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 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 Launchpad_MK2(IdentifiableControlSurface, OptimizedControlSurface): identity_request = consts.IDENTITY_REQUEST def __init__(self, c_instance, *a, **k): (super(Launchpad_MK2, self).__init__)(a, product_id_bytes=consts.PRODUCT_ID_BYTES, c_instance=c_instance, **k) self._challenge = Live.Application.get_random_int( 0, 400000000) & 2139062143 with self.component_guard(): self._skin = make_default_skin() with inject(skin=(const(self._skin))).everywhere(): self._create_controls() self._create_session() self._create_mixer() self._last_sent_layout_byte = None with inject( switch_layout=(const(self._switch_layout))).everywhere(): self._create_modes() def _create_controls(self): multi_button_channels = consts.USER_MODE_CHANNELS self._session_button_single = make_button(108, 0, 'Session_Mode_Button', msg_type=MIDI_CC_TYPE, is_modifier=True) self._session_button = FilteringMultiElement( ([self._session_button_single] + [ make_button(108, channel, msg_type=MIDI_CC_TYPE, name=('Session_Mode_Button_ch_%d' % (channel, ))) for channel in multi_button_channels ]), feedback_channels=[0]) self._user_1_button = FilteringMultiElement( [ make_button(109, channel, msg_type=MIDI_CC_TYPE, name=('User_1_Mode_Button_ch_%d' % (channel, ))) for channel in (0, ) + multi_button_channels ], feedback_channels=[0, 5, 6, 7]) self._user_2_button = FilteringMultiElement( [ make_button(110, channel, msg_type=MIDI_CC_TYPE, name=('User_2_Mode_Button_ch_%d' % (channel, ))) for channel in (0, ) + multi_button_channels ], feedback_channels=[0, 13, 14, 15]) self._mixer_button = FilteringMultiElement([ make_button(111, channel, msg_type=MIDI_CC_TYPE, name=('Mixer_Mode_Button_ch_%d' % (channel, ))) for channel in (0, ) + multi_button_channels ], feedback_channels=[0]) self._up_button = make_button(104, 0, msg_type=MIDI_CC_TYPE, name='Up_Button') self._down_button = make_button(105, 0, msg_type=MIDI_CC_TYPE, name='Down_Button') self._left_button = make_button(106, 0, msg_type=MIDI_CC_TYPE, name='Left_Button') self._right_button = make_button(107, 0, msg_type=MIDI_CC_TYPE, name='Right_Button') self._session_matrix_raw = [[ make_button((col + offset), 0, name=('Session_Matrix_Button_%d_%d' % (col, row))) for col in range(consts.SESSION_WIDTH) ] for row, offset in enumerate(range(81, 10, -10))] self._session_matrix = ButtonMatrixElement( rows=(self._session_matrix_raw), name='Session_Matrix') self._scene_launch_matrix_raw = [ make_button(identifier, 0, name=('Scene_Launch_Button_%d' % (index, ))) for index, identifier in enumerate(range(89, 18, -10)) ] self._scene_launch_matrix = ButtonMatrixElement( rows=[self._scene_launch_matrix_raw], name='Scene_Launch_Buttons') self._session_zoom_matrix = ButtonMatrixElement(rows=( recursive_map(partial(with_modifier, self._session_button_single), self._session_matrix_raw))) self._volume_reset_buttons = self._session_matrix.submatrix[:, :1] self._pan_reset_buttons = self._session_matrix.submatrix[:, 1:2] self._send_a_reset_buttons = self._session_matrix.submatrix[:, 2:3] self._send_b_reset_buttons = self._session_matrix.submatrix[:, 3:4] self._stop_clip_buttons = self._session_matrix.submatrix[:, 4:5] self._mute_buttons = self._session_matrix.submatrix[:, 5:6] self._solo_buttons = self._session_matrix.submatrix[:, 6:7] self._arm_buttons = self._session_matrix.submatrix[:, 7:] self._volume_button = self._scene_launch_matrix_raw[0] self._pan_button = self._scene_launch_matrix_raw[1] self._send_a_button = self._scene_launch_matrix_raw[2] self._send_b_button = self._scene_launch_matrix_raw[3] self._stop_button = self._scene_launch_matrix_raw[4] self._mute_button = self._scene_launch_matrix_raw[5] self._solo_button = self._scene_launch_matrix_raw[6] self._record_arm_button = self._scene_launch_matrix_raw[7] self._sliders = ButtonMatrixElement(rows=[[ SliderElement(MIDI_CC_TYPE, 0, identifier) for identifier in range(21, 29) ]]) self._create_user_controls() def _create_user_controls(self): self._user_1_matrix = ButtonMatrixElement(rows=[[ make_button(identifier, USER_1_CHANNEL, name=('User_1_Button_%d_%d' % (row_index, col_index))) for col_index, identifier in enumerate(row) ] for row_index, row in enumerate(USER_1_MATRIX_IDENTIFIERS)], name='User_1_Matrix') self._user_1_arrow_buttons = ButtonMatrixElement( rows=[[ make_button(identifier, USER_1_CHANNEL, msg_type=MIDI_CC_TYPE, name=('User_1_Arrow_Button_%d' % (index, ))) for index, identifier in enumerate(range(104, 108)) ]], name='User_1_Arrow_Buttons') self._user_1_side_buttons = ButtonMatrixElement( rows=[[ make_button(identifier, USER_1_CHANNEL, name=('User_1_Side_Button_%d' % (index, ))) ] for index, identifier in enumerate(range(100, 108))], name='User_1_Side_Buttons') self._user_2_matrix = ButtonMatrixElement(rows=[[ make_button((offset + col_index), USER_2_CHANNEL, name=('User_2_Button_%d_%d' % (col_index, row_index))) for col_index in range(8) ] for row_index, offset in enumerate(range(81, 10, -10))], name='User_2_Matrix') self._user_2_arrow_buttons = ButtonMatrixElement( rows=[[ make_button(identifier, USER_2_CHANNEL, msg_type=MIDI_CC_TYPE, name=('User_2_Arrow_Button_%d' % (index, ))) for index, identifier in enumerate(range(104, 108)) ]], name='User_2_Arrow_Buttons') self._user_2_side_buttons = ButtonMatrixElement( rows=[[ make_button(identifier, USER_2_CHANNEL, name=('User_2_Side_Button_%d' % (index, ))) ] for index, identifier in enumerate(range(89, 18, -10))], name='User_2_Side_Buttons') 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): self._mixer = MixerComponent(is_enabled=False, num_tracks=(consts.SESSION_WIDTH), invert_mute_feedback=True, enable_skinning=True, name='Mixer', is_root=True) self._session.set_mixer(self._mixer) self._mixer_home_page_layer = LayerMode( self._mixer, Layer(volume_reset_buttons=(self._volume_reset_buttons), pan_reset_buttons=(self._pan_reset_buttons), send_a_reset_buttons=(self._send_a_reset_buttons), send_b_reset_buttons=(self._send_b_reset_buttons), mute_buttons=(self._mute_buttons), solo_buttons=(self._solo_buttons), arm_buttons=(self._arm_buttons), unmute_all_button=(self._mute_button), unsolo_all_button=(self._solo_button), unarm_all_button=(self._record_arm_button))) self._mixer_volume_layer = LayerMode( self._mixer, Layer(volume_controls=(self._sliders))) self._mixer_pan_layer = LayerMode(self._mixer, Layer(pan_controls=(self._sliders))) self._mixer_send_a_layer = LayerMode( self._mixer, Layer(send_a_controls=(self._sliders))) self._mixer_send_b_layer = LayerMode( self._mixer, Layer(send_b_controls=(self._sliders))) def _create_translating_mixer_background(self, translation_channel): return TranslatingBackgroundComponent( translation_channel=translation_channel, is_enabled=False, name='Background', layer=Layer(stop_button=(self._stop_button), mute_buttons=(self._mute_button), solo_button=(self._solo_button), record_arm_button=(self._record_arm_button))) def _create_modes(self): self._modes = NotifyingModesComponent(is_root=True) self._modes.default_behaviour = mixin(SkinableBehaviourMixin, ImmediateBehaviour)() self._modes.add_mode( 'session_mode', [self._session, self._session_layer_mode], layout_byte=0, behaviour=(EnablingReenterBehaviour(self._session_zoom))) self._modes.add_mode('user_1_mode', [], layout_byte=1) self._modes.add_mode('user_2_mode', [], layout_byte=2) self._modes.add_mode('volume_mode', [ self._session, self._create_translating_mixer_background( consts.VOLUME_MODE_CHANNEL), self._mixer_volume_layer ], layout_byte=4, groups=(set('mixer'))) self._modes.add_mode('pan_mode', [ self._session, self._create_translating_mixer_background(consts.PAN_MODE_CHANNEL), self._mixer_pan_layer ], layout_byte=5, groups=(set('mixer'))) self._modes.add_mode('send_a_mode', [ self._session, self._create_translating_mixer_background( consts.SEND_A_MODE_CHANNEL), self._mixer_send_a_layer ], layout_byte=6, groups=(set('mixer'))) self._modes.add_mode('send_b_mode', [ self._session, self._create_translating_mixer_background( consts.SEND_B_MODE_CHANNEL), self._mixer_send_b_layer ], layout_byte=7, groups=(set('mixer'))) self._modes.add_mode('mixer_mode', [ self._session, self._stop_clip_layer_mode, self._mixer_home_page_layer ], layout_byte=3, groups=(set('mixer'))) self._modes.layer = Layer(session_mode_button=(self._session_button), user_1_mode_button=(self._user_1_button), user_2_mode_button=(self._user_2_button), mixer_mode_button=(self._mixer_button), volume_mode_button=(self._volume_button), pan_mode_button=(self._pan_button), send_a_mode_button=(self._send_a_button), send_b_mode_button=(self._send_b_button)) self._modes.selected_mode = 'session_mode' def _switch_layout(self, layout_byte): if layout_byte != self._last_sent_layout_byte: prefix = consts.STANDARD_SYSEX_PREFIX + consts.LAYOUT_CHANGE_BYTE self._send_midi(prefix + (layout_byte, 247)) self._clear_send_cache() self._last_sent_layout_byte = layout_byte def _clear_send_cache(self): with self.component_guard(): for control in self.controls: control.clear_send_cache() def on_identified(self): self._send_challenge() def _send_challenge(self): challenge_bytes = tuple( [self._challenge >> 8 * index & 127 for index in range(4)]) self._send_midi(consts.STANDARD_SYSEX_PREFIX + consts.CHALLENGE_RESPONSE_BYTE + challenge_bytes + (247, )) def handle_sysex(self, midi_bytes): if self._is_challenge_response(midi_bytes) and self._is_response_valid( midi_bytes): self._on_handshake_successful() else: super(Launchpad_MK2, self).handle_sysex(midi_bytes) def _is_challenge_response(self, midi_bytes): return len( midi_bytes ) == 10 and midi_bytes[:7] == consts.STANDARD_SYSEX_PREFIX + consts.CHALLENGE_RESPONSE_BYTE def _is_response_valid(self, midi_bytes): response = int(midi_bytes[7]) response += int(midi_bytes[8] << 8) return response == Live.Application.encrypt_challenge2(self._challenge) def _on_handshake_successful(self): self._modes.set_enabled(True) self._mixer.set_enabled(True) self._last_sent_layout_byte = None self._modes.send_switch_layout_message() self.set_highlighting_session_component(self._session) self.update() def disconnect(self): self._send_midi(consts.QUIT_MESSAGE) super(Launchpad_MK2, self).disconnect()
class MiniLab(ArturiaControlSurface): session_component_type = SessionComponent encoder_msg_channel = 0 encoder_msg_ids = (7, 74, 71, 76, 77, 93, 73, 75, 114, 18, 19, 16, 17, 91, 79, 72) pad_channel = 9 def __init__(self, *a, **k): (super(MiniLab, self).__init__)(*a, **k) with self.component_guard(): self._create_controls() self._create_device() self._create_session() self._create_mixer() def _create_controls(self): self._device_controls = ButtonMatrixElement(rows=[[EncoderElement(MIDI_CC_TYPE, (self.encoder_msg_channel), 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(( self.encoder_msg_ids[:4], self.encoder_msg_ids[8:12]))]) self._horizontal_scroll_encoder = EncoderElement(MIDI_CC_TYPE, (self.encoder_msg_channel), (self.encoder_msg_ids[7]), (Live.MidiMap.MapMode.relative_smooth_two_compliment), name='Horizontal_Scroll_Encoder') self._vertical_scroll_encoder = EncoderElement(MIDI_CC_TYPE, (self.encoder_msg_channel), (self.encoder_msg_ids[15]), (Live.MidiMap.MapMode.relative_smooth_two_compliment), name='Vertical_Scroll_Encoder') self._volume_encoder = EncoderElement(MIDI_CC_TYPE, (self.encoder_msg_channel), (self.encoder_msg_ids[13]), (Live.MidiMap.MapMode.relative_smooth_two_compliment), name='Volume_Encoder') self._pan_encoder = EncoderElement(MIDI_CC_TYPE, (self.encoder_msg_channel), (self.encoder_msg_ids[12]), (Live.MidiMap.MapMode.relative_smooth_two_compliment), name='Pan_Encoder') self._send_a_encoder = EncoderElement(MIDI_CC_TYPE, (self.encoder_msg_channel), (self.encoder_msg_ids[4]), (Live.MidiMap.MapMode.relative_smooth_two_compliment), name='Send_A_Encoder') self._send_b_encoder = EncoderElement(MIDI_CC_TYPE, (self.encoder_msg_channel), (self.encoder_msg_ids[5]), (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, (self.encoder_msg_channel), (self.encoder_msg_ids[6]), (Live.MidiMap.MapMode.relative_smooth_two_compliment), name='Return_A_Encoder') self._return_b_encoder = EncoderElement(MIDI_CC_TYPE, (self.encoder_msg_channel), (self.encoder_msg_ids[14]), (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, (self.pad_channel), (col + 36 + 8 * row), name=('Pad_%d_%d' % (col, row))) for col in range(8)] for row in range(2)]) def _create_device(self): self._device = DeviceComponent(name='Device', is_enabled=False, layer=Layer(parameter_controls=(self._device_controls)), device_selection_follows_track_selection=True) self._device.set_enabled(True) self.set_device_component(self._device) def _create_session(self): self._session = self.session_component_type(num_tracks=(self._pads.width()), num_scenes=(self._pads.height()), name='Session', is_enabled=False, 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 _collect_setup_messages(self): for cc_id, encoder_id in zip(self.encoder_msg_ids, HARDWARE_ENCODER_IDS): self._setup_hardware_encoder(encoder_id, cc_id, channel=(self.encoder_msg_channel)) for index, pad_id in enumerate(HARDWARE_BUTTON_IDS): self._setup_hardware_button(pad_id, index + PAD_IDENTIFIER_OFFSET, self.pad_channel)
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')