class AumPushTrollComponent(CompoundComponent): def __init__(self, script, device_component, *a, **k): super(AumPushTrollComponent, self).__init__(*a, **k) self._script = script self._device_component = device_component self._session_ring = SessionRingComponent(num_tracks=16, num_scenes=1, tracks_to_use=partial(tracks_to_use_from_song, self.song)) self._session_ring.set_enabled(False) self._mixer = TrollMixerComponent(tracks_provider = self._session_ring, num_returns = 4, device_component = self._device_component) self._mixer._sends_layer = LayerMode(self._mixer, Layer()) self._mixer._left_layer = LayerMode(self._mixer, Layer()) self._mixer._right_layer = LayerMode(self._mixer, Layer()) self._mixer._master_layer = LayerMode(self._mixer, Layer()) self._device_selector = AumPushDeviceSelectorComponent(self._script) self._device_selector.layer = Layer() self._send_reset = AumPushResetSendsComponent(self._script) self._send_reset.layer = Layer() self._device1 = AumpushDeviceParameterComponent(parameter_provider=self._device_component) self._device2 = AumpushDeviceParameterComponent(parameter_provider=self._device_component) self.register_component(self._device1) self.register_component(self._device2) self._trollmodes = ModesComponent(name = 'TrollMode') # is_enabled = False) self.register_component(self._trollmodes) #self._trollmodes.set_enabled(False) def set_enabled(self, enabled = True): super(AumPushTrollComponent, self).set_enabled(enabled) if not enabled: self._script.schedule_message(1, self._script._select_note_mode) def _find_device1(self): if self._device1: if len(self.song.return_tracks) > 0: if len(self.song.return_tracks[0].devices) > 0: #if self._device1.parameter_provider._locked_to_device: # self._device1.parameter_provider.set_lock_to_device(False, self._device1.parameter_provider._device) self._device1.parameter_provider.set_device(self.song.return_tracks[0].devices[0]) def _find_device2(self): if self._device2: if len(self.song.return_tracks) > 1: if len(self.song.return_tracks[1].devices) > 0: #if self._device2.parameter_provider._locked_to_device: # self._device2.parameter_provider.set_lock_to_device(False, self._device2.parameter_provider._device) self._device2.parameter_provider.set_device(self.song.return_tracks[1].devices[0])
class Cntrlr(Base_Cntrlr):
def __init__(self, *a, **k):
super(Cntrlr, self).__init__(*a, **k)
self._skin = Skin(CntrlrColors)
for button in self._grid:
button._skin = self._skin
self._main_modes.selected_mode = 'Translations'
self.schedule_message(3, self.initialize_translations)
def initialize_santos_mode(self):
self._main_modes.selected_mode = 'SantosMode'
self._device_toggle.scan_all()
self._session_ring.set_offsets(1, 0)
def initialize_translations(self):
self._main_modes.selected_mode = "Translations"
self.schedule_message(3, self.initialize_santos_mode)
def _open_log(self):
self.log_message("<<<<<<<<<<<<<<<<<<<<= " + str(self._host_name) + " for Santos Garcia " + str(self._version_check) + " log opened =>>>>>>>>>>>>>>>>>>>")
self.show_message(str(self._host_name) + ' Control Surface Loaded')
def _setup_device_toggle(self):
self._device_toggle = ToggleDeviceEnabledComponent(self, "@dd")
self._device_toggle.layer = Layer(priority = 9, matrix = self._key_matrix.submatrix[4:12, 1:])
self._device_toggle.set_enabled(False)
def _update_session_position(self):
self._session_ring.set_offsets(1, 0)
def _setup_mixer_control(self):
self._mixer = MonoMixerComponent(name = 'Mixer', num_returns = 4,tracks_provider = SessionRingComponent(num_tracks = 4, num_scenes = 4), track_assigner = simple_track_assigner, invert_mute_feedback = True, auto_name = True, enable_skinning = True)
if FREE_ENCODER_IS_CROSSFADER:
self._mixer.layer = Layer(priority = 4, crossfader_control = self._encoder[1])
self._mixer.main_faders_layer = AddLayerMode(self._mixer, Layer(priority = 4,
volume_controls = self._fader_matrix.submatrix[:4, :],
return_controls = self._fader_matrix.submatrix[4:, :],))
self._mixer.main_buttons_layer = AddLayerMode(self._mixer, Layer(priority = 4,
mute_buttons = self._key_matrix.submatrix[8:12, 1:],
stop_clip_buttons = self._key_matrix.submatrix[4:8, 1:],
arming_track_select_buttons = self._key_matrix.submatrix[:4, 1:],))
self._mixer.solo_buttons_layer = AddLayerMode(self._mixer, Layer(priority = 4,
solo_buttons = self._key_matrix.submatrix[8:12, 1:],))
self._mixer.shifted_buttons_layer = AddLayerMode(self._mixer, Layer(priority = 4,
track_select_buttons = self._key_matrix.submatrix[:4, 1:],
stop_clip_buttons = self._key_matrix.submatrix[4:8, 1:],
solo_buttons = self._key_matrix.submatrix[8:12, 1:],))
self._mixer.stop_layer = AddLayerMode(self._mixer, Layer(priority = 4,
stop_clip_buttons = self._key_matrix.submatrix[8:12, 1:],))
if EQS_INSTEAD_OF_MACROS:
self._mixer.main_knobs_layer = AddLayerMode(self._mixer, Layer(priority = 4,
send_controls = self._knob_left_matrix,
eq_gain_controls = self._knob_right_matrix))
else:
self._mixer.main_knobs_layer = AddLayerMode(self._mixer, Layer(priority = 4,
send_controls = self._knob_left_matrix,
parameter_controls = self._knob_right_matrix))
#self._mixer.main_knobs_layer = AddLayerMode(self._mixer, Layer(priority = 4))
self._mixer.master_fader_layer = AddLayerMode(self._mixer.master_strip(), Layer(priority = 4,
volume_control = self._fader[7]))
self._mixer.instrument_buttons_layer = AddLayerMode(self._mixer, Layer(priority = 4,
mute_buttons = self._key_matrix.submatrix[:4, 1:],
track_select_buttons = self._key_matrix.submatrix[4:8, 1:],))
self._mixer.set_enabled(False)
def _setup_session_control(self):
self._session_ring = SessionRingComponent(num_tracks = 3, num_scenes = 4)
self._session_ring.set_enabled(False)
self._session_navigation = CntrlrSessionNavigationComponent(name = 'SessionNavigation', session_ring = self._session_ring)
self._session_navigation._vertical_banking.scroll_up_button.color = 'Session.NavigationButtonOn'
self._session_navigation._vertical_banking.scroll_down_button.color = 'Session.NavigationButtonOn'
self._session_navigation._horizontal_banking.scroll_up_button.color = 'Session.NavigationButtonOn'
self._session_navigation._horizontal_banking.scroll_down_button.color = 'Session.NavigationButtonOn'
self._session_navigation._vertical_paginator.scroll_up_button.color = 'Session.PageNavigationButtonOn'
self._session_navigation._vertical_paginator.scroll_down_button.color = 'Session.PageNavigationButtonOn'
self._session_navigation._horizontal_paginator.scroll_up_button.color = 'Session.PageNavigationButtonOn'
self._session_navigation._horizontal_paginator.scroll_down_button.color = 'Session.PageNavigationButtonOn'
self._session_navigation.bank_dial_layer = AddLayerMode(self._session_navigation, Layer(priority = 5,
track_bank_dial = self._encoder[3],
scene_bank_dial = self._encoder[2],))
self._session_navigation.nav_dial_layer = AddLayerMode(self._session_navigation, Layer(priority = 5,
scene_nav_dial = self._encoder[2],
track_nav_dial = self._encoder[3],))
self._session_navigation.select_dial_layer = AddLayerMode(self._session_navigation, Layer(priority = 5))
"""self._session_navigation.nav_layer = AddLayerMode(self._session_navigation, Layer(priority = 4,
page_down_button = self._button[14],
page_up_button = self._button[15],
page_left_button = self._button[12],
page_right_button = self._button[13]))"""
self._session_navigation.nav_layer = AddLayerMode(self._session_navigation, Layer(priority = 4))
self._session_navigation.set_enabled(False)
self._session = SpecialCntrlrSessionComponent(session_ring = self._session_ring, auto_name = True)
hasattr(self._session, '_enable_skinning') and self._session._enable_skinning()
self._session.clip_launch_layer = LayerMode(self._session, Layer(priority = 4,
clip_launch_buttons = self._matrix.submatrix[:,:]))
self._session.scene_launch_layer = AddLayerMode(self._session._selected_scene, Layer(priority = 4,
launch_button = self._button[28],))
self._session.set_enabled(False)
self._session_zoom = SessionOverviewComponent(name = 'SessionZoom', session_ring = self._session_ring, enable_skinning = True)
self._session_zoom.layer = Layer(priority = 4, button_matrix = self._matrix.submatrix[:,:])
self._session.clip_launch_layer = LayerMode(self._session, Layer(priority = 4,
clip_launch_buttons = self._matrix.submatrix[:3,:],
scene_launch_buttons = self._matrix.submatrix[3:,:]))
self._session_ring.set_offsets(1, 0)
self._session_zoom.set_enabled(False)
def _setup_translations2(self):
self._translated_controls2 = self._knobs #+ self._button[:20] + self._button[28:]
self._translations2 = TranslationComponent(self._translated_controls2, user_channel_offset = 9, channel = 9)
self._translations2.name = 'TranslationComponent'
self._translations2.layer = Layer(priority = 10,)
self._translations2.set_enabled(False)
def _setup_modes(self):
self._setup_device_toggle()
self._setup_translations2()
self._mixer.santos_buttons_layer = AddLayerMode(self._mixer, Layer(priority = 4,
arming_track_select_buttons = self._key_matrix.submatrix[:4, 1:],))
super(Cntrlr, self)._setup_modes()
common = CompoundMode(self._mixer,
self._session_ring)
main_buttons=CompoundMode(self._mixer.main_buttons_layer,
self._transport,
self._recorder,
self._recorder.main_layer,
self._device,
self._device.button_layer)
shifted_main_buttons=CompoundMode(self._mixer.solo_buttons_layer,
self._recorder,
self._recorder.shift_layer,
self._session,
self._session.scene_launch_layer,
self._device,
self._device.button_layer)
main_faders=CompoundMode(self._mixer.main_faders_layer,
self._mixer.master_fader_layer)
main_dials=CompoundMode(self._view_control,
self._view_control.main_layer,
self._device,
self._device.dial_layer,
self._device_navigator.select_dial_layer,
self.encoder_navigation_on)
shifted_dials=CompoundMode(self._session_navigation,
self._session_navigation.nav_dial_layer,
self._device,
self._device.dial_layer,
self._device_navigator.select_dial_layer,
self.encoder_navigation_on)
self._main_modes = ModesComponent(name = 'MainModes')
self._main_modes.add_mode('disabled', [self._background])
self._main_modes.add_mode('MixMode', [common,
self._instrument,
self._instrument.shift_button_layer,
self._mixer,
main_faders,
self._mixer.main_knobs_layer,
self._device,
self._device_navigator,
self._device_navigator.main_layer,],
behaviour = DefaultedBehaviour(default_mode = 'SantosMode',color = 'ModeButtons.DeviceSelector', off_color = 'ModeButtons.DeviceSelectorDisabled'))
self._main_modes.add_mode('ModSwitcher', [common,
main_faders,
main_dials,
self._mixer.main_knobs_layer,
self._session_navigation.select_dial_layer,
self._view_control,
self._view_control.main_layer,
self._device_navigator.select_dial_layer,
self.encoder_navigation_on, self._modswitcher,
DelayMode(self._update_modswitcher, delay = .1)],
behaviour = ColoredCancellableBehaviourWithRelease(color = 'ModeButtons.ModSwitcher', off_color = 'ModeButtons.ModSwitcherDisabled'))
self._main_modes.add_mode('Translations', [common,
main_faders,
main_dials,
self._mixer.main_knobs_layer,
self._translations,
DelayMode(self._translations.selector_layer, delay = .1)],
behaviour = DefaultedBehaviour(default_mode = 'SantosMode', color = 'ModeButtons.Translations', off_color = 'ModeButtons.TranslationsDisabled'))
self._main_modes.add_mode('DeviceSelector', [common,
self._device_selector,
DelayMode(self._device_selector.select_layer, delay = .1),
DelayMode(self.modhandler.lock_layer, delay = .1),
DelayMode(self._device_selector.assign_layer, delay = .5),
main_buttons,
main_dials,
main_faders,
self._mixer.main_knobs_layer,
self._device,
self._device_navigator],
behaviour = ColoredCancellableBehaviourWithRelease(color = 'ModeButtons.DeviceSelector', off_color = 'ModeButtons.DeviceSelectorDisabled'))
self._main_modes.add_mode('SantosMode', [self._mixer,
self._mixer.main_faders_layer,
self._device_toggle,
self._translations2,
self._instrument,
self._instrument.shift_button_layer,
self._mixer.santos_buttons_layer,
self._device, self._device_navigator,
self._session_ring,
DelayMode(self._update_session_position, delay = .1)], )
self._main_modes.layer = Layer(priority = 4, ModSwitcher_button = self._encoder_button[2], MixMode_button = self._encoder_button[0], Translations_button = self._encoder_button[3]) #,
self._main_modes.selected_mode = 'disabled'
self._main_modes.set_enabled(True)
# a
class Cntrlr(BaseCntrlr):
def __init__(self, *a, **k):
super(Cntrlr, self).__init__(*a, **k)
self._skin = Skin(CntrlrColors)
for button in self._grid:
button._skin = self._skin
def _open_log(self):
self.log_message("<<<<<<<<<<<<<<<<<<<<= " + str(self._host_name) + " for Georg Oswald " + str(self._version_check) + " log opened =>>>>>>>>>>>>>>>>>>>")
self.show_message(str(self._host_name) + ' Control Surface Loaded')
def _setup_transport_control(self):
super(Cntrlr, self)._setup_transport_control()
self._transport._overdub_toggle.view_transform = lambda value: 'Transport.OverdubOn' if value else 'Transport.OverdubOff'
self._transport.layer = Layer(priority = 4,
play_button = self._button[24])
self._transport.overdub_layer = AddLayerMode(self._transport, Layer(priority = 4,
overdub_button = self._button[25]))
def _setup_session_control(self):
super(Cntrlr, self)._setup_session_control()
self._session_navigation.nav_layer = AddLayerMode(self._session_navigation, Layer(priority = 4,
page_down_button = self._button[22],
page_up_button = self._button[23],
page_left_button = self._button[20],
page_right_button = self._button[21]))
self._session.stop_clips_layer = AddLayerMode(self._session, Layer(priority = 4,
stop_all_clips_button = self._button[29],))
def _setup_session_recording_component(self):
super(Cntrlr, self)._setup_session_recording_component()
self._recorder.main_layer = AddLayerMode(self._recorder, Layer(priority = 4))
self._recorder.shift_layer = AddLayerMode(self._recorder, Layer(priority = 4, automation_button = self._button[25]))
def _setup_mixer_control(self):
super(Cntrlr, self)._setup_mixer_control()
mute_buttons = ButtonMatrixElement(name = 'mute_buttons', rows = [self._button[:4] + self._button[12:16]])
select_buttons = ButtonMatrixElement(name = 'select_buttons', rows = [self._button[16:20] + self._button[28:32]])
self._G_session_ring = SessionRingComponent(num_tracks = 8, num_scenes = 4)
self._G_session_ring.set_enabled(False)
self._G_mixer = MonoMixerComponent(name = 'Mixer', num_returns = 4,tracks_provider = self._G_session_ring, track_assigner = simple_track_assigner, invert_mute_feedback = True, auto_name = True, enable_skinning = True)
if FREE_ENCODER_IS_CROSSFADER:
self._mixer.layer = Layer(priority = 4, crossfader_control = self._encoder[1])
#self._G_mixer.select_dial_layer = AddLayerMode(self._G_mixer, Layer(priority = 5,
# track_select_dial = self._encoder[3],))
self._G_mixer.main_faders_layer = AddLayerMode(self._G_mixer, Layer(priority = 4,
volume_controls = self._fader_matrix.submatrix[:8, :],))
self._G_mixer.main_buttons_layer = AddLayerMode(self._G_mixer, Layer(priority = 4,
mute_buttons = mute_buttons,
arming_track_select_buttons = select_buttons,
solo_buttons = self._key_matrix.submatrix[4:12, :1],))
self._G_mixer.shifted_buttons_layer = AddLayerMode(self._G_mixer, Layer(priority = 4,
mute_buttons = mute_buttons,))
self._G_mixer.solo_buttons_layer = AddLayerMode(self._G_mixer, Layer(priority = 4,
solo_buttons = self._key_matrix.submatrix[4:12, :1],))
self._G_mixer.mute_buttons_layer = AddLayerMode(self._G_mixer, Layer(priority = 4,
mute_buttons = mute_buttons,))
self._G_mixer.stop_layer = AddLayerMode(self._G_mixer, Layer(priority = 4,
stop_clip_buttons = self._key_matrix.submatrix[8:12, 1:],))
self._G_mixer.main_knobs_layer = AddLayerMode(self._G_mixer, Layer(priority = 4))
self._G_mixer.master_fader_layer = AddLayerMode(self._G_mixer.master_strip(), Layer(priority = 4,))
self._G_mixer.instrument_buttons_layer = AddLayerMode(self._G_mixer, Layer(priority = 4,
mute_buttons = mute_buttons,
track_select_buttons = select_buttons,))
self._G_mixer.set_enabled(False)
def _setup_device_control(self):
super(Cntrlr, self)._setup_device_control()
self._device_navigator.main_layer = AddLayerMode(self._device_navigator, Layer(priority = 4,
prev_button = self._encoder_button[8],
next_button = self._encoder_button[9],
exit_button = self._encoder_button[10],
enter_button = self._encoder_button[11],))
def _setup_instrument(self):
self._grid_resolution = self.register_disconnectable(GridResolution())
self._c_instance.playhead.enabled = True
self._playhead_element = PlayheadElement(self._c_instance.playhead)
self._drum_group_finder = PercussionInstrumentFinder(device_parent=self.song.view.selected_track)
self._instrument = CntrlrMonoInstrumentComponent(name = 'InstrumentComponent', is_enabled = True, script = self, skin = self._skin, grid_resolution = self._grid_resolution, drum_group_finder = self._drum_group_finder, parent_task_group = self._task_group, settings = DEFAULT_INSTRUMENT_SETTINGS, device_provider = self._device_provider)
self._instrument.shift_button_layer = AddLayerMode(self._instrument, Layer(priority = 5, session_mode_button = self._button[26], shift_mode_button = self._button[27]))
self._instrument.audioloop_layer = AddLayerMode(self._instrument, Layer(priority = 5))
self._instrument.keypad_shift_layer = AddLayerMode(self._instrument, Layer(priority = 5,
scale_up_button = self._button[31],
scale_down_button = self._button[30],
offset_up_button = self._button[11],
offset_down_button = self._button[10],
vertical_offset_up_button = self._button[9],
vertical_offset_down_button = self._button[8],))
self._instrument.drumpad_shift_layer = AddLayerMode(self._instrument, Layer(priority = 5,
scale_up_button = self._button[31],
scale_down_button = self._button[30],
drum_offset_up_button = self._button[11],
drum_offset_down_button = self._button[10],
drumpad_mute_button = self._button[9],
drumpad_solo_button = self._button[8],))
self._instrument._keypad.sequencer_layer = LayerMode(self._instrument._keypad, Layer(priority = 5,
playhead = self._playhead_element,
keypad_matrix = self._matrix.submatrix[:,:],))
self._instrument._keypad.split_layer = LayerMode(self._instrument._keypad, Layer(priority = 5,
keypad_matrix = self._matrix.submatrix[:,:],))
self._instrument._keypad.sequencer_shift_layer = LayerMode(self._instrument._keypad, Layer(priority = 5,
keypad_matrix = self._matrix.submatrix[:,:],
loop_selector_matrix = self._key_matrix.submatrix[4:8, 0],
quantization_buttons = self._key_matrix.submatrix[:7, 1],
follow_button = self._button[23]))
self._instrument._keypad.sequencer_session_layer = LayerMode(self._instrument._keypad, Layer(priority = 5,
playhead = self._playhead_element,))
self._instrument._keypad.split_session_layer = LayerMode(self._instrument._keypad, Layer(priority = 5,
split_matrix = self._key_matrix.submatrix[:16,:1]))
self._instrument._keypad.sequencer_session_shift_layer = LayerMode(self._instrument._keypad, Layer(priority = 5,
loop_selector_matrix = self._key_matrix.submatrix[4:8, :1],
quantization_buttons = self._key_matrix.submatrix[:7, 1:],
follow_button = self._button[23]))
self._instrument._drumpad.sequencer_layer = LayerMode(self._instrument._drumpad, Layer(priority = 5,
playhead = self._playhead_element,
drumpad_matrix = self._matrix.submatrix[:,:],))
self._instrument._drumpad.split_layer = LayerMode(self._instrument._drumpad, Layer(priority = 5,
drumpad_matrix = self._matrix.submatrix[:,:],
split_matrix = self._key_matrix.submatrix[:16,:1]))
self._instrument._drumpad.sequencer_shift_layer = LayerMode(self._instrument._drumpad, Layer(priority = 5,
drumpad_matrix = self._matrix.submatrix[:,:],
loop_selector_matrix = self._key_matrix.submatrix[4:8, :1],
quantization_buttons = self._key_matrix.submatrix[:7, 1:],
follow_button = self._button[23]))
self._instrument._drumpad.sequencer_session_layer = LayerMode(self._instrument._drumpad, Layer(priority = 5,
playhead = self._playhead_element,))
self._instrument._drumpad.split_session_layer = LayerMode(self._instrument._drumpad, Layer(priority = 5,
split_matrix = self._key_matrix.submatrix[:16,:1]))
self._instrument._drumpad.sequencer_session_shift_layer = LayerMode(self._instrument._drumpad, Layer(priority = 5,
loop_selector_matrix = self._key_matrix.submatrix[4:8, :1],
quantization_buttons = self._key_matrix.submatrix[:7, 1:],
follow_button = self._button[23]))
#self._instrument.set_session_mode_button(self._button[30])
def _setup_modes(self):
common = CompoundMode(self._mixer,
self._session_ring)
main_buttons=CompoundMode(self._G_mixer.main_buttons_layer,
self._session_navigation,
self._session_navigation.nav_layer,
self._transport,
self._transport.overdub_layer,
self._recorder,
self._recorder.main_layer,
self._device)
shifted_main_buttons=CompoundMode(self._G_mixer.shifted_buttons_layer,
self._recorder,
self._recorder.shift_layer,
self._session,
self._session.scene_launch_layer,
self._session.stop_clips_layer,
self._transport,
self._device)
main_faders=CompoundMode(self._G_mixer.main_faders_layer,
self._G_mixer.master_fader_layer)
main_dials=CompoundMode(self._view_control,
self._view_control.main_layer,
self._device_navigator,
self._device_navigator.select_dial_layer,
self.encoder_navigation_on)
shifted_dials=CompoundMode(self._session_navigation,
self._session_navigation.nav_dial_layer,
self._device_navigator,
self._device_navigator.select_dial_layer,
self.encoder_navigation_on)
self._modalt_mode = ModesComponent(name = 'ModAltMode')
self._modalt_mode.add_mode('disabled', None)
self._modalt_mode.add_mode('enabled', [tuple([self._enable_mod_alt, self._disable_mod_alt])], behaviour = CancellableBehaviourWithRelease(), cycle_mode_button_color = 'Mod.AltOn')
self._modalt_mode.selected_mode = 'disabled'
self._modalt_mode.set_enabled(False)
self._modalt_mode.layer = Layer(priority = 4, enabled_button = self._encoder_button[1])
self._modswitcher = ModesComponent(name = 'ModSwitcher')
self._modswitcher.add_mode('mod', [self.modhandler, self._modalt_mode, main_faders, self._G_mixer.main_knobs_layer, self._device, self._device_navigator.main_layer, main_dials, DelayMode(self.modhandler.update, delay = .5, parent_task_group = self._task_group)])
self._modswitcher.add_mode('instrument', [self._instrument.shift_button_layer, main_buttons, main_faders, self._G_mixer.main_knobs_layer, self._device, self._device_navigator.main_layer]) #self._instrument.shift_button_layer, self._optional_translations])
self._modswitcher.selected_mode = 'instrument'
self._modswitcher.set_enabled(False)
self._instrument._main_modes = ModesComponent(name = 'InstrumentModes')
self._instrument._main_modes.add_mode('disabled', [main_buttons, main_dials, self._device.main_layer, self._session, self._session, self._session.clip_launch_layer])
self._instrument._main_modes.add_mode('drumpad', [self._instrument._drumpad.sequencer_layer,
main_buttons,
self._device.main_layer,
main_dials])
self._instrument._main_modes.add_mode('drumpad_split', [self._instrument._drumpad.split_layer,
self._instrument._selected_session,
main_buttons,
self._device.main_layer,
main_dials])
self._instrument._main_modes.add_mode('drumpad_sequencer', [self._instrument._drumpad.sequencer_layer,
main_buttons,
self._device.main_layer,
main_dials])
self._instrument._main_modes.add_mode('drumpad_shifted', [self._instrument._drumpad.sequencer_shift_layer,
self._instrument.drumpad_shift_layer,
shifted_main_buttons,
self._device.main_layer,
shifted_dials])
self._instrument._main_modes.add_mode('drumpad_split_shifted', [self._instrument._drumpad.split_layer,
self._instrument.drumpad_shift_layer,
shifted_main_buttons,
self._device.main_layer,
shifted_dials])
self._instrument._main_modes.add_mode('drumpad_sequencer_shifted', [self._instrument._drumpad.sequencer_shift_layer,
self._instrument.drumpad_shift_layer,
shifted_main_buttons,
self._device.main_layer,
shifted_dials])
self._instrument._main_modes.add_mode('keypad', [self._instrument._keypad.sequencer_layer,
main_buttons,
self._device.main_layer,
main_dials])
self._instrument._main_modes.add_mode('keypad_split', [self._instrument._keypad.split_layer,
self._instrument._selected_session,
main_buttons,
self._device.main_layer,
main_dials])
self._instrument._main_modes.add_mode('keypad_sequencer', [self._instrument._keypad.sequencer_layer,
main_buttons,
self._device.main_layer,
main_dials])
self._instrument._main_modes.add_mode('keypad_shifted', [self._instrument._keypad.sequencer_shift_layer,
self._instrument.keypad_shift_layer,
shifted_main_buttons,
self._device.main_layer,
shifted_dials])
self._instrument._main_modes.add_mode('keypad_split_shifted', [self._instrument._keypad.split_layer,
self._instrument.keypad_shift_layer,
shifted_main_buttons,
self._device.main_layer,
shifted_dials])
self._instrument._main_modes.add_mode('keypad_sequencer_shifted', [self._instrument._keypad.sequencer_shift_layer,
self._instrument.keypad_shift_layer,
shifted_main_buttons,
self._device.main_layer,
shifted_dials])
self._instrument._main_modes.add_mode('drumpad_session', [self._instrument._drumpad.sequencer_session_layer,
main_buttons,
self._device.main_layer,
self._session,
DelayMode(self._session.clip_launch_layer, delay = .1),
main_dials])
self._instrument._main_modes.add_mode('drumpad_split_session', [self._instrument._drumpad.split_session_layer,
self._instrument._selected_session,
main_buttons,
self._device.main_layer,
self._session,
DelayMode(self._session.clip_launch_layer, delay = .1),
main_dials])
self._instrument._main_modes.add_mode('drumpad_sequencer_session', [self._instrument._drumpad.sequencer_session_layer,
main_buttons,
self._device.main_layer,
self._session,
DelayMode(self._session.clip_launch_layer, delay = .1),
main_dials])
self._instrument._main_modes.add_mode('drumpad_shifted_session', [self._instrument._drumpad.sequencer_session_shift_layer,
self._instrument.drumpad_shift_layer,
main_buttons,
self._device.main_layer,
self._session_zoom,
shifted_dials])
self._instrument._main_modes.add_mode('drumpad_split_shifted_session', [self._instrument._drumpad.split_session_layer,
self._instrument.drumpad_shift_layer,
shifted_main_buttons,
self._device.main_layer,
self._session_zoom,
shifted_dials])
self._instrument._main_modes.add_mode('drumpad_sequencer_shifted_session', [self._instrument._drumpad.sequencer_session_shift_layer,
self._instrument.drumpad_shift_layer,
shifted_main_buttons,
self._device.main_layer,
self._session_zoom,
shifted_dials])
self._instrument._main_modes.add_mode('keypad_session', [self._instrument._keypad.sequencer_session_layer,
main_buttons,
self._device.main_layer,
self._session,
DelayMode(self._session.clip_launch_layer, delay = .1),
main_dials])
self._instrument._main_modes.add_mode('keypad_split_session', [self._instrument._keypad.split_session_layer,
self._instrument._selected_session,
main_buttons,
self._device.main_layer,
self._session,
DelayMode(self._session.clip_launch_layer, delay = .1),
main_dials])
self._instrument._main_modes.add_mode('keypad_sequencer_session', [self._instrument._keypad.sequencer_session_layer,
main_buttons,
self._device.main_layer,
self._session,
DelayMode(self._session.clip_launch_layer, delay = .1),
main_dials])
self._instrument._main_modes.add_mode('keypad_shifted_session', [self._instrument._keypad.sequencer_session_shift_layer,
self._instrument.keypad_shift_layer,
shifted_main_buttons,
self._device.main_layer,
self._session_zoom,
shifted_dials])
self._instrument._main_modes.add_mode('keypad_split_shifted_session', [self._instrument._keypad.split_session_layer,
self._instrument.keypad_shift_layer,
shifted_main_buttons,
self._device.main_layer,
self._session_zoom,
shifted_dials])
self._instrument._main_modes.add_mode('keypad_sequencer_shifted_session', [self._instrument._keypad.sequencer_session_shift_layer,
self._instrument.keypad_shift_layer,
shifted_main_buttons,
self._device.main_layer,
self._session_zoom,
shifted_dials])
self._instrument._main_modes.add_mode('audioloop', [self._instrument.audioloop_layer,
main_buttons,
self._device.main_layer,
main_dials,
self._session,
DelayMode(self._session.clip_launch_layer, delay = .1)])
self._instrument._main_modes.add_mode('audioloop_shifted', [self._instrument.audioloop_layer,
shifted_main_buttons,
self._device.main_layer,
self._session_zoom,
shifted_dials])
#self._instrument._main_modes.add_mode('audioloop_shifted_session', [self._instrument.audioloop_layer, self._session, shifted_main_buttons, main_dials, shifted_dials])
self._instrument.register_component(self._instrument._main_modes)
self._instrument._main_modes.selected_mode = 'disabled'
self._instrument.set_enabled(True)
self._main_modes = ModesComponent(name = 'MainModes')
self._main_modes.add_mode('disabled', [self._background])
self._main_modes.add_mode('MixMode', [common,
self._instrument,
self._instrument.shift_button_layer,
self._G_mixer,
main_faders,
self._G_mixer.main_knobs_layer,
self._device,
self._device.main_layer,
self._device_navigator,
self._device_navigator.main_layer,
self._device_navigator.select_dial_layer])
self._main_modes.add_mode('ModSwitcher', [common,
main_faders,
main_dials,
self._G_mixer.main_knobs_layer,
self._view_control,
self._view_control.main_layer,
self._device_navigator,
self._device_navigator.select_dial_layer,
self.encoder_navigation_on,
self._modswitcher,
DelayMode(self._update_modswitcher, delay = .1)],
behaviour = ColoredCancellableBehaviourWithRelease(color = 'ModeButtons.ModSwitcher', off_color = 'ModeButtons.ModSwitcherDisabled'))
self._main_modes.add_mode('Translations', [common,
main_faders,
main_dials,
self._G_mixer.main_knobs_layer,
self._translations,
DelayMode(self._translations.selector_layer, delay = .1)],
behaviour = DefaultedBehaviour(default_mode = 'MixMode', color = 'ModeButtons.Translations', off_color = 'ModeButtons.TranslationsDisabled'))
self._main_modes.add_mode('DeviceSelector', [common,
self._device_selector,
DelayMode(self._device_selector.select_layer, delay = .1),
DelayMode(self.modhandler.lock_layer, delay = .1),
DelayMode(self._device_selector.assign_layer, delay = .5),
main_buttons,
main_dials,
main_faders,
self._G_mixer.main_knobs_layer,
self._device.main_layer,
self._device_navigator,
self._device_navigator.main_layer,
self._device_navigator.select_dial_layer],
behaviour = ColoredCancellableBehaviourWithRelease(color = 'ModeButtons.DeviceSelector', off_color = 'ModeButtons.DeviceSelectorDisabled'))
self._main_modes.layer = Layer(priority = 4, ModSwitcher_button = self._encoder_button[2], DeviceSelector_button = self._encoder_button[0], Translations_button = self._encoder_button[3]) #,
self._main_modes.selected_mode = 'disabled'
self._main_modes.set_enabled(True)
self._test.subject = self._instrument._main_modes
#a
class Alias(LividControlSurface):
_sysex_id = 11
_model_name = 'Alias'
_color_type = 'OhmRGB'
def __init__(self, c_instance):
super(Alias, self).__init__(c_instance)
self._skin = Skin(AliasColors)
with self.component_guard():
self._setup_controls()
self._setup_m4l_interface()
self._setup_session_control()
self._setup_mixer_control()
self._setup_mixer_nav()
def _setup_controls(self):
is_momentary = True
optimized = True
resource = PrioritizedResource
self._fader = [
MonoEncoderElement(msg_type=MIDI_CC_TYPE,
channel=CHANNEL,
identifier=ALIAS_FADERS[index],
name='Fader_' + str(index),
num=index,
script=self,
optimized_send_midi=optimized,
resource_type=resource,
monobridge=self._monobridge)
for index in range(9)
]
self._button = [
MonoButtonElement(is_momentary=is_momentary,
msg_type=MIDI_NOTE_TYPE,
channel=CHANNEL,
identifier=ALIAS_BUTTONS[index],
name='Button_' + str(index),
script=self,
skin=self._skin,
optimized_send_midi=optimized,
resource_type=resource,
monobridge=self._monobridge)
for index in range(16)
]
self._dial = [
MonoEncoderElement(msg_type=MIDI_CC_TYPE,
channel=CHANNEL,
identifier=ALIAS_DIALS[index],
name='Dial_' + str(index),
num=index + 8,
script=self) for index in range(16)
]
self._encoder = MonoEncoderElement(msg_type=MIDI_CC_TYPE,
channel=CHANNEL,
identifier=ALIAS_ENCODER,
name='Encoder',
script=self,
optimized_send_midi=optimized,
resource_type=resource,
monobridge=self._monobridge)
self._fader_matrix = ButtonMatrixElement(name='FaderMatrix',
rows=[self._fader[:8]])
self._button_matrix = ButtonMatrixElement(
name='ButtonMatrix', rows=[self._button[:8], self._button[8:]])
self._dial_matrix = ButtonMatrixElement(
name='DialMatrix', rows=[self._dial[:8], self._dial[8:]])
def _setup_m4l_interface(self):
self._m4l_interface = M4LInterfaceComponent(
controls=self.controls, component_guard=self.component_guard)
self.get_control_names = self._m4l_interface.get_control_names
self.get_control = self._m4l_interface.get_control
self.grab_control = self._m4l_interface.grab_control
self.release_control = self._m4l_interface.release_control
def _setup_mixer_control(self):
self._mixer = MonoMixerComponent(name='Mixer',
tracks_provider=self._session_ring,
track_assigner=SimpleTrackAssigner(),
invert_mute_feedback=True,
auto_name=True,
enable_skinning=True)
self._mixer.layer = Layer(
volume_controls=self._fader_matrix,
send_controls=self._dial_matrix,
mute_buttons=self._button_matrix.submatrix[:, 0],
arm_buttons=self._button_matrix.submatrix[:, 1])
self._mixer.master_strip().layer = Layer(volume_control=self._fader[8])
self._mixer.set_enabled(True)
self.song.view.selected_track = self._mixer.channel_strip(0)._track
def _setup_session_control(self):
self._session_ring = SessionRingComponent(
num_tracks=8,
num_scenes=1,
tracks_to_use=lambda: self.song.visible_tracks + self.song.
return_tracks)
self._session_ring.set_enabled(True)
def _setup_mixer_nav(self):
self._nav_change.subject = self._encoder
@listens('value')
def _nav_change(self, value):
self._session_ring.set_offsets(
int((float(value) / float(127)) *
max(8,
len(self._session_ring.tracks_to_use()) - 8)),
self._session_ring.scene_offset)
class DS1(LividControlSurface):
_sysex_id = 16
_model_name = 'DS1'
def __init__(self, c_instance):
super(DS1, self).__init__(c_instance)
self._skin = Skin(DS1Colors)
with self.component_guard():
self._define_sysex()
self._setup_controls()
self._setup_background()
self._setup_m4l_interface()
self._setup_session_control()
self._setup_mixer_control()
self._setup_transport_control()
self._setup_device_control()
self._setup_session_recording_component()
self._setup_main_modes()
def _initialize_script(self):
super(DS1, self)._initialize_script()
self._main_modes.set_enabled(True)
self._main_modes.selected_mode = 'Main'
def _initialize_hardware(self):
super(DS1, self)._initialize_hardware()
self.local_control_off.enter_mode()
self.encoder_absolute_mode.enter_mode()
self.encoder_speed_sysex.enter_mode()
def _define_sysex(self):
self.encoder_speed_sysex = SendLividSysexMode(livid_settings = self._livid_settings, call = 'set_encoder_mapping', message = ENCODER_SPEED)
self.encoder_absolute_mode = SendLividSysexMode(livid_settings = self._livid_settings, call = 'set_encoder_encosion_mode', message = [2])
self.local_control_off = SendLividSysexMode(livid_settings = self._livid_settings, call = 'set_local_control', message = [0])
def _setup_controls(self):
is_momentary = True
optimized = True
resource = PrioritizedResource
self._fader = [MonoEncoderElement(mapping_feedback_delay = -1, msg_type = MIDI_CC_TYPE, channel = CHANNEL, identifier = DS1_FADERS[index], name = 'Fader_' + str(index), num = index, script = self, optimized_send_midi = optimized, resource_type = resource) for index in range(8)]
self._dial = [[MonoEncoderElement(mapping_feedback_delay = -1, msg_type = MIDI_CC_TYPE, channel = CHANNEL, identifier = DS1_DIALS[x][y], name = 'Dial_' + str(x) + '_' + str(y), num = x + (y*5), script = self, optimized_send_midi = optimized, resource_type = resource) for x in range(8)] for y in range(5)]
self._side_dial = [MonoEncoderElement(mapping_feedback_delay = -1, msg_type = MIDI_CC_TYPE, channel = CHANNEL, identifier = DS1_SIDE_DIALS[x], name = 'Side_Dial_' + str(x), num = x, script = self, optimized_send_midi = optimized, resource_type = resource) for x in range(4)]
self._encoder = [MonoEncoderElement(mapping_feedback_delay = -1, msg_type = MIDI_CC_TYPE, channel = CHANNEL, identifier = DS1_ENCODERS[x], name = 'Encoder_' + str(x), num = x, script = self, optimized_send_midi = optimized, resource_type = resource) for x in range(4)]
self._encoder_button = [MonoButtonElement(is_momentary = is_momentary, msg_type = MIDI_NOTE_TYPE, channel = CHANNEL, identifier = DS1_ENCODER_BUTTONS[index], name = 'EncoderButton_' + str(index), script = self, skin = self._skin, optimized_send_midi = optimized, resource_type = resource) for index in range(4)]
self._master_fader = MonoEncoderElement(msg_type = MIDI_CC_TYPE, channel = CHANNEL, identifier = DS1_MASTER, name = 'MasterFader', num = 0, script = self, optimized_send_midi = optimized, resource_type = resource)
self._button = [MonoButtonElement(is_momentary = is_momentary, msg_type = MIDI_NOTE_TYPE, channel = CHANNEL, identifier = DS1_BUTTONS[index], name = 'Button_' + str(index), script = self, skin = self._skin, optimized_send_midi = optimized, resource_type = resource) for index in range(16)]
self._grid = [[MonoButtonElement(is_momentary = is_momentary, msg_type = MIDI_NOTE_TYPE, channel = CHANNEL, identifier = DS1_GRID[x][y], name = 'Button_' + str(x) + '_' + str(y), script = self, skin = self._skin, optimized_send_midi = optimized, resource_type = resource) for x in range(3)] for y in range(3)]
self._dummy = [MonoEncoderElement(msg_type = MIDI_CC_TYPE, channel = CHANNEL, identifier = 120+x, name = 'Dummy_Dial_' + str(x), num = x, script = self, optimized_send_midi = optimized, resource_type = resource) for x in range(5)]
self._fader_matrix = ButtonMatrixElement(name = 'FaderMatrix', rows = [self._fader])
self._top_buttons = ButtonMatrixElement(name = 'TopButtonMatrix', rows = [self._button[:8]])
self._bottom_buttons = ButtonMatrixElement(name = 'BottomButtonMatrix', rows = [self._button[8:]])
self._dial_matrix = ButtonMatrixElement(name = 'DialMatrix', rows = self._dial)
self._side_dial_matrix = ButtonMatrixElement(name = 'SideDialMatrix', rows = [self._side_dial])
self._encoder_matrix = ButtonMatrixElement(name = 'EncoderMatrix', rows = [self._encoder])
self._encoder_button_matrix = ButtonMatrixElement(name = 'EncoderButtonMatrix', rows = [self._encoder_button])
self._grid_matrix = ButtonMatrixElement(name = 'GridMatrix', rows = self._grid)
self._selected_parameter_controls = ButtonMatrixElement(name = 'SelectedParameterControls', rows = [self._dummy + self._encoder[:1] + self._encoder[2:]])
def _setup_background(self):
self._background = BackgroundComponent(name = 'Background')
self._background.layer = Layer(priority = 0, fader_matrix = self._fader_matrix,
top_buttons = self._top_buttons,
bottom_buttons = self._bottom_buttons,
dial_matrix = self._dial_matrix,
side_dial_matrix = self._side_dial_matrix,
encoder_button_matrix = self._encoder_button_matrix,
grid_matrix = self._grid_matrix)
self._background.set_enabled(True)
def _setup_autoarm(self):
self._auto_arm = AutoArmComponent(name='Auto_Arm')
self._auto_arm.can_auto_arm_track = self._can_auto_arm_track
def _tracks_to_use(self):
return self.song.visible_tracks + self.song.return_tracks
def _setup_session_control(self):
self._session_ring = SessionRingComponent(num_tracks = 8, num_scenes = 1, tracks_to_use = self._tracks_to_use)
self._session_ring.set_enabled(True)
self._session_navigation = DS1SessionNavigationComponent(name = 'SessionNavigation', session_ring = self._session_ring)
self._session_navigation._vertical_banking.scroll_up_button.color = 'Session.NavigationButtonOn'
self._session_navigation._vertical_banking.scroll_down_button.color = 'Session.NavigationButtonOn'
self._session_navigation._horizontal_banking.scroll_up_button.color = 'Session.NavigationButtonOn'
self._session_navigation._horizontal_banking.scroll_down_button.color = 'Session.NavigationButtonOn'
self._session_navigation.layer = Layer(priority = 4, track_select_dial = ComboElement(control = self._encoder[1], modifier = [self._encoder_button[1]] ), up_button = self._grid[0][1], down_button = self._grid[0][2])
self._session_navigation.set_enabled(False)
self._session = DS1SessionComponent(session_ring = self._session_ring, auto_name = True)
hasattr(self._session, '_enable_skinning') and self._session._enable_skinning()
self._session.layer = Layer(priority = 4, scene_launch_buttons = self._grid_matrix.submatrix[1:2, 1:2])
self._session.clips_layer = AddLayerMode(self._session, Layer(priority = 4, clip_launch_buttons = self._top_buttons, stop_track_clip_buttons = self._bottom_buttons))
self._session.set_enabled(False)
def _setup_mixer_control(self):
self._mixer = MonoMixerComponent(name = 'Mixer', num_returns = 2, tracks_provider = self._session_ring, track_assigner = simple_track_assigner, invert_mute_feedback = True, auto_name = True, enable_skinning = True)
self._mixer.master_strip().set_volume_control(self._master_fader)
self._mixer.set_prehear_volume_control(self._side_dial[3])
self._mixer.layer = Layer(volume_controls = self._fader_matrix, track_select_dial = self._encoder[1])
self._strip = [self._mixer.channel_strip(index) for index in range(8)]
for index in range(8):
self._strip[index].layer = Layer(priority = 4, parameter_controls = self._dial_matrix.submatrix[index:index+1, :])
self._mixer.selected_strip().layer = Layer(priority = 4, parameter_controls = self._selected_parameter_controls)
self._mixer.master_strip().layer = Layer(priority = 4, parameter_controls = self._side_dial_matrix.submatrix[:3, :])
self._mixer.main_layer = AddLayerMode(self._mixer, Layer(priority = 4, solo_buttons = self._bottom_buttons, mute_buttons = self._top_buttons))
self._mixer.select_layer = AddLayerMode(self._mixer, Layer(priority = 4, arm_buttons = self._bottom_buttons, track_select_buttons = self._top_buttons))
self.song.view.selected_track = self._mixer.channel_strip(0)._track
self._mixer.set_enabled(False)
def _setup_transport_control(self):
self._transport = DS1TransportComponent()
self._transport.name = 'Transport'
self._transport._record_toggle.view_transform = lambda value: 'Transport.RecordOn' if value else 'Transport.RecordOff'
self._transport.layer = Layer(priority = 4, stop_button = self._grid[1][0], play_button = self._grid[0][0], record_button = self._grid[2][0])
self._transport.set_enabled(True)
def _setup_device_control(self):
self._device = DeviceComponent(name = 'Device_Component', device_provider = self._device_provider, device_bank_registry = DeviceBankRegistry())
self._device_navigator = DeviceNavigator(self._device_provider, self._mixer, self)
self._device_navigator.name = 'Device_Navigator'
def _setup_session_recording_component(self):
self._clip_creator = ClipCreator()
self._clip_creator.name = 'ClipCreator'
self._recorder = SessionRecordingComponent(ViewControlComponent())
self._recorder.set_enabled(True)
self._recorder.layer = Layer(priority = 4, automation_button = self._grid[1][2], record_button = self._grid[2][1],)
def _setup_m4l_interface(self):
self._m4l_interface = M4LInterfaceComponent(controls=self.controls, component_guard=self.component_guard, priority = 10)
self._m4l_interface.name = "M4LInterface"
self.get_control_names = self._m4l_interface.get_control_names
self.get_control = self._m4l_interface.get_control
self.grab_control = self._m4l_interface.grab_control
self.release_control = self._m4l_interface.release_control
def _setup_translations(self):
controls = []
for control in self.controls:
controls.append(control)
self._translations = TranslationComponent(controls, 10)
self._translations.name = 'TranslationComponent'
self._translations.set_enabled(False)
def _setup_main_modes(self):
self._main_modes = ModesComponent(name = 'MainModes')
self._main_modes.add_mode('Main', [self._mixer, self._mixer.main_layer, self._session, self._session_navigation], cycle_mode_button_color = 'ModeButtons.Main')
self._main_modes.add_mode('Select', [self._mixer, self._mixer.select_layer, self._session, self._session_navigation], cycle_mode_button_color = 'ModeButtons.Select')
self._main_modes.add_mode('Clips', [self._mixer, self._session, self._session.clips_layer, self._session_navigation], cycle_mode_button_color = 'ModeButtons.Clips')
self._main_modes.layer = Layer(priority = 4, cycle_mode_button = self._grid[2][2])
self._main_modes.selected_mode = 'Main'
self._main_modes.set_enabled(False)
def _can_auto_arm_track(self, track):
routing = track.current_input_routing
return routing == 'Ext: All Ins' or routing == 'All Ins' or routing.startswith('DS1 Input')
#self._main_modes.selected_mode in ['Sends', 'Device'] and
# a
class Cntrlr(LividControlSurface):
__module__ = __name__
__doc__ = " Monomodular controller script for Livid CNTRLR "
_sysex_id = 8
_model_name = 'Cntrlr'
_host_name = 'Cntrlr'
_version_check = 'b996'
monomodular = None
device_provider_class = ModDeviceProvider
def __init__(self, *a, **k):
super(Cntrlr, self).__init__(*a, **k)
self._skin = Skin(CntrlrColors)
self._device_selection_follows_track_selection = FOLLOW
with self.component_guard():
self._setup_monobridge()
self._setup_controls()
self._define_sysex()
self._setup_background()
self._setup_translations()
#self._setup_autoarm()
self._setup_session_control()
self._setup_send_reset_controls()
self._setup_mixer_control()
self._setup_transport_control()
self._setup_device_control()
self._setup_mod_device_control()
self._setup_device_selector()
#self._setup_session_recording_component()
#self._setup_viewcontrol()
#self._setup_instrument()
self._setup_mod()
self._setup_modswitcher()
self._setup_translations()
self._setup_modes()
self._setup_m4l_interface()
self._on_device_changed.subject = self.song
#self.set_feedback_channels(range(14, 15))
def _initialize_script(self):
super(Cntrlr, self)._initialize_script()
self._connected = True
self._main_modes.selected_mode = 'MixMode'
self._main_modes.set_enabled(True)
#self._instrument.set_enabled(True)
#self._main_modes.selected_mode = 'disabled'
#self._main_modes.selected_mode = 'MixMode'
self._session_ring._update_highlight()
self._session_ring.track_offset = 0
if liveobj_valid(self.song.visible_tracks[0]):
self.song.view.selected_track = self.song.visible_tracks[0]
def _initialize_hardware(self):
super(Cntrlr, self)._initialize_hardware()
for index in range(4):
self._encoder[index].send_value(0)
def port_settings_changed(self):
self._main_modes.selected_mode = 'disabled'
super(Cntrlr, self).port_settings_changed()
def _setup_monobridge(self):
self._monobridge = MonoBridgeElement(self)
self._monobridge.name = 'MonoBridge'
def _setup_controls(self):
is_momentary = True
optimized = True
resource = PrioritizedResource
self._fader = [MonoEncoderElement(msg_type = MIDI_CC_TYPE, channel = CHANNEL, identifier = CNTRLR_FADERS[index], name = 'Fader_' + str(index), num = index, script = self, optimized_send_midi = optimized, resource_type = resource, monobridge = self._monobridge) for index in range(8)]
self._dial_left = [MonoEncoderElement(msg_type = MIDI_CC_TYPE, channel = CHANNEL, identifier = CNTRLR_KNOBS_LEFT[index], name = 'Dial_Left_' + str(index), num = CNTRLR_KNOBS_LEFT[index], script = self, optimized_send_midi = optimized, resource_type = resource, monobridge = self._monobridge) for index in range(12)]
self._dial_right = [MonoEncoderElement(msg_type = MIDI_CC_TYPE, channel = CHANNEL, identifier = CNTRLR_KNOBS_RIGHT[index], name = 'Dial_Right_' + str(index), num = CNTRLR_KNOBS_RIGHT[index], script = self, optimized_send_midi = optimized, resource_type = resource, monobridge = self._monobridge) for index in range(12)]
self._encoder = [CodecEncoderElement(msg_type = MIDI_CC_TYPE, channel = CHANNEL, identifier = CNTRLR_DIALS[index], name = 'Encoder_' + str(index), num = CNTRLR_DIALS[index], script = self, optimized_send_midi = optimized, resource_type = resource, monobridge = self._monobridge) for index in range(12)]
self._encoder_button = [MonoButtonElement(is_momentary = is_momentary, msg_type = MIDI_NOTE_TYPE, channel = CHANNEL, identifier = CNTRLR_DIAL_BUTTONS[index], name = 'Encoder_Button_' + str(index), script = self, skin = self._skin, color_map = COLOR_MAP, optimized_send_midi = optimized, resource_type = resource, monobridge = self._monobridge) for index in range(12)]
self._grid = [MonoButtonElement(is_momentary = is_momentary, msg_type = MIDI_NOTE_TYPE, channel = CHANNEL, identifier = CNTRLR_GRID[index], name = 'Grid_' + str(index), script = self, skin = self._skin, color_map = COLOR_MAP, optimized_send_midi = optimized, resource_type = resource, monobridge = self._monobridge) for index in range(16)]
self._button = [MonoButtonElement(is_momentary = is_momentary,msg_type = MIDI_NOTE_TYPE, channel = CHANNEL, identifier = CNTRLR_BUTTONS[index], name = 'Button_' + str(index), script = self, skin = self._skin, color_map = COLOR_MAP, optimized_send_midi = optimized, resource_type = resource, monobridge = self._monobridge) for index in range(32)]
self._knobs = self._dial_left + self._dial_right
self._fader_matrix = ButtonMatrixElement(name = 'Fader_Matrix', rows = [self._fader])
self._matrix = ButtonMatrixElement(name = 'Matrix', rows = [self._grid[index*4:(index*4)+4] for index in range(4)])
self._knob_left_matrix = ButtonMatrixElement(name = 'Knob_Left_Matrix', rows = [self._dial_left[index*4:(index*4)+4] for index in range(3)])
self._knob_right_matrix = ButtonMatrixElement(name = 'Knob_Right_Matrix', rows = [self._dial_right[index*4:(index*4)+4] for index in range(3)])
self._dial_matrix = ButtonMatrixElement(name = 'Dial_Matrix', rows = [self._encoder[index*4:(index*4)+4] for index in range(3)])
self._dial_button_matrix = ButtonMatrixElement(name = 'Dial_Button_Matrix', rows = [self._encoder_button[index*4:(index*4)+4] for index in range(1,3)])
self._key_matrix = ButtonMatrixElement(name = 'Key_Matrix', rows = [self._button[0:16], self._button[16:32]])
self._translated_controls = self._grid + self._button
def _setup_background(self):
self._background = BackgroundComponent(name = 'Background')
self._background.layer = Layer(priority = 3, matrix = self._matrix.submatrix[:,:], faders = self._fader_matrix.submatrix[:,:], left_knobs = self._knob_left_matrix.submatrix[:,:], right_knobs = self._knob_right_matrix.submatrix[:,:], dials = self._dial_matrix, dial_buttons = self._dial_button_matrix.submatrix[:,:], keys = self._key_matrix.submatrix[:,:])
self._background.set_enabled(True)
def _define_sysex(self):
self.encoder_navigation_on = SendLividSysexMode(livid_settings = self._livid_settings, call = 'set_encoder_encosion_mode', message = [0, 0, 0, 0])
def _setup_transport_control(self):
self._transport = CntrlrTransportComponent(name = 'Transport')
self._transport._play_toggle.view_transform = lambda value: 'Transport.PlayOn' if value else 'Transport.PlayOff'
self._transport._record_toggle.view_transform = lambda value: 'Transport.RecordOn' if value else 'Transport.RecordOff'
self._transport.layer = Layer(priority = 4,
play_button = self._button[28],
stop_button = self._button[29],
record_button = self._button[30])
self._transport.set_enabled(False)
def _setup_autoarm(self):
self._auto_arm = CntrlrAutoArmComponent(name='Auto_Arm')
#self._auto_arm._update_notification = lambda a: None
self._auto_arm.can_auto_arm_track = self._can_auto_arm_track
def _setup_session_recording_component(self):
self._clip_creator = ClipCreator()
self._clip_creator.name = 'ClipCreator'
self._recorder = FixedLengthSessionRecordingComponent(clip_creator = self._clip_creator, view_controller = ViewControlComponent(), name = 'SessionRecorder') # is_enabled = False)
self._recorder.main_layer = AddLayerMode(self._recorder, Layer(priority = 4, record_button = self._button[29]))
self._recorder.shift_layer = AddLayerMode(self._recorder, Layer(priority = 4, automation_button = self._button[29]))
self._recorder.set_enabled(False)
def _setup_session_control(self):
self._session_ring = SessionRingComponent(num_tracks = 4, num_scenes = 4)
self._session_ring.set_enabled(False)
self._session_navigation = CntrlrSessionNavigationComponent(name = 'SessionNavigation', session_ring = self._session_ring)
self._session_navigation._vertical_banking.scroll_up_button.color = 'Session.NavigationButtonOn'
self._session_navigation._vertical_banking.scroll_down_button.color = 'Session.NavigationButtonOn'
self._session_navigation._horizontal_banking.scroll_up_button.color = 'Session.NavigationButtonOn'
self._session_navigation._horizontal_banking.scroll_down_button.color = 'Session.NavigationButtonOn'
self._session_navigation._vertical_paginator.scroll_up_button.color = 'Session.PageNavigationButtonOn'
self._session_navigation._vertical_paginator.scroll_down_button.color = 'Session.PageNavigationButtonOn'
self._session_navigation._horizontal_paginator.scroll_up_button.color = 'Session.PageNavigationButtonOn'
self._session_navigation._horizontal_paginator.scroll_down_button.color = 'Session.PageNavigationButtonOn'
self._session_navigation.layer = Layer(priority = 4,
down_button = self._button[14],
up_button = self._button[15],
left_button = self._button[12],
right_button = self._button[13])
self._session_navigation.set_enabled(False)
self._session = SessionComponent(session_ring = self._session_ring, auto_name = True)
hasattr(self._session, '_enable_skinning') and self._session._enable_skinning()
self._session.layer = Layer(priority = 4, clip_launch_buttons = self._matrix.submatrix[:,:])
self._session.set_enabled(False)
self._session_zoom = SessionOverviewComponent(name = 'SessionZoom', session_ring = self._session_ring, enable_skinning = True)
self._session_zoom.layer = Layer(priority = 4, button_matrix = self._matrix.submatrix[:,:])
self._session_zoom.set_enabled(False)
def _setup_send_reset_controls(self):
self._send_reset = ResetSendsComponent(script = self)
self._send_reset.layer = Layer(priority = 4, buttons = self._key_matrix.submatrix[8:12, :1])
self._send_reset.set_enabled(False)
def _setup_mixer_control(self):
self._mixer = MonoMixerComponent(name = 'Mixer', num_returns = 2,tracks_provider = self._session_ring, track_assigner = SimpleTrackAssigner(), invert_mute_feedback = True, auto_name = True, enable_skinning = True)
self._mixer.fader_layer = AddLayerMode(self._mixer, Layer(priority = 4, volume_controls = self._fader_matrix.submatrix[:4, :],
return_controls = self._fader_matrix.submatrix[4:6, :],
prehear_volume_control = self._fader[6],
send_controls = self._knob_left_matrix,
eq_gain_controls = self._knob_right_matrix))
self._mixer.button_layer = AddLayerMode(self._mixer, Layer(priority = 4, mute_buttons = self._key_matrix.submatrix[:4, 1:],
stop_clip_buttons = self._key_matrix.submatrix[8:12, 1:],
solo_buttons = self._key_matrix.submatrix[:4, :1],
arm_buttons = self._key_matrix.submatrix[4:8, :1],
track_select_buttons = self._key_matrix.submatrix[4:8, 1:],))
self._mixer.master_strip().layer = Layer(priority = 4, volume_control = self._fader[7],)
self._mixer.set_enabled(False)
def _setup_device_control(self):
self._device_selection_follows_track_selection = FOLLOW
self._device = CntrlrDeviceComponent(script = self, name = 'Device_Component', device_provider = self._device_provider, device_bank_registry = DeviceBankRegistry())
self._device.layer = Layer(priority = 4, parameter_controls = self._dial_matrix.submatrix[:, 1:],
on_off_button = self._encoder_button[4],
bank_prev_button = self._encoder_button[8],
bank_next_button = self._encoder_button[9],)
#lock_button = self._encoder_button[7])
self._device.set_enabled(False)
self._device_navigator = DeviceNavigator(self._device_provider, self._mixer, self)
self._device_navigator.name = 'Device_Navigator'
self._device_navigator.layer = Layer(priority = 4,
prev_button = self._encoder_button[10],
next_button = self._encoder_button[11],)
self._device_navigator.set_enabled(False)
def _setup_mod_device_control(self):
self._mod_device = SpecialCntrlrDeviceComponent(script = self, name = 'Device_Component', device_provider = self._device_provider, device_bank_registry = DeviceBankRegistry())
self._mod_device.layer = Layer(priority = 4, parameter_controls = self._dial_matrix.submatrix[:, :],)
self._mod_device.set_enabled(False)
def _setup_device_selector(self):
self._device_selector = CntrlrDeviceSelector(self)
self._device_selector.name = 'Device_Selector'
#self._device_selector.select_layer = AddLayerMode(self._device_selector, Layer(priority = 6 , matrix = self._matrix.submatrix[:, :]))
#self._device_selector.select_layer = AddLayerMode(self._device_selector, Layer(priority = 6, matrix = ButtonMatrixElement(rows = [self._grid[:4],self._grid[4:8],self._grid[8:12],self._grid[12:14]])))
#self._device_selector.assign_layer = AddLayerMode(self._device_selector, Layer(priority = 7, assign_button = self._grid[14]))
self._device_selector.set_enabled(False)
def _setup_translations(self):
self._translations = TranslationComponent(self._translated_controls, user_channel_offset = 4, channel = 4) # is_enabled = False)
self._translations.name = 'TranslationComponent'
self._translations.layer = Layer(priority = 10,)
self._translations._color = 127
self._translations.selector_layer = AddLayerMode(self._translations, Layer(priority = 10, channel_selector_buttons = self._dial_button_matrix))
self._translations.set_enabled(False)
#self._optional_translations = CompoundMode(TranslationComponent(controls = self._fader, user_channel_offset = 4, channel = 4, name = 'FaderTranslation', is_enabled = False, layer = Layer(priority = 10)) if FADER_BANKING else None
#TranslationComponent(controls = self._knobs, user_channel_offset = 4, channel = 4, name = 'DialTranslation', is_enabled = False, layer = Layer(priority = 10)) if DIAL_BANKING else None)
def _setup_mod(self):
self.monomodular = get_monomodular(self)
self.monomodular.name = 'monomodular_switcher'
self.modhandler = CntrlrModHandler(self, device_provider = self._device_provider) # is_enabled = False)
self.modhandler.name = 'ModHandler'
self.modhandler.lock_layer = AddLayerMode(self.modhandler, Layer(priority=8, lock_button=self._grid[15]))
self.modhandler.layer = Layer(priority = 8,
cntrlr_encoder_button_grid = self._dial_button_matrix.submatrix[:,:],
cntrlr_grid = self._matrix.submatrix[:,:],
cntrlr_keys = self._key_matrix.submatrix[:,:],)
#parameter_controls = self._dial_matrix.submatrix[:,:])
self.modhandler.set_enabled(False)
def _setup_modswitcher(self):
self._modswitcher = ModesComponent(name = 'ModSwitcher') # is_enabled = False)
self._modswitcher.set_enabled(False)
def _setup_viewcontrol(self):
self._view_control = CntrlrViewControlComponent(name='View_Control')
self._view_control.main_layer = AddLayerMode(self._view_control, Layer(scene_select_dial = self._encoder[2],
track_select_dial = self._encoder[3],))
#self._view_control.main_layer = AddLayerMode(self._view_control, Layer(prev_track_button=self._button[24],
# next_track_button= self._button[25],
# next_scene_button=self._button[27],
# prev_scene_button = self._button[26]))
self._view_control.set_enabled(False)
def _setup_modes(self):
self._modswitcher = ModesComponent(name = 'ModSwitcher')
self._modswitcher.add_mode('mod', [self._mixer,
self._mixer.fader_layer,
self.modhandler,
self._mod_device,
self._device_selector,])
self._modswitcher.add_mode('translations', [self._translations,
self._device,
self._mixer,
self._mixer.fader_layer,
self._device_navigator,
self._device_selector])
self._modswitcher.selected_mode = 'translations'
self._modswitcher.set_enabled(False)
self._session_modes = ModesComponent(name = 'SessionModes')
self._session_modes.add_mode('Launch', [self._session])
self._session_modes.add_mode('Zoom', [self._session_zoom])
self._session_modes.layer = Layer(priority = 4, cycle_mode_button = self._button[31])
self._session_modes.set_enabled(False)
self._main_modes = ModesComponent(name = 'MainModes')
self._main_modes.add_mode('disabled', [self._background, self.encoder_navigation_on])
self._main_modes.add_mode('MixMode', [self._mixer,
self._mixer.fader_layer,
self._mixer.button_layer,
self._session_modes,
self._session_navigation,
self._session_ring,
self._device,
self._device_navigator,
self._send_reset,
self._transport])
self._main_modes.add_mode('ModMode1', [self._modswitcher,
self._choose_mod,
DelayMode(self._update_modswitcher, delay = .1, parent_task_group = self._task_group),
DelayMode(self.modhandler.update, delay = .2, parent_task_group = self._task_group)],
behaviour = DefaultedBehaviour(default_mode = 'MixMode'))
self._main_modes.add_mode('ModMode2', [self._modswitcher,
self._choose_mod,
DelayMode(self._update_modswitcher, delay = .1, parent_task_group = self._task_group),
DelayMode(self.modhandler.update, delay = .2, parent_task_group = self._task_group)],
behaviour = DefaultedBehaviour(default_mode = 'MixMode'))
self._main_modes.add_mode('ModMode3', [self._modswitcher,
self._choose_mod,
DelayMode(self._update_modswitcher, delay = .1, parent_task_group = self._task_group),
DelayMode(self.modhandler.update, delay = .2, parent_task_group = self._task_group)],
behaviour = DefaultedBehaviour(default_mode = 'MixMode'))
self._main_modes.add_mode('ModMode4', [self._modswitcher,
self._choose_mod,
DelayMode(self._update_modswitcher, delay = .1, parent_task_group = self._task_group),
DelayMode(self.modhandler.update, delay = .2, parent_task_group = self._task_group)],
behaviour = DefaultedBehaviour(default_mode = 'MixMode'))
self._main_modes.layer = Layer(priority = 4, ModMode1_button = self._encoder_button[0], ModMode2_button = self._encoder_button[1], ModMode3_button = self._encoder_button[2], ModMode4_button = self._encoder_button[3]) #,
self._main_modes.selected_mode = 'disabled'
self._main_modes.set_enabled(True)
def _choose_mod(self):
modes = ('ModMode1', 'ModMode2', 'ModMode3', 'ModMode4')
mode = self._main_modes.selected_mode
debug('choose_mod:', self._main_modes.selected_mode)
if mode in modes:
index = modes.index(mode)
self._translations._channel = index + self._translations._user_channel_offset
self._translations.update()
self._device_selector.select_device(index)
def _setup_m4l_interface(self):
self._m4l_interface = M4LInterfaceComponent(controls=self.controls, component_guard=self.component_guard, priority = 10)
self._m4l_interface.name = "M4LInterface"
self.get_control_names = self._m4l_interface.get_control_names
self.get_control = self._m4l_interface.get_control
self.grab_control = self._m4l_interface.grab_control
self.release_control = self._m4l_interface.release_control
def _can_auto_arm_track(self, track):
routing = track.current_input_routing
return routing == 'Ext: All Ins' or routing == 'All Ins' or routing.startswith('Cntrlr Input')
@listens('appointed_device')
def _on_device_changed(self):
debug('appointed device changed, script')
#self._main_modes.selected_mode is 'ModSwitcher' and self._update_modswitcher()
def _on_selected_track_changed(self):
super(Cntrlr, self)._on_selected_track_changed()
#self._drum_group_finder.device_parent = self.song.veiw.selected_track
#if not len(self.song.view.selected_track.devices):
# self._main_modes.selected_mode is 'ModSwitcher' and self._update_modswitcher()
def _update_modswitcher(self):
debug('update modswitcher', self.modhandler.active_mod())
if self.modhandler.active_mod() and self._device_selector.has_mod_entry(['ModMode1', 'ModMode2', 'ModMode3', 'ModMode4'].index(self._main_modes.selected_mode)):
self._modswitcher.selected_mode = 'mod'
else:
self._modswitcher.selected_mode = 'translations'
def update_display(self):
super(Cntrlr, self).update_display()
self.modhandler.send_ring_leds()
def restart_monomodular(self):
#debug('restart monomodular')
self.modhandler.disconnect()
with self.component_guard():
self._setup_mod()
class Cntrlr(LividControlSurface):
__module__ = __name__
__doc__ = " Monomodular controller script for Livid CNTRLR "
_sysex_id = 8
_model_name = 'Cntrlr'
_host_name = 'Cntrlr'
monomodular = None
device_provider_class = ModDeviceProvider
def __init__(self, *a, **k):
super(Cntrlr, self).__init__(*a, **k)
self._skin = Skin(CntrlrColors)
self._device_selection_follows_track_selection = FOLLOW
with self.component_guard():
self._setup_controls()
self._define_sysex()
self._setup_background()
#self._setup_autoarm()
self._setup_viewcontrol()
self._setup_session_control()
self._setup_mixer_control()
self._setup_transport_control()
#self._setup_device_control()
#self._setup_device_selector()
#self._setup_session_recording_component()
#self._setup_modes()
self._setup_m4l_interface()
def _initialize_script(self):
super(Cntrlr, self)._initialize_script()
self._connected = True
#self._main_modes.selected_mode = 'MixMode'
self._session_ring._update_highlight()
self._session_ring.track_offset = 0
if liveobj_valid(self.song.visible_tracks[0]):
self.song.view.selected_track = self.song.visible_tracks[0]
def _setup_controls(self):
is_momentary = True
optimized = True
resource = PrioritizedResource
self._fader = [MonoEncoderElement(msg_type = MIDI_CC_TYPE, channel = CHANNEL, identifier = CNTRLR_FADERS[index], name = 'Fader_' + str(index), num = index, script = self, optimized_send_midi = optimized, resource_type = resource, monobridge = self._monobridge) for index in range(8)]
self._dial_left = [MonoEncoderElement(msg_type = MIDI_CC_TYPE, channel = CHANNEL, identifier = CNTRLR_KNOBS_LEFT[index], name = 'Dial_Left_' + str(index), num = CNTRLR_KNOBS_LEFT[index], script = self, optimized_send_midi = optimized, resource_type = resource, monobridge = self._monobridge) for index in range(12)]
self._dial_right = [MonoEncoderElement(msg_type = MIDI_CC_TYPE, channel = CHANNEL, identifier = CNTRLR_KNOBS_RIGHT[index], name = 'Dial_Right_' + str(index), num = CNTRLR_KNOBS_RIGHT[index], script = self, optimized_send_midi = optimized, resource_type = resource, monobridge = self._monobridge) for index in range(12)]
self._encoder = [CodecEncoderElement(msg_type = MIDI_CC_TYPE, channel = CHANNEL, identifier = CNTRLR_DIALS[index], name = 'Encoder_' + str(index), num = CNTRLR_DIALS[index], script = self, optimized_send_midi = optimized, resource_type = resource, monobridge = self._monobridge) for index in range(12)]
self._encoder_button = [MonoButtonElement(is_momentary = is_momentary, msg_type = MIDI_NOTE_TYPE, channel = CHANNEL, identifier = CNTRLR_DIAL_BUTTONS[index], name = 'Encoder_Button_' + str(index), script = self, skin = self._skin, color_map = COLOR_MAP, optimized_send_midi = optimized, resource_type = resource, monobridge = self._monobridge) for index in range(12)]
self._grid = [MonoButtonElement(is_momentary = is_momentary, msg_type = MIDI_NOTE_TYPE, channel = CHANNEL, identifier = CNTRLR_GRID[index], name = 'Grid_' + str(index), script = self, skin = self._skin, color_map = COLOR_MAP, optimized_send_midi = optimized, resource_type = resource, monobridge = self._monobridge) for index in range(16)]
self._button = [MonoButtonElement(is_momentary = is_momentary,msg_type = MIDI_NOTE_TYPE, channel = CHANNEL, identifier = CNTRLR_BUTTONS[index], name = 'Button_' + str(index), script = self, skin = self._skin, color_map = COLOR_MAP, optimized_send_midi = optimized, resource_type = resource, monobridge = self._monobridge) for index in range(32)]
self._knobs = self._dial_left + self._dial_right
self._fader_matrix = ButtonMatrixElement(name = 'Fader_Matrix', rows = [self._fader])
self._matrix = ButtonMatrixElement(name = 'Matrix', rows = [self._grid[index*4:(index*4)+4] for index in range(4)])
self._knob_left_matrix = ButtonMatrixElement(name = 'Knob_Left_Matrix', rows = [self._dial_left[index*4:(index*4)+4] for index in range(3)])
self._knob_right_matrix = ButtonMatrixElement(name = 'Knob_Right_Matrix', rows = [self._dial_right[index*4:(index*4)+4] for index in range(3)])
self._dial_matrix = ButtonMatrixElement(name = 'Dial_Matrix', rows = [self._encoder[index*4:(index*4)+4] for index in range(3)])
self._dial_button_matrix = ButtonMatrixElement(name = 'Dial_Button_Matrix', rows = [self._encoder_button[index*4:(index*4)+4] for index in range(1,3)])
self._key_matrix = ButtonMatrixElement(name = 'Key_Matrix', rows = [self._button[0:16], self._button[16:32]])
self._translated_controls = self._fader + self._knobs + self._encoder[4:] + self._grid + self._button
def _setup_background(self):
self._background = BackgroundComponent(name = 'Background')
self._background.layer = Layer(priority = 3, matrix = self._matrix.submatrix[:,:], faders = self._fader_matrix.submatrix[:,:], left_knobs = self._knob_left_matrix.submatrix[:,:], right_knobs = self._knob_right_matrix.submatrix[:,:], dials = self._dial_matrix, dial_buttons = self._dial_button_matrix.submatrix[:,:], keys = self._key_matrix.submatrix[:,:])
self._background.set_enabled(True)
def _define_sysex(self):
#self.encoder_navigation_on = SendLividSysexMode(livid_settings = self._livid_settings, call = 'set_encoder_encosion_mode', message = [13, 0, 0, 0])
pass
def _setup_transport_control(self):
self._transport = CntrlrTransportComponent(name = 'Transport')
self._transport._play_toggle.view_transform = lambda value: 'Transport.PlayOn' if value else 'Transport.PlayOff'
self._transport._record_toggle.view_transform = lambda value: 'Transport.RecordOn' if value else 'Transport.RecordOff'
self._transport._nudge_up_toggle.view_transform = lambda value: 'Transport.NudgeOn' if value else 'Transport.NudgeOff'
self._transport._nudge_down_toggle.view_transform = lambda value: 'Transport.NudgeOn' if value else 'Transport.NudgeOff'
self._transport._loop_toggle.view_transform = lambda value: 'Transport.LoopOn' if value else 'Transport.LoopOff'
self._transport.layer = Layer(priority = 4,
play_button = self._button[28],
stop_button = self._button[29],
record_button = self._button[30],
tap_tempo_button = self._button[31],
nudge_up_button = self._button[3],
nudge_down_button = self._button[19],
loop_button = self._button[23])
self._transport.set_enabled(True)
def _setup_autoarm(self):
self._auto_arm = CntrlrAutoArmComponent(name='Auto_Arm')
#self._auto_arm._update_notification = lambda a: None
self._auto_arm.can_auto_arm_track = self._can_auto_arm_track
def _setup_session_recording_component(self):
self._clip_creator = ClipCreator()
self._clip_creator.name = 'ClipCreator'
self._recorder = FixedLengthSessionRecordingComponent(clip_creator = self._clip_creator, view_controller = ViewControlComponent(), name = 'SessionRecorder') # is_enabled = False)
self._recorder.main_layer = AddLayerMode(self._recorder, Layer(priority = 4, record_button = self._button[29]))
#self._recorder.shift_layer = AddLayerMode(self._recorder, Layer(priority = 4, automation_button = self._button[29]))
self._recorder.set_enabled(False)
def _setup_session_control(self):
self._session_ring = SessionRingComponent(num_tracks = 4, num_scenes = 4)
self._session_ring.set_enabled(True)
self._session_navigation = SessionNavigationComponent(name = 'SessionNavigation', session_ring = self._session_ring)
self._session_navigation._vertical_banking.scroll_up_button.color = 'Session.NavigationButtonOn'
self._session_navigation._vertical_banking.scroll_down_button.color = 'Session.NavigationButtonOn'
self._session_navigation._horizontal_banking.scroll_up_button.color = 'Session.NavigationButtonOn'
self._session_navigation._horizontal_banking.scroll_down_button.color = 'Session.NavigationButtonOn'
self._session_navigation._vertical_paginator.scroll_up_button.color = 'Session.PageNavigationButtonOn'
self._session_navigation._vertical_paginator.scroll_up_button.disabled_color = 'Session.PageNavigationButtonOff'
self._session_navigation._vertical_paginator.scroll_down_button.color = 'Session.PageNavigationButtonOn'
self._session_navigation._vertical_paginator.scroll_down_button.disabled_color = 'Session.PageNavigationButtonOff'
self._session_navigation._horizontal_paginator.scroll_up_button.color = 'Session.PageNavigationButtonOn'
self._session_navigation._horizontal_paginator.scroll_up_button.disabled_color = 'Session.PageNavigationButtonOff'
self._session_navigation._horizontal_paginator.scroll_down_button.color = 'Session.PageNavigationButtonOn'
self._session_navigation._horizontal_paginator.scroll_down_button.disabled_color = 'Session.PageNavigationButtonOff'
self._session_navigation.layer = Layer(priority = 4,
down_button = self._button[14],
up_button = self._button[15],
left_button = self._button[12],
right_button = self._button[13])
self._session_navigation.set_enabled(True)
self._session = SessionComponent(session_ring = self._session_ring, auto_name = True)
hasattr(self._session, '_enable_skinning') and self._session._enable_skinning()
self._session.layer = Layer(priority = 4,
clip_launch_buttons = self._matrix.submatrix[:,:])
self._session.set_enabled(True)
def _setup_mixer_control(self):
self._mixer_session_ring = SessionRingComponent(num_tracks = 4, num_scenes = 4)
self._mixer = MonoMixerComponent(name = 'Mixer', tracks_provider = self._mixer_session_ring, track_assigner = simple_track_assigner, invert_mute_feedback = True, auto_name = True, enable_skinning = True)
self._mixer.layer = Layer(priority = 4,
solo_buttons = self._key_matrix.submatrix[8:11, 0],
stop_clip_buttons = self._key_matrix.submatrix[:3, 0],
track_select_buttons = self._key_matrix.submatrix[4:8, 0],)
for strip in self._mixer._channel_strips:
strip._on_select_button_double_clicked = self._toggle_view
self._mixer.set_enabled(True)
def _toggle_view(self, *a):
debug('toggle_view')
debug('Clip is visible:', self.application().view.is_view_visible('Detail/Clip'))
debug('Device is visible:', self.application().view.is_view_visible('Detail/DeviceChain'))
if self.application().view.is_view_visible('Detail/Clip'):
self._view_control.show_view('Detail/DeviceChain')
else:
self._view_control.show_view('Detail/Clip')
def _setup_device_control(self):
self._device_selection_follows_track_selection = FOLLOW
self._device = DeviceComponent(name = 'Device_Component', device_provider = self._device_provider, device_bank_registry = DeviceBankRegistry())
self._device.layer = Layer(priority = 4, parameter_controls = self._dial_matrix.submatrix[:, 1:3],)
#self._device.mod_layer = AddLayerMode(self._device, Layer(priority = 4, parameter_controls = self._dial_matrix.submatrix[:, 1:3],))
self._device.main_layer = AddLayerMode(self._device, Layer(priority = 4, parameter_controls = self._dial_matrix.submatrix[:, 1:3],
on_off_button = self._encoder_button[4],
bank_prev_button = self._encoder_button[6],
bank_next_button = self._encoder_button[7],))
#lock_button = self._encoder_button[5],
self._device.set_enabled(False)
self._device_navigator = DeviceNavigator(self._device_provider, self._mixer, self)
self._device_navigator.name = 'Device_Navigator'
self._device_navigator.select_dial_layer = AddLayerMode(self._device_navigator, Layer(priority = 6, device_select_dial = self._encoder[0],))
self._device_navigator.main_layer = AddLayerMode(self._device_navigator, Layer(priority = 4,
prev_chain_button = self._encoder_button[8],
next_chain_button = self._encoder_button[9],
exit_button = self._encoder_button[10],
enter_button = self._encoder_button[11],))
self._device_navigator.set_enabled(False)
def _setup_device_selector(self):
self._device_selector = DeviceSelectorComponent(self)
self._device_selector.name = 'Device_Selector'
#self._device_selector.select_layer = AddLayerMode(self._device_selector, Layer(priority = 6 , matrix = self._matrix.submatrix[:, :]))
self._device_selector.select_layer = AddLayerMode(self._device_selector, Layer(priority = 6, matrix = ButtonMatrixElement(rows = [self._grid[:4],self._grid[4:8],self._grid[8:12],self._grid[12:14]])))
self._device_selector.assign_layer = AddLayerMode(self._device_selector, Layer(priority = 7, assign_button = self._grid[14]))
self._device_selector.set_enabled(False)
def _setup_viewcontrol(self):
self._view_control = ViewControlComponent(name='View_Control')
#self._view_control.main_layer = AddLayerMode(self._view_control, Layer(priority = 5,
# scene_select_dial = self._encoder[2],
# track_select_dial = self._encoder[3],))
#self._view_control.main_layer = AddLayerMode(self._view_control, Layer(prev_track_button=self._button[24],
# next_track_button= self._button[25],
# next_scene_button=self._button[27],
# prev_scene_button = self._button[26]))
self._view_control.set_enabled(True)
def _setup_modes(self):
common = CompoundMode(self._mixer,
self._session_ring)
main_buttons=CompoundMode(self._mixer.main_buttons_layer,
self._transport,
self._recorder,
self._recorder.main_layer,
self._device,)
shifted_main_buttons=CompoundMode(self._mixer.solo_buttons_layer,
self._recorder,
self._recorder.shift_layer,
self._session.scene_launch_layer,
self._device,)
main_faders=CompoundMode(self._mixer.main_faders_layer,
self._mixer.master_fader_layer)
main_dials=CompoundMode(self._view_control,
self._view_control.main_layer,
self._device_navigator,
self._device_navigator.select_dial_layer,
self.encoder_navigation_on)
shifted_dials=CompoundMode(self._session_navigation,
self._session_navigation.nav_dial_layer,
self._device_navigator,
self._device_navigator.select_dial_layer,
self.encoder_navigation_on)
self._modalt_mode = ModesComponent(name = 'ModAltMode')
self._modalt_mode.add_mode('disabled', None)
self._modalt_mode.add_mode('enabled', [tuple([self._enable_mod_alt, self._disable_mod_alt])], behaviour = CancellableBehaviourWithRelease(), cycle_mode_button_color = 'Mod.AltOn')
self._modalt_mode.selected_mode = 'disabled'
self._modalt_mode.set_enabled(False)
self._modalt_mode.layer = Layer(priority = 4, enabled_button = self._encoder_button[1])
self._modswitcher = ModesComponent(name = 'ModSwitcher')
self._modswitcher.add_mode('mod', [self.modhandler, self._modalt_mode, main_faders, self._mixer.main_knobs_layer, self._device, main_dials, DelayMode(self.modhandler.update, delay = .5, parent_task_group = self._task_group)])
self._modswitcher.add_mode('instrument', [self._instrument.shift_button_layer, main_buttons, main_faders, self._mixer.main_knobs_layer, self._device, self._device.main_layer, self._device_navigator, self._device_navigator.main_layer, self._device_navigator.select_dial_layer]) #self._instrument.shift_button_layer, self._optional_translations])
self._modswitcher.selected_mode = 'instrument'
self._modswitcher.set_enabled(False)
self._instrument._main_modes = ModesComponent(name = 'InstrumentModes')
self._instrument._main_modes.add_mode('disabled', [main_buttons,
main_dials,
self._device.main_layer,
self._session,
self._session,
self._session.clip_launch_layer])
self._instrument._main_modes.add_mode('drumpad', [self._instrument._drumpad.sequencer_layer,
main_buttons,
self._device.main_layer,
main_dials])
self._instrument._main_modes.add_mode('drumpad_split', [self._instrument._drumpad.split_layer,
self._instrument._selected_session,
main_buttons,
self._device.main_layer,
main_dials])
self._instrument._main_modes.add_mode('drumpad_sequencer', [self._instrument._drumpad.sequencer_layer,
main_buttons,
self._device.main_layer,
main_dials])
self._instrument._main_modes.add_mode('drumpad_shifted', [self._instrument._drumpad.sequencer_shift_layer,
self._instrument.drumpad_shift_layer,
shifted_main_buttons,
self._device.main_layer,
shifted_dials])
self._instrument._main_modes.add_mode('drumpad_split_shifted', [self._instrument._drumpad.split_layer,
self._instrument.drumpad_shift_layer,
shifted_main_buttons,
self._device.main_layer,
shifted_dials])
self._instrument._main_modes.add_mode('drumpad_sequencer_shifted', [self._instrument._drumpad.sequencer_shift_layer,
self._instrument.drumpad_shift_layer,
shifted_main_buttons,
self._device.main_layer,
shifted_dials])
self._instrument._main_modes.add_mode('keypad', [self._instrument._keypad.sequencer_layer,
main_buttons,
self._device.main_layer,
main_dials])
self._instrument._main_modes.add_mode('keypad_split', [self._instrument._keypad.split_layer,
self._instrument._selected_session,
main_buttons,
self._device.main_layer,
main_dials])
self._instrument._main_modes.add_mode('keypad_sequencer', [self._instrument._keypad.sequencer_layer,
main_buttons,
self._device.main_layer,
main_dials])
self._instrument._main_modes.add_mode('keypad_shifted', [self._instrument._keypad.sequencer_shift_layer,
self._instrument.keypad_shift_layer,
shifted_main_buttons,
self._device.main_layer,
shifted_dials])
self._instrument._main_modes.add_mode('keypad_split_shifted', [self._instrument._keypad.split_layer,
self._instrument.keypad_shift_layer,
shifted_main_buttons,
self._device.main_layer,
shifted_dials])
self._instrument._main_modes.add_mode('keypad_sequencer_shifted', [self._instrument._keypad.sequencer_shift_layer,
self._instrument.keypad_shift_layer,
shifted_main_buttons,
self._device.main_layer,
shifted_dials])
self._instrument._main_modes.add_mode('drumpad_session', [self._instrument._drumpad.sequencer_session_layer,
main_buttons,
self._device.main_layer,
self._session,
DelayMode(self._session.clip_launch_layer, delay = .1),
main_dials])
self._instrument._main_modes.add_mode('drumpad_split_session', [self._instrument._drumpad.split_session_layer,
self._instrument._selected_session,
main_buttons,
self._device.main_layer,
self._session,
DelayMode(self._session.clip_launch_layer, delay = .1),
main_dials])
self._instrument._main_modes.add_mode('drumpad_sequencer_session', [self._instrument._drumpad.sequencer_session_layer,
main_buttons,
self._device.main_layer,
self._session,
DelayMode(self._session.clip_launch_layer, delay = .1),
main_dials])
self._instrument._main_modes.add_mode('drumpad_shifted_session', [self._instrument._drumpad.sequencer_session_shift_layer,
self._instrument.drumpad_shift_layer,
main_buttons,
self._device.main_layer,
self._session_zoom,
shifted_dials])
self._instrument._main_modes.add_mode('drumpad_split_shifted_session', [self._instrument._drumpad.split_session_layer,
self._instrument.drumpad_shift_layer,
shifted_main_buttons,
self._device.main_layer,
self._session_zoom,
shifted_dials])
self._instrument._main_modes.add_mode('drumpad_sequencer_shifted_session', [self._instrument._drumpad.sequencer_session_shift_layer,
self._instrument.drumpad_shift_layer,
shifted_main_buttons,
self._device.main_layer,
self._session_zoom,
shifted_dials])
self._instrument._main_modes.add_mode('keypad_session', [self._instrument._keypad.sequencer_session_layer,
main_buttons,
self._device.main_layer,
self._session,
DelayMode(self._session.clip_launch_layer, delay = .1),
main_dials])
self._instrument._main_modes.add_mode('keypad_split_session', [self._instrument._keypad.split_session_layer,
self._instrument._selected_session,
main_buttons,
self._device.main_layer,
self._session,
DelayMode(self._session.clip_launch_layer, delay = .1),
main_dials])
self._instrument._main_modes.add_mode('keypad_sequencer_session', [self._instrument._keypad.sequencer_session_layer,
main_buttons,
self._device.main_layer,
self._session,
DelayMode(self._session.clip_launch_layer, delay = .1),
main_dials])
self._instrument._main_modes.add_mode('keypad_shifted_session', [self._instrument._keypad.sequencer_session_shift_layer,
self._instrument.keypad_shift_layer,
shifted_main_buttons,
self._device.main_layer,
self._session_zoom,
shifted_dials])
self._instrument._main_modes.add_mode('keypad_split_shifted_session', [self._instrument._keypad.split_session_layer,
self._instrument.keypad_shift_layer,
shifted_main_buttons,
self._device.main_layer,
self._session_zoom,
shifted_dials])
self._instrument._main_modes.add_mode('keypad_sequencer_shifted_session', [self._instrument._keypad.sequencer_session_shift_layer,
self._instrument.keypad_shift_layer,
shifted_main_buttons,
self._device.main_layer,
self._session_zoom,
shifted_dials])
self._instrument._main_modes.add_mode('audioloop', [self._instrument.audioloop_layer,
main_buttons,
self._device.main_layer,
main_dials,
self._session,
DelayMode(self._session.clip_launch_layer, delay = .1)])
self._instrument._main_modes.add_mode('audioloop_shifted', [self._instrument.audioloop_layer,
shifted_main_buttons,
self._device.main_layer,
self._session_zoom,
shifted_dials])
#self._instrument._main_modes.add_mode('audioloop_shifted_session', [self._instrument.audioloop_layer, self._session, shifted_main_buttons, main_dials, shifted_dials])
self._instrument.register_component(self._instrument._main_modes)
self._instrument._main_modes.selected_mode = 'disabled'
self._instrument.set_enabled(True)
self._main_modes = ModesComponent(name = 'MainModes')
self._main_modes.add_mode('disabled', [self._background])
self._main_modes.add_mode('MixMode', [common,
self._instrument,
self._instrument.shift_button_layer,
self._mixer,
main_faders,
self._mixer.main_knobs_layer,
self._device,
self._device.main_layer,
self._device_navigator,
self._device_navigator.main_layer,
self._device_navigator.select_dial_layer])
self._main_modes.add_mode('ModSwitcher', [common,
main_faders,
main_dials,
self._mixer.main_knobs_layer,
self._view_control,
self._view_control.main_layer,
self._device_navigator,
self._device_navigator.select_dial_layer,
self.encoder_navigation_on,
self._modswitcher,
DelayMode(self._update_modswitcher, delay = .1)],
behaviour = ColoredCancellableBehaviourWithRelease(color = 'ModeButtons.ModSwitcher', off_color = 'ModeButtons.ModSwitcherDisabled'))
self._main_modes.add_mode('Translations', [common,
main_faders,
main_dials,
self._mixer.main_knobs_layer,
self._translations,
DelayMode(self._translations.selector_layer, delay = .1)],
behaviour = DefaultedBehaviour(default_mode = 'MixMode', color = 'ModeButtons.Translations', off_color = 'ModeButtons.TranslationsDisabled'))
self._main_modes.add_mode('DeviceSelector', [common,
self._device_selector,
DelayMode(self._device_selector.select_layer, delay = .1),
DelayMode(self.modhandler.lock_layer, delay = .1),
DelayMode(self._device_selector.assign_layer, delay = .5),
main_buttons,
main_dials,
main_faders,
self._mixer.main_knobs_layer,
self._device.main_layer,
self._device_navigator,
self._device_navigator.main_layer,
self._device_navigator.select_dial_layer],
behaviour = ColoredCancellableBehaviourWithRelease(color = 'ModeButtons.DeviceSelector', off_color = 'ModeButtons.DeviceSelectorDisabled'))
self._main_modes.layer = Layer(priority = 4, ModSwitcher_button = self._encoder_button[2], DeviceSelector_button = self._encoder_button[0], Translations_button = self._encoder_button[3]) #,
self._main_modes.selected_mode = 'disabled'
self._main_modes.set_enabled(True)
self._test.subject = self._instrument._main_modes
def _setup_modes(self):
pass
def _setup_m4l_interface(self):
self._m4l_interface = M4LInterfaceComponent(controls=self.controls, component_guard=self.component_guard, priority = 10)
self._m4l_interface.name = "M4LInterface"
self.get_control_names = self._m4l_interface.get_control_names
self.get_control = self._m4l_interface.get_control
self.grab_control = self._m4l_interface.grab_control
self.release_control = self._m4l_interface.release_control
def _can_auto_arm_track(self, track):
routing = track.current_input_routing
return routing == 'Ext: All Ins' or routing == 'All Ins' or routing.startswith('Cntrlr Input')
def _get_num_tracks(self):
return self.num_tracks
# a
class Cntrlr(LividControlSurface):
__module__ = __name__
__doc__ = " Monomodular controller script for Livid CNTRLR "
_sysex_id = 8
_model_name = 'Cntrlr'
_host_name = 'Cntrlr'
monomodular = None
device_provider_class = ModDeviceProvider
def __init__(self, *a, **k):
super(Cntrlr, self).__init__(*a, **k)
self._skin = Skin(CntrlrColors)
self._device_selection_follows_track_selection = FOLLOW
with self.component_guard():
self._setup_controls()
self._define_sysex()
self._setup_background()
#self._setup_autoarm()
self._setup_viewcontrol()
self._setup_session_control()
self._setup_mixer_control()
self._setup_transport_control()
#self._setup_device_control()
#self._setup_device_selector()
#self._setup_session_recording_component()
#self._setup_modes()
self._setup_m4l_interface()
def _initialize_script(self):
super(Cntrlr, self)._initialize_script()
self._connected = True
#self._main_modes.selected_mode = 'MixMode'
self._session_ring._update_highlight()
self._session_ring.track_offset = 0
if liveobj_valid(self.song.visible_tracks[0]):
self.song.view.selected_track = self.song.visible_tracks[0]
def _setup_controls(self):
is_momentary = True
optimized = True
resource = PrioritizedResource
self._fader = [MonoEncoderElement(msg_type = MIDI_CC_TYPE, channel = CHANNEL, identifier = CNTRLR_FADERS[index], name = 'Fader_' + str(index), num = index, script = self, optimized_send_midi = optimized, resource_type = resource, monobridge = self._monobridge) for index in range(8)]
self._dial_left = [MonoEncoderElement(msg_type = MIDI_CC_TYPE, channel = CHANNEL, identifier = CNTRLR_KNOBS_LEFT[index], name = 'Dial_Left_' + str(index), num = CNTRLR_KNOBS_LEFT[index], script = self, optimized_send_midi = optimized, resource_type = resource, monobridge = self._monobridge) for index in range(12)]
self._dial_right = [MonoEncoderElement(msg_type = MIDI_CC_TYPE, channel = CHANNEL, identifier = CNTRLR_KNOBS_RIGHT[index], name = 'Dial_Right_' + str(index), num = CNTRLR_KNOBS_RIGHT[index], script = self, optimized_send_midi = optimized, resource_type = resource, monobridge = self._monobridge) for index in range(12)]
self._encoder = [CodecEncoderElement(msg_type = MIDI_CC_TYPE, channel = CHANNEL, identifier = CNTRLR_DIALS[index], name = 'Encoder_' + str(index), num = CNTRLR_DIALS[index], script = self, optimized_send_midi = optimized, resource_type = resource, monobridge = self._monobridge) for index in range(12)]
self._encoder_button = [MonoButtonElement(is_momentary = is_momentary, msg_type = MIDI_NOTE_TYPE, channel = CHANNEL, identifier = CNTRLR_DIAL_BUTTONS[index], name = 'Encoder_Button_' + str(index), script = self, skin = self._skin, color_map = COLOR_MAP, optimized_send_midi = optimized, resource_type = resource, monobridge = self._monobridge) for index in range(12)]
self._grid = [MonoButtonElement(is_momentary = is_momentary, msg_type = MIDI_NOTE_TYPE, channel = CHANNEL, identifier = CNTRLR_GRID[index], name = 'Grid_' + str(index), script = self, skin = self._skin, color_map = COLOR_MAP, optimized_send_midi = optimized, resource_type = resource, monobridge = self._monobridge) for index in range(16)]
self._button = [MonoButtonElement(is_momentary = is_momentary,msg_type = MIDI_NOTE_TYPE, channel = CHANNEL, identifier = CNTRLR_BUTTONS[index], name = 'Button_' + str(index), script = self, skin = self._skin, color_map = COLOR_MAP, optimized_send_midi = optimized, resource_type = resource, monobridge = self._monobridge) for index in range(32)]
self._knobs = self._dial_left + self._dial_right
self._fader_matrix = ButtonMatrixElement(name = 'Fader_Matrix', rows = [self._fader])
self._matrix = ButtonMatrixElement(name = 'Matrix', rows = [self._grid[index*4:(index*4)+4] for index in range(4)])
self._knob_left_matrix = ButtonMatrixElement(name = 'Knob_Left_Matrix', rows = [self._dial_left[index*4:(index*4)+4] for index in range(3)])
self._knob_right_matrix = ButtonMatrixElement(name = 'Knob_Right_Matrix', rows = [self._dial_right[index*4:(index*4)+4] for index in range(3)])
self._dial_matrix = ButtonMatrixElement(name = 'Dial_Matrix', rows = [self._encoder[index*4:(index*4)+4] for index in range(3)])
self._dial_button_matrix = ButtonMatrixElement(name = 'Dial_Button_Matrix', rows = [self._encoder_button[index*4:(index*4)+4] for index in range(1,3)])
self._key_matrix = ButtonMatrixElement(name = 'Key_Matrix', rows = [self._button[0:16], self._button[16:32]])
self._translated_controls = self._fader + self._knobs + self._encoder[4:] + self._grid + self._button
def _setup_background(self):
self._background = BackgroundComponent(name = 'Background')
self._background.layer = Layer(priority = 3, matrix = self._matrix.submatrix[:,:], faders = self._fader_matrix.submatrix[:,:], left_knobs = self._knob_left_matrix.submatrix[:,:], right_knobs = self._knob_right_matrix.submatrix[:,:], dials = self._dial_matrix, dial_buttons = self._dial_button_matrix.submatrix[:,:], keys = self._key_matrix.submatrix[:,:])
self._background.set_enabled(True)
def _define_sysex(self):
#self.encoder_navigation_on = SendLividSysexMode(livid_settings = self._livid_settings, call = 'set_encoder_encosion_mode', message = [13, 0, 0, 0])
pass
def _setup_transport_control(self):
self._transport = CntrlrTransportComponent(name = 'Transport')
self._transport._play_toggle.view_transform = lambda value: 'Transport.PlayOn' if value else 'Transport.PlayOff'
self._transport._record_toggle.view_transform = lambda value: 'Transport.RecordOn' if value else 'Transport.RecordOff'
self._transport._nudge_up_toggle.view_transform = lambda value: 'Transport.NudgeOn' if value else 'Transport.NudgeOff'
self._transport._nudge_down_toggle.view_transform = lambda value: 'Transport.NudgeOn' if value else 'Transport.NudgeOff'
self._transport._loop_toggle.view_transform = lambda value: 'Transport.LoopOn' if value else 'Transport.LoopOff'
self._transport.layer = Layer(priority = 4,
play_button = self._button[28],
stop_button = self._button[29],
record_button = self._button[30],
tap_tempo_button = self._button[31],
nudge_up_button = self._button[3],
nudge_down_button = self._button[19],
loop_button = self._button[23])
self._transport.set_enabled(True)
def _setup_autoarm(self):
self._auto_arm = CntrlrAutoArmComponent(name='Auto_Arm')
#self._auto_arm._update_notification = lambda a: None
self._auto_arm.can_auto_arm_track = self._can_auto_arm_track
def _setup_session_recording_component(self):
self._clip_creator = ClipCreator()
self._clip_creator.name = 'ClipCreator'
self._recorder = FixedLengthSessionRecordingComponent(clip_creator = self._clip_creator, view_controller = ViewControlComponent(), name = 'SessionRecorder') # is_enabled = False)
self._recorder.main_layer = AddLayerMode(self._recorder, Layer(priority = 4, record_button = self._button[29]))
#self._recorder.shift_layer = AddLayerMode(self._recorder, Layer(priority = 4, automation_button = self._button[29]))
self._recorder.set_enabled(False)
def _setup_session_control(self):
self._session_ring = SessionRingComponent(num_tracks = 4, num_scenes = 4)
self._session_ring.set_enabled(True)
self._session_navigation = SessionNavigationComponent(name = 'SessionNavigation', session_ring = self._session_ring)
self._session_navigation._vertical_banking.scroll_up_button.color = 'Session.NavigationButtonOn'
self._session_navigation._vertical_banking.scroll_down_button.color = 'Session.NavigationButtonOn'
self._session_navigation._horizontal_banking.scroll_up_button.color = 'Session.NavigationButtonOn'
self._session_navigation._horizontal_banking.scroll_down_button.color = 'Session.NavigationButtonOn'
self._session_navigation._vertical_paginator.scroll_up_button.color = 'Session.PageNavigationButtonOn'
self._session_navigation._vertical_paginator.scroll_up_button.disabled_color = 'Session.PageNavigationButtonOff'
self._session_navigation._vertical_paginator.scroll_down_button.color = 'Session.PageNavigationButtonOn'
self._session_navigation._vertical_paginator.scroll_down_button.disabled_color = 'Session.PageNavigationButtonOff'
self._session_navigation._horizontal_paginator.scroll_up_button.color = 'Session.PageNavigationButtonOn'
self._session_navigation._horizontal_paginator.scroll_up_button.disabled_color = 'Session.PageNavigationButtonOff'
self._session_navigation._horizontal_paginator.scroll_down_button.color = 'Session.PageNavigationButtonOn'
self._session_navigation._horizontal_paginator.scroll_down_button.disabled_color = 'Session.PageNavigationButtonOff'
self._session_navigation.layer = Layer(priority = 4,
down_button = self._button[14],
up_button = self._button[15],
left_button = self._button[12],
right_button = self._button[13])
self._session_navigation.set_enabled(True)
self._session = SessionComponent(session_ring = self._session_ring, auto_name = True)
hasattr(self._session, '_enable_skinning') and self._session._enable_skinning()
self._session.layer = Layer(priority = 4,
clip_launch_buttons = self._matrix.submatrix[:,:])
self._session.set_enabled(True)
def _setup_mixer_control(self):
self._mixer_session_ring = SessionRingComponent(num_tracks = 4, num_scenes = 4)
self._mixer = MonoMixerComponent(name = 'Mixer', tracks_provider = self._mixer_session_ring, track_assigner = simple_track_assigner, invert_mute_feedback = True, auto_name = True, enable_skinning = True)
self._mixer.layer = Layer(priority = 4,
solo_buttons = self._key_matrix.submatrix[8:11, 0],
stop_clip_buttons = self._key_matrix.submatrix[:3, 0],
track_select_buttons = self._key_matrix.submatrix[4:8, 0],)
for strip in self._mixer._channel_strips:
strip._on_select_button_double_clicked = self._toggle_view
self._mixer.set_enabled(True)
def _toggle_view(self, *a):
debug('toggle_view')
debug('Clip is visible:', self.application.view.is_view_visible('Detail/Clip'))
debug('Device is visible:', self.application.view.is_view_visible('Detail/DeviceChain'))
if self.application.view.is_view_visible('Detail/Clip'):
self._view_control.show_view('Detail/DeviceChain')
else:
self._view_control.show_view('Detail/Clip')
def _setup_device_control(self):
self._device_selection_follows_track_selection = FOLLOW
self._device = DeviceComponent(name = 'Device_Component', device_provider = self._device_provider, device_bank_registry = DeviceBankRegistry())
self._device.layer = Layer(priority = 4, parameter_controls = self._dial_matrix.submatrix[:, 1:3],)
#self._device.mod_layer = AddLayerMode(self._device, Layer(priority = 4, parameter_controls = self._dial_matrix.submatrix[:, 1:3],))
self._device.main_layer = AddLayerMode(self._device, Layer(priority = 4, parameter_controls = self._dial_matrix.submatrix[:, 1:3],
on_off_button = self._encoder_button[4],
bank_prev_button = self._encoder_button[6],
bank_next_button = self._encoder_button[7],))
#lock_button = self._encoder_button[5],
self._device.set_enabled(False)
self._device_navigator = DeviceNavigator(self._device_provider, self._mixer, self)
self._device_navigator.name = 'Device_Navigator'
self._device_navigator.select_dial_layer = AddLayerMode(self._device_navigator, Layer(priority = 6, device_select_dial = self._encoder[0],))
self._device_navigator.main_layer = AddLayerMode(self._device_navigator, Layer(priority = 4,
prev_chain_button = self._encoder_button[8],
next_chain_button = self._encoder_button[9],
exit_button = self._encoder_button[10],
enter_button = self._encoder_button[11],))
self._device_navigator.set_enabled(False)
def _setup_device_selector(self):
self._device_selector = DeviceSelectorComponent(self)
self._device_selector.name = 'Device_Selector'
#self._device_selector.select_layer = AddLayerMode(self._device_selector, Layer(priority = 6 , matrix = self._matrix.submatrix[:, :]))
self._device_selector.select_layer = AddLayerMode(self._device_selector, Layer(priority = 6, matrix = ButtonMatrixElement(rows = [self._grid[:4],self._grid[4:8],self._grid[8:12],self._grid[12:14]])))
self._device_selector.assign_layer = AddLayerMode(self._device_selector, Layer(priority = 7, assign_button = self._grid[14]))
self._device_selector.set_enabled(False)
def _setup_viewcontrol(self):
self._view_control = ViewControlComponent(name='View_Control')
#self._view_control.main_layer = AddLayerMode(self._view_control, Layer(priority = 5,
# scene_select_dial = self._encoder[2],
# track_select_dial = self._encoder[3],))
#self._view_control.main_layer = AddLayerMode(self._view_control, Layer(prev_track_button=self._button[24],
# next_track_button= self._button[25],
# next_scene_button=self._button[27],
# prev_scene_button = self._button[26]))
self._view_control.set_enabled(True)
def _setup_modes(self):
common = CompoundMode(self._mixer,
self._session_ring)
main_buttons=CompoundMode(self._mixer.main_buttons_layer,
self._transport,
self._recorder,
self._recorder.main_layer,
self._device,)
shifted_main_buttons=CompoundMode(self._mixer.solo_buttons_layer,
self._recorder,
self._recorder.shift_layer,
self._session.scene_launch_layer,
self._device,)
main_faders=CompoundMode(self._mixer.main_faders_layer,
self._mixer.master_fader_layer)
main_dials=CompoundMode(self._view_control,
self._view_control.main_layer,
self._device_navigator,
self._device_navigator.select_dial_layer,
self.encoder_navigation_on)
shifted_dials=CompoundMode(self._session_navigation,
self._session_navigation.nav_dial_layer,
self._device_navigator,
self._device_navigator.select_dial_layer,
self.encoder_navigation_on)
self._modalt_mode = ModesComponent(name = 'ModAltMode')
self._modalt_mode.add_mode('disabled', None)
self._modalt_mode.add_mode('enabled', [tuple([self._enable_mod_alt, self._disable_mod_alt])], behaviour = CancellableBehaviourWithRelease(), cycle_mode_button_color = 'Mod.AltOn')
self._modalt_mode.selected_mode = 'disabled'
self._modalt_mode.set_enabled(False)
self._modalt_mode.layer = Layer(priority = 4, enabled_button = self._encoder_button[1])
self._modswitcher = ModesComponent(name = 'ModSwitcher')
self._modswitcher.add_mode('mod', [self.modhandler, self._modalt_mode, main_faders, self._mixer.main_knobs_layer, self._device, main_dials, DelayMode(self.modhandler.update, delay = .5, parent_task_group = self._task_group)])
self._modswitcher.add_mode('instrument', [self._instrument.shift_button_layer, main_buttons, main_faders, self._mixer.main_knobs_layer, self._device, self._device.main_layer, self._device_navigator, self._device_navigator.main_layer, self._device_navigator.select_dial_layer]) #self._instrument.shift_button_layer, self._optional_translations])
self._modswitcher.selected_mode = 'instrument'
self._modswitcher.set_enabled(False)
self._instrument._main_modes = ModesComponent(name = 'InstrumentModes')
self._instrument._main_modes.add_mode('disabled', [main_buttons,
main_dials,
self._device.main_layer,
self._session,
self._session,
self._session.clip_launch_layer])
self._instrument._main_modes.add_mode('drumpad', [self._instrument._drumpad.sequencer_layer,
main_buttons,
self._device.main_layer,
main_dials])
self._instrument._main_modes.add_mode('drumpad_split', [self._instrument._drumpad.split_layer,
self._instrument._selected_session,
main_buttons,
self._device.main_layer,
main_dials])
self._instrument._main_modes.add_mode('drumpad_sequencer', [self._instrument._drumpad.sequencer_layer,
main_buttons,
self._device.main_layer,
main_dials])
self._instrument._main_modes.add_mode('drumpad_shifted', [self._instrument._drumpad.sequencer_shift_layer,
self._instrument.drumpad_shift_layer,
shifted_main_buttons,
self._device.main_layer,
shifted_dials])
self._instrument._main_modes.add_mode('drumpad_split_shifted', [self._instrument._drumpad.split_layer,
self._instrument.drumpad_shift_layer,
shifted_main_buttons,
self._device.main_layer,
shifted_dials])
self._instrument._main_modes.add_mode('drumpad_sequencer_shifted', [self._instrument._drumpad.sequencer_shift_layer,
self._instrument.drumpad_shift_layer,
shifted_main_buttons,
self._device.main_layer,
shifted_dials])
self._instrument._main_modes.add_mode('keypad', [self._instrument._keypad.sequencer_layer,
main_buttons,
self._device.main_layer,
main_dials])
self._instrument._main_modes.add_mode('keypad_split', [self._instrument._keypad.split_layer,
self._instrument._selected_session,
main_buttons,
self._device.main_layer,
main_dials])
self._instrument._main_modes.add_mode('keypad_sequencer', [self._instrument._keypad.sequencer_layer,
main_buttons,
self._device.main_layer,
main_dials])
self._instrument._main_modes.add_mode('keypad_shifted', [self._instrument._keypad.sequencer_shift_layer,
self._instrument.keypad_shift_layer,
shifted_main_buttons,
self._device.main_layer,
shifted_dials])
self._instrument._main_modes.add_mode('keypad_split_shifted', [self._instrument._keypad.split_layer,
self._instrument.keypad_shift_layer,
shifted_main_buttons,
self._device.main_layer,
shifted_dials])
self._instrument._main_modes.add_mode('keypad_sequencer_shifted', [self._instrument._keypad.sequencer_shift_layer,
self._instrument.keypad_shift_layer,
shifted_main_buttons,
self._device.main_layer,
shifted_dials])
self._instrument._main_modes.add_mode('drumpad_session', [self._instrument._drumpad.sequencer_session_layer,
main_buttons,
self._device.main_layer,
self._session,
DelayMode(self._session.clip_launch_layer, delay = .1),
main_dials])
self._instrument._main_modes.add_mode('drumpad_split_session', [self._instrument._drumpad.split_session_layer,
self._instrument._selected_session,
main_buttons,
self._device.main_layer,
self._session,
DelayMode(self._session.clip_launch_layer, delay = .1),
main_dials])
self._instrument._main_modes.add_mode('drumpad_sequencer_session', [self._instrument._drumpad.sequencer_session_layer,
main_buttons,
self._device.main_layer,
self._session,
DelayMode(self._session.clip_launch_layer, delay = .1),
main_dials])
self._instrument._main_modes.add_mode('drumpad_shifted_session', [self._instrument._drumpad.sequencer_session_shift_layer,
self._instrument.drumpad_shift_layer,
main_buttons,
self._device.main_layer,
self._session_zoom,
shifted_dials])
self._instrument._main_modes.add_mode('drumpad_split_shifted_session', [self._instrument._drumpad.split_session_layer,
self._instrument.drumpad_shift_layer,
shifted_main_buttons,
self._device.main_layer,
self._session_zoom,
shifted_dials])
self._instrument._main_modes.add_mode('drumpad_sequencer_shifted_session', [self._instrument._drumpad.sequencer_session_shift_layer,
self._instrument.drumpad_shift_layer,
shifted_main_buttons,
self._device.main_layer,
self._session_zoom,
shifted_dials])
self._instrument._main_modes.add_mode('keypad_session', [self._instrument._keypad.sequencer_session_layer,
main_buttons,
self._device.main_layer,
self._session,
DelayMode(self._session.clip_launch_layer, delay = .1),
main_dials])
self._instrument._main_modes.add_mode('keypad_split_session', [self._instrument._keypad.split_session_layer,
self._instrument._selected_session,
main_buttons,
self._device.main_layer,
self._session,
DelayMode(self._session.clip_launch_layer, delay = .1),
main_dials])
self._instrument._main_modes.add_mode('keypad_sequencer_session', [self._instrument._keypad.sequencer_session_layer,
main_buttons,
self._device.main_layer,
self._session,
DelayMode(self._session.clip_launch_layer, delay = .1),
main_dials])
self._instrument._main_modes.add_mode('keypad_shifted_session', [self._instrument._keypad.sequencer_session_shift_layer,
self._instrument.keypad_shift_layer,
shifted_main_buttons,
self._device.main_layer,
self._session_zoom,
shifted_dials])
self._instrument._main_modes.add_mode('keypad_split_shifted_session', [self._instrument._keypad.split_session_layer,
self._instrument.keypad_shift_layer,
shifted_main_buttons,
self._device.main_layer,
self._session_zoom,
shifted_dials])
self._instrument._main_modes.add_mode('keypad_sequencer_shifted_session', [self._instrument._keypad.sequencer_session_shift_layer,
self._instrument.keypad_shift_layer,
shifted_main_buttons,
self._device.main_layer,
self._session_zoom,
shifted_dials])
self._instrument._main_modes.add_mode('audioloop', [self._instrument.audioloop_layer,
main_buttons,
self._device.main_layer,
main_dials,
self._session,
DelayMode(self._session.clip_launch_layer, delay = .1)])
self._instrument._main_modes.add_mode('audioloop_shifted', [self._instrument.audioloop_layer,
shifted_main_buttons,
self._device.main_layer,
self._session_zoom,
shifted_dials])
#self._instrument._main_modes.add_mode('audioloop_shifted_session', [self._instrument.audioloop_layer, self._session, shifted_main_buttons, main_dials, shifted_dials])
self._instrument.register_component(self._instrument._main_modes)
self._instrument._main_modes.selected_mode = 'disabled'
self._instrument.set_enabled(True)
self._main_modes = ModesComponent(name = 'MainModes')
self._main_modes.add_mode('disabled', [self._background])
self._main_modes.add_mode('MixMode', [common,
self._instrument,
self._instrument.shift_button_layer,
self._mixer,
main_faders,
self._mixer.main_knobs_layer,
self._device,
self._device.main_layer,
self._device_navigator,
self._device_navigator.main_layer,
self._device_navigator.select_dial_layer])
self._main_modes.add_mode('ModSwitcher', [common,
main_faders,
main_dials,
self._mixer.main_knobs_layer,
self._view_control,
self._view_control.main_layer,
self._device_navigator,
self._device_navigator.select_dial_layer,
self.encoder_navigation_on,
self._modswitcher,
DelayMode(self._update_modswitcher, delay = .1)],
behaviour = ColoredCancellableBehaviourWithRelease(color = 'ModeButtons.ModSwitcher', off_color = 'ModeButtons.ModSwitcherDisabled'))
self._main_modes.add_mode('Translations', [common,
main_faders,
main_dials,
self._mixer.main_knobs_layer,
self._translations,
DelayMode(self._translations.selector_layer, delay = .1)],
behaviour = DefaultedBehaviour(default_mode = 'MixMode', color = 'ModeButtons.Translations', off_color = 'ModeButtons.TranslationsDisabled'))
self._main_modes.add_mode('DeviceSelector', [common,
self._device_selector,
DelayMode(self._device_selector.select_layer, delay = .1),
DelayMode(self.modhandler.lock_layer, delay = .1),
DelayMode(self._device_selector.assign_layer, delay = .5),
main_buttons,
main_dials,
main_faders,
self._mixer.main_knobs_layer,
self._device.main_layer,
self._device_navigator,
self._device_navigator.main_layer,
self._device_navigator.select_dial_layer],
behaviour = ColoredCancellableBehaviourWithRelease(color = 'ModeButtons.DeviceSelector', off_color = 'ModeButtons.DeviceSelectorDisabled'))
self._main_modes.layer = Layer(priority = 4, ModSwitcher_button = self._encoder_button[2], DeviceSelector_button = self._encoder_button[0], Translations_button = self._encoder_button[3]) #,
self._main_modes.selected_mode = 'disabled'
self._main_modes.set_enabled(True)
self._test.subject = self._instrument._main_modes
def _setup_modes(self):
pass
def _setup_m4l_interface(self):
self._m4l_interface = M4LInterfaceComponent(controls=self.controls, component_guard=self.component_guard, priority = 10)
self._m4l_interface.name = "M4LInterface"
self.get_control_names = self._m4l_interface.get_control_names
self.get_control = self._m4l_interface.get_control
self.grab_control = self._m4l_interface.grab_control
self.release_control = self._m4l_interface.release_control
def _can_auto_arm_track(self, track):
routing = track.current_input_routing
return routing == 'Ext: All Ins' or routing == 'All Ins' or routing.startswith('Cntrlr Input')
def _get_num_tracks(self):
return self.num_tracks
# a
class ATOM(ControlSurface):
def __init__(self, *a, **k):
(super(ATOM, self).__init__)(*a, **k)
with self.component_guard():
with inject(skin=(const(skin))).everywhere():
self._elements = Elements()
with self.component_guard():
with inject(
element_container=(const(self._elements))).everywhere():
self._create_lighting()
self._create_transport()
self._create_record_modes()
self._create_undo()
self._create_view_toggle()
self._create_background()
self._create_session()
self._create_mixer()
self._create_encoder_modes()
self._create_session_navigation_modes()
self._create_keyboard()
self._create_drum_group()
self._create_note_modes()
self._create_pad_modes()
self._create_user_assignments_mode()
self._target_track = ArmedTargetTrackComponent(
name='Target_Track')
self._ATOM__on_target_track_changed.subject = self._target_track
self._ATOM__on_native_mode_reply.subject = self._elements.native_mode_reply_element
self._drum_group_finder = self.register_disconnectable(
PercussionInstrumentFinder(
device_parent=(self._target_track.target_track)))
self._ATOM__on_drum_group_changed.subject = self._drum_group_finder
self._ATOM__on_drum_group_changed()
self._ATOM__on_main_view_changed.subject = self.application.view
def disconnect(self):
self._send_midi(midi.NATIVE_MODE_OFF_MESSAGE)
super(ATOM, self).disconnect()
def port_settings_changed(self):
self._session_ring.set_enabled(False)
self._send_midi(midi.NATIVE_MODE_ON_MESSAGE)
super(ATOM, self).port_settings_changed()
def _create_lighting(self):
self._lighting = LightingComponent(name='Lighting',
is_enabled=False,
layer=Layer(
shift_button='shift_button',
zoom_button='zoom_button'))
self._lighting.set_enabled(True)
def _create_transport(self):
self._transport = TransportComponent(
name='Transport',
is_enabled=False,
layer=Layer(play_button='play_button',
loop_button='play_button_with_shift',
stop_button='stop_button',
metronome_button='click_button'))
self._transport.set_enabled(True)
def _create_record_modes(self):
self._session_record = SessionRecordingComponent(
name='Session_Record',
is_enabled=False,
layer=Layer(record_button='record_button'))
self._record_modes = ModesComponent(name='Record_Modes')
self._record_modes.add_mode('session', self._session_record)
self._record_modes.add_mode(
'arrange',
AddLayerMode((self._transport),
layer=Layer(record_button='record_button')))
self._ATOM__on_main_view_changed()
def _create_undo(self):
self._undo = UndoRedoComponent(
name='Undo',
is_enabled=False,
layer=Layer(undo_button='stop_button_with_shift'))
self._undo.set_enabled(True)
def _create_view_toggle(self):
self._view_toggle = ViewToggleComponent(
name='View_Toggle',
is_enabled=False,
layer=Layer(detail_view_toggle_button='show_hide_button',
main_view_toggle_button='preset_button'))
self._view_toggle.set_enabled(True)
def _create_background(self):
self._background = BackgroundComponent(
name='Background',
is_enabled=False,
add_nop_listeners=True,
layer=Layer(set_loop_button='set_loop_button',
nudge_button='nudge_button',
bank_button='bank_button'))
self._background.set_enabled(True)
def _create_session(self):
self._session_ring = SessionRingComponent(name='Session_Ring',
is_enabled=False,
num_tracks=SESSION_WIDTH,
num_scenes=SESSION_HEIGHT)
self._session = SessionComponent(name='Session',
session_ring=(self._session_ring))
self._session_navigation = SessionNavigationComponent(
name='Session_Navigation',
is_enabled=False,
session_ring=(self._session_ring),
layer=Layer(left_button='left_button',
right_button='right_button'))
self._session_navigation.set_enabled(True)
self._session_overview = SessionOverviewComponent(
name='Session_Overview',
is_enabled=False,
session_ring=(self._session_ring),
enable_skinning=True,
layer=Layer(button_matrix='pads_with_zoom'))
def _create_mixer(self):
self._mixer = MixerComponent(
name='Mixer',
auto_name=True,
tracks_provider=(self._session_ring),
track_assigner=(SimpleTrackAssigner()),
invert_mute_feedback=True,
channel_strip_component_type=ChannelStripComponent)
def _create_encoder_modes(self):
self._encoder_modes = ModesComponent(name='Encoder_Modes',
enable_skinning=True)
self._encoder_modes.add_mode(
'volume',
AddLayerMode(self._mixer, Layer(volume_controls='encoders')))
self._encoder_modes.add_mode(
'pan', AddLayerMode(self._mixer, Layer(pan_controls='encoders')))
self._encoder_modes.add_mode(
'send_a',
AddLayerMode(self._mixer, Layer(send_a_controls='encoders')))
self._encoder_modes.add_mode(
'send_b',
AddLayerMode(self._mixer, Layer(send_b_controls='encoders')))
self._encoder_modes.selected_mode = 'volume'
def _create_session_navigation_modes(self):
self._session_navigation_modes = ModesComponent(
name='Session_Navigation_Modes',
is_enabled=False,
layer=Layer(cycle_mode_button='bank_button'))
self._session_navigation_modes.add_mode(
'default',
AddLayerMode((self._session_navigation),
layer=Layer(up_button='up_button',
down_button='down_button')),
cycle_mode_button_color='DefaultButton.Off')
self._session_navigation_modes.add_mode(
'paged',
AddLayerMode((self._session_navigation),
layer=Layer(page_up_button='up_button',
page_down_button='down_button',
page_left_button='left_button',
page_right_button='right_button')),
cycle_mode_button_color='DefaultButton.On')
self._session_navigation_modes.selected_mode = 'default'
def _create_keyboard(self):
self._keyboard = KeyboardComponent(
(midi.KEYBOARD_CHANNEL),
name='Keyboard',
is_enabled=False,
layer=Layer(matrix='pads',
scroll_up_button='up_button',
scroll_down_button='down_button'))
def _create_drum_group(self):
self._drum_group = DrumGroupComponent(
name='Drum_Group',
is_enabled=False,
translation_channel=(midi.DRUM_CHANNEL),
layer=Layer(matrix='pads',
scroll_page_up_button='up_button',
scroll_page_down_button='down_button'))
def _create_note_modes(self):
self._note_modes = ModesComponent(name='Note_Modes', is_enabled=False)
self._note_modes.add_mode('keyboard', self._keyboard)
self._note_modes.add_mode('drum', self._drum_group)
self._note_modes.selected_mode = 'keyboard'
def _create_pad_modes(self):
self._pad_modes = ModesComponent(
name='Pad_Modes',
is_enabled=False,
layer=Layer(session_button='full_level_button',
note_button='note_repeat_button',
channel_button='select_button',
encoder_modes_button='setup_button'))
self._pad_modes.add_mode(
'session',
(AddLayerMode(self._background,
Layer(unused_pads='pads_with_shift')),
AddLayerMode(
self._session,
Layer(clip_launch_buttons='pads',
scene_launch_buttons=(
self._elements.pads_with_shift.submatrix[3:, :]))),
self._session_overview, self._session_navigation_modes))
self._pad_modes.add_mode('note', self._note_modes)
self._pad_modes.add_mode(
'channel',
(self._elements.pads.reset,
AddLayerMode(
self._mixer,
Layer(arm_buttons=(self._elements.pads.submatrix[:, :1]),
solo_buttons=(self._elements.pads.submatrix[:, 1:2]),
track_select_buttons=(
self._elements.pads.submatrix[:, 2:3]))),
AddLayerMode(
self._session,
Layer(stop_track_clip_buttons=(
self._elements.pads.submatrix[:, 3:]))),
self._session_navigation_modes))
self._pad_modes.add_mode(
'encoder_modes',
(LayerMode(
self._encoder_modes,
Layer(volume_button=(self._elements.pads_raw[0][0]),
pan_button=(self._elements.pads_raw[0][1]),
send_a_button=(self._elements.pads_raw[0][2]),
send_b_button=(self._elements.pads_raw[0][3]))),
AddLayerMode(
self._background,
Layer(unused_pads=(self._elements.pads.submatrix[:, 1:])))),
behaviour=(MomentaryBehaviour()))
self._pad_modes.selected_mode = 'session'
self._pad_modes.set_enabled(True)
def _create_user_assignments_mode(self):
self._translating_background = TranslatingBackgroundComponent(
(midi.USER_CHANNEL),
name='Translating_Background',
is_enabled=False,
add_nop_listeners=True,
layer=Layer(note_repeat_button='note_repeat_button',
full_level_button='full_level_button',
bank_button='bank_button',
preset_button='preset_button',
show_hide_button='show_hide_button',
nudge_button='nudge_button',
set_loop_button='set_loop_button',
setup_button='setup_button',
up_button='up_button',
down_button='down_button',
left_button='left_button',
right_button='right_button',
select_button='select_button',
click_button='click_button',
record_button='record_button',
play_button='play_button',
stop_button='stop_button',
pads='pads',
encoders='encoders'))
self._top_level_modes = ModesComponent(
name='Top_Level_Modes',
is_enabled=False,
support_momentary_mode_cycling=False,
layer=Layer(cycle_mode_button='editor_button'))
self._top_level_modes.add_mode(
'default', (self.refresh_state),
cycle_mode_button_color='DefaultButton.Off')
self._top_level_modes.add_mode(
'user', (self._translating_background),
cycle_mode_button_color='DefaultButton.On')
self._top_level_modes.selected_mode = 'default'
self._top_level_modes.set_enabled(True)
@listens('is_view_visible', 'Session')
def __on_main_view_changed(self):
if self.application.view.is_view_visible('Session'):
self._record_modes.selected_mode = 'session'
else:
self._record_modes.selected_mode = 'arrange'
@listens('target_track')
def __on_target_track_changed(self):
self._drum_group_finder.device_parent = self._target_track.target_track
@listens('instrument')
def __on_drum_group_changed(self):
drum_group = self._drum_group_finder.drum_group
self._drum_group.set_drum_group_device(drum_group)
self._note_modes.selected_mode = 'drum' if liveobj_valid(
drum_group) else 'keyboard'
@listens('value')
def __on_native_mode_reply(self, _):
self._session_ring.set_enabled(True)
class Cntrlr(Base_Cntrlr):
def __init__(self, *a, **k):
super(Cntrlr, self).__init__(*a, **k)
self._skin = Skin(CntrlrColors)
for button in self._grid:
button._skin = self._skin
for button in self._button:
button._skin = self._skin
for button in self._encoder_button:
button._skin = self._skin
self._main_modes.selected_mode = 'FrederikMode'
self._on_detail_clip_changed.subject = self.song.view
self._on_selected_scene_changed.subject = self.song.view
#self.set_feedback_channels(range(0, 15))
#self.schedule_message(10, self.initialize_frederik_mode)
@listens(u'selected_scene')
def _on_selected_scene_changed(self):
self._scene_scroller.update()
def initialize_frederik_mode(self):
self._main_modes.selected_mode = "FrederikMode"
def _open_log(self):
self.log_message("<<<<<<<<<<<<<<<<<<<<= " + str(self._host_name) +
" for Frederik Poisquet " + str(self._version_check) +
" log opened =>>>>>>>>>>>>>>>>>>>")
self.show_message(str(self._host_name) + ' Control Surface Loaded')
def _initialize_script(self):
super(Cntrlr, self)._initialize_script()
self._connected = True
#self._main_modes.selected_mode = 'FrederikMode'
#self._main_modes.set_enabled(True)
#self._instrument.set_enabled(True)
self._main_modes.selected_mode = 'disabled'
self._main_modes.selected_mode = 'FrederikMode'
#self._session_ring._update_highlight()
def _define_sysex(self):
self.encoder_navigation_on = SendLividSysexMode(
livid_settings=self._livid_settings,
call='set_encoder_encosion_mode',
message=[0, 0, 0, 0])
def _setup_session_control(self):
self._session_ring = SessionRingComponent(num_tracks=4, num_scenes=4)
self._session_ring.set_enabled(False)
self._session_navigation = CntrlrSessionNavigationComponent(
name='SessionNavigation', session_ring=self._session_ring)
self._session_navigation._vertical_banking.scroll_up_button.color = 'Session.NavigationButtonOn'
self._session_navigation._vertical_banking.scroll_down_button.color = 'Session.NavigationButtonOn'
self._session_navigation._horizontal_banking.scroll_up_button.color = 'Session.NavigationButtonOn'
self._session_navigation._horizontal_banking.scroll_down_button.color = 'Session.NavigationButtonOn'
self._session_navigation._vertical_paginator.scroll_up_button.color = 'Session.PageNavigationButtonOn'
self._session_navigation._vertical_paginator.scroll_down_button.color = 'Session.PageNavigationButtonOn'
self._session_navigation._horizontal_paginator.scroll_up_button.color = 'Session.PageNavigationButtonOn'
self._session_navigation._horizontal_paginator.scroll_down_button.color = 'Session.PageNavigationButtonOn'
self._session_navigation.bank_dial_layer = AddLayerMode(
self._session_navigation, Layer(priority=5, ))
self._session_navigation.nav_dial_layer = AddLayerMode(
self._session_navigation, Layer(priority=5, ))
self._session_navigation.select_dial_layer = AddLayerMode(
self._session_navigation, Layer(priority=5))
self._session_navigation.nav_layer = AddLayerMode(
self._session_navigation, Layer(priority=5, ))
self._session_navigation.set_enabled(False)
self._session = SessionComponent(session_ring=self._session_ring,
auto_name=True)
hasattr(self._session,
'_enable_skinning') and self._session._enable_skinning()
self._session.clip_launch_layer = LayerMode(
self._session,
Layer(priority=5, stop_all_clips_button=self._button[27]))
self._session.stop_all_clips_layer = AddLayerMode(
self._session,
Layer(priority=6, stop_all_clips_button=self._button[27]))
self._session.scene_launch_layer = AddLayerMode(
self._session._selected_scene,
Layer(priority=5, stop_all_clips_button=self._button[27]))
self._session.set_enabled(False)
self._session_zoom = SessionOverviewComponent(
name='SessionZoom',
session_ring=self._session_ring,
enable_skinning=True)
self._session_zoom.layer = Layer(priority=5, )
self._session_zoom.set_enabled(False)
self._session_ring2 = SessionRingComponent(num_tracks=4,
num_scenes=1,
set_session_highlight=nop)
self._session_ring2.set_enabled(False)
self._session2 = SpecialSessionComponent(
session_ring=self._session_ring2, auto_name=True)
self._session2._selected_scene.layer = Layer(
priority=5, launch_button=self._button[30])
self._session2.layer = Layer(
priority=5,
stop_all_clips_button=self._button[27],
fire_next_scene_button=self._button[31]
) #, fire_scene_button = self._button[28])
self._scene_scroller = ScrollComponent(
scrollable=SelectedSceneScroller(song=self.song))
self._scene_scroller.layer = Layer(priority=5,
scroll_up_button=self._button[29],
scroll_down_button=self._button[28])
self._scene_scroller.set_enabled(False)
def _setup_mixer_control(self):
super(Cntrlr, self)._setup_mixer_control()
self._mixer.main_faders_layer = AddLayerMode(self._mixer,
Layer(priority=5, ))
self._mixer.main_buttons_layer = AddLayerMode(self._mixer,
Layer(priority=5, ))
self._mixer.solo_buttons_layer = AddLayerMode(self._mixer,
Layer(priority=5, ))
self._mixer.shifted_buttons_layer = AddLayerMode(
self._mixer, Layer(priority=5, ))
self._mixer.main_knobs_layer = AddLayerMode(self._mixer,
Layer(priority=5, ))
self._mixer.master_fader_layer = AddLayerMode(
self._mixer.master_strip(), Layer(priority=5, ))
self._mixer.instrument_buttons_layer = AddLayerMode(
self._mixer, Layer(priority=5, ))
self._mixer.stop_layer = AddLayerMode(self._mixer, Layer(priority=5, ))
self._mixer.set_enabled(False)
def _setup_transport_control(self):
super(Cntrlr, self)._setup_transport_control()
self._transport.layer = Layer(priority=5, )
def _setup_session_recording_component(self):
super(Cntrlr, self)._setup_session_recording_component()
self._recorder.main_layer = AddLayerMode(self._recorder,
Layer(priority=5, ))
self._recorder.shift_layer = AddLayerMode(self._recorder,
Layer(priority=5, ))
self._recorder.set_enabled(False)
def _setup_device_control(self):
super(Cntrlr, self)._setup_device_control()
self._device.dial_layer = AddLayerMode(self._device,
Layer(priority=5, ))
self._device.button_layer = AddLayerMode(self._device,
Layer(priority=5, ))
self._device_navigator.select_dial_layer = AddLayerMode(
self._device_navigator, Layer(priority=5, ))
self._device_navigator.main_layer = AddLayerMode(
self._device_navigator, Layer(priority=5, ))
def _setup_device_selector(self):
super(Cntrlr, self)._setup_device_selector()
self._device_selector.select_layer = AddLayerMode(
self._device_selector, Layer(priority=6, ))
self._device_selector.assign_layer = AddLayerMode(
self._device_selector, Layer(priority=7, ))
def _setup_viewcontrol(self):
super(Cntrlr, self)._setup_viewcontrol()
self._view_control.main_layer = AddLayerMode(self._view_control,
Layer(priority=6, ))
def _update_modswitcher(self):
debug('update modswitcher', self.modhandler.active_mod())
self._modswitcher.selected_mode = 'instrument'
def _setup_translations(self):
super(Cntrlr, self)._setup_translations()
self._setup_translations2()
def _setup_translations2(self):
self._translated_controls2 = self._knobs + self._button[
16:28] + self._fader + self._encoder + self._encoder_button
self._translations2 = TranslationComponent(self._translated_controls2,
user_channel_offset=15,
channel=15)
self._translations2.name = 'TranslationComponent'
self._translations2.layer = Layer(priority=10, )
self._translations2.set_enabled(True)
def _setup_instrument(self):
super(Cntrlr, self)._setup_instrument()
self._instrument._main_modes._mode_map['audioloop'] = _ModeEntry(
mode=tomode(self._audioloop_pass),
cycle_mode_button_color=None,
behaviour=self._instrument._main_modes.default_behaviour,
groups=set())
self._instrument.shift_button_layer = AddLayerMode(
self._instrument, Layer(priority=5, ))
self._instrument._drumpad._step_sequencer._loop_selector._follow_task.restart(
)
#self._instrument._drumpad._step_sequencer._playhead_component._feedback_channels = range(16)
def _setup_instrument(self):
self._grid_resolution = self.register_disconnectable(GridResolution())
#self._c_instance.playhead.enabled = True
self._playhead_element = PlayheadElement(self._c_instance.playhead)
self._drum_group_finder = PercussionInstrumentFinder(
device_parent=self.song.view.selected_track)
self._instrument = CntrlrMonoInstrumentComponent(
name='InstrumentComponent',
is_enabled=True,
script=self,
skin=self._skin,
grid_resolution=self._grid_resolution,
drum_group_finder=self._drum_group_finder,
parent_task_group=self._task_group,
settings=DEFAULT_INSTRUMENT_SETTINGS,
device_provider=self._device_provider)
self._instrument.shift_button_layer = AddLayerMode(
self._instrument, Layer(priority=5, ))
self._instrument.audioloop_layer = AddLayerMode(
self._instrument,
Layer(
priority=5,
loop_selector_matrix=self._key_matrix.submatrix[:, 0],
))
self._instrument.keypad_shift_layer = AddLayerMode(
self._instrument,
Layer(priority=5,
scale_up_button=self._button[13],
scale_down_button=self._button[12],
offset_up_button=self._button[11],
offset_down_button=self._button[10],
vertical_offset_up_button=self._button[9],
vertical_offset_down_button=self._button[8],
split_button=self._button[14],
sequencer_button=self._button[15]))
self._instrument.drumpad_shift_layer = AddLayerMode(
self._instrument,
Layer(priority=5,
scale_up_button=self._button[13],
scale_down_button=self._button[12],
drum_offset_up_button=self._button[11],
drum_offset_down_button=self._button[10],
drumpad_mute_button=self._button[9],
drumpad_solo_button=self._button[8],
split_button=self._button[14],
sequencer_button=self._button[15]))
self._instrument._keypad.sequencer_layer = LayerMode(
self._instrument._keypad,
Layer(
priority=5,
playhead=self._playhead_element,
keypad_matrix=self._matrix.submatrix[:, :],
sequencer_matrix=self._key_matrix.submatrix[:, 0],
))
self._instrument._keypad.split_layer = LayerMode(
self._instrument._keypad,
Layer(priority=5,
keypad_matrix=self._matrix.submatrix[:, :],
split_matrix=self._key_matrix.submatrix[:14, 0]))
self._instrument._keypad.sequencer_shift_layer = LayerMode(
self._instrument._keypad,
Layer(
priority=5,
keypad_select_matrix=self._matrix.submatrix[:, :],
loop_selector_matrix=self._key_matrix.submatrix[:8, 0],
quantization_buttons=self._key_matrix.submatrix[:8, 1],
))
#follow_button = self._button[23]))
self._instrument._keypad.sequencer_session_layer = LayerMode(
self._instrument._keypad,
Layer(priority=5,
playhead=self._playhead_element,
sequencer_matrix=self._key_matrix.submatrix[:, :1]))
self._instrument._keypad.split_session_layer = LayerMode(
self._instrument._keypad,
Layer(priority=5,
split_matrix=self._key_matrix.submatrix[:16, :1]))
self._instrument._keypad.sequencer_session_shift_layer = LayerMode(
self._instrument._keypad,
Layer(
priority=5,
loop_selector_matrix=self._key_matrix.submatrix[:8, :1],
quantization_buttons=self._key_matrix.submatrix[:7, 1:],
))
#follow_button = self._button[23]))
self._instrument._drumpad.sequencer_layer = LayerMode(
self._instrument._drumpad,
Layer(
priority=5,
playhead=self._playhead_element,
drumpad_matrix=self._matrix.submatrix[:, :],
sequencer_matrix=self._key_matrix.submatrix[:, 0],
))
self._instrument._drumpad.split_layer = LayerMode(
self._instrument._drumpad,
Layer(priority=5,
drumpad_matrix=self._matrix.submatrix[:, :],
split_matrix=self._key_matrix.submatrix[:16, :1]))
self._instrument._drumpad.sequencer_shift_layer = LayerMode(
self._instrument._drumpad,
Layer(
priority=5,
drumpad_select_matrix=self._matrix.submatrix[:, :],
loop_selector_matrix=self._key_matrix.submatrix[:8, :1],
quantization_buttons=self._key_matrix.submatrix[:7, 1:],
))
#follow_button = self._button[23]))
self._instrument._drumpad.sequencer_session_layer = LayerMode(
self._instrument._drumpad,
Layer(priority=5,
sequencer_matrix=self._key_matrix.submatrix[:, :1]))
self._instrument._drumpad.split_session_layer = LayerMode(
self._instrument._drumpad,
Layer(priority=5,
split_matrix=self._key_matrix.submatrix[:16, :1]))
self._instrument._drumpad.sequencer_session_shift_layer = LayerMode(
self._instrument._drumpad,
Layer(
priority=5,
loop_selector_matrix=self._key_matrix.submatrix[:8, :1],
quantization_buttons=self._key_matrix.submatrix[:8, 1:],
)) #follow_button = self._button[23]))
#self._instrument.set_session_mode_button(self._button[30])
def _setup_modes(self):
common = CompoundMode(self._mixer, self._session_ring)
main_buttons = CompoundMode(self._mixer.main_buttons_layer,
self._transport, self._recorder,
self._recorder.main_layer, self._device,
self._device.button_layer)
shifted_main_buttons = CompoundMode(
self._mixer.solo_buttons_layer, self._recorder,
self._recorder.shift_layer, self._session,
self._session.scene_launch_layer, self._device,
self._device.button_layer)
main_faders = CompoundMode(self._mixer.main_faders_layer,
self._mixer.master_fader_layer)
main_dials = CompoundMode(self._view_control,
self._view_control.main_layer, self._device,
self._device.dial_layer,
self._device_navigator.select_dial_layer,
self.encoder_navigation_on)
shifted_dials = CompoundMode(self._session_navigation,
self._session_navigation.nav_dial_layer,
self._device, self._device.dial_layer,
self._device_navigator.select_dial_layer,
self.encoder_navigation_on)
self._modalt_mode = ModesComponent(name='ModAltMode')
self._modalt_mode.add_mode('disabled', None)
self._modalt_mode.add_mode(
'enabled', [tuple([self._enable_mod_alt, self._disable_mod_alt])],
behaviour=CancellableBehaviourWithRelease(),
cycle_mode_button_color='Mod.AltOn')
self._modalt_mode.selected_mode = 'disabled'
self._modalt_mode.set_enabled(False)
self._modalt_mode.layer = Layer(priority=5,
enabled_button=self._encoder_button[1])
self._modswitcher = ModesComponent(name='ModSwitcher')
self._modswitcher.add_mode('mod', [
self.modhandler, self._modalt_mode, main_faders,
self._mixer.main_knobs_layer, self._device,
self._device.dial_layer, self._device_navigator.main_layer,
main_dials,
DelayMode(self.modhandler.update,
delay=.5,
parent_task_group=self._task_group)
])
self._modswitcher.add_mode('instrument', [
self._instrument,
self._instrument.shift_button_layer,
main_buttons,
main_faders,
self._mixer.main_knobs_layer,
self._device,
self._device.dial_layer,
self._device.button_layer,
self._device_navigator.main_layer,
]) #self._instrument.shift_button_layer, self._optional_translations])
self._modswitcher.selected_mode = 'instrument'
self._modswitcher.set_enabled(False)
self._instrument._main_modes = ModesComponent(parent=self._instrument,
name='InstrumentModes')
self._instrument._main_modes.add_mode('disabled', [])
self._instrument._main_modes.add_mode('drumpad', [
self._instrument._drumpad.sequencer_layer, main_buttons, main_dials
])
self._instrument._main_modes.add_mode('drumpad_split', [
self._instrument._drumpad.split_layer,
self._instrument._selected_session, main_buttons, main_dials
])
self._instrument._main_modes.add_mode('drumpad_sequencer', [
self._instrument._drumpad.sequencer_layer, main_buttons, main_dials
])
self._instrument._main_modes.add_mode('drumpad_shifted', [])
self._instrument._main_modes.add_mode('drumpad_split_shifted', [])
self._instrument._main_modes.add_mode('drumpad_sequencer_shifted', [])
self._instrument._main_modes.add_mode('keypad', [
self._instrument._keypad.sequencer_layer, main_buttons, main_dials
])
self._instrument._main_modes.add_mode('keypad_split', [
self._instrument._keypad.split_layer,
self._instrument._selected_session, main_buttons, main_dials
])
self._instrument._main_modes.add_mode('keypad_sequencer', [
self._instrument._keypad.sequencer_layer, main_buttons, main_dials
])
self._instrument._main_modes.add_mode('keypad_shifted', [])
self._instrument._main_modes.add_mode('keypad_split_shifted', [])
self._instrument._main_modes.add_mode('keypad_sequencer_shifted', [])
self._instrument._main_modes.add_mode('drumpad_session', [])
self._instrument._main_modes.add_mode('drumpad_split_session', [])
self._instrument._main_modes.add_mode('drumpad_sequencer_session', [])
self._instrument._main_modes.add_mode('drumpad_shifted_session', [])
self._instrument._main_modes.add_mode('drumpad_split_shifted_session',
[])
self._instrument._main_modes.add_mode(
'drumpad_sequencer_shifted_session', [])
self._instrument._main_modes.add_mode('keypad_session', [])
self._instrument._main_modes.add_mode('keypad_split_session', [])
self._instrument._main_modes.add_mode('keypad_sequencer_session', [])
self._instrument._main_modes.add_mode('keypad_shifted_session', [])
self._instrument._main_modes.add_mode('keypad_split_shifted_session',
[])
self._instrument._main_modes.add_mode(
'keypad_sequencer_shifted_session', [])
self._instrument._main_modes.add_mode('audioloop', [
self._instrument.audioloop_layer,
])
self._instrument._main_modes.add_mode('audioloop_shifted', [
self._instrument.audioloop_layer,
])
self._instrument._main_modes.selected_mode = 'disabled'
self._instrument.set_enabled(True)
self._main_modes = ModesComponent(name='MainModes')
self._main_modes.add_mode('disabled', [self._background])
self._main_modes.add_mode('MixMode', [
common,
self._instrument,
self._instrument.shift_button_layer,
self._mixer,
main_faders,
self._mixer.main_knobs_layer,
self._device,
self._device_navigator,
self._device_navigator.main_layer,
])
self._main_modes.add_mode(
'ModSwitcher', [
common, main_faders, main_dials, self._mixer.main_knobs_layer,
self._session_navigation.select_dial_layer, self._view_control,
self._view_control.main_layer,
self._device_navigator.select_dial_layer,
self.encoder_navigation_on, self._modswitcher,
DelayMode(self._update_modswitcher, delay=.1)
],
behaviour=ColoredCancellableBehaviourWithRelease(
color='ModeButtons.ModSwitcher',
off_color='ModeButtons.ModSwitcherDisabled'))
self._main_modes.add_mode(
'Translations', [
common, main_faders, main_dials, self._mixer.main_knobs_layer,
DelayMode(self._translations, delay=.1),
DelayMode(self._translations.selector_layer, delay=.3)
],
behaviour=DefaultedBehaviour(
default_mode='MixMode',
color='ModeButtons.Translations',
off_color='ModeButtons.TranslationsDisabled'))
self._main_modes.add_mode(
'DeviceSelector', [
common, self._device_selector,
DelayMode(self._device_selector.select_layer, delay=.1),
DelayMode(self.modhandler.lock_layer, delay=.1),
DelayMode(self._device_selector.assign_layer,
delay=.5), main_buttons, main_dials, main_faders,
self._mixer.main_knobs_layer, self._device,
self._device_navigator
],
behaviour=ColoredCancellableBehaviourWithRelease(
color='ModeButtons.DeviceSelector',
off_color='ModeButtons.DeviceSelectorDisabled'))
self._main_modes.add_mode('FrederikMode', [
self._instrument, self._scene_scroller, self._session2,
self._translations2
])
self._main_modes.layer = Layer(priority=5)
self._main_modes.selected_mode = 'FrederikMode'
self._main_modes.set_enabled(True)
#self._test.subject = self._instrument._main_modes
@listens(u'detail_clip')
def _on_detail_clip_changed(self):
self._instrument._drumpad._step_sequencer._loop_selector._follow_task.restart(
)
#playhead = self._instrument._drumpad._step_sequencer._playhead_component
#debug('VVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVV')
#debug('playhead playhead:', playhead._playhead)
#debug('playhead clip:', playhead._clip.name if playhead._clip and hasattr(playhead._clip, 'name') else None)
#debug('playhead notes:', playhead._notes)
#debug('playhead feedback_channels:', playhead._feedback_channels)
#debug('enabled:', playhead._playhead.enabled if playhead._playhead and hasattr(playhead._playhead, 'enabled') else 'False')
#debug('^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^')
#self.schedule_message(2, self.update_playhead)
@listens('selected_mode')
def _test(self, *a):
comps = [
self._main_modes, self._modswitcher, self._instrument,
self._instrument._main_modes, self._instrument._matrix_modes,
self._instrument._selected_session, self._session, self._device,
self._mixer, self._session_navigation, self._session_zoom,
self._recorder, self._transport
]
debug('VVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVV')
"""
debug('main mode:', self._main_modes.selected_mode)
debug('instrument mode:', self._instrument._main_modes.selected_mode)
debug('modswitcher mode:', self._modswitcher.selected_mode)
debug('instrument matrix mode:', self._instrument._matrix_modes.selected_mode)
for comp in comps:
debug(comp.name, 'is enabled:', comp.is_enabled())
"""
playhead = self._instrument._drumpad._step_sequencer._note_editor._playhead_component
debug('playhead playhead:', playhead._playhead)
debug('playhead clip:', playhead._clip)
debug('playhead notes:', playhead._notes)
debug('playhead playhead:', playhead._playhead)
debug('playhead feedback_channels:', playhead._feedback_channels)
debug('^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^')
class Cntrlr(BaseCntrlr):
def __init__(self, *a, **k):
super(Cntrlr, self).__init__(*a, **k)
self._skin = Skin(CntrlrColors)
for button in self._grid:
button._skin = self._skin
def _open_log(self):
self.log_message("<<<<<<<<<<<<<<<<<<<<= " + str(self._host_name) +
" for Georg Oswald " + str(self._version_check) +
" log opened =>>>>>>>>>>>>>>>>>>>")
self.show_message(str(self._host_name) + ' Control Surface Loaded')
def _setup_transport_control(self):
super(Cntrlr, self)._setup_transport_control()
self._transport._overdub_toggle.view_transform = lambda value: 'Transport.OverdubOn' if value else 'Transport.OverdubOff'
self._transport.layer = Layer(priority=4, play_button=self._button[24])
self._transport.overdub_layer = AddLayerMode(
self._transport, Layer(priority=4,
overdub_button=self._button[25]))
def _setup_session_control(self):
super(Cntrlr, self)._setup_session_control()
self._session_navigation.nav_layer = AddLayerMode(
self._session_navigation,
Layer(priority=4,
page_down_button=self._button[23],
page_up_button=self._button[22],
page_left_button=self._button[20],
page_right_button=self._button[21]))
self._session.G_layer = AddLayerMode(
self._session,
Layer(priority=4,
scene_launch_buttons=self._key_matrix.submatrix[4:8, 0]))
self._session.stop_clips_layer = AddLayerMode(self._session,
Layer(priority=4, ))
#stop_all_clips_button = self._button[29],))
def _setup_session_recording_component(self):
super(Cntrlr, self)._setup_session_recording_component()
self._recorder.main_layer = AddLayerMode(self._recorder,
Layer(priority=4))
self._recorder.shift_layer = AddLayerMode(
self._recorder,
Layer(priority=4, automation_button=self._button[25]))
def _setup_mixer_control(self):
super(Cntrlr, self)._setup_mixer_control()
mute_buttons = ButtonMatrixElement(
name='mute_buttons', rows=[self._button[:4] + self._button[12:16]])
select_buttons = ButtonMatrixElement(
name='select_buttons',
rows=[self._button[16:20] + self._button[28:32]])
self._G_session_ring = SessionRingComponent(num_tracks=8, num_scenes=4)
self._G_session_ring.set_enabled(False)
self._G_mixer = MonoMixerComponent(
name='Mixer',
num_returns=4,
tracks_provider=self._G_session_ring,
track_assigner=simple_track_assigner,
invert_mute_feedback=True,
auto_name=True,
enable_skinning=True)
if FREE_ENCODER_IS_CROSSFADER:
self._mixer.layer = Layer(priority=4,
crossfader_control=self._encoder[1])
#self._G_mixer.select_dial_layer = AddLayerMode(self._G_mixer, Layer(priority = 5,
# track_select_dial = self._encoder[3],))
self._G_mixer.main_faders_layer = AddLayerMode(
self._G_mixer,
Layer(
priority=4,
volume_controls=self._fader_matrix.submatrix[:8, :],
))
self._G_mixer.main_buttons_layer = AddLayerMode(
self._G_mixer,
Layer(priority=4,
mute_buttons=mute_buttons,
arming_track_select_buttons=select_buttons,
solo_buttons=self._dial_button_matrix,
stop_clip_buttons=self._key_matrix.submatrix[4:12, :1]))
#solo_buttons = self._key_matrix.submatrix[4:12, :1],))
self._G_mixer.shifted_buttons_layer = AddLayerMode(
self._G_mixer, Layer(
priority=4,
mute_buttons=mute_buttons,
))
self._G_mixer.solo_buttons_layer = AddLayerMode(
self._G_mixer,
Layer(
priority=4,
solo_buttons=self._key_matrix.submatrix[4:12, :1],
))
self._G_mixer.mute_buttons_layer = AddLayerMode(
self._G_mixer, Layer(
priority=4,
mute_buttons=mute_buttons,
))
self._G_mixer.stop_layer = AddLayerMode(
self._G_mixer,
Layer(
priority=4,
stop_clip_buttons=self._key_matrix.submatrix[8:12, 1:],
))
self._G_mixer.main_knobs_layer = AddLayerMode(self._G_mixer,
Layer(priority=4))
self._G_mixer.master_fader_layer = AddLayerMode(
self._G_mixer.master_strip(), Layer(priority=4, ))
self._G_mixer.instrument_buttons_layer = AddLayerMode(
self._G_mixer,
Layer(
priority=4,
mute_buttons=mute_buttons,
track_select_buttons=select_buttons,
))
self._G_mixer.set_enabled(False)
def _setup_device_control(self):
super(Cntrlr, self)._setup_device_control()
self._device.button_layer = AddLayerMode(self._device,
Layer(priority=4, ))
self._device_navigator.main_layer = AddLayerMode(
self._device_navigator, Layer(priority=4, ))
#prev_button = self._encoder_button[8],
#next_button = self._encoder_button[9],
#exit_button = self._encoder_button[10],
#enter_button = self._encoder_button[11],))
self._device_navigator.G_layer = AddLayerMode(
self._device_navigator,
Layer(
priority=4,
prev_button=self._button[28],
next_button=self._button[29],
))
def _setup_instrument(self):
self._grid_resolution = self.register_disconnectable(GridResolution())
self._c_instance.playhead.enabled = True
self._playhead_element = PlayheadElement(self._c_instance.playhead)
self._drum_group_finder = PercussionInstrumentFinder(
device_parent=self.song.view.selected_track)
self._instrument = CntrlrMonoInstrumentComponent(
name='InstrumentComponent',
is_enabled=True,
script=self,
skin=self._skin,
grid_resolution=self._grid_resolution,
drum_group_finder=self._drum_group_finder,
parent_task_group=self._task_group,
settings=DEFAULT_INSTRUMENT_SETTINGS,
device_provider=self._device_provider)
self._instrument.shift_button_layer = AddLayerMode(
self._instrument,
Layer(priority=5,
session_mode_button=self._button[26],
shift_mode_button=self._button[27]))
self._instrument.audioloop_layer = AddLayerMode(
self._instrument, Layer(priority=5))
self._instrument.keypad_shift_layer = AddLayerMode(
self._instrument,
Layer(
priority=5,
scale_up_button=self._button[31],
scale_down_button=self._button[30],
offset_up_button=self._button[11],
offset_down_button=self._button[10],
vertical_offset_up_button=self._button[9],
vertical_offset_down_button=self._button[8],
))
self._instrument.drumpad_shift_layer = AddLayerMode(
self._instrument,
Layer(
priority=5,
scale_up_button=self._button[31],
scale_down_button=self._button[30],
drum_offset_up_button=self._button[11],
drum_offset_down_button=self._button[10],
drumpad_mute_button=self._button[9],
drumpad_solo_button=self._button[8],
))
self._instrument._keypad.sequencer_layer = LayerMode(
self._instrument._keypad,
Layer(
priority=5,
playhead=self._playhead_element,
keypad_matrix=self._matrix.submatrix[:, :],
))
self._instrument._keypad.split_layer = LayerMode(
self._instrument._keypad,
Layer(
priority=5,
keypad_matrix=self._matrix.submatrix[:, :],
))
self._instrument._keypad.sequencer_shift_layer = LayerMode(
self._instrument._keypad,
Layer(priority=5,
keypad_matrix=self._matrix.submatrix[:, :],
quantization_buttons=self._key_matrix.submatrix[:7, 1],
follow_button=self._button[23]))
self._instrument._keypad.sequencer_session_layer = LayerMode(
self._instrument._keypad,
Layer(
priority=5,
playhead=self._playhead_element,
))
self._instrument._keypad.split_session_layer = LayerMode(
self._instrument._keypad,
Layer(priority=5,
split_matrix=self._key_matrix.submatrix[:16, :1]))
self._instrument._keypad.sequencer_session_shift_layer = LayerMode(
self._instrument._keypad,
Layer(priority=5,
quantization_buttons=self._key_matrix.submatrix[:7, 1:],
follow_button=self._button[23]))
self._instrument._drumpad.sequencer_layer = LayerMode(
self._instrument._drumpad,
Layer(
priority=5,
playhead=self._playhead_element,
drumpad_matrix=self._matrix.submatrix[:, :],
))
self._instrument._drumpad.split_layer = LayerMode(
self._instrument._drumpad,
Layer(priority=5,
drumpad_matrix=self._matrix.submatrix[:, :],
split_matrix=self._key_matrix.submatrix[:16, :1]))
self._instrument._drumpad.sequencer_shift_layer = LayerMode(
self._instrument._drumpad,
Layer(priority=5,
drumpad_matrix=self._matrix.submatrix[:, :],
quantization_buttons=self._key_matrix.submatrix[:7, 1:],
follow_button=self._button[23]))
self._instrument._drumpad.sequencer_session_layer = LayerMode(
self._instrument._drumpad,
Layer(
priority=5,
playhead=self._playhead_element,
))
self._instrument._drumpad.split_session_layer = LayerMode(
self._instrument._drumpad,
Layer(priority=5,
split_matrix=self._key_matrix.submatrix[:16, :1]))
self._instrument._drumpad.sequencer_session_shift_layer = LayerMode(
self._instrument._drumpad,
Layer(priority=5,
quantization_buttons=self._key_matrix.submatrix[:7, 1:],
follow_button=self._button[23]))
#self._instrument.set_session_mode_button(self._button[30])
def _setup_modes(self):
common = CompoundMode(self._mixer, self._session_ring)
main_buttons = CompoundMode(
self._G_mixer.main_buttons_layer, self._session_navigation,
self._session_navigation.nav_layer, self._transport,
self._transport.overdub_layer, self._recorder,
self._recorder.main_layer, self._device, self._device.button_layer)
shifted_main_buttons = CompoundMode(
self._G_mixer.shifted_buttons_layer,
self._transport,
self._transport.overdub_layer,
#self._recorder,
#self._recorder.shift_layer,
self._session,
self._session.G_layer,
self._session.stop_clips_layer,
self._transport,
self._device,
self._device.button_layer,
self._device_navigator,
self._device_navigator.G_layer)
main_faders = CompoundMode(self._G_mixer,
self._G_mixer.main_faders_layer,
self._G_mixer.master_fader_layer)
main_dials = CompoundMode(self._view_control,
self._view_control.main_layer, self._device,
self._device.dial_layer,
self._device_navigator,
self._device_navigator.select_dial_layer,
self.encoder_navigation_on)
shifted_dials = CompoundMode(self._session_navigation,
self._session_navigation.nav_dial_layer,
self._device, self._device.dial_layer,
self._device_navigator,
self._device_navigator.select_dial_layer,
self.encoder_navigation_on)
self._modalt_mode = ModesComponent(name='ModAltMode')
self._modalt_mode.add_mode('disabled', None)
self._modalt_mode.add_mode(
'enabled', [tuple([self._enable_mod_alt, self._disable_mod_alt])],
behaviour=CancellableBehaviourWithRelease(),
cycle_mode_button_color='Mod.AltOn')
self._modalt_mode.selected_mode = 'disabled'
self._modalt_mode.set_enabled(False)
self._modalt_mode.layer = Layer(priority=4,
enabled_button=self._encoder_button[1])
self._modswitcher = ModesComponent(name='ModSwitcher')
self._modswitcher.add_mode('mod', [
self.modhandler, self._modalt_mode, main_faders,
self._G_mixer.main_knobs_layer, self._device,
self._device.dial_layer, self._device_navigator.main_layer,
main_dials,
DelayMode(self.modhandler.update,
delay=.5,
parent_task_group=self._task_group)
])
self._modswitcher.add_mode('instrument', [
self._instrument,
self._instrument.shift_button_layer,
main_buttons,
main_faders,
self._G_mixer.main_knobs_layer,
self._device,
self._device.dial_layer,
self._device.button_layer,
self._device_navigator.main_layer,
]) #self._instrument.shift_button_layer, self._optional_translations])
self._modswitcher.selected_mode = 'instrument'
self._modswitcher.set_enabled(False)
self._instrument._main_modes = ModesComponent(name='InstrumentModes')
self._instrument._main_modes.add_mode('disabled', [
main_buttons, main_dials, self._session, self._session,
self._session.clip_launch_layer
])
self._instrument._main_modes.add_mode('drumpad', [
self._instrument._drumpad.sequencer_layer, main_buttons, main_dials
])
self._instrument._main_modes.add_mode('drumpad_split', [
self._instrument._drumpad.split_layer,
self._instrument._selected_session, main_buttons, main_dials
])
self._instrument._main_modes.add_mode('drumpad_sequencer', [
self._instrument._drumpad.sequencer_layer, main_buttons, main_dials
])
self._instrument._main_modes.add_mode('drumpad_shifted', [
self._instrument._drumpad.sequencer_shift_layer,
self._instrument.drumpad_shift_layer, shifted_main_buttons,
shifted_dials
])
self._instrument._main_modes.add_mode('drumpad_split_shifted', [
self._instrument._drumpad.split_layer,
self._instrument.drumpad_shift_layer, shifted_main_buttons,
shifted_dials
])
self._instrument._main_modes.add_mode('drumpad_sequencer_shifted', [
self._instrument._drumpad.sequencer_shift_layer,
self._instrument.drumpad_shift_layer, shifted_main_buttons,
shifted_dials
])
self._instrument._main_modes.add_mode('keypad', [
self._instrument._keypad.sequencer_layer, main_buttons, main_dials
])
self._instrument._main_modes.add_mode('keypad_split', [
self._instrument._keypad.split_layer,
self._instrument._selected_session, main_buttons, main_dials
])
self._instrument._main_modes.add_mode('keypad_sequencer', [
self._instrument._keypad.sequencer_layer, main_buttons, main_dials
])
self._instrument._main_modes.add_mode('keypad_shifted', [
self._instrument._keypad.sequencer_shift_layer,
self._instrument.keypad_shift_layer, shifted_main_buttons,
shifted_dials
])
self._instrument._main_modes.add_mode('keypad_split_shifted', [
self._instrument._keypad.split_layer,
self._instrument.keypad_shift_layer, shifted_main_buttons,
shifted_dials
])
self._instrument._main_modes.add_mode('keypad_sequencer_shifted', [
self._instrument._keypad.sequencer_shift_layer,
self._instrument.keypad_shift_layer, shifted_main_buttons,
shifted_dials
])
self._instrument._main_modes.add_mode('drumpad_session', [
self._instrument._drumpad.sequencer_session_layer, main_buttons,
self._session,
DelayMode(self._session.clip_launch_layer, delay=.1), main_dials
])
self._instrument._main_modes.add_mode('drumpad_split_session', [
self._instrument._drumpad.split_session_layer,
self._instrument._selected_session, main_buttons, self._session,
DelayMode(self._session.clip_launch_layer, delay=.1), main_dials
])
self._instrument._main_modes.add_mode('drumpad_sequencer_session', [
self._instrument._drumpad.sequencer_session_layer, main_buttons,
self._session,
DelayMode(self._session.clip_launch_layer, delay=.1), main_dials
])
self._instrument._main_modes.add_mode('drumpad_shifted_session', [
self._instrument._drumpad.sequencer_session_shift_layer,
self._instrument.drumpad_shift_layer, main_buttons, self._session,
shifted_dials
])
self._instrument._main_modes.add_mode(
'drumpad_split_shifted_session', [
self._instrument._drumpad.split_session_layer,
self._instrument.drumpad_shift_layer, shifted_main_buttons,
self._session, shifted_dials
])
self._instrument._main_modes.add_mode(
'drumpad_sequencer_shifted_session', [
self._instrument._drumpad.sequencer_session_shift_layer,
self._instrument.drumpad_shift_layer, shifted_main_buttons,
self._session, shifted_dials
])
self._instrument._main_modes.add_mode('keypad_session', [
self._instrument._keypad.sequencer_session_layer, main_buttons,
self._session,
DelayMode(self._session.clip_launch_layer, delay=.1), main_dials
])
self._instrument._main_modes.add_mode('keypad_split_session', [
self._instrument._keypad.split_session_layer,
self._instrument._selected_session, main_buttons, self._session,
DelayMode(self._session.clip_launch_layer, delay=.1), main_dials
])
self._instrument._main_modes.add_mode('keypad_sequencer_session', [
self._instrument._keypad.sequencer_session_layer, main_buttons,
self._session,
DelayMode(self._session.clip_launch_layer, delay=.1), main_dials
])
self._instrument._main_modes.add_mode('keypad_shifted_session', [
self._instrument._keypad.sequencer_session_shift_layer,
self._instrument.keypad_shift_layer, shifted_main_buttons,
self._session, shifted_dials
])
self._instrument._main_modes.add_mode('keypad_split_shifted_session', [
self._instrument._keypad.split_session_layer,
self._instrument.keypad_shift_layer, shifted_main_buttons,
self._session, shifted_dials
])
self._instrument._main_modes.add_mode(
'keypad_sequencer_shifted_session', [
self._instrument._keypad.sequencer_session_shift_layer,
self._instrument.keypad_shift_layer, shifted_main_buttons,
self._session, shifted_dials
])
self._instrument._main_modes.add_mode('audioloop', [
self._instrument.audioloop_layer, main_buttons, main_dials,
self._session,
DelayMode(self._session.clip_launch_layer, delay=.1)
])
self._instrument._main_modes.add_mode('audioloop_shifted', [
self._instrument.audioloop_layer, shifted_main_buttons,
self._session, shifted_dials
])
#self._instrument._main_modes.add_mode('audioloop_shifted_session', [self._instrument.audioloop_layer, self._session, shifted_main_buttons, main_dials, shifted_dials])
self._instrument.register_component(self._instrument._main_modes)
self._instrument._main_modes.selected_mode = 'disabled'
self._instrument.set_enabled(True)
self._main_modes = ModesComponent(name='MainModes')
self._main_modes.add_mode('disabled', [self._background])
self._main_modes.add_mode('MixMode', [
common, self._instrument, self._instrument.shift_button_layer,
self._G_mixer, main_faders, self._G_mixer.main_knobs_layer,
self._device, self._device_navigator,
self._device_navigator.main_layer,
self._device_navigator.select_dial_layer
])
self._main_modes.add_mode(
'ModSwitcher', [
common, main_faders, main_dials,
self._G_mixer.main_knobs_layer,
self._session_navigation.select_dial_layer, self._view_control,
self._view_control.main_layer, self._device_navigator,
self._device_navigator.select_dial_layer,
self.encoder_navigation_on, self._modswitcher,
DelayMode(self._update_modswitcher, delay=.1)
],
behaviour=ColoredCancellableBehaviourWithRelease(
color='ModeButtons.ModSwitcher',
off_color='ModeButtons.ModSwitcherDisabled'))
self._main_modes.add_mode(
'Translations', [
common, main_faders, main_dials, self._mixer.main_knobs_layer,
self._translations,
DelayMode(self._translations.selector_layer, delay=.1)
],
behaviour=DefaultedBehaviour(
default_mode='MixMode',
color='ModeButtons.Translations',
off_color='ModeButtons.TranslationsDisabled'))
self._main_modes.add_mode(
'DeviceSelector', [
common, self._device_selector,
DelayMode(self._device_selector.select_layer, delay=.1),
DelayMode(self.modhandler.lock_layer, delay=.1),
DelayMode(self._device_selector.assign_layer,
delay=.5), main_buttons, main_dials, main_faders,
self._G_mixer.main_knobs_layer, self._device,
self._device_navigator
],
behaviour=ColoredCancellableBehaviourWithRelease(
color='ModeButtons.DeviceSelector',
off_color='ModeButtons.DeviceSelectorDisabled'))
self._main_modes.layer = Layer(
priority=4,
ModSwitcher_button=self._encoder_button[2],
DeviceSelector_button=self._encoder_button[0],
Translations_button=self._encoder_button[3]) #,
self._main_modes.selected_mode = 'disabled'
self._main_modes.set_enabled(True)
self._test.subject = self._instrument._main_modes
class Alias(LividControlSurface):
_sysex_id = 11
_model_name = 'Alias'
_color_type = 'OhmRGB'
def __init__(self, c_instance):
super(Alias, self).__init__(c_instance)
self._skin = Skin(AliasColors)
with self.component_guard():
self._setup_controls()
self._setup_m4l_interface()
self._setup_session_control()
self._setup_mixer_control()
self._setup_mixer_nav()
def _setup_controls(self):
is_momentary = True
optimized = True
resource = PrioritizedResource
self._fader = [MonoEncoderElement(msg_type = MIDI_CC_TYPE, channel = CHANNEL, identifier = ALIAS_FADERS[index], name = 'Fader_' + str(index), num = index, script = self, optimized_send_midi = optimized, resource_type = resource, monobridge = self._monobridge) for index in range(9)]
self._button = [MonoButtonElement(is_momentary = is_momentary, msg_type = MIDI_NOTE_TYPE, channel = CHANNEL, identifier = ALIAS_BUTTONS[index], name = 'Button_' + str(index), script = self, skin = self._skin, optimized_send_midi = optimized, resource_type = resource, monobridge = self._monobridge) for index in range(16)]
self._dial = [MonoEncoderElement(msg_type = MIDI_CC_TYPE, channel = CHANNEL, identifier = ALIAS_DIALS[index], name = 'Dial_' + str(index), num = index + 8, script = self) for index in range(16)]
self._encoder = MonoEncoderElement(msg_type = MIDI_CC_TYPE, channel = CHANNEL, identifier = ALIAS_ENCODER, name = 'Encoder', script = self, optimized_send_midi = optimized, resource_type = resource, monobridge = self._monobridge)
self._fader_matrix = ButtonMatrixElement(name = 'FaderMatrix', rows = [self._fader[:8]])
self._button_matrix = ButtonMatrixElement(name = 'ButtonMatrix', rows = [self._button[:8], self._button[8:]])
self._dial_matrix = ButtonMatrixElement(name = 'DialMatrix', rows = [self._dial[:8], self._dial[8:]])
def _setup_m4l_interface(self):
self._m4l_interface = M4LInterfaceComponent(controls=self.controls, component_guard=self.component_guard)
self.get_control_names = self._m4l_interface.get_control_names
self.get_control = self._m4l_interface.get_control
self.grab_control = self._m4l_interface.grab_control
self.release_control = self._m4l_interface.release_control
def _setup_mixer_control(self):
self._mixer = MonoMixerComponent(name = 'Mixer', tracks_provider = self._session_ring, track_assigner = simple_track_assigner, invert_mute_feedback = True, auto_name = True, enable_skinning = True)
self._mixer.layer = Layer(volume_controls = self._fader_matrix,
send_controls = self._dial_matrix,
mute_buttons = self._button_matrix.submatrix[:,0],
arm_buttons = self._button_matrix.submatrix[:,1])
self._mixer.master_strip().layer = Layer(volume_control = self._fader[8])
self._mixer.set_enabled(True)
self.song.view.selected_track = self._mixer.channel_strip(0)._track
def _setup_session_control(self):
self._session_ring = SessionRingComponent(num_tracks = 8, num_scenes = 1, tracks_to_use = lambda : self.song.visible_tracks + self.song.return_tracks)
self._session_ring.set_enabled(True)
def _setup_mixer_nav(self):
self._nav_change.subject = self._encoder
@listens('value')
def _nav_change(self, value):
self._session_ring.set_offsets(int((float(value)/float(127))*max(8, len(self._session_ring.tracks_to_use())-8)), self._session_ring.scene_offset)
# a
class GuitarWing(LividControlSurface): _sysex_id = 20 _model_name = 'GuitarWing' def __init__(self, *a, **k): super(GuitarWing, self).__init__(*a, **k) self._skin = Skin(GuitarWingColors) with self.component_guard(): self._setup_controls() self._setup_m4l_interface() self._setup_session_control() self._setup_mixer_control() self._setup_device_control() self._setup_transport_control() self._setup_view_control() def _setup_controls(self): is_momentary = True optimized = True resource = PrioritizedResource self._button = [MonoButtonElement(is_momentary = is_momentary, msg_type = MIDI_NOTE_TYPE, channel = CHANNEL, identifier = BUTTONS[index], name = 'Button_' + str(index), script = self, skin = self._skin, optimized_send_midi = optimized, resource_type = resource, monobridge = self._monobridge) for index in range(10)] self._fader = [MonoEncoderElement(msg_type = MIDI_CC_TYPE, channel = CHANNEL, identifier = SLIDERS[index], name = 'Fader_' + str(index), num = index, script = self, optimized_send_midi = optimized, resource_type = resource, monobridge = self._monobridge) for index in range(3)] self._fader_button = [MonoEncoderElement(msg_type = MIDI_NOTE_TYPE, channel = CHANNEL, identifier = SLIDERS[index], name = 'Fader_Button_' + str(index), num = index, script = self, optimized_send_midi = optimized, resource_type = resource, monobridge = self._monobridge) for index in range(3)] self._ccs = [MonoEncoderElement(msg_type = MIDI_CC_TYPE, channel = CHANNEL, identifier = CCS[index], name = 'CCs_' + str(index), num = index, script = self, optimized_send_midi = optimized, resource_type = resource, monobridge = self._monobridge) for index in range(4)] self._pad = [MonoButtonElement(is_momentary = is_momentary, msg_type = MIDI_NOTE_TYPE, channel = CHANNEL, identifier = PADS[index], name = 'Pad_' + str(index), script = self, skin = self._skin, optimized_send_midi = optimized, resource_type = resource, monobridge = self._monobridge) for index in range(5)] self._padCC = [MonoEncoderElement(msg_type = MIDI_CC_TYPE, channel = CHANNEL, identifier = PADS[index], name = 'PadCC_' + str(index), num = index, script = self, optimized_send_midi = optimized, resource_type = resource, monobridge = self._monobridge) for index in range(5)] self._accel = [MonoEncoderElement(msg_type = MIDI_CC_TYPE, channel = CHANNEL, identifier = ACCELS[index], name = 'Accel_' + str(index), num = index, script = self, optimized_send_midi = optimized, resource_type = resource, monobridge = self._monobridge) for index in range(3)] self._parameter_control_matrix = ButtonMatrixElement(rows = [ [ self._fader[0], self._fader[1], self._fader[2], self._accel[2], self._ccs[0], self._ccs[1], self._ccs[2], self._ccs[3] ]]) self._scene_launch_matrix = ButtonMatrixElement(rows = [self._pad[:4]]) def _setup_session_control(self): self._session_ring = SessionRingComponent(num_tracks = 1, num_scenes = 4, tracks_to_use = lambda : self.song.visible_tracks + self.song.return_tracks) self._session_ring.set_enabled(False) self._session = SessionComponent(session_ring = self._session_ring, auto_name = True) hasattr(self._session, '_enable_skinning') and self._session._enable_skinning() self._session.layer = Layer(scene_launch_buttons = self._scene_launch_matrix) self._session_navigation =SessionNavigationComponent(name = 'SessionNavigation', session_ring = self._session_ring) self._session_navigation._horizontal_banking.scroll_up_button.color = 'Session.NavigationButtonOn' self._session_navigation._horizontal_banking.scroll_down_button.color = 'Session.NavigationButtonOn' self._session_navigation.layer = Layer(left_button = self._button[1], right_button = self._button[0]) self._session_navigation.set_enabled(True) def _setup_mixer_control(self): self._mixer = MonoMixerComponent(name = 'Mixer', tracks_provider = self._session_ring, track_assigner = simple_track_assigner, invert_mute_feedback = True, auto_name = True, enable_skinning = True) self.song.view.selected_track = self._mixer.channel_strip(0)._track def _setup_transport_control(self): self._transport = TransportComponent() self._transport.layer = Layer(play_button = self._button[6], loop_button = self._button[7], seek_backward_button = self._button[8], record_button = self._button[9]) self._transport.set_enabled(True) def _setup_device_control(self): self._device = DeviceComponent(name = 'Device_Component', device_provider = self._device_provider, device_bank_registry = DeviceBankRegistry()) self._device.layer = Layer(parameter_controls = self._parameter_control_matrix) self._device.set_enabled(True) def _setup_m4l_interface(self): self._m4l_interface = M4LInterfaceComponent(controls=self.controls, component_guard=self.component_guard) self.get_control_names = self._m4l_interface.get_control_names self.get_control = self._m4l_interface.get_control self.grab_control = self._m4l_interface.grab_control self.release_control = self._m4l_interface.release_control def _setup_view_control(self): self._view_control = ViewControlComponent() self._view_control.layer = Layer(prev_track_button = self._button[1], next_track_button = self._button[0]) # a
class OhmModes(LividControlSurface):
_sysex_id = 2
_alt_sysex_id = 7
_model_name = 'Ohm'
_version_check = 'b996'
_host_name = 'Ohm'
device_provider_class = ModDeviceProvider
def __init__(self, c_instance):
super(OhmModes, self).__init__(c_instance)
self._skin = Skin(OhmColors)
with self.component_guard():
self._define_sysex()
self._setup_controls()
self._setup_background()
self._setup_m4l_interface()
self._setup_translations()
self._setup_session_control()
self._setup_mixer_control()
self._setup_device_control()
self._setup_transport_control()
self._setup_drumgroup()
self._setup_keygroup()
self._setup_bassgroup()
self._setup_mod()
self._setup_modswitcher()
self._setup_modes()
self._on_device_changed.subject = self._device_provider
def _define_sysex(self):
#self._send_midi(tuple(switchxfader))
self._reverse_crossfader = SendLividSysexMode(
self._livid_settings, call='reverse crossfader', message=[1])
def update_display(self):
super(OhmModes, self).update_display()
#self.strobe()
def _initialize_hardware(self):
super(OhmModes, self)._initialize_hardware()
#self._reverse_crossfader.enter_mode()
def _initialize_script(self):
super(OhmModes, self)._initialize_script()
self._main_modes.selected_mode = 'Mix'
self._session.update()
self._mixer.update()
def _setup_controls(self):
is_momentary = True
optimized = True
resource = PrioritizedResource
self._fader = [
MonoEncoderElement(msg_type=MIDI_CC_TYPE,
channel=CHANNEL,
identifier=OHM_FADERS[index],
name='Fader_' + str(index),
num=index,
script=self,
optimized_send_midi=optimized,
resource_type=resource) for index in range(8)
]
self._button = [
MonoButtonElement(is_momentary=is_momentary,
msg_type=MIDI_NOTE_TYPE,
channel=CHANNEL,
identifier=OHM_BUTTONS[index],
name='Button_' + str(index),
script=self,
skin=self._skin,
optimized_send_midi=optimized,
resource_type=resource) for index in range(8)
]
self._dial = [
MonoEncoderElement(msg_type=MIDI_CC_TYPE,
channel=CHANNEL,
identifier=OHM_DIALS[index],
name='Encoder_' + str(index),
num=index,
script=self,
optimized_send_midi=optimized,
resource_type=resource) for index in range(16)
]
self._menu = [
MonoButtonElement(is_momentary=is_momentary,
msg_type=MIDI_NOTE_TYPE,
channel=CHANNEL,
identifier=OHM_MENU[index],
name='Menu_' + str(index),
script=self,
skin=self._skin,
optimized_send_midi=optimized,
resource_type=resource) for index in range(6)
]
self._crossfader = MonoEncoderElement(msg_type=MIDI_CC_TYPE,
channel=CHANNEL,
identifier=CROSSFADER,
name='Crossfader',
script=self,
optimized_send_midi=optimized,
resource_type=resource)
self._livid = MonoButtonElement(is_momentary=is_momentary,
msg_type=MIDI_NOTE_TYPE,
channel=CHANNEL,
identifier=LIVID,
name='Livid_Button',
skin=self._skin,
script=self,
optimized_send_midi=optimized,
resource_type=resource)
self._shift_l = MonoButtonElement(is_momentary=is_momentary,
msg_type=MIDI_NOTE_TYPE,
channel=CHANNEL,
identifier=SHIFT_L,
name='Page_Button_Left',
script=self,
skin=self._skin,
optimized_send_midi=optimized,
resource_type=resource)
self._shift_r = MonoButtonElement(is_momentary=is_momentary,
msg_type=MIDI_NOTE_TYPE,
channel=CHANNEL,
identifier=SHIFT_R,
name='Page_Button_Right',
script=self,
skin=self._skin,
optimized_send_midi=optimized,
resource_type=resource)
self._grid = [[
MonoButtonElement(is_momentary=is_momentary,
msg_type=MIDI_NOTE_TYPE,
channel=CHANNEL,
identifier=column * 8 + row,
name='Grid_' + str(column + (row * 8)),
script=self,
skin=self._skin,
optimized_send_midi=optimized,
resource_type=resource) for column in range(8)
] for row in range(8)]
self._matrix = ButtonMatrixElement(
name='Matrix',
rows=[[self._grid[row][column] for column in range(8)]
for row in range(8)])
self._dial_matrix = ButtonMatrixElement(
name='DialMatrix',
rows=[self._dial[index * 4:(index * 4) + 4] for index in range(4)])
self._menu_matrix = ButtonMatrixElement(name='MenuMatrix',
rows=[self._menu])
self._fader_matrix = ButtonMatrixElement(name='FaderMatrix',
rows=[self._fader])
self._button_matrix = ButtonMatrixElement(name='ButtonMatrix',
rows=[self._button])
self._parameter_controls = ButtonMatrixElement(
rows=[self._dial[:4], self._dial[4:8]])
def _setup_background(self):
self._background = BackgroundComponent(name='Background')
self._background.layer = Layer(
priority=3,
matrix=self._matrix.submatrix[:, :],
livid_button=self._livid,
shift_l_button=self._shift_l,
shift_r_button=self._shift_r,
crossfader=self._crossfader,
dial_matrix=self._dial_matrix.submatrix[:, :],
menu_matrix=self._menu_matrix.submatrix[:, :],
fader_matrix=self._fader_matrix.submatrix[:, :],
button_matrix=self._button_matrix.submatrix[:, :])
self._background.set_enabled(False)
def _setup_m4l_interface(self):
self._m4l_interface = M4LInterfaceComponent(
controls=self.controls, component_guard=self.component_guard)
self.get_control_names = self._m4l_interface.get_control_names
self.get_control = self._m4l_interface.get_control
self.grab_control = self._m4l_interface.grab_control
self.release_control = self._m4l_interface.release_control
def _setup_translations(self):
controls = []
for array in self._grid:
for button in array:
controls.append(button)
if FADER_BANKING:
controls = controls + self._dial
if DIAL_BANKING:
controls = controls + self._dial
self._translations = TranslationComponent(
controls=controls, user_channel_offset=USER_CHANNEL, channel=8)
self._translations.layer = Layer(
priority=5,
channel_selector_buttons=self._menu_matrix.submatrix[:, :])
self._translations.set_enabled(False)
dj_controls = [self._grid[7][index] for index in range(7)]
self._dj_translation = TranslationComponent(controls=dj_controls,
channel=12)
def _setup_session_control(self):
self._session_ring = SessionRingComponent(num_tracks=7, num_scenes=5)
self._session_ring.set_enabled(True)
self._session_navigation = SessionNavigationComponent(
session_ring=self._session_ring)
self._session_navigation.scroll_navigation_layer = AddLayerMode(
self._session_navigation,
Layer(priority=5,
up_button=self._menu[2],
down_button=self._menu[5],
left_button=self._menu[3],
right_button=self._menu[4]))
self._session_navigation.page_navigation_layer = AddLayerMode(
self._session_navigation,
Layer(priority=5,
page_up_button=self._menu[2],
page_down_button=self._menu[5],
page_left_button=self._menu[3],
page_right_button=self._menu[4]))
self._session_navigation._vertical_banking.scroll_up_button.color = 'Session.NavigationButtonOn'
self._session_navigation._vertical_banking.scroll_down_button.color = 'Session.NavigationButtonOn'
self._session_navigation._horizontal_banking.scroll_up_button.color = 'Session.NavigationButtonOn'
self._session_navigation._horizontal_banking.scroll_down_button.color = 'Session.NavigationButtonOn'
self._session_navigation._vertical_paginator.scroll_up_button.color = 'Session.PageNavigationButtonOn'
self._session_navigation._vertical_paginator.scroll_down_button.color = 'Session.PageNavigationButtonOn'
self._session_navigation._horizontal_paginator.scroll_up_button.color = 'Session.PageNavigationButtonOn'
self._session_navigation._horizontal_paginator.scroll_down_button.color = 'Session.PageNavigationButtonOn'
self._session_navigation.set_enabled(False)
self._session = OhmSessionComponent(name='Session',
session_ring=self._session_ring,
auto_name=True)
hasattr(self._session,
'_enable_skinning') and self._session._enable_skinning()
self._session.set_enabled(False)
self._session.clip_launch_layer = AddLayerMode(
self._session,
Layer(priority=5,
clip_launch_buttons=self._matrix.submatrix[:7, :5]))
self._session.scene_launch_layer = AddLayerMode(
self._session,
Layer(priority=5,
scene_launch_buttons=self._matrix.submatrix[7, :5]))
self._session_zoom = SessionOverviewComponent(
name='Session_Overview',
session_ring=self._session_ring,
enable_skinning=True)
self._session_zoom.layer = Layer(
priority=5, button_matrix=self._matrix.submatrix[:7, :5])
self._session_zoom.set_enabled(False)
self._session_modes = ModesComponent(name='Session_Modes')
self._session_modes.add_mode('disabled', [
self._session, self._session.clip_launch_layer,
self._session.scene_launch_layer, self._session_navigation,
self._session_navigation.scroll_navigation_layer
])
self._session_modes.add_mode('enabled', [
self._session, self._session.scene_launch_layer,
self._session_zoom, self._session_navigation,
self._session_navigation.page_navigation_layer
],
behaviour=DefaultedBehaviour())
self._session_modes.layer = Layer(priority=5,
enabled_button=self._grid[7][7])
self._session_modes.selected_mode = 'disabled'
self._session_modes.set_enabled(False)
def _setup_mixer_control(self):
self._mixer = OhmMixerComponent(
name='Mixer',
tracks_provider=self._session_ring,
track_assigner=SimpleTrackAssigner(),
invert_mute_feedback=True,
auto_name=True,
enable_skinning=True,
channel_strip_component_type=MonoChannelStripComponent)
self._mixer.layer = Layer(
priority=5,
volume_controls=self._fader_matrix.submatrix[:7, :],
prehear_volume_control=self._dial[15],
crossfader_control=self._crossfader)
self._mixer.master_strip().layer = Layer(priority=5,
volume_control=self._fader[7],
select_button=self._button[7])
self._mixer.mix_layer = AddLayerMode(
self._mixer,
Layer(
priority=5,
mute_buttons=self._matrix.submatrix[:7, 5],
solo_buttons=self._matrix.submatrix[:7, 6],
arm_buttons=self._matrix.submatrix[:7, 7],
send_controls=self._dial_matrix.submatrix[:, :2],
pan_controls=self._dial_matrix.submatrix[:7, 2:],
track_select_buttons=self._button_matrix.submatrix[:7, :],
))
self._mixer.dj_layer = AddLayerMode(
self._mixer,
Layer(
priority=5,
mute_buttons=self._matrix.submatrix[:7, 5],
crossfade_toggles=self._matrix.submatrix[:7, 6],
end_pan_controls=self._dial_matrix.submatrix[:3, 3],
eq_gain_controls=self._dial_matrix.submatrix[:, :3],
track_select_buttons=self._button_matrix.submatrix[:7, :],
))
self._mixer.instrument_layer = AddLayerMode(
self._mixer,
Layer(priority=5,
instrument_send_controls=self._dial_matrix.submatrix[:, 2:],
arming_track_select_buttons=self._button_matrix.
submatrix[:7, :]))
def _setup_device_control(self):
self._device = OhmDeviceComponent(
script=self,
name='Device_Component',
device_provider=self._device_provider,
device_bank_registry=DeviceBankRegistry())
self._device.layer = Layer(priority=5,
parameter_controls=self._parameter_controls)
self._device.set_enabled(False)
self._device_navigator = DeviceNavigator(
self._device_provider,
self._mixer,
self,
name='Device_Navigator',
)
self._device_navigator.layer = Layer(priority=5,
prev_button=self._menu[3],
next_button=self._menu[4])
self._device_navigator.set_enabled(False)
def _setup_transport_control(self):
self._transport = OhmTransportComponent()
self._transport.name = 'Transport'
self._transport.layer = Layer(priority=5,
play_button=self._menu[0],
stop_button=self._menu[1])
self._transport.set_enabled(False)
def _setup_drumgroup(self):
self._drumgroup = MonoDrumGroupComponent(
translation_channel=PAGE1_DRUM_CHANNEL,
set_pad_translations=self.set_pad_translations)
self._drumgroup._on_selected_track_changed.subject = None
self._drumgroup.translation_channel = PAGE1_DRUM_CHANNEL
self._drumgroup.layer = Layer(priority=6,
matrix=self._matrix.submatrix[:4, :4])
self._drumgroup.set_enabled(False)
def _setup_keygroup(self):
self._scale_mode = ModesComponent(name='ScaleMode')
for scale in SCALES:
debug('making scale mode:', scale, str(scale))
self._scale_mode.add_mode(str(scale), [])
self._scale_mode.layer = Layer(priority=5,
ionian_button=self._grid[7][0],
dorian_button=self._grid[7][1],
phrygian_button=self._grid[7][2],
lydian_button=self._grid[7][3],
mixolydian_button=self._grid[7][4],
aeolian_button=self._grid[7][5],
locrian_button=self._grid[7][6],
major_button=self._grid[7][7])
self._scale_mode.selected_mode = 'ionian'
self._scale_mode.set_enabled(False)
self._on_scale_change.subject = self._scale_mode
self._octave_offset_component = ScrollingChannelizedSettingsComponent(
name='NoteOffset',
parent_task_group=self._task_group,
value_dict=range(104),
default_value_index=36,
default_channel=0,
bank_increment=12,
bank_on_color='MonoInstrument.OffsetOnValue',
bank_off_color='MonoInstrument.OffsetOffValue')
self._octave_offset_component.layer = Layer(
priority=5,
bank_up_button=self._menu[2],
bank_down_button=self._menu[5])
self._on_octave_change.subject = self._octave_offset_component
self._keygroup = OhmKeyGroupComponent()
self._keygroup._on_selected_track_changed.subject = None
self._keygroup.translation_channel = PAGE1_KEYS_CHANNEL
self._keygroup.layer = Layer(priority=6,
matrix=self._matrix.submatrix[:, 4:7])
self._keygroup.set_enabled(False)
def _setup_bassgroup(self):
self._bassgroup = OhmBassGroupComponent()
self._bassgroup._on_selected_track_changed.subject = None
self._bassgroup.translation_channel = PAGE1_BASS_CHANNEL
self._bassgroup.layer = Layer(priority=6,
matrix=self._matrix.submatrix[4:, :4])
self._bassgroup.set_enabled(False)
def _setup_mod(self):
self.monomodular = get_monomodular(self)
self.monomodular.name = 'monomodular_switcher'
self.modhandler = OhmModHandler(script=self,
device_provider=self._device_provider)
self.modhandler.name = 'ModHandler'
self.modhandler.layer = Layer(
priority=5,
grid=self._matrix.submatrix[:, :],
nav_up_button=self._menu[2],
nav_down_button=self._menu[5],
nav_left_button=self._menu[3],
nav_right_button=self._menu[4],
shift_button=self._menu[1],
alt_button=self._menu[0],
)
#parameter_controls = self._dial_matrix)
self.modhandler.legacy_shift_mode = AddLayerMode(
self.modhandler,
Layer(priority=6,
channel_buttons=self._matrix.submatrix[:, 1],
nav_matrix=self._matrix.submatrix[4:8, 2:6]))
self.modhandler.shift_mode = AddLayerMode(
self.modhandler,
Layer(priority=6,
device_selector_matrix=self._matrix.submatrix[:, 0],
lock_button=self._livid,
key_buttons=self._matrix.submatrix[:, 7]))
self.modhandler.set_enabled(False)
self.modhandler.set_mod_button(self._livid)
def _setup_modswitcher(self):
self._modswitcher = ModesComponent(name='ModSwitcher')
self._modswitcher.add_mode('mod', [
self.modhandler, self._device,
DelayMode(self.modhandler.update, delay=.5)
])
self._modswitcher.add_mode('translations', [self._translations])
self._modswitcher.selected_mode = 'translations'
self._modswitcher.set_enabled(False)
def _setup_modes(self):
self._main_modes = ModesComponent(name='MainModes')
self._main_modes.add_mode('disabled', [self._background])
self._main_modes.add_mode('Mix', [
self._session_modes, self._mixer, self._mixer.mix_layer,
self._transport
])
self._main_modes.add_mode(
'DJ', [
self._session_modes, self._mixer, self._mixer.dj_layer,
self._dj_translation,
tuple([self._assign_tempo, self._deassign_tempo])
],
behaviour=DefaultedBehaviour(default_mode='Mix'))
#tuple([ lambda:self._set_tempo_buttons([self._grid[7][5], self._grid[7][6]]), self._set_tempo_buttons([])])],
self._main_modes.add_mode(
'Instrument', [
self._update_keygroup_colors, self._bassgroup, self._keygroup,
self._scale_mode, self._octave_offset_component, self._device,
self._device_navigator, self._mixer,
self._mixer.instrument_layer, self._drumgroup
],
behaviour=DefaultedBehaviour(default_mode='Mix'))
self._main_modes.add_mode(
'Mod', [
self._modswitcher, self._device, self._mixer,
self._mixer.instrument_layer
],
behaviour=DefaultedBehaviour(default_mode='Mix'))
self._main_modes.layer = Layer(priority=5,
Instrument_button=self._shift_l,
DJ_button=self._shift_r,
Mod_button=self._livid)
self._main_modes.selected_mode = 'disabled'
self._main_modes.set_enabled(True)
def disconnect(self):
super(OhmModes, self).disconnect()
def strobe(self):
if self._backlight_type != 'static':
if self._backlight_type is 'pulse':
self._backlight = int(
math.fabs(self._timer * 16 % 64 - 32) + 32)
if self._backlight_type is 'up':
self._backlight = int(self._timer * 8 % 64 + 16)
if self._backlight_type is 'down':
self._backlight = int(
math.fabs(int(self._timer * 8 % 64 - 64)) + 16)
self._send_midi(tuple([176, 27, int(self._backlight)]))
if self._ohm_type != 'static':
if self._ohm_type is 'pulse':
self._ohm = int(math.fabs(self._timer * 16 % 64 - 32) + 32)
if self._ohm_type is 'up':
self._ohm = int(self._timer * 8 % 64 + 16)
if self._ohm_type is 'down':
self._ohm = int(math.fabs(int(self._timer * 8 % 64 - 64)) + 16)
self._send_midi(tuple([176, 63, int(self._ohm)]))
self._send_midi(tuple([176, 31, int(self._ohm)]))
def handle_sysex(self, midi_bytes):
debug('sysex: ', str(midi_bytes))
if len(midi_bytes) > 14:
if midi_bytes[:6] == tuple([240, 0, 1, 97, 12, 64]):
self._register_pad_pressed(midi_bytes[6:14])
elif midi_bytes[:6] == tuple([240, 0, 1, 97, 17, 64]):
self._register_pad_pressed(midi_bytes[6:14])
elif midi_bytes[3:11] == tuple(
[6, 2, 0, 1, 97, 1, 0] +
[self._sysex_id]) or midi_bytes[3:11] == tuple(
[6, 2, 0, 1, 97, 1, 0] + [self._alt_sysex_id]):
if not self._connected:
#self._connection_routine.kill()
self._connected = True
self._livid_settings.set_model(midi_bytes[11])
self._initialize_hardware()
self.schedule_message(1, self._initialize_script)
@listens('device')
def _on_device_changed(self):
self.schedule_message(1, self._update_modswitcher)
#debug('base on_device_changed')
self._update_modswitcher()
def _on_selected_track_changed(self):
super(OhmModes, self)._on_selected_track_changed()
if not len(self.song.view.selected_track.devices):
self._update_modswitcher()
def _update_modswitcher(self):
debug('update modswitcher, mod is:', self.modhandler.active_mod())
if self.modhandler.active_mod():
self._modswitcher.selected_mode = 'mod'
else:
self._modswitcher.selected_mode = 'translations'
@listens('selected_mode')
def _on_scale_change(self, mode):
debug('new scale is:', mode, self._scale_mode.selected_mode)
self._keygroup.scale = SCALES.index(self._scale_mode.selected_mode)
@listens('value')
def _on_octave_change(self, value):
self._keygroup.offset = value
#stupid hack....4 hours wasted on two buttons is too long, so we're doing this instead
def _update_keygroup_colors(self):
self._grid[5][7].send_value(2, force=True)
self._grid[6][7].send_value(2, force=True)
#everything below needs to be consolidated into transport component
def _assign_tempo(self):
self._grid[5][7].send_value(4, True)
self._grid[6][7].send_value(4, True)
self._tempo_up_value.subject = self._grid[5][7]
self._tempo_down_value.subject = self._grid[6][7]
def _deassign_tempo(self):
self._tempo_up_value.subject and self._tempo_up_value.subject.turn_off(
)
self._tempo_down_value.subject and self._tempo_down_value.subject.turn_off(
)
self._tempo_up_value.subject = None
self._tempo_down_value.subject = None
@listens('value')
def _tempo_up_value(self, value):
if value:
self.song.tempo = round(min(self.song.tempo + 1, 999))
@listens('value')
def _tempo_down_value(self, value):
if value:
self.song.tempo = round(max(self.song.tempo - 1, 20))
class OhmModesRay(OhmModes):
_sysex_id = 2
_alt_sysex_id = 7
_model_name = 'Ohm'
_version_check = 'b996'
_host_name = 'Ohm'
device_provider_class = ModDeviceProvider
def __init__(self, c_instance):
super(OhmModes, self).__init__(c_instance)
self._skin = Skin(OhmColors)
with self.component_guard():
self._define_sysex()
self._setup_controls()
self._setup_background()
self._setup_m4l_interface()
#self._setup_translations()
self._setup_session_control()
self._setup_mixer_control()
self._setup_instrument()
#self._setup_device_control()
#self._setup_transport_control()
#self._setup_drumgroup()
#self._setup_keygroup()
#self._setup_bassgroup()
#self._setup_mod()
#self._setup_modswitcher()
self._setup_modes()
self._on_device_changed.subject = self._device_provider
self.set_feedback_channels(FEEDBACK_CHANNELS)
self._session_ring._update_highlight()
def set_feedback_channels(self, channels, *a, **k):
super(OhmModes, self).set_feedback_channels(channels, *a, **k)
def _setup_session_control(self):
self._session_ring = SessionRingComponent(num_tracks = 7, num_scenes = 7)
self._session_ring.set_enabled(True)
self._session_navigation = SessionNavigationComponent(session_ring = self._session_ring)
self._session_navigation.scroll_navigation_layer = AddLayerMode(self._session_navigation, Layer(priority = 5, up_button = self._menu[1], down_button = self._menu[4], left_button = self._menu[3], right_button = self._menu[5]))
self._session_navigation.page_navigation_layer = AddLayerMode(self._session_navigation, Layer(priority = 5, page_up_button = self._menu[2], page_down_button = self._menu[5], page_left_button = self._menu[3], page_right_button = self._menu[4]))
self._session_navigation._vertical_banking.scroll_up_button.color = 'Session.NavigationButtonOn'
self._session_navigation._vertical_banking.scroll_down_button.color = 'Session.NavigationButtonOn'
self._session_navigation._horizontal_banking.scroll_up_button.color = 'Session.NavigationButtonOn'
self._session_navigation._horizontal_banking.scroll_down_button.color = 'Session.NavigationButtonOn'
self._session_navigation._vertical_paginator.scroll_up_button.color = 'Session.PageNavigationButtonOn'
self._session_navigation._vertical_paginator.scroll_down_button.color = 'Session.PageNavigationButtonOn'
self._session_navigation._horizontal_paginator.scroll_up_button.color = 'Session.PageNavigationButtonOn'
self._session_navigation._horizontal_paginator.scroll_down_button.color = 'Session.PageNavigationButtonOn'
self._session_navigation.set_enabled(False)
self._session = SpecialOhmSessionComponent(name = 'Session', session_ring = self._session_ring, auto_name = True)
self._session.set_enabled(False)
self._session.clip_launch_layer = AddLayerMode(self._session, Layer(priority = 5, clip_launch_buttons = self._matrix.submatrix[:7,:7]))
self._session.scene_launch_layer = AddLayerMode(self._session, Layer(priority = 5, scene_launch_buttons = self._matrix.submatrix[7,:7]))
self._session.stop_clips_layer = AddLayerMode(self._session, Layer(priority = 5, stop_track_clip_buttons = self._matrix.submatrix[:7,7], stop_all_clips_button = self._grid[7][7]))
"""self._session_zoom = SessionOverviewComponent(name = 'Session_Overview', session_ring = self._session_ring, enable_skinning = True)
self._session_zoom.layer = Layer(priority = 5, button_matrix = self._matrix.submatrix[:7,:7])
self._session_zoom.set_enabled(False)
self._session_modes = ModesComponent(name = 'Session_Modes')
self._session_modes.add_mode('disabled', [self._session,
self._session.clip_launch_layer,
self._session.scene_launch_layer,
self._session_navigation,
self._session_navigation.scroll_navigation_layer])
self._session_modes.add_mode('enabled', [self._session,
self._session.scene_launch_layer,
self._session_zoom,
self._session_navigation,
self._session_navigation.page_navigation_layer],
behaviour = DefaultedBehaviour())
self._session_modes.layer = Layer(priority = 5, enabled_button = self._grid[7][7])
self._session_modes.selected_mode = 'disabled'
self._session_modes.set_enabled(False)"""
def _setup_mixer_control(self):
self._mixer = OhmMixerComponent(name = 'Mixer', tracks_provider = self._session_ring, track_assigner = SimpleTrackAssigner(), invert_mute_feedback = True, auto_name = True, enable_skinning = True)
#self._mixer.layer = Layer(priority = 5, volume_controls = self._fader_matrix.submatrix[:7, :], prehear_volume_control = self._dial[15], crossfader_control = self._crossfader)
self._mixer.layer = Layer(priority = 5, solo_buttons = self._button_matrix.submatrix[:7,:])
"""self._mixer.master_strip().layer = Layer(priority = 5, volume_control = self._fader[7], select_button = self._button[7])
self._mixer.mix_layer = AddLayerMode(self._mixer, Layer(priority = 5, mute_buttons = self._matrix.submatrix[:7,5],
solo_buttons = self._matrix.submatrix[:7,6],
arm_buttons = self._matrix.submatrix[:7,7],
send_controls = self._dial_matrix.submatrix[:,:2],
pan_controls = self._dial_matrix.submatrix[:7,2:],
track_select_buttons = self._button_matrix.submatrix[:7,:],))
self._mixer.dj_layer = AddLayerMode(self._mixer, Layer(priority = 5, mute_buttons = self._matrix.submatrix[:7,5],
crossfade_toggles = self._matrix.submatrix[:7,6],
end_pan_controls = self._dial_matrix.submatrix[:3,3],
eq_gain_controls = self._dial_matrix.submatrix[:,:3],
track_select_buttons = self._button_matrix.submatrix[:7,:],))
self._mixer.instrument_layer = AddLayerMode(self._mixer, Layer(priority = 5,
instrument_send_controls = self._dial_matrix.submatrix[:,2:],
arming_track_select_buttons = self._button_matrix.submatrix[:7,:]))
"""
def _setup_instrument(self):
self._grid_resolution = GridResolution()
self._c_instance.playhead.enabled = True
self._playhead_element = PlayheadElement(self._c_instance.playhead)
#self._playhead_element.reset()
#quantgrid = ButtonMatrixElement([self._base_grid._orig_buttons[2][4:8], self._base_grid._orig_buttons[3][4:7]])
self._drum_group_finder = PercussionInstrumentFinder(device_parent=self.song.view.selected_track)
self._instrument = OhmMonoInstrumentComponent(name = 'InstrumentModes', script = self, skin = self._skin, drum_group_finder = self._drum_group_finder, grid_resolution = self._grid_resolution, settings = DEFAULT_INSTRUMENT_SETTINGS, device_provider = self._device_provider, parent_task_group = self._task_group)
self._instrument.layer = Layer(priority = 5, shift_button = self._livid)
self._instrument.audioloop_layer = LayerMode(self._instrument, Layer(priority = 5, loop_selector_matrix = self._matrix))
self._instrument.keypad_options_layer = AddLayerMode(self._instrument, Layer(priority = 5,
scale_up_button = self._menu[0],
scale_down_button = self._menu[3],
offset_up_button = self._menu[1],
offset_down_button = self._menu[4],
vertical_offset_up_button = self._menu[2],
vertical_offset_down_button = self._menu[5],))
self._instrument.drumpad_options_layer = AddLayerMode(self._instrument, Layer(priority = 5,
scale_up_button = self._menu[0],
scale_down_button = self._menu[3],
drum_offset_up_button = self._menu[1],
drum_offset_down_button = self._menu[4],
drumpad_mute_button = self._menu[2],
drumpad_solo_button = self._menu[5],))
self._instrument._keypad.octave_toggle_layer = AddLayerMode(self._instrument._keypad, Layer(priority = 5)) #, offset_shift_toggle = self._livid))
self._instrument._drumpad.octave_toggle_layer = AddLayerMode(self._instrument._drumpad, Layer(priority = 5)) #, offset_shift_toggle = self._livid))
self._instrument._keypad.main_layer = LayerMode(self._instrument._keypad, Layer(priority = 5, keypad_matrix = self._matrix.submatrix[:,:]))
self._instrument._keypad.select_layer = LayerMode(self._instrument._keypad, Layer(priority = 5, keypad_select_matrix = self._matrix.submatrix[:, :]))
self._instrument._keypad.split_layer = LayerMode(self._instrument._keypad, Layer(priority = 5, keypad_matrix = self._matrix.submatrix[:, 2:4]))
self._instrument._keypad.split_select_layer = LayerMode(self._instrument._keypad, Layer(priority = 5, keypad_select_matrix = self._matrix.submatrix[:, 2:4]))
self._instrument._keypad.sequencer_layer = AddLayerMode(self._instrument._keypad, Layer(priority = 5, playhead = self._playhead_element, sequencer_matrix = self._matrix.submatrix[:, :4]))
self._instrument._keypad.sequencer_shift_layer = AddLayerMode(self._instrument._keypad, Layer(priority = 5, loop_selector_matrix = self._matrix.submatrix[:, :4], quantization_buttons = self._matrix.submatrix[:8, 1:2],)) #follow_button = self._pad[15]))
self._instrument._drumpad.main_layer = LayerMode(self._instrument._drumpad, Layer(priority = 5, drumpad_matrix = self._matrix.submatrix[:,4:], sequencer_matrix = self._matrix.submatrix[:, :2], loop_selector_matrix = self._matrix.submatrix[:, 3:4], playhead = self._playhead_element, quantization_buttons = self._matrix.submatrix[:, 2:3]))
self._instrument._drumpad.select_layer = LayerMode(self._instrument._drumpad, Layer(priority = 5, drumpad_select_matrix = self._matrix.submatrix[:,4:], sequencer_matrix = self._matrix.submatrix[:, :2], loop_selector_matrix = self._matrix.submatrix[:, 3:4], playhead = self._playhead_element, quantization_buttons = self._matrix.submatrix[:, 2:3]))
self._instrument._drumpad.split_layer = LayerMode(self._instrument._drumpad, Layer(priority = 5, drumpad_matrix = self._matrix.submatrix[:4, 4:],))
self._instrument._drumpad.split_select_layer = LayerMode(self._instrument._drumpad, Layer(priority = 5, drumpad_select_matrix = self._matrix.submatrix[:4,4:]))
self._instrument._drumpad.sequencer_layer = AddLayerMode(self._instrument._drumpad, Layer(priority = 5, playhead = self._playhead_element, sequencer_matrix = self._matrix.submatrix[:, :4]))
self._instrument._drumpad.sequencer_shift_layer = AddLayerMode(self._instrument._drumpad, Layer(priority = 5, loop_selector_matrix = self._matrix.submatrix[4:8, :2], quantization_buttons = self._matrix.submatrix[4:8, 2:],)) #follow_button = self._pad[31]))
self._instrument._selected_session._keys_layer = LayerMode(self._instrument._selected_session, Layer(priority = 5, clip_launch_buttons = self._matrix.submatrix[:, :2]))
self._instrument._selected_session._drum_layer = LayerMode(self._instrument._selected_session, Layer(priority = 5, clip_launch_buttons = self._matrix.submatrix[4:8, :]))
self._instrument._main_modes = ModesComponent(parent = self._instrument, name = 'InstrumentModes')
self._instrument._main_modes.add_mode('disabled', [])
self._instrument._main_modes.add_mode('drumpad', [self._instrument._drumpad, self._instrument._drumpad.main_layer, self._instrument.drumpad_options_layer])
self._instrument._main_modes.add_mode('drumpad_split', [self._instrument._drumpad, self._instrument._drumpad.split_layer, self._instrument._selected_session, self._instrument._selected_session._drum_layer])
self._instrument._main_modes.add_mode('drumpad_sequencer', [self._instrument._drumpad, self._instrument._drumpad.sequencer_layer, self._instrument._drumpad.split_layer])
self._instrument._main_modes.add_mode('drumpad_shifted', [self._instrument._drumpad, self._instrument._drumpad.select_layer, self._instrument.drumpad_options_layer, self._instrument._drumpad.octave_toggle_layer])
self._instrument._main_modes.add_mode('drumpad_split_shifted', [ self._instrument._drumpad, self._instrument._drumpad.split_select_layer, self._instrument.drumpad_options_layer, self._instrument._drumpad.octave_toggle_layer, self._instrument._selected_session, self._instrument._selected_session._drum_layer])
self._instrument._main_modes.add_mode('drumpad_sequencer_shifted', [self._instrument._drumpad, self._instrument._drumpad.split_select_layer, self._instrument._drumpad.sequencer_shift_layer, self._instrument.drumpad_options_layer, self._instrument._drumpad.octave_toggle_layer])
self._instrument._main_modes.add_mode('keypad', [self._instrument._keypad, self._instrument._keypad.main_layer, self._instrument.keypad_options_layer])
self._instrument._main_modes.add_mode('keypad_split', [self._instrument._keypad, self._instrument._keypad.split_layer, self._instrument._selected_session, self._instrument._selected_session._keys_layer])
self._instrument._main_modes.add_mode('keypad_sequencer', [self._instrument._keypad, self._instrument._keypad.sequencer_layer, self._instrument._keypad.split_layer], )
self._instrument._main_modes.add_mode('keypad_shifted', [self._instrument._keypad, self._instrument._keypad.select_layer, self._instrument.keypad_options_layer, self._instrument._keypad.octave_toggle_layer])
self._instrument._main_modes.add_mode('keypad_split_shifted', [self._instrument._keypad, self._instrument._keypad.split_select_layer, self._instrument.keypad_options_layer, self._instrument._keypad.octave_toggle_layer, self._instrument._selected_session, self._instrument._selected_session._keys_layer])
self._instrument._main_modes.add_mode('keypad_sequencer_shifted', [self._instrument._keypad, self._instrument._keypad.split_select_layer, self._instrument._keypad.sequencer_shift_layer, self._instrument.keypad_options_layer, self._instrument._keypad.octave_toggle_layer])
self._instrument._main_modes.add_mode('audioloop', [self._instrument.audioloop_layer])
#self._instrument.register_component(self._instrument._main_modes)
self._instrument.set_enabled(False)
def _setup_modes(self):
self._main_modes = ModesComponent(name = 'MainModes')
self._main_modes.add_mode('disabled', [self._background])
self._main_modes.add_mode('Mix', [self._mixer, self._session, self._session.stop_clips_layer, self._session.clip_launch_layer, self._session.scene_launch_layer, self._session_navigation, self._session_navigation.scroll_navigation_layer])
self._main_modes.add_mode('Instrument', [self._instrument])
self._main_modes.selected_mode = 'disabled'
self._main_modes.layer = Layer(priority = 5, Mix_button = self._shift_l, Instrument_button = self._shift_r)
self._main_modes.set_enabled(True)
def reset_controlled_track(self, track = None, *a):
if not track:
track = self.song.view.selected_track
self.set_controlled_track(track)
def set_controlled_track(self, track = None, *a):
if isinstance(track, Live.Track.Track):
super(OhmModes, self).set_controlled_track(track)
else:
self.release_controlled_track()
@listens('device')
def _on_device_changed(self):
debug('_on_device_changed')
self.update()
def update(self):
self.reset_controlled_track()
self.set_feedback_channels(FEEDBACK_CHANNELS)
super(OhmModes, self).update()
class KeyLabEssential(ControlSurface):
mixer_component_type = MixerComponent
session_component_type = SessionComponent
view_control_component_type = ViewControlComponent
hardware_settings_component_type = HardwareSettingsComponent
channel_strip_component_type = ChannelStripComponent
def __init__(self, *a, **k):
super(KeyLabEssential, self).__init__(*a, **k)
with self.component_guard():
with inject(skin=const(default_skin)).everywhere():
self._create_controls()
self._create_hardware_settings()
self._on_focused_view_changed.subject = self.application.view
self._hardware_settings.set_hardware_live_mode_enabled(True)
self._on_memory_preset_changed_on_hardware.subject = self._hardware_settings
self._hardware_settings.select_memory_preset(
sysex.DAW_MEMORY_PRESET_INDEX)
with self.component_guard():
self._create_transport()
self._create_undo()
self._create_session()
self._create_navigation()
self._create_mixer()
self._create_view_control()
self._create_arrangement()
self._create_jogwheel_modes()
def port_settings_changed(self):
super(KeyLabEssential, self).port_settings_changed()
self._hardware_settings.set_hardware_live_mode_enabled(True)
def _create_controls(self):
self._hardware_live_mode_switch = SysexElement(
send_message_generator=lambda b: sysex.LIVE_MODE_MESSAGE_HEADER +
(b, sysex.END_BYTE),
default_value=sysex.OFF_VALUE,
name=u'Hardware_Live_Mode_Switch')
self._memory_preset_switch = SysexElement(
send_message_generator=lambda b: sysex.
MEMORY_PRESET_SWITCH_MESSAGE_HEADER + (b, sysex.END_BYTE),
sysex_identifier=sysex.MEMORY_PRESET_SWITCH_MESSAGE_HEADER,
name=u'Memory_Preset_Switch')
self._memory_preset_select_mode_switch = SysexElement(
sysex_identifier=sysex.MEMORY_PRESET_SELECT_MODE_MESSAGE_HEADER,
name=u'Memory_Preset_Select_Mode')
self._play_button = create_button(94, u'Play_Button')
self._stop_button = create_button(93, u'Stop_Button')
self._punch_in_button = create_button(87, u'Punch_In_Button')
self._punch_out_button = create_button(88, u'Punch_Out_Button')
self._metronome_button = create_button(89, u'Metronome_Button')
self._loop_button = create_button(86, u'Loop_Button')
self._rwd_button = create_button(91, u'Rewind_Button')
self._ff_button = create_button(92, u'Fast_Forward_Button')
self._record_button = create_button(95, u'Record_Button')
self._undo_button = create_button(81, u'Undo_Button')
self._bank_left_button = create_button(46, u'Bank_Left_Button')
self._bank_right_button = create_button(47, u'Bank_Right_Button')
self._left_button = create_button(48, u'Left_Button')
self._right_button = create_button(49, u'Right_Button')
self._left_arrow_button = create_button(98, u'Left_Arrow_Button')
self._right_arrow_button = create_button(99, u'Right_Arrow_Button')
self._marker_button = create_button(84, u'Marker_Button')
self._pads = ButtonMatrixElement(rows=[[
create_button(col + 36, u'Pad_%d' % (col, ), channel=10)
for col in xrange(8)
]],
name=u'Pad_Matrix')
self._pad_leds = ButtonMatrixElement(rows=[[
create_pad_led(column + 112, u'Pad_LED_%d' % (column, ))
for column in xrange(8)
]],
name=u'Pad_LED_Matrix')
self._faders = ButtonMatrixElement(rows=[[
SliderElement(msg_type=MIDI_PB_TYPE,
channel=index,
identifier=None,
name=u'Fader_%d' % (index, )) for index in xrange(8)
]],
name=u'Faders')
self._master_fader = SliderElement(MIDI_PB_TYPE,
8,
identifier=None,
name=u'Master_Fader')
self._encoders = ButtonMatrixElement(rows=[[
create_ringed_encoder(index + 16, index + 48, u'Encoder_%d' %
(index, )) for index in xrange(8)
]])
self._jogwheel = EncoderElement(
MIDI_CC_TYPE,
0,
60,
Live.MidiMap.MapMode.relative_smooth_signed_bit,
name=u'Jogwheel')
def _create_hardware_settings(self):
self._hardware_settings = self.hardware_settings_component_type(
is_enabled=False,
layer=Layer(
hardware_live_mode_switch=self._hardware_live_mode_switch,
memory_preset_switch=self._memory_preset_switch,
memory_preset_select_mode_switch=self.
_memory_preset_select_mode_switch),
name=u'Hardware_Settings')
self._hardware_settings.set_enabled(True)
def _create_transport(self):
self._transport = TransportComponent(
is_enabled=False,
layer=Layer(play_button=self._play_button,
stop_button=self._stop_button,
punch_in_button=self._punch_in_button,
punch_out_button=self._punch_out_button,
loop_button=self._loop_button,
metronome_button=self._metronome_button,
record_button=self._record_button))
self._transport.set_seek_buttons(self._ff_button, self._rwd_button)
self._transport.set_enabled(True)
def _create_undo(self):
self._undo = UndoComponent(is_enabled=False,
layer=Layer(undo_button=self._undo_button))
self._undo.set_enabled(True)
def _create_session(self):
self._session_ring = SessionRingComponent(
num_tracks=self._pads.width(),
num_scenes=self._pads.height(),
name=u'Session_Ring')
self._session_ring.set_enabled(False)
self._session = self.session_component_type(
session_ring=self._session_ring,
name=u'Session',
is_enabled=False,
layer=Layer(clip_launch_buttons=self._pads,
clip_slot_leds=self._pad_leds))
self._session.set_enabled(True)
def _create_navigation(self):
self._session_navigation = SessionNavigationComponent(
session_ring=self._session_ring,
is_enabled=False,
layer=Layer(page_left_button=self._bank_left_button,
page_right_button=self._bank_right_button,
left_button=self._left_button,
right_button=self._right_button),
name=u'Session_Navigation')
self._session_navigation.set_enabled(True)
def _create_mixer(self):
self._mixer = self.mixer_component_type(
tracks_provider=self._session_ring,
channel_strip_component_type=self.channel_strip_component_type,
is_enabled=False,
layer=Layer(volume_controls=self._faders,
pan_controls=self._encoders))
self._mixer.master_strip().set_volume_control(self._master_fader)
self._mixer.set_enabled(True)
def _create_view_control(self):
self._view_control = self.view_control_component_type(
is_enabled=False,
layer=Layer(prev_track_button=self._left_arrow_button,
next_track_button=self._right_arrow_button,
scene_scroll_encoder=self._jogwheel),
name=u'View_Control')
self._view_control.set_enabled(True)
def _create_arrangement(self):
self._arrangement = ArrangementComponent(
is_enabled=False,
layer=Layer(set_or_delete_cue_button=self._marker_button),
name=u'Arrangement')
self._arrangement.set_enabled(True)
def _create_jogwheel_modes(self):
self._jogwheel_modes = ModesComponent()
self._jogwheel_modes.add_mode(
u'Session',
AddLayerMode(self._view_control,
Layer(scene_scroll_encoder=self._jogwheel)))
self._jogwheel_modes.add_mode(
u'Arranger',
AddLayerMode(self._arrangement,
Layer(jump_encoder=self._jogwheel)))
self._on_focused_view_changed()
@listens(u'focused_document_view')
def _on_focused_view_changed(self):
view = self.application.view.focused_document_view
if self._jogwheel_modes:
self._jogwheel_modes.selected_mode = view
@listens(u'daw_preset')
def _on_memory_preset_changed_on_hardware(self, is_daw_preset_on):
self._session.set_allow_update(is_daw_preset_on)
if is_daw_preset_on:
for control in self.controls:
control.clear_send_cache()
self._session.set_enabled(is_daw_preset_on)
class DS1(LividControlSurface):
_sysex_id = 16
_model_name = 'DS1'
def __init__(self, c_instance):
super(DS1, self).__init__(c_instance)
self._skin = Skin(DS1Colors)
with self.component_guard():
self._define_sysex()
self._setup_controls()
self._setup_background()
self._setup_m4l_interface()
self._setup_session_control()
self._setup_mixer_control()
self._setup_transport_control()
self._setup_device_control()
self._setup_session_recording_component()
self._setup_main_modes()
def _initialize_script(self):
super(DS1, self)._initialize_script()
self._main_modes.set_enabled(True)
self._main_modes.selected_mode = 'Main'
def _initialize_hardware(self):
super(DS1, self)._initialize_hardware()
self.local_control_off.enter_mode()
self.encoder_absolute_mode.enter_mode()
self.encoder_speed_sysex.enter_mode()
def _define_sysex(self):
self.encoder_speed_sysex = SendLividSysexMode(
livid_settings=self._livid_settings,
call='set_encoder_mapping',
message=ENCODER_SPEED)
self.encoder_absolute_mode = SendLividSysexMode(
livid_settings=self._livid_settings,
call='set_encoder_encosion_mode',
message=[2])
self.local_control_off = SendLividSysexMode(
livid_settings=self._livid_settings,
call='set_local_control',
message=[0])
def _setup_controls(self):
is_momentary = True
optimized = True
resource = PrioritizedResource
self._fader = [
MonoEncoderElement(mapping_feedback_delay=-1,
msg_type=MIDI_CC_TYPE,
channel=CHANNEL,
identifier=DS1_FADERS[index],
name='Fader_' + str(index),
num=index,
script=self,
optimized_send_midi=optimized,
resource_type=resource) for index in range(8)
]
self._dial = [[
MonoEncoderElement(mapping_feedback_delay=-1,
msg_type=MIDI_CC_TYPE,
channel=CHANNEL,
identifier=DS1_DIALS[x][y],
name='Dial_' + str(x) + '_' + str(y),
num=x + (y * 5),
script=self,
optimized_send_midi=optimized,
resource_type=resource) for x in range(8)
] for y in range(5)]
self._side_dial = [
MonoEncoderElement(mapping_feedback_delay=-1,
msg_type=MIDI_CC_TYPE,
channel=CHANNEL,
identifier=DS1_SIDE_DIALS[x],
name='Side_Dial_' + str(x),
num=x,
script=self,
optimized_send_midi=optimized,
resource_type=resource) for x in range(4)
]
self._encoder = [
MonoEncoderElement(mapping_feedback_delay=-1,
msg_type=MIDI_CC_TYPE,
channel=CHANNEL,
identifier=DS1_ENCODERS[x],
name='Encoder_' + str(x),
num=x,
script=self,
optimized_send_midi=optimized,
resource_type=resource) for x in range(4)
]
self._encoder_button = [
MonoButtonElement(is_momentary=is_momentary,
msg_type=MIDI_NOTE_TYPE,
channel=CHANNEL,
identifier=DS1_ENCODER_BUTTONS[index],
name='EncoderButton_' + str(index),
script=self,
skin=self._skin,
optimized_send_midi=optimized,
resource_type=resource) for index in range(4)
]
self._master_fader = MonoEncoderElement(msg_type=MIDI_CC_TYPE,
channel=CHANNEL,
identifier=DS1_MASTER,
name='MasterFader',
num=0,
script=self,
optimized_send_midi=optimized,
resource_type=resource)
self._button = [
MonoButtonElement(is_momentary=is_momentary,
msg_type=MIDI_NOTE_TYPE,
channel=CHANNEL,
identifier=DS1_BUTTONS[index],
name='Button_' + str(index),
script=self,
skin=self._skin,
optimized_send_midi=optimized,
resource_type=resource) for index in range(16)
]
self._grid = [[
MonoButtonElement(is_momentary=is_momentary,
msg_type=MIDI_NOTE_TYPE,
channel=CHANNEL,
identifier=DS1_GRID[x][y],
name='Button_' + str(x) + '_' + str(y),
script=self,
skin=self._skin,
optimized_send_midi=optimized,
resource_type=resource) for x in range(3)
] for y in range(3)]
self._dummy = [
MonoEncoderElement(msg_type=MIDI_CC_TYPE,
channel=CHANNEL,
identifier=120 + x,
name='Dummy_Dial_' + str(x),
num=x,
script=self,
optimized_send_midi=optimized,
resource_type=resource) for x in range(5)
]
self._fader_matrix = ButtonMatrixElement(name='FaderMatrix',
rows=[self._fader])
self._top_buttons = ButtonMatrixElement(name='TopButtonMatrix',
rows=[self._button[:8]])
self._bottom_buttons = ButtonMatrixElement(name='BottomButtonMatrix',
rows=[self._button[8:]])
self._dial_matrix = ButtonMatrixElement(name='DialMatrix',
rows=self._dial)
self._side_dial_matrix = ButtonMatrixElement(name='SideDialMatrix',
rows=[self._side_dial])
self._encoder_matrix = ButtonMatrixElement(name='EncoderMatrix',
rows=[self._encoder])
self._encoder_button_matrix = ButtonMatrixElement(
name='EncoderButtonMatrix', rows=[self._encoder_button])
self._grid_matrix = ButtonMatrixElement(name='GridMatrix',
rows=self._grid)
self._selected_parameter_controls = ButtonMatrixElement(
name='SelectedParameterControls',
rows=[self._dummy + self._encoder[:1] + self._encoder[2:]])
def _setup_background(self):
self._background = BackgroundComponent(name='Background')
self._background.layer = Layer(
priority=0,
fader_matrix=self._fader_matrix,
top_buttons=self._top_buttons,
bottom_buttons=self._bottom_buttons,
dial_matrix=self._dial_matrix,
side_dial_matrix=self._side_dial_matrix,
encoder_button_matrix=self._encoder_button_matrix,
grid_matrix=self._grid_matrix)
self._background.set_enabled(True)
def _setup_autoarm(self):
self._auto_arm = AutoArmComponent(name='Auto_Arm')
self._auto_arm.can_auto_arm_track = self._can_auto_arm_track
def _tracks_to_use(self):
return self.song.visible_tracks + self.song.return_tracks
def _setup_session_control(self):
self._session_ring = SessionRingComponent(
num_tracks=8, num_scenes=1, tracks_to_use=self._tracks_to_use)
self._session_ring.set_enabled(True)
self._session_navigation = DS1SessionNavigationComponent(
name='SessionNavigation', session_ring=self._session_ring)
self._session_navigation._vertical_banking.scroll_up_button.color = 'Session.NavigationButtonOn'
self._session_navigation._vertical_banking.scroll_down_button.color = 'Session.NavigationButtonOn'
self._session_navigation._horizontal_banking.scroll_up_button.color = 'Session.NavigationButtonOn'
self._session_navigation._horizontal_banking.scroll_down_button.color = 'Session.NavigationButtonOn'
self._session_navigation.layer = Layer(
priority=4,
track_select_dial=ComboElement(control=self._encoder[1],
modifier=[self._encoder_button[1]]),
up_button=self._grid[0][1],
down_button=self._grid[0][2])
self._session_navigation.set_enabled(False)
self._session = DS1SessionComponent(session_ring=self._session_ring,
auto_name=True)
hasattr(self._session,
'_enable_skinning') and self._session._enable_skinning()
self._session.layer = Layer(
priority=4,
scene_launch_buttons=self._grid_matrix.submatrix[1:2, 1:2])
self._session.clips_layer = AddLayerMode(
self._session,
Layer(priority=4,
clip_launch_buttons=self._top_buttons,
stop_track_clip_buttons=self._bottom_buttons))
self._session.set_enabled(False)
def _setup_mixer_control(self):
self._mixer = MonoMixerComponent(
name='Mixer',
num_returns=2,
tracks_provider=self._session_ring,
track_assigner=SimpleTrackAssigner(),
invert_mute_feedback=True,
auto_name=True,
enable_skinning=True,
channel_strip_component_type=MonoChannelStripComponent)
self._mixer.master_strip().set_volume_control(self._master_fader)
self._mixer.set_prehear_volume_control(self._side_dial[3])
self._mixer.layer = Layer(volume_controls=self._fader_matrix,
track_select_dial=self._encoder[1])
self._strip = [self._mixer.channel_strip(index) for index in range(8)]
if KNOBS_ARE_SENDS:
for index in range(8):
self._strip[index].layer = Layer(
priority=4,
send_controls=self._dial_matrix.submatrix[index:index +
1, :4],
pan_control=self._dial[4][index])
else:
for index in range(8):
self._strip[index].layer = Layer(
priority=4,
parameter_controls=self._dial_matrix.submatrix[
index:index + 1, :])
self._mixer.selected_strip().layer = Layer(
priority=4, parameter_controls=self._selected_parameter_controls)
self._mixer.master_strip().layer = Layer(
priority=4,
parameter_controls=self._side_dial_matrix.submatrix[:3, :])
self._mixer.main_layer = AddLayerMode(
self._mixer,
Layer(priority=4,
solo_buttons=self._bottom_buttons,
mute_buttons=self._top_buttons))
self._mixer.select_layer = AddLayerMode(
self._mixer,
Layer(priority=4,
arm_buttons=self._bottom_buttons,
track_select_buttons=self._top_buttons))
self.song.view.selected_track = self._mixer.channel_strip(0)._track
self._mixer.set_enabled(False)
def _setup_transport_control(self):
self._transport = DS1TransportComponent()
self._transport.name = 'Transport'
self._transport._record_toggle.view_transform = lambda value: 'Transport.RecordOn' if value else 'Transport.RecordOff'
self._transport.layer = Layer(priority=4,
stop_button=self._grid[1][0],
play_button=self._grid[0][0],
record_button=self._grid[2][0])
self._transport.set_enabled(True)
def _setup_device_control(self):
self._device = DeviceComponent(
name='Device_Component',
device_provider=self._device_provider,
device_bank_registry=DeviceBankRegistry())
self._device_navigator = DeviceNavigator(self._device_provider,
self._mixer, self)
self._device_navigator.name = 'Device_Navigator'
def _setup_session_recording_component(self):
self._clip_creator = ClipCreator()
self._clip_creator.name = 'ClipCreator'
self._recorder = SessionRecordingComponent(ViewControlComponent())
self._recorder.set_enabled(True)
self._recorder.layer = Layer(
priority=4,
automation_button=self._grid[1][2],
record_button=self._grid[2][1],
)
def _setup_m4l_interface(self):
self._m4l_interface = M4LInterfaceComponent(
controls=self.controls,
component_guard=self.component_guard,
priority=10)
self._m4l_interface.name = "M4LInterface"
self.get_control_names = self._m4l_interface.get_control_names
self.get_control = self._m4l_interface.get_control
self.grab_control = self._m4l_interface.grab_control
self.release_control = self._m4l_interface.release_control
def _setup_translations(self):
controls = []
for control in self.controls:
controls.append(control)
self._translations = TranslationComponent(controls, 10)
self._translations.name = 'TranslationComponent'
self._translations.set_enabled(False)
def _setup_main_modes(self):
self._main_modes = ModesComponent(name='MainModes')
self._main_modes.add_mode('Main', [
self._mixer, self._mixer.main_layer, self._session,
self._session_navigation
],
cycle_mode_button_color='ModeButtons.Main')
self._main_modes.add_mode('Select', [
self._mixer, self._mixer.select_layer, self._session,
self._session_navigation
],
cycle_mode_button_color='ModeButtons.Select')
self._main_modes.add_mode('Clips', [
self._mixer, self._session, self._session.clips_layer,
self._session_navigation
],
cycle_mode_button_color='ModeButtons.Clips')
self._main_modes.layer = Layer(priority=4,
cycle_mode_button=self._grid[2][2])
self._main_modes.selected_mode = 'Main'
self._main_modes.set_enabled(False)
def _can_auto_arm_track(self, track):
routing = track.current_input_routing
return routing == 'Ext: All Ins' or routing == 'All Ins' or routing.startswith(
'DS1 Input')
class GuitarWing(LividControlSurface): _sysex_id = 20 _model_name = 'GuitarWing' def __init__(self, *a, **k): super(GuitarWing, self).__init__(*a, **k) self._skin = Skin(GuitarWingColors) with self.component_guard(): self._setup_controls() self._setup_m4l_interface() self._setup_session_control() self._setup_mixer_control() self._setup_device_control() self._setup_transport_control() self._setup_view_control() def _setup_controls(self): is_momentary = True optimized = True resource = PrioritizedResource self._button = [MonoButtonElement(is_momentary = is_momentary, msg_type = MIDI_NOTE_TYPE, channel = CHANNEL, identifier = BUTTONS[index], name = 'Button_' + str(index), script = self, skin = self._skin, optimized_send_midi = optimized, resource_type = resource, monobridge = self._monobridge) for index in range(10)] self._fader = [MonoEncoderElement(msg_type = MIDI_CC_TYPE, channel = CHANNEL, identifier = SLIDERS[index], name = 'Fader_' + str(index), num = index, script = self, optimized_send_midi = optimized, resource_type = resource, monobridge = self._monobridge) for index in range(3)] self._fader_button = [MonoEncoderElement(msg_type = MIDI_NOTE_TYPE, channel = CHANNEL, identifier = SLIDERS[index], name = 'Fader_Button_' + str(index), num = index, script = self, optimized_send_midi = optimized, resource_type = resource, monobridge = self._monobridge) for index in range(3)] self._ccs = [MonoEncoderElement(msg_type = MIDI_CC_TYPE, channel = CHANNEL, identifier = CCS[index], name = 'CCs_' + str(index), num = index, script = self, optimized_send_midi = optimized, resource_type = resource, monobridge = self._monobridge) for index in range(4)] self._pad = [MonoButtonElement(is_momentary = is_momentary, msg_type = MIDI_NOTE_TYPE, channel = CHANNEL, identifier = PADS[index], name = 'Pad_' + str(index), script = self, skin = self._skin, optimized_send_midi = optimized, resource_type = resource, monobridge = self._monobridge) for index in range(5)] self._padCC = [MonoEncoderElement(msg_type = MIDI_CC_TYPE, channel = CHANNEL, identifier = PADS[index], name = 'PadCC_' + str(index), num = index, script = self, optimized_send_midi = optimized, resource_type = resource, monobridge = self._monobridge) for index in range(5)] self._accel = [MonoEncoderElement(msg_type = MIDI_CC_TYPE, channel = CHANNEL, identifier = ACCELS[index], name = 'Accel_' + str(index), num = index, script = self, optimized_send_midi = optimized, resource_type = resource, monobridge = self._monobridge) for index in range(3)] self._parameter_control_matrix = ButtonMatrixElement(rows = [ [ self._fader[0], self._fader[1], self._fader[2], self._accel[2], self._ccs[0], self._ccs[1], self._ccs[2], self._ccs[3] ]]) self._scene_launch_matrix = ButtonMatrixElement(rows = [self._pad[:4]]) def _setup_session_control(self): self._session_ring = SessionRingComponent(num_tracks = 1, num_scenes = 4, tracks_to_use = lambda : self.song.visible_tracks + self.song.return_tracks) self._session_ring.set_enabled(False) self._session = SessionComponent(session_ring = self._session_ring, auto_name = True) hasattr(self._session, '_enable_skinning') and self._session._enable_skinning() self._session.layer = Layer(scene_launch_buttons = self._scene_launch_matrix) self._session_navigation =SessionNavigationComponent(name = 'SessionNavigation', session_ring = self._session_ring) self._session_navigation._horizontal_banking.scroll_up_button.color = 'Session.NavigationButtonOn' self._session_navigation._horizontal_banking.scroll_down_button.color = 'Session.NavigationButtonOn' self._session_navigation.layer = Layer(left_button = self._button[1], right_button = self._button[0]) self._session_navigation.set_enabled(True) def _setup_mixer_control(self): self._mixer = MonoMixerComponent(name = 'Mixer', tracks_provider = self._session_ring, track_assigner = SimpleTrackAssigner(), invert_mute_feedback = True, auto_name = True, enable_skinning = True, channel_strip_component_type = MonoChannelStripComponent) self.song.view.selected_track = self._mixer.channel_strip(0)._track def _setup_transport_control(self): self._transport = TransportComponent() self._transport.layer = Layer(play_button = self._button[6], loop_button = self._button[7], seek_backward_button = self._button[8], record_button = self._button[9]) self._transport.set_enabled(True) def _setup_device_control(self): self._device = DeviceComponent(name = 'Device_Component', device_provider = self._device_provider, device_bank_registry = DeviceBankRegistry()) self._device.layer = Layer(parameter_controls = self._parameter_control_matrix) self._device.set_enabled(True) def _setup_m4l_interface(self): self._m4l_interface = M4LInterfaceComponent(controls=self.controls, component_guard=self.component_guard) self.get_control_names = self._m4l_interface.get_control_names self.get_control = self._m4l_interface.get_control self.grab_control = self._m4l_interface.grab_control self.release_control = self._m4l_interface.release_control def _setup_view_control(self): self._view_control = ViewControlComponent() self._view_control.layer = Layer(prev_track_button = self._button[1], next_track_button = self._button[0])
class BaseJor(Base):
def __init__(self, *a, **k):
super(BaseJor, self).__init__(*a, **k)
def _setup_controls(self, *a, **k):
super(BaseJor, self)._setup_controls(*a, **k)
self._touchpad_multi = MultiElement(self._touchpad[0], self._touchpad[1], self._touchpad[2], self._touchpad[3], self._touchpad[4], self._touchpad[5],)
def _setup_translations(self):
controls = self._pad[:6] + self._pad[8:14] + self._pad[16:22] + self._pad[24:30] + self._fader[:6] + self._pad_CC[:6] + self._pad_CC[8:14] + self._pad_CC[16:22] + self._pad_CC[24:30]
if CAP_BUTTON_TRANSLATIONS:
controls = controls + self._touchpad
self._translations = BaseDisplayingTranslationComponent(controls, USER_OFFSET)
self._translations.name = 'TranslationComponent'
self._translations._channel = USER_OFFSET
self._translations.layer = Layer(priority = 10, channel_selector_buttons = self._nav_buttons, display = self._display)
self._translations.set_enabled(False)
controls = [self._pad[6], self._pad[7], self._pad[14], self._pad[15], self._pad[22], self._pad[23], self._pad[30], self._pad[31], self._pad_CC[6], self._pad_CC[7], self._pad_CC[14], self._pad_CC[15], self._pad_CC[22], self._pad_CC[23], self._pad_CC[30], self._pad_CC[31]]
self._translationsJor = BaseDisplayingTranslationComponent(controls, 15)
self._translationsJor.name = 'JorTranslationComponent'
self._translationsJor._channel = 15
self._translationsJor.set_enabled(False)
def _setup_mixer_control(self):
self._mixer = MonoMixerComponent(name = 'Mixer', num_returns = 4,tracks_provider = self._session_ring, track_assigner = right_align_return_tracks_track_assigner, invert_mute_feedback = True, auto_name = True, enable_skinning = True)
self._mixer.master_strip().layer = Layer(priority = 4, volume_control = self._fader[8])
self._mixer.volume_layer = AddLayerMode(self._mixer, Layer(priority = 4, volume_controls = self._fader_matrix.submatrix[:6, :]))
self._mixer.select_layer = AddLayerMode(self._mixer, Layer(priority = 4, track_select_buttons = self._touchpad_matrix.submatrix[:6, :]))
selected_strip = self._mixer.selected_strip()
selected_strip.set_invert_mute_feedback(True)
self._mixer.selected_channel_controls_layer = AddLayerMode(selected_strip, Layer(priority = 4, arm_button = self._button[6], solo_button = self._button[5], mute_button = self._button[4], stop_button = self._button[7]))
self._mixer.selected_sends_layer = AddLayerMode(selected_strip, Layer(priority = 4, send_controls = self._fader_matrix.submatrix[:4, :]))
self._mixer.returns_layer = AddLayerMode(self._mixer, Layer(priority = 4, return_controls = self._fader_matrix.submatrix[4:6, :]))
self._mixer.channel_controls_layer = AddLayerMode(self._mixer, Layer(priority = 4, mute_buttons = self._base_grid.submatrix[:6, :1],
solo_buttons = self._base_grid.submatrix[:6, 1:2],
arm_buttons = self._base_grid.submatrix[:6, 2:3],
stop_clip_buttons = self._base_grid.submatrix[:6, 3:4]))
#self._mixer.navigation_layer = AddLayerMode(self._mixer, Layer(priority = 4, previous_track_button = self._touchpad[6], next_track_button = self._touchpad[7]))
self._mixer.set_enabled(False)
self._view_controller = ViewControlComponent()
self._view_controller.layer = Layer(priority = 4, prev_track_button = self._touchpad[6], next_track_button = self._touchpad[7])
self._view_controller.set_enabled(False)
def _setup_session_control(self):
self._session_ring = SessionRingComponent(num_tracks = 6, num_scenes = 4, tracks_to_use = tracks_to_use)
self._session_ring.set_enabled(False)
self._session_navigation = SessionNavigationComponent(session_ring = self._session_ring)
self._session_navigation.navigation_layer = AddLayerMode(self._session_navigation, Layer(priority = 4, up_button = self._button[4], down_button = self._button[5], left_button = self._button[6], right_button = self._button[7]))
self._session_navigation.page_navigation_layer = AddLayerMode(self._session_navigation, Layer(priority = 4, page_up_button = self._button[4], page_down_button = self._button[5], page_left_button = self._button[6], page_right_button = self._button[7]))
self._session_navigation._vertical_banking.scroll_up_button.color = 'Session.NavigationButtonOn'
self._session_navigation._vertical_banking.scroll_down_button.color = 'Session.NavigationButtonOn'
self._session_navigation._horizontal_banking.scroll_up_button.color = 'Session.NavigationButtonOn'
self._session_navigation._horizontal_banking.scroll_down_button.color = 'Session.NavigationButtonOn'
self._session_navigation._vertical_paginator.scroll_up_button.color = 'Session.PageNavigationButtonOn'
self._session_navigation._vertical_paginator.scroll_down_button.color = 'Session.PageNavigationButtonOn'
self._session_navigation._horizontal_paginator.scroll_up_button.color = 'Session.PageNavigationButtonOn'
self._session_navigation._horizontal_paginator.scroll_down_button.color = 'Session.PageNavigationButtonOn'
self._session_navigation.set_enabled(False)
self._session = BaseSessionComponent(name = 'Session', parent_task_group = self._task_group, session_ring = self._session_ring, auto_name = True)
hasattr(self._session, '_enable_skinning') and self._session._enable_skinning()
self._session.cliplaunch_layer = AddLayerMode(self._session, Layer(priority = 4, clip_launch_buttons = self._base_grid.submatrix[:6, :]))
self._session.overlay_cliplaunch_layer = AddLayerMode(self._session, Layer(priority = 4, clip_launch_buttons = self._base_grid.submatrix[:5, :], scene_launch_buttons = self._base_grid.submatrix[5:6, :]))
#self._session.clipstop_layer = AddLayerMode(self._session, Layer(priority = 4, stop_track_clip_buttons = self._base_grid.submatrix[:, 3:4]))
self._session.set_enabled(False)
def _setup_instrument(self):
self._grid_resolution = GridResolution()
self._c_instance.playhead.enabled = True
self._playhead_element = PlayheadElement(self._c_instance.playhead)
#self._playhead_element.reset()
quantgrid = ButtonMatrixElement([self._base_grid._orig_buttons[2][4:8], self._base_grid._orig_buttons[3][4:7]])
self._drum_group_finder = PercussionInstrumentFinder(device_parent=self.song.view.selected_track)
self._instrument = BaseMonoInstrumentComponent(name = 'InstrumentModes', script = self, skin = self._skin, drum_group_finder = self._drum_group_finder, grid_resolution = self._grid_resolution, settings = DEFAULT_INSTRUMENT_SETTINGS, device_provider = self._device_provider, parent_task_group = self._task_group)
self._instrument.layer = Layer(priority = 6, base_display = self._display)
self._instrument.audioloop_layer = LayerMode(self._instrument, Layer(priority = 6, loop_selector_matrix = self._base_grid))
self._instrument.keypad_options_layer = AddLayerMode(self._instrument, Layer(priority = 6,
base_display = self._display,
scale_up_button = self._touchpad[7],
scale_down_button = self._touchpad[6],
offset_up_button = self._touchpad[5],
offset_down_button = self._touchpad[4],
vertical_offset_up_button = self._touchpad[3],
vertical_offset_down_button = self._touchpad[2],
split_button = self._touchpad[0],
sequencer_button = self._touchpad[1]))
self._instrument.drumpad_options_layer = AddLayerMode(self._instrument, Layer(priority = 6,
base_display = self._display,
scale_up_button = self._touchpad[7],
scale_down_button = self._touchpad[6],
drum_offset_up_button = self._touchpad[5],
drum_offset_down_button = self._touchpad[4],
drumpad_mute_button = self._touchpad[3],
drumpad_solo_button = self._touchpad[2],
split_button = self._touchpad[0],
sequencer_button = self._touchpad[1]))
self._instrument._keypad.octave_toggle_layer = AddLayerMode(self._instrument._keypad, Layer(priority = 7, offset_shift_toggle = self._button[4]))
self._instrument._drumpad.octave_toggle_layer = AddLayerMode(self._instrument._drumpad, Layer(priority = 7, offset_shift_toggle = self._button[4]))
self._instrument._keypad.main_layer = LayerMode(self._instrument._keypad, Layer(priority = 6, keypad_matrix = self._base_grid.submatrix[:6,:]))
self._instrument._keypad.select_layer = LayerMode(self._instrument._keypad, Layer(priority = 6, keypad_select_matrix = self._base_grid.submatrix[:6, :]))
self._instrument._keypad.split_layer = LayerMode(self._instrument._keypad, Layer(priority = 6, keypad_matrix = self._base_grid.submatrix[:6, 2:4]))
self._instrument._keypad.split_select_layer = LayerMode(self._instrument._keypad, Layer(priority = 6, keypad_select_matrix = self._base_grid.submatrix[:6, 2:4]))
self._instrument._keypad.sequencer_layer = AddLayerMode(self._instrument._keypad, Layer(priority = 6, playhead = self._playhead_element, sequencer_matrix = self._base_grid.submatrix[:6, :2]))
self._instrument._keypad.sequencer_shift_layer = AddLayerMode(self._instrument._keypad, Layer(priority = 6, loop_selector_matrix = self._base_grid.submatrix[:6, :1], quantization_buttons = self._base_grid.submatrix[:7, 1:2], follow_button = self._pad[15]))
self._instrument._drumpad.main_layer = LayerMode(self._instrument._drumpad, Layer(priority = 6, drumpad_matrix = self._base_grid.submatrix[:6,:]))
self._instrument._drumpad.select_layer = LayerMode(self._instrument._drumpad, Layer(priority = 6, drumpad_select_matrix = self._base_grid.submatrix[:6,:]))
self._instrument._drumpad.split_layer = LayerMode(self._instrument._drumpad, Layer(priority = 6, drumpad_matrix = self._base_grid.submatrix[:4, :],))
self._instrument._drumpad.split_select_layer = LayerMode(self._instrument._drumpad, Layer(priority = 6, drumpad_select_matrix = self._base_grid.submatrix[:4,:]))
self._instrument._drumpad.sequencer_layer = AddLayerMode(self._instrument._drumpad, Layer(priority = 6, playhead = self._playhead_element, sequencer_matrix = self._base_grid.submatrix[4:6, :]))
self._instrument._drumpad.sequencer_shift_layer = AddLayerMode(self._instrument._drumpad, Layer(priority = 6, loop_selector_matrix = self._base_grid.submatrix[4:6, :2],)) # quantization_buttons = quantgrid, follow_button = self._pad[31]))
self._instrument._selected_session._keys_layer = LayerMode(self._instrument._selected_session, Layer(priority = 6, clip_launch_buttons = self._base_grid.submatrix[:6, :2]))
self._instrument._selected_session._drum_layer = LayerMode(self._instrument._selected_session, Layer(priority = 6, clip_launch_buttons = self._base_grid.submatrix[4:6, :]))
self._instrument._main_modes = ModesComponent(name = 'InstrumentModes')
self._instrument._main_modes.add_mode('disabled', [])
self._instrument._main_modes.add_mode('drumpad', [self._instrument._drumpad, self._instrument._drumpad.main_layer, self.midi_mode_sysex])
self._instrument._main_modes.add_mode('drumpad_split', [self._instrument._drumpad, self._instrument._drumpad.split_layer, self._instrument._selected_session, self._instrument._selected_session._drum_layer, self.splitvertical_mode_sysex])
self._instrument._main_modes.add_mode('drumpad_sequencer', [self._instrument._drumpad, self._instrument._drumpad.sequencer_layer, self._instrument._drumpad.split_layer, self.splitvertical_mode_sysex])
self._instrument._main_modes.add_mode('drumpad_shifted', [self._instrument._drumpad, self._instrument._drumpad.select_layer, self._instrument.drumpad_options_layer, self._instrument._drumpad.octave_toggle_layer, self.midi_mode_sysex])
self._instrument._main_modes.add_mode('drumpad_split_shifted', [ self._instrument._drumpad, self._instrument._drumpad.split_select_layer, self._instrument.drumpad_options_layer, self._instrument._drumpad.octave_toggle_layer, self._instrument._selected_session, self._instrument._selected_session._drum_layer])
self._instrument._main_modes.add_mode('drumpad_sequencer_shifted', [self._instrument._drumpad, self._instrument._drumpad.split_select_layer, self._instrument._drumpad.sequencer_shift_layer, self._instrument.drumpad_options_layer, self._instrument._drumpad.octave_toggle_layer, self.splitvertical_mode_sysex])
self._instrument._main_modes.add_mode('keypad', [self._instrument._keypad, self._instrument._keypad.main_layer, self.midi_mode_sysex])
self._instrument._main_modes.add_mode('keypad_split', [self._instrument._keypad, self._instrument._keypad.split_layer, self._instrument._selected_session, self._instrument._selected_session._keys_layer, self.splithorizontal_mode_sysex])
self._instrument._main_modes.add_mode('keypad_sequencer', [self._instrument._keypad, self._instrument._keypad.sequencer_layer, self._instrument._keypad.split_layer, self.splithorizontal_mode_sysex], )
self._instrument._main_modes.add_mode('keypad_shifted', [self._instrument._keypad, self._instrument._keypad.select_layer, self._instrument.keypad_options_layer, self._instrument._keypad.octave_toggle_layer, self.midi_mode_sysex])
self._instrument._main_modes.add_mode('keypad_split_shifted', [self._instrument._keypad, self._instrument._keypad.split_select_layer, self._instrument.keypad_options_layer, self._instrument._keypad.octave_toggle_layer, self._instrument._selected_session, self._instrument._selected_session._keys_layer])
self._instrument._main_modes.add_mode('keypad_sequencer_shifted', [self._instrument._keypad, self._instrument._keypad.split_select_layer, self._instrument._keypad.sequencer_shift_layer, self._instrument.keypad_options_layer, self._instrument._keypad.octave_toggle_layer, self.splithorizontal_mode_sysex])
self._instrument._main_modes.add_mode('audioloop', [self._instrument.audioloop_layer, self.live_mode_sysex])
self._instrument.register_component(self._instrument._main_modes)
self._instrument.set_enabled(False)
def _setup_main_modes(self):
self._main_modes = BaseDisplayingModesComponent(name = 'MainModes')
self._main_modes.add_mode('disabled', [self._background])
self._main_modes.add_mode('Clips_shifted', [self._mixer, self._mixer.volume_layer, self._mixer.select_layer, self._mixer.channel_controls_layer, self._session_ring, self._session_navigation, self._session_navigation.page_navigation_layer, self.clips_layer_sysex, self.live_mode_sysex, self._translationsJor, self._view_controller], groups = ['shifted'], behaviour = self._shift_latching(color = 'MainModes.Clips'), display_string = MODE_DATA['Clips_shifted'])
self._main_modes.add_mode('Clips', [self._mixer, self._mixer.volume_layer, self._mixer.select_layer, self._session_ring, self._session, self._session.cliplaunch_layer, self._session_navigation, self._session_navigation.navigation_layer, self.clips_layer_sysex, self.live_mode_sysex, self._translationsJor, self._view_controller], behaviour = self._shift_latching(color = 'MainModes.Clips'), display_string = MODE_DATA['Clips'])
self._main_modes.add_mode('Sends_shifted', [self._mixer, self._mixer.returns_layer, self._mixer.selected_sends_layer, self.sends_layer_sysex, self._session_ring, self._recorder, self._recorder.alt_layer, self._instrument, tuple([self._send_instrument_shifted, self._send_instrument_unshifted]), self._translationsJor, self._view_controller], groups = ['shifted'], behaviour = self._shift_latching(color = 'MainModes.Sends'), display_string = MODE_DATA['Sends_shifted']) #self._instrument,
self._main_modes.add_mode('Sends', [self._mixer, self._mixer.returns_layer, self._mixer.selected_sends_layer, self.sends_layer_sysex, self._mixer.select_layer, self._session_ring, self._transport, self._recorder, self._recorder.main_layer, self._instrument, self._translationsJor, self._view_controller], behaviour = self._shift_latching(color = 'MainModes.Sends'), display_string = MODE_DATA['Sends'])
self._main_modes.add_mode('Device_shifted', [self.device_layer_sysex, self._modswitcher, self._mixer, self._session_ring, tuple([self._send_instrument_shifted, self._send_instrument_unshifted]), self._device, self._device.parameters_layer, self._device_navigator.alt_layer, self._translationsJor, self._view_controller], groups = ['shifted'], behaviour = self._shift_latching(color = 'MainModes.Device'), display_string = MODE_DATA['Device_shifted'])
self._main_modes.add_mode('Device', [self.device_layer_sysex, self._modswitcher, self._mixer, self._mixer.select_layer, self._session_ring, self._device, self._device.parameters_layer, self._device.nav_layer, self._device_navigator.main_layer,self._translationsJor, self._view_controller], behaviour = self._shift_latching(color = 'MainModes.Device'), display_string = MODE_DATA['Device'])
self._main_modes.add_mode('User_shifted', [self._translations, self._mixer, self._mixer.select_layer, self.user_layer_sysex, self.user_mode_sysex, self._translationsJor, self._view_controller ], groups = ['shifted'], behaviour = self._shift_latching(color = 'MainModes.User'), display_string = MODE_DATA['User'])
self._main_modes.add_mode('User', [self._translations, self._mixer, self._mixer.select_layer, self.user_layer_sysex, self.user_mode_sysex, self._translationsJor, self._view_controller], behaviour = self._shift_latching(color = 'MainModes.User'), display_string = MODE_DATA['User'])
self._main_modes.add_mode('Select', [self._mixer, self._mixer.volume_layer, self._mixer.selected_channel_controls_layer, self._session_ring, self._session, self._session.overlay_cliplaunch_layer, self.clips_layer_sysex], behaviour = DelayedExcludingMomentaryBehaviour(excluded_groups = ['shifted']), display_string = MODE_DATA['Select']) #excluded_groups = ['shifted']
self._main_modes.Select_button._send_current_color = lambda: None #cant have the multielement updating its button color since it belongs to select buttons, this is the easiest way to deal with it....should probably override in a separate behaviour class
self._main_modes.layer = Layer(priority = 4, Clips_button=self._button[0], Sends_button=self._button[1], Device_button=self._button[2], User_button=self._button[3], Select_button=self._touchpad_multi, display = self._display)
self._main_modes.selected_mode = 'disabled'
self._main_modes.set_enabled(True)
# a
class OhmModes(LividControlSurface):
_sysex_id = 2
_alt_sysex_id = 7
_model_name = 'Ohm'
_version_check = 'b996'
_host_name = 'Ohm'
def __init__(self, c_instance):
super(OhmModes, self).__init__(c_instance)
self._skin = Skin(OhmColors)
with self.component_guard():
self._define_sysex()
self._setup_controls()
self._setup_background()
self._setup_m4l_interface()
self._setup_translations()
self._setup_session_control()
self._setup_mixer_control()
self._setup_device_control()
self._setup_transport_control()
self._setup_drumgroup()
self._setup_keygroup()
self._setup_bassgroup()
self._setup_mod()
self._setup_modswitcher()
self._setup_modes()
self._on_device_changed.subject = self._device_provider
def _define_sysex(self):
#self._send_midi(tuple(switchxfader))
self._reverse_crossfader = SendLividSysexMode(self._livid_settings, call = 'reverse crossfader', message = [1])
def update_display(self):
super(OhmModes, self).update_display()
#self.strobe()
def _initialize_hardware(self):
super(OhmModes, self)._initialize_hardware()
#self._reverse_crossfader.enter_mode()
def _initialize_script(self):
super(OhmModes, self)._initialize_script()
self._main_modes.selected_mode = 'Mix'
self._session.update()
self._mixer.update()
def _setup_controls(self):
is_momentary = True
optimized = True
resource = PrioritizedResource
self._fader = [MonoEncoderElement(msg_type = MIDI_CC_TYPE, channel = CHANNEL, identifier = OHM_FADERS[index], name = 'Fader_' + str(index), num = index, script = self, optimized_send_midi = optimized, resource_type = resource) for index in range(8)]
self._button = [MonoButtonElement(is_momentary = is_momentary, msg_type = MIDI_NOTE_TYPE, channel = CHANNEL, identifier = OHM_BUTTONS[index], name = 'Button_' + str(index), script = self, skin = self._skin, optimized_send_midi = optimized, resource_type = resource) for index in range(8)]
self._dial = [MonoEncoderElement(msg_type = MIDI_CC_TYPE, channel = CHANNEL, identifier = OHM_DIALS[index], name = 'Encoder_' + str(index), num = index, script = self, optimized_send_midi = optimized, resource_type = resource) for index in range(16)]
self._menu = [MonoButtonElement(is_momentary = is_momentary, msg_type = MIDI_NOTE_TYPE, channel = CHANNEL, identifier = OHM_MENU[index], name = 'Menu_' + str(index), script = self, skin = self._skin, optimized_send_midi = optimized, resource_type = resource) for index in range(6)]
self._crossfader = MonoEncoderElement(msg_type = MIDI_CC_TYPE, channel = CHANNEL, identifier = CROSSFADER, name = 'Crossfader', script = self, optimized_send_midi = optimized, resource_type = resource)
self._livid = MonoButtonElement(is_momentary = is_momentary, msg_type = MIDI_NOTE_TYPE, channel = CHANNEL, identifier = LIVID, name = 'Livid_Button', skin = self._skin, script = self, optimized_send_midi = optimized, resource_type = resource)
self._shift_l = MonoButtonElement(is_momentary = is_momentary, msg_type = MIDI_NOTE_TYPE, channel = CHANNEL, identifier = SHIFT_L, name = 'Page_Button_Left', script = self, skin = self._skin, optimized_send_midi = optimized, resource_type = resource)
self._shift_r = MonoButtonElement(is_momentary = is_momentary, msg_type = MIDI_NOTE_TYPE, channel = CHANNEL, identifier = SHIFT_R, name = 'Page_Button_Right', script = self, skin = self._skin, optimized_send_midi = optimized, resource_type = resource)
self._grid = [[MonoButtonElement(is_momentary = is_momentary, msg_type = MIDI_NOTE_TYPE, channel = CHANNEL, identifier = column * 8 + row, name = 'Grid_' + str(column + (row*8)), script = self, skin = self._skin, optimized_send_midi = optimized, resource_type = resource) for column in range(8)] for row in range(8)]
self._matrix = ButtonMatrixElement(name = 'Matrix', rows = [[self._grid[row][column] for column in range(8)] for row in range(8)])
self._dial_matrix = ButtonMatrixElement(name = 'DialMatrix', rows = [self._dial[index*4:(index*4)+4] for index in range(4)])
self._menu_matrix = ButtonMatrixElement(name = 'MenuMatrix', rows = [self._menu])
self._fader_matrix = ButtonMatrixElement(name = 'FaderMatrix', rows = [self._fader])
self._button_matrix = ButtonMatrixElement(name = 'ButtonMatrix', rows = [self._button])
self._parameter_controls = ButtonMatrixElement(rows = [self._dial[:4], self._dial[4:8]])
def _setup_background(self):
self._background = BackgroundComponent(name = 'Background')
self._background.layer = Layer(priority = 3, matrix = self._matrix.submatrix[:,:],
livid_button = self._livid,
shift_l_button = self._shift_l,
shift_r_button = self._shift_r,
crossfader = self._crossfader,
dial_matrix = self._dial_matrix.submatrix[:,:],
menu_matrix = self._menu_matrix.submatrix[:,:],
fader_matrix = self._fader_matrix.submatrix[:,:],
button_matrix = self._button_matrix.submatrix[:,:])
self._background.set_enabled(False)
def _setup_m4l_interface(self):
self._m4l_interface = M4LInterfaceComponent(controls=self.controls, component_guard=self.component_guard)
self.get_control_names = self._m4l_interface.get_control_names
self.get_control = self._m4l_interface.get_control
self.grab_control = self._m4l_interface.grab_control
self.release_control = self._m4l_interface.release_control
def _setup_translations(self):
controls = []
for array in self._grid:
for button in array:
controls.append(button)
if FADER_BANKING:
controls = controls + self._dial
if DIAL_BANKING:
controls = controls + self._dial
self._translations = TranslationComponent(controls = controls, user_channel_offset = USER_CHANNEL, channel = 8)
self._translations.layer = Layer(priority = 5, channel_selector_buttons = self._menu_matrix.submatrix[:,:])
self._translations.set_enabled(False)
dj_controls = [self._grid[7][index] for index in range(7)]
self._dj_translation = TranslationComponent(controls = dj_controls, channel = 12)
def _setup_session_control(self):
self._session_ring = SessionRingComponent(num_tracks = 7, num_scenes = 5)
self._session_ring.set_enabled(True)
self._session_navigation = SessionNavigationComponent(session_ring = self._session_ring)
self._session_navigation.scroll_navigation_layer = AddLayerMode(self._session_navigation, Layer(priority = 5, up_button = self._menu[2], down_button = self._menu[5], left_button = self._menu[3], right_button = self._menu[4]))
self._session_navigation.page_navigation_layer = AddLayerMode(self._session_navigation, Layer(priority = 5, page_up_button = self._menu[2], page_down_button = self._menu[5], page_left_button = self._menu[3], page_right_button = self._menu[4]))
self._session_navigation._vertical_banking.scroll_up_button.color = 'Session.NavigationButtonOn'
self._session_navigation._vertical_banking.scroll_down_button.color = 'Session.NavigationButtonOn'
self._session_navigation._horizontal_banking.scroll_up_button.color = 'Session.NavigationButtonOn'
self._session_navigation._horizontal_banking.scroll_down_button.color = 'Session.NavigationButtonOn'
self._session_navigation._vertical_paginator.scroll_up_button.color = 'Session.PageNavigationButtonOn'
self._session_navigation._vertical_paginator.scroll_down_button.color = 'Session.PageNavigationButtonOn'
self._session_navigation._horizontal_paginator.scroll_up_button.color = 'Session.PageNavigationButtonOn'
self._session_navigation._horizontal_paginator.scroll_down_button.color = 'Session.PageNavigationButtonOn'
self._session_navigation.set_enabled(False)
self._session = OhmSessionComponent(name = 'Session', session_ring = self._session_ring, auto_name = True)
hasattr(self._session, '_enable_skinning') and self._session._enable_skinning()
self._session.set_enabled(False)
self._session.clip_launch_layer = AddLayerMode(self._session, Layer(priority = 5, clip_launch_buttons = self._matrix.submatrix[:7,:5]))
self._session.scene_launch_layer = AddLayerMode(self._session, Layer(priority = 5, scene_launch_buttons = self._matrix.submatrix[7,:5]))
self._session_zoom = SessionOverviewComponent(name = 'Session_Overview', session_ring = self._session_ring, enable_skinning = True)
self._session_zoom.layer = Layer(priority = 5, button_matrix = self._matrix.submatrix[:7,:5])
self._session_zoom.set_enabled(False)
self._session_modes = ModesComponent(name = 'Session_Modes')
self._session_modes.add_mode('disabled', [self._session,
self._session.clip_launch_layer,
self._session.scene_launch_layer,
self._session_navigation,
self._session_navigation.scroll_navigation_layer])
self._session_modes.add_mode('enabled', [self._session,
self._session.scene_launch_layer,
self._session_zoom,
self._session_navigation,
self._session_navigation.page_navigation_layer],
behaviour = DefaultedBehaviour())
self._session_modes.layer = Layer(priority = 5, enabled_button = self._grid[7][7])
self._session_modes.selected_mode = 'disabled'
self._session_modes.set_enabled(False)
def _setup_mixer_control(self):
self._mixer = OhmMixerComponent(name = 'Mixer', tracks_provider = self._session_ring, track_assigner = simple_track_assigner, invert_mute_feedback = True, auto_name = True, enable_skinning = True)
self._mixer.layer = Layer(priority = 5, volume_controls = self._fader_matrix.submatrix[:7, :], prehear_volume_control = self._dial[15], crossfader_control = self._crossfader)
self._mixer.master_strip().layer = Layer(priority = 5, volume_control = self._fader[7], select_button = self._button[7])
self._mixer.mix_layer = AddLayerMode(self._mixer, Layer(priority = 5, mute_buttons = self._matrix.submatrix[:7,5],
solo_buttons = self._matrix.submatrix[:7,6],
arm_buttons = self._matrix.submatrix[:7,7],
send_controls = self._dial_matrix.submatrix[:,:2],
pan_controls = self._dial_matrix.submatrix[:7,2:],
track_select_buttons = self._button_matrix.submatrix[:7,:],))
self._mixer.dj_layer = AddLayerMode(self._mixer, Layer(priority = 5, mute_buttons = self._matrix.submatrix[:7,5],
crossfade_toggles = self._matrix.submatrix[:7,6],
end_pan_controls = self._dial_matrix.submatrix[:3,3],
eq_gain_controls = self._dial_matrix.submatrix[:,:3],
track_select_buttons = self._button_matrix.submatrix[:7,:],))
self._mixer.instrument_layer = AddLayerMode(self._mixer, Layer(priority = 5,
instrument_send_controls = self._dial_matrix.submatrix[:,2:],
arming_track_select_buttons = self._button_matrix.submatrix[:7,:]))
def _setup_device_control(self):
self._device = OhmDeviceComponent(script = self, name = 'Device_Component', device_provider = self._device_provider, device_bank_registry = DeviceBankRegistry())
self._device.layer = Layer(priority = 5, parameter_controls = self._parameter_controls )
self._device.set_enabled(False)
self._device_navigator = DeviceNavigator(self._device_provider, self._mixer, self, name = 'Device_Navigator', )
self._device_navigator.layer = Layer(priority = 5, prev_button = self._menu[3], next_button = self._menu[4])
self._device_navigator.set_enabled(False)
def _setup_transport_control(self):
self._transport = OhmTransportComponent()
self._transport.name = 'Transport'
self._transport.layer = Layer(priority = 5, play_button = self._menu[0], stop_button = self._menu[1])
self._transport.set_enabled(False)
def _setup_drumgroup(self):
self._drumgroup = MonoDrumGroupComponent(translation_channel = PAGE1_DRUM_CHANNEL, set_pad_translations = self.set_pad_translations)
self._drumgroup._on_selected_track_changed.subject = None
self._drumgroup.translation_channel = PAGE1_DRUM_CHANNEL
self._drumgroup.layer = Layer(priority = 6, matrix = self._matrix.submatrix[:4, :4])
self._drumgroup.set_enabled(False)
def _setup_keygroup(self):
self._scale_mode = ModesComponent(name = 'ScaleMode')
for scale in SCALES:
debug('making scale mode:', scale, str(scale))
self._scale_mode.add_mode(str(scale), [])
self._scale_mode.layer = Layer(priority = 5,
ionian_button = self._grid[7][0],
dorian_button = self._grid[7][1],
phrygian_button = self._grid[7][2],
lydian_button = self._grid[7][3],
mixolydian_button = self._grid[7][4],
aeolian_button = self._grid[7][5],
locrian_button = self._grid[7][6],
major_button = self._grid[7][7])
self._scale_mode.selected_mode = 'ionian'
self._scale_mode.set_enabled(False)
self._on_scale_change.subject = self._scale_mode
self._octave_offset_component = ScrollingChannelizedSettingsComponent(name = 'NoteOffset', parent_task_group = self._task_group, value_dict = range(104), default_value_index = 36, default_channel = 0, bank_increment = 12, bank_on_color = 'MonoInstrument.OffsetOnValue', bank_off_color = 'MonoInstrument.OffsetOffValue')
self._octave_offset_component.layer = Layer(priority = 5, bank_up_button = self._menu[2], bank_down_button = self._menu[5])
self._on_octave_change.subject = self._octave_offset_component
self._keygroup = OhmKeyGroupComponent()
self._keygroup._on_selected_track_changed.subject = None
self._keygroup.translation_channel = PAGE1_KEYS_CHANNEL
self._keygroup.layer = Layer(priority = 6, matrix = self._matrix.submatrix[:, 4:7])
self._keygroup.set_enabled(False)
def _setup_bassgroup(self):
self._bassgroup = OhmBassGroupComponent()
self._bassgroup._on_selected_track_changed.subject = None
self._bassgroup.translation_channel = PAGE1_BASS_CHANNEL
self._bassgroup.layer = Layer(priority = 6, matrix = self._matrix.submatrix[4:, :4])
self._bassgroup.set_enabled(False)
def _setup_mod(self):
self.monomodular = get_monomodular(self)
self.monomodular.name = 'monomodular_switcher'
self.modhandler = OhmModHandler(self)
self.modhandler.name = 'ModHandler'
self.modhandler.layer = Layer(priority = 5,
grid = self._matrix.submatrix[:,:],
nav_up_button = self._menu[2],
nav_down_button = self._menu[5],
nav_left_button = self._menu[3],
nav_right_button = self._menu[4],
shift_button = self._menu[1],
alt_button = self._menu[0],
parameter_controls = self._dial_matrix)
self.modhandler.legacy_shift_mode = AddLayerMode(self.modhandler, Layer(priority = 6,
channel_buttons = self._matrix.submatrix[:, 1],
nav_matrix = self._matrix.submatrix[4:8, 2:6]))
self.modhandler.shift_mode = AddLayerMode(self.modhandler, Layer(priority = 6,
device_selector_matrix = self._matrix.submatrix[:, 0],
lock_button = self._livid,
key_buttons = self._matrix.submatrix[:, 7]))
self.modhandler.set_enabled(False)
self.modhandler.set_mod_button(self._livid)
def _setup_modswitcher(self):
self._modswitcher = ModesComponent(name = 'ModSwitcher')
self._modswitcher.add_mode('mod', [self.modhandler, DelayMode(self.modhandler.update, delay = .5)])
self._modswitcher.add_mode('translations', [self._translations])
self._modswitcher.selected_mode = 'translations'
self._modswitcher.set_enabled(False)
def _setup_modes(self):
self._main_modes = ModesComponent(name = 'MainModes')
self._main_modes.add_mode('disabled', [self._background])
self._main_modes.add_mode('Mix', [self._session_modes,
self._mixer,
self._mixer.mix_layer,
self._transport])
self._main_modes.add_mode('DJ', [self._session_modes,
self._mixer,
self._mixer.dj_layer,
self._dj_translation,
tuple([self._assign_tempo, self._deassign_tempo])],
behaviour = DefaultedBehaviour(default_mode = 'Mix'))
#tuple([ lambda:self._set_tempo_buttons([self._grid[7][5], self._grid[7][6]]), self._set_tempo_buttons([])])],
self._main_modes.add_mode('Instrument', [self._update_keygroup_colors,
self._bassgroup,
self._keygroup,
self._scale_mode,
self._octave_offset_component,
self._device,
self._device_navigator,
self._mixer,
self._mixer.instrument_layer,
self._drumgroup],
behaviour = DefaultedBehaviour(default_mode = 'Mix'))
self._main_modes.add_mode('Mod', [self._modswitcher,
self._device,
self._mixer,
self._mixer.instrument_layer],
behaviour = DefaultedBehaviour(default_mode = 'Mix'))
self._main_modes.layer = Layer(priority = 5, Instrument_button = self._shift_l, DJ_button = self._shift_r, Mod_button = self._livid)
self._main_modes.selected_mode = 'disabled'
self._main_modes.set_enabled(True)
def disconnect(self):
super(OhmModes, self).disconnect()
def strobe(self):
if self._backlight_type != 'static':
if self._backlight_type is 'pulse':
self._backlight = int(math.fabs(self._timer * 16 % 64 - 32) + 32)
if self._backlight_type is 'up':
self._backlight = int(self._timer * 8 % 64 + 16)
if self._backlight_type is 'down':
self._backlight = int(math.fabs(int(self._timer * 8 % 64 - 64)) + 16)
self._send_midi(tuple([176, 27, int(self._backlight)]))
if self._ohm_type != 'static':
if self._ohm_type is 'pulse':
self._ohm = int(math.fabs(self._timer * 16 % 64 - 32) + 32)
if self._ohm_type is 'up':
self._ohm = int(self._timer * 8 % 64 + 16)
if self._ohm_type is 'down':
self._ohm = int(math.fabs(int(self._timer * 8 % 64 - 64)) + 16)
self._send_midi(tuple([176, 63, int(self._ohm)]))
self._send_midi(tuple([176, 31, int(self._ohm)]))
def handle_sysex(self, midi_bytes):
debug('sysex: ', str(midi_bytes))
if len(midi_bytes) > 14:
if midi_bytes[:6] == tuple([240, 0, 1, 97, 12, 64]):
self._register_pad_pressed(midi_bytes[6:14])
elif midi_bytes[:6] == tuple([240, 0, 1, 97, 17, 64]):
self._register_pad_pressed(midi_bytes[6:14])
elif midi_bytes[3:11] == tuple([6, 2, 0, 1, 97, 1, 0] + [self._sysex_id]) or midi_bytes[3:11] == tuple([6, 2, 0, 1, 97, 1, 0] + [self._alt_sysex_id]):
if not self._connected:
#self._connection_routine.kill()
self._connected = True
self._livid_settings.set_model(midi_bytes[11])
self._initialize_hardware()
self.schedule_message(1, self._initialize_script)
@listens('device')
def _on_device_changed(self):
self.schedule_message(1, self._update_modswitcher)
#debug('base on_device_changed')
self._update_modswitcher()
def _on_selected_track_changed(self):
super(OhmModes, self)._on_selected_track_changed()
if not len(self.song.view.selected_track.devices):
self._update_modswitcher()
def _update_modswitcher(self):
debug('update modswitcher, mod is:', self.modhandler.active_mod())
if self.modhandler.active_mod():
self._modswitcher.selected_mode = 'mod'
else:
self._modswitcher.selected_mode = 'translations'
@listens('selected_mode')
def _on_scale_change(self, mode):
debug('new scale is:', mode, self._scale_mode.selected_mode)
self._keygroup.scale = SCALES.index(self._scale_mode.selected_mode)
@listens('value')
def _on_octave_change(self, value):
self._keygroup.offset = value
#stupid hack....4 hours wasted on two buttons is too long, so we're doing this instead
def _update_keygroup_colors(self):
self._grid[5][7].send_value(2, force = True)
self._grid[6][7].send_value(2, force = True)
#everything below needs to be consolidated into transport component
def _assign_tempo(self):
self._grid[5][7].send_value(4, True)
self._grid[6][7].send_value(4, True)
self._tempo_up_value.subject = self._grid[5][7]
self._tempo_down_value.subject = self._grid[6][7]
def _deassign_tempo(self):
self._tempo_up_value.subject and self._tempo_up_value.subject.turn_off()
self._tempo_down_value.subject and self._tempo_down_value.subject.turn_off()
self._tempo_up_value.subject = None
self._tempo_down_value.subject = None
@listens('value')
def _tempo_up_value(self, value):
if value:
self.song.tempo = round(min(self.song.tempo + 1, 999))
@listens('value')
def _tempo_down_value(self, value):
if value:
self.song.tempo = round(max(self.song.tempo - 1, 20))
class OhmModesRay(OhmModes):
_sysex_id = 2
_alt_sysex_id = 7
_model_name = 'Ohm'
_version_check = 'b996'
_host_name = 'Ohm'
device_provider_class = ModDeviceProvider
def __init__(self, c_instance):
super(OhmModes, self).__init__(c_instance)
self._skin = Skin(OhmColors)
with self.component_guard():
self._define_sysex()
self._setup_controls()
self._setup_background()
self._setup_m4l_interface()
#self._setup_translations()
self._setup_session_control()
self._setup_mixer_control()
#self._setup_device_control()
#self._setup_transport_control()
#self._setup_drumgroup()
#self._setup_keygroup()
#self._setup_bassgroup()
#self._setup_mod()
#self._setup_modswitcher()
self._setup_modes()
#self._on_device_changed.subject = self._device_provider
def _setup_session_control(self):
self._session_ring = SessionRingComponent(num_tracks=7, num_scenes=7)
self._session_ring.set_enabled(True)
self._session_navigation = SessionNavigationComponent(
session_ring=self._session_ring)
self._session_navigation.scroll_navigation_layer = AddLayerMode(
self._session_navigation,
Layer(priority=5,
up_button=self._menu[1],
down_button=self._menu[4],
left_button=self._menu[3],
right_button=self._menu[5]))
self._session_navigation.page_navigation_layer = AddLayerMode(
self._session_navigation,
Layer(priority=5,
page_up_button=self._menu[2],
page_down_button=self._menu[5],
page_left_button=self._menu[3],
page_right_button=self._menu[4]))
self._session_navigation._vertical_banking.scroll_up_button.color = 'Session.NavigationButtonOn'
self._session_navigation._vertical_banking.scroll_down_button.color = 'Session.NavigationButtonOn'
self._session_navigation._horizontal_banking.scroll_up_button.color = 'Session.NavigationButtonOn'
self._session_navigation._horizontal_banking.scroll_down_button.color = 'Session.NavigationButtonOn'
self._session_navigation._vertical_paginator.scroll_up_button.color = 'Session.PageNavigationButtonOn'
self._session_navigation._vertical_paginator.scroll_down_button.color = 'Session.PageNavigationButtonOn'
self._session_navigation._horizontal_paginator.scroll_up_button.color = 'Session.PageNavigationButtonOn'
self._session_navigation._horizontal_paginator.scroll_down_button.color = 'Session.PageNavigationButtonOn'
self._session_navigation.set_enabled(False)
self._session = SpecialOhmSessionComponent(
name='Session', session_ring=self._session_ring, auto_name=True)
self._session.set_enabled(False)
self._session.clip_launch_layer = AddLayerMode(
self._session,
Layer(priority=5,
clip_launch_buttons=self._matrix.submatrix[:7, :7]))
self._session.scene_launch_layer = AddLayerMode(
self._session,
Layer(priority=5,
scene_launch_buttons=self._matrix.submatrix[7, :7]))
self._session.stop_clips_layer = AddLayerMode(
self._session,
Layer(priority=5,
stop_track_clip_buttons=self._matrix.submatrix[:7, 7],
stop_all_clips_button=self._grid[7][7]))
"""self._session_zoom = SessionOverviewComponent(name = 'Session_Overview', session_ring = self._session_ring, enable_skinning = True)
self._session_zoom.layer = Layer(priority = 5, button_matrix = self._matrix.submatrix[:7,:7])
self._session_zoom.set_enabled(False)
self._session_modes = ModesComponent(name = 'Session_Modes')
self._session_modes.add_mode('disabled', [self._session,
self._session.clip_launch_layer,
self._session.scene_launch_layer,
self._session_navigation,
self._session_navigation.scroll_navigation_layer])
self._session_modes.add_mode('enabled', [self._session,
self._session.scene_launch_layer,
self._session_zoom,
self._session_navigation,
self._session_navigation.page_navigation_layer],
behaviour = DefaultedBehaviour())
self._session_modes.layer = Layer(priority = 5, enabled_button = self._grid[7][7])
self._session_modes.selected_mode = 'disabled'
self._session_modes.set_enabled(False)"""
def _setup_mixer_control(self):
self._mixer = OhmMixerComponent(name='Mixer',
tracks_provider=self._session_ring,
track_assigner=simple_track_assigner,
invert_mute_feedback=True,
auto_name=True,
enable_skinning=True)
#self._mixer.layer = Layer(priority = 5, volume_controls = self._fader_matrix.submatrix[:7, :], prehear_volume_control = self._dial[15], crossfader_control = self._crossfader)
self._mixer.layer = Layer(
priority=5, solo_buttons=self._button_matrix.submatrix[:7, :])
"""self._mixer.master_strip().layer = Layer(priority = 5, volume_control = self._fader[7], select_button = self._button[7])
self._mixer.mix_layer = AddLayerMode(self._mixer, Layer(priority = 5, mute_buttons = self._matrix.submatrix[:7,5],
solo_buttons = self._matrix.submatrix[:7,6],
arm_buttons = self._matrix.submatrix[:7,7],
send_controls = self._dial_matrix.submatrix[:,:2],
pan_controls = self._dial_matrix.submatrix[:7,2:],
track_select_buttons = self._button_matrix.submatrix[:7,:],))
self._mixer.dj_layer = AddLayerMode(self._mixer, Layer(priority = 5, mute_buttons = self._matrix.submatrix[:7,5],
crossfade_toggles = self._matrix.submatrix[:7,6],
end_pan_controls = self._dial_matrix.submatrix[:3,3],
eq_gain_controls = self._dial_matrix.submatrix[:,:3],
track_select_buttons = self._button_matrix.submatrix[:7,:],))
self._mixer.instrument_layer = AddLayerMode(self._mixer, Layer(priority = 5,
instrument_send_controls = self._dial_matrix.submatrix[:,2:],
arming_track_select_buttons = self._button_matrix.submatrix[:7,:]))
"""
def _setup_modes(self):
self._main_modes = ModesComponent(name='MainModes')
self._main_modes.add_mode('disabled', [self._background])
self._main_modes.add_mode('Mix', [
self._mixer, self._session, self._session.stop_clips_layer,
self._session.clip_launch_layer, self._session.scene_launch_layer,
self._session_navigation,
self._session_navigation.scroll_navigation_layer
])
self._main_modes.selected_mode = 'disabled'
self._main_modes.set_enabled(True)