def __init__(self, *a, **k): (super(MPK225, self).__init__)(*a, **k) with self.component_guard(): midimap = MidiMap() drum_rack = DrumRackComponent( name='Drum_Rack', is_enabled=False, layer=Layer(pads=(midimap['Drum_Pads']))) drum_rack.set_enabled(True) transport = TransportComponent( name='Transport', is_enabled=False, layer=Layer(play_button=(midimap['Play']), record_button=(midimap['Record']), stop_button=(midimap['Stop']), seek_forward_button=(midimap['Forward']), seek_backward_button=(midimap['Backward']), loop_button=(midimap['Loop']))) transport.set_enabled(True) device = DeviceComponent( name='Device', is_enabled=False, layer=Layer(parameter_controls=(midimap['Encoders'])), device_selection_follows_track_selection=True) device.set_enabled(True) self.set_device_component(device)
def __init__(self, *a, **k): (super(MPK261, self).__init__)(*a, **k) with self.component_guard(): midimap = MidiMap() drum_rack = DrumRackComponent( name='Drum_Rack', is_enabled=False, layer=Layer(pads=(midimap['Drum_Pads']))) drum_rack.set_enabled(True) transport = TransportComponent( name='Transport', is_enabled=False, layer=Layer(play_button=(midimap['Play']), record_button=(midimap['Record']), stop_button=(midimap['Stop']), seek_forward_button=(midimap['Forward']), seek_backward_button=(midimap['Backward']), loop_button=(midimap['Loop']))) transport.set_enabled(True) mixer_size = len(midimap['Sliders']) mixer = MixerComponent(mixer_size, name='Mixer', is_enabled=False, layer=Layer( volume_controls=(midimap['Sliders']), pan_controls=(midimap['Encoders']), arm_buttons=(midimap['Arm_Buttons']))) mixer.set_enabled(True)
def __init__(self, *a, **k): (super(Advance, self).__init__)(*a, **k) with self.component_guard(): encoders = ButtonMatrixElement(rows=[[ make_encoder(index + 22, 'Encoder_%d' % index) for index in range(8) ]]) pads = ButtonMatrixElement(rows=[[ make_button(identifier, 'Pad_%d_%d' % (col, row)) for col, identifier in enumerate(row_ids) ] for row, row_ids in enumerate(PAD_IDS)]) device = DeviceComponent( is_enabled=False, layer=Layer(parameter_controls=encoders), device_selection_follows_track_selection=True) device.set_enabled(True) self.set_device_component(device) drums = DrumRackComponent(is_enabled=False, layer=Layer(pads=pads)) drums.set_enabled(True) play_button = make_button(118, 'Play_Button', MIDI_CC_TYPE, 0) stop_button = make_button(117, 'Stop_Button', MIDI_CC_TYPE, 0) record_button = make_button(119, 'Record_Button', MIDI_CC_TYPE, 0) loop_button = make_button(114, 'Loop_Button', MIDI_CC_TYPE, 0) transport = TransportComponent(is_enabled=False, layer=Layer( play_button=play_button, stop_button=stop_button, record_button=record_button, loop_button=loop_button)) transport.set_enabled(True)
def __init__(self, *a, **k): (super(Alesis_VI, self).__init__)(*a, **k) with self.component_guard(): midimap = MidiMap() transport = TransportComponent( name='Transport', is_enabled=False, layer=Layer(play_button=(midimap['Play']), stop_button=(midimap['Stop']), loop_button=(midimap['Loop']), record_button=(midimap['Record']), seek_forward_button=(midimap['Forward']), seek_backward_button=(midimap['Backward']))) mixer_size = len(midimap['Volume_Encoders']) mixer = MixerComponent( mixer_size, name='Mixer', is_enabled=False, layer=Layer(volume_controls=(midimap['Volume_Encoders']))) transport.set_enabled(True) mixer.set_enabled(True)
class KeyLab(ArturiaControlSurface): def __init__(self, *a, **k): (super(KeyLab, self).__init__)(*a, **k) with self.component_guard(): self._create_controls() self._create_display() self._create_device() self._create_drums() self._create_transport() self._create_session() self._create_session_recording() self._create_mixer() def _create_controls(self): self._device_encoders = ButtonMatrixElement(rows=[[ EncoderElement(MIDI_CC_TYPE, ENCODER_CHANNEL, identifier, (Live.MidiMap.MapMode. relative_smooth_binary_offset), name=('Device_Encoder_%d_%d' % (col_index, row_index))) for col_index, identifier in enumerate(row) ] for row_index, row in enumerate((ENCODER_MSG_IDS[:4], ENCODER_MSG_IDS[4:8]))]) self._horizontal_scroll_encoder = EncoderElement( MIDI_CC_TYPE, ENCODER_CHANNEL, (ENCODER_MSG_IDS[(-2)]), (Live.MidiMap.MapMode.relative_smooth_binary_offset), name='Horizontal_Scroll_Encoder') self._vertical_scroll_encoder = EncoderElement( MIDI_CC_TYPE, ENCODER_CHANNEL, (ENCODER_MSG_IDS[(-1)]), (Live.MidiMap.MapMode.relative_smooth_binary_offset), name='Vertical_Scroll_Encoder') self._volume_sliders = ButtonMatrixElement(rows=[[ SliderElement(MIDI_CC_TYPE, ENCODER_CHANNEL, identifier) for identifier in SLIDER_MSG_IDS[:-1] ]]) self._master_slider = SliderElement(MIDI_CC_TYPE, ENCODER_CHANNEL, SLIDER_MSG_IDS[(-1)]) def make_keylab_button(name): button = ButtonElement(True, MIDI_CC_TYPE, 0, (get_button_identifier_by_name(name)), name=(name.title())) return button for button_name in list(BUTTON_HARDWARE_AND_MESSAGE_IDS.keys()): setattr(self, '_' + button_name, make_keylab_button(button_name)) self._pads = ButtonMatrixElement(rows=[[ ButtonElement(True, MIDI_CC_TYPE, PAD_CHANNEL, (col_index + row_offset), name=('Pad_%d_%d' % (col_index, row_index))) for col_index in range(4) ] for row_index, row_offset in enumerate(range(48, 35, -4))]) def _create_display(self): self._display_line1, self._display_line2 = DisplayElement( 16, 1), DisplayElement(16, 1) for index, display_line in enumerate( (self._display_line1, self._display_line2)): display_line.set_message_parts(SETUP_MSG_PREFIX + (4, 0, 96), SETUP_MSG_SUFFIX) display_line.segment(0).set_position_identifier((index + 1, )) def adjust_null_terminated_string(string, width): return string.ljust(width, ' ') + '\x00' self._display_line1_data_source, self._display_line2_data_source = DisplayDataSource( adjust_string_fn=adjust_null_terminated_string), DisplayDataSource( adjust_string_fn=adjust_null_terminated_string) self._display_line1.segment(0).set_data_source( self._display_line1_data_source) self._display_line2.segment(0).set_data_source( self._display_line2_data_source) self._display_line1_data_source.set_display_string('KeyLab') self._display_line2_data_source.set_display_string('Ableton Live') def _create_device(self): self._device = DeviceComponent( name='Device', is_enabled=False, layer=Layer(parameter_controls=(self._device_encoders)), device_selection_follows_track_selection=True) self._device.set_enabled(True) self.set_device_component(self._device) self._device_navigation = DeviceNavigationComponent( name='Device_Navigation', is_enabled=False, layer=Layer(device_nav_left_button=(self._device_left_button), device_nav_right_button=(self._device_right_button))) self._device_navigation.set_enabled(True) def _create_drums(self): self._drums = DrumRackComponent(name='Drums', is_enabled=False, layer=Layer(pads=(self._pads))) self._drums.set_enabled(True) def _create_transport(self): self._transport = TransportComponent( name='Transport', is_enabled=False, layer=Layer(play_button=(self._play_button), stop_button=(self._stop_button), record_button=(self._record_button), loop_button=(self._loop_button))) self._transport.set_enabled(True) def _create_session(self): self._session = SessionComponent( num_tracks=8, num_scenes=1, name='Session', is_enabled=False, layer=Layer( select_next_button=(self._scene_down_button), select_prev_button=(self._scene_up_button), selected_scene_launch_button=(self._scene_launch_button), stop_all_clips_button=(self._stop_all_clips_button), scene_select_encoder=(self._vertical_scroll_encoder))) self._session.set_enabled(True) def _create_session_recording(self): self._session_recording = SessionRecordingComponent( (ClipCreator()), (ViewControlComponent()), name='Session_Recording', is_enabled=False, layer=Layer(record_button=(self._session_record_button))) self._session_recording.set_enabled(True) def _create_mixer(self): self._mixer = MixerComponent( num_tracks=(self._volume_sliders.width()), name='Mixer', is_enabled=False, layer=Layer( volume_controls=(self._volume_sliders), track_select_encoder=(self._horizontal_scroll_encoder))) self._mixer.master_strip().layer = Layer( volume_control=(self._master_slider)) self._mixer.set_enabled(True) def _collect_setup_messages(self): for hardware_id, identifier in zip(ENCODER_HARDWARE_IDS, ENCODER_MSG_IDS): self._setup_hardware_encoder(hardware_id, identifier, ENCODER_CHANNEL) for hardware_id, identifier in zip(SLIDER_HARDWARE_IDS, SLIDER_MSG_IDS): self._setup_hardware_slider(hardware_id, identifier, ENCODER_CHANNEL) for hardware_id, identifier in BUTTON_HARDWARE_AND_MESSAGE_IDS.values( ): self._setup_hardware_button(hardware_id, identifier) for hardware_id, identifier in zip(PAD_HARDWARE_IDS, PAD_MSG_IDS): self._setup_hardware_pad(hardware_id, identifier) def _setup_hardware_encoder(self, hardware_id, identifier, channel=0): self._set_encoder_cc_msg_type(hardware_id, is_relative=True) self._set_identifier(hardware_id, identifier) self._set_channel(hardware_id, channel) def _setup_hardware_button(self, hardware_id, identifier, channel=0, **k): self._set_encoder_cc_msg_type(hardware_id) self._set_identifier(hardware_id, identifier) self._set_channel(hardware_id, channel) self._set_value_minimum(hardware_id) self._set_value_maximum(hardware_id) def _setup_hardware_pad(self, hardware_id, identifier, channel=PAD_CHANNEL): self._set_pad_note_msg_type(hardware_id) self._set_identifier(hardware_id, identifier) self._set_channel(hardware_id, channel) def _set_pad_note_msg_type(self, hardware_id): self._collect_setup_message(MODE_PROPERTY, hardware_id, PAD_NOTE_MODE) def _setup_hardware(self): for msg in self._messages_to_send: self._tasks.add( Task.sequence(partial(self._send_midi, msg), Task.wait(MESSAGE_DELAY))) self._messages_to_send = []
class KeyPad(ControlSurface): _encoder_range = list(range(73, 81)) _product_model_id = 101 def __init__(self, c_instance): super(KeyPad, self).__init__(c_instance) with self.component_guard(): self._create_controls() self._setup_mixer() self._setup_transport() self._setup_session() self._setup_cue_control() self.set_pad_translations(PAD_TRANSLATIONS) def _preset_message(self, send_byte): return ( 240, 38, self._product_model_id, send_byte, 17, 2, 247) def refresh_state(self): super(KeyPad, self).refresh_state() self.schedule_message(2, self._send_midi, self._preset_message(1)) def handle_sysex(self, midi_bytes): if midi_bytes != self._preset_message(2): super(KeyPad, self).handle_sysex(midi_bytes) else: list(map(lambda x: x.set_enabled(True), ( self._mixer, self._session, self._transport, self._cue_control))) def _create_controls(self): def make_controls_range(maker, label, cc_range): ccs = [(index + 1, cc) for index, cc in enumerate(cc_range)] return [maker(1, cc, label % index) for index, cc in ccs] + [maker(2, cc, label % (index + len(ccs))) for index, cc in ccs] def make_controls(maker, label, cc_offset): return make_controls_range(maker, label, range(cc_offset, cc_offset + 8)) make_non_momentary_button = partial(make_button, is_momentary=False) self._encoders = make_controls(make_encoder, 'Encoder_%d', 57) self._rotaries_a = make_controls(make_slider, 'Rotary_A%d', 89) self._rotaries_b = make_controls(make_slider, 'Rotary_B%d', 97) self._faders = make_controls(make_slider, 'Fader_%d', 0) self._mute_buttons = make_controls(make_non_momentary_button, 'Mute_%d_Button', 8) self._solo_buttons = make_controls(make_button, 'Solo_%d_Button', 24) self._arm_buttons = make_controls(make_button, 'Arm_%d_Button', 40) self._play_button = make_button(1, 105, 'Play_Button') self._stop_button = make_button(1, 106, 'Stop_Button') self._record_button = make_button(1, 107, 'Record_Button') self._encoder_pushes = make_controls_range(partial(make_button, is_momentary=False), 'Encoder_%d_Button', self._encoder_range) self._shifted_mute_buttons = make_controls(make_non_momentary_button, 'Shifted_Mute_%d_Button', 16) self._shifted_solo_buttons = make_controls(make_button, 'Shifted_Solo_%d_Button', 32) self._all_shifted_arm_buttons = make_controls(make_button, 'Shifted_Arm_%d_Button', 49) self._shifted_arm_buttons = [CombinedButtonsElement(buttons=(self._all_shifted_arm_buttons[index], self._all_shifted_arm_buttons[(index + 8)])) for index in range(8)] self._shifted_play_button = make_button(1, 108, 'Shifted_Play_Button') self._shifted_stop_button = make_button(1, 109, 'Shifted_Stop_Button') self._shifted_record_button = make_button(1, 110, 'Shifted_Record_Button') self._shifted_octave_down_button = make_button(1, 111, 'Shifted_Octave_Down_Button') self._shifted_octave_up_button = make_button(1, 112, 'Shifted_Octave_Up_Button') def _setup_mixer(self): self._mixer = MixerComponent(NUM_CHANNEL_STRIPS) self._mixer.name = 'Mixer' self._mixer.set_enabled(False) for index in range(NUM_CHANNEL_STRIPS): strip = self._mixer.channel_strip(index) strip.set_invert_mute_feedback(True) sends = ButtonMatrixElement(name=('%d_Send_Controls' % (index + 1)), rows=[ ( self._rotaries_a[index], self._rotaries_b[index])]) strip.layer = Layer(volume_control=(self._faders[index]), pan_control=(self._encoders[index]), send_controls=sends, mute_button=(self._mute_buttons[index]), solo_button=(self._solo_buttons[index]), arm_button=(self._arm_buttons[index]), select_button=(self._encoder_pushes[index])) def _setup_transport(self): self._transport = TransportComponent(name='Transport') self._transport.set_enabled(False) self._transport.layer = Layer(play_button=(self._play_button), stop_button=(self._stop_button), record_button=(self._record_button), overdub_button=(self._shifted_record_button), loop_button=(self._shifted_arm_buttons[3]), tap_tempo_button=(self._shifted_arm_buttons[4]), metronome_button=(self._shifted_arm_buttons[5]), nudge_down_button=(self._shifted_arm_buttons[6]), nudge_up_button=(self._shifted_arm_buttons[7])) def _setup_session(self): self._session = SessionComponent(NUM_CHANNEL_STRIPS, name='Session_Control') self._session.set_enabled(False) stop_buttons = ButtonMatrixElement(name='Track_Stop_Buttons', rows=[self._shifted_solo_buttons]) self._session.layer = Layer(stop_all_clips_button=(self._shifted_stop_button), stop_track_clip_buttons=stop_buttons, select_prev_button=(self._shifted_octave_down_button), select_next_button=(self._shifted_octave_up_button)) self._session.selected_scene().name = 'Selected_Scene_Control' self._session.selected_scene().layer = Layer(launch_button=(self._shifted_play_button)) for index in range(NUM_CHANNEL_STRIPS): slot = self._session.selected_scene().clip_slot(index) slot.layer = Layer(launch_button=(self._shifted_mute_buttons[index])) def _setup_cue_control(self): self._cue_control = CuePointControlComponent(name='Cue_Point_Control') self._cue_control.set_enabled(False) self._cue_control.layer = Layer(toggle_cue_button=(self._shifted_arm_buttons[0]), prev_cue_button=(self._shifted_arm_buttons[1]), next_cue_button=(self._shifted_arm_buttons[2]))
class Launchkey_MK2(OptimizedControlSurface): identity_request_delay = 0.5 def __init__(self, c_instance, *a, **k): (super(Launchkey_MK2, self).__init__)(a, c_instance=c_instance, **k) self._is_25_key_model = False self._is_in_control_on = True self._identity_response_pending = False with self.component_guard(): self._skin = make_skin() with inject(skin=(const(self._skin))).everywhere(): self._create_controls() self._request_task = self._tasks.add( Task.sequence(Task.wait(self.identity_request_delay), Task.run(self._send_identity_request))) self._request_task.kill() def _create_controls(self): self._encoders = ButtonMatrixElement(rows=[[ make_encoder(identifier, name=('Encoder_%d' % (index, ))) for index, identifier in enumerate(range(21, 29)) ]]) self._top_pad_row = ButtonMatrixElement(rows=[[ make_button(identifier, name=('Pad_0_%d' % (index, ))) for index, identifier in enumerate(range(96, 104)) ]]) self._bottom_pad_row_raw = [ make_button(identifier, name=('Pad_1_%d' % (index, ))) for index, identifier in enumerate(range(112, 120)) ] self._bottom_pad_row = ButtonMatrixElement( rows=[self._bottom_pad_row_raw]) self._top_launch_button = make_button(104, name='Scene_Launch_Button') self._bottom_launch_button = make_button(120, name='Stop_All_Clips_Button') self._scene_up_button = make_button(112, MIDI_CC_TYPE, name='Scene_Up_Button') self._scene_down_button = make_button(113, MIDI_CC_TYPE, name='Scene_Down_Button') self._stop_button = make_button(114, MIDI_CC_TYPE, name='Stop_Button') self._play_button = make_button(115, MIDI_CC_TYPE, name='Play_Button') self._loop_button = make_button(116, MIDI_CC_TYPE, name='Loop_Button') self._record_button = make_button(117, MIDI_CC_TYPE, name='Record_Button') self._sliders = ButtonMatrixElement(rows=[[ make_slider(identifier, name=('Slider_%d' % (index, ))) for index, identifier in enumerate(range(41, 49)) ]]) self._master_slider = make_slider(7, name='Master_Slider') self._25_key_slider = make_slider(7, name='Slider', channel=0) self._mute_buttons_raw = [ make_button(identifier, MIDI_CC_TYPE, name=('Mute_Button_%d' % (index, ))) for index, identifier in enumerate(range(51, 59)) ] self._mute_buttons = ButtonMatrixElement(rows=[self._mute_buttons_raw]) self._master_button = make_button(59, MIDI_CC_TYPE, name='Master_Button') self._track_left_button = make_button(102, MIDI_CC_TYPE, name='Track_Left_Button') self._track_right_button = make_button(103, MIDI_CC_TYPE, name='Track_Right_Button') self._device_mode_button = self._bottom_pad_row_raw[0] self._pan_mode_button = self._bottom_pad_row_raw[1] self._send_mode_buttons = dict() for index in range(consts.MAX_SENDS): setattr(self, '_send_%d_button' % (index, ), self._bottom_pad_row_raw[(index + 2)]) self._send_mode_buttons['send_%d_mode_button' % (index, )] = getattr( self, '_send_%d_button' % (index, )) self._extended_mode_button = make_button( 12, name='Dummy_Extended_Mode_Button') self._extended_mode_button.add_value_listener(nop) self._encoder_incontrol_button = make_button( 13, is_momentary=False, name='Encoder_InControl_Button') self._encoder_incontrol_button.add_value_listener(nop) self._slider_incontrol_button = make_button( 14, is_momentary=False, name='Fader_InControl_Button') self._slider_incontrol_button.add_value_listener(nop) self._pad_incontrol_button = make_button(15, is_momentary=False, name='Pad_InControl_Button') self._pad_incontrol_button.add_value_listener(self._update_pads) self._encoder_incontrol_button2 = make_button( 16, name='Encoder_InControl_Button') self._pad_in_control_status_button = make_button( 11, name='Dummy_InControl_Button') def _create_session(self): self._session = SessionComponent( name='Session', is_enabled=False, num_tracks=(self._top_pad_row.width()), num_scenes=(self._top_pad_row.height()), enable_skinning=True, layer=Layer(clip_launch_buttons=(self._top_pad_row), scene_launch_buttons=ButtonMatrixElement( rows=[[self._top_launch_button]]), stop_track_clip_buttons=(self._bottom_pad_row), stop_all_clips_button=(self._bottom_launch_button))) self._session.set_rgb_mode(LIVE_COLORS_TO_MIDI_VALUES, RGB_COLOR_TABLE) self._session.set_mixer(self._mixer) self._session.set_enabled(True) def _setup_navigation(self): self._session_navigation = SessionNavigationComponent( is_enabled=False, name='Session_Navigation', layer=Layer(next_track_button=(self._track_right_button), prev_track_button=(self._track_left_button), next_scene_button=(self._scene_down_button), prev_scene_button=(self._scene_up_button))) self._session_navigation.set_enabled(True) def _create_transport(self): self._transport = TransportComponent( is_enabled=False, name='Transport', layer=Layer(play_button=(self._play_button), stop_button=(self._stop_button), loop_button=(self._loop_button), record_button=(self._record_button))) self._transport.set_enabled(True) 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_device(self): self._device = DeviceComponent( name='Device', is_enabled=False, device_selection_follows_track_selection=True) self.set_device_component(self._device) self._device.set_enabled(True) def _create_background(self): self._background = BackgroundComponent(name='BackgroundComponent') 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 range(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 _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('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( 'session_mode', [partial(self._toggle_in_control, False), session_control]) self._mode_selector.layer = Layer( mode_selection_button=(self._encoder_incontrol_button2)) def _create_in_control_status_listener(self): self._in_control_status = InControlStatusComponent( set_is_in_control_on=(self._set_is_in_control_on), is_enabled=False, layer=Layer( in_control_status_button=(self._pad_in_control_status_button))) self._in_control_status.set_enabled(True) @subject_slot('value') def _update_pads(self, value): if value: self.update() @subject_slot('return_tracks') def _on_return_tracks_changed(self): num_sends = self._mixer.num_sends for index in range(6): self._encoder_modes.set_mode_enabled( 'send_%d_mode' % (index, ), True if index < num_sends else False) def _set_send_index(self, index): self._mixer.send_index = index def _set_is_in_control_on(self, value): self._is_in_control_on = value def _toggle_in_control(self, value): if not self._is_in_control_on: self._send_midi(consts.DRUM_IN_CONTROL_ON_MESSAGE if value else consts.DRUM_IN_CONTROL_OFF_MESSAGE) def port_settings_changed(self): self._disconnect_and_unregister_all_components() self._request_task.restart() def handle_sysex(self, midi_bytes): if self._is_identity_response(midi_bytes): product_id_bytes = self._extract_product_id_bytes(midi_bytes) if self._is_identity_response_valid(product_id_bytes): self._set_model_type(product_id_bytes) self._request_task.kill() if self._identity_response_pending: self.on_identified() self._identity_response_pending = False else: self.log_message( 'MIDI device responded with wrong product id (%s).' % (str(product_id_bytes), )) else: super(Launchkey_MK2, self).handle_sysex(midi_bytes) def _extract_product_id_bytes(self, midi_bytes): return midi_bytes[5:] def _is_identity_response(self, midi_bytes): return midi_bytes[3:5] == (6, 2) def _is_identity_response_valid(self, product_id_bytes): return product_id_bytes[: 3] == consts.PRODUCT_ID_BYTE_PREFIX and product_id_bytes[ 3] in consts.PRODUCT_ID_BYTES def _set_model_type(self, product_id_bytes): self._is_25_key_model = product_id_bytes[ 3] == consts.LAUNCHKEY_25_ID_BYTE def _send_identity_request(self): self._identity_response_pending = True self._send_midi(consts.IDENTITY_REQUEST) def on_identified(self): self._extended_mode_button.turn_on() with self.component_guard(): self._create_mixer() self._create_session() self._setup_navigation() self._create_transport() self._create_device() self._create_background() self._create_encoder_modes() self._create_mode_selector() self._create_in_control_status_listener() self._on_return_tracks_changed.subject = self.song() self._on_return_tracks_changed() self._mode_selector.selected_mode = 'session_mode' self.update() def disconnect(self): self._extended_mode_button.turn_off() super(Launchkey_MK2, self).disconnect()
class Roland_A_PRO(ControlSurface): def __init__(self, *a, **k): (super(Roland_A_PRO, self).__init__)(*a, **k) with self.component_guard(): self._create_controls() self._create_transport() self._create_mixer() self._create_device() self._create_drums() self._create_modes() def _create_controls(self): self._encoders = ButtonMatrixElement(rows=[ [EncoderElement(MIDI_CC_TYPE, 0, identifier, (Live.MidiMap.MapMode.absolute), name=('Encoder_%d' % index)) for index, identifier in enumerate(ENCODER_IDS)]]) self._master_encoder = EncoderElement(MIDI_CC_TYPE, 0, 10, (Live.MidiMap.MapMode.absolute), name='Master_Encoder') self._sliders = ButtonMatrixElement(rows=[ [SliderElement(MIDI_CC_TYPE, 0, identifier, name=('Slider_%d' % index)) for index, identifier in enumerate(SLIDER_IDS)]]) self._master_slider = SliderElement(MIDI_CC_TYPE, 0, 7, name='Master_Slider') self._play_button = ButtonElement(True, MIDI_CC_TYPE, 0, 26) self._stop_button = ButtonElement(True, MIDI_CC_TYPE, 0, 25) self._record_button = ButtonElement(True, MIDI_CC_TYPE, 0, 28) self._forward_button = ButtonElement(True, MIDI_CC_TYPE, 0, 24) self._backward_button = ButtonElement(True, MIDI_CC_TYPE, 0, 21) self._ff_button = ButtonElement(True, MIDI_CC_TYPE, 0, 23) self._rw_button = ButtonElement(True, MIDI_CC_TYPE, 0, 22) self._device_mode_button = ButtonElement(True, MIDI_CC_TYPE, 0, 80) self._pan_mode_button = ButtonElement(True, MIDI_CC_TYPE, 0, 81) self._send_a_mode_button = ButtonElement(True, MIDI_CC_TYPE, 0, 82) self._send_b_mode_button = ButtonElement(True, MIDI_CC_TYPE, 0, 83) self._pads = ButtonMatrixElement(rows=[[ButtonElement(True, MIDI_NOTE_TYPE, 0, identifier) for identifier in row] for row in PAD_ROWS]) def _create_transport(self): self._transport = TransportComponent(name='Transport', is_enabled=False, layer=Layer(play_button=(self._play_button), stop_button=(self._stop_button), record_button=(self._record_button))) self._transport.set_enabled(True) def _create_mixer(self): mixer_size = self._sliders.width() self._mixer = MixerComponent(mixer_size, name='Mixer', is_enabled=False, layer=Layer(volume_controls=(self._sliders), prehear_volume_control=(self._master_encoder))) self._mixer.master_strip().layer = Layer(volume_control=(self._master_slider)) self._mixer.set_enabled(True) def _create_device(self): self._device = DeviceComponent(device_selection_follows_track_selection=True) self._device_navigation = DeviceNavigationComponent() self._device.set_enabled(True) self._device_navigation.set_enabled(True) self.set_device_component(self._device) def _create_drums(self): self._drums = DrumRackComponent(name='Drum_Rack', is_enabled=False, layer=Layer(pads=(self._pads))) self._drums.set_enabled(True) 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('device_mode', [device_layer_mode, device_navigation_layer_mode]) self._encoder_modes.add_mode('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('send_a_mode', [send_layer_mode, partial(self._set_send_index, 0)]) self._encoder_modes.add_mode('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 = 'device_mode' self._encoder_modes.set_enabled(True) def _set_send_index(self, index): self._mixer.send_index = index
class BeatStep(ArturiaControlSurface): def __init__(self, *a, **k): (super(BeatStep, self).__init__)(*a, **k) self._skin = Skin(Colors) with self.component_guard(): self._create_controls() self._create_device() self._create_session() self._create_mixer() self._create_transport() def _create_controls(self): self._device_encoders = ButtonMatrixElement(rows=[[EncoderElement(MIDI_CC_TYPE, 0, identifier, (Live.MidiMap.MapMode.relative_smooth_two_compliment), name=('Encoder_%d_%d' % (column_index, row_index))) for column_index, identifier in enumerate(row)] for row_index, row in enumerate(( ENCODER_MSG_IDS[:4], ENCODER_MSG_IDS[8:12]))]) self._horizontal_scroll_encoder = EncoderElement(MIDI_CC_TYPE, 0, 75, (Live.MidiMap.MapMode.relative_smooth_two_compliment), name='Horizontal_Scroll_Encoder') self._vertical_scroll_encoder = EncoderElement(MIDI_CC_TYPE, 0, 72, (Live.MidiMap.MapMode.relative_smooth_two_compliment), name='Vertical_Scroll_Encoder') self._volume_encoder = EncoderElement(MIDI_CC_TYPE, 0, 91, (Live.MidiMap.MapMode.relative_smooth_two_compliment), name='Volume_Encoder') self._pan_encoder = EncoderElement(MIDI_CC_TYPE, 0, 17, (Live.MidiMap.MapMode.relative_smooth_two_compliment), name='Pan_Encoder') self._send_a_encoder = EncoderElement(MIDI_CC_TYPE, 0, 77, (Live.MidiMap.MapMode.relative_smooth_two_compliment), name='Send_A_Encoder') self._send_b_encoder = EncoderElement(MIDI_CC_TYPE, 0, 93, (Live.MidiMap.MapMode.relative_smooth_two_compliment), name='Send_B_Encoder') self._send_encoders = ButtonMatrixElement(rows=[ [ self._send_a_encoder, self._send_b_encoder]]) self._return_a_encoder = EncoderElement(MIDI_CC_TYPE, 0, 73, (Live.MidiMap.MapMode.relative_smooth_two_compliment), name='Return_A_Encoder') self._return_b_encoder = EncoderElement(MIDI_CC_TYPE, 0, 79, (Live.MidiMap.MapMode.relative_smooth_two_compliment), name='Return_B_Encoder') self._return_encoders = ButtonMatrixElement(rows=[ [ self._return_a_encoder, self._return_b_encoder]]) self._pads = ButtonMatrixElement(rows=[[ButtonElement(True, MIDI_NOTE_TYPE, PAD_CHANNEL, identifier, name=('Pad_%d_%d' % (col_index, row_index)), skin=(self._skin)) for col_index, identifier in enumerate(row)] for row_index, row in enumerate(PAD_MSG_IDS)]) self._stop_button = ButtonElement(True, MIDI_CC_TYPE, 0, 1, name='Stop_Button') self._play_button = ButtonElement(True, MIDI_CC_TYPE, 0, 2, name='Play_Button') def _create_device(self): self._device = DeviceComponent(name='Device', is_enabled=False, layer=Layer(parameter_controls=(self._device_encoders)), device_selection_follows_track_selection=True) self._device.set_enabled(True) self.set_device_component(self._device) def _create_session(self): self._session = SessionComponent(name='Session', is_enabled=False, num_tracks=(self._pads.width()), num_scenes=(self._pads.height()), enable_skinning=True, layer=Layer(clip_launch_buttons=(self._pads), scene_select_control=(self._vertical_scroll_encoder))) self._session.set_enabled(True) def _create_mixer(self): self._mixer = MixerComponent(name='Mixer', is_enabled=False, num_returns=2, layer=Layer(track_select_encoder=(self._horizontal_scroll_encoder), selected_track_volume_control=(self._volume_encoder), selected_track_pan_control=(self._pan_encoder), selected_track_send_controls=(self._send_encoders), return_volume_controls=(self._return_encoders))) self._mixer.set_enabled(True) def _create_transport(self): self._transport = TransportComponent(name='Transport', is_enabled=False, layer=Layer(stop_button=(self._stop_button), play_button=(self._play_button))) self._transport.set_enabled(True) def _collect_setup_messages(self): for identifier, hardware_id in zip(ENCODER_MSG_IDS, HARDWARE_ENCODER_IDS): self._setup_hardware_encoder(hardware_id, identifier) self._setup_hardware_button(HARDWARE_STOP_BUTTON_ID, 1, msg_type='cc') self._setup_hardware_button(HARDWARE_PLAY_BUTTON_ID, 2, msg_type='cc') for hardware_id, identifier in zip(HARDWARE_PAD_IDS, chain(*PAD_MSG_IDS)): self._setup_hardware_button(hardware_id, identifier, PAD_CHANNEL, msg_type='note')