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._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._note_modes = ModesComponent(name='Note_Modes')#, is_enabled=False)
self._note_modes.add_mode('drums', [self._note_repeat_enabler, self._drum_modes])
self._drum_modes.selected_mode = 'sequencer'
self._note_modes.add_mode('looper', self._audio_loop if consts.PROTO_AUDIO_NOTE_MODE else self._matrix_background)
self._note_modes.add_mode('instrument', [self._note_repeat_enabler, self._instrument])
self._note_modes.add_mode('disabled', self._matrix_background)
self._note_modes.selected_mode = 'disabled'
self._note_modes.set_enabled(False)
def switch_note_mode_layout():
self._matrix_modes.selected_mode = 'note'
if self._note_modes.selected_mode == 'instrument':
getattr(self._instrument, 'cycle_mode', nop)()
elif self._note_modes.selected_mode == 'drums':
getattr(self._drum_modes, 'cycle_mode', nop)()
self._matrix_modes = ModesComponent(name='Matrix_Modes', is_root=True)
self._matrix_modes.add_mode('session', self._session_mode_layers())
self._matrix_modes.add_mode('note', [self._drum_group_finder, self._view_control, self._note_modes],behaviour=self._auto_arm.auto_arm_restore_behaviour(ReenterBehaviour, on_reenter=switch_note_mode_layout))
self._matrix_modes.selected_mode = 'note'
self._matrix_modes.layer = Layer(session_button=self._pan_button, note_button=self._user_button)
self._on_matrix_mode_changed.subject = self._matrix_modes
self._matrix_modes.selected_mode = 'note'
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,
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_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')
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 __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 _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_encoder_modes(self):
knob_modes = ModesComponent(name=u'Knob Modes', is_enabled=False)
parameter_knobs_matrix = self.wrap_matrix(self._parameter_knobs)
send_toggle_component = SendToggleComponent(
self._mixer,
name=u'Toggle Send',
is_enabled=False,
layer=Layer(toggle_button=self._send_button, priority=1))
knob_modes.add_mode(
u'volume',
AddLayerMode(self._mixer,
Layer(volume_controls=parameter_knobs_matrix)))
knob_modes.add_mode(
u'pan',
AddLayerMode(self._mixer,
Layer(pan_controls=parameter_knobs_matrix)))
knob_modes.add_mode(u'send', [
AddLayerMode(self._mixer,
Layer(send_controls=parameter_knobs_matrix)),
send_toggle_component
])
knob_modes.add_mode(
u'device',
AddLayerMode(self._device,
Layer(parameter_controls=parameter_knobs_matrix)))
knob_modes.selected_mode = u'volume'
knob_modes.layer = Layer(volume_button=self._volume_button,
pan_button=self._pan_button,
send_button=self._send_button,
device_button=self._device_button)
return knob_modes
def __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_encoder_modes(self):
knob_modes = ModesComponent(name='Knob Modes', is_enabled=False)
parameter_knobs_matrix = self.wrap_matrix(self._parameter_knobs)
knob_modes.add_mode(
'volume',
AddLayerMode(self._mixer,
Layer(volume_controls=parameter_knobs_matrix)))
knob_modes.add_mode(
'pan',
AddLayerMode(self._mixer,
Layer(pan_controls=parameter_knobs_matrix)))
knob_modes.add_mode('send', [
AddLayerMode(self._mixer,
Layer(send_controls=parameter_knobs_matrix)),
DelayMode(LayerMode(
SendToggleComponent(
self._mixer, name='Toggle Send', is_enabled=False),
Layer(priority=MODE_PRIORITY,
toggle_button=self._send_button)),
delay=TIMER_DELAY)
])
knob_modes.add_mode(
'device',
AddLayerMode(self._device,
Layer(parameter_controls=parameter_knobs_matrix)))
knob_modes.selected_mode = 'volume'
knob_modes.layer = Layer(volume_button=self._volume_button,
pan_button=self._pan_button,
send_button=self._send_button,
device_button=self._device_button)
knob_modes.layer.priority = MODE_PRIORITY
def _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 _create_track_button_modes(self):
track_button_modes = ModesComponent(name='Track Button Modes',
is_enabled=False)
select_button_matrix = self.wrap_matrix(self._select_buttons)
track_button_modes.add_mode(
'clip_stop',
AddLayerMode(self._session,
Layer(stop_track_clip_buttons=select_button_matrix)))
track_button_modes.add_mode(
'solo',
AddLayerMode(self._mixer,
layer=Layer(solo_buttons=select_button_matrix)))
track_button_modes.add_mode(
'arm',
AddLayerMode(self._mixer,
layer=Layer(arm_buttons=select_button_matrix)))
track_button_modes.add_mode(
'mute',
AddLayerMode(self._mixer,
layer=Layer(mute_buttons=select_button_matrix)))
track_button_modes.add_mode(
'select',
AddLayerMode(
self._mixer,
layer=Layer(track_select_buttons=select_button_matrix)))
track_button_modes.selected_mode = 'clip_stop'
track_button_modes.layer = Layer(clip_stop_button=self._stop_button,
solo_button=self._solo_button,
arm_button=self._arm_button,
mute_button=self._mute_button,
select_button=self._select_button)
def _create_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, 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 _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 __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__(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 _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_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 _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 __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 __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 _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 _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_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(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()
