music_sampler/key.py

   1 from kivy.uix.widget import Widget
   2 from kivy.properties import AliasProperty, BooleanProperty, \
   3                             ListProperty, StringProperty
   4 from kivy.uix.behaviors import ButtonBehavior
   5
   6 from .action import Action
   7 from .helpers import debug_print
   8 import time
   9 import threading
  10 from transitions.extensions import HierarchicalMachine as Machine
  11
  12 class KeyMachine(Widget):
  13     STATES = [
  14         'initial',
  15         'configuring',
  16         'configured',
  17         'loading',
  18         'failed',
  19         {
  20             'name': 'loaded',
  21             'children': [
  22                 'no_config',
  23                 'no_actions',
  24                 'running',
  25                 'protecting_repeat'
  26             ]
  27         }
  28     ]
  29
  30     TRANSITIONS = [
  31         {
  32             'trigger': 'configure',
  33             'source': 'initial',
  34             'dest': 'configuring'
  35         },
  36         {
  37             'trigger': 'fail',
  38             'source': 'configuring',
  39             'dest': 'failed',
  40             'after': 'key_loaded_callback'
  41         },
  42         {
  43             'trigger': 'success',
  44             'source': 'configuring',
  45             'dest': 'configured',
  46             'after': 'load'
  47         },
  48         {
  49             'trigger': 'no_config',
  50             'source': 'configuring',
  51             'dest': 'loaded_no_config',
  52             'after': 'key_loaded_callback'
  53         },
  54         {
  55             'trigger': 'load',
  56             'source': 'configured',
  57             'dest': 'loading'
  58         },
  59         {
  60             'trigger': 'fail',
  61             'source': 'loading',
  62             'dest': 'failed',
  63             'after': 'key_loaded_callback'
  64         },
  65         {
  66             'trigger': 'success',
  67             'source': 'loading',
  68             'dest': 'loaded',
  69             'after': 'key_loaded_callback'
  70         },
  71         {
  72             'trigger': 'no_actions',
  73             'source': 'loading',
  74             'dest': 'loaded_no_actions',
  75             'after': 'key_loaded_callback'
  76         },
  77         {
  78             'trigger': 'reload',
  79             'source': ['loaded','failed'],
  80             'dest': 'configuring',
  81             'after': 'key_loaded_callback'
  82         },
  83         {
  84             'trigger': 'run',
  85             'source': 'loaded',
  86             'dest': 'loaded_running',
  87             'after': ['run_actions', 'finish'],
  88             # if a child, like loaded_no_actions, has no transitions, then it
  89             # is bubbled to the parent, and we don't want that.
  90             'conditions': ['is_loaded']
  91         },
  92         {
  93             'trigger': 'finish',
  94             'source': 'loaded_running',
  95             'dest': 'loaded_protecting_repeat'
  96         },
  97         {
  98             'trigger': 'repeat_protection_finished',
  99             'source': 'loaded_protecting_repeat',
 100             'dest': 'loaded'
 101         },
 102     ]
 103
 104     state = StringProperty("")
 105
 106     def __init__(self, key, **kwargs):
 107         self.key = key
 108
 109         Machine(model=self, states=self.STATES,
 110                 transitions=self.TRANSITIONS, initial='initial',
 111                 ignore_invalid_triggers=True, queued=True)
 112         super(KeyMachine, self).__init__(**kwargs)
 113
 114     # Machine states / events
 115     def is_loaded_or_failed(self):
 116         return self.is_loaded(allow_substates=True) or self.is_failed()
 117
 118     def is_loaded_inactive(self):
 119         return self.is_loaded_no_config() or self.is_loaded_no_actions()
 120
 121     def on_enter_configuring(self):
 122         self.destroy_actions()
 123         self.key.unset_description()
 124         self.key.unset_color()
 125
 126         if self.key.key_sym in self.key.parent.key_config:
 127             self.key.config = self.key.parent.key_config[self.key.key_sym]
 128
 129             for key_action in self.key.config['actions']:
 130                 self.key.add_action(key_action[0], **key_action[1])
 131
 132             if 'description' in self.key.config['properties']:
 133                 self.key.set_description(self.key.config['properties']['description'])
 134             if 'color' in self.key.config['properties']:
 135                 self.key.set_color(self.key.config['properties']['color'])
 136             self.success()
 137         else:
 138             self.no_config()
 139
 140     def on_enter_loading(self):
 141         if len(self.key.actions) > 0:
 142             for action in self.key.actions:
 143                 action.load()
 144         else:
 145             self.no_actions()
 146
 147     def destroy_actions(self):
 148         for action in self.key.actions:
 149             action.destroy()
 150         self.key.actions = []
 151
 152     def run_actions(self, modifiers):
 153         self.key.parent.parent.ids['KeyList'].append(self.key.key_sym)
 154         debug_print("running actions for {}".format(self.key.key_sym))
 155         start_time = time.time()
 156         self.key.parent.start_running(self.key, start_time)
 157         for self.key.current_action in self.key.actions:
 158             if self.key.parent.keep_running(self.key, start_time):
 159                 self.key.list_actions()
 160                 self.key.current_action.run(start_time)
 161         self.key.list_actions(last_action_finished=True)
 162
 163         self.key.parent.finished_running(self.key, start_time)
 164
 165     def on_enter_loaded_protecting_repeat(self, modifiers):
 166         if self.key.repeat_delay > 0:
 167             self.key.protecting_repeat_timer = threading.Timer(
 168                     self.key.repeat_delay,
 169                     self.key.repeat_protection_finished)
 170             self.key.protecting_repeat_timer.start()
 171         else:
 172             self.key.repeat_protection_finished()
 173
 174     # Callbacks
 175     def key_loaded_callback(self):
 176         self.key.parent.key_loaded_callback()
 177
 178
 179 class Key(ButtonBehavior, Widget):
 180
 181     key_sym = StringProperty(None)
 182     custom_color = ListProperty([0, 1, 0])
 183     description_title = StringProperty("")
 184     description = ListProperty([])
 185     machine_state = StringProperty("")
 186
 187     def get_alias_line_cross_color(self):
 188         if not self.is_failed() and (
 189                 not self.is_loaded(allow_substates=True)\
 190                 or self.is_loaded_running()\
 191                 or self.is_loaded_protecting_repeat()):
 192             return [120/255, 120/255, 120/255, 1]
 193         else:
 194             return [0, 0, 0, 0]
 195
 196     def set_alias_line_cross_color(self):
 197         pass
 198
 199     line_cross_color = AliasProperty(
 200             get_alias_line_cross_color,
 201             set_alias_line_cross_color,
 202             bind=['machine_state'])
 203
 204     def get_alias_line_color(self):
 205         if self.is_loaded_running():
 206             return [0, 0, 0, 1]
 207         else:
 208             return [120/255, 120/255, 120/255, 1]
 209
 210     def set_alias_line_color(self):
 211         pass
 212
 213     line_color = AliasProperty(get_alias_line_color, set_alias_line_color,
 214             bind=['machine_state'])
 215
 216     def get_alias_color(self):
 217         if self.is_loaded_inactive():
 218             return [1, 1, 1, 1]
 219         elif self.is_loaded_protecting_repeat():
 220             return [*self.custom_color, 100/255]
 221         elif self.is_loaded_running():
 222             return [*self.custom_color, 100/255]
 223         elif self.is_loaded(allow_substates=True):
 224             return [*self.custom_color, 1]
 225         elif self.is_failed():
 226             return [0, 0, 0, 1]
 227         else:
 228             return [*self.custom_color, 100/255]
 229     def set_alias_color(self):
 230         pass
 231
 232     color = AliasProperty(get_alias_color, set_alias_color,
 233             bind=['machine_state', 'custom_color'])
 234
 235     def __getattr__(self, name):
 236         if hasattr(self.machine, name):
 237             return getattr(self.machine, name)
 238         else:
 239             raise AttributeError
 240
 241     def machine_state_changed(self, instance, machine_state):
 242         self.machine_state = self.machine.state
 243
 244     def __init__(self, **kwargs):
 245         self.actions = []
 246         self.current_action = None
 247         self.machine = KeyMachine(self)
 248         self.machine.bind(state=self.machine_state_changed)
 249
 250         super(Key, self).__init__(**kwargs)
 251
 252     # Kivy events
 253     def on_key_sym(self, key, key_sym):
 254         if key_sym != "":
 255             self.configure()
 256
 257     def on_press(self):
 258         self.list_actions()
 259
 260     # This one cannot be in the Machine state since it would be queued to run
 261     # *after* the loop is ended...
 262     def interrupt(self):
 263         self.current_action.interrupt()
 264
 265     # Callbacks
 266     def callback_action_ready(self, action, success):
 267         if not success:
 268             self.fail()
 269         elif all(action.is_loaded_or_failed() for action in self.actions):
 270             self.success()
 271
 272     # Setters
 273     def set_description(self, description):
 274         if description[0] is not None:
 275             self.description_title = str(description[0])
 276         self.description = []
 277         for desc in description[1 :]:
 278             if desc is None:
 279                 self.description.append("")
 280             else:
 281                 self.description.append(str(desc).replace(" ", " "))
 282
 283     def unset_description(self):
 284         self.description_title = ""
 285         self.description = []
 286
 287     def set_color(self, color):
 288         color = [x / 255 for x in color]
 289         self.custom_color = color
 290
 291     def unset_color(self):
 292         self.custom_color = [0, 1, 0]
 293
 294     # Helpers
 295     @property
 296     def repeat_delay(self):
 297          if hasattr(self, 'config') and\
 298                  'repeat_delay' in self.config['properties']:
 299              return self.config['properties']['repeat_delay']
 300          else:
 301              return 0
 302
 303     # Actions handling
 304     def add_action(self, action_name, **arguments):
 305         self.actions.append(Action(action_name, self, **arguments))
 306
 307     def list_actions(self, last_action_finished=False):
 308         not_running = (not self.is_loaded_running())
 309         current_action_seen = False
 310         action_descriptions = []
 311         for action in self.actions:
 312             if not_running:
 313                 state = "inactive"
 314             elif last_action_finished:
 315                 state = "done"
 316             elif current_action_seen:
 317                 state = "pending"
 318             elif action == self.current_action:
 319                 current_action_seen = True
 320                 state = "current"
 321             else:
 322                 state = "done"
 323             action_descriptions.append([action.description(), state])
 324         self.parent.parent.ids['ActionList'].update_list(
 325                 self,
 326                 action_descriptions)