def _setup_shift_modes(self): self._main_shift_modes = ModesComponent(name = 'MainShiftModes') self._main_shift_modes.add_mode('disabled', [self.normal_encoder_sysex], cycle_mode_button_color = 'DefaultButton.Off') self._main_shift_modes.add_mode('enabled', [self.slow_encoder_sysex], cycle_mode_button_color = 'DefaultButton.On') #, self._value_default self._main_shift_modes.layer = Layer(priority = 4, cycle_mode_button = self._livid) self._main_shift_modes.set_enabled(False) self._main_shift_modes.selected_mode = 'disabled' self._mod_shift_modes = ModesComponent(name = 'ModShiftModes') self._mod_shift_modes.layer = Layer(priority = 4, cycle_mode_button = self._livid) self._mod_shift_modes.set_enabled(False)
def _setup_shift_mode(self): self._shifted = False #self._shift_mode = self.register_component(ModesComponent()) self._shift_mode = ModesComponent() #parent = self) self._shift_mode.add_mode('disabled', []) self._shift_mode.add_mode( 'shift', tuple([ lambda a: self._on_shift_value(True), lambda a: self._on_shift_value(False) ]), behaviour=ShiftCancellableBehaviourWithRelease())
def _init_track_modes(self): self._track_modes = ModesComponent(name='Track_Modes') self._track_modes.set_enabled(False) self._track_modes.add_mode( 'stop', AddLayerMode(self._stop_clips, self._stop_track_clips_layer)) self._track_modes.add_mode( 'solo', AddLayerMode(self._mixer, self._mixer_solo_layer)) self._track_modes.add_mode( 'mute', AddLayerMode(self._mixer, self._mixer_mute_layer)) self._track_modes.layer = self._create_track_modes_layer() self._track_modes.selected_mode = 'mute'
def __init__(self, note_settings_component_class=None, automation_component_class=None, grid_resolution=None, initial_encoder_layer=None, encoder_layer=None, *a, **k): super(NoteEditorSettingsComponent, self).__init__(*a, **k) assert encoder_layer assert note_settings_component_class is not None assert automation_component_class is not None self.settings = note_settings_component_class( grid_resolution=grid_resolution, parent=self, is_enabled=False) self.automation = automation_component_class(parent=self, is_enabled=False) self._mode_selector = ModeSelector(parent=self, is_enabled=False) self._visible_detail_view = 'Detail/DeviceChain' self._show_settings_task = self._tasks.add( task.sequence(task.wait(defaults.MOMENTARY_DELAY), task.run(self._show_settings))).kill() self._update_infos_task = self._tasks.add( task.run(self._update_note_infos)).kill() self._settings_modes = ModesComponent(parent=self) self._settings_modes.set_enabled(False) self._settings_modes.add_mode('automation', [ self.automation, self._mode_selector, partial(self._set_envelope_view_visible, True), partial(show_clip_view, self.application) ]) self._settings_modes.add_mode('note_settings', [ self.settings, self._update_note_infos, self._mode_selector, partial(self._set_envelope_view_visible, False), partial(show_clip_view, self.application) ]) self._settings_modes.selected_mode = 'note_settings' self.__on_selected_setting_mode_changed.subject = self._settings_modes self.add_mode('disabled', []) self.add_mode('about_to_show', [ AddLayerMode(self, initial_encoder_layer), (self._show_settings_task.restart, self._show_settings_task.kill) ]) self.add_mode('enabled', [ DetailViewRestorerMode(self.application), AddLayerMode(self, encoder_layer), self._settings_modes ]) self.selected_mode = 'disabled' self._editors = [] self._on_detail_clip_changed.subject = self.song.view self._on_selected_track_changed.subject = self.song.view self.__on_full_velocity_changed.subject = self.settings self.__on_setting_changed.subject = self.settings return
class KeyLabMkII(KeyLabEssential): 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(KeyLabMkII, self).__init__(*a, **k) with self.component_guard(): self._create_session_recording() def _create_controls(self): super(KeyLabMkII, self)._create_controls() def make_button_row(index_offset, name): return ButtonMatrixElement(rows=[[ create_button(index + index_offset, name=u'{}_{}'.format(name, index)) for index in xrange(8) ]], name=u'{}s'.format(name)) self._select_buttons = make_button_row(24, u'Select_Button') self._solo_buttons = make_button_row(8, u'Solo_Button') self._mute_buttons = make_button_row(16, u'Mute_Button') self._record_arm_buttons = make_button_row(0, u'Record_Arm_Buttons') self._automation_button = create_button(56, name=u'Automation_Button') self._re_enable_automation_button = create_button(57, name=u'Re_Enable_Automation_Button') self._view_button = create_button(74, name=u'View_Button') self._pads = ButtonMatrixElement(rows=[ [ create_button(identifier, channel=9, name=u'Pad_{}_{}'.format(col_index, row_index)) for col_index, identifier in enumerate(row) ] for row_index, row in enumerate(PAD_IDS) ]) self._pad_leds = ButtonMatrixElement(rows=[ [ create_pad_led(identifier, u'Pad_LED_{}_{}'.format(col_index, row_index)) for col_index, identifier in enumerate(row) ] for row_index, row in enumerate(PAD_LED_IDS) ], name=u'Pad_LED_Matrix') self._display = PhysicalDisplayElement(DISPLAY_LINE_WIDTH, name=u'Display') self._display.set_message_parts(sysex.LCD_SET_STRING_MESSAGE_HEADER + (sysex.LCD_LINE_1_ITEM_ID,), (sysex.NULL, sysex.LCD_LINE_2_ITEM_ID) + (ord(u' '),) * DISPLAY_LINE_WIDTH + (sysex.NULL, sysex.END_BYTE)) self._mixer_mode_cycle_button = create_button(51, name=u'Mixer_Mode_Cycle_Button') self._vegas_mode_switch = SysexElement(send_message_generator=lambda b: sysex.VEGAS_MODE_MESSAGE_HEADER + (b, sysex.END_BYTE), name=u'Vegas_Mode_Switch') def _create_mixer(self): super(KeyLabMkII, self)._create_mixer() self._mixer.layer += Layer(track_select_buttons=self._select_buttons, solo_buttons=self._solo_buttons, mute_buttons=self._mute_buttons, arm_buttons=self._record_arm_buttons, selected_track_name_display=self._display) self._mixer_modes = ModesComponent(name=u'Mixer_Modes') self._mixer_modes.add_mode(u'volume_mode', AddLayerMode(self._mixer, Layer(volume_controls=self._faders))) self._mixer_modes.add_mode(u'sends_a_mode', AddLayerMode(self._mixer, Layer(send_controls=self._faders))) self._mixer_modes.layer = Layer(cycle_mode_button=self._mixer_mode_cycle_button) self._mixer_modes.selected_mode = u'volume_mode' def _create_session_recording(self): self._session_recording = SessionRecordingComponent(name=u'Session_Recording', is_enabled=False, layer=Layer(automation_button=self._automation_button, re_enable_automation_button=self._re_enable_automation_button)) self._session_recording.set_enabled(True) def _create_view_control(self): super(KeyLabMkII, self)._create_view_control() self._view_control.layer += Layer(document_view_toggle_button=self._view_button) def _create_hardware_settings(self): super(KeyLabMkII, self)._create_hardware_settings() self._hardware_settings.layer += Layer(vegas_mode_switch=self._vegas_mode_switch)
def _create_launch_modes(self): self._scene_list = SceneListComponent(name='Expanded_Scene_Launch', session_ring=self._session_ring, num_scenes=16) self._launch_modes = ModesComponent(name='Launch_Modes') self._launch_modes.add_mode('clip_launch', [ partial(self._elements.launch_mode_switch.send_value, 0), ExtendComboElementMode(combo_pairs=zip(chain(*self._elements.clip_launch_buttons_raw), chain(*self._elements.physical_clip_launch_buttons_raw))), ExtendComboElementMode(combo_pairs=zip(chain(*self._elements.clip_color_controls_raw), chain(*self._elements.physical_clip_color_controls_raw)))], cycle_mode_button_color='Mode.Off') if not self.is_force: self._launch_modes.add_mode('scene_launch', [ partial(self._elements.launch_mode_switch.send_value, 1), LayerMode(self._scene_list, Layer(scene_launch_buttons='mpc_scene_launch_buttons', scene_color_controls='mpc_scene_color_controls'))], cycle_mode_button_color='Mode.On') self._launch_modes.layer = Layer(cycle_mode_button='xyfx_button' if self._product_id == MPC_X_PRODUCT_ID else 'sixteen_level_button') self._launch_modes.selected_mode = 'clip_launch'
def _create_record_modes(self): self._session_record = SessionRecordingComponent( name=b'Session_Record', is_enabled=False, layer=Layer(record_button=b'record_button')) self._record_modes = ModesComponent(name=b'Record_Modes') self._record_modes.add_mode(b'session', EnablingMode(self._session_record)) self._record_modes.add_mode( b'arrange', AddLayerMode(self._transport, layer=Layer(record_button=b'record_button'))) self.__on_main_view_changed()
def __init__(self, selection=None, browser_mode=None, browser_component=None, browser_hotswap_mode=None, *a, **k): (super(CreateInstrumentTrackComponent, self).__init__)(*a, **k) self._selection = selection self._with_browser_modes = ModesComponent(parent=self) self._with_browser_modes.add_mode('create', [ self._prepare_browser, SetAttributeMode(self.application.browser, 'filter_type', Live.Browser.FilterType.instrument_hotswap), SetAttributeMode(browser_component, 'do_load_item', self._do_browser_load_item), browser_mode, browser_component.reset_load_memory]) self._with_browser_modes.add_mode('hotswap', [browser_hotswap_mode, browser_mode]) self._go_to_hotswap_task = self._tasks.add(task.sequence(task.delay(1), task.run(self._go_to_hotswap))) self._go_to_hotswap_task.kill()
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)
def _setup_device_chooser(self): self._selected_device = self._device[0] self._last_selected_device = self._device[0] self._selected_device_modes = ModesComponent() self._selected_device_modes.add_mode('disabled', [None]) self._selected_device_modes.add_mode('device_0', [self._device_navigator._dev1_layer], behaviour = DefaultedBehaviour()) self._selected_device_modes.add_mode('device_1', [self._device_navigator._dev2_layer], behaviour = DefaultedBehaviour()) self._selected_device_modes.add_mode('device_2', [self._device_navigator._dev3_layer], behaviour = DefaultedBehaviour()) self._selected_device_modes.add_mode('device_3', [self._device_navigator._dev4_layer], behaviour = DefaultedBehaviour()) self._selected_device_modes.layer = Layer(priority = 4, device_0_button = self._button[0][0], device_1_button = self._button[0][1], device_2_button = self._button[0][2], device_3_button = self._button[0][3]) self._selected_device_modes.selected_mode = 'device_0' self._selected_device_modes.set_enabled(False) self._on_device_selector_mode_changed.subject = self._selected_device_modes
def _create_modes(self): self._modes = ModesComponent(name='Encoder_Modes') self._modes.add_mode('volume_mode', LayerMode(self._mixer, Layer(volume_controls=(self._encoders)))) self._modes.add_mode('pan_mode', LayerMode(self._mixer, Layer(pan_controls=(self._encoders)))) self._modes.add_mode('send_a_mode', [ LayerMode(self._mixer, Layer(send_controls=(self._encoders))), partial(self._set_send_index, 0)]) self._modes.add_mode('send_b_mode', [ LayerMode(self._mixer, Layer(send_controls=(self._encoders))), partial(self._set_send_index, 1)]) self._modes.layer = Layer(volume_mode_button=(self._volume_mode_button), pan_mode_button=(self._pan_mode_button), send_a_mode_button=(self._send_a_mode_button), send_b_mode_button=(self._send_b_mode_button)) self._modes.selected_mode = 'volume_mode'
def _create_main_modes(self): self._main_modes = ModesComponent(name='Main_Modes', is_enabled=False) suppressed_arrow_button_mode = ( AddLayerMode(self._background, Layer(left_button='left_button', right_button='right_button', up_button='up_button', down_button='down_button')),) self._main_modes.add_mode('none', suppressed_arrow_button_mode) self._main_modes.add_mode('fader', None) self._main_modes.add_mode('session', self._session_modes) self._main_modes.add_mode('note', ( AddLayerMode(self._drum_group, Layer(scroll_up_button='left_button', scroll_down_button='right_button', scroll_page_up_button='up_button', scroll_page_down_button='down_button')), self._clip_actions)) self._main_modes.add_mode('chord', suppressed_arrow_button_mode) self._main_modes.selected_mode = 'session' self._main_modes.set_enabled(True) self.__on_main_mode_changed.subject = self._main_modes return
def _create_note_modes(self): self._note_modes = ModesComponent(name=u'Note_Modes', is_enabled=False) self._note_modes.add_mode( u'scale', AddLayerMode(self._clip_actions, Layer(delete_button=u'clear_button'))) self._note_modes.add_mode( u'drum', AddLayerMode( self._drum_group, Layer(scroll_up_button=u'left_button', scroll_down_button=u'right_button', scroll_page_up_button=u'up_button', scroll_page_down_button=u'down_button', delete_button=u'clear_button')))
def _create_encoder_modes(self): self._encoder_modes = ModesComponent(name=u'Encoder_Modes', enable_skinning=True) self._encoder_modes.add_mode( u'volume', AddLayerMode(self._mixer, Layer(volume_controls=u'encoders'))) self._encoder_modes.add_mode( u'pan', AddLayerMode(self._mixer, Layer(pan_controls=u'encoders'))) self._encoder_modes.add_mode( u'send_a', AddLayerMode(self._mixer, Layer(send_a_controls=u'encoders'))) self._encoder_modes.add_mode( u'send_b', AddLayerMode(self._mixer, Layer(send_b_controls=u'encoders'))) self._encoder_modes.selected_mode = u'volume'
def _create_view_based_modes(self): self._view_based_modes = ModesComponent(is_enabled=False) self._view_based_modes.add_mode( b'session', (EnablingMode(self._clip_launch), AddLayerMode( self._transport, Layer(session_record_button=self._record_button, record_button=self._count_in_button)))) self._view_based_modes.add_mode( b'arrange', AddLayerMode( self._transport, Layer(record_button=self._record_button, session_record_button=self._count_in_button))) self.__on_main_view_changed()
class CreateInstrumentTrackComponent(Component, Messenger): @depends(selection=None) def __init__(self, selection=None, browser_mode=None, browser_component=None, browser_hotswap_mode=None, *a, **k): super(CreateInstrumentTrackComponent, self).__init__(*a, **k) self._selection = selection self._with_browser_modes = ModesComponent(parent=self) self._with_browser_modes.add_mode(b'create', [ self._prepare_browser, SetAttributeMode(self.application.browser, b'filter_type', Live.Browser.FilterType.instrument_hotswap), SetAttributeMode(browser_component, b'do_load_item', self._do_browser_load_item), browser_mode, browser_component.reset_load_memory ]) self._with_browser_modes.add_mode(b'hotswap', [browser_hotswap_mode, browser_mode]) self._go_to_hotswap_task = self._tasks.add( task.sequence(task.delay(1), task.run(self._go_to_hotswap))) self._go_to_hotswap_task.kill() def on_enabled_changed(self): self._with_browser_modes.selected_mode = b'create' if self.is_enabled( ) else None self._go_to_hotswap_task.kill() return def _prepare_browser(self): self.application.browser.hotswap_target = None return def _do_browser_load_item(self, item): song = self.song try: song.create_midi_track() except Live.Base.LimitationError: self.expect_dialog(MessageBoxText.TRACK_LIMIT_REACHED) item.action() self._go_to_hotswap_task.restart() def _go_to_hotswap(self): self._with_browser_modes.selected_mode = b'hotswap'
def __init__(self, *a, **k): super(ComradeEncoders, self).__init__((), *a, **k) self._main_modes = NullModes() self._element_injector = inject(element_container=const(None)).everywhere() self._message_injector = inject(message=const(None)).everywhere() with self.component_guard(): with inject(skin=const(skin), message_cache=const(self._sysex_message_cache)).everywhere(): self._elements = Elements() self._element_injector = inject(element_container=const(self._elements)).everywhere() with self.component_guard(): self._create_message() self._message_injector = inject(message=const(self._message)).everywhere() self._switch_display_layout(sysex.KNOB_SCREEN_LAYOUT_BYTE) self._device_bank_registry = DeviceBankRegistry() with self.component_guard(): self._create_transport() self._create_auto_arm() self._create_drums() self._create_device() self._create_device_navigation() self._create_actions() self._create_clip_actions() self._create_background() self._create_modes() self._drum_group_finder = self.register_disconnectable(PercussionInstrumentFinder(device_parent=self.song.view.selected_track)) self.__on_drum_group_found.subject = self._drum_group_finder self.__on_drum_group_found() self.__on_selected_track_changed.subject = self.song.view self.__on_selected_track_changed() self.__on_record_mode_changed.subject = self.song self.set_feedback_channels([DRUM_FEEDBACK_CHANNEL]) self._set_feedback_velocity()
def __init__(self, c_instance): ControlSurface.__init__(self, c_instance) self._main_modes = NullModes() self._element_injector = inject( element_container=const(None)).everywhere() self._message_injector = inject(message=const(None)).everywhere() with self.component_guard(): with inject(skin=const(skin), message_cache=const( self._sysex_message_cache)).everywhere(): self._elements = Elements() self._element_injector = inject( element_container=const(self._elements)).everywhere() with self.component_guard(): self._create_message() self._message_injector = inject( message=const(self._message)).everywhere() self._switch_display_layout(sysex.KNOB_SCREEN_LAYOUT_BYTE) self._device_bank_registry = DeviceBankRegistry() with self.component_guard(): self._create_session() self._create_mixer() self._create_session_recording() self._create_auto_arm() self._create_track_navigation() self._create_device() self._create_device_navigation() self._create_background() self._create_modes() return
def __init__(self, selection=None, browser_component=None, browser_mode=None, browser_hotswap_mode=None, insert_left=False, *a, **k): (super(CreateDeviceComponent, self).__init__)(*a, **k) self._selection = selection self._add_effect_mode = BrowserAddEffectMode(selection=selection, browser=(self.application.browser), application_view=(self.application.view), insert_left=insert_left) self._create_device_modes = ModesComponent(parent=self) self._create_device_modes.add_mode('create', [ SetAttributeMode(browser_component, 'do_load_item', self._do_browser_load_item), self._add_effect_mode, browser_mode, browser_component.reset_load_memory]) self._create_device_modes.add_mode('hotswap', [browser_hotswap_mode, browser_mode]) self._go_to_hotswap_task = self._tasks.add(task.sequence(task.delay(1), task.run(self._go_to_hotswap))) self._go_to_hotswap_task.kill()
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 _create_main_mixer_modes(self): self._mixer_control = MixerControlComponent(name='Global_Mix_Component', view_model=self._model.mixerView, tracks_provider=self._session_ring, is_enabled=False, layer=Layer(controls='fine_grain_param_controls', volume_button='track_state_buttons_raw[0]', panning_button='track_state_buttons_raw[1]', send_slot_one_button='track_state_buttons_raw[2]', send_slot_two_button='track_state_buttons_raw[3]', send_slot_three_button='track_state_buttons_raw[4]', send_slot_four_button='track_state_buttons_raw[5]', send_slot_five_button='track_state_buttons_raw[6]', cycle_sends_button='track_state_buttons_raw[7]')) self._model.mixerView.realtimeMeterData = self._mixer_control.real_time_meter_handlers track_mixer_control = TrollMixerControlComponent(script = self, name='Track_Mix_Component', is_enabled=False, tracks_provider=self._session_ring, layer=Layer(controls='fine_grain_param_controls', scroll_left_button='track_state_buttons_raw[6]', scroll_right_button='track_state_buttons_raw[7]')) self._track_mixer_control = track_mixer_control #track_mixer_control = TrackMixerControlComponent(name='Track_Mix_Component', is_enabled=False, tracks_provider=self._session_ring, layer=Layer(controls='fine_grain_param_controls', scroll_left_button='track_state_buttons_raw[6]', scroll_right_button='track_state_buttons_raw[7]')) routing_control = RoutingControlComponent(is_enabled=False, layer=Layer(monitor_state_encoder='parameter_controls_raw[0]')) track_mix_or_routing_chooser = TrackOrRoutingControlChooserComponent(tracks_provider=self._session_ring, track_mixer_component=track_mixer_control, routing_control_component=routing_control, is_enabled=False, layer=Layer(mix_button='track_state_buttons_raw[0]', routing_button='track_state_buttons_raw[1]')) self._model.mixerView.trackControlView = track_mix_or_routing_chooser self._mix_modes = ModesComponent(is_enabled=False) self._mix_modes.add_mode('global', self._mixer_control) self._mix_modes.add_mode('track', track_mix_or_routing_chooser) self._mix_modes.selected_mode = 'global' self._model.mixerSelectView = self._mixer_control self._model.trackMixerSelectView = track_mixer_control class MixModeBehaviour(ReenterBehaviour): def press_immediate(behaviour_self, component, mode): if self._is_on_master() and self._mix_modes.selected_mode != 'track': self._mix_modes.selected_mode = 'track' super(MixModeBehaviour, behaviour_self).press_immediate(component, mode) def on_reenter(behaviour_self): if not self._is_on_master(): self._mix_modes.cycle_mode() self._main_modes.add_mode('mix', [self._mix_modes, SetAttributeMode(obj=self._note_editor_settings_component, attribute='parameter_provider', value=self._track_parameter_provider)], behaviour=MixModeBehaviour())
def _create_lower_pad_modes(self): self._lower_pad_modes = ModesComponent( name=b'Lower_Pad_Modes', is_enabled=False, layer=Layer(cycle_mode_button=b'minus_button')) self._lower_pad_modes.add_mode( b'select', AddLayerMode(self._mixer, Layer(track_select_buttons=b'lower_pads')), cycle_mode_button_color=b'Session.StopClipDisabled') self._lower_pad_modes.add_mode( b'stop', AddLayerMode(self._session, Layer(stop_track_clip_buttons=b'lower_pads')), cycle_mode_button_color=b'Session.StopClip') self._lower_pad_modes.selected_mode = b'select'
def _setup_modes(self): self._button_modes = ModesComponent(name='Button_Modes') self._button_modes.add_mode('launcher', self._launcher) self._button_modes.add_mode('looper', self._looper) self._button_modes.add_mode('device', self._device_control) self._button_modes.selected_mode = 'looper' self._button_modes.set_enabled(True)
def __init__(self, *a, **k): super(OhmModHandler, self).__init__(*a, **k) self._shift_mode = ModesComponent() self._color_type = 'RGB' self._shift_mode.add_mode('shift', tuple([self._enable_shift, self._disable_shift]), behaviour = CancellableBehaviourWithRelease()) self.nav_box = self.register_component(NavigationBox(self, 16, 16, 8, 8, self.set_offset)) self._mod_button = None
def __init__(self, device_bank_registry=None, banking_info=None, delete_handler=None, track_list_component=None, *a, **k): assert banking_info is not None assert device_bank_registry is not None assert track_list_component is not None self._flattened_chain = FlattenedDeviceChain(collect_devices) self._track_decorator = DecoratorFactory() self._modes = NullModes() self.move_device = None super(DeviceNavigationComponent, self).__init__(item_provider=self._flattened_chain, *a, **k) self._delete_handler = delete_handler self.chain_selection = ChainSelectionComponent(parent=self, is_enabled=False) self.bank_selection = BankSelectionComponent( bank_registry=device_bank_registry, banking_info=banking_info, device_options_provider=self._device_component, is_enabled=False, parent=self) self.move_device = MoveDeviceComponent(parent=self, is_enabled=False) self._last_pressed_button_index = -1 self._selected_on_previous_press = None self._modes = ModesComponent(parent=self) self._modes.add_mode(b'default', [ partial(self.chain_selection.set_parent, None), partial(self.bank_selection.set_device, None) ]) self._modes.add_mode(b'chain_selection', [self.chain_selection]) self._modes.add_mode(b'bank_selection', [self.bank_selection]) self._modes.selected_mode = b'default' self.register_disconnectable(self._flattened_chain) self.__on_items_changed.subject = self self.__on_bank_selection_closed.subject = self.bank_selection self._update_selected_track() self._track_list = track_list_component watcher = self.register_disconnectable( DeviceChainStateWatcher(device_navigation=self)) self.__on_device_item_state_changed.subject = watcher self._update_device() self._update_button_colors() return
def _create_pad_modes(self): self._pad_modes = ModesComponent( name=u'Pad_Modes', is_enabled=False, layer=Layer(session_button=u'full_level_button', note_button=u'note_repeat_button', channel_button=u'select_button', encoder_modes_button=u'setup_button')) self._pad_modes.add_mode( u'session', (AddLayerMode(self._background, Layer(unused_pads=u'pads_with_shift')), AddLayerMode( self._session, Layer(clip_launch_buttons=u'pads', scene_launch_buttons=self._elements.pads_with_shift. submatrix[3:, :])), self._session_overview, self._session_navigation_modes)) self._pad_modes.add_mode(u'note', self._note_modes) self._pad_modes.add_mode( u'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( u'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 = u'session' self._pad_modes.set_enabled(True)
class CreateDeviceComponent(Component): @depends(selection=None) def __init__(self, selection=None, browser_component=None, browser_mode=None, browser_hotswap_mode=None, insert_left=False, *a, **k): super(CreateDeviceComponent, self).__init__(*a, **k) self._selection = selection self._add_effect_mode = BrowserAddEffectMode( selection=selection, browser=self.application.browser, application_view=self.application.view, insert_left=insert_left) self._create_device_modes = ModesComponent(parent=self) self._create_device_modes.add_mode(u'create', [ SetAttributeMode(browser_component, u'do_load_item', self._do_browser_load_item), self._add_effect_mode, browser_mode, browser_component.reset_load_memory ]) self._create_device_modes.add_mode( u'hotswap', [browser_hotswap_mode, browser_mode]) self._go_to_hotswap_task = self._tasks.add( task.sequence(task.delay(1), task.run(self._go_to_hotswap))) self._go_to_hotswap_task.kill() def on_enabled_changed(self): self._go_to_hotswap_task.kill() if self.is_enabled(): if is_empty_drum_pad(self._selection.selected_object): self._create_device_modes.selected_mode = u'hotswap' else: self._create_device_modes.selected_mode = u'create' def _go_to_hotswap(self): self._create_device_modes.selected_mode = u'hotswap' def _do_browser_load_item(self, item): selection = self._add_effect_mode.get_selection_for_insert() if selection: self._selection.selected_object = selection item.action() self._go_to_hotswap_task.restart()
def __init__(self, note_settings_component=None, automation_component=None, initial_encoder_layer=None, encoder_layer=None, *a, **k): super(NoteEditorSettingsComponent, self).__init__(*a, **k) raise encoder_layer or AssertionError self._request_hide = False self.settings = self.register_component(note_settings_component) self.settings.set_enabled(False) self._automation = self.register_component(automation_component) self._automation.set_enabled(False) self._mode_selector = self.register_component( OptionsComponent(num_options=2, num_labels=0, num_display_segments=8)) self._mode_selector.set_enabled(False) self._on_selected_option.subject = self._mode_selector self._update_available_modes() self._mode_selector.selected_option = 0 self._visible_detail_view = 'Detail/DeviceChain' self._show_settings_task = self._tasks.add( task.sequence(task.wait(defaults.MOMENTARY_DELAY), task.run(self._show_settings))).kill() self._update_infos_task = self._tasks.add( task.run(self._update_note_infos)).kill() self._settings_modes = self.register_component(ModesComponent()) self._settings_modes.set_enabled(False) self._settings_modes.add_mode('automation', [ self._automation, self._mode_selector, partial(self._set_envelope_view_visible, True), self._show_clip_view ]) self._settings_modes.add_mode('note_settings', [ self.settings, self._update_note_infos, self._mode_selector, partial(self._set_envelope_view_visible, False), self._show_clip_view ]) self._encoders = None self._initial_encoders = None self.add_mode('disabled', []) self.add_mode('about_to_show', [ AddLayerMode(self, initial_encoder_layer), (self._show_settings_task.restart, self._show_settings_task.kill) ]) self.add_mode('enabled', [ DetailViewRestorerMode(self.application), AddLayerMode(self, encoder_layer), self._update_available_modes, self._settings_modes ]) self.selected_mode = 'disabled' self._editors = [] self._on_detail_clip_changed.subject = self.song.view self._on_selected_track_changed.subject = self.song.view self.__on_full_velocity_changed.subject = self.settings self.__on_setting_changed.subject = self.settings return
def _create_main_modes(self): self._main_modes = ModesComponent( name='Main_Modes', is_enabled=False, layer=Layer(session_button='session_mode_button', note_button='note_mode_button', custom_button='custom_mode_button')) self._main_modes.add_mode('session', (self._session_modes), behaviour=(ImmediateBehaviour())) self._main_modes.add_mode('note', (self._note_modes), behaviour=(ImmediateBehaviour())) self._main_modes.add_mode('custom', None, behaviour=(ImmediateBehaviour())) self._main_modes.selected_mode = 'session' self._main_modes.set_enabled(True) self._Launchpad_X__on_main_mode_changed.subject = self._main_modes
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 _create_main_modes(self): self._main_modes = ModesComponent(name=u'Main_Modes', is_enabled=False) suppressed_arrow_button_mode = (AddLayerMode( self._background, Layer(left_button=u'left_button', right_button=u'right_button', up_button=u'up_button', down_button=u'down_button')), ) self._main_modes.add_mode(u'none', suppressed_arrow_button_mode) self._main_modes.add_mode(u'fader', None) self._main_modes.add_mode(u'session', self._session_modes) self._main_modes.add_mode(u'note', (self._note_modes, self._clip_actions)) self._main_modes.add_mode(u'chord', suppressed_arrow_button_mode) self._main_modes.selected_mode = u'session' self._main_modes.set_enabled(True) self.__on_main_mode_changed.subject = self._main_modes
def _create_mixer(self): super(KeyLabMkII, self)._create_mixer() self._mixer.layer += Layer(track_select_buttons=self._select_buttons, solo_buttons=self._solo_buttons, mute_buttons=self._mute_buttons, arm_buttons=self._record_arm_buttons, selected_track_name_display=self._display) self._mixer_modes = ModesComponent(name='Mixer_Modes') self._mixer_modes.add_mode( 'volume_mode', AddLayerMode(self._mixer, Layer(volume_controls=self._faders))) self._mixer_modes.add_mode( 'sends_a_mode', AddLayerMode(self._mixer, Layer(send_controls=self._faders))) self._mixer_modes.layer = Layer( cycle_mode_button=self._mixer_mode_cycle_button) self._mixer_modes.selected_mode = 'volume_mode'
def _init_track_modes(self): self._track_modes = ModesComponent(name='Track_Modes') self._track_modes.set_enabled(False) self._track_modes.add_mode('stop', AddLayerMode(self._stop_clips, self._stop_track_clips_layer)) self._track_modes.add_mode('solo', AddLayerMode(self._mixer, self._mixer_solo_layer)) self._track_modes.add_mode('mute', AddLayerMode(self._mixer, self._mixer_mute_layer)) self._track_modes.layer = self._create_track_modes_layer() self._track_modes.selected_mode = 'mute'
def _create_session_mode(self): session_modes = ModesComponent(is_enabled=False) session_modes.add_mode('session', self._session_mode) session_modes.add_mode('overview', self._session_overview_mode) session_modes.layer = Layer(cycle_mode_button='layout_button') session_modes.selected_mode = 'session' return [session_modes, self._session_navigation]
def _create_mixer_modes(self): self._mixer_modes = ModesComponent(name='Mixer_Modes', is_enabled=False, enable_skinning=True, layer=Layer(arm_button='record_arm_button', mute_button='mute_button', solo_button='solo_button', volume_button='volume_button', pan_button='pan_button', sends_button='sends_button', device_button='device_button', stop_button='stop_clip_button')) self._mixer.layer = Layer(volume_controls='volume_button_faders', pan_controls='pan_button_faders', send_controls='sends_button_faders') reselect_track_select_mode = partial(setattr, self._mixer_modes, 'selected_mode', 'track_select') def restore_main_layout(): if self._layout_to_restore: self._elements.layout_switch.send_value(self._layout_to_restore) def add_track_select_button_mode(name, control=None, component=self._mixer): control_key = control if control else ('{}_buttons').format(name) control_dict = {control_key: 'track_select_buttons'} self._mixer_modes.add_mode(name, ( AddLayerMode(component, Layer(**control_dict)), restore_main_layout), behaviour=ReenterBehaviour(on_reenter=reselect_track_select_mode)) add_track_select_button_mode('track_select') add_track_select_button_mode('arm') add_track_select_button_mode('mute') add_track_select_button_mode('solo') add_track_select_button_mode('stop', control='stop_track_clip_buttons', component=self._session) def switch_to_fader_layout(bank): fader_layout_bytes = ( ids.FADER_LAYOUT_BYTE, bank, 0) self._elements.layout_switch.send_value(fader_layout_bytes) def add_fader_mode(name, bank, add_layer_mode, static_color=None): self._mixer_modes.add_mode(name, ( add_layer_mode, AddLayerMode(self._mixer, Layer(track_select_buttons='track_select_buttons')), partial(self._mixer._update_send_control_colors), partial(self._mixer.set_static_color_value, static_color), partial(switch_to_fader_layout, bank)), behaviour=ReenterBehaviour(on_reenter=reselect_track_select_mode)) add_fader_mode('volume', 0, AddLayerMode(self._mixer, Layer(static_color_controls='volume_button_fader_color_elements')), static_color=Rgb.GREEN.midi_value) add_fader_mode('pan', 1, AddLayerMode(self._mixer, Layer(track_color_controls='pan_button_fader_color_elements'))) add_fader_mode('sends', 2, AddLayerMode(self._mixer, Layer(send_select_buttons='scene_launch_buttons', return_track_color_controls='sends_button_fader_color_elements', stop_fader_control='stop_fader_element'))) add_fader_mode('device', 3, ( AddLayerMode(self._background, Layer(up_button='up_button', down_button='down_button')), AddLayerMode(self._device_navigation, Layer(prev_button='left_button', next_button='right_button')), AddLayerMode(self._device_parameters, Layer(bank_select_buttons='scene_launch_buttons')))) self._mixer_modes.selected_mode = 'track_select' self._mixer_modes.set_enabled(True) return
def _setup_modswitcher(self): self._modswitcher = ModesComponent(name = 'ModSwitcher') self._modswitcher.add_mode('mod', [self.modhandler, self._mod_shift_modes]) self._modswitcher.add_mode('special_device', [self._special_device, self._mixer, self._mixer._select_layer, self._main_shift_modes]) self._modswitcher.selected_mode = 'special_device' self._modswitcher.set_enabled(False) self._mod_shift_modes.add_mode('disabled', [self.modhandler.keys_layer], cycle_mode_button_color = 'Mod.ShiftOff') self._mod_shift_modes.add_mode('enabled', [self.modhandler.code_keys_layer, self.modhandler.code_buttons_layer, tuple([self._send_mod_shift, self._release_mod_shift])], cycle_mode_button_color = 'Mod.ShiftOn') self._mod_shift_modes.selected_mode = 'disabled'
def _create_stop_solo_mute_modes(self): self._stop_solo_mute_modes = ModesComponent(name='Stop_Solo_Mute_Modes', is_enabled=False, support_momentary_mode_cycling=False, layer=Layer(cycle_mode_button=(self._elements.scene_launch_buttons_raw[7]))) bottom_row = self._elements.clip_launch_matrix.submatrix[:, 7:8] self._stop_solo_mute_modes.add_mode('launch', None, cycle_mode_button_color='Mode.Launch.On') self._stop_solo_mute_modes.add_mode('stop', (AddLayerMode(self._session, Layer(stop_track_clip_buttons=bottom_row))), cycle_mode_button_color='Session.StopClip') self._stop_solo_mute_modes.add_mode('solo', (AddLayerMode(self._mixer, Layer(solo_buttons=bottom_row))), cycle_mode_button_color='Mixer.SoloOn') self._stop_solo_mute_modes.add_mode('mute', (AddLayerMode(self._mixer, Layer(mute_buttons=bottom_row))), cycle_mode_button_color='Mixer.MuteOff') self._stop_solo_mute_modes.selected_mode = 'launch' self._stop_solo_mute_modes.set_enabled(True)
def _create_device_mode(self): self._drum_pad_parameter_component = DrumPadParameterComponent(view_model=self._model, is_enabled=False, layer=Layer(choke_encoder='parameter_controls_raw[0]')) self._device_or_pad_parameter_chooser = ModesComponent() self._device_or_pad_parameter_chooser.add_mode('device', [make_freeze_aware(self._device_parameter_component, self._device_parameter_component.layer), self._device_view]) self._device_or_pad_parameter_chooser.add_mode('drum_pad', [make_freeze_aware(self._drum_pad_parameter_component, self._drum_pad_parameter_component.layer)]) self._device_or_pad_parameter_chooser.selected_mode = 'device' return [partial(self._view_control.show_view, 'Detail/DeviceChain'), self._device_or_pad_parameter_chooser, self._setup_freeze_aware_device_navigation(), self._device_note_editor_mode, SetAttributeMode(obj=self._note_editor_settings_component, attribute='parameter_provider', value=self._device_component)]
def _setup_modes(self): self._main_modes = ModesComponent(name = 'MainModes') self._main_modes.add_mode('disabled', []) self._main_modes.add_mode('session_shifted', [self._recorder, self._mixer, self._mixer.solo_mute_record_stop_layer, self._session, self._session.stop_layer, self._session_navigation, self._session_navigation._vertical_layer, self._transport], groups = ['shifted'], behaviour = self._shift_latching(color = 'Mode.Session')) self._main_modes.add_mode('session', [self._recorder, self._mixer, self._session, self._session.cliplaunch_layer, self._session_navigation, self._session_navigation._horizontal_layer, self._transport], behaviour = self._shift_latching(color = 'Mode.Session')) self._main_modes.add_mode('instrument_shifted', [self._recorder, self._mixer, self._mixer.mute_layer, self._viewcontrol, self._instrument, self._transport], groups = ['shifted'], behaviour = self._shift_latching(color = 'Mode.Instrument')) self._main_modes.add_mode('instrument', [self._recorder, self._mixer, self._mixer.select_layer, self._viewcontrol, self._instrument, self._transport], behaviour = self._shift_latching(color = 'Mode.Instrument')) self._main_modes.layer = Layer(priority = 6, session_button = self._side_button[4], instrument_button = self._side_button[3]) self._main_modes.set_enabled(False) self._main_modes.selected_mode = 'disabled'
def _create_session_navigation_modes(self): self._session_navigation_modes = ModesComponent( name=u'Session_Navigation_Modes', is_enabled=False, layer=Layer(cycle_mode_button=u'bank_button')) self._session_navigation_modes.add_mode( u'default', AddLayerMode(self._session_navigation, layer=Layer(up_button=u'up_button', down_button=u'down_button')), cycle_mode_button_color=u'DefaultButton.Off') self._session_navigation_modes.add_mode( u'paged', AddLayerMode(self._session_navigation, layer=Layer(page_up_button=u'up_button', page_down_button=u'down_button', page_left_button=u'left_button', page_right_button=u'right_button')), cycle_mode_button_color=u'DefaultButton.On') self._session_navigation_modes.selected_mode = u'default'
def _setup_modes(self): self._main_modes = ModesComponent(name = 'MainModes') self._main_modes.add_mode('disabled', []) self._main_modes.add_mode('mix_shifted', [self._mixer, self._mixer._mix_layer, self._mixer._solo_mute_layer, self._device_selector, self._background], groups = ['shifted'], behaviour = self._shift_latching(color = 'Mode.Main')) self._main_modes.add_mode('mix', [self._mixer, self._mixer._mix_layer, self._mixer._select_layer, self._mixer._solo_mute_layer, self._session_navigation, self._background, self._main_shift_modes], behaviour = self._shift_latching(color = 'Mode.Main')) self._main_modes.add_mode('sends_shifted', [self._mixer, self._mixer._sends_layer, self._mixer._select_layer, self._device_selector, self._background], groups = ['shifted'], behaviour = self._shift_latching(color = 'Mode.Main')) self._main_modes.add_mode('sends', [self._mixer, self._mixer._sends_layer, self._mixer._select_layer, self._background, self._main_shift_modes], behaviour = self._shift_latching(color = 'Mode.Main')) self._main_modes.add_mode('device_shifted', [self._selected_device_modes, self._device_selector, self._device[0], self._device[1], self._device[2], self._device[3], self._device_selector, self._background], groups = ['shifted'], behaviour = self._shift_latching(color = 'Mode.Main')) self._main_modes.add_mode('device', [self._mixer, self._mixer._select_layer, self._selected_device_modes, self._device[0], self._device[1], self._device[2], self._device[3], self._background, self._mixer._select_layer, self._main_shift_modes], behaviour = self._shift_latching(color = 'Mode.Main')) self._main_modes.add_mode('special_device_shifted', [self._modswitcher, self._device_selector, self._background], groups = ['shifted'], behaviour = self._shift_latching(color = 'Mode.Main')) self._main_modes.add_mode('special_device', [self._modswitcher, self._background], behaviour = self._shift_latching(color = 'Mode.Main')) #self._main_modes.add_mode('select', [self.normal_encoder_sysex], behaviour = DelayedExcludingMomentaryBehaviour(excluded_groups = ['shifted'])) self._main_modes.layer = Layer(priority = 4, mix_button = self._row_button[0], sends_button = self._row_button[1], device_button = self._row_button[2], special_device_button = self._row_button[3], ) self._main_modes.selected_mode = 'disabled' self._main_modes.set_enabled(False)
def _create_clip_mode(self): base_loop_layer = Layer(shift_button='shift_button', loop_button='track_state_buttons_raw[1]') self._loop_controller = LoopSettingsControllerComponent(is_enabled=False) self._model.loopSettingsView = self._loop_controller audio_clip_layer = Layer(warp_mode_encoder='parameter_controls_raw[5]', transpose_encoder='parameter_controls_raw[6]', detune_encoder=self._with_shift('parameter_controls_raw[6]'), gain_encoder='parameter_controls_raw[7]', shift_button='shift_button') audio_clip_controller = AudioClipSettingsControllerComponent(is_enabled=False) self._model.audioClipSettingsView = audio_clip_controller clip_control_mode_selector = ModesComponent(is_enabled=False) clip_control_mode_selector.add_mode('midi', [make_freeze_aware(self._loop_controller, base_loop_layer + Layer(encoders=self.elements.global_param_controls.submatrix[:3, :]))]) clip_control_mode_selector.add_mode('audio', [make_freeze_aware(self._loop_controller, base_loop_layer + Layer(encoders=self.elements.global_param_controls.submatrix[1:4, :], zoom_encoder='fine_grain_param_controls_raw[0]')), make_freeze_aware(audio_clip_controller, audio_clip_layer)]) clip_control_mode_selector.add_mode('no_clip', []) clip_control_mode_selector.selected_mode = 'no_clip' clip_control = ClipControlComponent(loop_controller=self._loop_controller, audio_clip_controller=audio_clip_controller, mode_selector=clip_control_mode_selector, decorator_factory=self._clip_decorator_factory, is_enabled=False) self._model.clipView = clip_control return [partial(self._view_control.show_view, 'Detail/Clip'), clip_control_mode_selector, clip_control]
def _init_matrix_modes(self): self._auto_arm = AutoArmComponent(name='Auto_Arm') self._auto_arm.can_auto_arm_track = self._can_auto_arm_track self._auto_arm.layer = Layer(_notification=self._notification.use_single_line(2)) self._select_playing_clip = SelectPlayingClipComponent(name='Select_Playing_Clip', playing_clip_above_layer=Layer(action_button='nav_up_button'), playing_clip_below_layer=Layer(action_button='nav_down_button')) self._select_playing_clip.layer = Layer(_notification=self._notification.use_single_line(2)) self._percussion_instrument_finder = PercussionInstrumentFinderComponent(device_parent=self.song.view.selected_track) self.__on_percussion_instrument_changed.subject = self._percussion_instrument_finder self._drum_modes = ModesComponent(name='Drum_Modes', is_enabled=False) self._drum_modes.add_mode('sequencer', [self._drum_step_sequencer, self._note_editor_settings_component, AddLayerMode(self._drum_component, Layer(matrix=self.elements.matrix.submatrix[:4, 4:8]))]) self._drum_modes.add_mode('64pads', [AddLayerMode(self._drum_component, Layer(matrix='matrix'))]) self._drum_modes.selected_mode = 'sequencer' self._slicing_modes = self._create_slicing_modes() self._note_modes = ModesComponent(name='Note_Modes') self._note_modes.add_mode('drums', [self._drum_component, self._note_repeat_enabler, self._accent_component, self._drum_modes]) self._note_modes.add_mode('slicing', [self._slicing_component, self._note_repeat_enabler, self._accent_component, self._slicing_modes]) self._note_modes.add_mode('looper', self._audio_loop if consts.PROTO_AUDIO_NOTE_MODE else self._matrix_background) self._note_modes.add_mode('instrument', [self._note_repeat_enabler, self._accent_component, self._instrument, self._scales_enabler]) self._note_modes.add_mode('disabled', self._matrix_background) self._note_modes.selected_mode = 'disabled' self._note_modes.set_enabled(False) self._matrix_modes = ModesComponent(name='Matrix_Modes', is_root=True) self._matrix_modes.add_mode('session', self._create_session_mode()) self._matrix_modes.add_mode('note', self._create_note_mode(), behaviour=self._create_note_mode_behaviour()) self._matrix_modes.selected_mode = 'note' self._matrix_modes.layer = Layer(session_button='session_mode_button', note_button='note_mode_button') self.__on_matrix_mode_changed.subject = self._matrix_modes self._matrix_modes.selected_mode = 'note'
def _init_main_modes(self): def configure_note_editor_settings(parameter_provider, mode): for note_editor_setting in self._note_editor_settings: note_editor_setting.component.parameter_provider = parameter_provider note_editor_setting.component.automation_layer = getattr(note_editor_setting, mode + '_automation_layer') self._track_note_editor_mode = partial(configure_note_editor_settings, self._track_parameter_provider, 'track') self._device_note_editor_mode = partial(configure_note_editor_settings, self._device_component, 'device') self._enable_stop_mute_solo_as_modifiers = AddLayerMode(self._mod_background, Layer(stop='global_track_stop_button', mute='global_mute_button', solo='global_solo_button')) self._main_modes = ModesComponent(is_root=True) self._create_main_mixer_modes() self._main_modes.add_mode('clip', self._create_clip_mode()) self._main_modes.add_mode('device', self._create_device_mode(), behaviour=ReenterBehaviour(self._device_navigation.back_to_top)) self._init_browse_mode() self._main_modes.selected_mode = 'device' self._main_modes.layer = self._create_main_modes_layer()
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 _hack_stuff(self): self._crossfader_strip = TouchStripControllerComponent() self._crossfader_strip.layer = Layer(touch_strip = self.elements.touch_strip_control) self._crossfader_strip.set_enabled(False) self._device_selector = DeviceSelectorComponent(self) self._device_selector._off_value = 64 self._device_selector.layer = Layer(priority = 9, matrix = self.elements.matrix.submatrix[:, :4]) self._device_selector.set_enabled(False) self._send_reset = AumPushResetSendsComponent(self) self._send_reset.layer = Layer(priority = 9, send_a_button = self._with_select(self.elements.track_state_buttons_raw[4]), send_b_button = self._with_select(self.elements.track_state_buttons_raw[5]), send_c_button = self._with_select(self.elements.track_state_buttons_raw[6]), send_d_button = self._with_select(self.elements.track_state_buttons_raw[7])) self._send_reset.set_enabled(False) static_modes = CompoundMode(tuple([self._grab_crossfader, self._release_crossfader]), self._crossfader_strip, self._device_selector, self._send_reset) self._troll_modes = ModesComponent() self._troll_modes.add_mode('disabled', [], cycle_mode_button_color = 'DefaultButton.Off') self._troll_modes.add_mode('enabled', [static_modes, tuple([self._grab_track_mode, self._release_track_mode, ])], cycle_mode_button_color = 'DefaultButton.Alert') self._troll_modes.layer = Layer(priority = 6, cycle_mode_button = 'master_select_button') self._troll_modes.selected_mode = 'disabled'
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)
class Push(PushBase): """ Push controller script. Disclaimer: Any use of the Push control surface code (the "Code") or parts thereof for commercial purposes or in a commercial context is not allowed. Though we do not grant a license for non-commercial use of the Code, you may use it in this regard but should be aware that (1) we reserve the right to deny the future use any time and (2) you need to check whether the use is allowed under the national law applicable to your use. """ input_target_name_for_auto_arm = 'Push Input' def __init__(self, *a, **k): super(Push, self).__init__(*a, **k) with self.component_guard(): self.initialize() logger.info('Push script loaded') self._send_midi(sysex.WELCOME_MESSAGE) def disconnect(self): super(Push, self).disconnect() logger.info('Push script unloaded') self._send_midi(sysex.GOOD_BYE_MESSAGE) def port_settings_changed(self): super(Push, self).port_settings_changed() self._start_handshake_task.restart() def on_select_clip_slot(self, clip_slot): self._selector.on_select_clip(clip_slot) def on_select_scene(self, scene): self._selector.on_select_scene(scene) def on_select_track(self, track): self._selector.on_select_track(track) def _create_components(self): self._init_handshake() self._init_selector() super(Push, self)._create_components() self._init_browser() self._init_track_modes() def _create_settings(self): settings = create_settings(preferences=self.preferences) self.__on_pad_curve.subject = settings['curve'] self.__on_pad_threshold.subject = settings['threshold'] self.__on_aftertouch_threshold.subject = settings['aftertouch_threshold'] return settings def _init_settings(self): super(Push, self)._init_settings() self._init_global_pad_parameters() self._update_pad_params() def _init_selector(self): self._selector = SelectComponent(name='Selector', is_root=True) self._selector.layer = Layer(select_button='select_button') self._selector.selection_display_layer = Layer(display_line='display_line3', priority=consts.DIALOG_PRIORITY) def _init_handshake(self): dongle_message, dongle = make_dongle_message(sysex.DONGLE_ENQUIRY_PREFIX) identity_control = create_sysex_element(sysex.IDENTITY_PREFIX, sysex.IDENTITY_ENQUIRY) dongle_control = create_sysex_element(sysex.DONGLE_PREFIX, dongle_message) presentation_control = create_sysex_element(sysex.DONGLE_PREFIX, sysex.make_presentation_message(self.application())) self._handshake = HandshakeComponent(identity_control=identity_control, dongle_control=dongle_control, presentation_control=presentation_control, dongle=dongle, is_root=True) self._on_handshake_success.subject = self._handshake self._on_handshake_failure.subject = self._handshake self._start_handshake_task = self._tasks.add(task.sequence(task.wait(HANDSHAKE_DELAY), task.run(self._start_handshake))) self._start_handshake_task.kill() def _init_user(self): super(Push, self)._init_user() self._on_push_hardware_mode_changed.subject = self._user self._update_pad_params() def _with_firmware_version(self, major_version, minor_version, control_element): return MinimumFirmwareVersionElement(major_version, minor_version, control_element, self._handshake) def _start_handshake(self): self._start_handshake_task.kill() self.elements.playhead_element.proxied_object = self._c_instance.playhead self._note_repeat.set_note_repeat(self._c_instance.note_repeat) self._accent_component.set_full_velocity(self._c_instance.full_velocity) for control in self.controls: receive_value_backup = getattr(control, '_receive_value_backup', nop) if receive_value_backup != nop: control.receive_value = receive_value_backup send_midi_backup = getattr(control, '_send_midi_backup', nop) if send_midi_backup != nop: control.send_midi = send_midi_backup self._handshake._start_handshake() self.update() @listens('success') def _on_handshake_success(self): logger.info('Handshake succeded with firmware version %.2f!' % self._handshake.firmware_version) self.update() self._c_instance.set_firmware_version(self._handshake.firmware_version) if self._handshake.has_version_requirements(1, 16): self._user.settings = self._settings else: settings = copy(self._settings) del settings['aftertouch_threshold'] self._user.settings = settings @listens('failure') def _on_handshake_failure(self, bootloader_mode): logger.error('Handshake failed, performing harakiri!') if bootloader_mode: self._c_instance.set_firmware_version(0.0) self._c_instance.playhead.enabled = False self.elements.playhead_element.proxied_object = NullPlayhead() self._note_repeat.set_note_repeat(None) self._accent_component.set_full_velocity(None) for control in self.controls: receive_value_backup = getattr(control, 'receive_value', nop) send_midi_backup = getattr(control, 'send_midi', nop) try: control.receive_value = nop if receive_value_backup != nop: control._receive_value_backup = receive_value_backup control.send_midi = nop if send_midi_backup != nop: control._send_midi_backup = send_midi_backup except AttributeError: pass @listens('mode') def _on_push_hardware_mode_changed(self, mode): if mode == LIVE_MODE: if self._start_handshake_task.is_running: self._start_handshake() elif self._handshake.handshake_succeeded: self.update() def _create_background_layer(self): return super(Push, self)._create_background_layer() + Layer(display_line1='display_line1', display_line2='display_line2', display_line3='display_line3', display_line4='display_line4', in_button='in_button', out_button='out_button', pad_parameters=self._pad_parameter_control) def _create_message_box_background_layer(self): return super(Push, self)._create_message_box_background_layer() + BackgroundLayer('in_button', 'out_button', priority=consts.MESSAGE_BOX_PRIORITY) def _create_track_frozen_layer(self): return Layer(display='display_line2', _notification=self._notification.use_full_display(1)) def _create_notification_component(self): return NotificationComponent(display_lines='display_lines', is_root=True, is_enabled=True) def _create_message_box_layer(self): return Layer(display_line1='display_line1', display_line2='display_line2', display_line3='display_line3', display_line4='display_line4', cancel_button='select_buttons_raw[-1]', priority=consts.MESSAGE_BOX_PRIORITY) def _create_clip_mode(self): return [self._track_modes, (self._mixer, self._mixer_layer)] + super(Push, self)._create_clip_mode() def _create_clip_loop_layer(self): return super(Push, self)._create_clip_loop_layer() + Layer(name_display=self.elements.display_line1.subdisplay[:36], value_display=self.elements.display_line2.subdisplay[:36]) def _create_clip_audio_layer(self): return super(Push, self)._create_clip_audio_layer() + Layer(name_display=self.elements.display_line1.subdisplay[36:], value_display=self.elements.display_line2.subdisplay[36:]) def _create_clip_name_layer(self): return super(Push, self)._create_clip_name_layer() + Layer(display='display_line3') def _create_session_recording(self): return FixedLengthSessionRecordingComponent(fixed_length_setting=self._fixed_length_setting, clip_creator=self._clip_creator, view_controller=self._view_control, name='Session_Recording', is_root=True) def _init_track_modes(self): self._track_modes = ModesComponent(name='Track_Modes') self._track_modes.set_enabled(False) self._track_modes.add_mode('stop', AddLayerMode(self._stop_clips, self._stop_track_clips_layer)) self._track_modes.add_mode('solo', AddLayerMode(self._mixer, self._mixer_solo_layer)) self._track_modes.add_mode('mute', AddLayerMode(self._mixer, self._mixer_mute_layer)) self._track_modes.layer = self._create_track_modes_layer() self._track_modes.selected_mode = 'mute' def _browser_back_to_top(self): self._browser_mode.component.back_to_top() def _browser_reset_load_memory(self): self._browser_mode.component.reset_load_memory() def _init_browser(self): class BrowserMode(MultiEntryMode): def __init__(self, create_browser = nop, *a, **k): super(BrowserMode, self).__init__(LazyComponentMode(create_browser), *a, **k) def enter_mode(browser_mode_self): super(BrowserMode, browser_mode_self).enter_mode() self._scales_enabler.selected_mode = 'disabled' @property def component(self): return self._mode.component self._browser_mode = BrowserMode(self._create_browser) self._browser_hotswap_mode = MultiEntryMode(BrowserHotswapMode(application=self.application())) self._on_browse_mode_changed.subject = self.application().view def _init_browse_mode(self): self._main_modes.add_mode('browse', [self._when_track_is_not_frozen(self._enable_stop_mute_solo_as_modifiers, partial(self._view_control.show_view, 'Browser'), self._browser_back_to_top, self._browser_hotswap_mode, self._browser_mode, self._browser_reset_load_memory)], groups=['add_effect', 'add_track', 'browse'], behaviour=mixin(DynamicBehaviourMixin, CancellableBehaviour)(lambda : not self._browser_hotswap_mode._mode.can_hotswap() and 'add_effect_left')) self._main_modes.add_mode('add_effect_right', [self._when_track_is_not_frozen(self._enable_stop_mute_solo_as_modifiers, self._browser_back_to_top, LazyComponentMode(self._create_create_device_right))], behaviour=mixin(ExcludingBehaviourMixin, CancellableBehaviour)(['add_track', 'browse']), groups=['add_effect']) self._main_modes.add_mode('add_effect_left', [self._when_track_is_not_frozen(self._enable_stop_mute_solo_as_modifiers, self._browser_back_to_top, LazyComponentMode(self._create_create_device_left))], behaviour=mixin(ExcludingBehaviourMixin, CancellableBehaviour)(['add_track', 'browse']), groups=['add_effect']) self._main_modes.add_mode('add_instrument_track', [self._enable_stop_mute_solo_as_modifiers, self._browser_back_to_top, LazyComponentMode(self._create_create_instrument_track)], behaviour=mixin(ExcludingBehaviourMixin, AlternativeBehaviour)(excluded_groups=['browse', 'add_effect'], alternative_mode='add_default_track'), groups=['add_track']) self._main_modes.add_mode('add_default_track', [self._enable_stop_mute_solo_as_modifiers, self._browser_back_to_top, LazyComponentMode(self._create_create_default_track)], groups=['add_track']) self._main_modes.add_effect_right_button.mode_unselected_color = self._main_modes.add_effect_left_button.mode_unselected_color = self._main_modes.add_instrument_track_button.mode_unselected_color = 'DefaultButton.On' @listens('browse_mode') def _on_browse_mode_changed(self): if not self.application().browser.hotswap_target: if self._main_modes.selected_mode == 'browse' or self._browser_hotswap_mode.is_entered: self._main_modes.selected_mode = 'device' def _create_browser(self): state_buttons = self.elements.track_state_buttons.submatrix[:7, :] browser = BrowserComponent(name='Browser', is_enabled=False, layer=Layer(encoder_controls='global_param_controls', display_line1='display_line1', display_line2='display_line2', display_line3='display_line3', display_line4='display_line4', enter_button='in_button', exit_button='out_button', select_buttons='select_buttons', state_buttons=state_buttons, shift_button=WithPriority(consts.SHARED_PRIORITY, 'shift_button'), prehear_button='track_state_buttons_raw[7]', _notification=self._notification.use_full_display(2)), make_browser_model=make_browser_model, preferences=self.preferences) return browser def _create_create_device_right(self): return CreateDeviceComponent(name='Create_Device_Right', browser_component=self._browser_mode.component, browser_mode=self._browser_mode, browser_hotswap_mode=self._browser_hotswap_mode, insert_left=False, is_enabled=False) def _create_create_device_left(self): return CreateDeviceComponent(name='Create_Device_Right', browser_component=self._browser_mode.component, browser_mode=self._browser_mode, browser_hotswap_mode=self._browser_hotswap_mode, insert_left=True, is_enabled=False) def _create_create_default_track(self): create_default_track = CreateDefaultTrackComponent(name='Create_Default_Track', is_enabled=False) create_default_track.options.layer = Layer(display_line='display_line4', label_display_line='display_line3', blank_display_line2='display_line2', blank_display_line1='display_line1', select_buttons='select_buttons', state_buttons='track_state_buttons', priority=consts.DIALOG_PRIORITY) return create_default_track def _create_create_instrument_track(self): return CreateInstrumentTrackComponent(name='Create_Instrument_Track', browser_component=self._browser_mode.component, browser_mode=self._browser_mode, browser_hotswap_mode=self._browser_hotswap_mode, is_enabled=False) def _create_device_mode(self): return [self._when_track_is_not_frozen(self._enable_stop_mute_solo_as_modifiers, partial(self._view_control.show_view, 'Detail/DeviceChain'), self._device_parameter_component, self._device_navigation, self._device_note_editor_mode)] def _create_scales(self): scales = InstrumentScalesComponent(note_layout=self._note_layout, is_enabled=False, name='Scales', layer=(BackgroundLayer('display_line1', 'display_line2', priority=consts.DIALOG_PRIORITY), Layer(scale_line1=self.elements.display_line1.subdisplay[:18], scale_line2=self.elements.display_line2.subdisplay[:18], scale_line3=self.elements.display_line3.subdisplay[:9], scale_line4=self.elements.display_line4.subdisplay[:9], top_display_line=self.elements.display_line3.subdisplay[9:], bottom_display_line=self.elements.display_line4.subdisplay[9:], top_buttons='select_buttons', bottom_buttons='track_state_buttons', encoder_controls='global_param_controls', _notification=self._notification.use_single_line(0, get_slice[18:], align_right), priority=consts.DIALOG_PRIORITY), Layer(presets_toggle_button='shift_button'))) scales.presets_layer = (BackgroundLayer('track_state_buttons', 'global_param_controls', 'display_line1', 'display_line2', priority=consts.DIALOG_PRIORITY), Layer(top_display_line='display_line3', bottom_display_line='display_line4', top_buttons='select_buttons', _notification=self._notification.use_single_line(0), priority=consts.DIALOG_PRIORITY)) return scales def _create_scales_enabler(self): return EnablingModesComponent(component=self._create_scales(), enabled_color='DefaultButton.On', is_enabled=False, layer=Layer(cycle_mode_button='scale_presets_button')) def _create_drum_component(self): return DrumGroupComponent(name='Drum_Group', is_enabled=False, notification_formatter=self._drum_pad_notification_formatter(), quantizer=self._quantize, selector=self._selector) def _init_note_settings_component(self): self._note_settings_component = NoteSettingsComponent(grid_resolution=self._grid_resolution, is_enabled=False, layer=Layer(top_display_line='display_line1', bottom_display_line='display_line2', info_display_line='display_line3', clear_display_line='display_line4', full_velocity_button='accent_button', priority=consts.MOMENTARY_DIALOG_PRIORITY)) def _create_note_editor_mode_selector_layer(self): return super(Push, self)._create_note_editor_mode_selector_layer() + Layer(display_line='display_line4', priority=consts.MOMENTARY_DIALOG_PRIORITY) def _create_note_editor_track_automation_layer(self): return super(Push, self)._create_note_editor_track_automation_layer() + Layer(name_display_line='display_line1', graphic_display_line='display_line2', value_display_line='display_line3', priority=consts.MOMENTARY_DIALOG_PRIORITY) def _create_note_editor_device_automation_layer(self): return super(Push, self)._create_note_editor_device_automation_layer() + Layer(name_display_line='display_line1', value_display_line='display_line2', graphic_display_line='display_line3', priority=consts.MOMENTARY_DIALOG_PRIORITY) def _init_stop_clips_action(self): self._stop_clips = StopClipComponent(session_ring=self._session_ring, name='Stop_Clip', is_root=True) self._stop_clips.layer = Layer(stop_all_clips_button=self._with_shift('global_track_stop_button')) self._stop_track_clips_layer = Layer(stop_track_clips_buttons='track_state_buttons') def _init_quantize_actions(self): self._quantize_settings = QuantizationSettingsComponent(is_enabled=False, layer=(BackgroundLayer('global_param_controls', 'select_buttons', 'track_state_buttons', priority=consts.MOMENTARY_DIALOG_PRIORITY), Layer(swing_amount_encoder='parameter_controls_raw[0]', quantize_to_encoder='parameter_controls_raw[1]', quantize_amount_encoder='parameter_controls_raw[2]', record_quantization_encoder='parameter_controls_raw[7]', record_quantization_toggle_button='track_state_buttons_raw[7]', display_line1='display_line1', display_line2='display_line2', display_line3='display_line3', display_line4='display_line4', priority=consts.MOMENTARY_DIALOG_PRIORITY))) self._quantize = self._for_non_frozen_tracks(QuantizationComponent(name='Selected_Clip_Quantize', settings=self._quantize_settings, is_enabled=False, layer=Layer(action_button='quantize_button')), is_root=True) def _init_fixed_length(self): super(Push, self)._init_fixed_length() self._fixed_length_settings_component.layer = (BackgroundLayer('track_state_buttons', 'display_line1', 'display_line2', priority=consts.MOMENTARY_DIALOG_PRIORITY), Layer(length_option_buttons='select_buttons', label_display_line='display_line3', option_display_line='display_line4', _notification=self._notification.use_single_line(1), priority=consts.MOMENTARY_DIALOG_PRIORITY)) def _create_note_repeat_layer(self): return super(Push, self)._create_note_repeat_layer() + Layer(pad_parameters=self._pad_parameter_control, priority=consts.DIALOG_PRIORITY) def _create_user_component(self): sysex_control = create_sysex_element(sysex.MODE_CHANGE) user = UserComponent(value_control=sysex_control, is_root=True) user.layer = Layer(action_button='user_button') user.settings_layer = Layer(display_line1='display_line1', display_line2='display_line2', display_line3='display_line3', display_line4='display_line4', encoders='global_param_controls') user.settings_layer.priority = consts.DIALOG_PRIORITY return user def _init_value_components(self): super(Push, self)._init_value_components() self._swing_amount.display.layer = (BackgroundLayer('display_line4', priority=consts.DIALOG_PRIORITY), Layer(label_display='display_line1', value_display='display_line3', graphic_display='display_line2', priority=consts.DIALOG_PRIORITY)) self._tempo.display.layer = (BackgroundLayer('display_line3', 'display_line4', priority=consts.DIALOG_PRIORITY), Layer(label_display='display_line1', value_display='display_line2', priority=consts.DIALOG_PRIORITY)) self._master_vol.display.layer = (BackgroundLayer('display_line4', priority=consts.DIALOG_PRIORITY), Layer(label_display='display_line1', value_display='display_line3', graphic_display='display_line2', priority=consts.DIALOG_PRIORITY)) self._master_cue_vol.display.layer = (BackgroundLayer('display_line4', priority=consts.DIALOG_PRIORITY), Layer(label_display='display_line1', value_display='display_line3', graphic_display='display_line2', priority=consts.DIALOG_PRIORITY)) def _create_note_mode(self): return super(Push, self)._create_note_mode() + [self._global_pad_parameters] def _create_note_mode_behaviour(self): return self._auto_arm.auto_arm_restore_behaviour(ReenterBehaviour, on_reenter=self._switch_note_mode_layout) def _create_session_mode(self): return [self._session_overview_mode, self._session_mode, self._session_navigation] def _create_session_overview_layer(self): return Layer(button_matrix='shifted_matrix') def _set_session_skin(self, session): session.set_rgb_mode(CLIP_COLOR_TABLE, RGB_COLOR_TABLE, clip_slots_only=True) def _on_selected_track_changed(self): super(Push, self)._on_selected_track_changed() self._main_modes.pop_groups(['add_effect']) def _init_main_modes(self): super(Push, self)._init_main_modes() self.__on_main_mode_button_value.replace_subjects([self.elements.vol_mix_mode_button, self.elements.pan_send_mix_mode_button, self.elements.single_track_mix_mode_button, self.elements.clip_mode_button, self.elements.device_mode_button, self.elements.browse_mode_button]) def _create_mixer_layer(self): return super(Push, self)._create_mixer_layer() + Layer(track_names_display='display_line4') def _create_mixer_pan_send_layer(self): return super(Push, self)._create_mixer_pan_send_layer() + Layer(track_names_display='display_line4', pan_send_names_display='display_line1', pan_send_graphics_display='display_line2', selected_track_name_display='display_line3', pan_send_values_display=ComboElement('display_line3', 'any_touch_button')) def _create_mixer_volume_layer(self): return super(Push, self)._create_mixer_volume_layer() + Layer(track_names_display='display_line4', volume_names_display='display_line1', volume_graphics_display='display_line2', selected_track_name_display='display_line3', volume_values_display=ComboElement('display_line3', 'any_touch_button')) def _create_mixer_track_layer(self): return super(Push, self)._create_mixer_track_layer() + Layer(selected_track_name_display='display_line3', track_names_display='display_line4') def _create_track_mixer_layer(self): return super(Push, self)._create_track_mixer_layer() + Layer(name_display_line='display_line1', graphic_display_line='display_line2', value_display_line=ComboElement('display_line3', 'any_touch_button')) def _create_device_parameter_layer(self): return super(Push, self)._create_device_parameter_layer() + Layer(name_display_line='display_line1', value_display_line='display_line2', graphic_display_line=ComboElement('display_line3', 'any_touch_button')) def _create_device_navigation(self): return DeviceNavigationComponent(device_bank_registry=self._device_bank_registry, is_enabled=False, session_ring=self._session_ring, layer=Layer(enter_button='in_button', exit_button='out_button', select_buttons='select_buttons', state_buttons='track_state_buttons', display_line='display_line4', _notification=self._notification.use_single_line(2)), info_layer=Layer(display_line1='display_line1', display_line2='display_line2', display_line3='display_line3', display_line4='display_line4', _notification=self._notification.use_full_display(2)), delete_handler=self._delete_component) @listens_group('value') def __on_main_mode_button_value(self, value, sender): if not value: self._scales_enabler.selected_mode = 'disabled' def _create_controls(self): self._create_pad_sensitivity_update() class Deleter(object): @property def is_deleting(_): return self._delete_default_component.is_deleting def delete_clip_envelope(_, param): return self._delete_default_component.delete_clip_envelope(param) self.elements = Elements(deleter=Deleter(), undo_handler=self.song, pad_sensitivity_update=self._pad_sensitivity_update, playhead=self._c_instance.playhead) def _create_pad_sensitivity_update(self): all_pad_sysex_control = create_sysex_element(sysex.ALL_PADS_SENSITIVITY_PREFIX) pad_sysex_control = create_sysex_element(sysex.PAD_SENSITIVITY_PREFIX) sensitivity_sender = pad_parameter_sender(all_pad_sysex_control, pad_sysex_control) self._pad_sensitivity_update = PadUpdateComponent(all_pads=range(64), parameter_sender=sensitivity_sender, default_profile=action_pad_sensitivity, update_delay=TIMER_DELAY, is_root=True) def _init_global_pad_parameters(self): self._pad_parameter_control = self._with_firmware_version(1, 16, create_sysex_element(sysex.PAD_PARAMETER_PREFIX, default_value=sysex.make_pad_parameter_message())) aftertouch_threshold = self._settings['aftertouch_threshold'].value self._global_pad_parameters = GlobalPadParameters(aftertouch_threshold=aftertouch_threshold, is_enabled=False, layer=Layer(pad_parameter=self._pad_parameter_control)) @listens('value') def __on_pad_curve(self, _value): self._update_pad_params() @listens('value') def __on_pad_threshold(self, value): self._user.set_settings_info_text('' if value >= CRITICAL_THRESHOLD_LIMIT else consts.MessageBoxText.STUCK_PAD_WARNING) self._update_pad_params() @listens('value') def __on_aftertouch_threshold(self, value): self._global_pad_parameters.aftertouch_threshold = value def _update_pad_params(self): new_pad_parameters = make_pad_parameters(self._settings['curve'].value, self._settings['threshold'].value) self._pad_sensitivity_update.set_profile('instrument', new_pad_parameters) self._pad_sensitivity_update.set_profile('drums', new_pad_parameters) def _update_calibration(self): self._send_midi(sysex.CALIBRATION_SET) def update(self): self._update_calibration() super(Push, self).update()
class OhmModHandler(ModHandler): def __init__(self, *a, **k): super(OhmModHandler, self).__init__(*a, **k) self._shift_mode = ModesComponent() self._color_type = 'RGB' self._shift_mode.add_mode('shift', tuple([self._enable_shift, self._disable_shift]), behaviour = CancellableBehaviourWithRelease()) self.nav_box = self.register_component(NavigationBox(self, 16, 16, 8, 8, self.set_offset)) self._mod_button = None def _enable_shift(self): self._shift_value(1) def _disable_shift(self): self._shift_value(0) def set_shift_button(self, button): self._shift_mode.shift_button.set_control_element(button) def set_nav_matrix(self, matrix): self.nav_box.set_matrix(matrix) def _receive_grid(self, x, y, value, *a, **k): #self._receive_grid(x, y, value, *a, **k) legacy = self.active_mod().legacy if self._active_mod: if not self._grid_value.subject is None: if legacy: x = x - self.x_offset y = y - self.y_offset if x in range(8) and y in range(8): try: self._grid_value.subject.send_value(x, y, self._colors[value], True) except: pass def set_device_selector_matrix(self, matrix): self._device_selector.set_matrix(matrix) @listens('value') def _grid_value(self, value, x, y, *a, **k): #self.log_message('_base_grid_value ' + str(x) + str(y) + str(value)) if self.active_mod(): if self.active_mod().legacy: x += self.x_offset y += self.y_offset self._active_mod.send('grid', x, y, value) @listens('value') def _shift_value(self, value, *a, **k): self._is_shifted = not value is 0 mod = self.active_mod() if mod: mod.send('shift', value) if self._is_shifted: self.shift_mode.enter_mode() if mod and mod.legacy: self.legacy_shift_mode.enter_mode() else: self.legacy_shift_mode.leave_mode() self.shift_mode.leave_mode() self.update() def set_mod_button(self, button): self._mod_button = button def update(self, *a, **k): mod = self.active_mod() if self.is_enabled(): if not mod is None: mod.restore() else: if not self._grid_value.subject is None: self._grid_value.subject.reset() if not self._keys_value.subject is None: self._keys_value.subject.reset() self._alt_value.subject and self._alt_value.subject.send_value(2 + int(self.is_alted())*7, True) if self._on_lock_value.subject: self._on_lock_value.subject.send_value(1 + (int(self.is_locked())*4), True) else: self._mod_button and self._mod_button.send_value(7 + (not self.active_mod() is None)*7, True) else: self._mod_button and self._mod_button.send_value((not self.active_mod() is None)*3, True)
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)
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 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
def _init_dialog_modes(self): self._dialog_modes = ModesComponent(is_root=True) self._dialog_modes.add_mode('convert', LazyComponentMode(self._create_convert)) self.__dialog_mode_button_value.replace_subjects([self.elements.scale_presets_button, self.elements.convert_button])
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 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 Codec(LividControlSurface): _sysex_id = 4 _model_name = 'Code' _host_name = 'Codec' _version_check = 'b996' monomodular = None def __init__(self, c_instance, *a, **k): self.log_message = logger.warning super(Codec, self).__init__(c_instance, *a, **k) self._locked = False self._shift_button = None self._device_selection_follows_track_selection=FOLLOW self._leds_last = 0 self._shift_latching = LatchingShiftedBehaviour if SHIFT_LATCHING else ShiftedBehaviour self._skin = Skin(CodecColors) with self.component_guard(): self._define_sysex() self._setup_controls() self._setup_background() self._setup_mixer_controls() self._setup_device_navigator() self._setup_device_controls() self._setup_special_device_control() self._setup_device_chooser() self._setup_device_selector() self._setup_send_reset() self._setup_default_buttons() self._setup_shift_modes() self._setup_mod() self._setup_modswitcher() self._setup_modes() self._setup_m4l_interface() self._background.set_enabled(True) def _initialize_hardware(self): super(Codec, self)._initialize_hardware() def _initialize_script(self): super(Codec, self)._initialize_script() self._on_device_changed.subject = self._device_provider self._main_modes.set_enabled(True) self._main_modes.selected_mode = 'mix' def _define_sysex(self): self.fast_encoder_sysex = SendLividSysexMode(livid_settings = self._livid_settings, call = 'set_encoder_speed', message = FAST_ENCODER_MSG) self.normal_encoder_sysex = SendLividSysexMode(livid_settings = self._livid_settings, call = 'set_encoder_speed', message = NORMAL_ENCODER_MSG) self.slow_encoder_sysex = SendLividSysexMode(livid_settings = self._livid_settings, call = 'set_encoder_speed', message = SLOW_ENCODER_MSG) def _setup_controls(self): is_momentary = True optimized = False resource = PrioritizedResource self._livid = DoublePressElement(MonoButtonElement(is_momentary = is_momentary, msg_type = MIDI_NOTE_TYPE, channel = CHANNEL, identifier = LIVID, name = 'Livid_Button', script = self, skin = self._skin, color_map = COLOR_MAP, optimized_send_midi = optimized, resource_type = resource, monobridge = self._monobridge)) self._dial = [[CodecEncoderElement(msg_type = MIDI_CC_TYPE, channel = CHANNEL, identifier = CODE_DIALS[row][column], name = 'Dial_' + str(column) + '_' + str(row), num = (column + (row*8)), script = self, optimized_send_midi = optimized, resource_type = resource, monobridge = self._monobridge) for row in range(4)] for column in range(8)] self._button = [[MonoButtonElement(is_momentary = is_momentary, msg_type = MIDI_NOTE_TYPE, channel = CHANNEL, identifier = CODE_BUTTONS[row][column], name = 'Button_' + str(column) + '_' + str(row), script = self, skin = self._skin, color_map = COLOR_MAP, optimized_send_midi = optimized, resource_type = resource, monobridge = self._monobridge) for row in range(4)] for column in range(8)] self._column_button = [MonoButtonElement(is_momentary = is_momentary, msg_type = MIDI_NOTE_TYPE, channel = CHANNEL, identifier = CODE_COLUMN_BUTTONS[index], name = 'Column_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(8)] self._row_button = [MonoButtonElement(is_momentary = is_momentary, msg_type = MIDI_NOTE_TYPE, channel = CHANNEL, identifier = CODE_ROW_BUTTONS[index], name = 'Row_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(4)] self._code_keys = ButtonMatrixElement(name = 'Code_Keys', rows = [self._column_button]) self._code_buttons = ButtonMatrixElement(name = 'Code_Buttons', rows = [self._row_button]) self._encoder_matrix = ButtonMatrixElement(name = 'Encoder_Matrix', rows = [[self._dial[column][row] for column in range(8)] for row in range(4)]) self._button_matrix = ButtonMatrixElement(name = 'Button_Matrix', rows = [[self._button[column][row] for column in range(8)] for row in range(4)]) def _setup_background(self): self._background = BackgroundComponent() self._background.layer = Layer(priority = 3, matrix = self._button_matrix, encoders = self._encoder_matrix, livid = self._livid, buttons = self._code_buttons, keys = self._code_keys) self._background.set_enabled(False) def _setup_transport_control(self): self._transport = TransportComponent() self._transport.name = 'Transport' self._transport.set_enabled(False) def _setup_mixer_controls(self): self._session_ring = SessionRingComponent(name = 'Session_Ring', num_tracks = 8, num_scenes = 0) self._session_navigation = SessionNavigationComponent(name = 'Session_Navigation', session_ring = self._session_ring) self._session_navigation.layer = Layer(priority = 4, left_button = self._button[6][0], right_button = self._button[7][0]) self._session_navigation.set_enabled(False) #self._session = SessionComponent(name = 'Session', session_ring = self._session_ring) self._mixer = CodecMixerComponent(num_returns = 4, name = 'Mixer', tracks_provider = self._session_ring, invert_mute_feedback = True, auto_name = True) self._mixer._mix_layer = AddLayerMode(self._mixer, Layer(priority = 4, volume_controls = self._encoder_matrix.submatrix[:8,3], pan_controls = self._encoder_matrix.submatrix[:8,2], send_controls = self._encoder_matrix.submatrix[:8, :2], )) self._mixer._solo_mute_layer = AddLayerMode(self._mixer, Layer(priority = 4, solo_buttons = self._button_matrix.submatrix[:8,2], mute_buttons = self._button_matrix.submatrix[:8,3], )) self._mixer._select_layer = AddLayerMode(self._mixer, Layer(priority = 4, track_select_buttons = self._code_keys)) self._mixer._sends_layer = AddLayerMode(self._mixer, Layer(priority = 4, send_controls = self._encoder_matrix.submatrix[:, :])) self._mixer.set_enabled(False) def _setup_device_navigator(self): self._device_navigator = DeviceNavigator(self._device_provider, self._mixer, self) self._device_navigator._dev1_layer = AddLayerMode(self._device_navigator, Layer(priority = 4, prev_button = self._button[4][0], next_button = self._button[5][0], prev_chain_button = self._button[6][0], next_chain_button = self._button[7][0])) self._device_navigator._dev2_layer = AddLayerMode(self._device_navigator, Layer(priority = 4, prev_button = self._button[4][1], next_button = self._button[5][1], prev_chain_button = self._button[6][1], next_chain_button = self._button[7][1])) self._device_navigator._dev3_layer = AddLayerMode(self._device_navigator, Layer(priority = 4, prev_button = self._button[4][2], next_button = self._button[5][2], prev_chain_button = self._button[6][2], next_chain_button = self._button[7][2])) self._device_navigator._dev4_layer = AddLayerMode(self._device_navigator, Layer(priority = 4, prev_button = self._button[4][3], next_button = self._button[5][3], prev_chain_button = self._button[6][3], next_chain_button = self._button[7][3])) self._device_navigator.set_enabled(False) def _setup_device_controls(self): self._device = [None for index in range(4)] for index in range(4): self._device[index] = CodecDeviceComponent(self, index+1, device_bank_registry = DeviceBankRegistry()) self._device[index].name = 'CodecDevice_Component_' + str(index+1) self._device[index].layer = Layer(priority = 4, parameter_controls = self._encoder_matrix.submatrix[:, index], on_off_button = self._button[1][index], bank_prev_button = self._button[2][index], bank_next_button = self._button[3][index], ) self._device[index]._nav_layer = AddLayerMode(self._device[index], Layer(priority = 4, nav_prev_button = self._button[6][index], nav_next_button = self._button[7][index],)) self._device[index].set_enabled(False) def _setup_special_device_control(self): self._special_device = SpecialCodecDeviceComponent(self, device_bank_registry = DeviceBankRegistry(), device_provider = self._device_provider) self._special_device.name = 'SpecialCodecDeviceComponent' self._is_active_device = True self._special_device.layer = Layer(priority = 4, parameter_controls = self._encoder_matrix.submatrix[:,:], on_off_button = self._button[1][0], bank_prev_button = self._button[4][0], bank_next_button = self._button[5][0], ) self._special_device.set_enabled(False) def _setup_device_chooser(self): self._selected_device = self._device[0] self._last_selected_device = self._device[0] self._selected_device_modes = ModesComponent() self._selected_device_modes.add_mode('disabled', [None]) self._selected_device_modes.add_mode('device_0', [self._device_navigator._dev1_layer], behaviour = DefaultedBehaviour()) self._selected_device_modes.add_mode('device_1', [self._device_navigator._dev2_layer], behaviour = DefaultedBehaviour()) self._selected_device_modes.add_mode('device_2', [self._device_navigator._dev3_layer], behaviour = DefaultedBehaviour()) self._selected_device_modes.add_mode('device_3', [self._device_navigator._dev4_layer], behaviour = DefaultedBehaviour()) self._selected_device_modes.layer = Layer(priority = 4, device_0_button = self._button[0][0], device_1_button = self._button[0][1], device_2_button = self._button[0][2], device_3_button = self._button[0][3]) self._selected_device_modes.selected_mode = 'device_0' self._selected_device_modes.set_enabled(False) self._on_device_selector_mode_changed.subject = self._selected_device_modes def _setup_device_selector(self): self._device_selector = DeviceSelectorComponent(self) self._device_selector.name = 'Device_Selector' self._device_selector.layer = Layer(priority = 4, matrix = self._code_keys) self._device_selector.set_enabled(False) def _setup_send_reset(self): self._send_reset = CodecResetSendsComponent(self) self._send_reset.set_enabled(False) #self._send_reset.set_buttons(self._button) def _setup_default_buttons(self): self._value_default = ParameterDefaultComponent(script = self, dials = self._dial) self._value_default.layer = Layer(priority = 3, matrix = self._button_matrix) self._value_default.set_enabled(False) def _setup_shift_modes(self): self._main_shift_modes = ModesComponent(name = 'MainShiftModes') self._main_shift_modes.add_mode('disabled', [self.normal_encoder_sysex], cycle_mode_button_color = 'DefaultButton.Off') self._main_shift_modes.add_mode('enabled', [self.slow_encoder_sysex], cycle_mode_button_color = 'DefaultButton.On') #, self._value_default self._main_shift_modes.layer = Layer(priority = 4, cycle_mode_button = self._livid) self._main_shift_modes.set_enabled(False) self._main_shift_modes.selected_mode = 'disabled' self._mod_shift_modes = ModesComponent(name = 'ModShiftModes') self._mod_shift_modes.layer = Layer(priority = 4, cycle_mode_button = self._livid) self._mod_shift_modes.set_enabled(False) def _setup_mod(self): self.monomodular = get_monomodular(self) self.monomodular.name = 'monomodular_switcher' self.modhandler = CodecModHandler(script = self, device_provider = self._device_provider) self.modhandler.name = 'ModHandler' self.modhandler.layer = Layer(priority = 4, code_grid = self._button_matrix.submatrix[:,:], code_encoder_grid = self._encoder_matrix.submatrix[:,:]) self.modhandler.set_enabled(False) self.modhandler.code_buttons_layer = AddLayerMode(self.modhandler, Layer(priority = 5, code_buttons = self._code_buttons)) self.modhandler.keys_layer = AddLayerMode(self.modhandler, Layer(priority = 5, key_buttons = self._code_keys)) self.modhandler.code_keys_layer = AddLayerMode(self.modhandler, Layer(priority = 5, code_keys = self._code_buttons)) self.modhandler.alt_layer = AddLayerMode(self.modhandler, Layer(priority = 4, lock_button = self._livid)) def _setup_modswitcher(self): self._modswitcher = ModesComponent(name = 'ModSwitcher') self._modswitcher.add_mode('mod', [self.modhandler, self._mod_shift_modes]) self._modswitcher.add_mode('special_device', [self._special_device, self._mixer, self._mixer._select_layer, self._main_shift_modes]) self._modswitcher.selected_mode = 'special_device' self._modswitcher.set_enabled(False) self._mod_shift_modes.add_mode('disabled', [self.modhandler.keys_layer], cycle_mode_button_color = 'Mod.ShiftOff') self._mod_shift_modes.add_mode('enabled', [self.modhandler.code_keys_layer, self.modhandler.code_buttons_layer, tuple([self._send_mod_shift, self._release_mod_shift])], cycle_mode_button_color = 'Mod.ShiftOn') self._mod_shift_modes.selected_mode = 'disabled' def _setup_modes(self): self._main_modes = ModesComponent(name = 'MainModes') self._main_modes.add_mode('disabled', []) self._main_modes.add_mode('mix_shifted', [self._mixer, self._mixer._mix_layer, self._mixer._solo_mute_layer, self._device_selector, self._background], groups = ['shifted'], behaviour = self._shift_latching(color = 'Mode.Main')) self._main_modes.add_mode('mix', [self._mixer, self._mixer._mix_layer, self._mixer._select_layer, self._mixer._solo_mute_layer, self._session_navigation, self._background, self._main_shift_modes], behaviour = self._shift_latching(color = 'Mode.Main')) self._main_modes.add_mode('sends_shifted', [self._mixer, self._mixer._sends_layer, self._mixer._select_layer, self._device_selector, self._background], groups = ['shifted'], behaviour = self._shift_latching(color = 'Mode.Main')) self._main_modes.add_mode('sends', [self._mixer, self._mixer._sends_layer, self._mixer._select_layer, self._background, self._main_shift_modes], behaviour = self._shift_latching(color = 'Mode.Main')) self._main_modes.add_mode('device_shifted', [self._selected_device_modes, self._device_selector, self._device[0], self._device[1], self._device[2], self._device[3], self._device_selector, self._background], groups = ['shifted'], behaviour = self._shift_latching(color = 'Mode.Main')) self._main_modes.add_mode('device', [self._mixer, self._mixer._select_layer, self._selected_device_modes, self._device[0], self._device[1], self._device[2], self._device[3], self._background, self._mixer._select_layer, self._main_shift_modes], behaviour = self._shift_latching(color = 'Mode.Main')) self._main_modes.add_mode('special_device_shifted', [self._modswitcher, self._device_selector, self._background], groups = ['shifted'], behaviour = self._shift_latching(color = 'Mode.Main')) self._main_modes.add_mode('special_device', [self._modswitcher, self._background], behaviour = self._shift_latching(color = 'Mode.Main')) #self._main_modes.add_mode('select', [self.normal_encoder_sysex], behaviour = DelayedExcludingMomentaryBehaviour(excluded_groups = ['shifted'])) self._main_modes.layer = Layer(priority = 4, mix_button = self._row_button[0], sends_button = self._row_button[1], device_button = self._row_button[2], special_device_button = self._row_button[3], ) self._main_modes.selected_mode = 'disabled' self._main_modes.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 @listens('selected_mode') def _on_device_selector_mode_changed(self, mode): if mode == 'disabled': for device in self._device: device.set_dynamic_device_provider(None) elif mode in DEVICE_COMPONENTS: active_device = self._device[DEVICE_COMPONENTS.index(self._selected_device_modes.selected_mode)] for device in self._device: if device is active_device: device.set_dynamic_device_provider(self._device_provider) else: device.set_dynamic_device_provider(None) if active_device.find_track(active_device._get_device()) == self.song.view.selected_track: active_device.display_device() @listens('device') def _on_device_changed(self): self._on_device_name_changed.subject = self._device_provider.device self.schedule_message(1, self._update_modswitcher) @listens('name') def _on_device_name_changed(self): for device in self._device: device.scan_all() def _on_selected_track_changed(self): super(Codec, self)._on_selected_track_changed() #self.schedule_message(1, self._update_modswitcher) if not len(self.song.view.selected_track.devices): self._update_modswitcher() def _update_modswitcher(self): debug('update modswitcher', self.modhandler.active_mod()) if self.modhandler.active_mod(): self._modswitcher.selected_mode = 'mod' else: self._modswitcher.selected_mode = 'special_device' """general functionality""" def disconnect(self): self.log_message('<<<<<<<<<<<<<<<<<<<<<<<<< Codec log closed >>>>>>>>>>>>>>>>>>>>>>>>>') super(Codec, self).disconnect() def update_display(self): super(Codec, self).update_display() self.modhandler.send_ring_leds() def restart_monomodular(self): #self.log_message('restart monomodular') self.modhandler.disconnect() with self.component_guard(): self._setup_mod() def _send_mod_shift(self): self.modhandler._shift_value(1) def _release_mod_shift(self): self.modhandler._shift_value(0)
def _setup_modes(self): self._modswitcher = ModesComponent(name = 'ModSwitcher') self._modswitcher.add_mode('mod', [self.modhandler, self._device]) self._modswitcher.add_mode('device', [self._device, self._device.bank_layer]) self._modswitcher.selected_mode = 'device' self._modswitcher.set_enabled(True)
class Twister(LividControlSurface): __module__ = __name__ __doc__ = " Monomodular controller script for Livid CNTRLR " _sysex_id = 8 _model_name = 'Twister' _host_name = 'Twister' _version_check = 'b996' monomodular = None device_provider_class = ModDeviceProvider def __init__(self, *a, **k): super(Twister, self).__init__(*a, **k) self._skin = Skin(TwisterColors) self._device_selection_follows_track_selection = True with self.component_guard(): self._setup_monobridge() self._setup_controls() #self._define_sysex() self._setup_background() self._setup_m4l_interface() self._setup_mod() self._setup_device_control() self._setup_modes() self._on_device_changed.subject = self.song self._on_selected_track_changed.subject = self.song.view def _initialize_script(self): super(Twister, self)._initialize_script() self._connected = True def _setup_controls(self): is_momentary = True optimized = True resource = PrioritizedResource self._encoder = [CodecEncoderElement(msg_type = MIDI_CC_TYPE, channel = CHANNEL, identifier = TWISTER_DIALS[index], name = 'Encoder_' + str(index), num = TWISTER_DIALS[index], script = self, optimized_send_midi = optimized, resource_type = resource, monobridge = self._monobridge) for index in range(16)] self._encoder_button = [TwisterButtonElement(is_momentary = is_momentary, msg_type = MIDI_CC_TYPE, channel = 1, identifier = TWISTER_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(16)] self._dial_matrix = ButtonMatrixElement(name = 'Dial_Matrix', rows = [self._encoder[index*4:(index*4)+4] for index in range(4)]) self._dial_button_matrix = ButtonMatrixElement(name = 'Dial_Button_Matrix', rows = [self._encoder_button[index*4:(index*4)+4] for index in range(4)]) def _setup_background(self): self._background = BackgroundComponent(name = 'Background') self._background.layer = Layer(priority = 3, dials = self._dial_matrix, dial_buttons = self._dial_button_matrix.submatrix[:,:]) self._background.set_enabled(True) 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 _define_sysex(self): pass def _check_connection(self): self._connected = True self._initialize_hardware() self._initialize_script() 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._dial_button_matrix.submatrix[:,0], stop_clip_buttons = self._dial_button_matrix.submatrix[:,1], track_select_buttons = self._dial_button_matrix.submatrix[:,2]) self._mixer.set_enabled(True) def _setup_device_control(self): self._device = SpecialDeviceComponent(name = 'Device_Component', device_provider = self._device_provider, device_bank_registry = DeviceBankRegistry(), script = self) self._device.layer = Layer(priority = 4, parameter_controls = self._dial_matrix.submatrix[:,:],) self._device.bank_layer = AddLayerMode(self._device, Layer(priority = 4, bank_prev_button = self._encoder_button[12], bank_next_button = self._encoder_button[13])) self._device.set_enabled(False) def _setup_mod(self): self.monomodular = get_monomodular(self) self.monomodular.name = 'monomodular_switcher' self.modhandler = TwisterModHandler(self, device_provider = self._device_provider) self.modhandler.name = 'ModHandler' self.modhandler.layer = Layer(priority = 8, twister_encoder_button_grid = self._dial_button_matrix.submatrix[:,:],) #twister_encoder_grid = self._dial_matrix.submatrix[:,:],) self.modhandler.set_enabled(False) def _setup_modes(self): self._modswitcher = ModesComponent(name = 'ModSwitcher') self._modswitcher.add_mode('mod', [self.modhandler, self._device]) self._modswitcher.add_mode('device', [self._device, self._device.bank_layer]) self._modswitcher.selected_mode = 'device' self._modswitcher.set_enabled(True) def _update_modswitcher(self): debug('update modswitcher', self.modhandler.active_mod()) if self.modhandler.active_mod(): self._modswitcher.selected_mode = 'mod' else: self._modswitcher.selected_mode = 'device' @listens('appointed_device') def _on_device_changed(self): debug('appointed device changed, script') self._update_modswitcher() @listens('selected_track') def _on_selected_track_changed(self): debug('_on_selected_track_changed') #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._update_modswitcher() def restart_monomodular(self): #debug('restart monomodular') self.modhandler.disconnect() with self.component_guard(): self._setup_mod()