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