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)
class MaschineMk2(Maschine):
__doc__ = 'Control Script for Maschine Studio'
__module__ = __name__
_gated_buttons = []
def __init__(self, c_instance):
super().__init__(c_instance)
def create_pad_button(self, scene_index, track_index, color_source):
return PadColorButton(True, 0, scene_index, track_index, color_source)
def create_gated_button(self, identifier, hue):
button = GatedColorButton(True, MIDI_CC_TYPE, identifier, hue)
self._gated_buttons.append(button)
return button
def _init_maschine(self):
self._jogwheel = KnobSection(self._modeselect, self._editsection)
self._note_repeater.registerKnobHandler(self._jogwheel)
self._mixer.set_touch_mode(2)
self._device_component.set_touch_mode(2)
self.prehear_knob = SliderElement(MIDI_CC_TYPE, 0, 41)
self.prehear_knob.connect_to(
self.song().master_track.mixer_device.cue_volume)
def to_color_edit_mode(self, active):
if self._editsection.is_color_edit() != active:
self._jogwheel.invoke_color_mode(active and 1 or 0)
def use_layered_buttons(self):
return True
def _final_init(self):
debug_out('########## LIVE 9 MASCHINE Mk2 V 2.02 ############# ')
def _click_measure(self):
pass
def apply_preferences(self):
super().apply_preferences()
pref_dict = self._pref_dict
if 'color_mode' in pref_dict:
value = pref_dict['color_mode']
self._session.set_color_mode(value)
self._session._c_mode_button.send_value(value == True and 127 or 0,
True)
else:
self._session.set_color_mode(False)
self._session._c_mode_button.send_value(0, True)
def store_preferences(self):
super().store_preferences()
self._pref_dict['color_mode'] = self._session.is_color_mode()
def preferences_name(self):
return 'MaschineMk2'
def cleanup(self):
for button in self._gated_buttons:
button.switch_off()
def _setup_mixer_control(self):
is_momentary = True
num_tracks = 8
num_returns = 7
mixer = MixerComponent(num_tracks, num_returns)
for track in range(num_tracks):
strip = mixer.channel_strip(track)
strip.set_volume_control(
SliderElement(MIDI_CC_TYPE, 15, 54 - track))
strip.set_pan_control(SliderElement(MIDI_CC_TYPE, 15, 80 - track))
strip.set_mute_button(
ButtonElement(is_momentary, MIDI_CC_TYPE, 15, 117 - track))
strip.set_invert_mute_feedback(True)
for track in range(num_returns):
strip = mixer.return_strip(track)
strip.set_volume_control(
SliderElement(MIDI_CC_TYPE, 15, 10 + track))
mixer.set_bank_buttons(
ButtonElement(is_momentary, MIDI_CC_TYPE, 15, 108),
ButtonElement(is_momentary, MIDI_CC_TYPE, 15, 109))
mixer.set_crossfader_control(SliderElement(MIDI_CC_TYPE, 15, 9))
mixer.master_strip().set_volume_control(
SliderElement(MIDI_CC_TYPE, 15, 46))
session = SessionComponent(0, 0)
session.set_select_buttons(
ButtonElement(is_momentary, MIDI_CC_TYPE, 15, 95),
ButtonElement(is_momentary, MIDI_CC_TYPE, 15, 92))
session.selected_scene().set_launch_button(
ButtonElement(is_momentary, MIDI_CC_TYPE, 15, 91))
def _setup_mixer_control(self):
is_momentary = True
mixer = MixerComponent(NUM_TRACKS, 2)
for track in range(NUM_TRACKS):
strip = mixer.channel_strip(track)
strip.set_volume_control(SliderElement(MIDI_CC_TYPE, track, 23))
strip.set_pan_control(
EncoderElement(MIDI_CC_TYPE, track, 10,
Live.MidiMap.MapMode.absolute))
strip.set_send_controls(
(EncoderElement(MIDI_CC_TYPE, track, 19,
Live.MidiMap.MapMode.absolute),
EncoderElement(MIDI_CC_TYPE, track, 20,
Live.MidiMap.MapMode.absolute)))
strip.set_solo_button(
ButtonElement(is_momentary, MIDI_NOTE_TYPE, track, 64))
strip.set_mute_button(
ButtonElement(is_momentary, MIDI_NOTE_TYPE, track, 63))
strip.set_crossfade_toggle(
ButtonElement(is_momentary, MIDI_NOTE_TYPE, track, 65))
eq = mixer.track_eq(track)
eq.set_gain_controls(
tuple([
EncoderElement(MIDI_CC_TYPE, track, 18 - index,
Live.MidiMap.MapMode.absolute)
for index in range(3)
]))
eq.set_cut_buttons(
tuple([
ButtonElement(is_momentary, MIDI_NOTE_TYPE, track,
62 - index) for index in range(3)
]))
filter = mixer.track_filter(track)
filter.set_filter_controls(
EncoderElement(MIDI_CC_TYPE, track, 22,
Live.MidiMap.MapMode.absolute),
EncoderElement(MIDI_CC_TYPE, track, 21,
Live.MidiMap.MapMode.absolute))
for ret_track in range(2):
strip = mixer.return_strip(ret_track)
strip.set_volume_control(
SliderElement(MIDI_CC_TYPE, 12, 22 + ret_track))
strip.set_pan_control(
EncoderElement(MIDI_CC_TYPE, 12, 20 + ret_track,
Live.MidiMap.MapMode.absolute))
strip.set_mute_button(
ButtonElement(is_momentary, MIDI_NOTE_TYPE, 12,
78 + ret_track))
mixer.set_crossfader_control(SliderElement(MIDI_CC_TYPE, 12, 8))
mixer.set_prehear_volume_control(
EncoderElement(MIDI_CC_TYPE, 12, 24,
Live.MidiMap.MapMode.absolute))
mixer.master_strip().set_volume_control(
SliderElement(MIDI_CC_TYPE, 12, 7))
mixer.master_strip().set_pan_control(
EncoderElement(MIDI_CC_TYPE, 12, 10,
Live.MidiMap.MapMode.absolute))
return mixer
def __init__(self, c_instance):
ControlSurface.__init__(self, c_instance)
with self.component_guard():
self.set_pad_translations(PAD_TRANSLATIONS)
self._suggested_input_port = 'DirectLink'
self._suggested_output_port = 'DirectLink'
self._waiting_for_first_response = True
self._has_sliders = True
self._current_midi_map = None
self._display_reset_delay = -1
self._shift_pressed = False
self._shift_button = ButtonElement(IS_MOMENTARY, MIDI_CC_TYPE, 15,
13)
self._master_slider = SliderElement(MIDI_CC_TYPE, 15, 41)
self._next_nav_button = ButtonElement(IS_MOMENTARY, MIDI_CC_TYPE,
15, 111)
self._prev_nav_button = ButtonElement(IS_MOMENTARY, MIDI_CC_TYPE,
15, 110)
self._device_bank_buttons = None
self._device_navigation = None
self._shift_button.name = 'Shift_Button'
self._master_slider.name = 'Master_Volume_Control'
self._next_nav_button.name = 'Next_Track_Button'
self._prev_nav_button.name = 'Prev_Track_Button'
self._master_slider.add_value_listener((self._slider_value),
identify_sender=True)
self._shift_button.add_value_listener(self._shift_value)
self._setup_mixer()
self._setup_transport_and_session()
self._setup_device()
self._setup_display()
for component in self.components:
component.set_enabled(False)
def __init__(self, button_index, monochrome=False, *a, **k):
(super().__init__)(button_index, *a, **k)
self._note_display_mode = ND_KEYBOARD1
self.current_scale_index = 0
self._scale = None
self._base_note = 0
self._octave = 0.55
self.current_scale_index = 0
self._in_edit_mode = False
self._editmode = None
self._is_monochrome = monochrome
self._color_edit_assign = monochrome and self.assign_edit_mono or self.assign_edit_color
self.assign_transpose(SCALES[self.current_scale_index])
is_momentary = True
self.octave_down_button = ButtonElement(is_momentary, MIDI_CC_TYPE, 3,
120)
self.octave_up_button = ButtonElement(is_momentary, MIDI_CC_TYPE, 3,
121)
self.base_down_button = ButtonElement(is_momentary, MIDI_CC_TYPE, 3,
124)
self.base_up_button = ButtonElement(is_momentary, MIDI_CC_TYPE, 3, 125)
self.scale_down_button = ButtonElement(is_momentary, MIDI_CC_TYPE, 3,
118)
self.scale_up_button = ButtonElement(is_momentary, MIDI_CC_TYPE, 3,
119)
self._adjust_scale.subject = SliderElement(MIDI_CC_TYPE, 2, 116)
self._adjust_octav.subject = SliderElement(MIDI_CC_TYPE, 2, 115)
self._adjust_basem.subject = SliderElement(MIDI_CC_TYPE, 2, 117)
self._do_oct_down.subject = self.octave_down_button
self._do_oct_up.subject = self.octave_up_button
self._do_base_down.subject = self.base_down_button
self._do_base_up.subject = self.base_up_button
self._do_scale_down.subject = self.scale_down_button
self._do_scale_up.subject = self.scale_up_button
self._seg_display = None
def _init_maschine(self):
self._jogwheel = KnobSection(self._modeselect, self._editsection)
self._note_repeater.registerKnobHandler(self._jogwheel)
self._mixer.set_touch_mode(2)
self._device_component.set_touch_mode(2)
self.prehear_knob = SliderElement(MIDI_CC_TYPE, 0, 41)
self.prehear_knob.connect_to(
self.song().master_track.mixer_device.cue_volume)
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 __init__(self, note_repeat=None, *a, **k):
(super().__init__)(*a, **k)
self._note_repeat = note_repeat
self._adjust_cfg_value.subject = SliderElement(MIDI_CC_TYPE, 2, 105)
self._note_repeat_button = ButtonElement(True, MIDI_CC_TYPE, 0, 102)
self._do_note_repeat.subject = self._note_repeat_button
self._cfg_adjust_button = ButtonElement(True, MIDI_CC_TYPE, 2, 106)
self._cfg_adjust_button.add_value_listener(self._do_cfg_button)
self._cfg_down = False
self._hold_mode = False
self.nr_down = False
self._current_nr_button = None
self._do_change_nr_1.subject = SliderElement(MIDI_CC_TYPE, 1, 76)
self._do_change_nr_2.subject = SliderElement(MIDI_CC_TYPE, 1, 77)
self._do_change_nr_3.subject = SliderElement(MIDI_CC_TYPE, 1, 78)
self._do_change_nr_4.subject = SliderElement(MIDI_CC_TYPE, 1, 79)
def createButton(ccindenfier, nr_freq):
button = ButtonElement(True, MIDI_CC_TYPE, 1, ccindenfier)
button.add_value_listener(self._select_value, True)
button.active = False
button.freq = nr_freq
button.cfg = False
button.hold = False
return button
def createCfgButton(ccindenfier, nr_freq_idx):
button = ButtonElement(True, MIDI_CC_TYPE, 2, ccindenfier)
button.add_value_listener(self._select_value, True)
button.active = False
button.fr_idx = nr_freq_idx
button.freq = CFG_REPEAT_FREQUENCIES[nr_freq_idx]
button.cfg = True
button.hold = False
return button
self._cfg_buttons = [
createCfgButton(assign[0], assign[1])
for assign in CTRL_CFG_TO_FREQ
]
for button in self._cfg_buttons:
button.send_value(button.active and 1 or 0, True)
self.nr_frq = CTRL_TO_FREQ[4][1]
self._note_repeat.repeat_rate = 1.0 / self.nr_frq * 4.0
self.buttons = [
createButton(assign[0], assign[1]) for assign in CTRL_TO_FREQ
]
self.buttons[4].active = True
self._previous_button = self.buttons[4]
self._last_active_button = self.buttons[4]
for button in self.buttons:
button.send_value(button.active and 1 or 0, True)
def __init__(self, c_instance):
ControlSurface.__init__(self, c_instance)
with self.component_guard():
is_momentary = True
self._suggested_input_port = 'Oxygen'
self._suggested_output_port = 'Oxygen'
self._has_slider_section = True
self._shift_button = ButtonElement(is_momentary, MIDI_CC_TYPE,
GLOBAL_CHANNEL, 57)
self._shift_button.add_value_listener(self._shift_value)
self._mixer = SpecialMixerComponent(NUM_TRACKS)
self._mute_solo_buttons = []
self._track_up_button = ButtonElement(is_momentary, MIDI_CC_TYPE,
GLOBAL_CHANNEL, 111)
self._track_down_button = ButtonElement(is_momentary, MIDI_CC_TYPE,
GLOBAL_CHANNEL, 110)
self._master_slider = SliderElement(MIDI_CC_TYPE, GLOBAL_CHANNEL,
41)
for index in range(NUM_TRACKS):
self._mute_solo_buttons.append(
ButtonElement(is_momentary, MIDI_CC_TYPE, GLOBAL_CHANNEL,
49 + index))
self._mixer.channel_strip(index).set_volume_control(
SliderElement(MIDI_CC_TYPE, GLOBAL_CHANNEL, 33 + index))
self._shift_value(0)
self._mixer.master_strip().set_volume_control(self._master_slider)
self._mixer.selected_strip().set_volume_control(None)
device = DeviceComponent(
device_selection_follows_track_selection=True)
device.set_parameter_controls(
tuple([
EncoderElement(MIDI_CC_TYPE, GLOBAL_CHANNEL, 17 + index,
Live.MidiMap.MapMode.absolute)
for index in range(8)
]))
self.set_device_component(device)
ffwd_button = ButtonElement(is_momentary, MIDI_CC_TYPE,
GLOBAL_CHANNEL, 115)
rwd_button = ButtonElement(is_momentary, MIDI_CC_TYPE,
GLOBAL_CHANNEL, 114)
loop_button = ButtonElement(is_momentary, MIDI_CC_TYPE,
GLOBAL_CHANNEL, 113)
transport = TransportComponent()
transport.set_stop_button(
ButtonElement(is_momentary, MIDI_CC_TYPE, GLOBAL_CHANNEL, 116))
transport.set_play_button(
ButtonElement(is_momentary, MIDI_CC_TYPE, GLOBAL_CHANNEL, 117))
transport.set_record_button(
ButtonElement(is_momentary, MIDI_CC_TYPE, GLOBAL_CHANNEL, 118))
session = SessionComponent(0, 0)
transport_view_modes = TransportViewModeSelector(
transport, session, ffwd_button, rwd_button, loop_button)
def __init__(self, modeselector, editsection, *a, **k):
super(CompoundComponent, self).__init__(*a, **k)
self._modesel = modeselector
self._editsection = editsection
is_momentary = True
self._do_push_button.subject = ButtonElement(is_momentary,
MIDI_CC_TYPE, 0, 82)
self._do_edit_slider.subject = SliderElement(MIDI_CC_TYPE, 1, 81)
self._do_channel_slider.subject = SliderElement(MIDI_CC_TYPE, 1, 83)
self._do_channel_button.subject = ButtonElement(
is_momentary, MIDI_CC_TYPE, 1, 63)
self._do_req_quantize.subject = SliderElement(MIDI_CC_TYPE, 1, 100)
self._do_browse.subject = SliderElement(MIDI_CC_TYPE, 1, 84)
self._do_tempo.subject = SliderElement(MIDI_CC_TYPE, 1, 101)
self._do_volume.subject = SliderElement(MIDI_CC_TYPE, 1, 103)
self._do_dedicated_rec_quantize.subject = SliderElement(
MIDI_CC_TYPE, 2, 112)
self._do_dedicated_clip_quantize.subject = SliderElement(
MIDI_CC_TYPE, 2, 113)
self.set_up_function_buttons()
self._wheel_overide = None
self.scrub_mode = True
self.select_arm_mode = True
self._push_down = False
return
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_control(self):
is_momentary = True
transport = TransportComponent()
transport.set_play_button(
ButtonElement(is_momentary, MIDI_NOTE_TYPE, 12, 80))
transport.set_record_button(
ButtonElement(is_momentary, MIDI_NOTE_TYPE, 12, 81))
transport.set_nudge_buttons(
ButtonElement(is_momentary, MIDI_NOTE_TYPE, 12, 86),
ButtonElement(is_momentary, MIDI_NOTE_TYPE, 12, 85))
transport.set_loop_button(
ButtonElement(is_momentary, MIDI_NOTE_TYPE, 12, 84))
transport.set_punch_buttons(
ButtonElement(is_momentary, MIDI_NOTE_TYPE, 12, 82),
ButtonElement(is_momentary, MIDI_NOTE_TYPE, 12, 83))
transport.set_tempo_control(SliderElement(MIDI_CC_TYPE, 12, 26),
SliderElement(MIDI_CC_TYPE, 12, 25))
def __init__(self, modeselector, editsection, *a, **k):
(super().__init__)(*a, **k)
self._modesel = modeselector
self._editsection = editsection
self._modesel.connect_main_knob(self)
is_momentary = True
self.main_knob = SliderElement(MIDI_CC_TYPE, 1, 85)
self.push_button = ButtonElement(is_momentary, MIDI_CC_TYPE, 1, 87)
self.volume_button = ButtonElement(is_momentary, MIDI_CC_TYPE, 3, 110)
self.swing_button = ButtonElement(is_momentary, MIDI_CC_TYPE, 3, 111)
self.tempo_button = ButtonElement(is_momentary, MIDI_CC_TYPE, 3, 112)
self.xfade_button = ButtonElement(is_momentary, MIDI_CC_TYPE, 3, 116)
self._mode_button = self.canonical_parent.create_gated_button(
80, KSM_HUES[0])
self._color_edit_button = ButtonElement(is_momentary, MIDI_CC_TYPE, 3,
113)
self._set_inicliplen_button = ButtonElement(is_momentary, MIDI_CC_TYPE,
3, 122)
self._set_quantize_button = ButtonElement(is_momentary, MIDI_CC_TYPE,
3, 126)
self.do_main.subject = self.main_knob
self.do_main_push.subject = self.push_button
self._do_volume.subject = self.volume_button
self._do_swing.subject = self.swing_button
self._do_tempo.subject = self.tempo_button
self._do_xfade.subject = self.xfade_button
self._do_toggle_mode.subject = self._mode_button
self._do_color_button.subject = self._color_edit_button
self._do_mikr_cliplen.subject = self._set_inicliplen_button
self._do_mikr_quantize.subject = self._set_quantize_button
self._do_dedicated_rec_quantize.subject = SliderElement(
MIDI_CC_TYPE, 2, 112)
self._do_dedicated_clip_quantize.subject = SliderElement(
MIDI_CC_TYPE, 2, 113)
self._radio_buttons = (self.volume_button, self.swing_button,
self.tempo_button, self.xfade_button,
self._color_edit_button)
self._do_button_left.subject = ButtonElement(is_momentary,
MIDI_CC_TYPE, 2, 120)
self._do_button_right.subject = ButtonElement(is_momentary,
MIDI_CC_TYPE, 2, 121)
self.volume_button.send_value(0, True)
self._mode_button.set_color(KSM_HUES[0])
self.knob_action = self._scroll_action
self._prev_mode = None
self._prev_action = None
def __init__(self, *a, **k):
(super().__init__)(*a, **k)
is_momentary = True
self.split_knob = SliderElement(MIDI_CC_TYPE, 5, 70)
self.gate_knob = SliderElement(MIDI_CC_TYPE, 5, 71)
self.bend_knob = SliderElement(MIDI_CC_TYPE, 5, 72)
self.offset_knob = SliderElement(MIDI_CC_TYPE, 5, 73)
self.strech_knob = SliderElement(MIDI_CC_TYPE, 5, 74)
self.fade_knob = SliderElement(MIDI_CC_TYPE, 5, 75)
self.transpose_knob = SliderElement(MIDI_CC_TYPE, 5, 77)
self.edit_button = ButtonElement(is_momentary, MIDI_CC_TYPE, 5, 60)
self.split_button = ButtonElement(is_momentary, MIDI_CC_TYPE, 5, 61)
self.init_button = ButtonElement(is_momentary, MIDI_CC_TYPE, 5, 62)
self.delete_button = ButtonElement(is_momentary, MIDI_CC_TYPE, 5, 63)
self.select_button = ButtonElement(is_momentary, MIDI_CC_TYPE, 5, 64)
self._do_edit_button.subject = self.edit_button
self._do_split_button.subject = self.split_button
self._do_delete.subject = self.delete_button
self._do_init.subject = self.init_button
self._do_select.subject = self.select_button
self._do_split.subject = self.split_knob
self._do_gate.subject = self.gate_knob
self._do_bend.subject = self.bend_knob
self._do_offset.subject = self.offset_knob
self._do_strech.subject = self.strech_knob
self._do_fade.subject = self.fade_knob
self._do_transpose.subject = self.transpose_knob
def _create_controls(self):
self._device_encoders = ButtonMatrixElement(rows=[[
EncoderElement(MIDI_CC_TYPE,
ENCODER_CHANNEL,
identifier, (Live.MidiMap.MapMode.
relative_smooth_binary_offset),
name=('Device_Encoder_%d_%d' %
(col_index, row_index)))
for col_index, identifier in enumerate(row)
] for row_index, row in enumerate((ENCODER_MSG_IDS[:4],
ENCODER_MSG_IDS[4:8]))])
self._horizontal_scroll_encoder = EncoderElement(
MIDI_CC_TYPE,
ENCODER_CHANNEL, (ENCODER_MSG_IDS[(-2)]),
(Live.MidiMap.MapMode.relative_smooth_binary_offset),
name='Horizontal_Scroll_Encoder')
self._vertical_scroll_encoder = EncoderElement(
MIDI_CC_TYPE,
ENCODER_CHANNEL, (ENCODER_MSG_IDS[(-1)]),
(Live.MidiMap.MapMode.relative_smooth_binary_offset),
name='Vertical_Scroll_Encoder')
self._volume_sliders = ButtonMatrixElement(rows=[[
SliderElement(MIDI_CC_TYPE, ENCODER_CHANNEL, identifier)
for identifier in SLIDER_MSG_IDS[:-1]
]])
self._master_slider = SliderElement(MIDI_CC_TYPE, ENCODER_CHANNEL,
SLIDER_MSG_IDS[(-1)])
def make_keylab_button(name):
button = ButtonElement(True,
MIDI_CC_TYPE,
0, (get_button_identifier_by_name(name)),
name=(name.title()))
return button
for button_name in list(BUTTON_HARDWARE_AND_MESSAGE_IDS.keys()):
setattr(self, '_' + button_name, make_keylab_button(button_name))
self._pads = ButtonMatrixElement(rows=[[
ButtonElement(True,
MIDI_CC_TYPE,
PAD_CHANNEL, (col_index + row_offset),
name=('Pad_%d_%d' % (col_index, row_index)))
for col_index in range(4)
] for row_index, row_offset in enumerate(range(48, 35, -4))])
def _setup_transport(self):
is_momentary = True
self.shiftButton = SysExButton(120, name='Shift_Button')
self._MaschineJam__play_button = StateButton(is_momentary,
MIDI_CC_TYPE,
0,
108,
name='Play_Button')
self._hand_play_pressed.subject = self._MaschineJam__play_button
self._listen_playing.subject = self.song()
self._channel_led_left = SliderElement(MIDI_CC_TYPE, 0, 38)
self._channel_led_right = SliderElement(MIDI_CC_TYPE, 0, 39)
self._channel_led_left.last_raw = 0.0
self._channel_led_left.last_send = 0
self._channel_led_right.last_raw = 0.0
self._channel_led_right.last_send = 0
self._listen_master_left.subject = self.song().master_track
self._listen_master_right.subject = self.song().master_track
self._auto_button = StateButton(is_momentary,
MIDI_CC_TYPE,
0,
98,
name='Auto_Button')
self._listen_automation_record.subject = self.song()
self._handle_automation_record.subject = self._auto_button
self._do_direction_up.subject = StateButton(is_momentary,
MIDI_CC_TYPE,
0,
40,
name='Up_Arrow')
self._do_direction_down.subject = StateButton(is_momentary,
MIDI_CC_TYPE,
0,
41,
name='Down_Arrow')
self._do_direction_left.subject = StateButton(is_momentary,
MIDI_CC_TYPE,
0,
42,
name='Left_Arrow')
self._do_direction_right.subject = StateButton(is_momentary,
MIDI_CC_TYPE,
0,
43,
name='Right_Arrow')
def _create_controls(self):
self._encoders = ButtonMatrixElement(rows=[
[EncoderElement(MIDI_CC_TYPE, 0, identifier, (Live.MidiMap.MapMode.absolute), name=('Encoder_%d' % index)) for index, identifier in enumerate(ENCODER_IDS)]])
self._master_encoder = EncoderElement(MIDI_CC_TYPE,
0, 10, (Live.MidiMap.MapMode.absolute), name='Master_Encoder')
self._sliders = ButtonMatrixElement(rows=[
[SliderElement(MIDI_CC_TYPE, 0, identifier, name=('Slider_%d' % index)) for index, identifier in enumerate(SLIDER_IDS)]])
self._master_slider = SliderElement(MIDI_CC_TYPE, 0, 7, name='Master_Slider')
self._play_button = ButtonElement(True, MIDI_CC_TYPE, 0, 26)
self._stop_button = ButtonElement(True, MIDI_CC_TYPE, 0, 25)
self._record_button = ButtonElement(True, MIDI_CC_TYPE, 0, 28)
self._forward_button = ButtonElement(True, MIDI_CC_TYPE, 0, 24)
self._backward_button = ButtonElement(True, MIDI_CC_TYPE, 0, 21)
self._ff_button = ButtonElement(True, MIDI_CC_TYPE, 0, 23)
self._rw_button = ButtonElement(True, MIDI_CC_TYPE, 0, 22)
self._device_mode_button = ButtonElement(True, MIDI_CC_TYPE, 0, 80)
self._pan_mode_button = ButtonElement(True, MIDI_CC_TYPE, 0, 81)
self._send_a_mode_button = ButtonElement(True, MIDI_CC_TYPE, 0, 82)
self._send_b_mode_button = ButtonElement(True, MIDI_CC_TYPE, 0, 83)
self._pads = ButtonMatrixElement(rows=[[ButtonElement(True, MIDI_NOTE_TYPE, 0, identifier) for identifier in row] for row in PAD_ROWS])
def __init__(self, *a, **k):
(super().__init__)(*a, **k)
is_momentary = True
self.mikro_shift_button = ButtonElement(is_momentary, MIDI_CC_TYPE, 2, 80)
self._do_shift_mikro.subject = self.mikro_shift_button
self.shift_button = ButtonElement(is_momentary, MIDI_CC_TYPE, 1, 80)
self._do_shift.subject = self.shift_button
self.alt_button = ButtonElement(is_momentary, MIDI_CC_TYPE, 1, 82)
self._do_alt.subject = self.alt_button
self.mikro_shift = False
self.shiftdown = False
self.altdown = False
self.edit_state = ES_NONE
self._down_button = None
self._action_set_quant.subject = SliderElement(MIDI_CC_TYPE, 2, 110)
self._action_init_loop.subject = SliderElement(MIDI_CC_TYPE, 2, 111)
self._nav_button = StateButton(is_momentary, MIDI_CC_TYPE, 0, 115)
self._action_navigate.subject = self._nav_button
self._copy_button = StateButton(is_momentary, MIDI_CC_TYPE, 0, 95)
self._action_duplicate.subject = self._copy_button
self._quantize_button = StateButton(is_momentary, MIDI_CC_TYPE, 0, 97)
self._action_quantize.subject = self._quantize_button
self._paste_button = StateButton(is_momentary, MIDI_CC_TYPE, 0, 96)
self._action_new.subject = self._paste_button
self._note_button = StateButton(is_momentary, MIDI_CC_TYPE, 0, 101)
self._action_note.subject = self._note_button
self._clear_button = StateButton(is_momentary, MIDI_CC_TYPE, 0, 103)
self._action_clear.subject = self._clear_button
self._nudge_button = StateButton(is_momentary, MIDI_CC_TYPE, 0, 100)
self._action_nudge_button.subject = self._nudge_button
self.action_time = False
self.pad_action = False
self.pad_wheel_action = False
self.quantize = 5
self.quantize_amount = 1.0
self.initial_clip_len = 4.0
self._focused_clip = None
self._focused_c_index = None
self._color_edit = False
self.nav_index = 0
def __init__(self, c_instance):
ControlSurface.__init__(self, c_instance)
with self.component_guard():
self.set_pad_translations(PAD_TRANSLATIONS)
self._suggested_input_port = 'Impulse'
self._suggested_output_port = 'Impulse'
self._has_sliders = True
self._current_midi_map = None
self._display_reset_delay = -1
self._shift_button = ButtonElement(IS_MOMENTARY, MIDI_CC_TYPE, 0,
39)
self._preview_button = ButtonElement(IS_MOMENTARY, MIDI_CC_TYPE, 0,
41)
self._master_slider = SliderElement(MIDI_CC_TYPE, 0, 8)
self._shift_button.name = 'Shift_Button'
self._master_slider.name = 'Master_Volume_Control'
self._master_slider.add_value_listener((self._slider_value),
identify_sender=True)
self._preview_button.add_value_listener(self._preview_value)
self._setup_mixer()
self._setup_session()
self._setup_transport()
self._setup_device()
self._setup_name_display()
device_button = ButtonElement(not IS_MOMENTARY, MIDI_CC_TYPE, 1,
10)
mixer_button = ButtonElement(not IS_MOMENTARY, MIDI_CC_TYPE, 1, 9)
device_button.name = 'Encoder_Device_Mode'
mixer_button.name = 'Encoder_Mixer_Mode'
self._encoder_modes = EncoderModeSelector(self._device_component,
self._mixer,
self._next_bank_button,
self._prev_bank_button,
self._encoders)
self._encoder_modes.set_device_mixer_buttons(
device_button, mixer_button)
self._string_to_display = None
for component in self.components:
component.set_enabled(False)
def _setup_mixer(self):
mute_solo_flip_button = ButtonElement(not IS_MOMENTARY, MIDI_CC_TYPE,
0, 34)
self._next_nav_button = ButtonElement(IS_MOMENTARY, MIDI_CC_TYPE, 0,
37)
self._prev_nav_button = ButtonElement(IS_MOMENTARY, MIDI_CC_TYPE, 0,
38)
self._strip_buttons = []
mute_solo_flip_button.name = 'Mute_Solo_Flip_Button'
self._next_nav_button.name = 'Next_Track_Button'
self._prev_nav_button.name = 'Prev_Track_Button'
self._mixer = SpecialMixerComponent(8)
self._mixer.name = 'Mixer'
self._mixer.set_select_buttons(self._next_nav_button,
self._prev_nav_button)
self._mixer.selected_strip().name = 'Selected_Channel_Strip'
self._mixer.master_strip().name = 'Master_Channel_Strip'
self._mixer.master_strip().set_volume_control(self._master_slider)
self._sliders = []
for index in range(8):
strip = self._mixer.channel_strip(index)
strip.name = 'Channel_Strip_' + str(index)
strip.set_invert_mute_feedback(True)
self._sliders.append(SliderElement(MIDI_CC_TYPE, 0, index))
self._sliders[(-1)].name = str(index) + '_Volume_Control'
self._sliders[(-1)].set_feedback_delay(-1)
self._sliders[(-1)].add_value_listener((self._slider_value),
identify_sender=True)
strip.set_volume_control(self._sliders[(-1)])
self._strip_buttons.append(
ButtonElement(IS_MOMENTARY, MIDI_CC_TYPE, 0, 9 + index))
self._strip_buttons[(-1)].name = str(index) + '_Mute_Button'
self._strip_buttons[(-1)].add_value_listener(
(self._mixer_button_value), identify_sender=True)
self._mixer.master_strip().set_mute_button(
ButtonElement(IS_MOMENTARY, MIDI_CC_TYPE, 1, 17))
self._mixer.set_strip_mute_solo_buttons(tuple(self._strip_buttons),
mute_solo_flip_button)
def __init__(self, *a, **k):
super(JogWheelSection, self).__init__(*a, **k)
self._do_encoder_button.subject = ButtonElement(
True, MIDI_CC_TYPE, 0, CC_JOGWHEEL_PUSH)
self._do_encoder_touch.subject = ButtonElement(True, MIDI_CC_TYPE, 0,
CC_JOGWHEEL_TOUCH)
self._do_encoder_slider.subject = SliderElement(
MIDI_CC_TYPE, 0, CC_JOGWHEEL)
self.__nav_left_button = IndexedButton(True, MIDI_CC_TYPE, CC_NAV_LEFT,
0, (0, 127))
self.__nav_right_button = IndexedButton(True, MIDI_CC_TYPE,
CC_NAV_RIGHT, 0, (0, 127))
self.__nav_up_button = IndexedButton(True, MIDI_CC_TYPE, CC_NAV_UP, 0,
(0, 127))
self.__nav_down_button = IndexedButton(True, MIDI_CC_TYPE, CC_NAV_DOWN,
0, (0, 127))
self._do_nav_left.subject = self.__nav_left_button
self._do_nav_right.subject = self.__nav_right_button
self._do_nav_up.subject = self.__nav_up_button
self._do_nav_down.subject = self.__nav_down_button
self._selected_track_change.subject = self.song().view
self._clip = None
return
def make_slider(cc_no, name):
slider = SliderElement(MIDI_CC_TYPE, 0, cc_no)
slider.set_feedback_delay(-1)
slider.name = name
return slider
def __init__(self):
self._midi_channel = 1
self.main_faders = []
self.encoder_groups = []
self.encoder_buttons = []
self.buttons = []
#we are going to input this manually, so that it is easy to update later on:
##FADERS##
self.main_faders.append(
SliderElement(MIDI_CC_TYPE, self._midi_channel, 32))
self.main_faders.append(
SliderElement(MIDI_CC_TYPE, self._midi_channel, 33))
self.main_faders.append(
SliderElement(MIDI_CC_TYPE, self._midi_channel, 34))
self.main_faders.append(
SliderElement(MIDI_CC_TYPE, self._midi_channel, 35))
self.main_faders.append(
SliderElement(MIDI_CC_TYPE, self._midi_channel, 36))
self.main_faders.append(
SliderElement(MIDI_CC_TYPE, self._midi_channel, 37))
self.main_faders.append(
SliderElement(MIDI_CC_TYPE, self._midi_channel, 38))
self.main_faders.append(
SliderElement(MIDI_CC_TYPE, self._midi_channel, 39))
##ENCODERS##
#group 1, pan controls#
self.encoder_groups.append([])
self.encoder_groups[0].append(
EncoderElement(MIDI_CC_TYPE, self._midi_channel, 102,
Live.MidiMap.MapMode.absolute))
self.encoder_groups[0].append(
EncoderElement(MIDI_CC_TYPE, self._midi_channel, 103,
Live.MidiMap.MapMode.absolute))
self.encoder_groups[0].append(
EncoderElement(MIDI_CC_TYPE, self._midi_channel, 104,
Live.MidiMap.MapMode.absolute))
self.encoder_groups[0].append(
EncoderElement(MIDI_CC_TYPE, self._midi_channel, 105,
Live.MidiMap.MapMode.absolute))
self.encoder_groups[0].append(
EncoderElement(MIDI_CC_TYPE, self._midi_channel, 106,
Live.MidiMap.MapMode.absolute))
self.encoder_groups[0].append(
EncoderElement(MIDI_CC_TYPE, self._midi_channel, 107,
Live.MidiMap.MapMode.absolute))
self.encoder_groups[0].append(
EncoderElement(MIDI_CC_TYPE, self._midi_channel, 108,
Live.MidiMap.MapMode.absolute))
self.encoder_groups[0].append(
EncoderElement(MIDI_CC_TYPE, self._midi_channel, 109,
Live.MidiMap.MapMode.absolute))
#group 2, send A controls#
self.encoder_groups.append([])
self.encoder_groups[1].append(
EncoderElement(MIDI_CC_TYPE, self._midi_channel, 64,
Live.MidiMap.MapMode.absolute))
self.encoder_groups[1].append(
EncoderElement(MIDI_CC_TYPE, self._midi_channel, 65,
Live.MidiMap.MapMode.absolute))
self.encoder_groups[1].append(
EncoderElement(MIDI_CC_TYPE, self._midi_channel, 66,
Live.MidiMap.MapMode.absolute))
self.encoder_groups[1].append(
EncoderElement(MIDI_CC_TYPE, self._midi_channel, 67,
Live.MidiMap.MapMode.absolute))
self.encoder_groups[1].append(
EncoderElement(MIDI_CC_TYPE, self._midi_channel, 68,
Live.MidiMap.MapMode.absolute))
self.encoder_groups[1].append(
EncoderElement(MIDI_CC_TYPE, self._midi_channel, 69,
Live.MidiMap.MapMode.absolute))
self.encoder_groups[1].append(
EncoderElement(MIDI_CC_TYPE, self._midi_channel, 70,
Live.MidiMap.MapMode.absolute))
self.encoder_groups[1].append(
EncoderElement(MIDI_CC_TYPE, self._midi_channel, 71,
Live.MidiMap.MapMode.absolute))
#group 3, send B controls#
self.encoder_groups.append([])
self.encoder_groups[2].append(
EncoderElement(MIDI_CC_TYPE, self._midi_channel, 72,
Live.MidiMap.MapMode.absolute))
self.encoder_groups[2].append(
EncoderElement(MIDI_CC_TYPE, self._midi_channel, 73,
Live.MidiMap.MapMode.absolute))
self.encoder_groups[2].append(
EncoderElement(MIDI_CC_TYPE, self._midi_channel, 74,
Live.MidiMap.MapMode.absolute))
self.encoder_groups[2].append(
EncoderElement(MIDI_CC_TYPE, self._midi_channel, 75,
Live.MidiMap.MapMode.absolute))
self.encoder_groups[2].append(
EncoderElement(MIDI_CC_TYPE, self._midi_channel, 76,
Live.MidiMap.MapMode.absolute))
self.encoder_groups[2].append(
EncoderElement(MIDI_CC_TYPE, self._midi_channel, 77,
Live.MidiMap.MapMode.absolute))
self.encoder_groups[2].append(
EncoderElement(MIDI_CC_TYPE, self._midi_channel, 78,
Live.MidiMap.MapMode.absolute))
self.encoder_groups[2].append(
EncoderElement(MIDI_CC_TYPE, self._midi_channel, 79,
Live.MidiMap.MapMode.absolute))
#group 4, send C controls#
self.encoder_groups.append([])
self.encoder_groups[3].append(
EncoderElement(MIDI_CC_TYPE, self._midi_channel, 80,
Live.MidiMap.MapMode.absolute))
self.encoder_groups[3].append(
EncoderElement(MIDI_CC_TYPE, self._midi_channel, 81,
Live.MidiMap.MapMode.absolute))
self.encoder_groups[3].append(
EncoderElement(MIDI_CC_TYPE, self._midi_channel, 82,
Live.MidiMap.MapMode.absolute))
self.encoder_groups[3].append(
EncoderElement(MIDI_CC_TYPE, self._midi_channel, 83,
Live.MidiMap.MapMode.absolute))
self.encoder_groups[3].append(
EncoderElement(MIDI_CC_TYPE, self._midi_channel, 84,
Live.MidiMap.MapMode.absolute))
self.encoder_groups[3].append(
EncoderElement(MIDI_CC_TYPE, self._midi_channel, 85,
Live.MidiMap.MapMode.absolute))
self.encoder_groups[3].append(
EncoderElement(MIDI_CC_TYPE, self._midi_channel, 86,
Live.MidiMap.MapMode.absolute))
self.encoder_groups[3].append(
EncoderElement(MIDI_CC_TYPE, self._midi_channel, 87,
Live.MidiMap.MapMode.absolute))
##BUTTONS##
#encoder buttons, all control groups, record buttons#
self.encoder_buttons.append([])
self.encoder_buttons[0].append(
ButtonElement(True, MIDI_CC_TYPE, self._midi_channel, 56))
self.encoder_buttons[0].append(
ButtonElement(True, MIDI_CC_TYPE, self._midi_channel, 57))
self.encoder_buttons[0].append(
ButtonElement(True, MIDI_CC_TYPE, self._midi_channel, 58))
self.encoder_buttons[0].append(
ButtonElement(True, MIDI_CC_TYPE, self._midi_channel, 59))
self.encoder_buttons[0].append(
ButtonElement(True, MIDI_CC_TYPE, self._midi_channel, 60))
self.encoder_buttons[0].append(
ButtonElement(True, MIDI_CC_TYPE, self._midi_channel, 61))
self.encoder_buttons[0].append(
ButtonElement(True, MIDI_CC_TYPE, self._midi_channel, 62))
self.encoder_buttons[0].append(
ButtonElement(True, MIDI_CC_TYPE, self._midi_channel, 63))
self.encoder_buttons[0].append(
ButtonElement(True, MIDI_CC_TYPE, self._midi_channel, 64))
#top row buttons, Track Enable Buttons#
self.buttons.append([])
self.buttons[0].append(
ButtonElement(False, MIDI_CC_TYPE, self._midi_channel, 40))
self.buttons[0].append(
ButtonElement(False, MIDI_CC_TYPE, self._midi_channel, 41))
self.buttons[0].append(
ButtonElement(False, MIDI_CC_TYPE, self._midi_channel, 42))
self.buttons[0].append(
ButtonElement(False, MIDI_CC_TYPE, self._midi_channel, 43))
self.buttons[0].append(
ButtonElement(False, MIDI_CC_TYPE, self._midi_channel, 44))
self.buttons[0].append(
ButtonElement(False, MIDI_CC_TYPE, self._midi_channel, 45))
self.buttons[0].append(
ButtonElement(False, MIDI_CC_TYPE, self._midi_channel, 46))
self.buttons[0].append(
ButtonElement(False, MIDI_CC_TYPE, self._midi_channel, 47))
#bottom row self.buttons, Record Self.Buttons#
self.buttons.append([])
self.buttons[1].append(
ButtonElement(True, MIDI_CC_TYPE, self._midi_channel, 48))
self.buttons[1].append(
ButtonElement(True, MIDI_CC_TYPE, self._midi_channel, 49))
self.buttons[1].append(
ButtonElement(True, MIDI_CC_TYPE, self._midi_channel, 50))
self.buttons[1].append(
ButtonElement(True, MIDI_CC_TYPE, self._midi_channel, 51))
self.buttons[1].append(
ButtonElement(True, MIDI_CC_TYPE, self._midi_channel, 52))
self.buttons[1].append(
ButtonElement(True, MIDI_CC_TYPE, self._midi_channel, 53))
self.buttons[1].append(
ButtonElement(True, MIDI_CC_TYPE, self._midi_channel, 54))
self.buttons[1].append(
ButtonElement(True, MIDI_CC_TYPE, self._midi_channel, 55))
#bottom self.buttons, purpose TBD#
self.buttons.append([])
self.buttons[2].append(
ButtonElement(True, MIDI_CC_TYPE, self._midi_channel, 89))
self.buttons[2].append(
ButtonElement(True, MIDI_CC_TYPE, self._midi_channel, 90))
self.buttons[2].append(
ButtonElement(True, MIDI_CC_TYPE, self._midi_channel, 91))
self.buttons[2].append(
ButtonElement(True, MIDI_CC_TYPE, self._midi_channel, 92))
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()
def make_slider(identifier, name):
return SliderElement(MIDI_CC_TYPE, 0, identifier, name=name)
def make_slider(channel, cc, name):
element = SliderElement(MIDI_CC_TYPE, channel, cc)
element.name = name
return element
def __init__(self, *a, **k):
(super(AudioClipEditComponent, self).__init__)(*a, **k)
self._loop_start_slider = SliderElement(MIDI_CC_TYPE, 2, 60)
self._action_loop_start.subject = self._loop_start_slider
self._loop_end_slider = SliderElement(MIDI_CC_TYPE, 2, 61)
self._action_loop_end.subject = self._loop_end_slider
self._mark_start_slider = SliderElement(MIDI_CC_TYPE, 2, 62)
self._action_mark_start.subject = self._mark_start_slider
self._mark_end_slider = SliderElement(MIDI_CC_TYPE, 2, 63)
self._action_mark_end.subject = self._mark_end_slider
self._pitch_c_slider = SliderElement(MIDI_CC_TYPE, 2, 64)
self._pitch_f_slider = SliderElement(MIDI_CC_TYPE, 2, 65)
self._gain_slider = SliderElement(MIDI_CC_TYPE, 2, 66)
self._action_pitch_c.subject = self._pitch_c_slider
self._action_pitch_f.subject = self._pitch_f_slider
self._action_gain.subject = self._gain_slider
self._loop_inc_slider = SliderElement(MIDI_CC_TYPE, 2, 67)
self._action_loop_inc.subject = self._loop_inc_slider
self._loop_move_button = ButtonElement(False, MIDI_CC_TYPE, 2, 74)
self._action_mv_loop.subject = self._loop_move_button
self._loop_set_button = ButtonElement(False, MIDI_CC_TYPE, 2, 70)
self._action_loop_toggle.subject = self._loop_set_button
self._warp_set_button = ButtonElement(False, MIDI_CC_TYPE, 2, 71)
self._action_warp_toggle.subject = self._warp_set_button
self._zoom_scroll_button = ButtonElement(False, MIDI_CC_TYPE, 2, 73)
self._action_scroll_mode.subject = self._zoom_scroll_button
self.selected_clip_slot = None
self.inc_index = 4
self.loop_inc = INC_STEPS[self.inc_index]
self.start_inc = INC_STEPS[self.inc_index]
self.mv_loop = False
self._on_pitch_c_changed.subject = None
self._on_pitch_f_changed.subject = None
self._on_gain_changed.subject = None
self._scroll_mode = False
self.update_selected_clip()
def make_knob(channel, identifier, *a, **k):
return SliderElement(MIDI_CC_TYPE, channel, identifier, *a, **k)
class AudioClipEditComponent(CompoundComponent):
__doc__ = '\n classdocs\n '
def __init__(self, *a, **k):
(super(AudioClipEditComponent, self).__init__)(*a, **k)
self._loop_start_slider = SliderElement(MIDI_CC_TYPE, 2, 60)
self._action_loop_start.subject = self._loop_start_slider
self._loop_end_slider = SliderElement(MIDI_CC_TYPE, 2, 61)
self._action_loop_end.subject = self._loop_end_slider
self._mark_start_slider = SliderElement(MIDI_CC_TYPE, 2, 62)
self._action_mark_start.subject = self._mark_start_slider
self._mark_end_slider = SliderElement(MIDI_CC_TYPE, 2, 63)
self._action_mark_end.subject = self._mark_end_slider
self._pitch_c_slider = SliderElement(MIDI_CC_TYPE, 2, 64)
self._pitch_f_slider = SliderElement(MIDI_CC_TYPE, 2, 65)
self._gain_slider = SliderElement(MIDI_CC_TYPE, 2, 66)
self._action_pitch_c.subject = self._pitch_c_slider
self._action_pitch_f.subject = self._pitch_f_slider
self._action_gain.subject = self._gain_slider
self._loop_inc_slider = SliderElement(MIDI_CC_TYPE, 2, 67)
self._action_loop_inc.subject = self._loop_inc_slider
self._loop_move_button = ButtonElement(False, MIDI_CC_TYPE, 2, 74)
self._action_mv_loop.subject = self._loop_move_button
self._loop_set_button = ButtonElement(False, MIDI_CC_TYPE, 2, 70)
self._action_loop_toggle.subject = self._loop_set_button
self._warp_set_button = ButtonElement(False, MIDI_CC_TYPE, 2, 71)
self._action_warp_toggle.subject = self._warp_set_button
self._zoom_scroll_button = ButtonElement(False, MIDI_CC_TYPE, 2, 73)
self._action_scroll_mode.subject = self._zoom_scroll_button
self.selected_clip_slot = None
self.inc_index = 4
self.loop_inc = INC_STEPS[self.inc_index]
self.start_inc = INC_STEPS[self.inc_index]
self.mv_loop = False
self._on_pitch_c_changed.subject = None
self._on_pitch_f_changed.subject = None
self._on_gain_changed.subject = None
self._scroll_mode = False
self.update_selected_clip()
@subject_slot('value')
def _action_scroll_mode(self, value):
if value > 0:
self._scroll_mode = True
else:
self._scroll_mode = False
@subject_slot('value')
def _action_warp_toggle(self, value):
if value > 0:
if self.selected_clip_slot:
if self.selected_clip_slot.has_clip:
clip = self.selected_clip_slot.clip
if clip.is_audio_clip:
clip.warping = not clip.warping
self._warp_set_button.send_value(
clip.warping and 127 or 0, True)
@subject_slot('value')
def _action_loop_toggle(self, value):
if value > 0:
if self.selected_clip_slot:
if self.selected_clip_slot.has_clip:
clip = self.selected_clip_slot.clip
clip.looping = not clip.looping
self._loop_set_button.send_value(clip.looping and 127 or 0,
True)
@subject_slot('value')
def _action_loop_inc(self, value):
inc = value == 1 and 1 or -1
val = self.inc_index + inc
if val >= 0:
if val < len(INC_STEPS):
self.inc_index = val
self.loop_inc = INC_STEPS[val]
self.start_inc = INC_STEPS[val]
self.canonical_parent.timed_message(
2, 'Loop Adjust: ' + INC_DISP[val])
self.canonical_parent.show_message('Loop Adjust: ' +
INC_DISP[val])
@subject_slot('value')
def _action_mv_loop(self, value):
if value > 0:
if self.mv_loop:
self._loop_move_button.send_value(0, True)
self.mv_loop = False
else:
self._loop_move_button.send_value(127, True)
self.mv_loop = True
@subject_slot('value')
def _action_mark_start(self, value):
if self._scroll_mode:
scroll = value == 1 and 3 or 2
self.application().view.scroll_view(scroll, 'Detail/Clip', False)
else:
inc = value == 1 and 1 or -1
if self.selected_clip_slot:
if self.selected_clip_slot.has_clip:
clip = self.selected_clip_slot.clip
ls = clip.start_marker
le = clip.end_marker
ls = max(
0, min(le - self.start_inc, ls + inc * self.start_inc))
clip.start_marker = ls
bars_to_measure(ls, clip.signature_denominator,
clip.signature_numerator)
self.canonical_parent.timed_message(
2, 'Clip Start: ' +
bars_to_measure(ls, clip.signature_denominator,
clip.signature_numerator))
@subject_slot('value')
def _action_mark_end(self, value):
if self._scroll_mode:
scroll = value == 1 and 3 or 2
self.application().view.zoom_view(scroll, 'Detail/Clip', False)
else:
inc = value == 1 and 1 or -1
if self.selected_clip_slot:
if self.selected_clip_slot.has_clip:
clip = self.selected_clip_slot.clip
ls = clip.start_marker
le = clip.end_marker
le = max(ls + self.start_inc, le + inc * self.start_inc)
clip.end_marker = le
self.canonical_parent.timed_message(
2, 'Clip End: ' +
bars_to_measure(le, clip.signature_denominator,
clip.signature_numerator))
@subject_slot('value')
def _action_loop_start(self, value):
inc = value == 1 and 1 or -1
if self.selected_clip_slot:
if self.selected_clip_slot.has_clip:
clip = self.selected_clip_slot.clip
ls = clip.loop_start
le = clip.loop_end
if self.mv_loop:
diff = le - ls
ls = max(0, ls + inc * self.loop_inc)
if inc > 0:
clip.loop_end = ls + diff
clip.end_marker = ls + diff
clip.loop_start = ls
clip.start_marker = ls
else:
clip.loop_start = ls
clip.start_marker = ls
clip.loop_end = ls + diff
clip.end_marker = ls + diff
self.canonical_parent.timed_message(2, loop_str(clip))
else:
ls = max(0,
min(le - self.loop_inc, ls + inc * self.loop_inc))
clip.loop_start = ls
self.canonical_parent.timed_message(2, loop_str(clip))
@subject_slot('value')
def _action_loop_end(self, value):
inc = value == 1 and 1 or -1
if self.selected_clip_slot:
if self.selected_clip_slot.has_clip:
clip = self.selected_clip_slot.clip
ls = clip.loop_start
le = clip.loop_end
le = max(ls + self.loop_inc, le + inc * self.loop_inc)
clip.loop_end = le
if self.mv_loop:
clip.end_marker = le
self.canonical_parent.timed_message(2, loop_str(clip))
def update(self):
pass
@subject_slot('value')
def _action_pitch_c(self, value):
cs = self.selected_clip_slot
if cs:
if cs.has_clip:
if cs.clip.is_audio_clip:
cs.clip.pitch_coarse = midi_to_pitchc(value)
@subject_slot('value')
def _action_pitch_f(self, value):
cs = self.selected_clip_slot
if cs:
if cs.has_clip:
if cs.clip.is_audio_clip:
cs.clip.pitch_fine = midi_to_pitchf(value)
@subject_slot('value')
def _action_gain(self, value):
cs = self.selected_clip_slot
if cs:
if cs.has_clip:
if cs.clip.is_audio_clip:
cs.clip.gain = midi_to_gain(value)
def _update_clip_name(self):
cs = self.song().view.highlighted_clip_slot
if not cs:
track = self.song().view.selected_track
self.canonical_parent.send_to_display('Rt Trck: ' + track.name, 3)
else:
if cs.has_clip:
self.canonical_parent.send_to_display(
(cs.clip.is_audio_clip and 'A' or 'M') + ':' +
cs.clip.name, 3)
else:
track = cs.canonical_parent
index = list(track.clip_slots).index(cs)
scene = self.song().scenes[index]
self.canonical_parent.send_to_display(
'E<' + str(scene.name) + '> T:' + track.name, 3)
@subject_slot('has_clip')
def _on_has_clip_changed(self):
self._update_clip_name()
@subject_slot('name')
def _on_name_changed(self):
self._update_clip_name()
def update_selected_clip(self):
cs = self.song().view.highlighted_clip_slot
if cs != self.selected_clip_slot:
self.selected_clip_slot = cs
self._update_clip_name()
if cs and cs.has_clip and cs.clip.is_audio_clip:
self._on_pitch_c_changed.subject = cs.clip
self._on_pitch_f_changed.subject = cs.clip
self._on_gain_changed.subject = cs.clip
self._on_warp_changed.subject = cs.clip
self._gain_slider.send_value(gain_to_midi(cs.clip.gain))
self._pitch_c_slider.send_value(
pitchc_to_midi(cs.clip.pitch_coarse))
self._pitch_f_slider.send_value(
pitchf_to_midi(cs.clip.pitch_fine))
self._warp_set_button.send_value(cs.clip.warping and 127 or 0,
True)
else:
self._on_pitch_c_changed.subject = None
self._on_pitch_f_changed.subject = None
self._on_gain_changed.subject = None
self._on_warp_changed.subject = None
self._on_loop_changed.subject = None
if cs and cs.has_clip:
self._on_loop_changed.subject = cs.clip
self._on_name_changed.subject = cs.clip
self._loop_set_button.send_value(cs.clip.looping and 127 or 0,
True)
else:
self._on_name_changed.subject = None
self._on_loop_changed.subject = None
self._on_has_clip_changed.subject = cs
def on_selected_track_changed(self):
self.update_selected_clip()
def on_selected_scene_changed(self):
self.update_selected_clip()
@subject_slot('looping')
def _on_loop_changed(self):
cs = self.song().view.highlighted_clip_slot
if cs:
if cs.has_clip:
self._loop_set_button.send_value(cs.clip.looping and 127 or 0,
True)
@subject_slot('warping')
def _on_warp_changed(self):
cs = self.song().view.highlighted_clip_slot
if cs:
if cs.has_clip:
if cs.clip.is_audio_clip:
self._warp_set_button.send_value(
cs.clip.warping and 127 or 0, True)
@subject_slot('pitch_coarse')
def _on_pitch_c_changed(self):
cs = self.song().view.highlighted_clip_slot
if cs:
if cs.has_clip:
if cs.clip.is_audio_clip:
self._pitch_c_slider.send_value(
pitchc_to_midi(cs.clip.pitch_coarse))
@subject_slot('pitch_fine')
def _on_pitch_f_changed(self):
cs = self.song().view.highlighted_clip_slot
if cs:
if cs.has_clip:
if cs.clip.is_audio_clip:
self._pitch_f_slider.send_value(
pitchf_to_midi(cs.clip.pitch_fine))
@subject_slot('gain')
def _on_gain_changed(self):
cs = self.song().view.highlighted_clip_slot
if cs:
if cs.has_clip:
if cs.clip.is_audio_clip:
self._gain_slider.send_value(gain_to_midi(cs.clip.gain))
