def _init_device_component(self, device_controls, bank_controls, global_channel, macro_map_mode, device_component_class):
is_momentary = True
DeviceButton = partial(ButtonElement, is_momentary, MIDI_CC_TYPE)
def make_bank_button(control, name):
return DeviceButton(global_channel, (bank_controls[control]), name=name)
if device_controls:
device = device_component_class(device_selection_follows_track_selection=True,
name='Device_Component')
layer_specs = {}
if bank_controls:
if has_specification_for('NEXTBANK', bank_controls):
layer_specs['bank_next_button'] = make_bank_button('NEXTBANK', 'Device_Next_Bank_Button')
if has_specification_for('PREVBANK', bank_controls):
layer_specs['bank_prev_button'] = make_bank_button('PREVBANK', 'Device_Previous_Bank_Button')
if has_specification_for('TOGGLELOCK', bank_controls):
layer_specs['lock_button'] = make_bank_button('TOGGLELOCK', 'Device_Lock_Button')
if has_specification_for('ONOFF', bank_controls):
layer_specs['on_off_button'] = make_bank_button('ONOFF', 'Device_On_Off_Button')
bank_buttons_raw = []
for index in range(8):
key = 'BANK{}'.format(index + 1)
if key in list(bank_controls.keys()):
control_info = bank_controls[key]
channel = global_channel
cc = control_info
if isinstance(control_info, (tuple, list)):
cc = control_info[0]
if is_valid_midi_channel(control_info[1]):
channel = control_info[1]
if is_valid_midi_identifier(cc):
if is_valid_midi_channel(channel):
name = 'Device_Bank_{}_Button'.format(index)
bank_buttons_raw.append(DeviceButton(channel, cc, name=name))
if len(bank_buttons_raw) > 0:
layer_specs['bank_buttons'] = ButtonMatrixElement(rows=[
bank_buttons_raw],
name='Device_Bank_Buttons')
parameter_encoders_raw = []
for index, control_info in enumerate(device_controls):
channel = global_channel
cc = control_info
if isinstance(control_info, (tuple, list)):
cc = control_info[0]
if is_valid_midi_channel(control_info[1]):
channel = control_info[1]
if is_valid_midi_identifier(cc):
if is_valid_midi_channel(channel):
name = 'Device_Parameter_%d_Control' % index
parameter_encoders_raw.append(EncoderElement(MIDI_CC_TYPE,
channel, cc, macro_map_mode, name=name))
if len(parameter_encoders_raw) > 0:
layer_specs['parameter_controls'] = ButtonMatrixElement(rows=[
parameter_encoders_raw],
name='Device_Parameter_Controls')
device.layer = Layer(**layer_specs)
self.set_device_component(device)
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 _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_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_controls(self):
make_on_off_button = partial(make_button, skin=(self._default_skin))
make_color_button = partial(make_button, skin=(self._color_skin))
make_stop_button = partial(make_button, skin=(self._stop_button_skin))
self._shift_button = make_button(0,
98, resource_type=SharedResource, name='Shift_Button')
self._parameter_knobs = [make_knob(0, (index + 48), name=('Parameter_Knob_%d' % (index + 1))) for index in range(self.SESSION_WIDTH)]
self._select_buttons = [make_stop_button(0, (64 + index), name=('Track_Select_%d' % (index + 1))) for index in range(self.SESSION_WIDTH)]
self._up_button = self.make_shifted_button(self._select_buttons[0])
self._down_button = self.make_shifted_button(self._select_buttons[1])
self._left_button = self.make_shifted_button(self._select_buttons[2])
self._right_button = self.make_shifted_button(self._select_buttons[3])
self._volume_button = self.make_shifted_button(self._select_buttons[4])
self._pan_button = self.make_shifted_button(self._select_buttons[5])
self._send_button = self.make_shifted_button(self._select_buttons[6])
self._device_button = self.make_shifted_button(self._select_buttons[7])
if self.HAS_TRANSPORT:
self._play_button = make_on_off_button(0, 91, name='Play_Button')
self._record_button = make_on_off_button(0, 93, name='Record_Button')
def matrix_note(x, y):
return x + self.SESSION_WIDTH * (self.SESSION_HEIGHT - y - 1)
self._matrix_buttons = [[make_color_button(0, (matrix_note(track, scene)), name=('%d_Clip_%d_Button' % (track, scene))) for track in range(self.SESSION_WIDTH)] for scene in range(self.SESSION_HEIGHT)]
self._session_matrix = ButtonMatrixElement(name='Button_Matrix',
rows=(self._matrix_buttons))
self._scene_launch_buttons = [make_color_button(0, (index + 82), name=('Scene_Launch_%d' % (index + 1))) for index in range(self.SESSION_HEIGHT)]
self._stop_button = self.make_shifted_button(self._scene_launch_buttons[0])
self._solo_button = self.make_shifted_button(self._scene_launch_buttons[1])
self._arm_button = self.make_shifted_button(self._scene_launch_buttons[2])
self._mute_button = self.make_shifted_button(self._scene_launch_buttons[3])
self._select_button = self.make_shifted_button(self._scene_launch_buttons[4])
self._stop_all_button = self._make_stop_all_button()
def add_matrix(self, name, element_factory, channel, numbers,
midi_message_type):
def one_dimensional_name(base_name, x, _y):
return '%s_%d' % (base_name, x)
def two_dimensional_name(base_name, x, y):
return '%s_%d_%d' % (base_name, x, y)
name_factory = two_dimensional_name if len(
numbers) > 1 else one_dimensional_name
elements = []
id_dict = {}
for row, identifiers in enumerate(numbers):
element_row = []
for column, identifier in enumerate(identifiers):
element_row.append(
element_factory(name_factory(name, column, row), channel,
identifier, midi_message_type))
id_dict[identifier] = (column, row)
elements.append(element_row)
self['%s_Raw' % name] = elements
self['%s_Ids' % name] = id_dict
self[name] = ButtonMatrixElement(rows=elements, name=name)
def _create_controls(self):
self._create_pads()
self._encoders = ButtonMatrixElement(rows=[[
make_encoder(identifier, 0, 'Encoder_%d' % index)
for index, identifier in enumerate(range(22, 30))
]])
self._sliders = ButtonMatrixElement(rows=[[
make_slider(identifier, 0, 'Slider_%d' % index)
for index, identifier in enumerate(range(12, 20))
]])
self._control_buttons = ButtonMatrixElement(rows=[[
make_button(identifier, 0, 'Control_Button_%d' % index)
for index, identifier in enumerate(range(32, 40))
]])
self._play_button = make_button(118, 0, 'Play_Button')
self._stop_button = make_button(117, 0, 'Stop_Button')
self._record_button = make_button(119, 0, 'Record_Button')
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_controls(self):
super(MPD226, self)._create_controls()
self._encoders = ButtonMatrixElement(rows=[[
make_encoder(identifier, 0 if index < 4 else 1, 'Encoder_%d' %
index)
for index, identifier in zip(range(8), cycle(range(22, 26)))
]])
self._sliders = ButtonMatrixElement(rows=[[
make_slider(identifier, 0 if index < 4 else 1, 'Slider_%d' % index)
for index, identifier in zip(range(8), cycle(range(12, 16)))
]])
self._control_buttons = ButtonMatrixElement(rows=[[
make_button(identifier, 0 if index < 4 else 1,
'Control_Button_%d' % index)
for index, identifier in zip(range(8), cycle(range(32, 36)))
]])
self._play_button = make_button(118, 0, 'Play_Button')
self._stop_button = make_button(117, 0, 'Stop_Button')
self._record_button = make_button(119, 0, 'Record_Button')
def _set_up_session(self, mode_selector):
is_momentary = True
self._session = MaschineSessionComponent()
self._session.set_color_manager(mode_selector.get_color_manager())
self.nav_buttons = (self.create_gated_button(92, COLOR_HUE_NAV),
self.create_gated_button(81, COLOR_HUE_NAV),
self.create_gated_button(93, COLOR_HUE_NAV),
self.create_gated_button(91, COLOR_HUE_NAV))
self._session.set_scene_bank_buttons(self.nav_buttons[0],
self.nav_buttons[1])
self._session.set_track_bank_buttons(self.nav_buttons[2],
self.nav_buttons[3])
track_stop_buttons = [
StateButton(is_momentary, MIDI_CC_TYPE, BASIC_CHANNEL,
index + STOP_CC_OFF) for index in range(4)
]
self._session.set_stop_track_clip_buttons(tuple(track_stop_buttons))
self._matrix = []
self._bmatrix = ButtonMatrixElement()
for scene_index in range(4):
button_row = []
for track_index in range(4):
button = self.create_pad_button(scene_index, track_index,
mode_selector)
button_row.append(button)
self._matrix.append(tuple(button_row))
self._bmatrix.add_row(tuple(button_row))
self._session.set_matrix(self._matrix)
for button, (track_index, scene_index) in self._bmatrix.iterbuttons():
if button:
scene = self._session.scene(scene_index)
clip_slot = scene.clip_slot(track_index)
clip_slot.set_launch_button(button)
clip_slot.set_triggered_to_play_value(1)
clip_slot.set_triggered_to_record_value(1)
clip_slot.set_started_value(1)
clip_slot.set_recording_value(1)
clip_slot.set_stopped_value(1)
self._session._link()
def _init_session(self):
make_button = partial(make_launch_control_button, channel=9)
make_encoder = partial(make_launch_control_encoder, channel=9)
bottom_encoders, top_encoders = make_all_encoders(
'Session_Mixer', make_encoder)
pan_volume_layer = Layer(
volume_controls=ButtonMatrixElement(rows=[bottom_encoders]),
pan_controls=ButtonMatrixElement(rows=[top_encoders]))
self._session_mixer = SpecialMixerComponent(8, Layer(),
pan_volume_layer, Layer())
self._session_mixer.set_enabled(False)
self._session_mixer.name = 'Session_Mixer'
clip_launch_buttons = [
make_button(identifier, ('Clip_Launch_Button_' + str(i)),
is_pad=True)
for i, identifier in enumerate(pad_identifiers)
]
self._session = SpecialSessionComponent(num_tracks=8,
num_scenes=0,
name='Session')
self._session.set_enabled(False)
self._session.set_mixer(self._session_mixer)
self._session_layer = Layer(
track_bank_left_button=(make_button(116,
'Track_Bank_Left_Button')),
track_bank_right_button=(make_button(117,
'Track_Bank_Right_Button')),
select_prev_button=(make_button(114, 'Scene_Bank_Up_Button')),
select_next_button=(make_button(115, 'Scene_Bank_Down_Button')),
clip_launch_buttons=ButtonMatrixElement(
rows=[clip_launch_buttons]))
scene = self._session.selected_scene()
for index in range(8):
clip_slot = scene.clip_slot(index)
clip_slot.set_triggered_to_play_value(Colors.GREEN_BLINK)
clip_slot.set_triggered_to_record_value(Colors.RED_BLINK)
clip_slot.set_stopped_value(Colors.AMBER_FULL)
clip_slot.set_started_value(Colors.GREEN_FULL)
clip_slot.set_recording_value(Colors.RED_FULL)
clip_slot.name = 'Selected_Clip_Slot_' + str(index)
self._on_track_offset.subject = self._session
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 _init_mixer(self):
make_button = partial(make_launch_control_button, channel=8)
make_encoder = partial(make_launch_control_encoder, channel=8)
bottom_encoders, top_encoders = make_all_encoders(
'Mixer', make_encoder)
pan_volume_layer = Layer(
volume_controls=ButtonMatrixElement(rows=[bottom_encoders]),
pan_controls=ButtonMatrixElement(rows=[top_encoders]))
sends_layer = Layer(sends_controls=ButtonMatrixElement(
rows=[bottom_encoders, top_encoders]))
modes_layer = Layer(pan_volume_button=(make_button(
114, 'Pan_Volume_Mode_Button')),
sends_button=(make_button(115,
'Sends_Mode_Button')))
self._mixer = SpecialMixerComponent(8, modes_layer, pan_volume_layer,
sends_layer)
self._mixer.set_enabled(False)
self._mixer.name = 'Mixer'
self._mixer.selected_strip().name = 'Selected_Channel_Strip'
self._mixer.master_strip().name = 'Master_Channel_Strip'
self._mixer_track_nav_layer = Layer(
track_bank_left_button=(make_button(116,
'Mixer_Track_Left_Button')),
track_bank_right_button=(make_button(117,
'Mixer_Track_Right_Button')))
for index in range(8):
strip = self._mixer.channel_strip(index)
strip.name = 'Channel_Strip_' + str(index)
strip.empty_color = Colors.LED_OFF
strip.set_invert_mute_feedback(True)
mute_button = make_button((pad_identifiers[index]),
('Track_Mute_Button_' + str(index)),
is_pad=True)
mute_button.set_on_off_values(Colors.AMBER_FULL,
Colors.AMBER_THIRD)
strip.set_mute_button(mute_button)
self._on_selected_send_index.subject = self._mixer
self._on_selected_mixer_mode.subject = self._mixer
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 _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 _init_device(self):
make_button = partial(make_launch_control_button, channel=10)
make_encoder = partial(make_launch_control_encoder, channel=10)
bottom_encoders, top_encoders = make_all_encoders(
'Device', make_encoder)
parameter_controls = top_encoders[:4] + bottom_encoders[:4]
bank_buttons = [
make_button(identifier, ('Device_Bank_Button_' + str(i)),
is_pad=True)
for i, identifier in enumerate(pad_identifiers)
]
for button in bank_buttons:
button.set_on_off_values(Colors.LED_ON, Colors.LED_OFF)
self._device_bank_registry = DeviceBankRegistry()
self._device = DeviceComponent(
device_bank_registry=(self._device_bank_registry),
name='Device',
device_selection_follows_track_selection=True)
self._device.set_enabled(False)
self._device.layer = Layer(
parameter_controls=ButtonMatrixElement(rows=[parameter_controls]),
bank_buttons=ButtonMatrixElement(rows=[bank_buttons]))
self.set_device_component(self._device)
self._device_navigation = DeviceNavigationComponent()
self._device_navigation.set_enabled(False)
self._device_navigation.name = 'Device_Navigation'
self._device_navigation.layer = Layer(
next_device_button=(make_button(115, 'Next_Device_Button')),
previous_device_button=(make_button(114, 'Prev_Device_Button')))
self._view_control = ViewControlComponent()
self._view_control.set_enabled(False)
self._view_control.name = 'View_Control'
self._view_control.layer = Layer(
next_track_button=(make_button(117, 'Device_Next_Track_Button')),
prev_track_button=(make_button(116, 'Device_Prev_Track_Button')))
def __init__(self, *a, **k):
(super(Alesis_V, self).__init__)(*a, **k)
with self.component_guard():
encoders = ButtonMatrixElement(rows=[[
EncoderElement(MIDI_CC_TYPE,
0, (identifier +
20), (Live.MidiMap.MapMode.absolute),
name=('Encoder_%d' % identifier))
for identifier in range(4)
]])
device = DeviceComponent(
name='Device',
is_enabled=False,
layer=Layer(parameter_controls=encoders),
device_selection_follows_track_selection=True)
device.set_enabled(True)
self.set_device_component(device)
def _create_controls(self):
super(MiniLabMk2, self)._create_controls()
self._pad_leds = ButtonMatrixElement(rows=[[
SysexValueControl(
message_prefix=(SETUP_MSG_PREFIX +
(WRITE_COMMAND, WORKING_MEMORY_ID,
COLOR_PROPERTY, column + 112 + row * 8)),
default_value=(0, ),
name=('Pad_LED_%d' % (column, ))) for column in range(8)
] for row in range(2)],
name='Pad_LED_Matrix')
self._memory_slot_selection = SysexValueControl(
message_prefix=(SETUP_MSG_PREFIX + (MEMORY_SLOT_PROPERTY, )),
name='Memory_Slot_Selection')
self._hardware_live_mode_switch = SysexValueControl(
message_prefix=LIVE_MODE_MSG_HEAD,
default_value=(OFF_VALUE, ),
name='Hardware_Live_Mode_Switch')
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 _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_controls(self):
self._sliders = make_button_row(
chain(range(19, 32, 4), range(49, 62, 4)), make_slider,
'Volume_Slider')
self._rec_arm_buttons = make_button_row(range(3, 25, 3), make_button,
'Record_Arm_Button')
self._mute_buttons = make_button_row(range(1, 23, 3), make_button,
'Mute_Button')
self._solo_buttons = make_button_row(range(2, 24, 3), make_button,
'Solo_Button')
self._send_encoders = ButtonMatrixElement(rows=[[
make_encoder(
id, 'Send_Encoder_%d' % (id_index + row_index * NUM_TRACKS))
for id_index, id in enumerate(row)
] for row_index, row in enumerate(SEND_IDS)])
self._pan_encoders = make_button_row(
chain(range(18, 31, 4), range(48, 61, 4)), make_encoder,
'Pan_Encoder')
self._bank_left_button = make_button(25, 'Bank_Left_Button')
self._bank_right_button = make_button(26, 'Bank_Right_Button')
self._solo_mode_button = make_button(27, 'Solo_Mode_Button')
self._master_slider = make_slider(62, 'Master_Slider')
def _create_controls(self):
self._aux_button = make_button('Aux_Button', 32, is_modifier=True)
self._cursor_up_button = make_button('Cursor_Up_Button', 12)
self._cursor_down_button = make_button('Cursor_Down_Button', 13)
self._modified_cursor_up_button = with_modifier(
self._cursor_up_button, self._aux_button)
self._modified_cursor_down_button = with_modifier(
self._cursor_down_button, self._aux_button)
self._start_stop_button = make_button('Start_Stop_Button', 16)
self._modified_start_stop_button = with_modifier(
self._start_stop_button, self._aux_button)
self._recall_button = make_button('Recall_Button', 17)
self._store_button = make_button('Store_Button', 18)
self._tone_filter_knobs = ButtonMatrixElement(rows=[[
make_encoder('Tone_Filter_Encoder_%d' % (col, ), identifier)
for col, identifier in enumerate(range(102, 113))
]],
name='Tone_Filter_Knobs')
step_buttons_raw = [[
make_button('Step_Button_%d' % (col, ), identifier)
for col, identifier in enumerate(range(20, 31))
]]
self._step_buttons = ButtonMatrixElement(rows=step_buttons_raw,
name='Step_Buttons')
self._modified_step_buttons = ButtonMatrixElement(
rows=(recursive_map(
partial(with_modifier, modifier=(self._aux_button)),
step_buttons_raw)),
name='Step_Buttons_With_Modifier')
self._select_buttons = ButtonMatrixElement(rows=[[
make_button('Select_Button_%d' % (col, ), identifier)
for col, identifier in enumerate(range(60, 71))
]],
name='Select_Buttons')
self._bfx_buttons = ButtonMatrixElement(rows=[[
make_button('BFX_Button_%d' % (col, ), identifier)
for col, identifier in enumerate(range(80, 91))
]],
name='BFX_Buttons')
self._mfx_buttons = ButtonMatrixElement(rows=[[
make_button('MFX_Button_%d' % (col, ), identifier)
for col, identifier in enumerate(range(100, 111))
]],
name='MFX_Buttons')
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 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 = []
def _create_controls(self):
make_on_off_button = partial(make_button, skin=(self._default_skin))
def make_color_button(*a, **k):
button = make_button(a, skin=self._color_skin, **k)
button.is_rgb = True
button.num_delayed_messages = 2
return button
def make_matrix_button(track, scene):
return make_color_button(0,
(32 + track - NUM_TRACKS * scene),
name=('%d_Clip_%d_Button' % (track, scene)))
def make_stop_button(track):
return make_button(track,
52, name=('%d_Stop_Button' % track), skin=(self._stop_button_skin))
self._shift_button = make_button(0,
98, name='Shift_Button', resource_type=PrioritizedResource)
self._bank_button = make_on_off_button(0, 103, name='Bank_Button')
self._left_button = make_button(0, 97, name='Bank_Select_Left_Button')
self._right_button = make_button(0, 96, name='Bank_Select_Right_Button')
self._up_button = make_button(0, 94, name='Bank_Select_Up_Button')
self._down_button = make_button(0, 95, name='Bank_Select_Down_Button')
self._stop_buttons = ButtonMatrixElement(rows=[
[make_stop_button(track) for track in range(NUM_TRACKS)]])
self._stop_all_button = make_button(0, 81, name='Stop_All_Clips_Button')
self._scene_launch_buttons_raw = [make_color_button(0, (scene + 82), name=('Scene_%d_Launch_Button' % scene)) for scene in range(NUM_SCENES)]
self._scene_launch_buttons = ButtonMatrixElement(rows=[
self._scene_launch_buttons_raw])
self._matrix_rows_raw = [[make_matrix_button(track, scene) for track in range(NUM_TRACKS)] for scene in range(NUM_SCENES)]
self._session_matrix = ButtonMatrixElement(rows=(self._matrix_rows_raw))
self._pan_button = make_on_off_button(0, 87, name='Pan_Button')
self._sends_button = make_on_off_button(0,
88, name='Sends_Button', resource_type=PrioritizedResource)
self._user_button = make_on_off_button(0, 89, name='User_Button')
self._mixer_encoders = ButtonMatrixElement(rows=[
[make_ring_encoder((48 + track), (56 + track), name=('Track_Control_%d' % track)) for track in range(NUM_TRACKS)]])
self._volume_controls = ButtonMatrixElement(rows=[
[make_slider(track, 7, name=('%d_Volume_Control' % track)) for track in range(NUM_TRACKS)]])
self._master_volume_control = make_slider(0, 14, name='Master_Volume_Control')
self._prehear_control = make_encoder(0, 47, name='Prehear_Volume_Control')
self._crossfader_control = make_slider(0, 15, name='Crossfader')
self._raw_select_buttons = [make_on_off_button(channel, 51, name=('%d_Select_Button' % channel)) for channel in range(NUM_TRACKS)]
self._arm_buttons = ButtonMatrixElement(rows=[
[make_on_off_button(channel, 48, name=('%d_Arm_Button' % channel)) for channel in range(NUM_TRACKS)]])
self._solo_buttons = ButtonMatrixElement(rows=[
[make_on_off_button(channel, 49, name=('%d_Solo_Button' % channel)) for channel in range(NUM_TRACKS)]])
self._mute_buttons = ButtonMatrixElement(rows=[
[make_on_off_button(channel, 50, name=('%d_Mute_Button' % channel)) for channel in range(NUM_TRACKS)]])
self._crossfade_buttons = ButtonMatrixElement(rows=[
[make_button(channel, 66, name=('%d_Crossfade_Button' % channel), skin=(self._crossfade_button_skin)) for channel in range(NUM_TRACKS)]])
self._select_buttons = ButtonMatrixElement(rows=[self._raw_select_buttons])
self._master_select_button = make_on_off_button(channel=0,
identifier=80,
name='Master_Select_Button')
self._send_select_buttons = ButtonMatrixElement(rows=[
[ComboElement(button, modifiers=[self._sends_button]) for button in self._raw_select_buttons]])
self._quantization_buttons = ButtonMatrixElement(rows=[
[ComboElement(button, modifiers=[self._shift_button]) for button in self._raw_select_buttons]])
self._metronome_button = make_on_off_button(0, 90, name='Metronome_Button')
self._play_button = make_on_off_button(0, 91, name='Play_Button')
self._record_button = make_on_off_button(0, 93, name='Record_Button')
self._session_record_button = make_on_off_button(0,
102, name='Session_Record_Button')
self._nudge_down_button = make_button(0, 100, name='Nudge_Down_Button')
self._nudge_up_button = make_button(0, 101, name='Nudge_Up_Button')
self._tap_tempo_button = make_button(0, 99, name='Tap_Tempo_Button')
self._tempo_control = make_encoder(0, 13, name='Tempo_Control')
self._device_controls = ButtonMatrixElement(rows=[
[make_ring_encoder((16 + index), (24 + index), name=('Device_Control_%d' % index)) for index in range(8)]])
self._device_control_buttons_raw = [make_on_off_button(0, 58 + index) for index in range(8)]
self._device_bank_buttons = ButtonMatrixElement(rows=[
[DeviceBankButtonElement(button, modifiers=[self._shift_button]) for button in self._device_control_buttons_raw]])
self._device_prev_bank_button = self._device_control_buttons_raw[2]
self._device_prev_bank_button.name = 'Device_Prev_Bank_Button'
self._device_next_bank_button = self._device_control_buttons_raw[3]
self._device_next_bank_button.name = 'Device_Next_Bank_Button'
self._device_on_off_button = self._device_control_buttons_raw[4]
self._device_on_off_button.name = 'Device_On_Off_Button'
self._device_lock_button = self._device_control_buttons_raw[5]
self._device_lock_button.name = 'Device_Lock_Button'
self._prev_device_button = self._device_control_buttons_raw[0]
self._prev_device_button.name = 'Prev_Device_Button'
self._next_device_button = self._device_control_buttons_raw[1]
self._next_device_button.name = 'Next_Device_Button'
self._clip_device_button = self._device_control_buttons_raw[6]
self._clip_device_button.name = 'Clip_Device_Button'
self._detail_view_button = self._device_control_buttons_raw[7]
self._detail_view_button.name = 'Detail_View_Button'
self._foot_pedal_button = DoublePressElement(make_pedal_button(64, name='Foot_Pedal'))
self._shifted_matrix = ButtonMatrixElement(rows=(recursive_map(self._with_shift, self._matrix_rows_raw)))
self._shifted_scene_buttons = ButtonMatrixElement(rows=[
[self._with_shift(button) for button in self._scene_launch_buttons_raw]])
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_controls(self):
make_on_off_button = partial(make_button, skin=(self._default_skin))
make_color_button = partial(make_button, skin=(self._color_skin))
self._shift_button = make_button(0,
98,
resource_type=PrioritizedResource,
name='Shift_Button')
self._right_button = make_button(0,
96,
name='Bank_Select_Right_Button')
self._left_button = make_button(0, 97, name='Bank_Select_Left_Button')
self._up_button = make_button(0, 94, name='Bank_Select_Up_Button')
self._down_button = make_button(0, 95, name='Bank_Select_Down_Button')
self._session_matrix = ButtonMatrixElement(name='Button_Matrix')
self._scene_launch_buttons_raw = [
make_color_button(0, (index + 82),
name=('Scene_%d_Launch_Button' % index))
for index in range(SESSION_HEIGHT)
]
self._track_stop_buttons = [
make_color_button(index, 52, name=('Track_%d_Stop_Button' % index))
for index in range(SESSION_WIDTH)
]
self._stop_all_button = make_color_button(0,
81,
name='Stop_All_Clips_Button')
self._matrix_rows_raw = [[
make_color_button(track_index, (scene_index + 53),
name=('%d_Clip_%d_Button' %
(track_index, scene_index)))
for track_index in range(SESSION_WIDTH)
] for scene_index in range(SESSION_HEIGHT)]
for row in self._matrix_rows_raw:
self._session_matrix.add_row(row)
self._selected_slot_launch_button = make_pedal_button(
67, name='Selected_Slot_Launch_Button')
self._selected_scene_launch_button = make_pedal_button(
64, name='Selected_Scene_Launch_Button')
self._volume_controls = []
self._arm_buttons = []
self._solo_buttons = []
self._mute_buttons = []
self._select_buttons = []
for index in range(MIXER_SIZE):
self._volume_controls.append(
make_slider(index, 7, name=('%d_Volume_Control' % index)))
self._arm_buttons.append(
make_on_off_button(index, 48, name=('%d_Arm_Button' % index)))
self._solo_buttons.append(
make_on_off_button(index, 49, name=('%d_Solo_Button' % index)))
self._mute_buttons.append(
make_on_off_button(index, 50, name=('%d_Mute_Button' % index)))
self._select_buttons.append(
make_on_off_button(index,
51,
name=('%d_Select_Button' % index)))
self._crossfader_control = make_slider(0, 15, name='Crossfader')
self._master_volume_control = make_slider(0,
14,
name='Master_Volume_Control')
self._master_select_button = make_on_off_button(
0, 80, name='Master_Select_Button')
self._prehear_control = make_encoder(0,
47,
name='Prehear_Volume_Control')
self._device_bank_buttons = []
self._device_param_controls_raw = []
bank_button_labels = ('Clip_Track_Button', 'Device_On_Off_Button',
'Previous_Device_Button', 'Next_Device_Button',
'Detail_View_Button', 'Rec_Quantization_Button',
'Midi_Overdub_Button', 'Metronome_Button')
for index in range(8):
self._device_bank_buttons.append(
make_on_off_button(0, (58 + index),
name=(bank_button_labels[index])))
encoder_name = 'Device_Control_%d' % index
ringed_encoder = make_ring_encoder((16 + index), (24 + index),
name=encoder_name)
self._device_param_controls_raw.append(ringed_encoder)
self._play_button = make_button(0, 91, name='Play_Button')
self._stop_button = make_button(0, 92, name='Stop_Button')
self._record_button = make_button(0, 93, name='Record_Button')
self._nudge_up_button = make_button(0, 100, name='Nudge_Up_Button')
self._nudge_down_button = make_button(0, 101, name='Nudge_Down_Button')
self._tap_tempo_button = make_button(0, 99, name='Tap_Tempo_Button')
self._global_bank_buttons = []
self._global_param_controls = []
for index in range(8):
encoder_name = 'Track_Control_%d' % index
ringed_encoder = make_ring_encoder((48 + index), (56 + index),
name=encoder_name)
self._global_param_controls.append(ringed_encoder)
self._global_bank_buttons = [
make_on_off_button(0, (87 + index), name=name)
for index, name in enumerate(('Pan_Button', 'Send_A_Button',
'Send_B_Button', 'Send_C_Button'))
]
self._device_clip_toggle_button = self._device_bank_buttons[0]
self._device_on_off_button = self._device_bank_buttons[1]
self._detail_left_button = self._device_bank_buttons[2]
self._detail_right_button = self._device_bank_buttons[3]
self._detail_toggle_button = self._device_bank_buttons[4]
self._rec_quantization_button = self._device_bank_buttons[5]
self._overdub_button = self._device_bank_buttons[6]
self._metronome_button = self._device_bank_buttons[7]
def wrap_matrix(control_list, wrapper=nop):
return ButtonMatrixElement(rows=[list(map(wrapper, control_list))])
self._scene_launch_buttons = wrap_matrix(
self._scene_launch_buttons_raw)
self._track_stop_buttons = wrap_matrix(self._track_stop_buttons)
self._volume_controls = wrap_matrix(self._volume_controls)
self._arm_buttons = wrap_matrix(self._arm_buttons)
self._solo_buttons = wrap_matrix(self._solo_buttons)
self._mute_buttons = wrap_matrix(self._mute_buttons)
self._select_buttons = wrap_matrix(self._select_buttons)
self._device_param_controls = wrap_matrix(
self._device_param_controls_raw)
self._device_bank_buttons = wrap_matrix(
self._device_bank_buttons,
partial(DeviceBankButtonElement, modifiers=[self._shift_button]))
self._shifted_matrix = ButtonMatrixElement(
rows=(recursive_map(self._with_shift, self._matrix_rows_raw)))
self._shifted_scene_buttons = ButtonMatrixElement(rows=[[
self._with_shift(button)
for button in self._scene_launch_buttons_raw
]])
class APC40(APC, OptimizedControlSurface):
def __init__(self, *a, **k):
(super(APC40, self).__init__)(*a, **k)
self._color_skin = make_biled_skin()
self._default_skin = make_default_skin()
with self.component_guard():
self._create_controls()
self._create_session()
self._create_mixer()
self._create_device()
self._create_detail_view_control()
self._create_transport()
self._create_global_control()
self._create_fallback_control_owner()
self._session.set_mixer(self._mixer)
self.set_highlighting_session_component(self._session)
self.set_device_component(self._device)
for component in self.components:
component.set_enabled(False)
def _with_shift(self, button):
return ComboElement(button, modifiers=[self._shift_button])
def _create_controls(self):
make_on_off_button = partial(make_button, skin=(self._default_skin))
make_color_button = partial(make_button, skin=(self._color_skin))
self._shift_button = make_button(0,
98,
resource_type=PrioritizedResource,
name='Shift_Button')
self._right_button = make_button(0,
96,
name='Bank_Select_Right_Button')
self._left_button = make_button(0, 97, name='Bank_Select_Left_Button')
self._up_button = make_button(0, 94, name='Bank_Select_Up_Button')
self._down_button = make_button(0, 95, name='Bank_Select_Down_Button')
self._session_matrix = ButtonMatrixElement(name='Button_Matrix')
self._scene_launch_buttons_raw = [
make_color_button(0, (index + 82),
name=('Scene_%d_Launch_Button' % index))
for index in range(SESSION_HEIGHT)
]
self._track_stop_buttons = [
make_color_button(index, 52, name=('Track_%d_Stop_Button' % index))
for index in range(SESSION_WIDTH)
]
self._stop_all_button = make_color_button(0,
81,
name='Stop_All_Clips_Button')
self._matrix_rows_raw = [[
make_color_button(track_index, (scene_index + 53),
name=('%d_Clip_%d_Button' %
(track_index, scene_index)))
for track_index in range(SESSION_WIDTH)
] for scene_index in range(SESSION_HEIGHT)]
for row in self._matrix_rows_raw:
self._session_matrix.add_row(row)
self._selected_slot_launch_button = make_pedal_button(
67, name='Selected_Slot_Launch_Button')
self._selected_scene_launch_button = make_pedal_button(
64, name='Selected_Scene_Launch_Button')
self._volume_controls = []
self._arm_buttons = []
self._solo_buttons = []
self._mute_buttons = []
self._select_buttons = []
for index in range(MIXER_SIZE):
self._volume_controls.append(
make_slider(index, 7, name=('%d_Volume_Control' % index)))
self._arm_buttons.append(
make_on_off_button(index, 48, name=('%d_Arm_Button' % index)))
self._solo_buttons.append(
make_on_off_button(index, 49, name=('%d_Solo_Button' % index)))
self._mute_buttons.append(
make_on_off_button(index, 50, name=('%d_Mute_Button' % index)))
self._select_buttons.append(
make_on_off_button(index,
51,
name=('%d_Select_Button' % index)))
self._crossfader_control = make_slider(0, 15, name='Crossfader')
self._master_volume_control = make_slider(0,
14,
name='Master_Volume_Control')
self._master_select_button = make_on_off_button(
0, 80, name='Master_Select_Button')
self._prehear_control = make_encoder(0,
47,
name='Prehear_Volume_Control')
self._device_bank_buttons = []
self._device_param_controls_raw = []
bank_button_labels = ('Clip_Track_Button', 'Device_On_Off_Button',
'Previous_Device_Button', 'Next_Device_Button',
'Detail_View_Button', 'Rec_Quantization_Button',
'Midi_Overdub_Button', 'Metronome_Button')
for index in range(8):
self._device_bank_buttons.append(
make_on_off_button(0, (58 + index),
name=(bank_button_labels[index])))
encoder_name = 'Device_Control_%d' % index
ringed_encoder = make_ring_encoder((16 + index), (24 + index),
name=encoder_name)
self._device_param_controls_raw.append(ringed_encoder)
self._play_button = make_button(0, 91, name='Play_Button')
self._stop_button = make_button(0, 92, name='Stop_Button')
self._record_button = make_button(0, 93, name='Record_Button')
self._nudge_up_button = make_button(0, 100, name='Nudge_Up_Button')
self._nudge_down_button = make_button(0, 101, name='Nudge_Down_Button')
self._tap_tempo_button = make_button(0, 99, name='Tap_Tempo_Button')
self._global_bank_buttons = []
self._global_param_controls = []
for index in range(8):
encoder_name = 'Track_Control_%d' % index
ringed_encoder = make_ring_encoder((48 + index), (56 + index),
name=encoder_name)
self._global_param_controls.append(ringed_encoder)
self._global_bank_buttons = [
make_on_off_button(0, (87 + index), name=name)
for index, name in enumerate(('Pan_Button', 'Send_A_Button',
'Send_B_Button', 'Send_C_Button'))
]
self._device_clip_toggle_button = self._device_bank_buttons[0]
self._device_on_off_button = self._device_bank_buttons[1]
self._detail_left_button = self._device_bank_buttons[2]
self._detail_right_button = self._device_bank_buttons[3]
self._detail_toggle_button = self._device_bank_buttons[4]
self._rec_quantization_button = self._device_bank_buttons[5]
self._overdub_button = self._device_bank_buttons[6]
self._metronome_button = self._device_bank_buttons[7]
def wrap_matrix(control_list, wrapper=nop):
return ButtonMatrixElement(rows=[list(map(wrapper, control_list))])
self._scene_launch_buttons = wrap_matrix(
self._scene_launch_buttons_raw)
self._track_stop_buttons = wrap_matrix(self._track_stop_buttons)
self._volume_controls = wrap_matrix(self._volume_controls)
self._arm_buttons = wrap_matrix(self._arm_buttons)
self._solo_buttons = wrap_matrix(self._solo_buttons)
self._mute_buttons = wrap_matrix(self._mute_buttons)
self._select_buttons = wrap_matrix(self._select_buttons)
self._device_param_controls = wrap_matrix(
self._device_param_controls_raw)
self._device_bank_buttons = wrap_matrix(
self._device_bank_buttons,
partial(DeviceBankButtonElement, modifiers=[self._shift_button]))
self._shifted_matrix = ButtonMatrixElement(
rows=(recursive_map(self._with_shift, self._matrix_rows_raw)))
self._shifted_scene_buttons = ButtonMatrixElement(rows=[[
self._with_shift(button)
for button in self._scene_launch_buttons_raw
]])
def _create_session(self):
self._session = SessionComponent(
SESSION_WIDTH,
SESSION_HEIGHT,
auto_name=True,
enable_skinning=True,
is_enabled=False,
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),
stop_all_clips_button=(self._stop_all_button),
stop_track_clip_buttons=(self._track_stop_buttons),
scene_launch_buttons=(self._scene_launch_buttons),
clip_launch_buttons=(self._session_matrix),
slot_launch_button=(self._selected_slot_launch_button),
selected_scene_launch_button=(
self._selected_scene_launch_button)))
self._session_zoom = SessionZoomingComponent(
(self._session),
name='Session_Overview',
enable_skinning=True,
is_enabled=False,
layer=Layer(button_matrix=(self._shifted_matrix),
nav_up_button=(self._with_shift(self._up_button)),
nav_down_button=(self._with_shift(self._down_button)),
nav_left_button=(self._with_shift(self._left_button)),
nav_right_button=(self._with_shift(
self._right_button)),
scene_bank_buttons=(self._shifted_scene_buttons)))
def _create_mixer(self):
self._mixer = MixerComponent(
MIXER_SIZE,
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),
track_select_buttons=(self._select_buttons),
shift_button=(self._shift_button),
crossfader_control=(self._crossfader_control),
prehear_volume_control=(self._prehear_control)))
self._mixer.master_strip().layer = Layer(
volume_control=(self._master_volume_control),
select_button=(self._master_select_button))
def _create_device(self):
self._device = DeviceComponent(
name='Device_Component',
is_enabled=False,
layer=Layer(bank_buttons=(self._device_bank_buttons),
on_off_button=(self._device_on_off_button)),
use_fake_banks=True,
device_selection_follows_track_selection=True)
ChannelTranslationSelector(8, name='Control_Translations')
self._device.set_parameter_controls(
tuple(self._device_param_controls_raw))
def _create_detail_view_control(self):
self._detail_view_toggler = DetailViewCntrlComponent(
name='Detail_View_Control',
is_enabled=False,
layer=Layer(
device_clip_toggle_button=(self._device_clip_toggle_button),
detail_toggle_button=(self._detail_toggle_button),
device_nav_left_button=(self._detail_left_button),
device_nav_right_button=(self._detail_right_button)))
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),
nudge_up_button=(self._nudge_up_button),
nudge_down_button=(self._nudge_down_button),
tap_tempo_button=(self._tap_tempo_button),
quant_toggle_button=(self._rec_quantization_button),
overdub_button=(self._overdub_button),
metronome_button=(self._metronome_button)))
self._bank_button_translator = ChannelTranslationSelector(
name='Bank_Button_Translations', is_enabled=False)
def _create_global_control(self):
def set_pan_controls():
for index, control in enumerate(self._global_param_controls):
self._mixer.channel_strip(index).set_pan_control(control)
self._mixer.channel_strip(index).set_send_controls(
(None, None, None))
control.set_channel(0)
def set_send_controls(send_index):
for index, control in enumerate(self._global_param_controls):
self._mixer.channel_strip(index).set_pan_control(None)
send_controls = [None] * 3
send_controls[send_index] = control
self._mixer.channel_strip(index).set_send_controls(
send_controls)
control.set_channel(send_index + 1)
encoder_modes = ModesComponent(name='Track_Control_Modes',
is_enabled=False)
encoder_modes.add_mode('pan', [set_pan_controls])
encoder_modes.add_mode('send_a', [partial(set_send_controls, 0)])
encoder_modes.add_mode('send_b', [partial(set_send_controls, 1)])
encoder_modes.add_mode('send_c', [partial(set_send_controls, 2)])
encoder_modes.selected_mode = 'pan'
encoder_modes.layer = Layer(
pan_button=(self._global_bank_buttons[0]),
send_a_button=(self._global_bank_buttons[1]),
send_b_button=(self._global_bank_buttons[2]),
send_c_button=(self._global_bank_buttons[3]))
self._translation_selector = ChannelTranslationSelector(
name='Global_Translations')
def _create_fallback_control_owner(self):
self.register_disconnectable(
SimpleLayerOwner(
layer=Layer(_matrix=(self._session_matrix),
priority=FALLBACK_CONTROL_OWNER_PRIORITY)))
def get_matrix_button(self, column, row):
return self._matrix_rows_raw[row][column]
def _product_model_id_byte(self):
return 115
def wrap_matrix(control_list, wrapper=nop):
return ButtonMatrixElement(rows=[list(map(wrapper, control_list))])
def make_button_row(identifier_sequence, element_factory, name):
return ButtonMatrixElement(rows=[[element_factory(identifier, name + '_%d' % index)] for index, identifier in enumerate(identifier_sequence)])
