def __init__(self, *a, **k):
(super(MPK261, self).__init__)(*a, **k)
with self.component_guard():
midimap = MidiMap()
drum_rack = DrumRackComponent(
name='Drum_Rack',
is_enabled=False,
layer=Layer(pads=(midimap['Drum_Pads'])))
drum_rack.set_enabled(True)
transport = TransportComponent(
name='Transport',
is_enabled=False,
layer=Layer(play_button=(midimap['Play']),
record_button=(midimap['Record']),
stop_button=(midimap['Stop']),
seek_forward_button=(midimap['Forward']),
seek_backward_button=(midimap['Backward']),
loop_button=(midimap['Loop'])))
transport.set_enabled(True)
mixer_size = len(midimap['Sliders'])
mixer = MixerComponent(mixer_size,
name='Mixer',
is_enabled=False,
layer=Layer(
volume_controls=(midimap['Sliders']),
pan_controls=(midimap['Encoders']),
arm_buttons=(midimap['Arm_Buttons'])))
mixer.set_enabled(True)
def _create_mixer(self):
mixer = MixerComponent(NUM_TRACKS, is_enabled=True, auto_name=True)
mixer.layer = Layer(track_select_buttons=(self._select_buttons),
send_controls=(self._send_encoders),
next_sends_button=(self._down_button),
prev_sends_button=(self._up_button),
pan_controls=(self._pan_device_encoders),
volume_controls=(self._volume_faders),
send_lights=(self._send_encoder_lights),
pan_lights=(self._pan_device_encoder_lights))
mixer.on_send_index_changed = partial(
self._show_controlled_sends_message, mixer)
for channel_strip in map(mixer.channel_strip, range(NUM_TRACKS)):
channel_strip.empty_color = 'Mixer.NoTrack'
mixer_modes = ModesComponent()
mixer_modes.add_mode(
'mute',
[AddLayerMode(mixer, Layer(mute_buttons=(self._state_buttons)))])
mixer_modes.add_mode(
'solo',
[AddLayerMode(mixer, Layer(solo_buttons=(self._state_buttons)))])
mixer_modes.add_mode(
'arm',
[AddLayerMode(mixer, Layer(arm_buttons=(self._state_buttons)))])
mixer_modes.layer = Layer(mute_button=(self._mute_mode_button),
solo_button=(self._solo_mode_button),
arm_button=(self._arm_mode_button))
mixer_modes.selected_mode = 'mute'
return mixer
def _create_session(self):
self._session = SessionComponent(
NUM_TRACKS,
NUM_SCENES,
auto_name=True,
is_enabled=False,
enable_skinning=True,
layer=Layer(
track_bank_left_button=(self._midimap['Arrow_Left_Button']),
track_bank_right_button=(self._midimap['Arrow_Right_Button']),
scene_bank_up_button=(self._midimap['Arrow_Up_Button']),
scene_bank_down_button=(self._midimap['Arrow_Down_Button'])))
self._session.set_enabled(True)
self._session.set_rgb_mode(LIVE_COLORS_TO_MIDI_VALUES, RGB_COLOR_TABLE)
for scene_index in range(NUM_SCENES):
scene = self._session.scene(scene_index)
scene.layer = Layer(
select_button=(self._midimap['Shift_Button']),
delete_button=(self._midimap['Delete_Button']),
duplicate_button=(self._midimap['Duplicate_Button']))
for track_index in range(NUM_TRACKS):
slot = scene.clip_slot(track_index)
slot.layer = Layer(
select_button=(self._midimap['Shift_Button']),
delete_button=(self._midimap['Delete_Button']),
duplicate_button=(self._midimap['Duplicate_Button']),
double_loop_button=(self._midimap['Double_Loop_Button']),
quantize_button=(self._midimap['Quantize_Button']))
self._session_zoom = SessionZoomingComponent((self._session),
name='Session_Overview',
is_enabled=True,
enable_skinning=True)
def _create_device_mode(self):
device_mode_scene_launch_translation = self._create_translation(
'Device_Mode_Scene_Launch_Translation', consts.DEVICE_MAP_CHANNEL,
Layer(scene_launch_buttons=(
self._midimap['Scene_Launch_Button_Matrix'])))
device_layer_mode = LayerMode(
(self._device),
layer=Layer(
parameter_controls=(self._midimap['Slider_Button_Matrix'])))
device_nav_layer_mode = LayerMode(
(self._device_navigation),
layer=Layer(
device_nav_left_button=(self._midimap['Arrow_Left_Button']),
device_nav_right_button=(self._midimap['Arrow_Right_Button'])))
device_background_layer_mode = LayerMode(
(self._device_background),
layer=Layer(
arrow_up_button=(self._midimap['Arrow_Up_Button']),
arrow_down_button=(self._midimap['Arrow_Down_Button'])))
self._modes.add_mode('device_mode', [
partial(self._layout_setup, consts.FADER_LAYOUT_SYSEX_BYTE),
self._device, device_layer_mode, device_nav_layer_mode,
device_background_layer_mode, self._clip_actions_component,
self._clip_delete_layer_mode, device_mode_scene_launch_translation,
self._show_playing_clip, self._set_clip_actions_type
],
behaviour=(ReenterBehaviour(
self.toggle_detail_view)))
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 __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_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 __init__(self, *a, **k):
(super(MPK225, self).__init__)(*a, **k)
with self.component_guard():
midimap = MidiMap()
drum_rack = DrumRackComponent(
name='Drum_Rack',
is_enabled=False,
layer=Layer(pads=(midimap['Drum_Pads'])))
drum_rack.set_enabled(True)
transport = TransportComponent(
name='Transport',
is_enabled=False,
layer=Layer(play_button=(midimap['Play']),
record_button=(midimap['Record']),
stop_button=(midimap['Stop']),
seek_forward_button=(midimap['Forward']),
seek_backward_button=(midimap['Backward']),
loop_button=(midimap['Loop'])))
transport.set_enabled(True)
device = DeviceComponent(
name='Device',
is_enabled=False,
layer=Layer(parameter_controls=(midimap['Encoders'])),
device_selection_follows_track_selection=True)
device.set_enabled(True)
self.set_device_component(device)
def _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_note_modes(self):
note_mode_matrix_translation = self._create_translation(
'Note_Mode_Matrix_Translation', (consts.CHROM_MAP_CHANNEL),
Layer(button_matrix=(self._midimap['Main_Button_Matrix']),
note_button_matrix=(self._midimap['Note_Button_Matrix']),
drum_matrix=(self._midimap['Drum_Button_Matrix']),
mixer_button_matrix=(self._midimap['Mixer_Button_Matrix'])),
should_enable=False)
note_mode_scene_launch_translation = self._create_translation(
'Note_Mode_Scene_Launch_Translation', consts.CHROM_MAP_CHANNEL,
Layer(scene_launch_buttons=(
self._midimap['Scene_Launch_Button_Matrix'])))
scale_setup_mode_button_lighting = LedLightingComponent(
name='LED_Lighting_Component',
is_enabled=False,
layer=Layer(button=(self._midimap.with_shift('Note_Mode_Button'))))
drum_mode_note_matrix_translation = self._create_translation(
'Drum_Mode_Note_Button_Translation',
0,
Layer(note_button_matrix=(self._midimap['Note_Button_Matrix'])),
should_enable=False,
should_reset=False)
drum_group_layer_mode = LayerMode(
(self._drum_group),
layer=Layer(
scroll_up_button=(self._midimap['Arrow_Left_Button']),
scroll_down_button=(self._midimap['Arrow_Right_Button']),
scroll_page_up_button=(self._midimap['Arrow_Up_Button']),
scroll_page_down_button=(self._midimap['Arrow_Down_Button']),
drum_matrix=(self._midimap['Drum_Button_Matrix']),
select_button=(self._midimap['Shift_Button']),
delete_button=(self._midimap['Delete_Button'])))
self._note_modes = SpecialModesComponent(name='Note_Modes')
self._note_modes.add_mode('chromatic_mode', [
partial(self._layout_setup, consts.NOTE_LAYOUT_SYSEX_BYTE),
self._clip_delete_layer_mode, note_mode_matrix_translation,
scale_setup_mode_button_lighting
])
self._note_modes.add_mode('drum_mode', [
partial(self._layout_setup,
consts.DRUM_LAYOUT_SYSEX_BYTE), self._setup_drum_group,
drum_group_layer_mode, drum_mode_note_matrix_translation
])
self._note_modes.add_mode('audio_mode', [
partial(self._layout_setup, consts.AUDIO_LAYOUT_SYSEX_BYTE),
self._clip_delete_layer_mode
])
self._note_modes.set_enabled(False)
self._modes.add_mode('note_mode', [
note_mode_scene_launch_translation, self._note_modes,
self._select_note_mode, self._select_target_track,
self._clip_actions_component, self._show_playing_clip,
self._set_clip_actions_type
],
behaviour=(ReenterBehaviour(
self.toggle_detail_view)))
self._session_record.set_modes_component(self._modes)
self._session_record.set_note_mode_name('note_mode')
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_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 _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_step_button_modes(self):
matrix_modes = ModesComponent(name='Step_Button_Modes')
clip_mode = AddLayerMode(
self._session,
Layer(clip_launch_buttons=(self._step_buttons),
stop_track_clip_buttons=(self._modified_step_buttons)))
scene_mode = AddLayerMode(
self._session, Layer(scene_launch_buttons=(self._step_buttons)))
matrix_modes.add_mode('clip', clip_mode)
matrix_modes.add_mode('scene', scene_mode)
matrix_modes.layer = Layer(clip_button=(self._recall_button),
scene_button=(self._store_button))
matrix_modes.selected_mode = 'clip'
return matrix_modes
def _create_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_modes(self):
self._modes = ModesComponent(name='Launchpad_Modes', is_enabled=False)
self._session_layer_mode = AddLayerMode(
self._session,
Layer(scene_launch_buttons=(
self._midimap['Scene_Launch_Button_Matrix']),
clip_launch_buttons=(self._midimap['Main_Button_Matrix']),
delete_button=(self._midimap['Delete_Button']),
duplicate_button=(self._midimap['Duplicate_Button']),
double_button=(self._midimap['Double_Loop_Button']),
quantize_button=(self._midimap['Quantize_Button'])))
action_button_background = BackgroundComponent(name='No_Op_Buttons')
self._action_button_background_layer_mode = LayerMode(
action_button_background,
Layer(delete_button=(self._midimap['Delete_Button']),
quantize_button=(self._midimap['Quantize_Button']),
duplicate_button=(self._midimap['Duplicate_Button']),
double_button=(self._midimap['Double_Loop_Button'])))
self._clip_delete_layer_mode = AddLayerMode(
(self._clip_actions_component),
layer=Layer(delete_button=(self._midimap['Delete_Button'])))
self._create_session_zooming_modes()
self._create_session_mode()
self._create_note_modes()
self._create_device_mode()
self._create_user_mode()
self._create_record_arm_mode()
self._create_track_select_mode()
self._create_mute_mode()
self._create_solo_mode()
self._create_volume_mode()
self._create_pan_mode()
self._create_sends_mode()
self._create_stop_clips_mode()
self._modes.layer = Layer(
session_mode_button=(self._midimap['Session_Mode_Button']),
note_mode_button=(self._midimap['Note_Mode_Button']),
device_mode_button=(self._midimap['Device_Mode_Button']),
user_mode_button=(self._midimap['User_Mode_Button']),
record_arm_mode_button=(self._midimap['Record_Arm_Mode_Button']),
track_select_mode_button=(
self._midimap['Track_Select_Mode_Button']),
mute_mode_button=(self._midimap['Mute_Mode_Button']),
solo_mode_button=(self._midimap['Solo_Mode_Button']),
volume_mode_button=(self._midimap['Volume_Mode_Button']),
pan_mode_button=(self._midimap['Pan_Mode_Button']),
sends_mode_button=(self._midimap['Sends_Mode_Button']),
stop_clip_mode_button=(self._midimap['Stop_Clip_Mode_Button']))
self._modes.selected_mode = 'session_mode'
self._on_layout_changed.subject = self._modes
def _create_mixer(self):
self._mixer = MixerComponent(
num_tracks=NUM_TRACKS,
is_enabled=False,
invert_mute_feedback=True,
layer=Layer(volume_controls=(self._sliders),
pan_controls=(self._pan_encoders),
send_controls=(self._send_encoders),
bank_down_button=(self._bank_left_button),
bank_up_button=(self._bank_right_button),
arm_buttons=(self._rec_arm_buttons),
solo_buttons=(self._solo_buttons),
mute_buttons=(self._mute_buttons)))
self._mixer.master_strip().layer = Layer(
volume_control=(self._master_slider))
def _create_background(self):
self._modifier_background_component = ModifierBackgroundComponent(
name='Background_Component',
is_enabled=False,
layer=Layer(shift_button=(self._midimap['Shift_Button'])))
self._shifted_background = BackgroundComponent(
name='No_Op_Shifted_Buttons',
is_enabled=False,
layer=Layer(
click_bitton=(self._midimap.with_shift('Click_Button')),
delete_button=(self._midimap.with_shift('Delete_Button')),
duplicate_button=(
self._midimap.with_shift('Duplicate_Button')),
double_button=(self._midimap.with_shift('Double_Loop_Button')),
session_record_button=(
self._midimap.with_shift('Session_Record_Button'))))
def _create_transport(self):
transport = TransportComponent(
play_toggle_model_transform=(lambda v: v))
transport.layer = Layer(
record_button=(self._modified_start_stop_button),
play_button=(self._start_stop_button))
return transport
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)
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_recording(self):
self._session_record = SpecialSessionRecordingComponent(
(self._target_track_component),
name='Session_Recording',
is_enabled=False,
layer=Layer(
record_button=(self._midimap['Session_Record_Button'])))
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 _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_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_actions(self):
self._clip_actions_component = ClipActionsComponent(
(self._target_track_component), (self._actions_component),
name='Clip_Actions',
is_enabled=False,
layer=Layer(duplicate_button=(self._midimap['Duplicate_Button']),
double_button=(self._midimap['Double_Loop_Button']),
quantize_button=(self._midimap['Quantize_Button'])))
def _create_session(self):
session = NotifyingSessionComponent(NUM_TRACKS,
NUM_SCENES,
enable_skinning=True,
auto_name=True)
session.layer = Layer(scene_bank_down_button=(self._cursor_up_button),
scene_bank_up_button=(self._cursor_down_button))
return session
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_view_control(self):
self._view_control = DetailViewCntrlComponent(name='View_Control',
is_enabled=False,
layer=Layer(device_nav_left_button=(self._prev_device_button),
device_nav_right_button=(self._next_device_button),
device_clip_toggle_button=(self._clip_device_button),
detail_toggle_button=(self._detail_view_button)))
self._view_control.device_clip_toggle_button.pressed_color = 'DefaultButton.On'
def _create_mixer(self):
self._mixer = MixerComponent(NUM_TRACKS,
auto_name=True,
is_enabled=False,
invert_mute_feedback=True,
layer=Layer(volume_controls=(self._volume_controls),
arm_buttons=(self._arm_buttons),
solo_buttons=(self._solo_buttons),
mute_buttons=(self._mute_buttons),
shift_button=(self._shift_button),
track_select_buttons=(self._select_buttons),
prehear_volume_control=(self._prehear_control),
crossfader_control=(self._crossfader_control),
crossfade_buttons=(self._crossfade_buttons)))
self._mixer.master_strip().layer = Layer(volume_control=(self._master_volume_control),
select_button=(self._master_select_button))
self._encoder_mode = ModesComponent(name='Encoder_Mode', is_enabled=False)
self._encoder_mode.default_behaviour = ImmediateBehaviour()
self._encoder_mode.add_mode('pan', [AddLayerMode(self._mixer, Layer(pan_controls=(self._mixer_encoders)))])
self._encoder_mode.add_mode('sends', [
AddLayerMode(self._mixer, Layer(send_controls=(self._mixer_encoders))),
DelayMode(AddLayerMode(self._mixer, Layer(send_select_buttons=(self._send_select_buttons))))])
self._encoder_mode.add_mode('user', [AddLayerMode(self._mixer, Layer(user_controls=(self._mixer_encoders)))])
self._encoder_mode.layer = Layer(pan_button=(self._pan_button),
sends_button=(self._sends_button),
user_button=(self._user_button))
self._encoder_mode.selected_mode = 'pan'