def _create_mixer(self): self._mixer = MixerComponent(NUM_TRACKS, auto_name=True, is_enabled=False, invert_mute_feedback=True, layer=Layer(volume_controls=(self._volume_controls), arm_buttons=(self._arm_buttons), solo_buttons=(self._solo_buttons), mute_buttons=(self._mute_buttons), shift_button=(self._shift_button), track_select_buttons=(self._select_buttons), prehear_volume_control=(self._prehear_control), crossfader_control=(self._crossfader_control), crossfade_buttons=(self._crossfade_buttons))) self._mixer.master_strip().layer = Layer(volume_control=(self._master_volume_control), select_button=(self._master_select_button)) self._encoder_mode = ModesComponent(name='Encoder_Mode', is_enabled=False) self._encoder_mode.default_behaviour = ImmediateBehaviour() self._encoder_mode.add_mode('pan', [AddLayerMode(self._mixer, Layer(pan_controls=(self._mixer_encoders)))]) self._encoder_mode.add_mode('sends', [ AddLayerMode(self._mixer, Layer(send_controls=(self._mixer_encoders))), DelayMode(AddLayerMode(self._mixer, Layer(send_select_buttons=(self._send_select_buttons))))]) self._encoder_mode.add_mode('user', [AddLayerMode(self._mixer, Layer(user_controls=(self._mixer_encoders)))]) self._encoder_mode.layer = Layer(pan_button=(self._pan_button), sends_button=(self._sends_button), user_button=(self._user_button)) self._encoder_mode.selected_mode = 'pan'
def _create_session(self): self._session = SessionComponent( is_enabled=False, num_tracks=self._session_matrix.width(), num_scenes=self._session_matrix.height(), enable_skinning=True, name='Session', is_root=True, layer=Layer(track_bank_left_button=self._left_button, track_bank_right_button=self._right_button, scene_bank_up_button=self._up_button, scene_bank_down_button=self._down_button)) self._session.set_rgb_mode(LIVE_COLORS_TO_MIDI_VALUES, RGB_COLOR_TABLE) self._session_layer_mode = AddLayerMode( self._session, Layer(clip_launch_buttons=self._session_matrix, scene_launch_buttons=self._scene_launch_matrix)) self._session_zoom = SessionZoomingComponent( self._session, is_enabled=False, enable_skinning=True, layer=Layer( nav_up_button=with_modifier(self._session_button_single, self._up_button), nav_down_button=with_modifier(self._session_button_single, self._down_button), nav_left_button=with_modifier(self._session_button_single, self._left_button), nav_right_button=with_modifier(self._session_button_single, self._right_button), button_matrix=self._session_zoom_matrix)) self._stop_clip_layer_mode = AddLayerMode( self._session, Layer(stop_track_clip_buttons=self._stop_clip_buttons, stop_all_clips_button=self._stop_button))
def _create_mixer(self): mixer_volume_layer = None if self._is_25_key_model: mixer_volume_layer = Layer(volume_control=self._25_key_slider) else: mixer_volume_layer = Layer(volume_controls=self._sliders) self._mixer = MixerComponent(is_enabled=False, name='Mixer', num_tracks=self._sliders.width(), layer=mixer_volume_layer) if not self._is_25_key_model: self._mixer.master_strip().layer = Layer( volume_control=self._master_slider) self._mixer.set_enabled(True) self._mute_button_modes = ModesComponent() mute_mode = AddLayerMode(self._mixer, Layer(mute_buttons=self._mute_buttons)) solo_mode = AddLayerMode(self._mixer, Layer(solo_buttons=self._mute_buttons)) self._mute_button_modes.add_mode('mute_mode', mute_mode) self._mute_button_modes.add_mode('solo_mode', solo_mode, behaviour=CancellableBehaviour()) self._mute_button_modes.layer = Layer( solo_mode_button=self._master_button) self._mute_button_modes.selected_mode = 'mute_mode' self._mute_button_modes.set_enabled(True)
def _create_mixer(self): mixer = MixerComponent(NUM_TRACKS, is_enabled=True, auto_name=True) mixer.layer = Layer(track_select_buttons=self._select_buttons, send_controls=self._send_encoders, next_sends_button=self._down_button, prev_sends_button=self._up_button, pan_controls=self._pan_device_encoders, volume_controls=self._volume_faders, send_lights=self._send_encoder_lights, pan_lights=self._pan_device_encoder_lights) mixer.on_send_index_changed = partial( self._show_controlled_sends_message, mixer) for channel_strip in map(mixer.channel_strip, xrange(NUM_TRACKS)): channel_strip.empty_color = 'Mixer.NoTrack' mixer_modes = ModesComponent() mixer_modes.add_mode( 'mute', [AddLayerMode(mixer, Layer(mute_buttons=self._state_buttons))]) mixer_modes.add_mode( 'solo', [AddLayerMode(mixer, Layer(solo_buttons=self._state_buttons))]) mixer_modes.add_mode( 'arm', [AddLayerMode(mixer, Layer(arm_buttons=self._state_buttons))]) mixer_modes.layer = Layer(mute_button=self._mute_mode_button, solo_button=self._solo_mode_button, arm_button=self._arm_mode_button) mixer_modes.selected_mode = 'mute' return mixer
def _setup_mixer_control(self): self._num_tracks = (8) self._mixer = MixerComponent(script=self, num_tracks=8, num_returns=4, invert_mute_feedback=True, autoname=True) self._mixer.name = 'Mixer' self._mixer.set_track_offset(0) 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( parameter_controls=self._dial_matrix.submatrix[index:index + 1, :]) self._mixer.selected_strip().layer = Layer( parameter_controls=self._selected_parameter_controls) self._mixer.master_strip().layer = Layer( parameter_controls=self._side_dial_matrix.submatrix[:3, :]) self._mixer.main_layer = AddLayerMode( self._mixer, Layer(solo_buttons=self._bottom_buttons, mute_buttons=self._top_buttons)) self._mixer.select_layer = AddLayerMode( self._mixer, Layer(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(True)
def _create_encoder_modes(self): self._encoder_modes = DisablingModesComponent() self._encoder_modes.default_behaviour = mixin(SkinableBehaviourMixin, ImmediateBehaviour)() device_mode = LayerMode( self._device, Layer(parameter_controls=self._encoders, bank_buttons=self._top_pad_row)) pan_mode = AddLayerMode(self._mixer, Layer(pan_controls=self._encoders)) sends_mode = AddLayerMode(self._mixer, Layer(send_controls=self._encoders)) background_mode = LayerMode(self._background, Layer(bank_buttons=self._top_pad_row)) self._encoder_modes.add_mode('device_mode', device_mode, is_enabled=True) self._encoder_modes.add_mode('pan_mode', [pan_mode, background_mode], is_enabled=True) for index in xrange(6): self._encoder_modes.add_mode('send_%d_mode' % (index, ), [ sends_mode, partial(self._set_send_index, index), background_mode ], is_enabled=False) self._encoder_modes.selected_mode = 'device_mode' self._encoder_modes.set_enabled(True)
def __init__(self, playing_clip_above_layer=None, playing_clip_below_layer=None, *a, **k): super(SelectPlayingClipComponent, self).__init__(*a, **k) self._update_mode_task = self._tasks.add( Task.sequence(Task.delay(1), Task.run(self._update_mode))) self._update_mode_task.kill() self._notification = self.register_component( NotificationComponent(notification_time=-1, is_enabled=False)) self.add_mode('default', None) self.add_mode('above', [ AddLayerMode(self, playing_clip_above_layer), self._notification, partial(self._show_notification, MessageBoxText.PLAYING_CLIP_ABOVE_SELECTED_CLIP) ]) self.add_mode('below', [ AddLayerMode(self, playing_clip_below_layer), self._notification, partial(self._show_notification, MessageBoxText.PLAYING_CLIP_BELOW_SELECTED_CLIP) ]) self.selected_mode = 'default' self._on_detail_clip_changed.subject = self.song().view self._on_playing_slot_index_changed.subject = self.song( ).view.selected_track
def _create_encoder_modes(self): knob_modes = ModesComponent(name=u'Knob Modes', is_enabled=False) parameter_knobs_matrix = self.wrap_matrix(self._parameter_knobs) send_toggle_component = SendToggleComponent( self._mixer, name=u'Toggle Send', is_enabled=False, layer=Layer(toggle_button=self._send_button, priority=1)) knob_modes.add_mode( u'volume', AddLayerMode(self._mixer, Layer(volume_controls=parameter_knobs_matrix))) knob_modes.add_mode( u'pan', AddLayerMode(self._mixer, Layer(pan_controls=parameter_knobs_matrix))) knob_modes.add_mode(u'send', [ AddLayerMode(self._mixer, Layer(send_controls=parameter_knobs_matrix)), send_toggle_component ]) knob_modes.add_mode( u'device', AddLayerMode(self._device, Layer(parameter_controls=parameter_knobs_matrix))) knob_modes.selected_mode = u'volume' knob_modes.layer = Layer(volume_button=self._volume_button, pan_button=self._pan_button, send_button=self._send_button, device_button=self._device_button) return knob_modes
def _create_encoder_modes(self): knob_modes = ModesComponent(name='Knob Modes', is_enabled=False) parameter_knobs_matrix = self.wrap_matrix(self._parameter_knobs) knob_modes.add_mode( 'volume', AddLayerMode(self._mixer, Layer(volume_controls=parameter_knobs_matrix))) knob_modes.add_mode( 'pan', AddLayerMode(self._mixer, Layer(pan_controls=parameter_knobs_matrix))) knob_modes.add_mode('send', [ AddLayerMode(self._mixer, Layer(send_controls=parameter_knobs_matrix)), DelayMode(LayerMode( SendToggleComponent( self._mixer, name='Toggle Send', is_enabled=False), Layer(priority=MODE_PRIORITY, toggle_button=self._send_button)), delay=TIMER_DELAY) ]) knob_modes.add_mode( 'device', AddLayerMode(self._device, Layer(parameter_controls=parameter_knobs_matrix))) knob_modes.selected_mode = 'volume' knob_modes.layer = Layer(volume_button=self._volume_button, pan_button=self._pan_button, send_button=self._send_button, device_button=self._device_button) knob_modes.layer.priority = MODE_PRIORITY
def _create_track_button_modes(self): track_button_modes = ModesComponent(name='Track Button Modes', is_enabled=False) select_button_matrix = self.wrap_matrix(self._select_buttons) track_button_modes.add_mode( 'clip_stop', AddLayerMode(self._session, Layer(stop_track_clip_buttons=select_button_matrix))) track_button_modes.add_mode( 'solo', AddLayerMode(self._mixer, layer=Layer(solo_buttons=select_button_matrix))) track_button_modes.add_mode( 'arm', AddLayerMode(self._mixer, layer=Layer(arm_buttons=select_button_matrix))) track_button_modes.add_mode( 'mute', AddLayerMode(self._mixer, layer=Layer(mute_buttons=select_button_matrix))) track_button_modes.add_mode( 'select', AddLayerMode( self._mixer, layer=Layer(track_select_buttons=select_button_matrix))) track_button_modes.selected_mode = 'clip_stop' track_button_modes.layer = Layer(clip_stop_button=self._stop_button, solo_button=self._solo_button, arm_button=self._arm_button, mute_button=self._mute_button, select_button=self._select_button)
def _create_mode_selector(self): self._mode_selector = ModesComponent() mode_selection = LayerMode(self._encoder_modes, Layer(device_mode_button=self._device_mode_button, pan_mode_button=self._pan_mode_button, **self._send_mode_buttons)) device_navigation = AddLayerMode(self._device, Layer(device_nav_left_button=self._track_left_button, device_nav_right_button=self._track_right_button)) self._mode_selector.add_mode(u'mode_selection', [partial(self._toggle_in_control, True), mode_selection, device_navigation], behaviour=MomentaryBehaviour()) session_control = AddLayerMode(self._session, Layer(clip_launch_buttons=self._top_pad_row)) self._mode_selector.add_mode(u'session_mode', [partial(self._toggle_in_control, False), session_control]) self._mode_selector.layer = Layer(mode_selection_button=self._encoder_incontrol_button2)
def _create_step_button_modes(self): matrix_modes = ModesComponent(name='Step_Button_Modes') clip_mode = AddLayerMode(self._session, Layer(clip_launch_buttons=self._step_buttons, stop_track_clip_buttons=self._modified_step_buttons)) scene_mode = AddLayerMode(self._session, Layer(scene_launch_buttons=self._step_buttons)) matrix_modes.add_mode('clip', clip_mode) matrix_modes.add_mode('scene', scene_mode) matrix_modes.layer = Layer(clip_button=self._recall_button, scene_button=self._store_button) matrix_modes.selected_mode = 'clip' return matrix_modes
def _create_modes(self): self._modes = ModesComponent(name='Launchpad_Modes', is_enabled=False) self._session_layer_mode = AddLayerMode( self._session, Layer(scene_launch_buttons=self. _midimap['Scene_Launch_Button_Matrix'], clip_launch_buttons=self._midimap['Main_Button_Matrix'], delete_button=self._midimap['Delete_Button'], duplicate_button=self._midimap['Duplicate_Button'], double_button=self._midimap['Double_Loop_Button'], quantize_button=self._midimap['Quantize_Button'])) # self._arrangement_layer_mode = AddLayerMode(self._arrangement, Layer(transport_buttons=self._midimap['Scene_Launch_Button_Matrix'], track_buttons=self._midimap['Main_Button_Matrix'], quantize_button=self._midimap['Quantize_Button'])) action_button_background = BackgroundComponent(name='No_Op_Buttons') self._action_button_background_layer_mode = LayerMode( action_button_background, Layer(delete_button=self._midimap['Delete_Button'], quantize_button=self._midimap['Quantize_Button'], duplicate_button=self._midimap['Duplicate_Button'], double_button=self._midimap['Double_Loop_Button'])) self._clip_delete_layer_mode = AddLayerMode( self._clip_actions_component, layer=Layer(delete_button=self._midimap['Delete_Button'])) self._create_session_zooming_modes() self._create_session_mode() self._create_note_modes() self._create_device_mode() # self._create_user_mode() self._create_arrangement_mode() self._create_record_arm_mode() self._create_track_select_mode() self._create_mute_mode() self._create_solo_mode() self._create_volume_mode() self._create_pan_mode() self._create_sends_mode() self._create_stop_clips_mode() self._modes.layer = Layer( session_mode_button=self._midimap['Session_Mode_Button'], note_mode_button=self._midimap['Note_Mode_Button'], device_mode_button=self._midimap['Device_Mode_Button'], arrangement_mode_button=self._midimap['User_Mode_Button'], record_arm_mode_button=self._midimap['Record_Arm_Mode_Button'], track_select_mode_button=self._midimap['Track_Select_Mode_Button'], mute_mode_button=self._midimap['Mute_Mode_Button'], solo_mode_button=self._midimap['Solo_Mode_Button'], volume_mode_button=self._midimap['Volume_Mode_Button'], pan_mode_button=self._midimap['Pan_Mode_Button'], sends_mode_button=self._midimap['Sends_Mode_Button'], stop_clip_mode_button=self._midimap['Stop_Clip_Mode_Button']) self._modes.selected_mode = 'session_mode' self._on_layout_changed.subject = self._modes self._create_view_control_component()
def _Launchpad_MK2_setup_mod(args): # debug('args:', args) lp2script = args[0]; script = args[1] if not hasattr(lp2script, '_modified') or (hasattr(lp2script, '_modified') and not lp2script._modified): lp2script.modhandler = LaunchpadMk2ModHandler(script = lp2script, modrouter = script.monomodular, song = lp2script.song(), register_component = lp2script._register_component, is_enabled=False) lp2script.modhandler.name = 'ModHandler' lp2script.modhandler.layer = Layer( grid = lp2script._session_matrix, key_buttons = lp2script._scene_launch_matrix, nav_up_button = lp2script._up_button, nav_down_button = lp2script._down_button, nav_left_button = lp2script._left_button, nav_right_button = lp2script._right_button, Shift_button = lp2script._user_1_button,) lp2script.modhandler.legacy_shift_layer = AddLayerMode( lp2script.modhandler, Layer( nav_matrix = lp2script._session_matrix.submatrix[2:6, 2:6])) script.schedule_message(1, script._device_provider.restart_mod) lp2script._modes.add_mode('mod_mode', [lp2script.modhandler], layout_byte=0) lp2script._modes._original_layer = lp2script._modes.layer lp2script._modes.layer = Layer(session_mode_button=lp2script._session_button, mod_mode_button=lp2script._user_1_button, user_2_mode_button=lp2script._user_2_button, mixer_mode_button=lp2script._mixer_button, volume_mode_button=lp2script._volume_button, pan_mode_button=lp2script._pan_button, send_a_mode_button=lp2script._send_a_button, send_b_mode_button=lp2script._send_b_button) def make_lp2script_disconnect_mod(): def _disconnect_mod(): if hasattr(lp2script._modes, '_original_layer'): if lp2script._modes.selected_mode == 'mod_mode': lp2script._modes.selected_mode = 'user_2_mode' lp2script._modes.layer = lp2script._modes._original_layer if 'mod_mode' in lp2script._modes._mode_list: del lp2script._modes._mode_list[lp2script._modes._mode_list.index('mod_mode')] if 'mod_mode' in list(lp2script._modes._mode_map.keys()): del lp2script._modes._mode_map['mod_mode'] lp2script.modhandler.select_mod = nop if hasattr(lp2script, '_original_disconnect'): lp2script.disconnect = lp2script._original_disconnect lp2script._modified = False return _disconnect_mod lp2script._disconnect_mod = make_lp2script_disconnect_mod() lp2script._original_disconnect = lp2script.disconnect def make_lp2script_disconnect(): def disconnect(): lp2script.modhandler.select_mod = nop lp2script.modhandler.disconnect() Launchpad_MK2.disconnect(lp2script) return disconnect lp2script.disconnect = make_lp2script_disconnect() lp2script._modified = True
def _setup_mod(self): self.monomodular = get_monomodular(self) self.monomodular.name = 'monomodular_switcher' self.modhandler = LaunchModHandler(self) self.modhandler.name = 'ModHandler' self.modhandler.layer = Layer( shift_button = self._top_buttons[4], lock_button = self._top_buttons[5], alt_button = self._top_buttons[6], key_buttons = self._side_buttons, nav_up_button = self._top_buttons[0], nav_down_button = self._top_buttons[1], nav_left_button = self._top_buttons[2], nav_right_button = self._top_buttons[3]) self.modhandler.shift_layer = AddLayerMode(self.modhandler, Layer(device_selector_matrix = self._matrix.submatrix[:, :1])) self.modhandler.legacy_shift_layer = AddLayerMode(self.modhandler, Layer(channel_buttons = self._matrix.submatrix[:, 1:2], nav_matrix = self._matrix.submatrix[2:6, 2:6],))
def _create_device(self): device = DeviceComponent(name='Device_Component', is_enabled=False) device.layer = Layer(parameter_controls=self._pan_device_encoders, parameter_lights=self._pan_device_encoder_lights, priority=1) device_settings_layer = Layer(bank_buttons=self._state_buttons, prev_device_button=self._left_button, next_device_button=self._right_button, priority=1) mode = DeviceModeComponent(component=device, device_settings_mode=[AddLayerMode(device, device_settings_layer)], is_enabled=True) mode.layer = Layer(device_mode_button=self._pan_device_mode_button) return device
def _setup_session_control(self): self._session = DS1SessionComponent(num_tracks = 8, num_scenes = 1, auto_name = True, enable_skinning = True) self._session.set_offsets(0, 0) self._session.set_mixer(self._mixer) self._session.layer = Layer(track_select_dial = ComboElement(self._encoder[1], modifiers = [self._encoder_button[1]]), scene_bank_up_button = self._grid[0][1], scene_bank_down_button = self._grid[0][2], scene_launch_buttons = self._grid_matrix.submatrix[1:2, 1:2]) self._session.clips_layer = AddLayerMode(self._session, Layer(clip_launch_buttons = self._top_buttons, stop_track_clip_buttons = self._bottom_buttons)) self.set_highlighting_session_component(self._session) self._session._do_show_highlight()
def __init__(self): super(PadModes, self).__init__() self._init_session() self.add_mode('session', self._session_modes.modes()) self.add_mode('note', LazyComponentMode(self._note_modes)) self.add_mode('track', AddLayerMode(self.control_surface.mixer, self._track_control_layer())) self.add_mode('sequencer', LazyComponentMode(self._init_sequencer)) self.selected_mode = "session"
def _create_stop_clips_mode(self): stop_layer_mode = AddLayerMode(self._session, Layer(stop_track_clip_buttons=self._midimap['Mixer_Button_Matrix'], stop_scene_clip_buttons=self._midimap['Scene_Stop_Button_Matrix'], stop_all_clips_button=self._midimap['Stop_All_Clips_Button'])) self._modes.add_mode('stop_clip_mode', [partial(self._layout_setup, consts.SESSION_LAYOUT_SYSEX_BYTE), self._session_layer_mode, stop_layer_mode, self._session_zooming_manager, self._prioritized_session_zooming_button_layer_mode, self._session.update_navigation_buttons], behaviour=SpecialReenterBehaviour('session_mode'))
def __init__(self, grid_resolution = None, initial_encoder_layer = None, encoder_layer = None, settings_layer = None, *a, **k): super(NoteEditorSettingsComponent, self).__init__(*a, **k) raise encoder_layer or AssertionError self._bottom_data_sources = [ DisplayDataSource() for _ in xrange(8) ] self._request_hide = False self.settings = self.register_component(NoteSettingsComponent(grid_resolution=grid_resolution, layer=settings_layer)) self.settings.set_enabled(False) self._automation = self.register_component(AutomationComponent()) 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))) self._show_settings_task.kill() self._update_infos_task = self._tasks.add(Task.run(self._update_note_infos)) self._update_infos_task.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._settings_modes.add_mode('pad_settings', [self.settings, 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
def _create_modes(self): self._encoder_modes = ModesComponent() device_layer_mode = LayerMode(self._device, Layer(parameter_controls=self._encoders)) device_navigation_layer_mode = LayerMode( self._device_navigation, Layer(device_nav_right_button=self._forward_button, device_nav_left_button=self._backward_button)) self._encoder_modes.add_mode( b'device_mode', [device_layer_mode, device_navigation_layer_mode]) self._encoder_modes.add_mode( b'pan_mode', AddLayerMode( self._mixer, Layer(pan_controls=self._encoders, bank_up_button=self._forward_button, bank_down_button=self._backward_button, track_up_button=self._ff_button, track_down_button=self._rw_button))) send_layer_mode = AddLayerMode( self._mixer, Layer(send_controls=self._encoders, bank_up_button=self._forward_button, bank_down_button=self._backward_button, track_up_button=self._ff_button, track_down_button=self._rw_button)) self._encoder_modes.add_mode( b'send_a_mode', [send_layer_mode, partial(self._set_send_index, 0)]) self._encoder_modes.add_mode( b'send_b_mode', [send_layer_mode, partial(self._set_send_index, 1)]) self._encoder_modes.layer = Layer( device_mode_button=self._device_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._encoder_modes.selected_mode = b'device_mode' self._encoder_modes.set_enabled(True)
def _setup_mod(self): self._host = PushMonomodComponent(self) self._host.name = 'Monomod_Host' self._host._host_name = 'AumPush' self._host.layer = Layer( lock_button = self._note_mode_button, button_matrix = self._matrix, shift_button = self._shift_button, alt_button = self._select_button, key_buttons = self._track_state_buttons) #, nav_up_button = OptionalElement( self._nav_up_button, self._host._alt_pressed, False), nav_down_button = OptionalElement( self._nav_down_button, self._host._alt_pressed, False), nav_left_button = OptionalElement( self._nav_left_button, self._host._alt_pressed, False), nav_right_button = OptionalElement( self._nav_right_button, self._host._alt_pressed, False)) #name_display_line=self._display_line1, value_display_line=self._display_line2, alternating_display=self._display_line3, device_controls = self._global_param_controls, encoder_touch_buttons=self._global_param_touch_buttons, lcd_displays = self._display_line1) self._host.layer.priority = 4 self._host.alt_display_layer = Layer( name_display_line = self._display_line3, value_display_line = self._display_line4 ) #alt_controls = self._track_state_buttons, self._host.shift_display_layer = Layer( name_display_line = self._display_line3, value_display_line = self._display_line4 ) #alt_controls = self._track_state_buttons, self._host.nav_buttons_layer = AddLayerMode( self._host, Layer(nav_up_button = self._nav_up_button, nav_down_button = self._nav_down_button, nav_left_button = self._nav_left_button, nav_right_button = self._nav_right_button) ) self.hosts = [self._host]
def _setup_layers(self): self._device_navigator.layer = Layer(priority = 5, prev_button = self._menu[2], next_button = self._menu[3]) self._device.mod_layer = AddLayerMode(self._device, Layer(priority = 5, bank_prev_button = self._menu[0], bank_next_button = self._menu[1])) self._transport.mod_layer = AddLayerMode(self._transport, Layer(priority = 5, play_button = self._menu[2], stop_button = self._menu[3])) self.modhandler.set_mod_button(self._livid) self.modhandler.layer = Layer(priority = 5, grid = self._monomod, nav_up_button = self._menu[0], nav_down_button = self._menu[1], nav_left_button = self._menu[2], nav_right_button = self._menu[3], shift_button = self._shift_r, alt_button = self._shift_l, parameter_controls = self._dial_matrix) self.modhandler.legacy_shift_mode = AddLayerMode(self.modhandler, Layer(priority = 6, channel_buttons = self._monomod.submatrix[:, 1:2], nav_matrix = self._monomod.submatrix[:4, 2:6])) self.modhandler.shift_mode = AddLayerMode(self.modhandler, Layer(priority = 6, lock_button = self._livid, device_selector_matrix = self._monomod.submatrix[:, :1], key_buttons = self._monomod.submatrix[:, 7:8])) self.modhandler.shiftlock_mode = AddLayerMode(self.modhandler, Layer(priority = 6, key_buttons = self._monomod.submatrix[:, 7:8]))
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._monomod, 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._monomod.submatrix[:, 1:2], nav_matrix = self._monomod.submatrix[4:8, 2:6])) self.modhandler.shift_mode = AddLayerMode(self.modhandler, Layer(priority = 6, device_selector_matrix = self._monomod.submatrix[:, :1], lock_button = self._livid, key_buttons = self._monomod.submatrix[:, 7:8])) self.modhandler.set_enabled(False) self.modhandler.set_mod_button(self._livid)
def _create_mixer(self): self.log('_create_mixer', True) mixer = MixerComponent(self, NUM_TRACKS, 3, show_returns=self._show_returns, max_returns=self._max_returns, show_master=self._show_master, delayed_update=True, is_enabled=True, auto_name=True) layer = Layer(volume_controls=self._volume_encoders, send_controls=self._send_encoders, next_sends_button=self._bank_down_button, prev_sends_button=self._bank_up_button) valid_opts = self._get_button_options() layer += Layer(**valid_opts) mixer.layer = layer self._mixer = mixer self._bcr_controls.setup_mixer_controls() self._modes.add_mode('mixer', [AddLayerMode(self._mixer, layer)]) self._modes.selected_mode = 'mixer'
def __init__(self, matrix, should_invert_buttons=True, default_smoothing_speed=2, velocity_sensitive=False, *a, **k): super(ButtonSliderManager, self).__init__(name='Button_Slider_Manager', *a, **k) self.is_private = True self._layers = [] slider = SpecialButtonSliderElement w_range = xrange(matrix.width()) self._default_colors = ['ButtonSlider.Slider' for _ in w_range] slider_elements = [[ slider(should_invert_buttons=should_invert_buttons, default_smoothing_speed=default_smoothing_speed, velocity_sensitive=velocity_sensitive, name='Button_Sliders_%s' % i, inc_dec_colors=('ButtonSlider.IncDecOff', 'ButtonSlider.IncDecOn'), off_on_colors=('ButtonSlider.OffOnOff', 'ButtonSlider.OffOnOn'), automat_clear_colors=('ButtonSlider.ClearOff', 'ButtonSlider.ClearOn'), slider_color='ButtonSlider.Slider', bipolar_color='ButtonSlider.Bipolar') for i in w_range ]] self._slider_elements = slider_elements[0] for index, element in enumerate(self._slider_elements): layer = Layer(buttons=matrix.submatrix[index:index + 1, :]) self._layers.append(AddLayerMode(element, layer)) self._slider_matrix = ButtonMatrixElement(rows=slider_elements, name='Button_Sliders')
def _create_components(self): self._initialize_task.kill() self._disconnect_and_unregister_all_components() with self.component_guard(): mixer = self._create_mixer() session = self._create_session() device = self._create_device() transport = self._create_transport() session.set_mixer(mixer) self.set_device_component(device) self.set_highlighting_session_component(session) mixer_modes = ModesComponent(mixer, device, transport, session) set_main_mode = partial(setattr, mixer_modes, 'selected_mode') # AddLayerMode(mixer, Layer( # send_mute_buttons=self._state_buttons3, # )) # AddLayerMode(session, Layer( # page_left_button=self._button_1, # page_right_button=self._button_2, # track_bank_left_button=self._button_9, # track_bank_right_button=self._button_10, # clip_left_button=self._button_6, # clip_right_button=self._button_7, # scene_up_button=self._button_8, # scene_down_button=self._button_16 # )) # AddLayerMode(transport, Layer( # toggle_view_button=self._button_3, # metronome_button = self._button_4, # delete_clip_button=self._button_5, # overdub_button=self._button_12, # arm_button=self._button_13, # stop_clip_button=self._button_14, # play_clip_button=self._button_15 # )) mixer_modes.add_mode( 'mode_1', [ AddLayerMode( mixer, Layer(track_select_buttons=self._state_buttons1)), AddLayerMode(device, Layer(device_buttons=self._state_buttons2)) ], behaviour=ReenterBehaviour( on_reenter=partial(set_main_mode, 'mode_1_detail'))) mixer_modes.add_mode( 'mode_1_detail', [ AddLayerMode( mixer, Layer(send_select_buttons=self._state_buttons4, switch_sends_button=self._button_7, master_select_button=self._button_8)), AddLayerMode(device, Layer(device_buttons=self._state_buttons2)) ], behaviour=ReenterBehaviour( on_reenter=partial(set_main_mode, 'mode_1'))) mixer_modes.add_mode('mode_2', [ AddLayerMode( mixer, Layer(mute_buttons=self._state_buttons1, track_activate_send_buttons=self._state_buttons2)) ]) mixer_modes.add_mode('mode_3', [ AddLayerMode( mixer, Layer(solo_buttons=self._state_buttons1, arm_buttons=self._state_buttons2)) ]) mixer_modes.add_mode('mode_4', [ AddLayerMode( mixer, Layer(crossfader_buttons_A=self._state_buttons1, crossfader_buttons_B=self._state_buttons2)) ]) mixer_modes.layer = Layer(mode_1_button=self._mode_1_button, mode_2_button=self._mode_2_button, mode_3_button=self._mode_3_button, mode_4_button=self._mode_4_button) mixer_modes.selected_mode = 'mode_2'
def _create_device(self): self.log('_create_device', True) def make_button(identifier, name, midi_type=MIDI_CC_TYPE, skin=self._default_skin): return ButtonElement(True, midi_type, MIXER_MODE, identifier, name=name, skin=skin) def make_encoder(identifier, name, bit_14=True): if self._bit_14: self.log('make_encoder: ' + name + ', CC: ' + str(identifier) + ', 14_bit: ' + str(bit_14)) control = EncoderElement( MIDI_CC_TYPE, MIXER_MODE, identifier, Live.MidiMap.MapMode.absolute_14_bit if bit_14 else Live.MidiMap.MapMode.absolute, name=name) else: control = EncoderElement( MIDI_CC_TYPE, MIXER_MODE, identifier, Live.MidiMap.MapMode.absolute if not self._relative else Live.MidiMap.MapMode.relative_two_compliment, name=name) return control if self._bit_14: volume_cc = 0 sends_cc = 8 else: volume_cc = 1 sends_cc = 81 if self._use_32: self._device_encoders = ButtonMatrixElement( rows=[[ make_encoder(volume_cc + i, 'Volume_%d' % (i + 1)) for i in xrange(8) ], [ make_encoder(sends_cc + i, 'BCR_Device_0_%d' % (i + 1)) for i in xrange(8) ], [ make_encoder(sends_cc + 8 + i, 'BCR_Device_1_%d' % (i + 1)) for i in xrange(8) ], [ make_encoder(sends_cc + 16 + i, 'BCR_Device_2_%d' % (i + 1)) for i in xrange(8) ]]) self._send_encoders = self._device_encoders.submatrix[:8, 1:4] else: self._device_encoders = self._send_encoders if self._channel_strip: self._device = DeviceComponent_Strip( self, name='XL_Device', is_enabled=True, direct_bank=self._direct_bank, num_params=32 if self._use_32 else 24, path=self._my_path, delayed_update=True) else: self._device = DeviceComponent( self, name='XL_Device', is_enabled=True, direct_bank=self._direct_bank, num_params=32 if self._use_32 else 24, path=self._my_path, delayed_update=True) self.set_preditor_device_component(self._device) if self._direct_bank: device_layer = Layer(parameter_controls=self._device_encoders, device_select=self._top_buttons, device_enable=self._bottom_buttons, device_lock_button=self._track_fold_button, bank_up_button=self._bank_down_button, bank_down_button=self._bank_up_button, direct_bank=self._direct_bank_buttons) else: device_layer = Layer(parameter_controls=self._device_encoders, device_select=self._top_buttons, device_enable=self._bottom_buttons, device_lock_button=self._track_fold_button, bank_up_button=self._bank_down_button, bank_down_button=self._bank_up_button) device_settings_layer = Layer() self.device_mode = DeviceModeComponent(script=self, component=self._device, device_settings_mode=[ AddLayerMode( self._device, device_settings_layer) ], is_enabled=True) self.device_mode.layer = Layer( device_mode_button=self._device_engage_button) if self._has_pans: mixer_layer = Layer(volume_controls=self._volume_encoders, pan_controls=self._pan_encoders) else: mixer_layer = Layer(volume_controls=self._volume_encoders) self._modes.add_mode('device', [ AddLayerMode(self._device, device_layer), AddLayerMode(self._mixer, mixer_layer) ]) if self._channel_strip: if hasattr(self._device, 'enable_channel_strip'): strip_layer = Layer(parameter_controls=self._device_encoders) valid_opts = self._get_button_options(True) mixer_layer += Layer(**valid_opts) self._modes.add_mode('device_strip', [ AddLayerMode(self._device, strip_layer), AddLayerMode(self._mixer, mixer_layer), AddLayerMode( self._session, Layer(track_bank_left_button=self._left_button, track_bank_right_button=self._right_button)) ]) else: self._channel_strip = False
def _Launchpad_Pro_setup_mod(args): lpproscript = args[0] modscript = args[1] if not hasattr(lpproscript, '_modified') or (hasattr( lpproscript, '_modified') and not lpproscript._modified): with lpproscript.component_guard(): lpproscript.modhandler = LaunchpadProModHandler( script=lpproscript, modrouter=modscript.monomodular, song=lpproscript.song(), register_component=lpproscript._register_component, is_enabled=False) lpproscript.modhandler.name = 'ModHandler' lpproscript.modhandler.layer = Layer( grid=lpproscript._midimap[u'Main_Button_Matrix'].submatrix[:, :], key_buttons=lpproscript._midimap[u'Scene_Launch_Button_Matrix'], nav_up_button=lpproscript._midimap[u'Arrow_Up_Button'], nav_down_button=lpproscript._midimap[u'Arrow_Down_Button'], nav_left_button=lpproscript._midimap[u'Arrow_Left_Button'], nav_right_button=lpproscript._midimap[u'Arrow_Right_Button'], Shift_button=lpproscript._midimap[u'Shift_Button'], Alt_button=lpproscript._midimap[u'Note_Mode_Button']) lpproscript.modhandler.legacy_shift_layer = AddLayerMode( lpproscript.modhandler, Layer(nav_matrix=lpproscript._midimap[u'Main_Button_Matrix']. submatrix[2:6, 2:6])) modscript.schedule_message(1, modscript._device_provider.restart_mod) lpproscript._note_modes.add_mode(u'mod_mode', [ partial(lpproscript._layout_setup, consts.SESSION_LAYOUT_SYSEX_BYTE), lpproscript.modhandler ]) lpproscript._original_select_note_mode = lpproscript._select_note_mode def create_note_mode_override(lpproscript): def _select_note_mode(): track = lpproscript._target_track_component.target_track drum_device = lpproscript._drum_group_finder.drum_group if lpproscript.modhandler.active_mod(): lpproscript._note_modes.selected_mode = 'mod_mode' elif track is None or track.is_foldable or track in lpproscript.song( ).return_tracks or track == lpproscript.song( ).master_track or track.is_frozen or track.has_audio_input: lpproscript._note_modes.selected_mode = u'audio_mode' elif drum_device: lpproscript._note_modes.selected_mode = u'drum_mode' else: lpproscript._note_modes.selected_mode = u'chromatic_mode' lpproscript._modes.update() if lpproscript._note_modes.selected_mode == u'audio_mode' or lpproscript._note_modes.selected_mode == u'mod_mode': lpproscript.release_controlled_track() else: lpproscript.set_controlled_track( lpproscript._target_track_component.target_track) return _select_note_mode lpproscript._select_note_mode = create_note_mode_override(lpproscript) def make_lpproscript_disconnect_mod(): def _disconnect_mod(): if hasattr(lpproscript, '_original_select_note_mode'): if lpproscript._note_modes.selected_mode == u'mod_mode': lpproscript._note_modes.selected_mode = u'audio_mode' lpproscript._select_note_mode = lpproscript._original_select_note_mode lpproscript._select_note_mode() if u'mod_mode' in lpproscript._note_modes._mode_list: del lpproscript._note_modes._mode_list[ lpproscript._note_modes._mode_list.index(u'mod_mode')] if u'mod_mode' in lpproscript._note_modes._mode_map.keys(): del lpproscript._note_modes._mode_map[u'mod_mode'] lpproscript.modhandler.select_mod = nop if hasattr(lpproscript, '_original_disconnect'): lpproscript.disconnect = lpproscript._original_disconnect lpproscript._modified = False return _disconnect_mod lpproscript._disconnect_mod = make_lpproscript_disconnect_mod() lpproscript._original_disconnect = lpproscript.disconnect def make_lpproscript_disconnect(): def disconnect(): lpproscript.modhandler.select_mod = nop # modscript.schedule_message(1, modscript._device_provider.restart_mod) lpproscript.modhandler.disconnect() Launchpad_Pro.disconnect(lpproscript) return disconnect lpproscript.disconnect = make_lpproscript_disconnect() lpproscript._modified = True