class Maschine(ControlSurface):
__doc__ = 'Basic Control Script for All Maschine Modell Mikro, Mikro Mk2, Mk1, Mk2, Studio'
__module__ = __name__
def __init__(self, c_instance):
super().__init__(c_instance)
with self.component_guard():
register_sender(self)
self._diplay_cache = ['', '', '', '']
self._suppress_send_midi = True
is_momentary = True
self._c_ref = c_instance
self.display_task = DisplayTask()
self._challenge = Live.Application.get_random_int(
0, 400000000) & 2139062143
self._active = False
self._midi_pause_count = 0
self.blink_state = 0
self.send_slider_index = 0
self.nav_index = 0
self.arm_selected_track = False
self.undo_state = 0
self.redo_state = 0
self._set_suppress_rebuild_requests(True)
self._modeselect = ModeSelector(self.is_monochrome())
self._device = self._set_up_device_control()
self._set_up_session(self._modeselect)
self._set_up_mixer()
self._setup_transport()
self._set_global_buttons()
self._editsection = EditSection()
self._editsection.connect_session(self._session)
self._editsection.set_mode_selector(self._modeselect)
self._session.set_mode(self._modeselect._clip_mode)
self._audio_clip_editor = AudioClipEditComponent()
self._note_repeater = NoteRepeatComponent(c_instance.note_repeat)
self._midi_edit = MidiEditSection()
self._init_settings()
self._init_maschine()
self.set_highlighting_session_component(self._session)
self.set_pad_translations(PAD_TRANSLATIONS)
self._on_selected_track_changed()
self.set_up_function_buttons()
self.show_message(str(''))
self.request_rebuild_midi_map()
self._set_suppress_rebuild_requests(False)
self._active = True
self._display_device_param = False
self.set_feedback_channels(FEEDBACK_CHANNELS)
self._final_init()
self._suppress_send_midi = False
self.apply_preferences()
self.init_text_display()
self._on_appointed_device_changed.subject = self.song()
def _init_maschine(self):
pass
def _final_init(self):
pass
def create_pad_button(self, scene_index, track_index, color_source):
pass
def create_gated_button(self, identifier, hue):
pass
def apply_preferences(self):
pref_dict = self._pref_dict
if 'step_advance' in pref_dict:
self._session.set_step_advance(pref_dict['step_advance'])
else:
if 'solo_exclusive' in pref_dict:
self._modeselect.set_solo_exclusive(
pref_dict['solo_exclusive'])
else:
self._modeselect.set_solo_exclusive(True)
if 'arm_exclusive' in pref_dict:
self._modeselect.set_arm_exclusive(pref_dict['arm_exclusive'])
else:
self._modeselect.set_arm_exclusive(True)
if 'quantize_val' in pref_dict:
self._editsection.quantize = pref_dict['quantize_val']
else:
self._editsection.quantize = 5
if 'initial_cliplen' in pref_dict:
self._editsection.initial_clip_len = pref_dict[
'initial_cliplen']
else:
self._editsection.initial_clip_len = 4.0
if 'auto_arm_sel_track' in pref_dict:
self.arm_selected_track = pref_dict['auto_arm_sel_track']
else:
self.arm_selected_track = False
if 'note_color_mode' in pref_dict:
self._modeselect._pad_mode._note_display_mode = pref_dict[
'note_color_mode']
else:
self._modeselect._pad_mode._note_display_mode = ND_KEYBOARD1
self._pref_dict[
'note_color_mode'] = self._modeselect._pad_mode._note_display_mode
self.set_sel_arm_button.send_value(
self.arm_selected_track and 127 or 0, True)
self._note_repeater.recall_values(self._pref_dict)
def store_preferences(self):
self._pref_dict['step_advance'] = self._session.get_step_advance()
self._pref_dict['solo_exclusive'] = self._modeselect.is_solo_exclusive(
)
self._pref_dict['arm_exclusive'] = self._modeselect.is_arm_exclusive()
self._pref_dict['quantize_val'] = self._editsection.quantize
self._pref_dict['initial_cliplen'] = self._editsection.initial_clip_len
self._pref_dict['auto_arm_sel_track'] = self.arm_selected_track
self._pref_dict[
'note_color_mode'] = self._modeselect._pad_mode._note_display_mode
self._note_repeater.store_values(self._pref_dict)
def _init_settings(self):
from pickle import loads, dumps
from encodings import ascii
nop(ascii)
preferences = self._c_instance.preferences(self.preferences_name())
self._pref_dict = {}
try:
self._pref_dict = loads(str(preferences))
except Exception:
pass
pref_dict = self._pref_dict
preferences.set_serializer(lambda: dumps(pref_dict))
def preferences_name(self):
return 'Maschine'
def _pre_serialize(self):
from pickle import dumps
from encodings import ascii
nop(ascii)
preferences = self._c_instance.preferences('Maschine')
self.store_preferences()
dump = dumps(self._pref_dict)
preferences.set_serializer(lambda: dump)
def toggle_nav_mode(self):
self._session.switch_step_advance()
self.show_message(' View Navigation in steps of ' +
str(self._session.get_step_advance()))
def _set_up_session(self, mode_selector):
is_momentary = True
self._session = MaschineSessionComponent()
self._session.set_color_manager(mode_selector.get_color_manager())
self.nav_buttons = (self.create_gated_button(92, COLOR_HUE_NAV),
self.create_gated_button(81, COLOR_HUE_NAV),
self.create_gated_button(93, COLOR_HUE_NAV),
self.create_gated_button(91, COLOR_HUE_NAV))
self._session.set_scene_bank_buttons(self.nav_buttons[0],
self.nav_buttons[1])
self._session.set_track_bank_buttons(self.nav_buttons[2],
self.nav_buttons[3])
track_stop_buttons = [
StateButton(is_momentary, MIDI_CC_TYPE, BASIC_CHANNEL,
index + STOP_CC_OFF) for index in range(4)
]
self._session.set_stop_track_clip_buttons(tuple(track_stop_buttons))
self._matrix = []
self._bmatrix = ButtonMatrixElement()
for scene_index in range(4):
button_row = []
for track_index in range(4):
button = self.create_pad_button(scene_index, track_index,
mode_selector)
button_row.append(button)
self._matrix.append(tuple(button_row))
self._bmatrix.add_row(tuple(button_row))
self._session.set_matrix(self._matrix)
for button, (track_index, scene_index) in self._bmatrix.iterbuttons():
if button:
scene = self._session.scene(scene_index)
clip_slot = scene.clip_slot(track_index)
clip_slot.set_launch_button(button)
clip_slot.set_triggered_to_play_value(1)
clip_slot.set_triggered_to_record_value(1)
clip_slot.set_started_value(1)
clip_slot.set_recording_value(1)
clip_slot.set_stopped_value(1)
self._session._link()
def _set_up_mixer(self):
is_momentary = True
self._mixer = MaschineMixerComponent(8)
self.send_sliders = []
for track in range(8):
self.send_sliders.append(
SliderElement(MIDI_CC_TYPE, BASIC_CHANNEL,
SEND_CC_OFF + track))
for track in range(8):
strip = self._mixer.channel_strip(track)
strip.set_arm_button(
StateButton(is_momentary, MIDI_CC_TYPE, BASIC_CHANNEL,
ARM_CC_OFF + track))
strip.set_solo_button(
StateButton(is_momentary, MIDI_CC_TYPE, BASIC_CHANNEL,
SOLO_CC_OFF + track))
strip.set_mute_button(
StateButton(is_momentary, MIDI_CC_TYPE, BASIC_CHANNEL,
MUTE_CC_OFF + track))
strip.set_volume_control(
SliderElement(MIDI_CC_TYPE, BASIC_CHANNEL,
LEVEL_CC_OFF + track))
strip.set_pan_control(
SliderElement(MIDI_CC_TYPE, BASIC_CHANNEL, PAN_CC_OFF + track))
strip.set_select_button(
StateButton(is_momentary, MIDI_CC_TYPE, BASIC_CHANNEL,
SELECT_CC_OFF + track))
st = tuple([self.send_sliders[track]])
strip.set_send_controls(st)
self.send_slider_toggle_button = StateButton(False, MIDI_CC_TYPE, 0,
90)
self._do_toggle_send.subject = self.send_slider_toggle_button
self._session.set_mixer(self._mixer)
def _set_global_buttons(self):
is_momentary = True
self._undo_button = StateButton(is_momentary, MIDI_CC_TYPE, 0, 85)
self._do_undo.subject = self._undo_button
self._redo_button = StateButton(is_momentary, MIDI_CC_TYPE, 0, 87)
self._do_redo.subject = self._redo_button
self._stop_all_button = StateButton(is_momentary, MIDI_CC_TYPE, 0, 111)
self._do_stop_all.subject = self._stop_all_button
self._toggle_detail_button = ButtonElement(is_momentary, MIDI_CC_TYPE,
1, 121)
self._action_toogle_detail_view.subject = self._toggle_detail_button
self._fire_button = StateButton(is_momentary, MIDI_CC_TYPE, 0, 9)
self._do_fire_button.subject = self._fire_button
self._g_clear_button = ButtonElement(is_momentary, MIDI_CC_TYPE, 1,
106)
self._hold_clear_action.subject = self._g_clear_button
self._g_duplicate_button = ButtonElement(is_momentary, MIDI_CC_TYPE, 1,
107)
self._hold_duplicate_action.subject = self._g_duplicate_button
self.track_left_button = StateButton(is_momentary, MIDI_CC_TYPE, 0,
120)
self.track_right_button = StateButton(is_momentary, MIDI_CC_TYPE, 0,
121)
self.set_sel_arm_button = StateButton(is_momentary, MIDI_CC_TYPE, 2,
56)
self._reenable_button = ButtonElement(is_momentary, MIDI_CC_TYPE, 1,
120)
self._do_auto_reenable.subject = self._reenable_button
self._on_change_reenabled.subject = self.song()
self._on_change_reenabled()
self._a_trk_left.subject = self.track_left_button
self._a_trk_right.subject = self.track_right_button
self._a_sel_arm.subject = self.set_sel_arm_button
def _set_up_device_control(self):
is_momentary = True
device = MaschineDeviceComponent()
param_controls = []
for index in range(8):
param_controls.append(
SliderElement(MIDI_CC_TYPE, BASIC_CHANNEL,
DEVICE_CC_OFF + index))
device.set_parameter_controls(tuple(param_controls))
self.device_control = param_controls
device.set_on_off_button(
StateButton(is_momentary, MIDI_CC_TYPE, BASIC_CHANNEL,
DEVICE_BUTTON_CC_OFF))
device.set_bank_nav_buttons(
StateButton(is_momentary, MIDI_CC_TYPE, 3, 104),
ButtonElement(is_momentary, MIDI_CC_TYPE, 3, 105))
self._device_nav_button_left = StateButton(is_momentary, MIDI_CC_TYPE,
3, 106)
self._device_nav_button_right = StateButton(is_momentary, MIDI_CC_TYPE,
3, 107)
self._navigate_button = StateButton(is_momentary, MIDI_CC_TYPE, 0, 127)
self._nav_value_left.subject = self._device_nav_button_left
self._nav_value_right.subject = self._device_nav_button_right
self._do_focus_navigate.subject = self._navigate_button
self.set_device_component(device)
return device
def _setup_transport(self):
is_momentary = True
transport = TransportComponent()
studiotransport = MaschineTransport()
playButton = StateButton(is_momentary, MIDI_CC_TYPE, 0, 108)
stopButton = StateButton(not is_momentary, MIDI_CC_TYPE, 0, 110)
recordButton = StateButton(is_momentary, MIDI_CC_TYPE, 0, 109)
overdubButton = StateButton(is_momentary, MIDI_CC_TYPE, 0, 107)
metrononmeButton = StateButton(is_momentary, MIDI_CC_TYPE, 0, 104)
eventRecButton = StateButton(is_momentary, MIDI_CC_TYPE, 0, 98)
playButton.name = 'Play'
stopButton.name = 'Stop'
recordButton.name = 'Record'
overdubButton.name = 'Overdub'
metrononmeButton.name = 'Metronome'
transport.set_play_button(playButton)
transport.set_stop_button(stopButton)
transport.set_record_button(recordButton)
transport.set_overdub_button(overdubButton)
transport.set_metronome_button(metrononmeButton)
studiotransport.set_session_auto_button(eventRecButton)
studiotransport.set_arrangement_overdub_button(
StateButton(is_momentary, MIDI_CC_TYPE, 0, 106))
studiotransport.set_back_arrange_button(
StateButton(is_momentary, MIDI_CC_TYPE, 0, 105))
transport.set_nudge_buttons(
StateButton(is_momentary, MIDI_CC_TYPE, 1, 51),
StateButton(is_momentary, MIDI_CC_TYPE, 1, 50))
punchinbutton = ToggleButton(MIDI_CC_TYPE, 1, 52)
punchoutbutton = ToggleButton(MIDI_CC_TYPE, 1, 53)
punchinbutton.name = 'Punch In'
punchoutbutton.name = 'Punch Out'
transport.set_punch_buttons(punchinbutton, punchoutbutton)
transport.set_loop_button(
StateButton(is_momentary, MIDI_CC_TYPE, 1, 54))
self.song_follow_button = ButtonElement(True, MIDI_CC_TYPE, 2, 98)
self._do_song_follow.subject = self.song_follow_button
self._song_follow_changed.subject = self.song().view
self._song_follow_changed()
self.transp_ff_button = ButtonElement(True, MIDI_CC_TYPE, 1, 59)
self.transp_rw_button = ButtonElement(True, MIDI_CC_TYPE, 1, 58)
transport.set_seek_buttons(self.transp_ff_button,
self.transp_rw_button)
self.xfadeKnob = SliderElement(MIDI_CC_TYPE, 1, 105)
self.xfadeKnob.connect_to(
self.song().master_track.mixer_device.crossfader)
self.master_knob = SliderElement(MIDI_CC_TYPE, 0, 99)
self.master_knob.connect_to(
self.song().master_track.mixer_device.volume)
self.tap_button = StateButton(is_momentary, MIDI_CC_TYPE, 0, 88)
self._do_tap_tempo.subject = self.tap_button
self.cue_add_delete_button = StateButton(is_momentary, MIDI_CC_TYPE, 1,
55)
self.cue_prev_button = StateButton(is_momentary, MIDI_CC_TYPE, 1, 56)
self.cue_next_button = StateButton(is_momentary, MIDI_CC_TYPE, 1, 57)
self._do_toggle_cue.subject = self.cue_add_delete_button
self._do_toggle_prev_cue.subject = self.cue_prev_button
self._do_toggle_next_cue.subject = self.cue_next_button
def set_up_function_buttons(self):
is_momentary = True
self.keycolor_mod_button = StateButton(is_momentary, MIDI_CC_TYPE, 1,
73)
self._do_key_color.subject = self.keycolor_mod_button
self._update_button = ButtonElement(is_momentary, MIDI_CC_TYPE, 0, 86)
self._do_update_display.subject = self._update_button
@subject_slot('appointed_device')
def _on_appointed_device_changed(self):
self._modeselect._device_changed()
def _update_hardware(self):
self._session.update()
self._modeselect.refresh()
self.update_undo_redo(True)
def refresh_state(self):
ControlSurface.refresh_state(self)
self._update_hardware()
def _send_midi(self, midi_bytes, **keys):
self._c_ref.send_midi(midi_bytes)
return True
def init_text_display(self):
if USE_DISPLAY:
self._modeselect._pad_mode.update_text_display()
def _on_selected_track_changed(self):
super()._on_selected_track_changed()
self.set_controlled_track(self.song().view.selected_track)
self._on_devices_changed.subject = self.song().view.selected_track
@subject_slot('devices')
def _on_devices_changed(self):
pass
def update(self):
self.set_feedback_channels(FEEDBACK_CHANNELS)
super().update()
def is_monochrome(self):
return False
def _deassign_matrix(self):
for scene_index in range(4):
scene = self._session.scene(scene_index)
for track_index in range(4):
clip_slot = scene.clip_slot(track_index)
clip_slot.set_launch_button(None)
def update_display(self):
with self.component_guard():
with self._is_sending_scheduled_messages():
self._task_group.update(0.1)
self._modeselect.notify(self.blink_state)
self.blink_state = (self.blink_state + 1) % 4
self.display_task.tick()
self.update_undo_redo(False)
def update_undo_redo(self, force=False):
if force:
self.undo_state = self.song().can_undo
self.redo_state = self.song().can_redo
if self.song().can_undo != self.undo_state:
self.undo_state = self.song().can_undo
self._undo_button.send_value(self.undo_state == 1 and 127 or 0)
if self.song().can_redo != self.redo_state:
self.redo_state = self.song().can_redo
self._redo_button.send_value(self.redo_state == 1 and 127 or 0)
def adjust_loop_start(self, delta):
loopval = self.song().loop_start
self.song().loop_start = min(self.song().song_length,
max(0, loopval + delta))
def adjust_loop_length(self, delta):
loopval = self.song().loop_length
self.song().loop_length = min(self.song().song_length,
max(abs(delta), loopval + delta))
def _do_armsolo_mode(self, value):
pass
@subject_slot('value')
def _do_fire_button(self, value):
if not self._fire_button is not None:
raise AssertionError
else:
assert value in range(128)
if value != 0:
if self.isShiftDown():
self.song().tap_tempo()
else:
clip_slot = self.song().view.highlighted_clip_slot
if clip_slot:
clip_slot.fire()
@subject_slot('value')
def _do_undo(self, value):
if value != 0:
if self.use_layered_buttons() and self.isShiftDown():
if self.song().can_redo == 1:
self.song().redo()
self.show_message(str('REDO'))
elif self.song().can_undo == 1:
self.song().undo()
self.show_message(str('UNDO'))
@subject_slot('value')
def _do_redo(self, value):
if value != 0:
if self.song().can_redo == 1:
self.song().redo()
self.show_message(str('REDO'))
@subject_slot('value')
def _do_stop_all(self, value):
if value != 0:
if self.use_layered_buttons() and self.isShiftDown():
self.song().stop_all_clips(0)
else:
self.song().stop_all_clips(1)
def isShiftDown(self):
return self._editsection.isShiftdown()
def modifiers(self):
return self._editsection.modifiers()
def use_layered_buttons(self):
return False
def _handle_base_note(self, diff):
self._modeselect._pad_mode.inc_base_note(diff)
def _handle_octave(self, diff):
self._modeselect._pad_mode.inc_octave(diff)
octave_val = self._modeselect._pad_mode
def _handle_scale(self, diff):
self._modeselect._pad_mode.inc_scale(diff)
@subject_slot('value')
def _do_update_display(self, value):
if value != 0:
self.refresh_state()
@subject_slot('value')
def _do_key_color(self, value):
assert value in range(128)
if value != 0:
self._modeselect._pad_mode.step_key_color_mode()
@subject_slot('value')
def _do_tap_tempo(self, value):
assert value in range(128)
if value != 0:
self.song().tap_tempo()
@subject_slot('value')
def _do_toggle_cue(self, value):
assert value in range(128)
if value != 0:
self.song().set_or_delete_cue()
@subject_slot('value')
def _do_toggle_prev_cue(self, value):
assert value in range(128)
if value != 0:
self.song().jump_to_prev_cue()
@subject_slot('value')
def _do_toggle_next_cue(self, value):
assert value in range(128)
if value != 0:
self.song().jump_to_next_cue()
@subject_slot('value')
def _do_toggle_send(self, value):
if not value in range(128):
raise AssertionError
elif self.isShiftDown():
if value != 0:
self.refresh_state()
self.show_message('Refresh Display')
else:
nr_of_tracks = len(self.song().return_tracks)
if value == 0 or nr_of_tracks < 1:
return
prev = self.send_slider_index
self.send_slider_index += 1
if self.send_slider_index >= nr_of_tracks:
self.send_slider_index = 0
self.show_message(' Set Send ' +
str(SENDS[self.send_slider_index]))
self.timed_message(
2, ' Set Send ' + str(SENDS[self.send_slider_index]))
if prev != self.send_slider_index:
for track in range(8):
strip = self._mixer.channel_strip(track)
slider_list = []
for index in range(self.send_slider_index + 1):
if index < self.send_slider_index - 1:
slider_list.append(None)
else:
slider_list.append(self.send_sliders[track])
strip.set_send_controls(tuple(slider_list))
@subject_slot('value')
def _a_trk_left(self, value):
if value not in range(128):
raise AssertionError
if value != 0:
if self.application().view.is_view_visible('Session'):
direction = Live.Application.Application.View.NavDirection.left
self.application().view.scroll_view(
direction, 'Session', True)
track = self.song().view.selected_track
self.timed_message(2, 'T:' + track.name, False)
if self.arm_selected_track:
if track.can_be_armed:
arm_exclusive(self.song(), track)
@subject_slot('value')
def _a_trk_right(self, value):
if value not in range(128):
raise AssertionError
if value != 0:
if self.application().view.is_view_visible('Session'):
direction = Live.Application.Application.View.NavDirection.right
self.application().view.scroll_view(
direction, 'Session', True)
track = self.song().view.selected_track
self.timed_message(2, 'T:' + track.name, False)
if self.arm_selected_track:
if track.can_be_armed:
arm_exclusive(self.song(), track)
@subject_slot('value')
def _a_sel_arm(self, value):
if value != 0:
if self.arm_selected_track:
self.arm_selected_track = False
self.set_sel_arm_button.send_value(0, True)
else:
self.arm_selected_track = True
self.set_sel_arm_button.send_value(127, True)
@subject_slot('value')
def _nav_value_left(self, value):
if self._device_nav_button_left is None:
raise AssertionError
assert value in range(128)
modifier_pressed = True
if value != 0:
self.application().view.is_view_visible(
'Detail') and self.application().view.is_view_visible(
'Detail/DeviceChain') or self.application(
).view.show_view('Detail')
self.application().view.show_view('Detail/DeviceChain')
else:
direction = Live.Application.Application.View.NavDirection.left
self.application().view.scroll_view(direction,
'Detail/DeviceChain',
not modifier_pressed)
@subject_slot('value')
def _nav_value_right(self, value):
if not self._device_nav_button_right is not None:
raise AssertionError
else:
assert value in range(128)
if value != 0:
modifier_pressed = True
if self.application().view.is_view_visible('Detail'):
self.application().view.is_view_visible(
'Detail/DeviceChain') or self.application(
).view.show_view('Detail')
self.application().view.show_view('Detail/DeviceChain')
else:
direction = Live.Application.Application.View.NavDirection.right
self.application().view.scroll_view(
direction, 'Detail/DeviceChain', not modifier_pressed)
@subject_slot('value')
def _do_focus_navigate(self, value):
assert self._navigate_button is not None
assert value in range(128)
if value != 0:
self.nav_index = (self.nav_index + 1) % len(VIEWS_ALL)
self.application().view.focus_view(VIEWS_ALL[self.nav_index])
self.show_message('Focus on : ' + str(VIEWS_ALL[self.nav_index]))
def focus_clip_detail(self):
self.application().view.focus_view('Detail/Clip')
@subject_slot('follow_song')
def _song_follow_changed(self):
view = self.song().view
if view.follow_song:
self.song_follow_button.send_value(1, True)
else:
self.song_follow_button.send_value(0, True)
@subject_slot('value')
def _do_song_follow(self, value):
if value != 0:
view = self.song().view
if view.follow_song:
view.follow_song = False
self.song_follow_button.send_value(0, True)
else:
view.follow_song = True
self.song_follow_button.send_value(1, True)
@subject_slot('value')
def _hold_duplicate_action(self, value):
if value != 0:
pass
@subject_slot('value')
def _hold_clear_action(self, value):
if value != 0:
self._mixer.enter_clear_mode()
self._device_component.enter_clear_mode()
else:
self._mixer.exit_clear_mode()
self._device_component.exit_clear_mode()
@subject_slot('value')
def _action_toogle_main_view(self, value):
if value != 0:
appv = self.application().view
if appv.is_view_visible('Arranger'):
appv.show_view('Session')
else:
appv.show_view('Arranger')
@subject_slot('value')
def _action_toogle_detail_view(self, value):
if value != 0:
appv = self.application().view
if self.isShiftDown():
if appv.is_view_visible('Arranger'):
appv.show_view('Session')
else:
appv.show_view('Arranger')
elif appv.is_view_visible('Detail/Clip'):
appv.show_view('Detail/DeviceChain')
else:
appv.show_view('Detail/Clip')
@subject_slot('re_enable_automation_enabled')
def _on_change_reenabled(self):
if self.song().re_enable_automation_enabled:
self._reenable_button.turn_on()
else:
self._reenable_button.turn_off()
@subject_slot('value')
def _do_auto_reenable(self, value):
if value != 0:
self.song().re_enable_automation()
def to_color_edit_mode(self, active):
pass
def clear_display_all(self):
self.send_to_display('', 0)
self.send_to_display('', 1)
self.send_to_display('', 2)
self.send_to_display('', 3)
def clear_display(self, grid):
self.send_to_display('', grid)
def timed_message(self, grid, text, hold=False):
if USE_DISPLAY == False:
self.show_message(text)
else:
self.display_task.set_func(self.clear_display, grid)
self.send_to_display(text, grid)
if hold:
self.display_task.hold()
self.display_task.start()
def timed_message_release(self):
self.display_task.release()
def update_bank_display(self):
if USE_DISPLAY:
name, bank = self._device._current_bank_details()
if self._display_device_param:
prms = len(bank)
d1 = ''
for i in range(4):
parm = bank[i]
if parm:
name = parm.name
d1 += name[:6] + (i < 3 and '|' or '')
else:
d1 += ' ' + (i < 3 and '|' or '')
self.send_to_display(d1, 2)
d1 = ''
for i in range(4):
parm = bank[(i + 4)]
if parm:
name = parm.name
d1 += name[:6] + (i < 3 and '|' or '')
else:
d1 += ' ' + (i < 3 and '|' or '')
self.send_to_display(d1, 4)
else:
self.timed_message(2, 'Bank: ' + name)
def display_parameters(self, paramlist):
if USE_DISPLAY == False:
return
def send_to_display(self, text, grid=0):
if USE_DISPLAY == False:
return
if self._diplay_cache[grid] == text:
return
self._diplay_cache[grid] = text
if len(text) > 28:
text = text[:27]
msgsysex = [240, 0, 0, 102, 23, 18, min(grid, 3) * 28]
filled = text.ljust(28)
for c in filled:
msgsysex.append(ord(c))
msgsysex.append(247)
self._send_midi(tuple(msgsysex))
def cleanup(self):
pass
def disconnect(self):
self._pre_serialize()
self.clear_display_all()
for button, (track_index, scene_index) in self._bmatrix.iterbuttons():
if button:
button.send_color_direct(PColor.OFF[0])
time.sleep(0.2)
self._active = False
self._suppress_send_midi = True
super().disconnect()
class APC40(APC, OptimizedControlSurface):
def __init__(self, *a, **k):
(super(APC40, self).__init__)(*a, **k)
self._color_skin = make_biled_skin()
self._default_skin = make_default_skin()
with self.component_guard():
self._create_controls()
self._create_session()
self._create_mixer()
self._create_device()
self._create_detail_view_control()
self._create_transport()
self._create_global_control()
self._create_fallback_control_owner()
self._session.set_mixer(self._mixer)
self.set_highlighting_session_component(self._session)
self.set_device_component(self._device)
for component in self.components:
component.set_enabled(False)
def _with_shift(self, button):
return ComboElement(button, modifiers=[self._shift_button])
def _create_controls(self):
make_on_off_button = partial(make_button, skin=(self._default_skin))
make_color_button = partial(make_button, skin=(self._color_skin))
self._shift_button = make_button(0,
98,
resource_type=PrioritizedResource,
name='Shift_Button')
self._right_button = make_button(0,
96,
name='Bank_Select_Right_Button')
self._left_button = make_button(0, 97, name='Bank_Select_Left_Button')
self._up_button = make_button(0, 94, name='Bank_Select_Up_Button')
self._down_button = make_button(0, 95, name='Bank_Select_Down_Button')
self._session_matrix = ButtonMatrixElement(name='Button_Matrix')
self._scene_launch_buttons_raw = [
make_color_button(0, (index + 82),
name=('Scene_%d_Launch_Button' % index))
for index in range(SESSION_HEIGHT)
]
self._track_stop_buttons = [
make_color_button(index, 52, name=('Track_%d_Stop_Button' % index))
for index in range(SESSION_WIDTH)
]
self._stop_all_button = make_color_button(0,
81,
name='Stop_All_Clips_Button')
self._matrix_rows_raw = [[
make_color_button(track_index, (scene_index + 53),
name=('%d_Clip_%d_Button' %
(track_index, scene_index)))
for track_index in range(SESSION_WIDTH)
] for scene_index in range(SESSION_HEIGHT)]
for row in self._matrix_rows_raw:
self._session_matrix.add_row(row)
self._selected_slot_launch_button = make_pedal_button(
67, name='Selected_Slot_Launch_Button')
self._selected_scene_launch_button = make_pedal_button(
64, name='Selected_Scene_Launch_Button')
self._volume_controls = []
self._arm_buttons = []
self._solo_buttons = []
self._mute_buttons = []
self._select_buttons = []
for index in range(MIXER_SIZE):
self._volume_controls.append(
make_slider(index, 7, name=('%d_Volume_Control' % index)))
self._arm_buttons.append(
make_on_off_button(index, 48, name=('%d_Arm_Button' % index)))
self._solo_buttons.append(
make_on_off_button(index, 49, name=('%d_Solo_Button' % index)))
self._mute_buttons.append(
make_on_off_button(index, 50, name=('%d_Mute_Button' % index)))
self._select_buttons.append(
make_on_off_button(index,
51,
name=('%d_Select_Button' % index)))
self._crossfader_control = make_slider(0, 15, name='Crossfader')
self._master_volume_control = make_slider(0,
14,
name='Master_Volume_Control')
self._master_select_button = make_on_off_button(
0, 80, name='Master_Select_Button')
self._prehear_control = make_encoder(0,
47,
name='Prehear_Volume_Control')
self._device_bank_buttons = []
self._device_param_controls_raw = []
bank_button_labels = ('Clip_Track_Button', 'Device_On_Off_Button',
'Previous_Device_Button', 'Next_Device_Button',
'Detail_View_Button', 'Rec_Quantization_Button',
'Midi_Overdub_Button', 'Metronome_Button')
for index in range(8):
self._device_bank_buttons.append(
make_on_off_button(0, (58 + index),
name=(bank_button_labels[index])))
encoder_name = 'Device_Control_%d' % index
ringed_encoder = make_ring_encoder((16 + index), (24 + index),
name=encoder_name)
self._device_param_controls_raw.append(ringed_encoder)
self._play_button = make_button(0, 91, name='Play_Button')
self._stop_button = make_button(0, 92, name='Stop_Button')
self._record_button = make_button(0, 93, name='Record_Button')
self._nudge_up_button = make_button(0, 100, name='Nudge_Up_Button')
self._nudge_down_button = make_button(0, 101, name='Nudge_Down_Button')
self._tap_tempo_button = make_button(0, 99, name='Tap_Tempo_Button')
self._global_bank_buttons = []
self._global_param_controls = []
for index in range(8):
encoder_name = 'Track_Control_%d' % index
ringed_encoder = make_ring_encoder((48 + index), (56 + index),
name=encoder_name)
self._global_param_controls.append(ringed_encoder)
self._global_bank_buttons = [
make_on_off_button(0, (87 + index), name=name)
for index, name in enumerate(('Pan_Button', 'Send_A_Button',
'Send_B_Button', 'Send_C_Button'))
]
self._device_clip_toggle_button = self._device_bank_buttons[0]
self._device_on_off_button = self._device_bank_buttons[1]
self._detail_left_button = self._device_bank_buttons[2]
self._detail_right_button = self._device_bank_buttons[3]
self._detail_toggle_button = self._device_bank_buttons[4]
self._rec_quantization_button = self._device_bank_buttons[5]
self._overdub_button = self._device_bank_buttons[6]
self._metronome_button = self._device_bank_buttons[7]
def wrap_matrix(control_list, wrapper=nop):
return ButtonMatrixElement(rows=[list(map(wrapper, control_list))])
self._scene_launch_buttons = wrap_matrix(
self._scene_launch_buttons_raw)
self._track_stop_buttons = wrap_matrix(self._track_stop_buttons)
self._volume_controls = wrap_matrix(self._volume_controls)
self._arm_buttons = wrap_matrix(self._arm_buttons)
self._solo_buttons = wrap_matrix(self._solo_buttons)
self._mute_buttons = wrap_matrix(self._mute_buttons)
self._select_buttons = wrap_matrix(self._select_buttons)
self._device_param_controls = wrap_matrix(
self._device_param_controls_raw)
self._device_bank_buttons = wrap_matrix(
self._device_bank_buttons,
partial(DeviceBankButtonElement, modifiers=[self._shift_button]))
self._shifted_matrix = ButtonMatrixElement(
rows=(recursive_map(self._with_shift, self._matrix_rows_raw)))
self._shifted_scene_buttons = ButtonMatrixElement(rows=[[
self._with_shift(button)
for button in self._scene_launch_buttons_raw
]])
def _create_session(self):
self._session = SessionComponent(
SESSION_WIDTH,
SESSION_HEIGHT,
auto_name=True,
enable_skinning=True,
is_enabled=False,
layer=Layer(track_bank_left_button=(self._left_button),
track_bank_right_button=(self._right_button),
scene_bank_up_button=(self._up_button),
scene_bank_down_button=(self._down_button),
stop_all_clips_button=(self._stop_all_button),
stop_track_clip_buttons=(self._track_stop_buttons),
scene_launch_buttons=(self._scene_launch_buttons),
clip_launch_buttons=(self._session_matrix),
slot_launch_button=(self._selected_slot_launch_button),
selected_scene_launch_button=(
self._selected_scene_launch_button)))
self._session_zoom = SessionZoomingComponent(
(self._session),
name='Session_Overview',
enable_skinning=True,
is_enabled=False,
layer=Layer(button_matrix=(self._shifted_matrix),
nav_up_button=(self._with_shift(self._up_button)),
nav_down_button=(self._with_shift(self._down_button)),
nav_left_button=(self._with_shift(self._left_button)),
nav_right_button=(self._with_shift(
self._right_button)),
scene_bank_buttons=(self._shifted_scene_buttons)))
def _create_mixer(self):
self._mixer = MixerComponent(
MIXER_SIZE,
auto_name=True,
is_enabled=False,
invert_mute_feedback=True,
layer=Layer(volume_controls=(self._volume_controls),
arm_buttons=(self._arm_buttons),
solo_buttons=(self._solo_buttons),
mute_buttons=(self._mute_buttons),
track_select_buttons=(self._select_buttons),
shift_button=(self._shift_button),
crossfader_control=(self._crossfader_control),
prehear_volume_control=(self._prehear_control)))
self._mixer.master_strip().layer = Layer(
volume_control=(self._master_volume_control),
select_button=(self._master_select_button))
def _create_device(self):
self._device = DeviceComponent(
name='Device_Component',
is_enabled=False,
layer=Layer(bank_buttons=(self._device_bank_buttons),
on_off_button=(self._device_on_off_button)),
use_fake_banks=True,
device_selection_follows_track_selection=True)
ChannelTranslationSelector(8, name='Control_Translations')
self._device.set_parameter_controls(
tuple(self._device_param_controls_raw))
def _create_detail_view_control(self):
self._detail_view_toggler = DetailViewCntrlComponent(
name='Detail_View_Control',
is_enabled=False,
layer=Layer(
device_clip_toggle_button=(self._device_clip_toggle_button),
detail_toggle_button=(self._detail_toggle_button),
device_nav_left_button=(self._detail_left_button),
device_nav_right_button=(self._detail_right_button)))
def _create_transport(self):
self._transport = TransportComponent(
name='Transport',
is_enabled=False,
layer=Layer(play_button=(self._play_button),
stop_button=(self._stop_button),
record_button=(self._record_button),
nudge_up_button=(self._nudge_up_button),
nudge_down_button=(self._nudge_down_button),
tap_tempo_button=(self._tap_tempo_button),
quant_toggle_button=(self._rec_quantization_button),
overdub_button=(self._overdub_button),
metronome_button=(self._metronome_button)))
self._bank_button_translator = ChannelTranslationSelector(
name='Bank_Button_Translations', is_enabled=False)
def _create_global_control(self):
def set_pan_controls():
for index, control in enumerate(self._global_param_controls):
self._mixer.channel_strip(index).set_pan_control(control)
self._mixer.channel_strip(index).set_send_controls(
(None, None, None))
control.set_channel(0)
def set_send_controls(send_index):
for index, control in enumerate(self._global_param_controls):
self._mixer.channel_strip(index).set_pan_control(None)
send_controls = [None] * 3
send_controls[send_index] = control
self._mixer.channel_strip(index).set_send_controls(
send_controls)
control.set_channel(send_index + 1)
encoder_modes = ModesComponent(name='Track_Control_Modes',
is_enabled=False)
encoder_modes.add_mode('pan', [set_pan_controls])
encoder_modes.add_mode('send_a', [partial(set_send_controls, 0)])
encoder_modes.add_mode('send_b', [partial(set_send_controls, 1)])
encoder_modes.add_mode('send_c', [partial(set_send_controls, 2)])
encoder_modes.selected_mode = 'pan'
encoder_modes.layer = Layer(
pan_button=(self._global_bank_buttons[0]),
send_a_button=(self._global_bank_buttons[1]),
send_b_button=(self._global_bank_buttons[2]),
send_c_button=(self._global_bank_buttons[3]))
self._translation_selector = ChannelTranslationSelector(
name='Global_Translations')
def _create_fallback_control_owner(self):
self.register_disconnectable(
SimpleLayerOwner(
layer=Layer(_matrix=(self._session_matrix),
priority=FALLBACK_CONTROL_OWNER_PRIORITY)))
def get_matrix_button(self, column, row):
return self._matrix_rows_raw[row][column]
def _product_model_id_byte(self):
return 115
class APC20(APC):
def __init__(self, *a, **k):
(super(APC20, self).__init__)(*a, **k)
self._skin = make_biled_skin()
with self.component_guard():
self._create_controls()
self._create_session()
self._create_mixer()
self._create_transport()
self._create_background()
self._create_global_control()
self._session.set_mixer(self._mixer)
self.set_highlighting_session_component(self._session)
for component in self.components:
component.set_enabled(False)
def _activate_combination_mode(self, track_offset, support_devices):
super(APC20, self)._activate_combination_mode(track_offset,
support_devices)
if support_devices:
self._shift_modes.invert_assignment()
def _create_controls(self):
make_color_button = partial(make_button, skin=(self._skin))
self._shift_button = make_button(0, 81, name='Shift_Button')
self._matrix = ButtonMatrixElement(name='Button_Matrix')
self._scene_launch_buttons = [
make_color_button(0, (index + 82),
name=('Scene_%d_Launch_Button' % index))
for index in range(SESSION_HEIGHT)
]
self._track_stop_buttons = [
make_color_button(index, 52, name=('Track_%d_Stop_Button' % index))
for index in range(SESSION_WIDTH)
]
for scene_index in range(SESSION_HEIGHT):
row = [
make_color_button(track_index, (scene_index + 53),
name=('%d_Clip_%d_Button' %
(track_index, scene_index)))
for track_index in range(SESSION_WIDTH)
]
self._matrix.add_row(row)
self._selected_scene_launch_button = make_pedal_button(
64, name='Selected_Scene_Launch_Button')
self._scene_launch_buttons = ButtonMatrixElement(
name='Scene_Launch_Buttons', rows=[self._scene_launch_buttons])
self._solo_buttons = [
make_button(track_index, 49, name=('%d_Solo_Button' % track_index))
for track_index in range(MIXER_SIZE)
]
self._mute_buttons = [
make_button(track_index, 50, name=('%d_Mute_Button' % track_index))
for track_index in range(MIXER_SIZE)
]
self._master_volume_control = make_slider(0,
14,
name='Master_Volume_Control')
self._prehear_control = EncoderElement(
MIDI_CC_TYPE,
0,
47, (MapMode.relative_two_compliment),
name='Prehear_Volume_Control')
self._master_select_button = make_button(0,
80,
name='Master_Select_Button')
self._select_buttons = [
make_button(track_index,
51,
name=('%d_Select_Button' % track_index))
for track_index in range(8)
]
self._arm_buttons = [
make_button(track_index, 48, name=('%d_Arm_Button' % track_index))
for track_index in range(8)
]
self._sliders = [
make_slider(track_index,
7,
name=('%d_Volume_Control' % track_index))
for track_index in range(8)
]
self._note_matrix = ButtonMatrixElement(name='Note_Button_Matrix')
self._note_buttons = [[
make_button(9, (note + i), name=('Note_%d_Button' % (note + i)))
for i in range(4)
] for note in range(36, 75, 4)]
for row in self._note_buttons:
for button in row:
button.send_depends_on_forwarding = False
self._note_matrix.add_row(row)
def _create_session(self):
self._session = SessionComponent(SESSION_WIDTH,
SESSION_HEIGHT,
name='Session_Control',
auto_name=True,
enable_skinning=True)
self._session.set_clip_launch_buttons(self._matrix)
self._session.set_stop_track_clip_buttons(
tuple(self._track_stop_buttons))
self._session.set_scene_launch_buttons(self._scene_launch_buttons)
for scene_index in range(SESSION_HEIGHT):
scene = self._session.scene(scene_index)
for track_index in range(SESSION_WIDTH):
clip_slot = scene.clip_slot(track_index)
clip_slot.name = '%d_Clip_Slot_%d' % (track_index, scene_index)
self._session.selected_scene().set_launch_button(
self._selected_scene_launch_button)
self._session_zoom = ShiftableZoomingComponent(
(self._session), (tuple(self._track_stop_buttons)),
name='Session_Overview',
enable_skinning=True)
self._session_zoom.set_button_matrix(self._matrix)
self._session_zoom.set_zoom_button(self._shift_button)
self._session_zoom.set_scene_bank_buttons(self._scene_launch_buttons)
def _create_mixer(self):
self._mixer = MixerComponent(MIXER_SIZE, name='Mixer')
self._mixer.master_strip().name = 'Master_Channel_Strip'
self._mixer.selected_strip().name = 'Selected_Channel_Strip'
buttons = zip(self._solo_buttons, self._mute_buttons)
for track_index, (solo_button, mute_button) in enumerate(buttons):
strip = self._mixer.channel_strip(track_index)
strip.name = 'Channel_Strip_%d' % track_index
strip.set_solo_button(solo_button)
strip.set_mute_button(mute_button)
strip.set_shift_button(self._shift_button)
strip.set_invert_mute_feedback(True)
self._mixer.set_prehear_volume_control(self._prehear_control)
self._mixer.master_strip().set_volume_control(
self._master_volume_control)
def _create_transport(self):
self._transport = TransportComponent(name='Transport')
def _create_background(self):
self._background = BackgroundComponent(name='Background')
def _create_global_control(self):
self._slider_modes = SliderModesComponent((self._mixer),
(tuple(self._sliders)),
name='Slider_Modes')
self._shift_modes = ShiftableSelectorComponent(
(tuple(self._select_buttons)), (self._master_select_button),
(tuple(self._arm_buttons)), (self._matrix), (self._session),
(self._session_zoom), (self._mixer), (self._transport),
(self._slider_modes), (self._send_introduction_message),
(self._note_matrix), (self._background),
name='Shift_Modes')
self._shift_modes.set_mode_toggle(self._shift_button)
def _product_model_id_byte(self):
return 123
