Source Code for Module _Framework.ModeSelectorComponent

  1  #Embedded file name: /Users/versonator/Hudson/live/Projects/AppLive/Resources/MIDI Remote Scripts/_Framework/ModeSelectorComponent.py 
  2  from ControlSurfaceComponent import ControlSurfaceComponent 
  3  from ButtonElement import ButtonElement 
  4  from MomentaryModeObserver import MomentaryModeObserver 
  5   
  6 -class ModeSelectorComponent(ControlSurfaceComponent): 
  7      """ Class for switching between modes, handle several functions with few controls """ 
  8   
  9 -    def __init__(self, *a, **k): 
 10          super(ModeSelectorComponent, self).__init__(*a, **k) 
 11          self._modes_buttons = [] 
 12          self._mode_toggle = None 
 13          self._mode_listeners = [] 
 14          self.__mode_index = -1 
 15          self._modes_observers = {} 
 16          self._modes_heap = [] 
 17   
 18 -    def _get_protected_mode_index(self): 
 19          return self.__mode_index 
 20   
 21 -    def _set_protected_mode_index(self, mode): 
 22          raise isinstance(mode, int) or AssertionError 
 23          self.__mode_index = mode 
 24          for listener in self._mode_listeners: 
 25              listener() 
 26   
 27      _mode_index = property(_get_protected_mode_index, _set_protected_mode_index) 
 28   
 29 -    def _get_public_mode_index(self): 
 30          return self.__mode_index 
 31   
 32 -    def _set_public_mode_index(self, mode): 
 33          raise False or AssertionError 
 34   
 35      mode_index = property(_get_public_mode_index, _set_public_mode_index) 
 36   
 37 -    def disconnect(self): 
 38          self._clean_heap() 
 39          if self._mode_toggle != None: 
 40              self._mode_toggle.remove_value_listener(self._toggle_value) 
 41              self._mode_toggle = None 
 42          self._modes_buttons = None 
 43          self._mode_listeners = None 
 44          super(ModeSelectorComponent, self).disconnect() 
 45   
 46 -    def on_enabled_changed(self): 
 47          self.update() 
 48   
 49 -    def set_mode_toggle(self, button): 
 50          if not (button == None or isinstance(button, ButtonElement)): 
 51              raise AssertionError 
 52              if self._mode_toggle != None: 
 53                  self._mode_toggle.remove_value_listener(self._toggle_value) 
 54              self._mode_toggle = button 
 55              self._mode_toggle != None and self._mode_toggle.add_value_listener(self._toggle_value) 
 56          self.set_mode(0) 
 57   
 58 -    def set_mode_buttons(self, buttons): 
 59          raise buttons != None or AssertionError 
 60          raise isinstance(buttons, tuple) or AssertionError 
 61          raise len(buttons) - 1 in range(16) or AssertionError 
 62          for button in buttons: 
 63              raise isinstance(button, ButtonElement) or AssertionError 
 64              identify_sender = True 
 65              button.add_value_listener(self._mode_value, identify_sender) 
 66              self._modes_buttons.append(button) 
 67   
 68          self.set_mode(0) 
 69   
 70 -    def set_mode(self, mode): 
 71          self._clean_heap() 
 72          self._modes_heap = [(mode, None, None)] 
 73          if self._mode_index != mode: 
 74              self._update_mode() 
 75   
 76 -    def _update_mode(self): 
 77          mode = self._modes_heap[-1][0] 
 78          if not mode in range(self.number_of_modes()): 
 79              raise AssertionError 
 80              self._mode_index = self._mode_index != mode and mode 
 81              self.update() 
 82   
 83 -    def _clean_heap(self): 
 84          for _, _, observer in self._modes_heap: 
 85              if observer != None: 
 86                  observer.disconnect() 
 87   
 88          self._modes_heap = [] 
 89   
 90 -    def number_of_modes(self): 
 91          raise NotImplementedError 
 92   
 93 -    def mode_index_has_listener(self, listener): 
 94          return listener in self._mode_listeners 
 95   
 96 -    def add_mode_index_listener(self, listener): 
 97          raise listener not in self._mode_listeners or AssertionError 
 98          self._mode_listeners.append(listener) 
 99   
100 -    def remove_mode_index_listener(self, listener): 
101          raise listener in self._mode_listeners or AssertionError 
102          self._mode_listeners.remove(listener) 
103   
104 -    def update(self): 
105          raise NotImplementedError 
106   
107 -    def _mode_value(self, value, sender): 
108          raise len(self._modes_buttons) > 0 or AssertionError 
109          raise isinstance(value, int) or AssertionError 
110          raise sender in self._modes_buttons or AssertionError 
111          new_mode = self._modes_buttons.index(sender) 
112          if sender.is_momentary(): 
113              if value > 0: 
114                  mode_observer = MomentaryModeObserver() 
115                  mode_observer.set_mode_details(new_mode, self._controls_for_mode(new_mode), self._get_public_mode_index) 
116                  self._modes_heap.append((new_mode, sender, mode_observer)) 
117                  self._update_mode() 
118              elif self._modes_heap[-1][1] == sender and not self._modes_heap[-1][2].is_mode_momentary(): 
119                  self.set_mode(new_mode) 
120              else: 
121                  for mode, button, observer in self._modes_heap: 
122                      if button == sender: 
123                          self._modes_heap.remove((mode, button, observer)) 
124                          break 
125   
126                  self._update_mode() 
127          else: 
128              self.set_mode(new_mode) 
129   
130 -    def _toggle_value(self, value): 
131          if not self._mode_toggle != None: 
132              raise AssertionError 
133              raise isinstance(value, int) or AssertionError 
134              (value is not 0 or not self._mode_toggle.is_momentary()) and self.set_mode((self._mode_index + 1) % self.number_of_modes()) 
135   
136 -    def _controls_for_mode(self, mode): 
137          return None 
138   
139 -    def _on_timer(self): 
140          for _, _, mode_observer in self._modes_heap: 
141              if mode_observer != None: 
142                  mode_observer.on_timer() 
143