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 '-')
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)
]
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_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
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())
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()
