def _create_controls(self):
self.log(
'_create_controls: dynamic: ' + str(self._dynamic) +
', function: ' + str(self._enable_function), True)
if not self._dynamic:
self._track_left = 105
self._track_right = 106
self._device_toggle = 107
elif not self._enable_function:
self._device_toggle = 105
self._track_fold = 106
self._device_lock = 106
self._bank_up = 107
self._bank_down = 108
self.log('left: ' + str(self._track_left) + ', right: ' +
str(self._track_right) + ', toggle: ' +
str(self._device_toggle) + ', user_custom: ' +
str(self._user_custom))
if self._dynamic:
if self._user_custom:
self._bcr_controls.connect(self._toggle_1, self._toggle_2,
self._toggle_3, self._toggle_4)
else:
self._bcr_controls.connect()
self._modes = ModesComponent()
self._create_our_controls()
self._create_mixer()
self._create_session()
self._create_device()
self._create_transport()
def __init__(self, *a, **k):
super(OhmModHandler, self).__init__(*a, **k)
self._shift_mode = ModesComponent()
self._color_type = 'RGB'
self._shift_mode.add_mode('shift', tuple([self._enable_shift, self._disable_shift]), behaviour = CancellableBehaviourWithRelease())
self.nav_box = self.register_component(NavigationBox(self, 16, 16, 8, 8, self.set_offset))
self._mod_button = None
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 _init_matrix_modes(self):
""" Switch between Session and StepSequencer modes """
"""here we go trying to switch.... lew 05:53 21/10/17"""
self._auto_arm = AutoArmComponent(name='Auto_Arm')
self._matrix_modes = ModesComponent(name='Matrix_Modes', is_root=True)
self._matrix_modes.default_behaviour = ImmediateBehaviour()
self._matrix_modes.add_mode(
'disable',
[self._matrix_background, self._background, self._mod_background])
self._matrix_modes.add_mode('sends', self._session_mode_layers())
self._matrix_modes.add_mode('user', self._user_mode_layers())
self._matrix_modes.add_mode('user2', self._user2_mode_layers())
self._matrix_modes.add_mode('session', self._session_mode_layers())
#self._matrix_modes.add_mode('user', [self._user_modes], behaviour=CustomReenterBehaviour(on_reenter=self.switch_note_mode_layout, on_enter=self.enter_note_mode_layout))
#self._matrix_modes.add_mode('user', [self._drum_group_finder, self._view_control, self._user_modes],
# behaviour=self._auto_arm.auto_arm_restore_behaviour(ReenterBehaviour,
# on_reenter=self.switch_note_mode_layout))
self._matrix_modes.layer = Layer(session_button=self._pan_button,
sends_button=self._sends_button,
user_button=self._user_button,
user2_button=self._metronome_button)
self._on_matrix_mode_changed.subject = self._matrix_modes
self._matrix_modes.selected_mode = 'session'
def __init__(self, control_surface, drum_component=None, *a, **k):
self._control_surface = control_surface
self._drum_component = drum_component
self._implicit_arm = True
self._modes = ModesComponent(name='Instrument_Modes', is_enabled=False)
self._modes.set_enabled = self.set_enabled
self._feedback_channels = [
consts.DR_MAP_CHANNEL, consts.DR_MAP_CHANNEL + 1,
consts.DR_MAP_CHANNEL + 2, consts.DR_MAP_CHANNEL + 3,
consts.DR_MAP_CHANNEL + 4
]
self._non_feedback_channel = consts.DR_MAP_CHANNEL + 5
self._common_component = CommonModeComponent(
instrument_component=self, control_surface=self._control_surface)
self._scale_component = ScaleComponent(
control_surface=self._control_surface, enabled=True)
self._note_component = NoteComponent(
control_surface=self._control_surface,
feedback_channels=self._feedback_channels,
non_feedback_channel=self._non_feedback_channel,
get_pattern=self._scale_component.get_pattern)
super(InstrumentComponent, self).__init__(*a, **k)
def _setup_modes(self):
self._button_modes = ModesComponent(name='Button_Modes')
self._button_modes.add_mode('launcher', self._launcher)
self._button_modes.add_mode('looper', self._looper)
self._button_modes.add_mode('device', self._device_control)
self._button_modes.selected_mode = 'looper'
self._button_modes.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 set_enabled(self, enabled):
if not enabled:
self._do_implicit_arm(enabled)
ControlSurfaceComponent.set_enabled(self, enabled)
ModesComponent.set_enabled(self._modes, enabled)
if enabled:
self._do_implicit_arm(enabled)
def set_enabled(self, enabled):
if not enabled:
self._do_implicit_arm(enabled)
ControlSurfaceComponent.set_enabled(self, enabled)
ModesComponent.set_enabled(self._modes, enabled)
if enabled:
self._do_implicit_arm(enabled)
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=u'Track_Control_Modes',
is_enabled=False)
encoder_modes.add_mode(u'pan', [set_pan_controls])
encoder_modes.add_mode(u'send_a', [partial(set_send_controls, 0)])
encoder_modes.add_mode(u'send_b', [partial(set_send_controls, 1)])
encoder_modes.add_mode(u'send_c', [partial(set_send_controls, 2)])
encoder_modes.selected_mode = u'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=u'Global_Translations')
class CntrlrMonoInstrumentComponent(MonoInstrumentComponent):
def _setup_shift_mode(self):
self._shifted = False
self._shift_mode = ModesComponent()
self._shift_mode.add_mode('shift', tuple([self._enable_shift, self._disable_shift]), behaviour = ColoredCancellableBehaviourWithRelease(color = 'MonoInstrument.ShiftOn', off_color = 'MonoInstrument.ShiftOff'))
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 _setup_modes(self):
super(AumTroll, self)._setup_modes()
self._alt_shift_mode = ModesComponent()
self._alt_shift_mode.add_mode(
'alt_shift',
tuple([self._enable_alt_shift, self._disable_alt_shift]),
behaviour=CancellableBehaviourWithRelease())
self._alt_shift_mode.set_mode_button('alt_shift', self._grid[15])
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_delete_component(self):
self._delete_component = ModesComponent(name='DeleteClipComponent')
self._delete_component.add_mode('disabled', None)
self._delete_component.add_mode(
'enabled',
[DelayMode(tuple([self._delete_on, self._delete_off]), delay=1.5)])
self._delete_component.layer = Layer(
toggle_button=self._selected_scene_launch_button)
self._delete_component.selected_mode = 'disabled'
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)
return None
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)
return
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 _user2_mode_layers(self):
self._user_modes = ModesComponent(name='Instrument_Modes',
is_enabled=False)
#self._user_modes.add_mode('drums', [self._drum_modes])
self._user_modes.add_mode(
'instrument', [self._note_repeat_enabler, self._instrument])
self._user_modes.selected_mode = 'instrument'
return [self._user_modes, self._view_control,
self._matrix_background] # , self._mixer
def _create_session_mode(self):
""" Switch between Session and StepSequencer modes """
self._session_mode = ModesComponent(name='Session_Mode', is_enabled = False)
self._session_mode.default_behaviour = ImmediateBehaviour()
self._session_mode.add_mode('session', self._session_mode_layers())
self._session_mode.add_mode('session_2', self._session_mode_layers())
self._session_mode.add_mode('sequencer', (self._sequencer, self._sequencer_layer()))
self._session_mode.layer = Layer(
session_button = self._pan_button,
session_2_button = self._sends_button,
sequencer_button = self._user_button)
self._session_mode.selected_mode = "session"
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 _create_session_switcher(self):
self._session_switcher = ModesComponent(
name='SessionSwitcher') # is_enabled = False)
self._session_switcher.add_mode('session',
[self._session, self._session_zoom],
toggle_value='DefaultButton.Off')
self._session_switcher.add_mode('altsession', [
self._alt_session, self._alt_session_zoom,
tuple([self._enable_alt_session, self._disable_alt_session])
],
toggle_value='DefaultButton.On')
self._session_switcher.layer = Layer(
toggle_button=self._detail_toggle_button)
self._session_switcher.selected_mode = 'session'
def __init__(self, *a, **k):
super(PushMonomodComponent, self).__init__(*a, **k)
self._buttons = None
self._shift = None
self._is_modlocked = False
self._nav_up_button = None
self._nav_down_button = None
self._nav_right_button = None
self._nav_left_button = None
self._nav_locked = False
self.nav_buttons_layer = None
self.is_push = True
self._device_component = None
for index in range(16):
self._color_maps[index][1:8] = [3, 85, 33, 95, 5, 21, 67]
self._color_maps[index][127] = 67
self._alt_display = MonomodDisplayComponent(self, [' ', ' ', ' ', ' ', ' ', ' ', ' ', ' '], [' ', ' ', ' ', ' ', 'Display', 'Mute', 'Enable', 'Select'])
self._shift_display = MonomodDisplayComponent(self, ['ModLock', ' ', ' ', ' ', ' ', ' ', 'Channel', 'Name'], [' ', ' ', ' ', ' ', ' ', ' ', ' ', ' '])
self._shift_modes = self.register_component(ModesComponent())
self._shift_modes.add_mode('disabled', None)
self._shift_modes.add_mode('alt', self._alt_display, groups = 'alt', behaviour = ModShiftBehaviour())
self._shift_modes.add_mode('shift', self._shift_display, groups = 'shift', behaviour = ModShiftBehaviour())
self._shift_modes.selected_mode = 'disabled'
self._shift_display.set_value_string(self._is_modlocked, 0)
def _init_modes(self):
self._modes = ModesComponent()
self._modes.add_mode(
"mixer",
[
partial(self._session.set_mixer, self._mixer),
LayerMode(self._session, self._mixer_track_nav_layer),
self._mixer,
self._session,
self._show_controlled_tracks_message,
],
)
self._modes.add_mode(
"session",
[
partial(self._session.set_mixer, self._session_mixer),
LayerMode(self._session, self._session_layer),
self._session_mixer,
self._session,
self._show_controlled_tracks_message,
],
)
self._modes.add_mode("device", [self._device, self._device_navigation, self._view_control])
self._modes.add_mode("user", None)
self._modes.selected_mode = "mixer"
self._modes.layer = Layer(
mixer_button=ButtonSysexControl(Sysex.MIXER_MODE),
session_button=ButtonSysexControl(Sysex.SESSION_MODE),
device_button=ButtonSysexControl(Sysex.DEVICE_MODE),
)
def __init__(self, control_surface, drum_component=None, *a, **k):
self._control_surface = control_surface
self._drum_component = drum_component
self._implicit_arm = True
self._modes = ModesComponent(name="Instrument_Modes", is_enabled=False)
self._modes.set_enabled = self.set_enabled
self._feedback_channels = [
consts.DR_MAP_CHANNEL,
consts.DR_MAP_CHANNEL + 1,
consts.DR_MAP_CHANNEL + 2,
consts.DR_MAP_CHANNEL + 3,
consts.DR_MAP_CHANNEL + 4,
]
self._non_feedback_channel = consts.DR_MAP_CHANNEL + 5
self._common_component = CommonModeComponent(instrument_component=self, control_surface=self._control_surface)
self._scale_component = ScaleComponent(control_surface=self._control_surface, enabled=True)
self._note_component = NoteComponent(
control_surface=self._control_surface,
feedback_channels=self._feedback_channels,
non_feedback_channel=self._non_feedback_channel,
get_pattern=self._scale_component.get_pattern,
)
super(InstrumentComponent, self).__init__(*a, **k)
def _init_modes(self):
self._modes = ModesComponent()
self._modes.add_mode('mixer', [partial(self._session.set_mixer, self._mixer),
LayerMode(self._session, self._mixer_track_nav_layer),
self._mixer,
self._session,
self._show_controlled_tracks_message])
self._modes.add_mode('session', [partial(self._session.set_mixer, self._session_mixer),
LayerMode(self._session, self._session_layer),
self._session_mixer,
self._session,
self._show_controlled_tracks_message])
self._modes.add_mode('device', [self._device, self._device_navigation, self._view_control])
self._modes.add_mode('user', None)
self._modes.selected_mode = 'mixer'
self._modes.layer = Layer(mixer_button=ButtonSysexControl(Sysex.MIXER_MODE), session_button=ButtonSysexControl(Sysex.SESSION_MODE), device_button=ButtonSysexControl(Sysex.DEVICE_MODE))
def __init__(self, *a, **k):
super(InstrumentScalesComponent, self).__init__(*a, **k)
self._key_center_slots = self.register_slot_manager()
self._key_center_buttons = []
self._encoder_touch_button_slots = self.register_slot_manager()
self._encoder_touch_buttons = []
self._top_key_center_buttons = None
self._bottom_key_center_buttons = None
self._absolute_relative_button = None
self._diatonic_chromatic_button = None
table = consts.MUSICAL_MODES
self._modus_list = [
Modus(table[k], table[k + 1])
for k in xrange(0, len(consts.MUSICAL_MODES), 2)
]
self._selected_modus = 0
self._line_sources = recursive_map(DisplayDataSource,
SCALES_DISPLAY_STRINGS)
self._presets = self.register_component(InstrumentPresetsComponent())
self._presets.set_enabled(False)
self._presets_modes = self.register_component(ModesComponent())
self._presets_modes.add_mode('disabled', None)
self._presets_modes.add_mode('enabled', self._presets,
'Scales.PresetsEnabled')
self._presets_modes.selected_mode = 'disabled'
self._presets_modes.momentary_toggle = True
self._presets.selected_mode = 'scale_p4_vertical'
self._scales_info = self.register_component(ScalesInfoComponent())
self._scales_info.set_enabled(True)
self._modus_scroll = self.register_component(ScrollComponent())
self._modus_scroll.scrollable = self
self._update_data_sources()
def __init__(self, script, *a, **k):
super(MonoScaleComponent, self).__init__(*a, **k)
self._script = script
self._matrix = None
self._setup_selected_session_control()
self._touchstrip = None
self._display = MonoScaleDisplayComponent(self)
self._display.set_enabled(False)
self._scales_modes = self.register_component(ModesComponent())
self._scales_modes.add_mode('disabled', None)
self._scales_modes.add_mode('enabled', self._display, 'DefaultButton.On')
self._scales_modes.selected_mode = 'disabled'
self._offsets = [{'offset':DEFAULT_OFFSET, 'vertoffset':DEFAULT_VERTOFFSET, 'drumoffset':DEFAULT_DRUMOFFSET, 'scale':DEFAULT_SCALE, 'split':DEFAULT_SPLIT} for index in range(16)]
self._split_mode_selector = SplitModeSelector(self._split_mode_value)
self._vertical_offset_component = ScrollingOffsetComponent(self._vertical_offset_value)
self._offset_component = ScrollingOffsetComponent(self._offset_value)
self._offset_component._shifted_value = 11
self._shift_is_momentary = OFFSET_SHIFT_IS_MOMENTARY
self._scale_offset_component = ScrollingOffsetComponent(self._scale_offset_value)
self._scale_offset_component._minimum = 0
self._scale_offset_component._maximum = len(SCALES.keys())-1
def _setup_modes(self):
self._button_modes = ModesComponent(name='Button_Modes')
self._button_modes.add_mode('launcher', self._launcher)
self._button_modes.add_mode('looper', self._looper)
self._button_modes.add_mode('device', self._device_control)
self._button_modes.selected_mode = 'looper'
self._button_modes.set_enabled(True)
def __init__(self,
selection=None,
browser_component=None,
browser_mode=None,
browser_hotswap_mode=None,
insert_left=False,
*a,
**k):
super(CreateDeviceComponent, self).__init__(*a, **k)
self._selection = selection
self._add_effect_mode = BrowserAddEffectMode(
selection=selection,
browser=self.application().browser,
application_view=self.application().view,
insert_left=insert_left)
self._create_device_modes = self.register_component(ModesComponent())
self._create_device_modes.add_mode('create', [
SetAttributeMode(browser_component, 'do_load_item',
self._do_browser_load_item),
self._add_effect_mode, browser_mode,
browser_component.reset_load_memory
])
self._create_device_modes.add_mode(
'hotswap', [browser_hotswap_mode, browser_mode])
self._go_to_hotswap_task = self._tasks.add(
Task.sequence(Task.delay(1), Task.run(self._go_to_hotswap)))
self._go_to_hotswap_task.kill()
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 _user_mode_layers(self):
self._drum_group_finder = DrumGroupFinderComponent()
self._on_drum_group_changed.subject = self._drum_group_finder
self._drum_modes = ModesComponent(name='Drum_Modes', is_enabled=False)
self._drum_modes.add_mode('sequencer', self._step_sequencer)
#self._drum_modes.add_mode('64pads', self._drum_component) # added 15:18 subday 22/10/17 can maybe look into this. causes issues when trying to scroll.(drumcomp1)
self._drum_modes.selected_mode = 'sequencer'
#self._user_modes = ModesComponent(name='User_Modes', is_enabled=False)
#self._user_modes.add_mode('drums', [self._drum_modes])
#self._user_modes.add_mode('instrument', [self._note_repeat_enabler, self._instrument])
#self._user_modes.selected_mode = 'drums'
return [self._drum_modes, self._view_control,
self._matrix_background] # , self._mixer
def _setup_modes(self):
self._button_modes = ModesComponent(name='Button_Modes')
self._button_modes.add_mode('launcher', self._launcher)
self._button_modes.add_mode('looper', self._looper)
self._button_modes.add_mode('device', self._device_control)
self._button_modes.selected_mode = 'looper'
self._button_modes.layer = Layer(looper_button = self._side_buttons[0], launcher_button = self._side_buttons[1], device_button = self._side_buttons[2])
self._button_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_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 set_modes(self, sends_layer, fx1_layer, fx2_layer, fx3_layer):
if hasattr(self, '_modes'):
self._modes.disconnect()
self._modes = ModesComponent()
self._modes.add_mode('sends', [LayerMode(self, sends_layer)])
self._modes.add_mode('fx1', [LayerMode(self, fx1_layer)])
self._modes.add_mode('fx2', [LayerMode(self, fx2_layer)])
self._modes.add_mode('fx3', [LayerMode(self, fx3_layer)])
self._modes._set_selected_mode('sends')
def _init_track_modes(self):
self._track_modes = ModesComponent(name='Track_Modes', is_enabled=False)
self._track_modes.default_behaviour = ImmediateBehaviour()
self._track_modes.add_mode('pan', [AddLayerMode(self._mixer, Layer(pan_controls=self._mixer_encoders))])
self._track_modes.add_mode('send_a', [AddLayerMode(self._mixer, Layer(send_controls=self._mixer_encoders)), partial(self._mixer.set_send_button_index, 0)])
self._track_modes.add_mode('send_b', [AddLayerMode(self._mixer, Layer(send_controls=self._mixer_encoders)), partial(self._mixer.set_send_button_index, 1)])
self._track_modes.add_mode('send_c', [AddLayerMode(self._mixer, Layer(send_controls=self._mixer_encoders)), partial(self._mixer.set_send_button_index, 2)])
self._track_modes.layer = Layer(pan_button=self._pan_button, send_a_button=self._send_a_button, send_b_button=self._send_b_button, send_c_button=self._send_c_button)
self._track_modes.selected_mode = 'pan'
def _setup_modes(self):
super(AumTroll, self)._setup_modes()
self._alt_shift_mode = ModesComponent()
self._alt_shift_mode.add_mode(
"alt_shift",
tuple([self._enable_alt_shift, self._disable_alt_shift]),
behaviour=CancellableBehaviourWithRelease(),
)
self._alt_shift_mode.set_mode_button("alt_shift", self._grid[15])
def _setup_modes(self):
next_buttons = CompoundMode(self._next_a_button, self._next_a_button)
self._main_modes = ModesComponent(name='MainModes')
self._main_modes.add_mode('disabled', None)
self._main_modes.add_mode('left_session',
[self._left_session, next_buttons])
self._main_modes.add_mode('right_session',
[self._right_session, next_buttons])
self._main_modes.add_mode(
'set_session',
[self._left_set_session, self._right_set_session, next_buttons])
self._main_modes.layer = Layer(
priority=6,
left_session_button=self._crate_button[0],
right_session_button=self._crate_button[1],
set_session_button=self._crate_button[2])
self._main_modes.selected_mode = 'set_session'
self._main_modes.set_enabled(True)
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 _setup_modes(self):
next_buttons = CompoundMode(self._next_a_button, self._next_a_button)
self._main_modes = ModesComponent(name = 'MainModes')
self._main_modes.add_mode('disabled', None)
self._main_modes.add_mode('left_session', [self._left_session, next_buttons])
self._main_modes.add_mode('right_session', [self._right_session, next_buttons])
self._main_modes.add_mode('set_session', [self._left_set_session, self._right_set_session, next_buttons])
self._main_modes.layer = Layer(priority = 6, left_session_button = self._crate_button[0], right_session_button = self._crate_button[1], set_session_button = self._crate_button[2])
self._main_modes.selected_mode = 'set_session'
self._main_modes.set_enabled(True)
def _create_modes(self):
self._encoder_modes = ModesComponent()
device_layer_mode = LayerMode(self._device,
Layer(parameter_controls=self._encoders))
device_navigation_layer_mode = LayerMode(
self._device_navigation,
Layer(device_nav_right_button=self._forward_button,
device_nav_left_button=self._backward_button))
self._encoder_modes.add_mode(
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 _create_modes(self):
self._encoder_modes = ModesComponent()
device_layer_mode = LayerMode(self._device, Layer(parameter_controls=self._encoders))
device_navigation_layer_mode = LayerMode(self._device_navigation, Layer(device_nav_right_button=self._forward_button, device_nav_left_button=self._backward_button))
self._encoder_modes.add_mode('device_mode', [device_layer_mode, device_navigation_layer_mode])
self._encoder_modes.add_mode('pan_mode', AddLayerMode(self._mixer, Layer(pan_controls=self._encoders, bank_up_button=self._forward_button, bank_down_button=self._backward_button, track_up_button=self._ff_button, track_down_button=self._rw_button)))
send_layer_mode = AddLayerMode(self._mixer, Layer(send_controls=self._encoders, bank_up_button=self._forward_button, bank_down_button=self._backward_button, track_up_button=self._ff_button, track_down_button=self._rw_button))
self._encoder_modes.add_mode('send_a_mode', [send_layer_mode, partial(self._set_send_index, 0)])
self._encoder_modes.add_mode('send_b_mode', [send_layer_mode, partial(self._set_send_index, 1)])
self._encoder_modes.layer = Layer(device_mode_button=self._device_mode_button, pan_mode_button=self._pan_mode_button, send_a_mode_button=self._send_a_mode_button, send_b_mode_button=self._send_b_mode_button)
self._encoder_modes.selected_mode = 'device_mode'
self._encoder_modes.set_enabled(True)
def _setup_modes(self):
self._modes = self.register_component(ModesComponent())
self._modes.add_mode('empty', [ComponentMode(self._empty)])
self._modes.add_mode('device', [
ComponentMode(self._device_buttons),
ComponentMode(self._device),
ComponentMode(self._background)
])
self._modes.add_mode(
'menu', [ComponentMode(self._top_menu),
ComponentMode(self._menu)])
self._modes.selected_mode = 'empty'
def __init__(self, selection = None, browser_mode = None, browser_component = None, browser_hotswap_mode = None, *a, **k):
super(CreateInstrumentTrackComponent, self).__init__(*a, **k)
self._selection = selection
self._with_browser_modes = self.register_component(ModesComponent())
self._with_browser_modes.add_mode('create', [self._prepare_browser,
SetAttributeMode(self.application().browser, 'filter_type', Live.Browser.FilterType.instrument_hotswap),
SetAttributeMode(browser_component, 'do_load_item', self._do_browser_load_item),
browser_mode,
browser_component.reset_load_memory])
self._with_browser_modes.add_mode('hotswap', [browser_hotswap_mode, browser_mode])
self._go_to_hotswap_task = self._tasks.add(Task.sequence(Task.delay(1), Task.run(self._go_to_hotswap)))
self._go_to_hotswap_task.kill()
def __init__(self, num_tracks, mode_layer = None, pan_volume_layer = None, sends_layer = None, *a, **k):
super(SpecialMixerComponent, self).__init__(num_tracks, *a, **k)
self.set_enabled(False)
self._send_controls = None
self._selected_send_index = 0
self._modes = self.register_component(ModesComponent())
self._modes.add_mode('pan_volume', [LayerMode(self, pan_volume_layer)])
self._modes.add_mode('sends', [LayerMode(self, sends_layer)], behaviour=SendSelectButtonBehaviour(self))
self._modes.selected_mode = 'pan_volume'
self._modes.layer = mode_layer
self._on_visible_tracks.subject = self.song()
self._on_selected_mixer_mode.subject = self._modes
def _setup_modes(self):
main_buttons=CompoundMode(self._mixer.main_buttons_layer, self._mixer.stop_layer, self._transport, self._send_reset, self._session.nav_layer)
main_buttons_instrument=CompoundMode(self._mixer.main_buttons_layer, self._recorder, self._view_control.main_layer)
main_faders=CompoundMode(self._mixer.main_faders_layer, self._mixer.master_fader_layer)
bottom_buttons=CompoundMode(self._mixer.instrument_buttons_layer, self._recorder, self._view_control.main_layer)
self._instrument._main_modes = ModesComponent(name = 'InstrumentModes')
self._instrument._main_modes.add_mode('disabled', [main_buttons_instrument, main_faders, self._mixer.main_knobs_layer, self._device, self._session, self._recorder, self._view_control.main_layer, self._send_reset, self._session.nav_layer,])
self._instrument._main_modes.add_mode('drumpad', [self._instrument._drumpad.main_layer, main_buttons_instrument, self._send_reset, self._session.nav_layer])
self._instrument._main_modes.add_mode('drumpad_split', [self._instrument._drumpad.split_layer, self._send_reset, self._session.nav_layer])
self._instrument._main_modes.add_mode('drumpad_sequencer', [self._instrument._drumpad.sequencer_layer, bottom_buttons])
self._instrument._main_modes.add_mode('drumpad_shifted', [self._instrument._drumpad.main_layer, self._instrument.drumpad_shift_layer, main_buttons_instrument, self._recorder, self._view_control.main_layer])
self._instrument._main_modes.add_mode('drumpad_split_shifted', [self._instrument._drumpad.split_layer, self._instrument.drumpad_shift_layer, bottom_buttons, self._recorder, self._view_control.main_layer])
self._instrument._main_modes.add_mode('drumpad_sequencer_shifted', [self._instrument._drumpad.sequencer_shift_layer, self._instrument.drumpad_shift_layer, self._recorder, self._view_control.main_layer])
self._instrument._main_modes.add_mode('keypad', [self._instrument._keypad.main_layer, main_buttons_instrument, self._send_reset, self._session.nav_layer])
self._instrument._main_modes.add_mode('keypad_split', [self._instrument._keypad.split_layer, bottom_buttons, self._send_reset, self._session.nav_layer])
self._instrument._main_modes.add_mode('keypad_sequencer', [self._instrument._keypad.sequencer_layer, bottom_buttons])
self._instrument._main_modes.add_mode('keypad_shifted', [self._instrument._keypad.main_layer, self._instrument.keypad_shift_layer, main_buttons_instrument, self._recorder, self._view_control.main_layer])
self._instrument._main_modes.add_mode('keypad_split_shifted', [self._instrument._keypad.split_layer, self._instrument.keypad_shift_layer, bottom_buttons, self._recorder, self._view_control.main_layer])
self._instrument._main_modes.add_mode('keypad_sequencer_shifted', [self._instrument._keypad.sequencer_shift_layer, self._instrument.keypad_shift_layer, self._recorder, self._view_control.main_layer])
self._instrument._main_modes.add_mode('audioloop', [self._instrument.audioloop_layer, self._session, bottom_buttons, self._recorder, self._view_control.main_layer])
self._instrument.register_component(self._instrument._main_modes)
self._instrument.set_enabled(False)
self._session_modes = ModesComponent(name = 'SessionModes', is_enabled = False)
self._session_modes.add_mode('Session', [self._session])
self._session_modes.add_mode('SessionZoom', [self._session_zoom.buttons_layer], behaviour = BicoloredMomentaryBehaviour(color = 'Session.ZoomOn', off_color = 'Session.ZoomOff'))
self._session_modes.layer = Layer(priority = 4, SessionZoom_button = self._button[31])
self._session_modes.selected_mode = 'Session'
self._main_modes = ModesComponent(name = 'MainModes')
self._main_modes.add_mode('MixMode', [main_buttons, main_faders, self._mixer.main_knobs_layer, self._device, self._session_modes, self._session.nav_layer,]) # self._session.dial_nav_layer, self._mixer.dial_nav_layer, self.encoder_navigation_on])
self._main_modes.add_mode('ModSwitcher', [main_faders, self._mixer.main_knobs_layer, self._modswitcher], behaviour = DefaultedBehaviour(default_mode = 'MixMode', color = 'ModeButtons.ModSwitcher', off_color = 'ModeButtons.ModSwitcherDisabled'))
self._main_modes.add_mode('Translations', [main_faders, self._mixer.main_knobs_layer, self._translations, DelayMode(self._translations.selector_layer)], behaviour = DefaultedBehaviour(default_mode = 'MixMode', color = 'ModeButtons.Translations', off_color = 'ModeButtons.TranslationsDisabled'))
self._main_modes.add_mode('DeviceSelector', [self._device_selector, main_buttons, main_faders, self._mixer.main_knobs_layer, self._device, self._device_navigator, self._view_control.selector_layer], behaviour = ColoredCancellableBehaviourWithRelease(color = 'ModeButtons.DeviceSelector', off_color = 'ModeButtons.DeviceSelectorDisabled'))
self._main_modes.layer = Layer(priority = 4, ModSwitcher_button = self._encoder_button[0], Translations_button = self._encoder_button[3], DeviceSelector_button = self._encoder_button[2])
def _init_modes(self):
self._modes = ModesComponent(is_root=True)
self._modes.add_mode('mixer', [partial(self._session.set_mixer, self._mixer),
LayerMode(self._session, self._mixer_track_nav_layer),
self._mixer,
self._session,
self._show_controlled_tracks_message])
self._modes.add_mode('session', [partial(self._session.set_mixer, self._session_mixer),
LayerMode(self._session, self._session_layer),
self._session_mixer,
self._session,
self._show_controlled_tracks_message])
self._modes.add_mode('device', [self._device, self._device_navigation, self._view_control])
self._modes.add_mode('user', None)
self._modes.selected_mode = 'mixer'
self._modes.layer = Layer(mixer_button=ButtonSysexControl(Sysex.MIXER_MODE), session_button=ButtonSysexControl(Sysex.SESSION_MODE), device_button=ButtonSysexControl(Sysex.DEVICE_MODE))
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 __init__(self, *a, **k):
super(SpecialSessionComponent, self).__init__(*a, **k)
self._slot_launch_button = None
self._duplicate_button = None
self._duplicate, self._duplicate_modes, self._paginator = self.register_components(
DuplicateSceneComponent(self), ModesComponent(), ScrollComponent())
self._paginator.can_scroll_up = self._can_scroll_page_up
self._paginator.can_scroll_down = self._can_scroll_page_down
self._paginator.scroll_up = self._scroll_page_up
self._paginator.scroll_down = self._scroll_page_down
self._duplicate.set_enabled(False)
self._duplicate_modes.add_mode('disabled', None)
self._duplicate_modes.add_mode('enabled', self._duplicate)
self._duplicate_modes.selected_mode = 'disabled'
self._duplicate_modes.momentary_toggle = True
self._track_playing_slots = self.register_slot_manager()
self._end_initialisation()
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)
class Launchpad_Pro(IdentifiableControlSurface, OptimizedControlSurface):
def __init__(self, c_instance, *a, **k):
product_id_bytes = consts.MANUFACTURER_ID + consts.DEVICE_CODE
super(Launchpad_Pro, self).__init__(c_instance=c_instance, product_id_bytes=product_id_bytes, *a, **k)
self._challenge = Live.Application.get_random_int(0, 400000000) & 2139062143
with self.component_guard():
self._skin = make_default_skin()
with inject(skin=const(self._skin)).everywhere():
self._midimap = MidiMap()
self._target_track_component = TargetTrackComponent(name='Target_Track')
self._create_background()
self._create_global_component()
self._last_sent_mode_byte = None
with inject(layout_setup=const(self._layout_setup), should_arm=const(self._should_arm_track)).everywhere():
self._create_session()
self._create_recording()
self._create_actions()
self._create_drums()
self._create_mixer()
self._create_device()
self._create_modes()
self._create_m4l_interface()
self._on_session_record_changed.subject = self.song()
self.set_highlighting_session_component(self._session)
self.set_device_component(self._device)
self._device_selection_follows_track_selection = True
self._on_session_record_changed()
def disconnect(self):
self._send_midi(consts.TURN_OFF_LEDS)
self._send_midi(consts.QUIT_MESSAGE)
super(Launchpad_Pro, self).disconnect()
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_global_component(self):
self._actions_component = ActionsComponent(name='Global_Actions', is_enabled=False, layer=Layer(undo_button=self._midimap['Undo_Button'], redo_button=self._midimap.with_shift('Undo_Button'), metronome_button=self._midimap['Click_Button'], quantization_on_button=self._midimap.with_shift('Quantize_Button')))
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(CLIP_COLOR_TABLE, RGB_COLOR_TABLE)
SpecialClipSlotComponent.quantization_component = self._actions_component
for scene_index in xrange(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 xrange(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_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 _create_actions(self):
self._clip_actions_component = ClipActionsComponent(self._target_track_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']))
ClipActionsComponent.quantization_component = self._actions_component
def _create_drums(self):
self._drum_group_finder = DrumGroupFinderComponent(self._target_track_component, name='Drum_Group_Finder', is_enabled=False, layer=None)
self._on_drum_group_changed.subject = self._drum_group_finder
self._drum_group_finder.set_enabled(True)
self._drum_group = DrumGroupComponent(self._clip_actions_component, name='Drum_Group_Control', translation_channel=consts.DR_MAP_CHANNEL)
self._drum_group.set_enabled(True)
def _create_mixer(self):
self._mixer = SpecialMixerComponent(NUM_TRACKS, auto_name=True, is_enabled=True, invert_mute_feedback=True)
self._mixer.name = 'Mixer_Control'
self._session.set_mixer(self._mixer)
def _create_device(self):
self._device = SpecialDeviceComponent(name='Device_Control', is_enabled=False)
self._device_navigation = DeviceNavigationComponent(name='Device_Navigation')
self._device_background = BackgroundComponent(name='Device_Background_Component')
def _setup_drum_group(self):
self._drum_group.set_drum_group_device(self._drum_group_finder.drum_group)
def _create_translation(self, comp_name, channel, button_layer, should_enable = True, should_reset = True):
translation_component = TranslationComponent(name=comp_name, translated_channel=channel, should_enable=should_enable, should_reset=should_reset, is_enabled=False, layer=button_layer)
setattr(self, '_' + comp_name.lower(), translation_component)
return translation_component
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_session_zooming_modes(self):
session_zoom_layer = Layer(button_matrix=self._midimap['Main_Button_Matrix'], nav_left_button=self._midimap['Arrow_Left_Button'], nav_right_button=self._midimap['Arrow_Right_Button'], nav_up_button=self._midimap['Arrow_Up_Button'], nav_down_button=self._midimap['Arrow_Down_Button'])
session_zooming_layer_mode = LayerMode(self._session_zoom, session_zoom_layer)
self._session_zooming_manager = SessionZoomingManagerComponent(self._modes, is_enabled=False)
session_zooming_button_layer_mode = LayerMode(self._session_zooming_manager, Layer(session_zooming_button=self._midimap['Session_Mode_Button']))
self._prioritized_session_zooming_button_layer_mode = LayerMode(self._session_zooming_manager, Layer(session_zooming_button=self._midimap['Session_Mode_Button'], priority=1))
self._session_zooming_background = BackgroundComponent(name='Session_Zooming_Background')
session_zooming_background_layer_mode = LayerMode(self._session_zooming_background, Layer(scene_launch_buttons=self._midimap['Scene_Launch_Button_Matrix'], delete_button=self._midimap['Delete_Button'], quantize_button=self._midimap['Quantize_Button'], duplicate_button=self._midimap['Duplicate_Button'], double_loop_button=self._midimap['Double_Loop_Button']))
self._modes.add_mode('session_zooming_mode', [self._session_zooming_manager,
session_zooming_button_layer_mode,
session_zooming_layer_mode,
session_zooming_background_layer_mode])
self._modes.add_mode('prioritized_session_zooming_mode', [partial(self._layout_switch, consts.SESSION_LAYOUT_SYSEX_BYTE),
self._session_zooming_manager,
self._prioritized_session_zooming_button_layer_mode,
session_zooming_layer_mode,
session_zooming_background_layer_mode,
self.update])
def _create_session_mode(self):
self._modes.add_mode('session_mode', [partial(self._layout_setup, consts.SESSION_LAYOUT_SYSEX_BYTE), self._session_layer_mode, self._session.update_navigation_buttons], behaviour=CancelingReenterBehaviour('session_zooming_mode'))
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']))
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])
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_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_user_mode(self):
self._modes.add_mode('user_mode', [partial(self._layout_setup, consts.USER_LAYOUT_SYSEX_BYTE)])
def _create_record_arm_mode(self):
arm_layer_mode = LayerMode(self._mixer, layer=Layer(arm_buttons=self._midimap['Mixer_Button_Matrix']))
self._modes.add_mode('record_arm_mode', [partial(self._layout_setup, consts.SESSION_LAYOUT_SYSEX_BYTE),
self._session_layer_mode,
arm_layer_mode,
self._session_zooming_manager,
self._prioritized_session_zooming_button_layer_mode,
self._session.update_navigation_buttons], behaviour=SpecialReenterBehaviour('session_mode'))
def _create_track_select_mode(self):
track_select_layer_mode = LayerMode(self._mixer, layer=Layer(track_select_buttons=self._midimap['Mixer_Button_Matrix']))
self._modes.add_mode('track_select_mode', [partial(self._layout_setup, consts.SESSION_LAYOUT_SYSEX_BYTE),
self._session_layer_mode,
track_select_layer_mode,
self._session_zooming_manager,
self._prioritized_session_zooming_button_layer_mode,
self._session.update_navigation_buttons], behaviour=SpecialReenterBehaviour('session_mode'))
def _create_mute_mode(self):
mute_layer_mode = LayerMode(self._mixer, layer=Layer(mute_buttons=self._midimap['Mixer_Button_Matrix']))
self._modes.add_mode('mute_mode', [partial(self._layout_setup, consts.SESSION_LAYOUT_SYSEX_BYTE),
self._session_layer_mode,
mute_layer_mode,
self._session_zooming_manager,
self._prioritized_session_zooming_button_layer_mode,
self._session.update_navigation_buttons], behaviour=SpecialReenterBehaviour('session_mode'))
def _create_solo_mode(self):
solo_layer_mode = LayerMode(self._mixer, layer=Layer(solo_buttons=self._midimap['Mixer_Button_Matrix']))
self._modes.add_mode('solo_mode', [partial(self._layout_setup, consts.SESSION_LAYOUT_SYSEX_BYTE),
self._session_layer_mode,
solo_layer_mode,
self._session_zooming_manager,
self._prioritized_session_zooming_button_layer_mode,
self._session.update_navigation_buttons], behaviour=SpecialReenterBehaviour('session_mode'))
def _create_volume_mode(self):
volume_mode_scene_launch_translation = self._create_translation('Volume_Mode_Scene_Launch_Translation', consts.VOLUME_MAP_CHANNEL, Layer(scene_launch_buttons=self._midimap['Scene_Launch_Button_Matrix']))
volume_layer_mode = LayerMode(self._mixer, layer=Layer(volume_controls=self._midimap['Slider_Button_Matrix']))
self._modes.add_mode('volume_mode', [partial(self._layout_setup, consts.FADER_LAYOUT_SYSEX_BYTE),
volume_layer_mode,
self._action_button_background_layer_mode,
self._session_zooming_manager,
self._prioritized_session_zooming_button_layer_mode,
volume_mode_scene_launch_translation,
self._session.update_navigation_buttons], behaviour=SpecialReenterBehaviour('session_mode'))
def _create_pan_mode(self):
pan_mode_scene_launch_translation = self._create_translation('Pan_Mode_Scene_Launch_Translation', consts.PAN_MAP_CHANNEL, Layer(scene_launch_buttons=self._midimap['Scene_Launch_Button_Matrix']))
pan_layer_mode = LayerMode(self._mixer, layer=Layer(pan_controls=self._midimap['Slider_Button_Matrix']))
self._modes.add_mode('pan_mode', [partial(self._layout_setup, consts.FADER_LAYOUT_SYSEX_BYTE),
pan_layer_mode,
self._action_button_background_layer_mode,
self._session_zooming_manager,
self._prioritized_session_zooming_button_layer_mode,
pan_mode_scene_launch_translation,
self._session.update_navigation_buttons], behaviour=SpecialReenterBehaviour('session_mode'))
def _create_sends_mode(self):
send_layer_mode = LayerMode(self._mixer, layer=Layer(send_controls=self._midimap['Slider_Button_Matrix'], send_select_buttons=self._midimap['Scene_Launch_Button_Matrix']))
self._modes.add_mode('sends_mode', [partial(self._layout_setup, consts.FADER_LAYOUT_SYSEX_BYTE),
send_layer_mode,
self._action_button_background_layer_mode,
self._session_zooming_manager,
self._prioritized_session_zooming_button_layer_mode,
self._session.update_navigation_buttons], behaviour=SpecialReenterBehaviour('session_mode'))
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 _create_m4l_interface(self):
self._m4l_interface = M4LInterfaceComponent(controls=self.controls, component_guard=self.component_guard, priority=1)
self.get_control_names = self._m4l_interface.get_control_names
self.get_control = self._m4l_interface.get_control
self.grab_control = self._m4l_interface.grab_control
self.release_control = self._m4l_interface.release_control
def toggle_detail_view(self):
view = self.application().view
if view.is_view_visible('Detail'):
if view.is_view_visible('Detail/DeviceChain'):
view.show_view('Detail/Clip')
else:
view.show_view('Detail/DeviceChain')
@subject_slot('drum_group')
def _on_drum_group_changed(self):
if self._note_modes.selected_mode == 'drum_mode':
self._drum_group.set_drum_group_device(self._drum_group_finder.drum_group)
if self._modes.selected_mode == 'note_mode':
self._select_note_mode()
else:
self.release_controlled_track()
self._update_note_mode_button(self._drum_group_finder.drum_group is not None)
def _select_note_mode(self):
"""
Selects which note mode to use depending on the kind of
current target track and its device chain. Will also
select the target if specified.
"""
track = self._target_track_component.target_track
drum_device = self._drum_group_finder.drum_group
if track is None or track.is_foldable or track in self.song().return_tracks or track == self.song().master_track or track.is_frozen or track.has_audio_input:
self._note_modes.selected_mode = 'audio_mode'
elif drum_device:
self._note_modes.selected_mode = 'drum_mode'
else:
self._note_modes.selected_mode = 'chromatic_mode'
self._modes.update()
if self._note_modes.selected_mode == 'audio_mode':
self.release_controlled_track()
else:
self.set_controlled_track(self._target_track_component.target_track)
def _select_target_track(self):
track = self._target_track_component.target_track
if track != self.song().view.selected_track:
self.song().view.selected_track = track
def _update_note_mode_button(self, focused_track_is_drum_track):
button = self._midimap['Note_Mode_Button']
if focused_track_is_drum_track:
button.default_states = {True: 'Mode.Drum.On',
False: 'Mode.Drum.Off'}
else:
button.default_states = {True: 'Mode.Chromatic.On',
False: 'Mode.Chromatic.Off'}
button.reset_state()
self._modes.update()
def _show_playing_clip(self):
track = None
if self._use_sel_track():
track = self.song().view.selected_track
else:
track = self._target_track_component.target_track
if track in self.song().tracks:
slot_index = track.fired_slot_index
if slot_index < 0:
slot_index = track.playing_slot_index
if slot_index >= 0:
clip_slot = track.clip_slots[slot_index]
self.song().view.highlighted_clip_slot = clip_slot
def _set_clip_actions_type(self):
self._clip_actions_component.use_selected_track(self._use_sel_track())
self._clip_actions_component.update()
def _use_sel_track(self):
return self._modes.selected_mode == 'device_mode'
def _should_arm_track(self):
return self._modes.selected_mode == 'record_arm_mode'
@subject_slot('selected_mode')
def _on_layout_changed(self, mode):
if mode == 'note_mode':
self.set_controlled_track(self._target_track_component.target_track)
else:
self.release_controlled_track()
self._session_record.set_enabled(mode != 'user_mode')
@subject_slot('session_record')
def _on_session_record_changed(self):
status = self.song().session_record
feedback_color = int(self._skin['Instrument.FeedbackRecord'] if status else self._skin['Instrument.Feedback'])
self._c_instance.set_feedback_velocity(feedback_color)
def _clear_send_cache(self):
with self.component_guard():
for control in self.controls:
control.clear_send_cache()
def _update_global_components(self):
self._actions_component.update()
self._session_record.update()
self._modifier_background_component.update()
def _layout_setup(self, mode):
self._layout_switch(mode)
self._clear_send_cache()
self._update_global_components()
def _layout_switch(self, mode):
prefix = consts.SYSEX_STANDARD_PREFIX + consts.SYSEX_PARAM_BYTE_LAYOUT
suffix = consts.SYSEX_STANDARD_SUFFIX
self._send_midi(prefix + mode + suffix)
self._last_sent_mode_byte = mode
def _send_identity_request(self):
self._send_midi(consts.SYSEX_IDENTITY_REQUEST)
def on_identified(self):
self._send_challenge()
def _send_challenge(self):
challenge_bytes = []
for index in range(4):
challenge_bytes.append(self._challenge >> 8 * index & 127)
challenge = consts.CHALLENGE_PREFIX + tuple(challenge_bytes) + (247,)
self._send_midi(challenge)
def _on_handshake_successful(self):
self._do_send_midi(consts.LIVE_MODE_SWITCH_REQUEST)
with self.component_guard():
self._modes.set_enabled(True)
self._actions_component.set_enabled(True)
self._session_record.set_enabled(True)
self._modifier_background_component.set_enabled(True)
self._shifted_background.set_enabled(True)
self.release_controlled_track()
self.set_feedback_channels(consts.FEEDBACK_CHANNELS)
if self._last_sent_mode_byte is not None:
self._layout_setup(self._last_sent_mode_byte)
self.update()
def _is_challenge_response(self, midi_bytes):
return len(midi_bytes) == 10 and midi_bytes[:7] == consts.SYSEX_STANDARD_PREFIX + consts.SYSEX_CHALLENGE_RESPONSE_BYTE
def _is_response_valid(self, midi_bytes):
response = long(midi_bytes[7])
response += long(midi_bytes[8] << 8)
return response == Live.Application.encrypt_challenge2(self._challenge)
def handle_sysex(self, midi_bytes):
if len(midi_bytes) < 7:
pass
if self._is_challenge_response(midi_bytes) and self._is_response_valid(midi_bytes):
self._on_handshake_successful()
elif midi_bytes[6] in (consts.SYSEX_STATUS_BYTE_MODE, consts.SYSEX_STATUS_BYTE_LAYOUT):
pass
else:
super(Launchpad_Pro, self).handle_sysex(midi_bytes)
class APC40_MkII(APC, OptimizedControlSurface):
def __init__(self, *a, **k):
super(APC40_MkII, self).__init__(*a, **k)
self._color_skin = make_rgb_skin()
self._default_skin = make_default_skin()
self._stop_button_skin = make_stop_button_skin()
self._crossfade_button_skin = make_crossfade_button_skin()
with self.component_guard():
self._create_controls()
self._create_bank_toggle()
self._create_session()
self._create_mixer()
self._create_transport()
self._create_device()
self._create_view_control()
self._create_quantization_selection()
self._create_recording()
self._create_m4l_interface()
self._session.set_mixer(self._mixer)
self.set_highlighting_session_component(self._session)
self.set_device_component(self._device)
self._device_selection_follows_track_selection = True
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)
def make_color_button(*a, **k):
button = make_button(skin=self._color_skin, *a, **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 xrange(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 xrange(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 xrange(NUM_TRACKS) ] for scene in xrange(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 xrange(NUM_TRACKS) ]])
self._volume_controls = ButtonMatrixElement(rows=[[ make_slider(track, 7, name='%d_Volume_Control' % track) for track in xrange(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 xrange(NUM_TRACKS) ]
self._arm_buttons = ButtonMatrixElement(rows=[[ make_on_off_button(channel, 48, name='%d_Arm_Button' % channel) for channel in xrange(NUM_TRACKS) ]])
self._solo_buttons = ButtonMatrixElement(rows=[[ make_on_off_button(channel, 49, name='%d_Solo_Button' % channel) for channel in xrange(NUM_TRACKS) ]])
self._mute_buttons = ButtonMatrixElement(rows=[[ make_on_off_button(channel, 50, name='%d_Mute_Button' % channel) for channel in xrange(NUM_TRACKS) ]])
self._crossfade_buttons = ButtonMatrixElement(rows=[[ make_button(channel, 66, name='%d_Crossfade_Button' % channel, skin=self._crossfade_button_skin) for channel in xrange(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 xrange(8) ]])
self._device_control_buttons_raw = [ make_on_off_button(0, 58 + index) for index in xrange(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_bank_toggle(self):
self._bank_toggle = BankToggleComponent(is_enabled=False, layer=Layer(bank_toggle_button=self._bank_button))
def _create_session(self):
def when_bank_on(button):
return self._bank_toggle.create_toggle_element(on_control=button)
def when_bank_off(button):
return self._bank_toggle.create_toggle_element(off_control=button)
self._session = SessionComponent(NUM_TRACKS, NUM_SCENES, auto_name=True, is_enabled=False, enable_skinning=True, layer=Layer(track_bank_left_button=when_bank_off(self._left_button), track_bank_right_button=when_bank_off(self._right_button), scene_bank_up_button=when_bank_off(self._up_button), scene_bank_down_button=when_bank_off(self._down_button), page_left_button=when_bank_on(self._left_button), page_right_button=when_bank_on(self._right_button), page_up_button=when_bank_on(self._up_button), page_down_button=when_bank_on(self._down_button), stop_track_clip_buttons=self._stop_buttons, stop_all_clips_button=self._stop_all_button, scene_launch_buttons=self._scene_launch_buttons, clip_launch_buttons=self._session_matrix))
clip_color_table = colors.CLIP_COLOR_TABLE.copy()
clip_color_table[16777215] = 119
self._session.set_rgb_mode(clip_color_table, colors.RGB_COLOR_TABLE)
self._session_zoom = SessionZoomingComponent(self._session, name='Session_Overview', enable_skinning=True, is_enabled=False, layer=Layer(button_matrix=self._shifted_matrix, nav_left_button=self._with_shift(self._left_button), nav_right_button=self._with_shift(self._right_button), nav_up_button=self._with_shift(self._up_button), nav_down_button=self._with_shift(self._down_button), scene_bank_buttons=self._shifted_scene_buttons))
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_transport(self):
self._transport = TransportComponent(name='Transport', is_enabled=False, layer=Layer(shift_button=self._shift_button, play_button=self._play_button, stop_button=ComboElement(self._play_button, modifiers=[self._shift_button]), record_button=self._record_button, metronome_button=self._metronome_button, tap_tempo_button=self._tap_tempo_button, nudge_down_button=self._nudge_down_button, nudge_up_button=self._nudge_up_button, tempo_encoder=self._tempo_control), play_toggle_model_transform=lambda v: v)
def _create_device(self):
self._device = DeviceComponent(name='Device', is_enabled=False, layer=Layer(parameter_controls=self._device_controls, bank_buttons=self._device_bank_buttons, bank_prev_button=self._device_prev_bank_button, bank_next_button=self._device_next_bank_button, on_off_button=self._device_on_off_button, lock_button=self._device_lock_button))
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_quantization_selection(self):
self._quantization_selection = QuantizationComponent(name='Quantization_Selection', is_enabled=False, layer=Layer(quantization_buttons=self._quantization_buttons))
def _create_recording(self):
record_button = MultiElement(self._session_record_button, self._foot_pedal_button.single_press)
self._session_recording = SessionRecordingComponent(ClipCreator(), self._view_control, name='Session_Recording', is_enabled=False, layer=Layer(new_button=self._foot_pedal_button.double_press, record_button=record_button, _uses_foot_pedal=self._foot_pedal_button))
def _create_m4l_interface(self):
self._m4l_interface = M4LInterfaceComponent(controls=self.controls, component_guard=self.component_guard, priority=1)
self.get_control_names = self._m4l_interface.get_control_names
self.get_control = self._m4l_interface.get_control
self.grab_control = self._m4l_interface.grab_control
self.release_control = self._m4l_interface.release_control
def get_matrix_button(self, column, row):
return self._matrix_rows_raw[row][column]
def _product_model_id_byte(self):
return 41
def _setup_modswitcher(self):
self._modswitcher = ModesComponent(name = 'ModSwitcher') # is_enabled = False)
#self._modswitcher.add_mode('instrument', [self._optional_translations])
self._modswitcher.add_mode('mod', [self.modhandler, self._optional_translations])
self._modswitcher.add_mode('instrument', [self._instrument, self._instrument.shift_button_layer, self._optional_translations])
self._modswitcher.set_enabled(False)
class Cntrlr(ControlSurface):
__module__ = __name__
__doc__ = " Monomodular controller script for Livid CNTRLR "
def __init__(self, *a, **k):
super(Cntrlr, self).__init__(*a, **k)
self._version_check = 'b996'
self._host_name = 'Cntrlr'
self._color_type = 'OhmRGB'
self._client = [None for index in range(4)]
self._active_client = None
self._rgb = 0
self._timer = 0
self._touched = 0
self.flash_status = 1
self._skin = Skin(CntrlrColors)
self._device_selection_follows_track_selection = FOLLOW
with self.component_guard():
self._setup_monobridge()
self._setup_controls()
self._define_sysex()
self._setup_transport_control()
self._setup_autoarm()
self._setup_session_recording_component()
self._setup_mixer_control()
self._setup_send_resets()
self._setup_session_control()
self._setup_device_control()
self._setup_device_selector()
self._setup_translations()
self._setup_viewcontrol()
self._setup_mod()
self._setup_instrument()
self._setup_modswitcher()
self._setup_modes()
self._setup_m4l_interface()
self._on_device_changed.subject = self.song()
self.set_feedback_channels(range(14, 15))
self._main_modes.selected_mode = 'MixMode'
self.schedule_message(1, self._open_log)
def _open_log(self):
self.log_message("<<<<<<<<<<<<<<<<<<<<= " + str(self._host_name) + " " + str(self._version_check) + " log opened =>>>>>>>>>>>>>>>>>>>")
self.show_message(str(self._host_name) + ' Control Surface Loaded')
def _setup_monobridge(self):
self._monobridge = MonoBridgeElement(self)
self._monobridge.name = 'MonoBridge'
def _setup_controls(self):
is_momentary = True
self._fader = [MonoEncoderElement(MIDI_CC_TYPE, CHANNEL, CNTRLR_FADERS[index], Live.MidiMap.MapMode.absolute, 'Fader_' + str(index), index, self) for index in range(8)]
self._dial_left = [MonoEncoderElement(MIDI_CC_TYPE, CHANNEL, CNTRLR_KNOBS_LEFT[index], Live.MidiMap.MapMode.absolute, 'Dial_Left_' + str(index), CNTRLR_KNOBS_LEFT[index], self) for index in range(12)]
self._dial_right = [MonoEncoderElement(MIDI_CC_TYPE, CHANNEL, CNTRLR_KNOBS_RIGHT[index], Live.MidiMap.MapMode.absolute, 'Dial_Right_' + str(index), CNTRLR_KNOBS_RIGHT[index], self) for index in range(12)]
self._encoder = [CodecEncoderElement(MIDI_CC_TYPE, CHANNEL, CNTRLR_DIALS[index], Live.MidiMap.MapMode.absolute, 'Encoder_' + str(index), CNTRLR_DIALS[index], self) for index in range(12)]
self._encoder_button = [MonoButtonElement(is_momentary, MIDI_NOTE_TYPE, CHANNEL, CNTRLR_DIAL_BUTTONS[index], name = 'Encoder_Button_' + str(index), script = self, skin = self._skin) for index in range(12)]
self._grid = [MonoButtonElement(is_momentary, MIDI_NOTE_TYPE, CHANNEL, CNTRLR_GRID[index], name = 'Grid_' + str(index), script = self, skin = self._skin) for index in range(16)]
self._button = [MonoButtonElement(is_momentary, MIDI_NOTE_TYPE, CHANNEL, CNTRLR_BUTTONS[index], name = 'Button_' + str(index), script = self, skin = self._skin) for index in range(32)]
self._knobs = self._dial_left + self._dial_right
self._fader_matrix = ButtonMatrixElement(name = 'Fader_Matrix', rows = [self._fader])
self._matrix = ButtonMatrixElement(name = 'Matrix', rows = [self._grid[index*4:(index*4)+4] for index in range(4)])
self._knob_left_matrix = ButtonMatrixElement(name = 'Knob_Left_Matrix', rows = [self._dial_left[index*4:(index*4)+4] for index in range(3)])
self._knob_right_matrix = ButtonMatrixElement(name = 'Knob_Right_Matrix', rows = [self._dial_right[index*4:(index*4)+4] for index in range(3)])
self._dial_matrix = ButtonMatrixElement(name = 'Dial_Matrix', rows = [self._encoder[index*4:(index*4)+4] for index in range(3)])
self._dial_button_matrix = ButtonMatrixElement(name = 'Dial_Button_Matrix', rows = [self._encoder_button[index*4:(index*4)+4] for index in range(1,3)])
self._key_matrix = ButtonMatrixElement(name = 'Key_Matrix', rows = [self._button[0:16], self._button[16:32]])
self._translated_controls = self._fader + self._knobs + self._encoder[4:] + self._grid + self._button
def _define_sysex(self):
self.encoder_navigation_on = SendSysexMode(script = self, sysex = (240, 0, 1, 97, 8, 17, 15, 0, 0, 0, 0, 0, 0, 0, 247))
self.encoder_navigation_off = SendSysexMode(script = self, sysex = (240, 0, 1, 97, 8, 17, 0, 0, 0, 0, 0, 0, 0, 0, 247))
def _setup_transport_control(self):
self._transport = CntrlrTransportComponent()
self._transport.name = 'Transport'
self._transport.layer = Layer(priority = 4,
play_button = self._button[28],
record_button = self._button[30],
stop_button = self._button[29])
def _setup_autoarm(self):
self._auto_arm = AutoArmComponent(name='Auto_Arm')
self._auto_arm.can_auto_arm_track = self._can_auto_arm_track
def _setup_session_recording_component(self):
self._clip_creator = ClipCreator()
self._clip_creator.name = 'ClipCreator'
self._recorder = CntrlrSessionRecordingComponent(self._clip_creator, ViewControlComponent()) # is_enabled = False)
self._recorder.layer = Layer(priority = 4, new_button = self._button[28], record_button = self._button[29], automation_button = self._button[30])
self._recorder.set_enabled(False)
def _setup_mixer_control(self):
is_momentary = True
self._num_tracks = (4)
self._mixer = MixerComponent(num_tracks = 4, num_returns = 2, name = 'Mixer', auto_name = True, invert_mute_feedback = True)
self._mixer.set_track_offset(0)
if self._mixer.channel_strip(0)._track:
self.song().view.selected_track = self._mixer.channel_strip(0)._track
self._mixer.main_faders_layer = AddLayerMode(self._mixer, Layer(priority = 4,
volume_controls = self._fader_matrix.submatrix[:4, :],
return_controls = self._fader_matrix.submatrix[4:6, :],
prehear_volume_control = self._fader[6],))
self._mixer.main_buttons_layer = AddLayerMode(self._mixer, Layer(priority = 4,
mute_buttons = self._key_matrix.submatrix[:4, 1:],
arm_buttons = self._key_matrix.submatrix[4:8, :1],
solo_buttons = self._key_matrix.submatrix[:4, :1],
track_select_buttons = self._key_matrix.submatrix[4:8, 1:],))
self._mixer.stop_layer = AddLayerMode(self._mixer, Layer(priority = 4,
stop_clip_buttons = self._key_matrix.submatrix[8:12, 1:],))
self._mixer.main_knobs_layer = AddLayerMode(self._mixer, Layer(priority = 4,
send_controls = self._knob_left_matrix.submatrix[:, :2],
pan_controls = self._knob_left_matrix.submatrix[:, 2:],
eq_gain_controls = self._knob_right_matrix))
self._mixer.master_fader_layer = AddLayerMode(self._mixer.master_strip(), Layer(priority = 4,
volume_control = self._fader[7]))
self._mixer.instrument_buttons_layer = AddLayerMode(self._mixer, Layer(priority = 4,
mute_buttons = self._key_matrix.submatrix[:4, 1:],
track_select_buttons = self._key_matrix.submatrix[4:8, 1:],))
self._mixer.dial_nav_layer = AddLayerMode(self._mixer, Layer(priority = 4,
track_select_dial = self._encoder[3]))
def _setup_send_resets(self):
self._send_reset = CntrlrResetSendsComponent(self)
self._send_reset.name = 'Sends_Reset'
self._send_reset.layer = Layer(buttons = self._key_matrix.submatrix[8:12, :1])
def _setup_session_control(self):
self._session = CntrlrSessionComponent(num_tracks = 4, num_scenes = 4, name = 'Session', enable_skinning = True, auto_name = True)
self._session.set_mixer(self._mixer)
self.set_highlighting_session_component(self._session)
self._session.layer = Layer(priority = 4, clip_launch_buttons = self._matrix)
self._session.nav_layer = AddLayerMode(self._session, Layer(priority = 4,
scene_bank_down_button = self._button[14],
scene_bank_up_button = self._button[15],
track_bank_left_button = self._button[12],
track_bank_right_button = self._button[13]))
self._session.dial_nav_layer = AddLayerMode(self._session, Layer(priority = 4,
scene_select_dial = self._encoder[2]))
self._session_zoom = SessionZoomingComponent(session = self._session, name = 'Session_Overview', enable_skinning = True) # is_enabled = False) #
self._session_zoom.buttons_layer = AddLayerMode(self._session_zoom, Layer(priority = 4, button_matrix = self._matrix))
self._session.set_offsets(0, 0)
def _setup_device_control(self):
self._device_selection_follows_track_selection = FOLLOW
self._device = DeviceComponent()
self._device.name = 'Device_Component'
self._device._is_banking_enabled = self.device_is_banking_enabled(self._device)
self.set_device_component(self._device)
self._device.layer = Layer(priority = 4, parameter_controls = self._dial_matrix.submatrix[:, 1:3],
lock_button = self._encoder_button[5],
on_off_button = self._encoder_button[4],
bank_prev_button = self._encoder_button[6],
bank_next_button = self._encoder_button[7])
self._device_navigator = DeviceNavigator(self._device, self._mixer, self)
self._device_navigator.name = 'Device_Navigator'
self._device_navigator.layer = Layer(priority = 4, prev_button = self._encoder_button[8],
next_button = self._encoder_button[9],
prev_chain_button = self._encoder_button[10],
next_chain_button = self._encoder_button[11],)
def _setup_device_selector(self):
self._device_selector = DeviceSelectorComponent(self) # is_enabled = False)
self._device_selector.name = 'Device_Selector'
self._device_selector.layer = Layer(matrix = self._matrix.submatrix[:, :3])
self._device_selector.set_enabled(False)
def _setup_translations(self):
self._translations = TranslationComponent(self._translated_controls, user_channel_offset = 4, channel = 4) # is_enabled = False)
self._translations.name = 'TranslationComponent'
self._translations.layer = Layer(priority = 10,)
self._translations.selector_layer = AddLayerMode(self._translations, Layer(priority = 10, channel_selector_buttons = self._dial_button_matrix))
self._translations.set_enabled(False)
self._optional_translations = CompoundMode(TranslationComponent(controls = self._fader, user_channel_offset = 4, channel = 4, name = 'FaderTranslation', is_enabled = False, layer = Layer(priority = 10)) if FADER_BANKING else None,
TranslationComponent(controls = self._knobs, user_channel_offset = 4, channel = 4, name = 'DialTranslation', is_enabled = False, layer = Layer(priority = 10)) if DIAL_BANKING else None)
def _setup_mod(self):
self.monomodular = get_monomodular(self)
self.monomodular.name = 'monomodular_switcher'
self.modhandler = CntrlrModHandler(self) # is_enabled = False)
self.modhandler.name = 'ModHandler'
self.modhandler.set_lock_button(self._encoder_button[1])
self.modhandler.layer = Layer(priority = 8, cntrlr_encoder_grid = self._dial_matrix,
cntrlr_encoder_button_grid = self._dial_button_matrix,
cntrlr_grid = self._matrix,
cntrlr_keys = self._key_matrix,)
#parameter_controls = self._dial_matrix)
def _setup_instrument(self):
self._grid_resolution = self.register_disconnectable(GridResolution())
self._c_instance.playhead.enabled = True
self._playhead_element = PlayheadElement(self._c_instance.playhead)
self._playhead_element.reset()
self._instrument = CntrlrMonoInstrumentComponent(self, self._skin, grid_resolution = self._grid_resolution, name = 'InstrumentModes') # is_enabled = False)
#self._instrument.layer = Layer(priority = 10, shift_mode_button = self._button[31])
self._instrument.shift_button_layer = AddLayerMode(self._instrument, Layer(priority = 5, shift_mode_button = self._button[31]))
self._instrument.audioloop_layer = LayerMode(self._instrument, Layer(priority = 4, loop_selector_matrix = self._key_matrix.submatrix[:, :1]))
self._instrument.keypad_shift_layer = AddLayerMode(self._instrument, Layer(priority = 4,
scale_up_button = self._button[13],
scale_down_button = self._button[12],
offset_up_button = self._button[11],
offset_down_button = self._button[10],
vertical_offset_up_button = self._button[9],
vertical_offset_down_button = self._button[8],
split_button = self._button[14],
sequencer_button = self._button[15]))
self._instrument.drumpad_shift_layer = AddLayerMode(self._instrument, Layer(priority = 4,
scale_up_button = self._button[13],
scale_down_button = self._button[12],
drum_offset_up_button = self._button[11],
drum_offset_down_button = self._button[10],
drumpad_mute_button = self._button[9],
drumpad_solo_button = self._button[8],
split_button = self._button[14],
sequencer_button = self._button[15]))
self._instrument._keypad.main_layer = LayerMode(self._instrument._keypad, Layer(priority = 4, keypad_matrix = self._matrix))
self._instrument._keypad.sequencer_layer = LayerMode(self._instrument._keypad, Layer(priority = 4, playhead = self._playhead_element, keypad_matrix = self._matrix, sequencer_matrix = self._key_matrix.submatrix[:,:1]))
self._instrument._keypad.split_layer = LayerMode(self._instrument._keypad, Layer(priority = 4, keypad_matrix = self._matrix, split_matrix = self._key_matrix.submatrix[:8,:1]))
self._instrument._keypad.sequencer_shift_layer = LayerMode(self._instrument._keypad, Layer(priority = 4, keypad_matrix = self._matrix, loop_selector_matrix = self._key_matrix.submatrix[:8, :1], quantization_buttons = self._key_matrix.submatrix[:7, 1:], follow_button = self._button[23]))
self._instrument._drumpad.main_layer = LayerMode(self._instrument._drumpad, Layer(priority = 4, drumpad_matrix = self._matrix))
self._instrument._drumpad.sequencer_layer = LayerMode(self._instrument._drumpad, Layer(priority = 4, playhead = self._playhead_element, drumpad_matrix = self._matrix, sequencer_matrix = self._key_matrix.submatrix[:,:1]))
self._instrument._drumpad.split_layer = LayerMode(self._instrument._drumpad, Layer(priority = 4, drumpad_matrix = self._matrix, split_matrix = self._key_matrix.submatrix[:8,:1]))
self._instrument._drumpad.sequencer_shift_layer = LayerMode(self._instrument._drumpad, Layer(priority = 4, drumpad_matrix = self._matrix, loop_selector_matrix = self._key_matrix.submatrix[:8, :1], quantization_buttons = self._key_matrix.submatrix[:7, 1:], follow_button = self._button[23]))
self._instrument.set_enabled(False)
def _setup_modswitcher(self):
self._modswitcher = ModesComponent(name = 'ModSwitcher') # is_enabled = False)
#self._modswitcher.add_mode('instrument', [self._optional_translations])
self._modswitcher.add_mode('mod', [self.modhandler, self._optional_translations])
self._modswitcher.add_mode('instrument', [self._instrument, self._instrument.shift_button_layer, self._optional_translations])
self._modswitcher.set_enabled(False)
def _setup_viewcontrol(self):
self._view_control = ViewControlComponent(name='View_Control')# is_enabled = False)
self._view_control.main_layer = AddLayerMode(self._view_control, Layer(prev_track_button=self._button[24],
next_track_button= self._button[25],
next_scene_button=self._button[27],
prev_scene_button = self._button[26]))
#self._view_control.set_enabled(False)
self._view_control.selector_layer = AddLayerMode(self._view_control, Layer(priority = 8,
prev_track_button = self._grid[12],
next_track_button = self._grid[13],
next_scene_button = self._grid[15],
prev_scene_button = self._grid[14]))
def _setup_modes(self):
main_buttons=CompoundMode(self._mixer.main_buttons_layer, self._mixer.stop_layer, self._transport, self._send_reset, self._session.nav_layer)
main_buttons_instrument=CompoundMode(self._mixer.main_buttons_layer, self._recorder, self._view_control.main_layer)
main_faders=CompoundMode(self._mixer.main_faders_layer, self._mixer.master_fader_layer)
bottom_buttons=CompoundMode(self._mixer.instrument_buttons_layer, self._recorder, self._view_control.main_layer)
self._instrument._main_modes = ModesComponent(name = 'InstrumentModes')
self._instrument._main_modes.add_mode('disabled', [main_buttons_instrument, main_faders, self._mixer.main_knobs_layer, self._device, self._session, self._recorder, self._view_control.main_layer, self._send_reset, self._session.nav_layer,])
self._instrument._main_modes.add_mode('drumpad', [self._instrument._drumpad.main_layer, main_buttons_instrument, self._send_reset, self._session.nav_layer])
self._instrument._main_modes.add_mode('drumpad_split', [self._instrument._drumpad.split_layer, self._send_reset, self._session.nav_layer])
self._instrument._main_modes.add_mode('drumpad_sequencer', [self._instrument._drumpad.sequencer_layer, bottom_buttons])
self._instrument._main_modes.add_mode('drumpad_shifted', [self._instrument._drumpad.main_layer, self._instrument.drumpad_shift_layer, main_buttons_instrument, self._recorder, self._view_control.main_layer])
self._instrument._main_modes.add_mode('drumpad_split_shifted', [self._instrument._drumpad.split_layer, self._instrument.drumpad_shift_layer, bottom_buttons, self._recorder, self._view_control.main_layer])
self._instrument._main_modes.add_mode('drumpad_sequencer_shifted', [self._instrument._drumpad.sequencer_shift_layer, self._instrument.drumpad_shift_layer, self._recorder, self._view_control.main_layer])
self._instrument._main_modes.add_mode('keypad', [self._instrument._keypad.main_layer, main_buttons_instrument, self._send_reset, self._session.nav_layer])
self._instrument._main_modes.add_mode('keypad_split', [self._instrument._keypad.split_layer, bottom_buttons, self._send_reset, self._session.nav_layer])
self._instrument._main_modes.add_mode('keypad_sequencer', [self._instrument._keypad.sequencer_layer, bottom_buttons])
self._instrument._main_modes.add_mode('keypad_shifted', [self._instrument._keypad.main_layer, self._instrument.keypad_shift_layer, main_buttons_instrument, self._recorder, self._view_control.main_layer])
self._instrument._main_modes.add_mode('keypad_split_shifted', [self._instrument._keypad.split_layer, self._instrument.keypad_shift_layer, bottom_buttons, self._recorder, self._view_control.main_layer])
self._instrument._main_modes.add_mode('keypad_sequencer_shifted', [self._instrument._keypad.sequencer_shift_layer, self._instrument.keypad_shift_layer, self._recorder, self._view_control.main_layer])
self._instrument._main_modes.add_mode('audioloop', [self._instrument.audioloop_layer, self._session, bottom_buttons, self._recorder, self._view_control.main_layer])
self._instrument.register_component(self._instrument._main_modes)
self._instrument.set_enabled(False)
self._session_modes = ModesComponent(name = 'SessionModes', is_enabled = False)
self._session_modes.add_mode('Session', [self._session])
self._session_modes.add_mode('SessionZoom', [self._session_zoom.buttons_layer], behaviour = BicoloredMomentaryBehaviour(color = 'Session.ZoomOn', off_color = 'Session.ZoomOff'))
self._session_modes.layer = Layer(priority = 4, SessionZoom_button = self._button[31])
self._session_modes.selected_mode = 'Session'
self._main_modes = ModesComponent(name = 'MainModes')
self._main_modes.add_mode('MixMode', [main_buttons, main_faders, self._mixer.main_knobs_layer, self._device, self._session_modes, self._session.nav_layer,]) # self._session.dial_nav_layer, self._mixer.dial_nav_layer, self.encoder_navigation_on])
self._main_modes.add_mode('ModSwitcher', [main_faders, self._mixer.main_knobs_layer, self._modswitcher], behaviour = DefaultedBehaviour(default_mode = 'MixMode', color = 'ModeButtons.ModSwitcher', off_color = 'ModeButtons.ModSwitcherDisabled'))
self._main_modes.add_mode('Translations', [main_faders, self._mixer.main_knobs_layer, self._translations, DelayMode(self._translations.selector_layer)], behaviour = DefaultedBehaviour(default_mode = 'MixMode', color = 'ModeButtons.Translations', off_color = 'ModeButtons.TranslationsDisabled'))
self._main_modes.add_mode('DeviceSelector', [self._device_selector, main_buttons, main_faders, self._mixer.main_knobs_layer, self._device, self._device_navigator, self._view_control.selector_layer], behaviour = ColoredCancellableBehaviourWithRelease(color = 'ModeButtons.DeviceSelector', off_color = 'ModeButtons.DeviceSelectorDisabled'))
self._main_modes.layer = Layer(priority = 4, ModSwitcher_button = self._encoder_button[0], Translations_button = self._encoder_button[3], DeviceSelector_button = self._encoder_button[2])
def _setup_m4l_interface(self):
self._m4l_interface = MonoM4LInterfaceComponent(controls=self.controls, component_guard=self.component_guard, priority = 10)
self._m4l_interface.name = "M4LInterface"
self.get_control_names = self._m4l_interface.get_control_names
self.get_control = self._m4l_interface.get_control
self.grab_control = self._m4l_interface.grab_control
self.release_control = self._m4l_interface.release_control
def _can_auto_arm_track(self, track):
routing = track.current_input_routing
return routing == 'Ext: All Ins' or routing == 'All Ins' or routing.startswith('Cntrlr Input')
@subject_slot('appointed_device')
def _on_device_changed(self):
debug('appointed device changed, script')
self.schedule_message(2, self._update_modswitcher)
def _on_selected_track_changed(self):
super(Cntrlr, self)._on_selected_track_changed()
self.schedule_message(2, self._update_modswitcher)
def _update_modswitcher(self):
debug('update modswitcher', self.modhandler.active_mod())
if self.modhandler.active_mod():
self._modswitcher.selected_mode = 'mod'
else:
self._modswitcher.selected_mode = 'instrument'
def reset_controlled_track(self, track = None, *a):
if not track:
track = self.song().view.selected_track
self.set_controlled_track(track)
def set_controlled_track(self, track = None, *a):
if isinstance(track, Live.Track.Track):
super(Cntrlr, self).set_controlled_track(track)
else:
self.release_controlled_track()
"""called on timer"""
def update_display(self):
super(Cntrlr, self).update_display() #since we are overriding this from the inherited method, we need to call the original routine as well
self._timer = (self._timer + 1) % 256 #each 100/60ms, increase the self._timer property by one. Start over at 0 when we hit 256
self.modhandler.send_ring_leds() #if local rings are turned off, then we need to send the new values if they've changed
self.flash() #call the flash method below
def flash(self):
if(self.flash_status > 0):
for control in self.controls:
if isinstance(control, MonoButtonElement):
control.flash(self._timer)
"""m4l lcd bridge"""
def generate_strip_string(self, display_string):
NUM_CHARS_PER_DISPLAY_STRIP = 12
if (not display_string):
return (' ' * NUM_CHARS_PER_DISPLAY_STRIP)
if ((len(display_string.strip()) > (NUM_CHARS_PER_DISPLAY_STRIP - 1)) and (display_string.endswith('dB') and (display_string.find('.') != -1))):
display_string = display_string[:-2]
if (len(display_string) > (NUM_CHARS_PER_DISPLAY_STRIP - 1)):
for um in [' ',
'i',
'o',
'u',
'e',
'a']:
while ((len(display_string) > (NUM_CHARS_PER_DISPLAY_STRIP - 1)) and (display_string.rfind(um, 1) != -1)):
um_pos = display_string.rfind(um, 1)
display_string = (display_string[:um_pos] + display_string[(um_pos + 1):])
else:
display_string = display_string.center((NUM_CHARS_PER_DISPLAY_STRIP - 1))
ret = u''
for i in range((NUM_CHARS_PER_DISPLAY_STRIP - 1)):
if ((ord(display_string[i]) > 127) or (ord(display_string[i]) < 0)):
ret += ' '
else:
ret += display_string[i]
ret += ' '
ret = ret.replace(' ', '_')
assert (len(ret) == NUM_CHARS_PER_DISPLAY_STRIP)
return ret
def notification_to_bridge(self, name, value, sender):
if(isinstance(sender, (MonoEncoderElement, CodecEncoderElement))):
pn = str(self.generate_strip_string(name))
pv = str(self.generate_strip_string(value))
self._monobridge._send(sender.name, 'lcd_name', pn)
self._monobridge._send(sender.name, 'lcd_value', pv)
def touched(self):
if self._touched is 0:
self._monobridge._send('touch', 'on')
self.schedule_message(2, self.check_touch)
self._touched +=1
def check_touch(self):
if self._touched > 5:
self._touched = 5
elif self._touched > 0:
self._touched -= 1
if self._touched is 0:
self._monobridge._send('touch', 'off')
else:
self.schedule_message(2, self.check_touch)
def handle_sysex(self, midi_bytes):
pass
def disconnect(self):
self.log_message("<<<<<<<<<<<<<<<<<<<<<<<<< " + str(self._host_name) + " log closed >>>>>>>>>>>>>>>>>>>>>>>>>")
super(Cntrlr, self).disconnect()
def restart_monomodular(self):
#debug('restart monomodular')
self.modhandler.disconnect()
with self.component_guard():
self._setup_mod()
def _get_num_tracks(self):
return self.num_tracks
"""a closure fix for banking when we deassign the bank buttons and still want to change bank indexes"""
def device_is_banking_enabled(self, device):
def _is_banking_enabled():
return True
return _is_banking_enabled
class LaunchControl(ControlSurface):
def __init__(self, c_instance):
super(LaunchControl, self).__init__(c_instance)
with self.component_guard():
self._device_selection_follows_track_selection = True
self._init_mixer()
self._init_session()
self._init_device()
self._init_modes()
self._refresh_state_task = self._tasks.add(Task.sequence(Task.delay(3), Task.run(self._do_refresh_state)))
self._refresh_state_task.kill()
self.log_message('Launch Control script loaded')
def disconnect(self):
super(LaunchControl, self).disconnect()
for channel in xrange(16):
self._send_midi((CC_STATUS + channel, 0, 0))
def refresh_state(self):
self._refresh_state_task.restart()
def _do_refresh_state(self):
self._send_current_mode()
self._update_hardware()
self.schedule_message(3, super(LaunchControl, self).refresh_state)
def _update_hardware(self):
for channel in xrange(8, 11):
self._send_midi(Sysex.make_automatic_flashing_message(channel))
def _send_current_mode(self):
try:
self._send_midi(MODE_SYSEX_MAP[self._modes.selected_mode])
except KeyError:
pass
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 xrange(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 _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 _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')
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_modes(self):
self._modes = ModesComponent(is_root=True)
self._modes.add_mode('mixer', [partial(self._session.set_mixer, self._mixer),
LayerMode(self._session, self._mixer_track_nav_layer),
self._mixer,
self._session,
self._show_controlled_tracks_message])
self._modes.add_mode('session', [partial(self._session.set_mixer, self._session_mixer),
LayerMode(self._session, self._session_layer),
self._session_mixer,
self._session,
self._show_controlled_tracks_message])
self._modes.add_mode('device', [self._device, self._device_navigation, self._view_control])
self._modes.add_mode('user', None)
self._modes.selected_mode = 'mixer'
self._modes.layer = Layer(mixer_button=ButtonSysexControl(Sysex.MIXER_MODE), session_button=ButtonSysexControl(Sysex.SESSION_MODE), device_button=ButtonSysexControl(Sysex.DEVICE_MODE))
return
@subject_slot('offset')
def _on_track_offset(self):
self._show_controlled_tracks_message()
@subject_slot('selected_send_index')
def _on_selected_send_index(self, index):
self._show_controlled_sends_message()
@subject_slot('selected_mixer_mode')
def _on_selected_mixer_mode(self, mode):
if mode == 'sends':
self._show_controlled_sends_message()
else:
self.show_message('Controlling Pan and Volume')
def _show_controlled_tracks_message(self):
start = self._session.track_offset() + 1
end = min(start + 8, len(self._session.tracks_to_use()))
if start < end:
self.show_message('Controlling Track %d to %d' % (start, end))
else:
self.show_message('Controlling Track %d' % start)
def _show_controlled_sends_message(self):
send_index = self._mixer.selected_send_index
send_name1 = chr(ord('A') + send_index)
if send_index + 1 < self._mixer.num_sends:
send_name2 = chr(ord('A') + send_index + 1)
self.show_message('Controlling Send %s and %s' % (send_name1, send_name2))
else:
self.show_message('Controlling Send %s' % send_name1)
def handle_sysex(self, midi_bytes):
super(LaunchControl, self).handle_sysex(midi_bytes)
if self._is_user_mode_message(midi_bytes):
self._modes.selected_mode = 'user'
self.request_rebuild_midi_map()
def _is_user_mode_message(self, midi_bytes):
"""
True if midi_byes refer to a mode change, but none of the three
predefined Live modes
"""
return midi_bytes[:7] == Sysex.MODE_CHANGE_PREFIX and midi_bytes not in SYSEX_MODE_MAP
class InstrumentComponent(ControlSurfaceComponent):
"""
handles notes mode and switches between note, drum and dummy audio mode.
"""
def __init__(self, control_surface, drum_component=None, *a, **k):
self._control_surface = control_surface
self._drum_component = drum_component
self._implicit_arm = True
self._modes = ModesComponent(name="Instrument_Modes", is_enabled=False)
self._modes.set_enabled = self.set_enabled
self._feedback_channels = [
consts.DR_MAP_CHANNEL,
consts.DR_MAP_CHANNEL + 1,
consts.DR_MAP_CHANNEL + 2,
consts.DR_MAP_CHANNEL + 3,
consts.DR_MAP_CHANNEL + 4,
]
self._non_feedback_channel = consts.DR_MAP_CHANNEL + 5
self._common_component = CommonModeComponent(instrument_component=self, control_surface=self._control_surface)
self._scale_component = ScaleComponent(control_surface=self._control_surface, enabled=True)
self._note_component = NoteComponent(
control_surface=self._control_surface,
feedback_channels=self._feedback_channels,
non_feedback_channel=self._non_feedback_channel,
get_pattern=self._scale_component.get_pattern,
)
super(InstrumentComponent, self).__init__(*a, **k)
def set_layers(self, midimap):
common_layer_mode = LayerMode(
self._common_component,
layer=Layer(
arrow_left_button=midimap["Arrow_Left_Button"],
arrow_right_button=midimap["Arrow_Right_Button"],
arrow_up_button=midimap["Arrow_Up_Button"],
arrow_down_button=midimap["Arrow_Down_Button"],
scale_button=midimap["Scene_Launch_Button_Matrix_Raw"][0][0],
scale_up_button=midimap["Scene_Launch_Button_Matrix_Raw"][0][1],
scale_down_button=midimap["Scene_Launch_Button_Matrix_Raw"][0][2],
dummy_button=midimap["Scene_Launch_Button_Matrix_Raw"][0][3],
play_button=midimap["Scene_Launch_Button_Matrix_Raw"][0][6],
stop_button=midimap["Scene_Launch_Button_Matrix_Raw"][0][7],
),
)
drum_group_layer_mode = LayerMode(
self._control_surface._drum_group,
layer=Layer(
# scroll_up_button = midimap['Scene_Launch_Button_Matrix_Raw'][0][1],
# scroll_down_button = midimap['Scene_Launch_Button_Matrix_Raw'][0][2],
mute_button=midimap["Scene_Launch_Button_Matrix_Raw"][0][4],
solo_button=midimap["Scene_Launch_Button_Matrix_Raw"][0][5],
# scroll_up_button=midimap['Arrow_Left_Button'],
# scroll_down_button=midimap['Arrow_Right_Button'],
# scroll_page_up_button=midimap['Arrow_Up_Button'],
# scroll_page_down_button=midimap['Arrow_Down_Button'],
# drum_matrix = midimap['Drum_Button_Matrix']#,
drum_matrix=midimap["Main_Button_Matrix"]
# select_button = midimap['Shift_Button'],
# delete_button = midimap['Delete_Button']
),
)
self._modes.add_mode(
"drum_mode",
[
partial(self._control_surface._layout_setup, consts.SESSION_LAYOUT_SYSEX_BYTE),
partial(
self._control_surface._layout_setup,
consts.USER_LAYOUT_SYSEX_BYTE,
consts.SYSEX_PARAM_BYTE_STANDALONE_LAYOUT,
),
# partial(self._control_surface._layout_setup, consts.DRUM_LAYOUT_SYSEX_BYTE),
self._control_surface._setup_drum_group(),
drum_group_layer_mode,
common_layer_mode # ,
# drum_mode_note_matrix_translation
],
)
scale_layer_mode = LayerMode(self._scale_component, layer=Layer(matrix=midimap["Main_Button_Matrix"]))
self._modes.add_mode(
"scale_mode",
[
partial(self._control_surface._layout_setup, consts.SESSION_LAYOUT_SYSEX_BYTE),
partial(
self._control_surface._layout_setup,
consts.USER_LAYOUT_SYSEX_BYTE,
consts.SYSEX_PARAM_BYTE_STANDALONE_LAYOUT,
),
scale_layer_mode,
common_layer_mode # ,
# drum_mode_note_matrix_translation
],
)
note_layer_mode = LayerMode(
self._note_component,
layer=Layer(
matrix=midimap["Main_Button_Matrix"]
# select_button = midimap['Shift_Button'],
# delete_button = midimap['Delete_Button']
),
)
self._modes.add_mode(
"note_mode",
[
partial(self._control_surface._layout_setup, consts.SESSION_LAYOUT_SYSEX_BYTE),
partial(
self._control_surface._layout_setup,
consts.USER_LAYOUT_SYSEX_BYTE,
consts.SYSEX_PARAM_BYTE_STANDALONE_LAYOUT,
),
note_layer_mode,
common_layer_mode # ,
# drum_mode_note_matrix_translation
],
)
# Audio mode
audio_layer_mode = LayerMode(AudioModeComponent(), layer=Layer(matrix=midimap["Main_Button_Matrix"]))
self._modes.add_mode(
"audio_mode",
[
partial(self._control_surface._layout_setup, consts.SESSION_LAYOUT_SYSEX_BYTE),
partial(
self._control_surface._layout_setup,
consts.DRUM_LAYOUT_SYSEX_BYTE,
consts.SYSEX_PARAM_BYTE_STANDALONE_LAYOUT,
),
# partial(self._control_surface._layout_setup, consts.DRUM_LAYOUT_SYSEX_BYTE),#consts.AUDIO_LAYOUT_SYSEX_BYTE),
self._control_surface._clip_delete_layer_mode,
common_layer_mode,
audio_layer_mode,
],
)
def set_enabled(self, enabled):
if not enabled:
self._do_implicit_arm(enabled)
ControlSurfaceComponent.set_enabled(self, enabled)
ModesComponent.set_enabled(self._modes, enabled)
if enabled:
self._do_implicit_arm(enabled)
def _enter_scale_mode(self):
self._previous_mode = self._modes.selected_mode
self.set_mode("scale_mode")
def _leave_scale_mode(self):
self.set_mode(self._previous_mode)
def _detect_mode(self):
track = self._control_surface._target_track_component.target_track
# drum_device = self._control_surface._drum_group_finder.drum_group
self._control_surface._setup_drum_group()
if (
track is None
or track.is_foldable
or track in self.song().return_tracks
or track == self.song().master_track
or track.is_frozen
or track.has_audio_input
):
self.set_mode("audio_mode")
self._scale_component._is_drumrack = False
elif self._control_surface._drum_group._drum_group_device:
self._scale_component._is_drumrack = True
self.set_mode("drum_mode")
else:
self._scale_component._is_drumrack = False
self.set_mode("note_mode")
def get_pattern(self):
return self._scale_component.get_pattern()
def on_selected_track_changed(self):
if self._implicit_arm:
# self._control_surface._setup_drum_group()
self._detect_mode()
self._do_implicit_arm()
def update(self):
self._modes.update()
def on_selected_scene_changed(self):
# self._do_implicit_arm()
self.update()
def set_mode(self, mode):
self._modes.selected_mode = mode
self._modes.update()
def get_mode(self):
return self._modes.selected_mode
def can_implicit_arm_track(self, track):
# todo
return track.can_be_armed and track.has_midi_input
def _do_implicit_arm(self, arm=True):
if self._is_enabled:
if self._implicit_arm and arm:
self._control_surface.set_feedback_channels(self._feedback_channels)
self._control_surface.set_controlled_track(self._control_surface._target_track_component.target_track)
else:
self._control_surface.release_controlled_track()
for track in self.song().tracks:
if self.can_implicit_arm_track(track):
track.implicit_arm = (
self._is_enabled
and self._implicit_arm
and arm
and self._control_surface._target_track_component.target_track == track
)
class Launchkey_MK2(OptimizedControlSurface):
identity_request_delay = 0.5
def __init__(self, c_instance, *a, **k):
super(Launchkey_MK2, self).__init__(c_instance=c_instance, *a, **k)
self._is_25_key_model = False
self._is_in_control_on = True
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(xrange(21, 29)) ]])
self._top_pad_row = ButtonMatrixElement(rows=[[ make_button(identifier, name='Pad_0_%d' % (index,)) for index, identifier in enumerate(xrange(96, 104)) ]])
self._bottom_pad_row_raw = [ make_button(identifier, name='Pad_1_%d' % (index,)) for index, identifier in enumerate(xrange(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(xrange(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(xrange(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 xrange(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(CLIP_COLOR_TABLE, 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 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 _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 xrange(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()
self.on_identified()
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._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 MonoWing(ControlSurface):
def __init__(self, *a, **k):
super(MonoWing, self).__init__(*a, **k)
self._monomod_version = 'b995'
self._codec_version = 'b996'
self._cntrlr_version = 'b996'
self._cntrlr = None
self._host_name = 'MonoWing'
self._color_type = 'OhmRGB'
self.hosts = []
self._timer = 0
self.flash_status = 0
self._touched = 0
self._last_main_mode = 'looper'
with self.component_guard():
self._setup_monobridge()
self._setup_controls()
self._setup_looper()
self._setup_launcher()
self._setup_device_control()
self._setup_modes()
self.schedule_message(1, self._open_log)
#self._loop_selector.set_enabled(True)
"""script initialization methods"""
def _open_log(self):
self.log_message("<<<<<<<<<<<<<<<<<<<<= " + str(self._host_name) + " " + str(self._monomod_version) + " log opened =>>>>>>>>>>>>>>>>>>>")
self.show_message(str(self._host_name) + ' Control Surface Loaded')
def _setup_monobridge(self):
self._monobridge = MonoBridgeElement(self)
self._monobridge.name = 'MonoBridge'
def _setup_controls(self):
self._pedal = [None for index in range(12)]
for index in range(9):
self._pedal[index] = DoublePressElement(MonoButtonElement(True, MIDI_NOTE_TYPE, 0, PEDAL_DEFS[index], 'Pedal_'+str(index), self))
#is_momentary, MIDI_NOTE_TYPE, CHANNEL, LIVID, 'Livid_Button', self
self._pedal[index].name = 'Pedal_'+str(index)
self._pedal[index]._report = False
self._pedal[9] = LoopPedalExpressionElement(self, MIDI_CC_TYPE, 0, 3, Live.MidiMap.MapMode.absolute)
self._pedal[9].name = 'Pedal_'+str(9)
self._pedal[9]._report = False
self._pedal[10] = LoopPedalExpressionElement(self, MIDI_CC_TYPE, 0, 1, Live.MidiMap.MapMode.absolute)
self._pedal[10].name = 'Pedal_'+str(10)
self._pedal[10]._report = False
self._pedal[11] = LoopPedalExpressionElement(self, MIDI_CC_TYPE, 0, 2, Live.MidiMap.MapMode.absolute)
self._pedal[11].name = 'Pedal_'+str(11)
self._pedal[11]._report = False
self._leds = [self._pedal[6], self._pedal[5], self._pedal[4], self._pedal[3]]
self._side_buttons = [MonoButtonElement(True, MIDI_NOTE_TYPE, 0, SIDE_DEFS[index], 'Side_Button_'+str(index), self) for index in range(4)]
self._select_buttons = ButtonMatrixElement()
self._select_buttons.name = 'SelectMatrix'
self._select_buttons.add_row([self._pedal[6], self._pedal[5], self._pedal[4], self._pedal[3]])
self._doublepress_select_buttons = ButtonMatrixElement()
self._doublepress_select_buttons.name = 'DoublepressSelectMatrix'
self._doublepress_select_buttons.add_row([self._pedal[6].double_press, self._pedal[5].double_press, self._pedal[4].double_press, self._pedal[3].double_press])
self._record_button = self._pedal[1]
self._mute_button = self._pedal[2]
self._overdub_button = self._pedal[0]
self._clear_button = self._pedal[7]
self._reverse_button = self._pedal[8]
self._record_button.turn_off()
self._mute_button.turn_off()
self._overdub_button.turn_off()
self._clear_button.turn_off()
self._reverse_button.turn_off()
def _setup_looper(self):
self._looper = MonolooperComponent(self._leds, self)
self._looper.layer = Layer(select_buttons = self._select_buttons,
doublepress_select_buttons = self._doublepress_select_buttons,
overdub_button = self._pedal[2],
record_button = self._pedal[1],
mute_button = self._pedal[0],
clear_button = self._pedal[7],
reverse_button = self._pedal[8],
expression_pedal = self._pedal[9],)
def _setup_launcher(self):
self._launcher = LauncherComponent(self._leds, self)
self._launcher.set_enabled(False)
self._launcher.layer = Layer(select_buttons = self._select_buttons,
doublepress_select_buttons = self._doublepress_select_buttons,
fire1_button = self._pedal[2],
fire2_button = self._pedal[1],
fire3_button = self._pedal[0],
fire4_button = self._pedal[8],
expression_pedal = self._pedal[9])
def _setup_device_control(self):
self._device_control = DeviceControlComponent(self._leds, self)
self._device_control.set_enabled(False)
self._device_control.layer = Layer(select_buttons = self._select_buttons,
doublepress_select_buttons = self._doublepress_select_buttons,
toggle1_button = self._pedal[2],
toggle2_button = self._pedal[1],
toggle3_button = self._pedal[0],
toggle4_button = self._pedal[8],
expression_pedal = self._pedal[9],
expression2 = self._pedal[10],
expression3 = self._pedal[11])
def _setup_modes(self):
self._button_modes = ModesComponent(name='Button_Modes')
self._button_modes.add_mode('launcher', self._launcher)
self._button_modes.add_mode('looper', self._looper)
self._button_modes.add_mode('device', self._device_control)
self._button_modes.selected_mode = 'looper'
self._button_modes.layer = Layer(looper_button = self._side_buttons[0], launcher_button = self._side_buttons[1], device_button = self._side_buttons[2])
self._button_modes.set_enabled(True)
def receive_led(self, button, value):
#self.log_message('receive led: ' + str(index) + ' ' + str(value))
pass
def toggle_mode(self):
self._button_modes.selected_mode = 'launcher' if self._button_modes.selected_mode is 'looper' else 'looper'
self._last_main_mode = self._button_modes.selected_mode
#self.log_message('toggle mode to: ' + str(self._button_modes.selected_mode))
def toggle_device_control(self, x):
self._button_modes.selected_mode = 'device' if not self._button_modes.selected_mode is 'device' else self._last_main_mode
if self._button_modes.selected_mode is 'device':
self._device_control.set_bank(x)
"""called on timer"""
def update_display(self):
super(MonoWing, self).update_display()
self._timer = (self._timer + 1) % 256
self.flash()
def flash(self):
if(self.flash_status > 0):
for control in self.controls:
if isinstance(control, MonoButtonElement):
control.flash(self._timer)
