Source Code for Module _Framework.SessionZoomingComponent

  1  #Embedded file name: /Users/versonator/Hudson/live/Projects/AppLive/Resources/MIDI Remote Scripts/_Framework/SessionZoomingComponent.py 
  2  from SubjectSlot import subject_slot 
  3  from CompoundComponent import CompoundComponent 
  4  from ScrollComponent import ScrollComponent 
  5  from Util import in_range 
  6   
  7 -class SessionZoomingComponent(CompoundComponent): 
  8      """ 
  9      Class using a matrix of buttons to choose blocks of clips in the 
 10      session, as if you had zoomed out from session. 
 11      """ 
 12   
 13 -    def __init__(self, session = None, *a, **k): 
 14          super(SessionZoomingComponent, self).__init__(*a, **k) 
 15          raise session or AssertionError 
 16          self._buttons = None 
 17          self._zoom_button = None 
 18          self._scene_bank_buttons = None 
 19          self._scene_bank_button_slots = self.register_slot_manager() 
 20          self._scene_bank_index = 0 
 21          self._is_zoomed_out = False 
 22          self._empty_value = 0 
 23          self._stopped_value = 100 
 24          self._playing_value = 127 
 25          self._selected_value = 64 
 26          self._session, self._vertical_scroll, self._horizontal_scroll = self.register_components(session, ScrollComponent(), ScrollComponent()) 
 27          self._vertical_scroll.can_scroll_up = self._can_scroll_up 
 28          self._vertical_scroll.can_scroll_down = self._can_scroll_down 
 29          self._vertical_scroll.scroll_up = self._scroll_up 
 30          self._vertical_scroll.scroll_down = self._scroll_down 
 31          self._horizontal_scroll.can_scroll_up = self._can_scroll_left 
 32          self._horizontal_scroll.can_scroll_down = self._can_scroll_right 
 33          self._horizontal_scroll.scroll_up = self._scroll_left 
 34          self._horizontal_scroll.scroll_down = self._scroll_right 
 35          self.register_slot(self._session, self._on_session_offset_changes, 'offset') 
 36   
 37 -    def on_scene_list_changed(self): 
 38          self.update() 
 39   
 40 -    def on_enabled_changed(self): 
 41          super(SessionZoomingComponent, self).on_enabled_changed() 
 42          self._session.set_show_highlight(self.is_enabled()) 
 43   
 44 -    def set_button_matrix(self, buttons): 
 45          if buttons != self._buttons: 
 46              self._buttons = buttons 
 47              self._on_matrix_value.subject = self._buttons 
 48          self.update() 
 49   
 50 -    def set_zoom_button(self, button): 
 51          if button != self._zoom_button: 
 52              self._zoom_button = button 
 53              self._on_zoom_value.subject = button 
 54              self._is_zoomed_out = False 
 55              self.update() 
 56   
 57 -    def set_nav_buttons(self, up, down, left, right): 
 58          self.set_nav_up_button(up) 
 59          self.set_nav_down_button(down) 
 60          self.set_nav_left_button(left) 
 61          self.set_nav_right_button(right) 
 62          self.update() 
 63   
 64 -    def set_nav_up_button(self, button): 
 65          self._vertical_scroll.set_scroll_up_button(button) 
 66   
 67 -    def set_nav_down_button(self, button): 
 68          self._vertical_scroll.set_scroll_down_button(button) 
 69   
 70 -    def set_nav_left_button(self, button): 
 71          self._horizontal_scroll.set_scroll_up_button(button) 
 72   
 73 -    def set_nav_right_button(self, button): 
 74          self._horizontal_scroll.set_scroll_down_button(button) 
 75   
 76 -    def set_scene_bank_buttons(self, buttons): 
 77          if self._scene_bank_buttons != buttons: 
 78              self._scene_bank_button_slots.disconnect() 
 79              self._scene_bank_buttons = buttons 
 80              if self._scene_bank_buttons != None: 
 81                  for button in self._scene_bank_buttons: 
 82                      self._scene_bank_button_slots.register_slot(button, self._on_scene_bank_value, 'value', extra_kws=dict(identify_sender=True)) 
 83   
 84              self.update() 
 85   
 86 -    def set_empty_value(self, value): 
 87          value = int(value) 
 88          raise in_range(value, 0, 128) or AssertionError 
 89          self._empty_value = value 
 90   
 91 -    def set_playing_value(self, value): 
 92          value = int(value) 
 93          raise in_range(value, 0, 128) or AssertionError 
 94          self._playing_value = value 
 95   
 96 -    def set_stopped_value(self, value): 
 97          value = int(value) 
 98          raise in_range(value, 0, 128) or AssertionError 
 99          self._stopped_value = value 
100   
101 -    def set_selected_value(self, value): 
102          value = int(value) 
103          raise in_range(value, 0, 128) or AssertionError 
104          self._selected_value = value 
105   
106 -    def _session_set_enabled(self, is_enabled): 
107          """ 
108          Override to customize behaviour when session is disabled. 
109          """ 
110          self._session.set_enabled(is_enabled) 
111   
112 -    def update(self): 
113          if self._allow_updates: 
114              self._session_set_enabled(not self._is_zoomed_out) 
115              if self.is_enabled(): 
116                  if self._is_zoomed_out and self._buttons != None: 
117                      tracks = self._session.tracks_to_use() 
118                      scenes = self.song().scenes 
119                      slots_registry = [ None for index in range(len(scenes)) ] 
120                      width = self._session.width() 
121                      height = self._session.height() 
122                      for x in range(self._buttons.width()): 
123                          for y in range(self._buttons.height()): 
124                              value_to_send = self._empty_value 
125                              scene_bank_offset = self._scene_bank_index * self._buttons.height() * height 
126                              track_offset = x * width 
127                              scene_offset = y * height + scene_bank_offset 
128                              if track_offset in range(len(tracks)) and scene_offset in range(len(scenes)): 
129                                  value_to_send = self._stopped_value 
130                                  if self._session.track_offset() in range(width * (x - 1) + 1, width * (x + 1)) and self._session.scene_offset() - scene_bank_offset in range(height * (y - 1) + 1, height * (y + 1)): 
131                                      value_to_send = self._selected_value 
132                                  else: 
133                                      playing = False 
134                                      for track in range(track_offset, track_offset + width): 
135                                          for scene in range(scene_offset, scene_offset + height): 
136                                              if track in range(len(tracks)) and scene in range(len(scenes)): 
137                                                  if slots_registry[scene] == None: 
138                                                      slots_registry[scene] = scenes[scene].clip_slots 
139                                                  slot = slots_registry[scene][track] if len(slots_registry[scene]) > track else None 
140                                                  if slot != None and slot.has_clip and slot.clip.is_playing: 
141                                                      value_to_send = self._playing_value 
142                                                      playing = True 
143                                                      break 
144   
145                                          if playing: 
146                                              break 
147   
148                              self._buttons.send_value(x, y, value_to_send) 
149   
150                  if self._scene_bank_buttons != None: 
151                      for index in range(len(self._scene_bank_buttons)): 
152                          if self._is_zoomed_out and index == self._scene_bank_index: 
153                              self._scene_bank_buttons[index].turn_on() 
154                          else: 
155                              self._scene_bank_buttons[index].turn_off() 
156   
157          else: 
158              self._update_requests += 1 
159   
160 -    def _on_session_offset_changes(self): 
161          if self._is_zoomed_out: 
162              self._scene_bank_index = int(self._session.scene_offset() / self._session.height() / self._buttons.height()) 
163          self.update() 
164   
165      @subject_slot('value') 
166 -    def _on_zoom_value(self, value): 
167          if self.is_enabled(): 
168              if self._zoom_button.is_momentary(): 
169                  self._is_zoomed_out = value > 0 
170              else: 
171                  self._is_zoomed_out = not self._is_zoomed_out 
172              if self._is_zoomed_out and self._buttons: 
173                  self._scene_bank_index = int(self._session.scene_offset() / self._session.height() / self._buttons.height()) 
174              else: 
175                  self._scene_bank_index = 0 
176              self._session_set_enabled(not self._is_zoomed_out) 
177              self.update() 
178   
179      @subject_slot('value') 
180 -    def _on_matrix_value(self, value, x, y, is_momentary): 
181          if self.is_enabled() and self._is_zoomed_out: 
182              if value != 0 or not is_momentary: 
183                  track_offset = x * self._session.width() 
184                  scene_offset = (y + self._scene_bank_index * self._buttons.height()) * self._session.height() 
185                  if track_offset in range(len(self._session.tracks_to_use())) and scene_offset in range(len(self.song().scenes)): 
186                      self._session.set_offsets(track_offset, scene_offset) 
187   
188 -    def _on_scene_bank_value(self, value, sender): 
189          if self.is_enabled() and self._is_zoomed_out: 
190              if value != 0 or not sender.is_momentary(): 
191                  button_offset = list(self._scene_bank_buttons).index(sender) 
192                  scene_offset = button_offset * self._buttons.height() * self._session.height() 
193                  if scene_offset in range(len(self.song().scenes)): 
194                      self._scene_bank_index = button_offset 
195                      self.update() 
196   
197 -    def _can_scroll_up(self): 
198          return self._session._can_bank_up() 
199   
200 -    def _can_scroll_down(self): 
201          return self._session._can_bank_down() 
202   
203 -    def _can_scroll_left(self): 
204          return self._session._can_bank_left() 
205   
206 -    def _can_scroll_right(self): 
207          return self._session._can_bank_right() 
208   
209 -    def _scroll_up(self): 
210          if self._is_zoomed_out: 
211              height = self._session.height() 
212              track_offset = self._session.track_offset() 
213              scene_offset = self._session.scene_offset() 
214              if scene_offset > 0: 
215                  new_scene_offset = scene_offset 
216                  if scene_offset % height > 0: 
217                      new_scene_offset -= scene_offset % height 
218                  else: 
219                      new_scene_offset = max(0, scene_offset - height) 
220                  self._session.set_offsets(track_offset, new_scene_offset) 
221   
222 -    def _scroll_down(self): 
223          if self._is_zoomed_out: 
224              height = self._session.height() 
225              track_offset = self._session.track_offset() 
226              scene_offset = self._session.scene_offset() 
227              new_scene_offset = scene_offset + height - scene_offset % height 
228              self._session.set_offsets(track_offset, new_scene_offset) 
229   
230 -    def _scroll_left(self): 
231          if self._is_zoomed_out: 
232              width = self._session.width() 
233              track_offset = self._session.track_offset() 
234              scene_offset = self._session.scene_offset() 
235              if track_offset > 0: 
236                  new_track_offset = track_offset 
237                  if track_offset % width > 0: 
238                      new_track_offset -= track_offset % width 
239                  else: 
240                      new_track_offset = max(0, track_offset - width) 
241                  self._session.set_offsets(new_track_offset, scene_offset) 
242   
243 -    def _scroll_right(self): 
244          if self._is_zoomed_out: 
245              width = self._session.width() 
246              track_offset = self._session.track_offset() 
247              scene_offset = self._session.scene_offset() 
248              new_track_offset = track_offset + width - track_offset % width 
249              self._session.set_offsets(new_track_offset, scene_offset) 
250