def __init__(self, display_label=' ', display_seg_start=0, *a, **k): super(ValueDisplayComponentBase, self).__init__(*a, **k) self._label_data_source = DisplayDataSource(display_label) self._value_data_source = DisplayDataSource() self._graphic_data_source = DisplayDataSource() self._display_label = display_label self._display_seg_start = display_seg_start
class NoteSettingsComponent(NoteSettingsComponentBase): def __init__(self, *a, **k): super(NoteSettingsComponent, self).__init__(*a, **k) self._top_data_sources = [DisplayDataSource() for _ in xrange(8)] self._bottom_data_sources = [DisplayDataSource() for _ in xrange(8)] self._info_data_source = DisplayDataSource() self._create_display_sources() def _create_display_sources(self): self._top_data_sources = [DisplayDataSource() for _ in xrange(8 - len(self._settings))] + [ s.label_source for s in self._settings ] self._bottom_data_sources = [DisplayDataSource() for _ in xrange(8 - len(self._settings))] + [ s.value_source for s in self._settings ] def set_top_display_line(self, display): if self.is_enabled() and display: display.set_data_sources(self._top_data_sources) def set_bottom_display_line(self, display): if self.is_enabled() and display: display.set_data_sources(self._bottom_data_sources) def set_info_display_line(self, display): if self.is_enabled() and display: display.set_data_sources([self._info_data_source]) def set_clear_display_line(self, display): if self.is_enabled() and display: display.reset() def set_info_message(self, message): self._info_data_source.set_display_string(message.rjust(62))
def _create_display_sources(self): self._top_data_sources = [ DisplayDataSource() for _ in xrange(8 - len(self._settings)) ] + [s.label_source for s in self._settings] self._bottom_data_sources = [ DisplayDataSource() for _ in xrange(8 - len(self._settings)) ] + [s.value_source for s in self._settings]
class NoteSettingsComponent(NoteSettingsComponentBase): def __init__(self, *a, **k): super(NoteSettingsComponent, self).__init__(*a, **k) self._top_data_sources = [ DisplayDataSource() for _ in xrange(8) ] self._bottom_data_sources = [ DisplayDataSource() for _ in xrange(8) ] self._info_data_source = DisplayDataSource() self._create_display_sources() def _create_display_sources(self): self._top_data_sources = [ DisplayDataSource() for _ in xrange(8 - len(self._settings)) ] + [ s.label_source for s in self._settings ] self._bottom_data_sources = [ DisplayDataSource() for _ in xrange(8 - len(self._settings)) ] + [ s.value_source for s in self._settings ] def set_top_display_line(self, display): if self.is_enabled() and display: display.set_data_sources(self._top_data_sources) def set_bottom_display_line(self, display): if self.is_enabled() and display: display.set_data_sources(self._bottom_data_sources) def set_info_display_line(self, display): if self.is_enabled() and display: display.set_data_sources([self._info_data_source]) def set_clear_display_line(self, display): if self.is_enabled() and display: display.reset() def set_info_message(self, message): self._info_data_source.set_display_string(message.rjust(62))
def __init__(self, display_label = ' ', display_seg_start = 0, *a, **k): super(ValueDisplayComponentBase, self).__init__(*a, **k) self._label_data_source = DisplayDataSource(display_label) self._value_data_source = DisplayDataSource() self._graphic_data_source = DisplayDataSource() self._display_label = display_label self._display_seg_start = display_seg_start
def __init__(self, *a, **k): super(UserSettingsComponent, self).__init__(*a, **k) self._name_sources = [DisplayDataSource() for _ in xrange(4)] self._value_sources = [DisplayDataSource() for _ in xrange(4)] self._info_source = DisplayDataSource() self._settings = [] self._encoders = []
def __init__(self, *a, **k): super(LoopSettingsComponent, self).__init__(*a, **k) self._name_sources = [DisplayDataSource() for _ in xrange(4)] self._value_sources = [DisplayDataSource() for _ in xrange(4)] self.__on_looping_changed.subject = self._loop_model self.__on_start_marker_changed.subject = self._loop_model self.__on_loop_start_changed.subject = self._loop_model self.__on_loop_end_changed.subject = self._loop_model
class UserSettingsComponent(Component): """ Component for changing a list of settings """ def __init__(self, *a, **k): super(UserSettingsComponent, self).__init__(*a, **k) self._name_sources = [DisplayDataSource() for _ in xrange(4)] self._value_sources = [DisplayDataSource() for _ in xrange(4)] self._info_source = DisplayDataSource() self._settings = [] self._encoders = [] def set_display_line1(self, display): if display: display.set_data_sources(self._value_sources) def set_display_line2(self, display): if display: display.set_data_sources(self._name_sources) def set_display_line3(self, display): if display: display.reset() def set_display_line4(self, display): if display: display.set_data_sources([self._info_source]) def set_encoders(self, encoders): self._encoders = encoders or [] self._on_encoder_value.replace_subjects(self._encoders[::2], count()) def _set_settings(self, settings): self._settings = settings.values() self._update_display() def _get_settings(self): return self._settings settings = property(_get_settings, _set_settings) def set_info_text(self, info_text): self._info_source.set_display_string(info_text) @listens_group('normalized_value') def _on_encoder_value(self, value, index): if index >= 0 and index < len( self._settings) and self._settings[index].change_relative( value): self._update_display() def _update_display(self): for index, setting in enumerate(self._settings): self._name_sources[index].set_display_string(setting.name) self._value_sources[index].set_display_string(str(setting)) def update(self): super(UserSettingsComponent, self).update() if self.is_enabled(): self._update_display()
def __init__(self, *a, **k): self._oled_display_track_name_data_source = DisplayDataSource() self._oled_display_volume_value_data_source = DisplayDataSource() self._track_name_or_volume_value_display = None self._drum_group_finder = None super(ChannelStripComponent, self).__init__(*a, **k) self.__on_selected_track_changed.subject = self.song.view self.__on_selected_track_changed() self._drum_group_finder = self.register_disconnectable(PercussionInstrumentFinder(device_parent=self.track))
def __init__(self, *a, **k): super(AudioClipSettingsComponent, self).__init__(*a, **k) self._name_sources = [DisplayDataSource() for _ in xrange(4)] self._value_sources = [DisplayDataSource() for _ in xrange(4)] self.__on_pitch_fine_changed.subject = self._audio_clip_model self.__on_pitch_coarse_changed.subject = self._audio_clip_model self.__on_gain_changed.subject = self._audio_clip_model self.__on_warping_changed.subject = self._audio_clip_model self.__on_warp_mode_changed.subject = self._audio_clip_model
class UserSettingsComponent(Component): """ Component for changing a list of settings """ def __init__(self, *a, **k): super(UserSettingsComponent, self).__init__(*a, **k) self._name_sources = [ DisplayDataSource() for _ in xrange(4) ] self._value_sources = [ DisplayDataSource() for _ in xrange(4) ] self._info_source = DisplayDataSource() self._settings = [] self._encoders = [] def set_display_line1(self, display): if display: display.set_data_sources(self._value_sources) def set_display_line2(self, display): if display: display.set_data_sources(self._name_sources) def set_display_line3(self, display): if display: display.reset() def set_display_line4(self, display): if display: display.set_data_sources([self._info_source]) def set_encoders(self, encoders): self._encoders = encoders or [] self._on_encoder_value.replace_subjects(self._encoders[::2], count()) def _set_settings(self, settings): self._settings = settings.values() self._update_display() def _get_settings(self): return self._settings settings = property(_get_settings, _set_settings) def set_info_text(self, info_text): self._info_source.set_display_string(info_text) @listens_group('normalized_value') def _on_encoder_value(self, value, index): if index >= 0 and index < len(self._settings) and self._settings[index].change_relative(value): self._update_display() def _update_display(self): for index, setting in enumerate(self._settings): self._name_sources[index].set_display_string(setting.name) self._value_sources[index].set_display_string(str(setting)) def update(self): super(UserSettingsComponent, self).update() if self.is_enabled(): self._update_display()
def __init__(self, parent, display_strings, value_strings, *a, **k): assert len(display_strings) == len(value_strings) super(ModDispayComponent, self).__init__(*a, **k) self.num_segments = len(display_strings) self._parent = parent self._name_display_line = None self._value_display_line = None self._name_data_sources = [ DisplayDataSource(string) for string in display_strings ] self._value_data_sources = [ DisplayDataSource(string) for string in value_strings ]
class InfoComponent(BackgroundComponent): def __init__(self, info_text='', *a, **k): (super(InfoComponent, self).__init__)(*a, **k) self._data_source = DisplayDataSource() self._data_source.set_display_string(info_text) def set_display(self, display): if display: display.set_data_sources([self._data_source])
class InfoComponent(BackgroundComponent): u""" Component that will show an info text and grab all components that should be unusable. """ def __init__(self, info_text=u'', *a, **k): super(InfoComponent, self).__init__(*a, **k) self._data_source = DisplayDataSource() self._data_source.set_display_string(info_text) def set_display(self, display): if display: display.set_data_sources([self._data_source])
class InfoComponent(BackgroundComponent): """ Component that will show an info text and grab all components that should be unusable. """ def __init__(self, info_text = '', *a, **k): super(InfoComponent, self).__init__(*a, **k) self._data_source = DisplayDataSource() self._data_source.set_display_string(info_text) def set_display(self, display): if display: display.set_data_sources([self._data_source])
def __init__(self, *a, **k): (super(SpecialChanStripComponent, self).__init__)(*a, **k) self.empty_color = 'Option.Unused' self._invert_mute_feedback = True self._duplicate_button = None self._selector_button = None self._delete_handler = None self._track_parameter_name_sources = [DisplayDataSource(' ') for _ in range(14)] self._track_parameter_data_sources = [DisplayDataSource(' ') for _ in range(14)] self._track_parameter_graphic_sources = [DisplayDataSource(' ') for _ in range(14)] self._on_return_tracks_changed.subject = self.song self._on_selected_track_changed.subject = self.song.view self._fold_task = self._tasks.add(task.sequence(task.wait(TRACK_FOLD_DELAY), task.run(self._do_fold_track))).kill() self._cue_volume_slot = self.register_disconnectable(ParameterSlot())
def __init__(self, num_options=8, num_labels=4, num_display_segments=None, *a, **k): super(OptionsComponent, self).__init__(*a, **k) num_display_segments = num_display_segments or num_options self._label_data_sources = [ DisplayDataSource() for _ in xrange(num_labels) ] self._data_sources = [ DisplayDataSource() for _ in xrange(num_display_segments) ] self._option_names = []
class NoteSetting(NoteSettingBase): def __init__(self, *a, **k): super(NoteSetting, self).__init__(*a, **k) self.value_source = DisplayDataSource() self.label_source = DisplayDataSource() self.label_source.set_display_string(self.get_label()) def get_label(self): raise NotImplementedError def attribute_min_max_to_string(self, min_value, max_value): raise NotImplementedError def set_min_max(self, min_max_value): self.value_source.set_display_string(self.attribute_min_max_to_string(min_max_value[0], min_max_value[1]) if min_max_value else '-')
def __init__(self, *a, **k): super(UserSettingsComponent, self).__init__(*a, **k) self._name_sources = [ DisplayDataSource() for _ in xrange(4) ] self._value_sources = [ DisplayDataSource() for _ in xrange(4) ] self._info_source = DisplayDataSource() self._settings = [] self._encoders = []
def __init__(self, *a, **k): super(ClipNameComponent, self).__init__(*a, **k) self._clip = None self._name_data_sources = [ DisplayDataSource() for _ in xrange(self.num_label_segments) ] self._name_data_sources[0].set_display_string('Clip Selection:')
def __init__(self, *a, **k): super(ScrollableListComponent, self).__init__(*a, **k) self._data_sources = [ DisplayDataSource() for _ in range(self.num_segments) ] self._selected_option = None self._offset_index = 0 self._option_names = [] self._select_buttons = [] self._select_button_slots = self.register_slot_manager() self.register_slot(self, self._set_selected_option, 'press_option')
class ValueDisplayComponentBase(Component): def __init__(self, display_label = u' ', display_seg_start = 0, *a, **k): super(ValueDisplayComponentBase, self).__init__(*a, **k) self._label_data_source = DisplayDataSource(display_label) self._value_data_source = DisplayDataSource() self._graphic_data_source = DisplayDataSource() self._display_label = display_label self._display_seg_start = display_seg_start def get_value_string(self): raise NotImplementedError def get_graphic_string(self): raise NotImplementedError @listenable_property def value_string(self): return self.get_value_string() def set_label_display(self, display): self._set_display(display, self._label_data_source) def set_value_display(self, display): self._set_display(display, self._value_data_source) def set_graphic_display(self, display): self._set_display(display, self._graphic_data_source) def _set_display(self, display, source): if display: display.set_data_sources((None,) * NUM_SEGMENTS) display.segment(self._display_seg_start).set_data_source(source) return None def update(self): super(ValueDisplayComponentBase, self).update() if self.is_enabled(): self._value_data_source.set_display_string(self.get_value_string()) self._graphic_data_source.set_display_string(self.get_graphic_string())
class ValueDisplayComponentBase(Component): def __init__(self, display_label = ' ', display_seg_start = 0, *a, **k): super(ValueDisplayComponentBase, self).__init__(*a, **k) self._label_data_source = DisplayDataSource(display_label) self._value_data_source = DisplayDataSource() self._graphic_data_source = DisplayDataSource() self._display_label = display_label self._display_seg_start = display_seg_start def get_value_string(self): raise NotImplementedError def get_graphic_string(self): raise NotImplementedError @listenable_property def value_string(self): return self.get_value_string() def set_label_display(self, display): self._set_display(display, self._label_data_source) def set_value_display(self, display): self._set_display(display, self._value_data_source) def set_graphic_display(self, display): self._set_display(display, self._graphic_data_source) def _set_display(self, display, source): if display: display.set_data_sources((None,) * NUM_SEGMENTS) display.segment(self._display_seg_start).set_data_source(source) def update(self): super(ValueDisplayComponentBase, self).update() if self.is_enabled(): self._value_data_source.set_display_string(self.get_value_string()) self._graphic_data_source.set_display_string(self.get_graphic_string())
def __init__(self, *a, **k): super(NoteSettingsComponent, self).__init__(*a, **k) self._top_data_sources = [DisplayDataSource() for _ in xrange(8)] self._bottom_data_sources = [DisplayDataSource() for _ in xrange(8)] self._info_data_source = DisplayDataSource() self._create_display_sources()
def __init__(self, info_text = '', *a, **k): super(InfoComponent, self).__init__(*a, **k) self._data_source = DisplayDataSource() self._data_source.set_display_string(info_text)
def device_name_data_source(self): if self._device_name_data_source == None: self._device_name_data_source = DisplayDataSource() self._on_device_name_changed() return self._device_name_data_source
class ChannelStripComponent(ChannelStripComponentBase): track_type_display = SendValueControl() track_selection_display = SendValueControl() track_mute_display = SendValueControl() track_solo_display = SendValueControl() track_muted_via_solo_display = SendValueControl() def __init__(self, *a, **k): super(ChannelStripComponent, self).__init__(*a, **k) self._track_volume_data_source = DisplayDataSource() self._track_panning_data_source = DisplayDataSource() self.__on_selected_track_changed.subject = self.song.view @property def track_volume_data_source(self): return self._track_volume_data_source @property def track_panning_data_source(self): return self._track_panning_data_source def set_track(self, track): super(ChannelStripComponent, self).set_track(track) track = track if liveobj_valid(track) else None mixer = track.mixer_device if track else None self.__on_muted_via_solo_changed.subject = track self.__on_volume_value_changed.subject = mixer.volume if mixer else None self.__on_panning_value_changed.subject = mixer.panning if mixer else None self._update_track_volume_data_source() self._update_track_panning_data_source() self._update_track_type_display() self.__on_muted_via_solo_changed() return def _on_mute_changed(self): super(ChannelStripComponent, self)._on_mute_changed() self.track_mute_display.value = int(self._track.mute) if liveobj_valid(self._track) and self._track != self.song.master_track else 0 def _on_solo_changed(self): super(ChannelStripComponent, self)._on_solo_changed() self.track_solo_display.value = int(self._track.solo) if liveobj_valid(self._track) and self._track != self.song.master_track else 0 @listens('selected_track') def __on_selected_track_changed(self): selected_track = self.song.view.selected_track self.track_selection_display.value = int(self._track == selected_track) if liveobj_valid(self._track) else 0 @listens('muted_via_solo') def __on_muted_via_solo_changed(self): self.track_muted_via_solo_display.value = int(self._track.muted_via_solo) if liveobj_valid(self._track) and self._track != self.song.master_track else 0 @listens('value') def __on_volume_value_changed(self): self._update_track_volume_data_source() @listens('value') def __on_panning_value_changed(self): self._update_track_panning_data_source() def _update_track_volume_data_source(self): volume_string = '' if liveobj_valid(self._track): volume_string = str(self._track.mixer_device.volume) found_string = ('').join(volume_pattern.findall(volume_string)) if found_string: volume_string = '%s dB' % round(float(found_string), 1) self._track_volume_data_source.set_display_string(volume_string) def _update_track_panning_data_source(self): pan_string = '' if liveobj_valid(self._track): pan_string = str(self._track.mixer_device.panning) self._track_panning_data_source.set_display_string(pan_string) def _update_track_type_display(self): value_to_send = EMPTY_TRACK_TYPE_VALUE if liveobj_valid(self._track): value_to_send = DEFAULT_TRACK_TYPE_VALUE if self._track == self.song.master_track: value_to_send = MASTER_TRACK_TYPE_VALUE self.track_type_display.value = value_to_send
class Live8DeviceComponent(ControlSurfaceComponent): __doc__ = ' Class representing a device in Live ' def __init__(self, *a, **k): super(Live8DeviceComponent, self).__init__(*a, **k) self._device_banks = DEVICE_DICT self._device_best_banks = DEVICE_BOB_DICT self._device_bank_names = BANK_NAME_DICT self._device = None self._parameter_controls = None self._bank_up_button = None self._bank_down_button = None self._bank_buttons = None self._on_off_button = None self._lock_button = None self._lock_callback = None self._device_name_data_source = None self._device_bank_registry = {} self._bank_index = 0 self._bank_name = '<No Bank>' self._locked_to_device = False return None def disconnect(self): self._lock_callback = None self._device_bank_registry = None if self._parameter_controls != None: for control in self._parameter_controls: control.release_parameter() self._parameter_controls = None if self._bank_up_button != None: self._bank_up_button.remove_value_listener(self._bank_up_value) self._bank_up_button = None if self._bank_down_button != None: self._bank_down_button.remove_value_listener(self._bank_down_value) self._bank_down_button = None if self._bank_buttons != None: for button in self._bank_buttons: button.remove_value_listener(self._bank_value) self._bank_buttons = None if self._on_off_button != None: if self._on_off_button.value_has_listener(self._on_off_value): self._on_off_button.remove_value_listener(self._on_off_value) self._on_off_button = None if self._lock_button != None: if self._lock_button.value_has_listener(self._lock_value): self._lock_button.remove_value_listener(self._lock_value) self._lock_button = None if self._device != None: parameter = self._on_off_parameter() if parameter != None: if parameter.value_has_listener(self._on_on_off_changed): parameter.remove_value_listener(self._on_on_off_changed) if self._device.name_has_listener(self._on_device_name_changed): self._device.remove_name_listener(self._on_device_name_changed) if self._device.parameters_has_listener( self._on_parameters_changed): self._device.remove_parameters_listener( self._on_parameters_changed) self._device = None return None def on_enabled_changed(self): self.update() def set_device(self, device): assert ((device == None) or isinstance(device, Live.Device.Device)) if ((not self._locked_to_device) and (device != self._device)): if (self._device != None): self._device.remove_name_listener(self._on_device_name_changed) self._device.remove_parameters_listener( self._on_parameters_changed) parameter = self._on_off_parameter() if (parameter != None): parameter.remove_value_listener(self._on_on_off_changed) if (self._parameter_controls != None): for control in self._parameter_controls: control.release_parameter() self._device = device if (self._device != None): self._bank_index = 0 self._device.add_name_listener(self._on_device_name_changed) self._device.add_parameters_listener( self._on_parameters_changed) parameter = self._on_off_parameter() if (parameter != None): parameter.add_value_listener(self._on_on_off_changed) for key in list(self._device_bank_registry.keys()): if (key == self._device): self._bank_index = self._device_bank_registry.get(key, 0) del self._device_bank_registry[key] break self._bank_name = '<No Bank>' #added self._on_device_name_changed() self.update() def set_bank_nav_buttons(self, down_button, up_button): assert ((down_button != None) or (up_button == None)) assert ((up_button == None) or isinstance(up_button, ButtonElement)) assert ((down_button == None) or isinstance(down_button, ButtonElement)) do_update = False if up_button != self._bank_up_button: do_update = True if self._bank_up_button != None: self._bank_up_button.remove_value_listener(self._bank_up_value) self._bank_up_button = up_button if self._bank_up_button != None: self._bank_up_button.add_value_listener(self._bank_up_value) if down_button != self._bank_down_button: do_update = True if self._bank_down_button != None: self._bank_down_button.remove_value_listener( self._bank_down_value) self._bank_down_button = down_button if self._bank_down_button != None: self._bank_down_button.add_value_listener( self._bank_down_value) if do_update: self.update() return None def set_bank_buttons(self, buttons): assert ((buttons == None) or isinstance(buttons, tuple)) if self._bank_buttons != None: for button in self._bank_buttons: button.remove_value_listener(self._bank_value) self._bank_buttons = buttons if self._bank_buttons != None: identify_sender = True for button in self._bank_buttons: button.add_value_listener(self._bank_value, identify_sender) self.update() return None def set_parameter_controls(self, controls): assert (controls != None) assert isinstance(controls, tuple) if self._device != None and self._parameter_controls != None: for control in self._parameter_controls: control.release_parameter() for control in controls: assert (control != None) assert isinstance(control, EncoderElement) self._parameter_controls = controls self.update() return None def set_lock_to_device(self, lock, device): assert isinstance(lock, type(False)) assert (lock is not self._locked_to_device) if lock: self.set_device(device) else: assert (device == self._device) self._locked_to_device = lock if self.is_enabled(): if (self._lock_button != None): if self._locked_to_device: self._lock_button.turn_on() else: self._lock_button.turn_off() def set_lock_button(self, button): assert ((button == None) or isinstance(button, ButtonElement)) if self._lock_button != None: self._lock_button.remove_value_listener(self._lock_value) self._lock_button = None self._lock_button = button if self._lock_button != None: self._lock_button.add_value_listener(self._lock_value) self.update() return None def set_on_off_button(self, button): assert ((button == None) or isinstance(button, ButtonElement)) if self._on_off_button != None: self._on_off_button.remove_value_listener(self._on_off_value) self._on_off_button = None self._on_off_button = button if self._on_off_button != None: self._on_off_button.add_value_listener(self._on_off_value) self.update() return None def set_lock_callback(self, callback): assert (self._lock_callback == None) assert (callback != None) assert (dir(callback).count('im_func') is 1) self._lock_callback = callback return None def restore_bank(self, bank_index): if self._device != None and self._is_banking_enabled( ) and self._locked_to_device and self._number_of_parameter_banks( ) > bank_index and self._bank_index != bank_index: self._bank_index = bank_index self.update() return None def device_name_data_source(self): if self._device_name_data_source == None: self._device_name_data_source = DisplayDataSource() self._on_device_name_changed() return self._device_name_data_source def update(self): if (self.is_enabled() and (self._device != None)): self._device_bank_registry[self._device] = self._bank_index if (self._parameter_controls != None): old_bank_name = self._bank_name #added self._assign_parameters() if self._bank_name != old_bank_name: #added try: self._show_msg_callback(self._device.name + ' Bank: ' + self._bank_name) #added except: pass if ((self._bank_up_button != None) and (self._bank_down_button != None)): if (self._number_of_parameter_banks()) > (self._bank_index + 1): self._bank_up_button.turn_on() else: self._bank_up_button.turn_off() if (self._bank_index > 0): self._bank_down_button.turn_on() else: self._bank_down_button.turn_off() if (self._bank_buttons != None): for index in range(len(self._bank_buttons)): if (index == self._bank_index): self._bank_buttons[index].turn_on() else: self._bank_buttons[index].turn_off() else: if (self._lock_button != None): self._lock_button.turn_off() if (self._bank_up_button != None): self._bank_up_button.turn_off() if (self._bank_down_button != None): self._bank_down_button.turn_off() if (self._bank_buttons != None): for button in self._bank_buttons: button.turn_off() if (self._parameter_controls != None): for control in self._parameter_controls: control.release_parameter() #self._rebuild_callback() def _bank_up_value(self, value): assert (self._bank_up_button != None) assert (value != None) assert isinstance(value, int) if self.is_enabled(): if ((not self._bank_up_button.is_momentary()) or (value is not 0)): if (self._device != None): num_banks = self._number_of_parameter_banks() if (self._bank_down_button == None): self._bank_name = '' self._bank_index = ((self._bank_index + 1) % num_banks) self.update() elif (num_banks > (self._bank_index + 1)): self._bank_name = '' self._bank_index += 1 self.update() def _bank_down_value(self, value): assert (self._bank_down_button != None) assert (value != None) assert isinstance(value, int) if self.is_enabled(): if ((not self._bank_down_button.is_momentary()) or (value is not 0)): if ((self._device != None) and (self._bank_index > 0)): self._bank_name = '' self._bank_index -= 1 self.update() def _lock_value(self, value): assert (self._lock_button != None) assert (self._lock_callback != None) assert (value != None) assert isinstance(value, int) if not self._lock_button.is_momentary() or value is not 0: self._lock_callback() return None def _on_off_value(self, value): assert (self._on_off_button != None) assert (value in range(128)) if not self._on_off_button.is_momentary() or value is not 0: parameter = self._on_off_parameter() if parameter != None and parameter.is_enabled: parameter.value = float(int(parameter.value == 0.0)) return None def _bank_value(self, value, button): assert (self._bank_buttons != None) assert (value != None) assert (button != None) assert isinstance(value, int) assert isinstance(button, ButtonElement) assert (list(self._bank_buttons).count(button) == 1) if self.is_enabled() and self._device != None: #added if ((not button.is_momentary()) or (value is not 0)): bank = list(self._bank_buttons).index(button) if (bank != self._bank_index): if (self._number_of_parameter_banks() > bank): self._bank_name = '' #added self._bank_index = bank self.update() else: try: self._show_msg_callback(self._device.name + ' Bank: ' + self._bank_name) except: pass def _is_banking_enabled(self): direct_banking = (self._bank_buttons != None) roundtrip_banking = (self._bank_up_button != None) increment_banking = ((self._bank_up_button != None) and (self._bank_down_button != None)) return (direct_banking or (roundtrip_banking or increment_banking)) def _assign_parameters(self): assert self.is_enabled() assert (self._device != None) assert (self._parameter_controls != None) self._bank_name = ('Bank ' + str(self._bank_index + 1)) #added if (self._device.class_name in list(self._device_banks.keys())): #modified assert (self._device.class_name in list(self._device_best_banks.keys())) banks = self._device_banks[self._device.class_name] bank = None #if (not self._is_banking_enabled()): # banks = self._device_best_banks[self._device.class_name] # self._bank_name = 'Best of Parameters' #added if (len(banks) > self._bank_index): bank = banks[self._bank_index] if self._is_banking_enabled(): #added if self._device.class_name in list( self._device_bank_names.keys()): #added self._bank_name = self._device_bank_names[ self._device.class_name] #added *recheck assert ((bank == None) or (len(bank) >= len(self._parameter_controls))) for index in range(len(self._parameter_controls)): parameter = None if (bank != None): parameter = get_parameter_by_name(self._device, bank[index]) if (parameter != None): self._parameter_controls[index].connect_to(parameter) else: self._parameter_controls[index].release_parameter() else: parameters = self._device_parameters_to_map() num_controls = len(self._parameter_controls) index = (self._bank_index * num_controls) for control in self._parameter_controls: if (index < len(parameters)): control.connect_to(parameters[index]) else: control.release_parameter() index += 1 def _on_device_name_changed(self): if (self._device_name_data_source != None): if (self.is_enabled() and (self._device != None)): self._device_name_data_source.set_display_string( self._device.name) else: self._device_name_data_source.set_display_string('No Device') def _on_parameters_changed(self): self.update() def _on_off_parameter(self): result = None if (self._device != None): for parameter in self._device.parameters: if str(parameter.name).startswith('Device On'): result = parameter break return result def _on_on_off_changed(self): if (self.is_enabled() and (self._on_off_button != None)): turn_on = False if (self._device != None): parameter = self._on_off_parameter() turn_on = ((parameter != None) and (parameter.value > 0.0)) if turn_on: self._on_off_button.turn_on() else: self._on_off_button.turn_off() def _device_parameters_to_map(self): assert self.is_enabled() assert (self._device != None) assert (self._parameter_controls != None) return self._device.parameters[1:] #check this... def _number_of_parameter_banks(self): return number_of_parameter_banks(self._device) #added
def __init__(self, info_text='', *a, **k): super(InfoComponent, self).__init__(*a, **k) self._data_source = DisplayDataSource() self._data_source.set_display_string(info_text)
class UserSettingsComponent(Component): def __init__(self, *a, **k): (super(UserSettingsComponent, self).__init__)(*a, **k) self._name_sources = [DisplayDataSource() for _ in range(4)] self._value_sources = [DisplayDataSource() for _ in range(4)] self._info_source = DisplayDataSource() self._settings = [] self._encoders = [] self._value_display = None self._name_display = None def set_display_line1(self, display): self._value_display = display if display: display.set_data_sources(self._value_sources) def set_display_line2(self, display): self._name_display = display if display: display.set_data_sources(self._name_sources) def set_display_line3(self, display): if display: display.reset() def set_display_line4(self, display): if display: display.set_data_sources([self._info_source]) def set_encoders(self, encoders): self._encoders = encoders or [] self._on_encoder_value.replace_subjects(self._encoders, count()) def _set_settings(self, settings): self._settings = list(settings.values()) self._update_display() def _get_settings(self): return self._settings settings = property(_get_settings, _set_settings) def set_info_text(self, info_text): self._info_source.set_display_string(info_text) @listens_group('normalized_value') def _on_encoder_value(self, value, index): num_encoders = len(self._encoders) setting_index = -1 if index % 2 == 0: setting_index = old_div(index, 2) elif index == num_encoders - 1: setting_index = old_div(num_encoders, 2) if 0 <= setting_index < len(self._settings): if self._settings[setting_index].change_relative(value): self._update_display() def _update_display(self): num_segments = len(self._name_sources) num_settings = len(self._settings) def setting_property(index, display, getter): value = getter( self._settings[index]) if (0 <= index < num_settings) else '' index += 1 if index == num_segments: if index < num_settings: separators = num_segments - 1 segment_length = old_div( display.width - separators, num_segments) if display else consts.DISPLAY_LENGTH value = combine_strings(value, getter(self._settings[index]), segment_length) return value for index in range(num_segments): self._name_sources[index].set_display_string( setting_property(index, self._name_display, lambda s: s.name)) self._value_sources[index].set_display_string( setting_property(index, self._value_display, lambda s: str(s))) def update(self): super(UserSettingsComponent, self).update() if self.is_enabled(): self._update_display()
class Live8DeviceComponent(ControlSurfaceComponent): __doc__ = ' Class representing a device in Live ' def __init__(self, *a, **k): super(Live8DeviceComponent, self).__init__(*a, **k) self._device_banks = DEVICE_DICT self._device_best_banks = DEVICE_BOB_DICT self._device_bank_names = BANK_NAME_DICT self._device = None self._parameter_controls = None self._bank_up_button = None self._bank_down_button = None self._bank_buttons = None self._on_off_button = None self._lock_button = None self._lock_callback = None self._device_name_data_source = None self._device_bank_registry = {} self._bank_index = 0 self._bank_name = '<No Bank>' self._locked_to_device = False return None def disconnect(self): self._lock_callback = None self._device_bank_registry = None if self._parameter_controls != None: for control in self._parameter_controls: control.release_parameter() self._parameter_controls = None if self._bank_up_button != None: self._bank_up_button.remove_value_listener(self._bank_up_value) self._bank_up_button = None if self._bank_down_button != None: self._bank_down_button.remove_value_listener(self._bank_down_value) self._bank_down_button = None if self._bank_buttons != None: for button in self._bank_buttons: button.remove_value_listener(self._bank_value) self._bank_buttons = None if self._on_off_button != None: if self._on_off_button.value_has_listener(self._on_off_value): self._on_off_button.remove_value_listener(self._on_off_value) self._on_off_button = None if self._lock_button != None: if self._lock_button.value_has_listener(self._lock_value): self._lock_button.remove_value_listener(self._lock_value) self._lock_button = None if self._device != None: parameter = self._on_off_parameter() if parameter != None: if parameter.value_has_listener(self._on_on_off_changed): parameter.remove_value_listener(self._on_on_off_changed) if self._device.name_has_listener(self._on_device_name_changed): self._device.remove_name_listener(self._on_device_name_changed) if self._device.parameters_has_listener(self._on_parameters_changed): self._device.remove_parameters_listener(self._on_parameters_changed) self._device = None return None def on_enabled_changed(self): self.update() def set_device(self, device): assert ((device == None) or isinstance(device, Live.Device.Device)) if ((not self._locked_to_device) and (device != self._device)): if (self._device != None): self._device.remove_name_listener(self._on_device_name_changed) self._device.remove_parameters_listener(self._on_parameters_changed) parameter = self._on_off_parameter() if (parameter != None): parameter.remove_value_listener(self._on_on_off_changed) if (self._parameter_controls != None): for control in self._parameter_controls: control.release_parameter() self._device = device if (self._device != None): self._bank_index = 0 self._device.add_name_listener(self._on_device_name_changed) self._device.add_parameters_listener(self._on_parameters_changed) parameter = self._on_off_parameter() if (parameter != None): parameter.add_value_listener(self._on_on_off_changed) for key in self._device_bank_registry.keys(): if (key == self._device): self._bank_index = self._device_bank_registry.get(key, 0) del self._device_bank_registry[key] break self._bank_name = '<No Bank>' #added self._on_device_name_changed() self.update() def set_bank_nav_buttons(self, down_button, up_button): assert ((down_button != None) or (up_button == None)) assert ((up_button == None) or isinstance(up_button, ButtonElement)) assert ((down_button == None) or isinstance(down_button, ButtonElement)) do_update = False if up_button != self._bank_up_button: do_update = True if self._bank_up_button != None: self._bank_up_button.remove_value_listener(self._bank_up_value) self._bank_up_button = up_button if self._bank_up_button != None: self._bank_up_button.add_value_listener(self._bank_up_value) if down_button != self._bank_down_button: do_update = True if self._bank_down_button != None: self._bank_down_button.remove_value_listener(self._bank_down_value) self._bank_down_button = down_button if self._bank_down_button != None: self._bank_down_button.add_value_listener(self._bank_down_value) if do_update: self.update() return None def set_bank_buttons(self, buttons): assert ((buttons == None) or isinstance(buttons, tuple)) if self._bank_buttons != None: for button in self._bank_buttons: button.remove_value_listener(self._bank_value) self._bank_buttons = buttons if self._bank_buttons != None: identify_sender = True for button in self._bank_buttons: button.add_value_listener(self._bank_value, identify_sender) self.update() return None def set_parameter_controls(self, controls): assert (controls != None) assert isinstance(controls, tuple) if self._device != None and self._parameter_controls != None: for control in self._parameter_controls: control.release_parameter() for control in controls: assert (control != None) assert isinstance(control, EncoderElement) self._parameter_controls = controls self.update() return None def set_lock_to_device(self, lock, device): assert isinstance(lock, type(False)) assert (lock is not self._locked_to_device) if lock: self.set_device(device) else: assert (device == self._device) self._locked_to_device = lock if self.is_enabled(): if (self._lock_button != None): if self._locked_to_device: self._lock_button.turn_on() else: self._lock_button.turn_off() def set_lock_button(self, button): assert ((button == None) or isinstance(button, ButtonElement)) if self._lock_button != None: self._lock_button.remove_value_listener(self._lock_value) self._lock_button = None self._lock_button = button if self._lock_button != None: self._lock_button.add_value_listener(self._lock_value) self.update() return None def set_on_off_button(self, button): assert ((button == None) or isinstance(button, ButtonElement)) if self._on_off_button != None: self._on_off_button.remove_value_listener(self._on_off_value) self._on_off_button = None self._on_off_button = button if self._on_off_button != None: self._on_off_button.add_value_listener(self._on_off_value) self.update() return None def set_lock_callback(self, callback): assert (self._lock_callback == None) assert (callback != None) assert (dir(callback).count('im_func') is 1) self._lock_callback = callback return None def restore_bank(self, bank_index): if self._device != None and self._is_banking_enabled() and self._locked_to_device and self._number_of_parameter_banks() > bank_index and self._bank_index != bank_index: self._bank_index = bank_index self.update() return None def device_name_data_source(self): if self._device_name_data_source == None: self._device_name_data_source = DisplayDataSource() self._on_device_name_changed() return self._device_name_data_source def update(self): if (self.is_enabled() and (self._device != None)): self._device_bank_registry[self._device] = self._bank_index if (self._parameter_controls != None): old_bank_name = self._bank_name #added self._assign_parameters() if self._bank_name != old_bank_name: #added try: self._show_msg_callback(self._device.name + ' Bank: ' + self._bank_name) #added except: pass if ((self._bank_up_button != None) and (self._bank_down_button != None)): if (self._number_of_parameter_banks()) > (self._bank_index + 1): self._bank_up_button.turn_on() else: self._bank_up_button.turn_off() if (self._bank_index > 0): self._bank_down_button.turn_on() else: self._bank_down_button.turn_off() if (self._bank_buttons != None): for index in range(len(self._bank_buttons)): if (index == self._bank_index): self._bank_buttons[index].turn_on() else: self._bank_buttons[index].turn_off() else: if (self._lock_button != None): self._lock_button.turn_off() if (self._bank_up_button != None): self._bank_up_button.turn_off() if (self._bank_down_button != None): self._bank_down_button.turn_off() if (self._bank_buttons != None): for button in self._bank_buttons: button.turn_off() if (self._parameter_controls != None): for control in self._parameter_controls: control.release_parameter() #self._rebuild_callback() def _bank_up_value(self, value): assert (self._bank_up_button != None) assert (value != None) assert isinstance(value, int) if self.is_enabled(): if ((not self._bank_up_button.is_momentary()) or (value is not 0)): if (self._device != None): num_banks = self._number_of_parameter_banks() if (self._bank_down_button == None): self._bank_name = '' self._bank_index = ((self._bank_index + 1) % num_banks) self.update() elif (num_banks > (self._bank_index + 1)): self._bank_name = '' self._bank_index += 1 self.update() def _bank_down_value(self, value): assert (self._bank_down_button != None) assert (value != None) assert isinstance(value, int) if self.is_enabled(): if ((not self._bank_down_button.is_momentary()) or (value is not 0)): if ((self._device != None) and (self._bank_index > 0)): self._bank_name = '' self._bank_index -= 1 self.update() def _lock_value(self, value): assert (self._lock_button != None) assert (self._lock_callback != None) assert (value != None) assert isinstance(value, int) if not self._lock_button.is_momentary() or value is not 0: self._lock_callback() return None def _on_off_value(self, value): assert (self._on_off_button != None) assert (value in range(128)) if not self._on_off_button.is_momentary() or value is not 0: parameter = self._on_off_parameter() if parameter != None and parameter.is_enabled: parameter.value = float(int(parameter.value == 0.0)) return None def _bank_value(self, value, button): assert (self._bank_buttons != None) assert (value != None) assert (button != None) assert isinstance(value, int) assert isinstance(button, ButtonElement) assert (list(self._bank_buttons).count(button) == 1) if self.is_enabled() and self._device != None: #added if ((not button.is_momentary()) or (value is not 0)): bank = list(self._bank_buttons).index(button) if (bank != self._bank_index): if (self._number_of_parameter_banks() > bank): self._bank_name = '' #added self._bank_index = bank self.update() else: try: self._show_msg_callback(self._device.name + ' Bank: ' + self._bank_name) except: pass def _is_banking_enabled(self): direct_banking = (self._bank_buttons != None) roundtrip_banking = (self._bank_up_button != None) increment_banking = ((self._bank_up_button != None) and (self._bank_down_button != None)) return (direct_banking or (roundtrip_banking or increment_banking)) def _assign_parameters(self): assert self.is_enabled() assert (self._device != None) assert (self._parameter_controls != None) self._bank_name = ('Bank ' + str(self._bank_index + 1)) #added if (self._device.class_name in self._device_banks.keys()): #modified assert (self._device.class_name in self._device_best_banks.keys()) banks = self._device_banks[self._device.class_name] bank = None #if (not self._is_banking_enabled()): # banks = self._device_best_banks[self._device.class_name] # self._bank_name = 'Best of Parameters' #added if (len(banks) > self._bank_index): bank = banks[self._bank_index] if self._is_banking_enabled(): #added if self._device.class_name in self._device_bank_names.keys(): #added self._bank_name = self._device_bank_names[self._device.class_name] #added *recheck assert ((bank == None) or (len(bank) >= len(self._parameter_controls))) for index in range(len(self._parameter_controls)): parameter = None if (bank != None): parameter = get_parameter_by_name(self._device, bank[index]) if (parameter != None): self._parameter_controls[index].connect_to(parameter) else: self._parameter_controls[index].release_parameter() else: parameters = self._device_parameters_to_map() num_controls = len(self._parameter_controls) index = (self._bank_index * num_controls) for control in self._parameter_controls: if (index < len(parameters)): control.connect_to(parameters[index]) else: control.release_parameter() index += 1 def _on_device_name_changed(self): if (self._device_name_data_source != None): if (self.is_enabled() and (self._device != None)): self._device_name_data_source.set_display_string(self._device.name) else: self._device_name_data_source.set_display_string('No Device') def _on_parameters_changed(self): self.update() def _on_off_parameter(self): result = None if (self._device != None): for parameter in self._device.parameters: if str(parameter.name).startswith('Device On'): result = parameter break return result def _on_on_off_changed(self): if (self.is_enabled() and (self._on_off_button != None)): turn_on = False if (self._device != None): parameter = self._on_off_parameter() turn_on = ((parameter != None) and (parameter.value > 0.0)) if turn_on: self._on_off_button.turn_on() else: self._on_off_button.turn_off() def _device_parameters_to_map(self): assert self.is_enabled() assert (self._device != None) assert (self._parameter_controls != None) return self._device.parameters[1:] #check this... def _number_of_parameter_banks(self): return number_of_parameter_banks(self._device) #added
def __init__(self, *a, **k): super(NoteSetting, self).__init__(*a, **k) self.value_source = DisplayDataSource() self.label_source = DisplayDataSource() self.label_source.set_display_string(self.get_label())
def __init__(self, *a, **k): super(SelectionDisplayComponent, self).__init__(*a, **k) self._data_sources = [ DisplayDataSource() for _ in range(self.num_segments) ]
class ChannelStripComponent(ChannelStripComponentBase): track_type_control = SendValueControl() oled_display_style_control = SendValueControl() arm_color_control = ButtonControl() mute_color_control = ButtonControl() solo_color_control = ButtonControl() output_meter_left_control = SendValueControl() output_meter_right_control = SendValueControl() track_color_control = ButtonControl() physical_track_color_control = ButtonControl() volume_touch_control = ButtonControl() solo_mute_button = ButtonControl() crossfade_assign_control = SendReceiveValueControl() assign_a_button = ButtonControl() assign_b_button = ButtonControl() assign_a_color_control = ButtonControl() assign_b_color_control = ButtonControl() volume_value_display = TextDisplayControl() pan_value_display = TextDisplayControl() send_value_displays = control_list(TextDisplayControl, MAX_NUM_SENDS) mpc_mute_button = ButtonControl() def __init__(self, *a, **k): self._oled_display_track_name_data_source = DisplayDataSource() self._oled_display_volume_value_data_source = DisplayDataSource() self._track_name_or_volume_value_display = None self._drum_group_finder = None super(ChannelStripComponent, self).__init__(*a, **k) self.__on_selected_track_changed.subject = self.song.view self.__on_selected_track_changed() self._drum_group_finder = self.register_disconnectable(PercussionInstrumentFinder(device_parent=self.track)) def set_track(self, track): super(ChannelStripComponent, self).set_track(track) self._drum_group_finder.device_parent = track self.__on_drum_group_found.subject = self._drum_group_finder self.__on_drum_group_found() self._update_listeners() self._update_controls() def set_volume_control(self, control): super(ChannelStripComponent, self).set_volume_control(control) self.volume_touch_control.set_control_element(control.touch_element if control else None) def set_track_name_display(self, display): if display: display.set_data_sources([self.track_name_data_source()]) def set_track_name_or_volume_value_display(self, display): self._track_name_or_volume_value_display = display self._update_track_name_or_volume_value_display() def set_send_value_displays(self, displays): self.send_value_displays.set_control_element(displays) @volume_touch_control.pressed def volume_touch_control(self, _): self._update_track_name_or_volume_value_display() @volume_touch_control.released def volume_touch_control(self, _): self._update_track_name_or_volume_value_display() @crossfade_assign_control.value def crossfade_assign_control(self, value, _): value_to_set = force_to_live_crossfade_assign_value(value) if value_to_set < len(LIVE_CROSSFADE_ASSIGN_VALUES) and self._track_has_visible_crossfade_assignment_buttons(): self.track.mixer_device.crossfade_assign = value_to_set @assign_a_button.pressed def assign_a_button(self, _): self._toggle_crossfade_assign(force_to_live_crossfade_assign_value(CROSSFADE_ASSIGN_A)) @assign_b_button.pressed def assign_b_button(self, _): self._toggle_crossfade_assign(force_to_live_crossfade_assign_value(CROSSFADE_ASSIGN_B)) @mpc_mute_button.pressed def mpc_mute_button(self, _): track = self.track if liveobj_valid(track) and track != self.song.master_track: track.mute = not track.mute def _on_select_button_pressed_delayed(self, _): if self.track.is_foldable: self.track.fold_state = not self.track.fold_state @listens(u'has_audio_output') def __on_has_audio_output_changed(self): self._update_output_meter_listeners() self._update_track_type_control() self._update_oled_display_style_control() self._update_crossfade_assignment_control() self._update_crossfade_assign_color_controls() def _update_output_meter_listeners(self): track = self.track subject = track if liveobj_valid(track) and track.has_audio_output else None self.__on_output_meter_left_changed.subject = subject self.__on_output_meter_right_changed.subject = subject if liveobj_valid(subject): self.__on_output_meter_left_changed() self.__on_output_meter_right_changed() else: self._reset_output_meter_controls() def _on_arm_changed(self): super(ChannelStripComponent, self)._on_arm_changed() self._update_arm_color_control() def _on_mute_changed(self): self._update_mute_color_controls() def _on_solo_changed(self): super(ChannelStripComponent, self)._on_solo_changed() self._update_solo_color_control() def _on_cf_assign_changed(self): super(ChannelStripComponent, self)._on_cf_assign_changed() self._update_crossfade_assignment_control() self._update_crossfade_assign_color_controls() def _on_sends_changed(self): super(ChannelStripComponent, self)._on_sends_changed() self._update_listeners() self._update_controls() @listens(u'output_meter_left') def __on_output_meter_left_changed(self): self.output_meter_left_control.value = meter_value_to_midi_value(self.track.output_meter_left) @listens(u'output_meter_right') def __on_output_meter_right_changed(self): self.output_meter_right_control.value = meter_value_to_midi_value(self.track.output_meter_right) @listens(u'color') def __on_track_color_changed(self): self._update_track_color_control() @listens(u'value') def __on_volume_changed(self): track = self.track value_string = format_volume_value_string(str(track.mixer_device.volume) if liveobj_valid(track) and track.has_audio_output else u'') self._oled_display_volume_value_data_source.set_display_string(value_string) self.volume_value_display[0] = value_string @listens(u'value') def __on_pan_changed(self): track = self.track self.pan_value_display[0] = str(track.mixer_device.panning) if liveobj_valid(track) and track.has_audio_output else u'' @listens_group(u'value') def __on_send_value_changed(self, send_index): self._update_send_value_display(send_index) @listens(u'selected_track') def __on_selected_track_changed(self): self._update_select_button() self._update_track_color_control() @listens(u'muted_via_solo') def __on_muted_via_solo_changed(self): self.solo_mute_button.color = u'DefaultButton.On' if liveobj_valid(self.track) and self.track != self.song.master_track and self.track.muted_via_solo else u'DefaultButton.Off' @listens(u'instrument') def __on_drum_group_found(self): self._update_track_type_control() def _update_listeners(self): track = self.track self.__on_has_audio_output_changed.subject = track self.__on_has_audio_output_changed() self.__on_track_color_changed.subject = track self.__on_track_color_changed() self.__on_volume_changed.subject = track.mixer_device.volume if liveobj_valid(track) else None self.__on_volume_changed() self.__on_muted_via_solo_changed.subject = track self.__on_muted_via_solo_changed() self.__on_pan_changed.subject = track.mixer_device.panning if liveobj_valid(track) else None self.__on_pan_changed() track = self.track self.__on_send_value_changed.replace_subjects(track.mixer_device.sends if liveobj_valid(track) else [], count()) def _update_controls(self): self._update_track_type_control() self._update_oled_display_style_control() for send_index in range(MAX_NUM_SENDS): self._update_send_value_display(send_index) def _update_track_type_control(self): track_type = NO_TRACK track = self.track if liveobj_valid(track): if track == self.song.master_track: track_type = MASTER_TRACK elif track in self.song.return_tracks: track_type = RETURN_TRACK elif track.is_foldable: track_type = GROUP_TRACK elif track.has_midi_input: if self._drum_group_finder is not None and liveobj_valid(self._drum_group_finder.drum_group): track_type = DRUM_TRACK elif track.has_audio_output: track_type = MELODIC_TRACK else: track_type = EMPTY_MIDI_TRACK elif track.has_audio_output: track_type = AUDIO_TRACK self.track_type_control.value = track_type def _update_crossfade_assignment_control(self): self.crossfade_assign_control.value = LIVE_CROSSFADE_ASSIGN_VALUES[self.track.mixer_device.crossfade_assign] if self._track_has_visible_crossfade_assignment_buttons() else CROSSFADE_ASSIGN_OFF def _update_crossfade_assign_color_controls(self): off_color = u'DefaultButton.Off' track = self.track assign_a_control_color = off_color assign_b_control_color = off_color if self._track_has_visible_crossfade_assignment_buttons(): mixer_device = track.mixer_device assign_a_control_color = u'Mixer.CrossfadeAssignA' if mixer_device.crossfade_assign == force_to_live_crossfade_assign_value(CROSSFADE_ASSIGN_A) else off_color assign_b_control_color = u'Mixer.CrossfadeAssignB' if mixer_device.crossfade_assign == force_to_live_crossfade_assign_value(CROSSFADE_ASSIGN_B) else off_color self.assign_a_color_control.color = assign_a_control_color self.assign_b_color_control.color = assign_b_control_color def _update_track_name_data_source(self): super(ChannelStripComponent, self)._update_track_name_data_source() self._oled_display_track_name_data_source.set_display_string(self._track.name if liveobj_valid(self._track) else u' - ') def _update_arm_color_control(self): color = u'Mixer.ArmOff' track = self.track if liveobj_valid(track) and track in self.song.tracks and track.can_be_armed and track.arm: color = u'Mixer.ArmOn' self.arm_color_control.color = color def _update_mute_color_controls(self): mute_color_control_color = u'Mixer.MuteOff' mute_button_color = u'Mixer.MuteOn' track = self.track if liveobj_valid(track) and (track == self.song.master_track or not track.mute): mute_color_control_color = u'Mixer.MuteOn' mute_button_color = u'Mixer.MuteOff' self.mute_color_control.color = mute_color_control_color self.mpc_mute_button.color = mute_color_control_color if self._mute_button: self._mute_button.set_light(mute_button_color) def _update_solo_color_control(self): color = u'Mixer.SoloOff' track = self.track if liveobj_valid(track) and track != self.song.master_track and track.solo: color = u'Mixer.SoloOn' self.solo_color_control.color = color def _update_track_color_control(self): color_to_send = u'DefaultButton.Off' selected_color_to_send = None track = self.track if liveobj_valid(track) and track.color_index != None: color_to_send = track.color_index + LIVE_COLOR_TABLE_INDEX_OFFSET if track == self.song.view.selected_track: selected_color_to_send = u'DefaultButton.On' self.track_color_control.color = color_to_send self.physical_track_color_control.color = selected_color_to_send or color_to_send def _update_oled_display_style_control(self): value_to_send = OLED_DISPLAY_OFF track = self.track if liveobj_valid(track) and track.has_audio_output: value_to_send = OLED_DISPLAY_UNIPOLAR self.oled_display_style_control.value = value_to_send def _update_track_name_or_volume_value_display(self): if self._track_name_or_volume_value_display: self._track_name_or_volume_value_display.set_data_sources([self._oled_display_volume_value_data_source if self.volume_touch_control.is_pressed else self._oled_display_track_name_data_source]) def _update_send_value_display(self, index): if index < MAX_NUM_SENDS: value_to_send = u'' track = self.track if liveobj_valid(track): sends = track.mixer_device.sends if index < len(sends): value_to_send = str(sends[index]) self.send_value_displays[index][0] = value_to_send def _reset_output_meter_controls(self): self.output_meter_left_control.value = 0 self.output_meter_right_control.value = 0 def _track_has_visible_crossfade_assignment_buttons(self): track = self.track return liveobj_valid(track) and track != self.song.master_track and track.has_audio_output def _toggle_crossfade_assign(self, value): track = self.track if self._track_has_visible_crossfade_assignment_buttons(): mixer_device = track.mixer_device mixer_device.crossfade_assign = force_to_live_crossfade_assign_value(CROSSFADE_ASSIGN_OFF) if mixer_device.crossfade_assign == value else value
def __init__(self, *a, **k): super(NoteSettingsComponent, self).__init__(*a, **k) self._top_data_sources = [ DisplayDataSource() for _ in xrange(8) ] self._bottom_data_sources = [ DisplayDataSource() for _ in xrange(8) ] self._info_data_source = DisplayDataSource() self._create_display_sources()
def __init__(self, *a, **k): super(ChannelStripComponent, self).__init__(*a, **k) self._pan_value_display_data_source = DisplayDataSource() self.__on_selected_track_changed.subject = self.song.view
class DeviceComponentBase(Component): """ Class representing a device in Live """ @depends(device_bank_registry=None) @depends(device_provider=None) def __init__(self, device_provider = None, device_bank_registry = None, *a, **k): assert device_bank_registry is not None super(DeviceComponentBase, self).__init__(*a, **k) self._device_bank_registry = device_bank_registry self._device_provider = device_provider self._parameter_controls = None self._bank_up_button = None self._bank_down_button = None self._bank_buttons = None self._on_off_button = None self._device_name_data_source = None self._bank_index = 0 self._bank_name = '<No Bank>' def make_button_slot(name): return self.register_slot(None, getattr(self, '_%s_value' % name), 'value') self._bank_up_button_slot = make_button_slot('bank_up') self._bank_down_button_slot = make_button_slot('bank_down') self._on_off_button_slot = make_button_slot('on_off') self.__on_device_bank_changed.subject = self._device_bank_registry self.__on_provided_device_changed.subject = self._device_provider self.__on_provided_device_changed() def disconnect(self): self._device_bank_registry = None self._release_parameters(self._parameter_controls) self._parameter_controls = None self._bank_up_button = None self._bank_down_button = None self._bank_buttons = None self._on_off_button = None self._device_provider = None super(DeviceComponentBase, self).disconnect() def _get_device(self): return self._device_provider.device def on_enabled_changed(self): self.update() @listens('device') def __on_provided_device_changed(self): self._on_device_changed(self._get_device()) def _on_device_changed(self, device): if liveobj_valid(device): self._release_parameters(self._parameter_controls) self.__on_device_name_changed.subject = device self.__on_parameters_changed.subject = device self.__on_device_on_off_changed.subject = self._on_off_parameter() if liveobj_valid(device): self._bank_index = 0 self._bank_index = self._device_bank_registry.get_device_bank(device) self._bank_name = '<No Bank>' self.__on_device_name_changed() self.update() def set_bank_prev_button(self, button): if button != self._bank_down_button: self._bank_down_button = button self._bank_down_button_slot.subject = button self.update() def set_bank_next_button(self, button): if button != self._bank_up_button: self._bank_up_button = button self._bank_up_button_slot.subject = button self.update() def set_bank_nav_buttons(self, down_button, up_button): self.set_bank_prev_button(down_button) self.set_bank_next_button(up_button) def set_bank_buttons(self, buttons): self._bank_buttons = buttons self.__on_bank_value.replace_subjects(buttons or []) self.update() def set_parameter_controls(self, controls): self._release_parameters(self._parameter_controls) self._parameter_controls = controls self.update() def set_on_off_button(self, button): self._on_off_button = button self._on_off_button_slot.subject = button self._update_on_off_button() def device_name_data_source(self): if self._device_name_data_source == None: self._device_name_data_source = DisplayDataSource() self.__on_device_name_changed() return self._device_name_data_source def update(self): super(DeviceComponentBase, self).update() if self.is_enabled() and liveobj_valid(self._get_device()): self._device_bank_registry.set_device_bank(self._get_device(), self._bank_index) if self._parameter_controls != None: old_bank_name = self._bank_name self._assign_parameters() #if self._bank_name != old_bank_name: # self._show_msg_callback(self._get_device().name + u' Bank: ' + self._bank_name) elif self._parameter_controls != None: self._release_parameters(self._parameter_controls) if self.is_enabled(): self._update_on_off_button() self._update_device_bank_buttons() self._update_device_bank_nav_buttons() def _bank_up_value(self, value): assert self._bank_up_button != None assert value != None assert isinstance(value, int) if self.is_enabled(): if not self._bank_up_button.is_momentary() or value is not 0: if liveobj_valid(self._get_device()): num_banks = self._number_of_parameter_banks() if self._bank_down_button == None: self._bank_name = '' self._bank_index = (self._bank_index + 1) % num_banks if self._bank_index != None else 0 self.update() elif self._bank_index == None or num_banks > self._bank_index + 1: self._bank_name = '' self._bank_index = self._bank_index + 1 if self._bank_index != None else 0 self.update() def _bank_down_value(self, value): assert self._bank_down_button != None assert value != None assert isinstance(value, int) if self.is_enabled(): if not self._bank_down_button.is_momentary() or value is not 0: if liveobj_valid(self._get_device()) and (self._bank_index == None or self._bank_index > 0): self._bank_name = '' self._bank_index = self._bank_index - 1 if self._bank_index != None else max(0, self._number_of_parameter_banks() - 1) self.update() def _on_off_value(self, value): assert self._on_off_button != None assert value in range(128) if not self._on_off_button.is_momentary() or value is not 0: parameter = self._on_off_parameter() if parameter != None and parameter.is_enabled: parameter.value = float(int(parameter.value == 0.0)) @listens_group('value') def __on_bank_value(self, value, button): self._bank_value(value, button) def _bank_value(self, value, button): if self.is_enabled() and liveobj_valid(self._get_device()): if not button.is_momentary() or value is not 0: bank = list(self._bank_buttons).index(button) if bank != self._bank_index: if self._number_of_parameter_banks() > bank: self._bank_name = '' self._bank_index = bank self.update() #else: # self._show_msg_callback(self._get_device().name + u' Bank: ' + self._bank_name) def _is_banking_enabled(self): direct_banking = self._bank_buttons != None roundtrip_banking = self._bank_up_button != None increment_banking = self._bank_up_button != None and self._bank_down_button != None return direct_banking or roundtrip_banking or increment_banking def _assign_parameters(self): assert self.is_enabled() assert liveobj_valid(self._get_device()) assert self._parameter_controls != None self._bank_name, bank = self._current_bank_details() for control, parameter in zip(self._parameter_controls, bank): if control != None: if parameter != None: control.connect_to(parameter) else: control.release_parameter() self._release_parameters(self._parameter_controls[len(bank):]) @listens('value') def __on_device_on_off_changed(self): self._update_on_off_button() @listens('name') def __on_device_name_changed(self): if self._device_name_data_source != None: self._device_name_data_source.set_display_string(self._get_device().name if self.is_enabled() and liveobj_valid(self._get_device()) else 'No Device') @listens('parameters') def __on_parameters_changed(self): self.update() def _on_off_parameter(self): result = None if liveobj_valid(self._get_device()): for parameter in self._get_device().parameters: if str(parameter.name).startswith('Device On'): result = parameter break return result def _update_on_off_button(self): if self.is_enabled() and self._on_off_button != None: turn_on = False if liveobj_valid(self._get_device()): parameter = self._on_off_parameter() turn_on = parameter != None and parameter.value > 0.0 self._on_off_button.set_light(turn_on) def _update_device_bank_buttons(self): if self.is_enabled(): for index, button in enumerate(self._bank_buttons or []): if button: turn_on = index == self._bank_index and liveobj_valid(self._get_device()) button.set_light(turn_on) def _update_device_bank_nav_buttons(self): if self.is_enabled(): if self._bank_up_button != None and self._bank_down_button != None: can_bank_up = self._bank_index == None or self._number_of_parameter_banks() > self._bank_index + 1 can_bank_down = self._bank_index == None or self._bank_index > 0 self._bank_up_button.set_light(self._get_device() and can_bank_up) self._bank_down_button.set_light(self._get_device() and can_bank_down) def _best_of_parameter_bank(self): return best_of_parameter_bank(self._get_device()) def _parameter_banks(self): return parameter_banks(self._get_device()) def _parameter_bank_names(self): return parameter_bank_names(self._get_device()) def _device_parameters_to_map(self): return device_parameters_to_map(self._get_device()) def _number_of_parameter_banks(self): return number_of_parameter_banks(self._get_device()) def _current_bank_details(self): bank_name = self._bank_name bank = [] best_of = self._best_of_parameter_bank() banks = self._parameter_banks() if banks: if self._bank_index != None and self._is_banking_enabled() or not best_of: index = self._bank_index if self._bank_index != None else 0 bank = banks[index] bank_name = self._parameter_bank_names()[index] else: bank = best_of bank_name = 'Best of Parameters' return (bank_name, bank) @listens('device_bank') def __on_device_bank_changed(self, device, new_bank_index): if device == self._get_device() and new_bank_index != self._bank_index and self._number_of_parameter_banks() > new_bank_index: self._bank_index = new_bank_index self.update() def _release_parameters(self, controls): if controls != None: for control in controls: if control != None: control.release_parameter()