class Maschine(ControlSurface):
"""Basic Control Script for All Maschine Modell Mikro, Mikro Mk2, Mk1, Mk2, Studio"""
__module__ = __name__
def __init__(self, c_instance):
super(Maschine, self).__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'])
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(Maschine, self)._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(Maschine, self).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)
return
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):
assert self._fire_button != None
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()
return
@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):
assert value in range(128)
if 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))
return
@subject_slot('value')
def _a_trk_left(self, value):
assert value in range(128)
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 and track.can_be_armed:
arm_exclusive(self.song(), track)
@subject_slot('value')
def _a_trk_right(self, value):
assert value in range(128)
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 and 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):
assert self._device_nav_button_left != None
assert value in range(128)
modifier_pressed = True
if value != 0:
if not self.application().view.is_view_visible(
'Detail') or not self.application().view.is_view_visible(
'Detail/DeviceChain'):
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)
return
@subject_slot('value')
def _nav_value_right(self, value):
assert self._device_nav_button_right != None
assert value in range(128)
if value != 0:
modifier_pressed = True
if not self.application().view.is_view_visible(
'Detail') or not self.application().view.is_view_visible(
'Detail/DeviceChain'):
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)
return
@subject_slot('value')
def _do_focus_navigate(self, value):
assert self._navigate_button != 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]))
return
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(Maschine, self).disconnect()
return
class AumPC40(APC40):
def __init__(self, c_instance, *a, **k):
super(AumPC40, self).__init__(c_instance, *a, **k)
self._monomod_version = 'b996'
self._host_name = 'AumPC'
self._color_type = 'APC'
self._timer = 0
self._touched = 0
self.flash_status = False
with self.component_guard():
self._setup_monobridge()
self._setup_mod()
self._device_component._current_bank_details = self._make_current_bank_details(self._device_component)
def disconnect(self):
super(AumPC40, self).disconnect()
rebuild_sys()
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 = [ make_color_button(0, index + 82, name='Scene_%d_Launch_Button' % index, cs = self) for index in xrange(SESSION_HEIGHT) ]
self._track_stop_buttons = [ make_color_button(index, 52, name='Track_%d_Stop_Button' % index, cs = self) for index in xrange(SESSION_WIDTH) ]
self._stop_all_button = make_color_button(0, 81, name='Stop_All_Clips_Button', cs = self)
self._matrix_rows_raw = [ [ make_color_button(track_index, scene_index + 53, name='%d_Clip_%d_Button' % (track_index, scene_index), cs = self) for track_index in xrange(SESSION_WIDTH) ] for scene_index in xrange(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._original_solo_buttons = []
self._original_mute_buttons = []
self._select_buttons = []
for index in xrange(MIXER_SIZE):
self._volume_controls.append(make_slider(index, 7, name='%d_Volume_Control' % index, num=index, script = self))
self._arm_buttons.append(make_on_off_button(index, 48, name='%d_Arm_Button' % index, cs = self))
self._original_solo_buttons.append(make_on_off_button(index, 49, name='%d_Solo_Button' % index, cs = self))
self._original_mute_buttons.append(make_on_off_button(index, 50, name='%d_Mute_Button' % index, cs = self))
self._select_buttons.append(make_on_off_button(index, 51, name='%d_Select_Button' % index, cs = self))
self._crossfader_control = make_slider(0, 15, name='Crossfader', script = self)
self._master_volume_control = make_slider(0, 14, name='Master_Volume_Control', script = self)
self._master_select_button = make_on_off_button(0, 80, name='Master_Select_Button', cs = self)
self._prehear_control = make_encoder(0, 47, name='Prehear_Volume_Control', script = self)
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, num = index + 8, script = self)
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, num = index, script = self)
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]
self._monomod = ButtonMatrixElement(name = 'Monomod')
for row in self._matrix_rows_raw:
self._monomod.add_row(row)
self._monomod.add_row(self._track_stop_buttons)
self._monomod.add_row(self._select_buttons)
self._monomod.add_row(self._original_mute_buttons)
#self._doublepress_detail_button = DoublePressElement(self._detail_toggle_button)
def wrap_matrix(control_list, wrapper = nop):
return ButtonMatrixElement(rows=[map(wrapper, control_list)])
self._scene_launch_buttons = wrap_matrix(self._scene_launch_buttons)
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._original_solo_buttons = wrap_matrix(self._original_solo_buttons)
self._original_mute_buttons = wrap_matrix(self._original_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._solo_buttons = self._original_solo_buttons
self._mute_buttons = self._original_mute_buttons
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, device_nav_left_button=self._detail_left_button, device_nav_right_button=self._detail_right_button)) #detail_toggle_button=self._detail_toggle_button
def _setup_monobridge(self):
self._monobridge = MonoBridgeElement(self)
self._monobridge.name = 'MonoBridge'
def _setup_mod(self):
self.monomodular = get_monomodular(self)
self.monomodular.name = 'monomodular_switcher'
self.modhandler = APCModHandler(self)
self.modhandler.name = 'ModHandler'
self.modhandler.layer = Layer(priority = 5,
grid = self._monomod,
nav_up_button = self._up_button,
nav_down_button = self._down_button,
nav_left_button = self._left_button,
nav_right_button = self._right_button,
shiftlock_button = self._nudge_up_button,
alt_button = self._nudge_down_button,
shift_button = self._shift_button)
self.modhandler.set_device_component(self._device_component)
self.modhandler.set_enabled(False)
self._monomod_mode = MonomodModeComponent(self._monomod_mode_update, self)
self._monomod_mode.name = "Monomod_Mode_Component"
self._monomod_mode.layer = Layer(priority = 5, mode_toggle = self._detail_toggle_button)
self._on_shift_value.subject = self._shift_button
@subject_slot('value')
def _on_shift_value(self, value):
#self._monomod_mode.set_enabled(value>0)
self._monomod_mode.set_enabled(value is 0)
#self.modhandler.is_enabled() and self.modhanlder._shift_value(value)
if value:
self.modhandler.set_lock_button(self._detail_toggle_button)
else:
self.modhandler.set_lock_button(None)
def _monomod_mode_update(self):
#self.log_message('mode update: ' + str(self._monomod_mode._mode_index))
if(self._monomod_mode._mode_index == 0):
self.flash_status = False
self.modhandler.set_enabled(False)
self._monomod.reset()
self._on_selected_track_changed()
elif(self._monomod_mode._mode_index == 1):
self.flash_status = True
self._monomod.reset()
self.modhandler.set_enabled(True)
self._detail_toggle_button.send_value(self._monomod_mode._mode_index)
"""m4l bridge"""
def generate_strip_string(self, display_string):
#self.log_message(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 += ' '
assert (len(ret) == NUM_CHARS_PER_DISPLAY_STRIP)
return ret
def notification_to_bridge(self, name, value, sender):
if isinstance(sender, (MonoRingedEncoderElement, MonoEncoderElement)):
self._monobridge._send(sender.name, 'lcd_name', str(self.generate_strip_string(name)))
self._monobridge._send(sender.name, 'lcd_value', str(self.generate_strip_string(value)))
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 get_clip_names(self):
clip_names = []
for scene in self._session._scenes:
for clip_slot in scene._clip_slots:
if clip_slot.has_clip() is True:
clip_names.append(clip_slot._clip_slot)##.clip.name)
return clip_slot._clip_slot
##self.log_message(str(clip_slot._clip_slot.clip.name))
return clip_names
def update_display(self):
super(AumPC40, self).update_display()
self._timer = (self._timer + 1) % 256
self.flash()
def flash(self):
if self.flash_status:
for control, _ in self._monomod.iterbuttons():
if isinstance(control, MonoButtonElement):
control.flash(self._timer)
def _make_current_bank_details(self, device_component):
def _current_bank_details():
if not self.modhandler.active_mod() is None:
if self.modhandler.active_mod() and self.modhandler.active_mod()._param_component._device_parent != None:
bank_name = self.modhandler.active_mod()._param_component._bank_name
bank = [param._parameter for param in self.modhandler.active_mod()._param_component._params]
if self.modhandler._alt_value.subject and self.modhandler._alt_value.subject.is_pressed():
bank = bank[8:]
#self.log_message('current mod bank details: ' + str(bank_name) + ' ' + str(bank))
return (bank_name, bank)
else:
return DeviceComponent._current_bank_details(device_component)
else:
return DeviceComponent._current_bank_details(device_component)
return _current_bank_details
class Maschine(ControlSurface):
__module__ = __name__
__doc__ = 'Basic Control Script for All Maschine Modell Mikro, Mikro Mk2, Mk1, Mk2, Studio'
def __init__(self, c_instance):
super(Maschine, self).__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'])
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.prehear_knob = SliderElement(MIDI_CC_TYPE, 0, 41)
self.prehear_knob.connect_to(self.song().master_track.mixer_device.cue_volume)
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(Maschine, self)._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(Maschine, self).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):
raise self._fire_button != None or AssertionError
raise value in range(128) or AssertionError
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):
if not value in range(128):
raise AssertionError
value != 0 and self._modeselect._pad_mode.step_key_color_mode()
@subject_slot('value')
def _do_tap_tempo(self, value):
if not value in range(128):
raise AssertionError
value != 0 and self.song().tap_tempo()
@subject_slot('value')
def _do_toggle_cue(self, value):
if not value in range(128):
raise AssertionError
value != 0 and self.song().set_or_delete_cue()
@subject_slot('value')
def _do_toggle_prev_cue(self, value):
if not value in range(128):
raise AssertionError
value != 0 and self.song().jump_to_prev_cue()
@subject_slot('value')
def _do_toggle_next_cue(self, value):
if not value in range(128):
raise AssertionError
value != 0 and self.song().jump_to_next_cue()
@subject_slot('value')
def _do_toggle_send(self, value):
if not value in range(128):
raise AssertionError
if self.isShiftDown():
value != 0 and 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 not value 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)
self.arm_selected_track and track.can_be_armed and arm_exclusive(self.song(), track)
@subject_slot('value')
def _a_trk_right(self, value):
if not value 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)
self.arm_selected_track and track.can_be_armed and 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 not self._device_nav_button_left != None:
raise AssertionError
if not value in range(128):
raise AssertionError
modifier_pressed = True
value != 0 and (not self.application().view.is_view_visible('Detail') or not self.application().view.is_view_visible('Detail/DeviceChain')) and 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 != None:
raise AssertionError
if not value in range(128):
raise AssertionError
modifier_pressed = value != 0 and True
(not self.application().view.is_view_visible('Detail') or not self.application().view.is_view_visible('Detail/DeviceChain')) and 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):
if not self._navigate_button != None:
raise AssertionError
raise value in range(128) or AssertionError
self.nav_index = value != 0 and (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(Maschine, self).disconnect()
class AumPC20(APC20):
def __init__(self, c_instance, *a, **k):
self._monomod_version = 'b996'
self._host_name = 'AumPC'
self._color_type = 'APC'
self._timer = 0
self._touched = 0
self.flash_status = False
super(AumPC20, self).__init__(c_instance, *a, **k)
with self.component_guard():
self._setup_mod()
def disconnect(self):
super(AumPC20, self).disconnect()
rebuild_sys()
def _create_controls(self):
make_color_button = partial(make_button, skin=self._skin)
self._shift_button = make_button(0, 81, name='Shift_Button', num = 0, cs = self)
self._matrix = ButtonMatrixElement(name='Button_Matrix')
self._scene_launch_buttons_raw = [ make_color_button(0, index + 82, name='Scene_%d_Launch_Button' % index, num = index, cs = self) for index in xrange(SESSION_HEIGHT) ]
self._track_stop_buttons = [ make_color_button(index, 52, name='Track_%d_Stop_Button' % index, num = index, cs = self) for index in xrange(SESSION_WIDTH) ]
self._matrix_rows_raw = []
for scene_index in xrange(SESSION_HEIGHT):
row = [ make_color_button(track_index, scene_index + 53, name='%d_Clip_%d_Button' % (track_index, scene_index), num = index, cs = self) for track_index in xrange(SESSION_WIDTH) ]
self._matrix_rows_raw.append(row)
self._matrix.add_row(row)
self._selected_scene_launch_button = make_pedal_button(64, name='Selected_Scene_Launch_Button')
self._scene_launch_buttons = ButtonMatrixElement(rows=[self._scene_launch_buttons_raw])
self._solo_buttons = [ make_button(track_index, 49, name='%d_Solo_Button' % track_index, num = track_index, cs = self) for track_index in xrange(MIXER_SIZE) ]
self._mute_buttons = [ make_button(track_index, 50, name='%d_Mute_Button' % track_index, num = track_index, cs = self) for track_index in xrange(MIXER_SIZE) ]
self._master_volume_control = make_slider(0, 14, name='Master_Volume_Control', num = 0, script = self)
self._prehear_control = EncoderElement(MIDI_CC_TYPE, 0, 47, MapMode.relative_two_compliment, name='Prehear_Volume_Control', num = 0, script = self)
self._master_select_button = make_button(0, 80, name='Master_Select_Button', num = index, cs = self)
self._select_buttons = [ make_button(track_index, 51, name='%d_Select_Button' % track_index, num = track_index, cs = self ) for track_index in xrange(8) ]
self._arm_buttons = [ make_button(track_index, 48, name='%d_Arm_Button' % track_index, num = track_index, cs = self) for track_index in xrange(8) ]
self._sliders = [ make_slider(track_index, 7, name='%d_Volume_Control' % track_index, num = track_index, script = self) for track_index in xrange(8) ]
self._monomod = ButtonMatrixElement(name = 'Monomod')
for row in self._matrix_rows_raw:
self._monomod.add_row(row)
self._monomod.add_row(self._track_stop_buttons)
self._monomod.add_row(self._select_buttons)
self._monomod.add_row(self._mute_buttons)
self._setup_monobridge() #had to put this here b/c the original author foolishly placed assignment methods inside of creation methods...argh.
def _setup_monobridge(self):
self._monobridge = MonoBridgeElement(self)
self._monobridge.name = 'MonoBridge'
def _setup_mod(self):
self.monomodular = get_monomodular(self)
self.monomodular.name = 'monomodular_switcher'
self.modhandler = APCModHandler(self)
self.modhandler.name = 'ModHandler'
self.modhandler.layer = Layer(priority = 5,
grid = self._monomod,
nav_up_button = self._scene_launch_buttons_raw[2],
nav_down_button = self._scene_launch_buttons_raw[3],
lock_button = self._scene_launch_buttons_raw[4],
shiftlock_button = self._scene_launch_buttons_raw[0],
alt_button = self._scene_launch_buttons_raw[1],
shift_button = self._shift_button)
self.modhandler.set_enabled(False)
self._monomod_mode = MonomodModeComponent(self._monomod_mode_update, self)
self._monomod_mode.name = "Monomod_Mode_Component"
self._monomod_mode.layer = Layer(priority = 5, mode_toggle = self._master_select_button)
self._on_shift_value.subject = self._shift_button
self._on_master_value.subject = self._master_select_button
@subject_slot('value')
def _on_shift_value(self, value):
self._monomod_mode.set_enabled(value>0)
@subject_slot('value')
def _on_master_value(self, value):
if not self._shift_button.is_pressed() and not self.modhandler.is_enabled():
self.schedule_message(1, self._shift_modes.update)
def _monomod_mode_update(self):
#self.log_message('mode update: ' + str(self._monomod_mode._mode_index))
if(self._monomod_mode._mode_index == 0):
self.flash_status = False
self.modhandler.set_enabled(False)
self._slider_modes.set_enabled(True)
self._shift_modes.set_enabled(True)
self._scene_launch_buttons[2].set_on_off_values(127, 0)
self._scene_launch_buttons[3].set_on_off_values(127, 0)
self._monomod.reset()
self._shift_modes.set_enabled(True)
for track in range(8):
self._mixer.channel_strip(track).set_mute_button(self._mute_buttons[track])
self._session.set_enabled(True)
self._session_zoom._is_zoomed_out = False
self._session_zoom.set_enabled(True)
self._transport.set_enabled(True)
self.request_rebuild_midi_map()
self.schedule_message(1, self._shift_modes.update)
elif(self._monomod_mode._mode_index == 1):
self._slider_modes.set_enabled(False)
if self._shift_modes._note_mode_active is True:
self._shift_modes._mode_callback(ABLETON_MODE)
self._shift_modes._note_mode_active = False
self._session_zoom.set_ignore_buttons(False)
self._shift_modes._transport.update()
self._shift_modes._on_note_mode_changed()
self._shift_modes.set_enabled(False)
self._session.set_clip_launch_buttons(None)
for track in range(8):
self._mixer.channel_strip(track).set_select_button(None)
self._mixer.channel_strip(track).set_mute_button(None)
self._session.set_track_bank_buttons(None, None)
self._session.set_scene_bank_buttons(None, None)
for scene in range(5):
self._scene_launch_buttons[scene].turn_off()
self._transport.set_enabled(False)
self._session.set_enabled(False)
self._session_zoom.set_enabled(False)
self.flash_status = True
self._monomod.reset()
self.modhandler.set_enabled(True)
self._master_select_button.send_value(self._monomod_mode._mode_index)
"""m4l bridge"""
def generate_strip_string(self, display_string):
#self.log_message(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 += ' '
assert (len(ret) == NUM_CHARS_PER_DISPLAY_STRIP)
return ret
def notification_to_bridge(self, name, value, sender):
if isinstance(sender, (MonoRingedEncoderElement, MonoEncoderElement)):
self._monobridge._send(sender.name, 'lcd_name', str(self.generate_strip_string(name)))
self._monobridge._send(sender.name, 'lcd_value', str(self.generate_strip_string(value)))
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 get_clip_names(self):
clip_names = []
for scene in self._session._scenes:
for clip_slot in scene._clip_slots:
if clip_slot.has_clip() is True:
clip_names.append(clip_slot._clip_slot)##.clip.name)
return clip_slot._clip_slot
##self.log_message(str(clip_slot._clip_slot.clip.name))
return clip_names
def update_display(self):
super(AumPC20, self).update_display()
self._timer = (self._timer + 1) % 256
self.flash()
def flash(self):
if self.flash_status:
for control, _ in self._monomod.iterbuttons():
if isinstance(control, MonoButtonElement):
control.flash(self._timer)
class AumPC20(APC20):
def __init__(self, c_instance, *a, **k):
self._monomod_version = 'b996'
self._host_name = 'AumPC'
self._color_type = 'APC'
self._timer = 0
self._touched = 0
self.flash_status = False
super(AumPC20, self).__init__(c_instance, *a, **k)
with self.component_guard():
self._setup_mod()
def disconnect(self):
super(AumPC20, self).disconnect()
rebuild_sys()
def _create_controls(self):
make_color_button = partial(make_button, skin=self._skin)
self._shift_button = make_button(0,
81,
name='Shift_Button',
num=0,
cs=self)
self._matrix = ButtonMatrixElement(name='Button_Matrix')
self._scene_launch_buttons_raw = [
make_color_button(0,
index + 82,
name='Scene_%d_Launch_Button' % index,
num=index,
cs=self) for index in xrange(SESSION_HEIGHT)
]
self._track_stop_buttons = [
make_color_button(index,
52,
name='Track_%d_Stop_Button' % index,
num=index,
cs=self) for index in xrange(SESSION_WIDTH)
]
self._matrix_rows_raw = []
for scene_index in xrange(SESSION_HEIGHT):
row = [
make_color_button(
track_index,
scene_index + 53,
name='%d_Clip_%d_Button' % (track_index, scene_index),
num=index,
cs=self) for track_index in xrange(SESSION_WIDTH)
]
self._matrix_rows_raw.append(row)
self._matrix.add_row(row)
self._selected_scene_launch_button = make_pedal_button(
64, name='Selected_Scene_Launch_Button')
self._scene_launch_buttons = ButtonMatrixElement(
rows=[self._scene_launch_buttons_raw])
self._solo_buttons = [
make_button(track_index,
49,
name='%d_Solo_Button' % track_index,
num=track_index,
cs=self) for track_index in xrange(MIXER_SIZE)
]
self._mute_buttons = [
make_button(track_index,
50,
name='%d_Mute_Button' % track_index,
num=track_index,
cs=self) for track_index in xrange(MIXER_SIZE)
]
self._master_volume_control = make_slider(0,
14,
name='Master_Volume_Control',
num=0,
script=self)
self._prehear_control = EncoderElement(MIDI_CC_TYPE,
0,
47,
MapMode.relative_two_compliment,
name='Prehear_Volume_Control',
num=0,
script=self)
self._master_select_button = make_button(0,
80,
name='Master_Select_Button',
num=index,
cs=self)
self._select_buttons = [
make_button(track_index,
51,
name='%d_Select_Button' % track_index,
num=track_index,
cs=self) for track_index in xrange(8)
]
self._arm_buttons = [
make_button(track_index,
48,
name='%d_Arm_Button' % track_index,
num=track_index,
cs=self) for track_index in xrange(8)
]
self._sliders = [
make_slider(track_index,
7,
name='%d_Volume_Control' % track_index,
num=track_index,
script=self) for track_index in xrange(8)
]
self._monomod = ButtonMatrixElement(name='Monomod')
for row in self._matrix_rows_raw:
self._monomod.add_row(row)
self._monomod.add_row(self._track_stop_buttons)
self._monomod.add_row(self._select_buttons)
self._monomod.add_row(self._mute_buttons)
self._setup_monobridge(
) #had to put this here b/c the original author foolishly placed assignment methods inside of creation methods...argh.
def _setup_monobridge(self):
self._monobridge = MonoBridgeElement(self)
self._monobridge.name = 'MonoBridge'
def _setup_mod(self):
self.monomodular = get_monomodular(self)
self.monomodular.name = 'monomodular_switcher'
self.modhandler = APCModHandler(self)
self.modhandler.name = 'ModHandler'
self.modhandler.layer = Layer(
priority=5,
grid=self._monomod,
nav_up_button=self._scene_launch_buttons_raw[2],
nav_down_button=self._scene_launch_buttons_raw[3],
lock_button=self._scene_launch_buttons_raw[4],
shiftlock_button=self._scene_launch_buttons_raw[0],
alt_button=self._scene_launch_buttons_raw[1],
shift_button=self._shift_button)
self.modhandler.set_enabled(False)
self._monomod_mode = MonomodModeComponent(self._monomod_mode_update,
self)
self._monomod_mode.name = "Monomod_Mode_Component"
self._monomod_mode.layer = Layer(
priority=5, mode_toggle=self._master_select_button)
self._on_shift_value.subject = self._shift_button
self._on_master_value.subject = self._master_select_button
@subject_slot('value')
def _on_shift_value(self, value):
self._monomod_mode.set_enabled(value > 0)
@subject_slot('value')
def _on_master_value(self, value):
if not self._shift_button.is_pressed(
) and not self.modhandler.is_enabled():
self.schedule_message(1, self._shift_modes.update)
def _monomod_mode_update(self):
#self.log_message('mode update: ' + str(self._monomod_mode._mode_index))
if (self._monomod_mode._mode_index == 0):
self.flash_status = False
self.modhandler.set_enabled(False)
self._slider_modes.set_enabled(True)
self._shift_modes.set_enabled(True)
self._scene_launch_buttons[2].set_on_off_values(127, 0)
self._scene_launch_buttons[3].set_on_off_values(127, 0)
self._monomod.reset()
self._shift_modes.set_enabled(True)
for track in range(8):
self._mixer.channel_strip(track).set_mute_button(
self._mute_buttons[track])
self._session.set_enabled(True)
self._session_zoom._is_zoomed_out = False
self._session_zoom.set_enabled(True)
self._transport.set_enabled(True)
self.request_rebuild_midi_map()
self.schedule_message(1, self._shift_modes.update)
elif (self._monomod_mode._mode_index == 1):
self._slider_modes.set_enabled(False)
if self._shift_modes._note_mode_active is True:
self._shift_modes._mode_callback(ABLETON_MODE)
self._shift_modes._note_mode_active = False
self._session_zoom.set_ignore_buttons(False)
self._shift_modes._transport.update()
self._shift_modes._on_note_mode_changed()
self._shift_modes.set_enabled(False)
self._session.set_clip_launch_buttons(None)
for track in range(8):
self._mixer.channel_strip(track).set_select_button(None)
self._mixer.channel_strip(track).set_mute_button(None)
self._session.set_track_bank_buttons(None, None)
self._session.set_scene_bank_buttons(None, None)
for scene in range(5):
self._scene_launch_buttons[scene].turn_off()
self._transport.set_enabled(False)
self._session.set_enabled(False)
self._session_zoom.set_enabled(False)
self.flash_status = True
self._monomod.reset()
self.modhandler.set_enabled(True)
self._master_select_button.send_value(self._monomod_mode._mode_index)
"""m4l bridge"""
def generate_strip_string(self, display_string):
#self.log_message(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 += ' '
assert (len(ret) == NUM_CHARS_PER_DISPLAY_STRIP)
return ret
def notification_to_bridge(self, name, value, sender):
if isinstance(sender, (MonoRingedEncoderElement, MonoEncoderElement)):
self._monobridge._send(sender.name, 'lcd_name',
str(self.generate_strip_string(name)))
self._monobridge._send(sender.name, 'lcd_value',
str(self.generate_strip_string(value)))
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 get_clip_names(self):
clip_names = []
for scene in self._session._scenes:
for clip_slot in scene._clip_slots:
if clip_slot.has_clip() is True:
clip_names.append(clip_slot._clip_slot) ##.clip.name)
return clip_slot._clip_slot
##self.log_message(str(clip_slot._clip_slot.clip.name))
return clip_names
def update_display(self):
super(AumPC20, self).update_display()
self._timer = (self._timer + 1) % 256
self.flash()
def flash(self):
if self.flash_status:
for control, _ in self._monomod.iterbuttons():
if isinstance(control, MonoButtonElement):
control.flash(self._timer)
class Eeboo(ControlSurface):
""" Script for Eeboo's Controller """
__module__=__name__ #name of the class
__doc__="Eeboo function" #documentation
def __init__(self, c_instance):
super(Eeboo, self).__init__(c_instance)
with self.component_guard(): #don't know the us of this, but it is recquiered in live 9 scripts
self.__c_instance = c_instance
# identifies P&d1 as a ButtonElement. IS_MOMENTARY is true if the button send a message on being released
self.show_message("Hack enabled! Let's get groove!")
############ TODO => use it #########
self._clip = None
self._is_active = True
self._playing_position_buttons = True
self._is_following = True
self._quantization = 0.25
# Playhead current position
self._row_index = None
self._column_index = None
# number of buttons per row
self._width = 8
# number of row of 8 buttons
self.bank_display_capabilities = 2
#####################################
# TODO remove line here :: not usefull
row_1 = [ make_button(0, 32 + idx) for idx in xrange(8) ]
row_2 = [ make_button(0, 48 + idx) for idx in xrange(8) ]
self._grid_buttons = ButtonMatrixElement(name='Scene_Launch_Buttons', rows=[ row_1, row_2 ])
for pad in self._grid_buttons:
pad.add_value_listener(self.on_pad_pressed, identify_sender= False)
self.song().view.add_detail_clip_listener(self._on_selected_clip)
#self.song().add_current_song_time_listener(self._song_time_listener)
def build_midi_map(self, midi_map_handle):
ControlSurface.build_midi_map(self, midi_map_handle)
self.log_message( "midi"+str(midi_map_handle) )
def receive_midi(self, midi_bytes):
ControlSurface.receive_midi(self, midi_bytes)
self.log_message("receive"+ str(midi_bytes) )
def on_pad_pressed(self, value):
self.log_message( 'pad pressed' + str(value) )
def _on_selected_clip(self):
# add_detail_clip_listener is triggered even slot is empty
if self.song().view.detail_clip != None:
# remove listener
if self._clip != None:
if self._clip.playing_status_has_listener(self._on_playing_status_changed):
self._clip.remove_playing_status_listener(self._on_playing_status_changed)
if self._clip.playing_position_has_listener(self._on_playing_position_changed):
self._clip.remove_playing_position_listener(self._on_playing_position_changed)
# new value
self._clip = self.song().view.detail_clip
# add listener
if self._clip.is_midi_clip:
self._clip.add_playing_status_listener(self._on_playing_status_changed)
self._clip.add_playing_position_listener(self._on_playing_position_changed)
self.update_matrix_with_notes()
def _on_playing_status_changed(self):
self.log_message( " on_playing_status_changed: " )
if self._clip.is_playing:
self.show_message( "clip playing" )
def _on_playing_position_changed(self):
self.__on_playing_position_changed()
def is_enabled(self):
return True
""" note tuple (63, 0.0, 2.5, 100, False) pitch = 63, start = 0.0, length = 0.0, velocity = 100 """
def update_matrix_with_notes(self):
notes = self._clip.get_notes(0.0, 0, self._clip.length, 127)
for note in notes:
start = note[1]
index = start / self._quantization
button = self._grid_buttons[ int(index) ]
self._send_midi((176, button.message_identifier() ,127))
self.log_message( "note on: " +str(index) )
def __on_playing_position_changed(self): #playing position changed listener
if self.is_enabled() and self._is_active:
self._sequencer_clip = self._clip
if self._playing_position_buttons != None:
if self._sequencer_clip != None:
"""LiveAPI clip.playing_position: Constant access to the current playing position of the clip.
The returned value is the position in beats for midi and warped audio clips,
or in seconds for unwarped audio clips. Stopped clips will return 0."""
position = self._sequencer_clip.playing_position #position in beats (1/4 notes in 4/4 time)
row = int(position / self._quantization / self._width) # 0.25 for 16th notes; 0.5 for 8th notes
column = int(position / self._quantization) - (row * self._width) #stepped postion
if( row != self._row_index or column != self._column_index ):
self._row_index = row
self._column_index = column
self.log_message( "row:" + str(row) + "column:" + str(column))
for button, (y, x) in self._grid_buttons.iterbuttons():
#self.log_message('x:'+str(x)+' y:'+str(y))
if( row == x and y == column ):
#self.log_message( 'row: ' + str(row) + ' ,column:' + str(column) )
#button.turn_on()
#self._grid_buttons.set_light(x, y, True)
self._send_midi((176, button.message_identifier() ,127))
#self.log_message('turn on: ' + str(button.message_identifier()) + " row:" + str(x) + "column:" + str(y))
else:
#button.turn_off()
#self._grid_buttons.set_light(x, y, False)
self._send_midi((176, button.message_identifier(),0))
else:
self.log_message( '#####' )
self.update_matrix_with_notes()
