Source Code for Module _Framework.CompoundElement

  1  #Embedded file name: /Users/versonator/Hudson/live/Projects/AppLive/Resources/MIDI Remote Scripts/_Framework/CompoundElement.py 
  2  from __future__ import with_statement 
  3  from SubjectSlot import subject_slot_group, SlotManager 
  4  from NotifyingControlElement import NotifyingControlElement 
  5  from Util import BooleanContext 
  6   
  7 -class CompoundElement(NotifyingControlElement, SlotManager): 
  8      """ 
  9      Utility class that helps in writing Elements that act as a facade 
 10      to nested elements, hiding the complexity oif making sure that 
 11      resource ownership rules are preserved. 
 12      """ 
 13   
 14 -    def __init__(self, *a, **k): 
 15          super(CompoundElement, self).__init__(*a, **k) 
 16          self._nested_control_elements = dict() 
 17          self._disable_notify_owner_on_button_ownership_change = BooleanContext() 
 18          self._listen_nested_requests = 0 
 19   
 20 -    def on_nested_control_element_grabbed(self, control): 
 21          """ 
 22          Notifies that the nested control can be used by the compound 
 23          """ 
 24          raise NotImplementedError 
 25   
 26 -    def on_nested_control_element_released(self, control): 
 27          """ 
 28          Notifies that we lost control over the control. 
 29          """ 
 30          raise NotImplementedError 
 31   
 32 -    def on_nested_control_element_value(self, control, value): 
 33          """ 
 34          Notifies that an owned control element has received a value. 
 35          """ 
 36          raise NotImplementedError 
 37   
 38 -    def register_control_elements(self, *elements): 
 39          return map(self.register_control_element, elements) 
 40   
 41 -    def register_control_element(self, element): 
 42          if not element not in self._nested_control_elements: 
 43              raise AssertionError 
 44              self._nested_control_elements[element] = False 
 45              if self._listen_nested_requests > 0: 
 46                  self._on_nested_control_element_value.add_subject(element) 
 47              priority = self._has_resource and self.resource.owner and self.resource.max_priority 
 48              element.resource.grab(self, priority=priority) 
 49          else: 
 50              self._on_nested_control_element_grabbed(element) 
 51          return element 
 52   
 53 -    def unregister_control_elements(self, *elements): 
 54          return map(self.unregister_control_element, elements) 
 55   
 56 -    def unregister_control_element(self, element): 
 57          if not element in self._nested_control_elements: 
 58              raise AssertionError 
 59              if self._has_resource and self.resource.owner: 
 60                  element.resource.release(self) 
 61              else: 
 62                  self._on_nested_control_element_released(element) 
 63              self._listen_nested_requests > 0 and self._on_nested_control_element_value.remove_subject(element) 
 64          del self._nested_control_elements[element] 
 65          return element 
 66   
 67 -    def has_control_element(self, control): 
 68          return control in self._nested_control_elements 
 69   
 70 -    def owns_control_element(self, control): 
 71          return self._nested_control_elements.get(control, False) 
 72   
 73 -    def reset(self): 
 74          for element, owned in self._nested_control_elements.iteritems(): 
 75              if owned: 
 76                  element.reset() 
 77   
 78 -    def add_value_listener(self, *a, **k): 
 79          if self.value_listener_count() == 0: 
 80              self.request_listen_nested_control_elements() 
 81          super(CompoundElement, self).add_value_listener(*a, **k) 
 82   
 83 -    def remove_value_listener(self, *a, **k): 
 84          super(CompoundElement, self).remove_value_listener(*a, **k) 
 85          if self.value_listener_count() == 0: 
 86              self.unrequest_listen_nested_control_elements() 
 87   
 88 -    def request_listen_nested_control_elements(self): 
 89          """ 
 90          By default, the compound control element will listen to its 
 91          nested control elements IFF he himself has listeners.  This is 
 92          important, because for nested InputControlElements, the 
 93          existence of listeners determine wether they will send the 
 94          MIDI messages to Live or to the script. 
 95           
 96          You can force the compound to listen to its nested elements 
 97          using this methods.  The compound will then listen to them IFF 
 98          the number of requests is greater than the number of 
 99          unrequests OR it has listeners. 
100          """ 
101          if self._listen_nested_requests == 0: 
102              self._connect_nested_control_elements() 
103          self._listen_nested_requests += 1 
104   
105 -    def unrequest_listen_nested_control_elements(self): 
106          """ 
107          See request_listen_nested_control_elements() 
108          """ 
109          if self._listen_nested_requests == 1: 
110              self._disconnect_nested_control_elements() 
111          self._listen_nested_requests -= 1 
112   
113 -    def _connect_nested_control_elements(self): 
114          self._on_nested_control_element_value.replace_subjects(self._nested_control_elements.keys()) 
115   
116 -    def _disconnect_nested_control_elements(self): 
117          self._on_nested_control_element_value.replace_subjects([]) 
118   
119 -    def _on_nested_control_element_grabbed(self, control): 
120          if not control in self._nested_control_elements: 
121              raise AssertionError 
122              self._nested_control_elements[control] = self._nested_control_elements[control] or True 
123              self.on_nested_control_element_grabbed(control) 
124   
125 -    def _on_nested_control_element_released(self, control): 
126          if not control in self._nested_control_elements: 
127              raise AssertionError 
128              self._nested_control_elements[control] = self._nested_control_elements[control] and False 
129              self.on_nested_control_element_released(control) 
130   
131      @subject_slot_group('value') 
132 -    def _on_nested_control_element_value(self, value, sender): 
133          if self.owns_control_element(sender): 
134              self.on_nested_control_element_value(value, sender) 
135   
136 -    def set_control_element(self, control, grabbed): 
137          if grabbed or self._resource.stack_size == 0: 
138              self._on_nested_control_element_grabbed(control) 
139          else: 
140              self._on_nested_control_element_released(control) 
141          owner = self._resource.owner 
142          if owner and not self._disable_notify_owner_on_button_ownership_change: 
143              owner.set_control_element(self, True) 
144   
145 -    def _on_grab_resource(self, client, *a, **k): 
146          with self._disable_notify_owner_on_button_ownership_change(): 
147              for element in self._nested_control_elements: 
148                  self._on_nested_control_element_released(element) 
149                  element.resource.grab(self, priority=self.resource.max_priority, *a, **k) 
150   
151              super(CompoundElement, self)._on_grab_resource(client, *a, **k) 
152   
153 -    def _on_release_resource(self, client): 
154          with self._disable_notify_owner_on_button_ownership_change(): 
155              super(CompoundElement, self)._on_release_resource(client) 
156              for element in self._nested_control_elements: 
157                  element.resource.release(self) 
158                  self._on_nested_control_element_grabbed(element) 
159