def _init_transport_component(self, transport_controls, global_channel):
is_momentary = True
if transport_controls:
transport = TransportComponent()
transport.name = "Transport"
if "STOP" in transport_controls.keys() and transport_controls["STOP"] in range(128):
stop_button = ButtonElement(is_momentary, MIDI_CC_TYPE, global_channel, transport_controls["STOP"])
stop_button.name = "Stop_Button"
transport.set_stop_button(stop_button)
if "PLAY" in transport_controls.keys() and transport_controls["PLAY"] in range(128):
play_button = ButtonElement(is_momentary, MIDI_CC_TYPE, global_channel, transport_controls["PLAY"])
play_button.name = "Play_Button"
transport.set_play_button(play_button)
if "REC" in transport_controls.keys() and transport_controls["REC"] in range(128):
rec_button = ButtonElement(is_momentary, MIDI_CC_TYPE, global_channel, transport_controls["REC"])
rec_button.name = "Record_Button"
transport.set_record_button(rec_button)
if "LOOP" in transport_controls.keys() and transport_controls["LOOP"] in range(128):
loop_button = ButtonElement(is_momentary, MIDI_CC_TYPE, global_channel, transport_controls["LOOP"])
loop_button.name = "Loop_Button"
transport.set_loop_button(loop_button)
ffwd_button = None
rwd_button = None
momentary_seek = "NORELEASE" not in transport_controls.keys()
if "FFWD" in transport_controls.keys() and transport_controls["FFWD"] in range(128):
ffwd_button = ButtonElement(momentary_seek, MIDI_CC_TYPE, global_channel, transport_controls["FFWD"])
ffwd_button.name = "FFwd_Button"
if "RWD" in transport_controls.keys() and transport_controls["RWD"] in range(128):
rwd_button = ButtonElement(momentary_seek, MIDI_CC_TYPE, global_channel, transport_controls["RWD"])
rwd_button.name = "Rwd_Button"
transport.set_seek_buttons(ffwd_button, rwd_button)
def _init_transport_component(self, transport_controls, global_channel):
is_momentary = True
if transport_controls:
transport = TransportComponent()
transport.name = 'Transport'
if 'STOP' in transport_controls.keys() and transport_controls['STOP'] in range(128):
stop_button = ButtonElement(is_momentary, MIDI_CC_TYPE, global_channel, transport_controls['STOP'])
stop_button.name = 'Stop_Button'
transport.set_stop_button(stop_button)
if 'PLAY' in transport_controls.keys() and transport_controls['PLAY'] in range(128):
play_button = ButtonElement(is_momentary, MIDI_CC_TYPE, global_channel, transport_controls['PLAY'])
play_button.name = 'Play_Button'
transport.set_play_button(play_button)
if 'REC' in transport_controls.keys() and transport_controls['REC'] in range(128):
rec_button = ButtonElement(is_momentary, MIDI_CC_TYPE, global_channel, transport_controls['REC'])
rec_button.name = 'Record_Button'
transport.set_record_button(rec_button)
if 'LOOP' in transport_controls.keys() and transport_controls['LOOP'] in range(128):
loop_button = ButtonElement(is_momentary, MIDI_CC_TYPE, global_channel, transport_controls['LOOP'])
loop_button.name = 'Loop_Button'
transport.set_loop_button(loop_button)
ffwd_button = None
rwd_button = None
momentary_seek = 'NORELEASE' not in transport_controls.keys()
if 'FFWD' in transport_controls.keys() and transport_controls['FFWD'] in range(128):
ffwd_button = ButtonElement(momentary_seek, MIDI_CC_TYPE, global_channel, transport_controls['FFWD'])
ffwd_button.name = 'FFwd_Button'
if 'RWD' in transport_controls.keys() and transport_controls['RWD'] in range(128):
rwd_button = ButtonElement(momentary_seek, MIDI_CC_TYPE, global_channel, transport_controls['RWD'])
rwd_button.name = 'Rwd_Button'
transport.set_seek_buttons(ffwd_button, rwd_button)
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 _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 _setup_components(self):
# Session
self._session = SessionComponent(8, len(self._scene_launch_buttons))
self._session.name = 'Session_Control'
self._session.selected_scene().name = 'Selected_Scene'
self._session.selected_scene().set_launch_button(self._scene_launch_button)
self._session.set_stop_all_clips_button(self._scene_stop_button)
for index in range(8):
clip_slot = self._session.selected_scene().clip_slot(index)
clip_slot.set_launch_button(self._clip_launch_buttons[index])
clip_slot.name = 'Selected_Clip_Slot_' + str(index)
self._session.set_stop_track_clip_buttons(tuple(self._clip_stop_buttons))
# Undo
self._do_undo.subject = self._clip_undo_button;
# Transport
transport = TransportComponent()
transport.name = 'Transport'
transport.set_stop_button(self._stop_button)
transport.set_play_button(self._play_button)
transport.set_record_button(self._rec_button)
transport.set_loop_button(self._loop_button)
self._transport_view_modes = TransportViewModeSelector(transport, self._session, self._ffwd_button, self._rwd_button)
self._transport_view_modes.name = 'Transport_View_Modes'
session_recording = SessionRecordingComponent(ClipCreator(), ViewControlComponent(), name='Session_Recording', is_enabled=False, layer=Layer(record_button=self._overdub_button))
# Device
# device = DeviceComponent()
# device.name = 'Device_Component'
# self.set_device_component(device)
# device.set_parameter_controls(self._encoders)
# Navigation
self._session_navigation = SessionNavigationComponent(name='Session_Navigation')
self._session_navigation.set_next_track_button(self._next_track_button)
self._session_navigation.set_prev_track_button(self._prev_track_button)
# Playing
# self._session.set_scene_launch_buttons(tuple(self._scene_launch_buttons))
for index in range(len(self._scene_launch_buttons)):
scene = self._session.scene(index)
scene.set_launch_button(self._scene_launch_buttons[index])
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 _setup_transport(self):
rwd_button = make_button(112, 'Rwd_Button')
ffwd_button = make_button(113, 'FFwd_Button')
stop_button = make_button(114, 'Stop_Button')
play_button = make_button(115, 'Play_Button')
loop_button = make_button(116, 'Loop_Button')
rec_button = make_button(117, 'Record_Button')
transport = TransportComponent()
transport.name = 'Transport'
transport.set_stop_button(stop_button)
transport.set_play_button(play_button)
transport.set_record_button(rec_button)
transport.set_loop_button(loop_button)
self._transport_view_modes = TransportViewModeSelector(transport, self._session, ffwd_button, rwd_button)
self._transport_view_modes.name = 'Transport_View_Modes'
def _setup_transport(self):
rwd_button = make_button(112, "Rwd_Button")
ffwd_button = make_button(113, "FFwd_Button")
stop_button = make_button(114, "Stop_Button")
play_button = make_button(115, "Play_Button")
loop_button = make_button(116, "Loop_Button")
rec_button = make_button(117, "Record_Button")
transport = TransportComponent()
transport.name = "Transport"
transport.set_stop_button(stop_button)
transport.set_play_button(play_button)
transport.set_record_button(rec_button)
transport.set_loop_button(loop_button)
self._transport_view_modes = TransportViewModeSelector(transport, self._session, ffwd_button, rwd_button)
self._transport_view_modes.name = "Transport_View_Modes"
def _setup_transport(self):
rwd_button = make_button(112, 'Rwd_Button')
ffwd_button = make_button(113, 'FFwd_Button')
stop_button = make_button(114, 'Stop_Button')
play_button = make_button(115, 'Play_Button')
loop_button = make_button(116, 'Loop_Button')
rec_button = make_button(117, 'Record_Button')
transport = TransportComponent()
transport.name = 'Transport'
transport.set_stop_button(stop_button)
transport.set_play_button(play_button)
transport.set_record_button(rec_button)
transport.set_loop_button(loop_button)
self._transport_view_modes = TransportViewModeSelector(transport, self._session, ffwd_button, rwd_button)
self._transport_view_modes.name = 'Transport_View_Modes'
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_transport_component(self, transport_controls, global_channel, macro_map_mode):
is_momentary = True
if transport_controls:
transport = TransportComponent()
transport.name = 'Transport'
#THIS IS NEW STUFF
#if 'TEMPO' in transport_control.keys() and transport_controls['TEMPO'] in range(128):
tempo_slider = EncoderElement(MIDI_CC_TYPE, global_channel, 1, macro_map_mode)
tempo_slider.name = 'Tempo_Slider'
transport.set_tempo_control(tempo_slider)
#END NEW STUFF
if 'STOP' in transport_controls.keys() and transport_controls['STOP'] in range(128):
stop_button = ButtonElement(is_momentary, MIDI_CC_TYPE, global_channel, transport_controls['STOP'])
stop_button.name = 'Stop_Button'
transport.set_stop_button(stop_button)
if 'PLAY' in transport_controls.keys() and transport_controls['PLAY'] in range(128):
play_button = ButtonElement(is_momentary, MIDI_CC_TYPE, global_channel, transport_controls['PLAY'])
play_button.name = 'Play_Button'
transport.set_play_button(play_button)
if 'REC' in transport_controls.keys() and transport_controls['REC'] in range(128):
rec_button = ButtonElement(is_momentary, MIDI_CC_TYPE, global_channel, transport_controls['REC'])
rec_button.name = 'Record_Button'
transport.set_record_button(rec_button)
if 'LOOP' in transport_controls.keys() and transport_controls['LOOP'] in range(128):
loop_button = ButtonElement(is_momentary, MIDI_CC_TYPE, global_channel, transport_controls['LOOP'])
loop_button.name = 'Loop_Button'
transport.set_loop_button(loop_button)
ffwd_button = None
rwd_button = None
momentary_seek = 'NORELEASE' not in transport_controls.keys()
if 'FFWD' in transport_controls.keys() and transport_controls['FFWD'] in range(128):
ffwd_button = ButtonElement(momentary_seek, MIDI_CC_TYPE, global_channel, transport_controls['FFWD'])
ffwd_button.name = 'FFwd_Button'
if 'RWD' in transport_controls.keys() and transport_controls['RWD'] in range(128):
rwd_button = ButtonElement(momentary_seek, MIDI_CC_TYPE, global_channel, transport_controls['RWD'])
rwd_button.name = 'Rwd_Button'
transport.set_seek_buttons(ffwd_button, rwd_button)
def _init_transport_component(self, transport_controls, global_channel, macro_map_mode):
is_momentary = True
if transport_controls:
transport = TransportComponent()
transport.name = 'Transport'
#THIS IS NEW STUFF
#if 'TEMPO' in transport_control.keys() and transport_controls['TEMPO'] in range(128):
tempo_slider = EncoderElement(MIDI_CC_TYPE, global_channel, 1, macro_map_mode)
tempo_slider.name = 'Tempo_Slider'
transport.set_tempo_control(tempo_slider)
#END NEW STUFF
if 'STOP' in transport_controls.keys() and transport_controls['STOP'] in range(128):
stop_button = ButtonElement(is_momentary, MIDI_CC_TYPE, global_channel, transport_controls['STOP'])
stop_button.name = 'Stop_Button'
transport.set_stop_button(stop_button)
if 'PLAY' in transport_controls.keys() and transport_controls['PLAY'] in range(128):
play_button = ButtonElement(is_momentary, MIDI_CC_TYPE, global_channel, transport_controls['PLAY'])
play_button.name = 'Play_Button'
transport.set_play_button(play_button)
if 'REC' in transport_controls.keys() and transport_controls['REC'] in range(128):
rec_button = ButtonElement(is_momentary, MIDI_CC_TYPE, global_channel, transport_controls['REC'])
rec_button.name = 'Record_Button'
transport.set_record_button(rec_button)
if 'LOOP' in transport_controls.keys() and transport_controls['LOOP'] in range(128):
loop_button = ButtonElement(is_momentary, MIDI_CC_TYPE, global_channel, transport_controls['LOOP'])
loop_button.name = 'Loop_Button'
transport.set_loop_button(loop_button)
ffwd_button = None
rwd_button = None
momentary_seek = 'NORELEASE' not in transport_controls.keys()
if 'FFWD' in transport_controls.keys() and transport_controls['FFWD'] in range(128):
ffwd_button = ButtonElement(momentary_seek, MIDI_CC_TYPE, global_channel, transport_controls['FFWD'])
ffwd_button.name = 'FFwd_Button'
if 'RWD' in transport_controls.keys() and transport_controls['RWD'] in range(128):
rwd_button = ButtonElement(momentary_seek, MIDI_CC_TYPE, global_channel, transport_controls['RWD'])
rwd_button.name = 'Rwd_Button'
transport.set_seek_buttons(ffwd_button, rwd_button)
def _setup_transport_control(self):
is_momentary = True
""" Instantiate a Transport Component """
transport = TransportComponent()
""" Buttons declaration """
button_play = ButtonElement(is_momentary, MIDI_CC_TYPE, midi_channel, midi_transport_play_button)
button_stop = ButtonElement(is_momentary, MIDI_CC_TYPE, midi_channel, midi_transport_stop_button)
button_record = ButtonElement(is_momentary, MIDI_CC_TYPE, midi_channel, midi_transport_record_button)
button_loop = ButtonElement(is_momentary, MIDI_CC_TYPE, midi_channel, midi_transport_loop_button)
button_seek_ffwd = ButtonElement(is_momentary, MIDI_CC_TYPE, midi_channel, midi_transport_seek_ffwd)
button_seek_rwd = ButtonElement(is_momentary, MIDI_CC_TYPE, midi_channel, midi_transport_seek_rwd)
""" Buttons association """
transport.set_play_button(button_play)
transport.set_stop_button(button_stop)
transport.set_record_button(button_record)
transport.set_loop_button(button_loop)
transport.set_seek_buttons(button_seek_ffwd, button_seek_rwd)
def _setup_transport_control(self):
is_momentary = True # We'll only be using momentary buttons here
transport = TransportComponent() #Instantiate a Transport Component
return
"""set up the buttons"""
transport.set_play_button(
ButtonElement(is_momentary, MIDI_NOTE_TYPE, CHANNEL, 61)
) #ButtonElement(is_momentary, msg_type, channel, identifier) Note that the MIDI_NOTE_TYPE constant is defined in the InputControlElement module
transport.set_stop_button(
ButtonElement(is_momentary, MIDI_NOTE_TYPE, CHANNEL, 63))
transport.set_record_button(
ButtonElement(is_momentary, MIDI_NOTE_TYPE, CHANNEL, 66))
transport.set_overdub_button(
ButtonElement(is_momentary, MIDI_NOTE_TYPE, CHANNEL, 68))
transport.set_nudge_buttons(
ButtonElement(is_momentary, MIDI_NOTE_TYPE, CHANNEL, 75),
ButtonElement(is_momentary, MIDI_NOTE_TYPE, CHANNEL,
73)) #(up_button, down_button)
transport.set_tap_tempo_button(
ButtonElement(is_momentary, MIDI_NOTE_TYPE, CHANNEL, 78))
transport.set_metronome_button(
ButtonElement(is_momentary, MIDI_NOTE_TYPE, CHANNEL, 80)
) #For some reason, in Ver 7.x.x this method's name has no trailing "e" , and must be called as "set_metronom_button()"...
transport.set_loop_button(
ButtonElement(is_momentary, MIDI_NOTE_TYPE, CHANNEL, 82))
transport.set_punch_buttons(
ButtonElement(is_momentary, MIDI_NOTE_TYPE, CHANNEL, 85),
ButtonElement(is_momentary, MIDI_NOTE_TYPE, CHANNEL,
87)) #(in_button, out_button)
transport.set_seek_buttons(
ButtonElement(is_momentary, MIDI_NOTE_TYPE, CHANNEL, 90),
ButtonElement(is_momentary, MIDI_NOTE_TYPE, CHANNEL,
92)) # (ffwd_button, rwd_button)
"""set up the sliders"""
transport.set_tempo_control(
SliderElement(MIDI_CC_TYPE, CHANNEL, 26),
SliderElement(MIDI_CC_TYPE, CHANNEL, 25)) #(control, fine_control)
transport.set_song_position_control(
SliderElement(MIDI_CC_TYPE, CHANNEL, 24))
def _setup_transport(self):
is_momentary = True
transport = TransportComponent()
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)
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)
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.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, 100)
self.xfadeKnob.connect_to(self.song().master_track.mixer_device.crossfader)
self.tap_button = StateButton(is_momentary, MIDI_CC_TYPE, 0, 88)
self.tap_button.add_value_listener(self._do_tap_tempo)
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.cue_add_delete_button.add_value_listener(self._do_toggle_cue)
self.cue_prev_button.add_value_listener(self._do_toggle_prev_cue)
self.cue_next_button.add_value_listener(self._do_toggle_next_cue)
class midi_twister_110(ControlSurface):
def __init__(self, c_instance):
super(midi_twister_110, self).__init__(c_instance)
with self.component_guard():
global active_mode
active_mode = "_mode1"
self._set_active_mode()
self.show_message("Modified by XXPW")
def _mode1(self):
self.show_message("_mode1 is active")
# mixer
global mixer
num_tracks = 32
num_returns = 7
self.mixer = MixerComponent(num_tracks, num_returns)
self.mixer.set_track_offset(0)
self.song().view.selected_track = self.mixer.channel_strip(0)._track
# sends
send0_controls = (
SliderElement(MIDI_CC_TYPE, 0, 32),
SliderElement(MIDI_CC_TYPE, 0, 36),
SliderElement(MIDI_CC_TYPE, 0, 40),
None,
None,
None,
None,
None,
)
self.mixer.channel_strip(0).set_send_controls(tuple(send0_controls))
self.mixer.channel_strip(0).set_volume_control(
SliderElement(MIDI_CC_TYPE, 0, 44))
send1_controls = (
SliderElement(MIDI_CC_TYPE, 0, 33),
SliderElement(MIDI_CC_TYPE, 0, 37),
SliderElement(MIDI_CC_TYPE, 0, 41),
None,
None,
None,
None,
None,
)
self.mixer.channel_strip(1).set_send_controls(tuple(send1_controls))
self.mixer.channel_strip(1).set_volume_control(
SliderElement(MIDI_CC_TYPE, 0, 45))
send2_controls = (
SliderElement(MIDI_CC_TYPE, 0, 34),
SliderElement(MIDI_CC_TYPE, 0, 38),
SliderElement(MIDI_CC_TYPE, 0, 42),
None,
None,
None,
None,
None,
)
self.mixer.channel_strip(2).set_send_controls(tuple(send2_controls))
self.mixer.channel_strip(2).set_volume_control(
SliderElement(MIDI_CC_TYPE, 0, 46))
send3_controls = (
SliderElement(MIDI_CC_TYPE, 0, 35),
SliderElement(MIDI_CC_TYPE, 0, 39),
SliderElement(MIDI_CC_TYPE, 0, 43),
None,
None,
None,
None,
None,
)
self.mixer.channel_strip(3).set_send_controls(tuple(send3_controls))
self.mixer.channel_strip(3).set_volume_control(
SliderElement(MIDI_CC_TYPE, 0, 47))
# session
global _session
num_tracks = 4
num_scenes = 3
session_buttons = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]
self._pads = [
ButtonElement(1, MIDI_CC_TYPE, 1, session_buttons[index])
for index in range(num_tracks * num_scenes)
]
self._grid = ButtonMatrixElement(rows=[
self._pads[(index * num_tracks):(index * num_tracks) + num_tracks]
for index in range(num_scenes)
])
self._session = SessionComponent(num_tracks, num_scenes)
self._session.set_clip_launch_buttons(self._grid)
self.set_highlighting_session_component(self._session)
# session track stop
stop_track_buttons = [12, 13, 14, 15]
self._track_stop_buttons = [
ButtonElement(1, MIDI_CC_TYPE, 1, stop_track_buttons[index])
for index in range(num_tracks)
]
self._session.set_stop_track_clip_buttons(
tuple(self._track_stop_buttons))
# session navigation
self.session_left = ButtonElement(1, MIDI_CC_TYPE, 3, 8)
self._session.set_page_left_button(self.session_left)
self.session_left.add_value_listener(self._reload_active_devices,
identify_sender=False)
self.session_right = ButtonElement(1, MIDI_CC_TYPE, 3, 11)
self._session.set_page_right_button(self.session_right)
self.session_right.add_value_listener(self._reload_active_devices,
identify_sender=False)
self.session_up = ButtonElement(1, MIDI_CC_TYPE, 3, 10)
self._session.set_page_up_button(self.session_up)
self.session_up.add_value_listener(self._reload_active_devices,
identify_sender=False)
self.session_down = ButtonElement(1, MIDI_CC_TYPE, 3, 13)
self._session.set_page_down_button(self.session_down)
self.session_down.add_value_listener(self._reload_active_devices,
identify_sender=False)
self._session._link()
self._session.set_mixer(self.mixer)
#self._session.set_mixer(self.mixer)
self._mode1_devices()
self.add_device_listeners()
# button: next device
self.next_device = ButtonElement(0, MIDI_CC_TYPE, 1, 25)
self.next_device.add_value_listener(self._next_device_value,
identify_sender=False)
# button: prev device
self.previous_device = ButtonElement(1, MIDI_CC_TYPE, 1, 24)
self.previous_device.add_value_listener(self._prev_device_value,
identify_sender=False)
# transport
global transport
self.transport = TransportComponent()
self.transport.name = 'Transport'
loop_button = ButtonElement(1, MIDI_CC_TYPE, 1, 50)
loop_button.name = 'loop_button'
self.transport.set_loop_button(loop_button)
stop_button = ButtonElement(1, MIDI_CC_TYPE, 1, 49)
stop_button.name = 'stop_button'
self.transport.set_stop_button(stop_button)
play_button = ButtonElement(1, MIDI_CC_TYPE, 1, 48)
play_button.name = 'play_button'
self.transport.set_play_button(play_button)
# button: track navigation right
self.track_navigation_right = ButtonElement(1, MIDI_CC_TYPE, 3, 17)
self.track_navigation_right.add_value_listener(
self._track_navigation_right_track_nav, identify_sender=False)
# button: track navigation left
self.track_navigation_left = ButtonElement(1, MIDI_CC_TYPE, 3, 14)
self.track_navigation_left.add_value_listener(
self._track_navigation_left_track_nav, identify_sender=False)
def _remove_mode1(self):
# mixer
global mixer
self._remove_mode1_devices()
self.remove_device_listeners()
send0_controls = (
None,
None,
None,
None,
None,
None,
None,
None,
)
self.mixer.channel_strip(0).set_send_controls(tuple(send0_controls))
send1_controls = (
None,
None,
None,
None,
None,
None,
None,
None,
)
self.mixer.channel_strip(1).set_send_controls(tuple(send1_controls))
send2_controls = (
None,
None,
None,
None,
None,
None,
None,
None,
)
self.mixer.channel_strip(2).set_send_controls(tuple(send2_controls))
send3_controls = (
None,
None,
None,
None,
None,
None,
None,
None,
)
self.mixer.channel_strip(3).set_send_controls(tuple(send3_controls))
# session
global _session
self._session.set_clip_launch_buttons(None)
self.set_highlighting_session_component(None)
self._session.set_mixer(None)
self._session.set_stop_all_clips_button(None)
# session track stop
self._track_stop_buttons = None
self._session.set_stop_track_clip_buttons(None)
# session scene launch
self._scene_launch_buttons = None
self._session.set_scene_launch_buttons(None)
# session navigation
self.session_left.remove_value_listener(self._reload_active_devices)
self._session.set_page_left_button(None)
self.session_right.remove_value_listener(self._reload_active_devices)
self._session.set_page_right_button(None)
self.session_up.remove_value_listener(self._reload_active_devices)
self._session.set_page_up_button(None)
self.session_down.remove_value_listener(self._reload_active_devices)
self._session.set_page_down_button(None)
self._session = None
self.next_device.remove_value_listener(self._next_device_value)
self.next_device = None
self.previous_device.remove_value_listener(self._prev_device_value)
self.previous_device = None
# transport
global transport
self.transport.set_loop_button(None)
self.transport.set_stop_button(None)
self.transport.set_play_button(None)
self.transport = None
self.track_navigation_right.remove_value_listener(
self._track_navigation_right_track_nav)
self.track_navigation_right = None
self.track_navigation_left.remove_value_listener(
self._track_navigation_left_track_nav)
self.track_navigation_left = None
def _mode1_devices(self):
global mixer
global _session
# device
self.mixer.selected_strip().set_volume_control(
SliderElement(MIDI_CC_TYPE, 0, 28))
self.mixer.selected_strip().set_pan_control(
SliderElement(MIDI_CC_TYPE, 0, 29))
self.mixer.selected_strip().set_mute_button(
ButtonElement(1, MIDI_CC_TYPE, 1, 28))
self.mixer.selected_strip().set_solo_button(
ButtonElement(1, MIDI_CC_TYPE, 1, 29))
if (len(self.mixer.selected_strip()._track.devices) > 0):
global device_tracktype_selected__chain_number_selected
self.device_tracktype_selected__chain_number_selected = DeviceComponent(
)
device_controls = (
SliderElement(MIDI_CC_TYPE, 0, 16),
SliderElement(MIDI_CC_TYPE, 0, 17),
SliderElement(MIDI_CC_TYPE, 0, 18),
SliderElement(MIDI_CC_TYPE, 0, 19),
SliderElement(MIDI_CC_TYPE, 0, 20),
SliderElement(MIDI_CC_TYPE, 0, 21),
SliderElement(MIDI_CC_TYPE, 0, 22),
SliderElement(MIDI_CC_TYPE, 0, 23),
)
self.device_tracktype_selected__chain_number_selected.set_parameter_controls(
tuple(device_controls))
self.set_device_component(
self.device_tracktype_selected__chain_number_selected)
self.device_tracktype_selected__chain_number_selected.set_on_off_button(
ButtonElement(1, MIDI_CC_TYPE, 1, 26))
self.device_tracktype_selected__chain_number_selected.set_bank_nav_buttons(
ButtonElement(0, MIDI_CC_TYPE, 1, 31),
ButtonElement(1, MIDI_CC_TYPE, 1, 33))
def _remove_mode1_devices(self):
global mixer
global _session
# device
if (hasattr(self, 'device_tracktype_selected__chain_number_selected')):
global device_tracktype_selected__chain_number_selected
device_controls = (
None,
None,
None,
None,
None,
None,
None,
None,
)
self.device_tracktype_selected__chain_number_selected.set_parameter_controls(
tuple(device_controls))
self.device_tracktype_selected__chain_number_selected.set_on_off_button(
None)
self.device_tracktype_selected__chain_number_selected.set_bank_nav_buttons(
None, None)
self.set_device_component(
self.device_tracktype_selected__chain_number_selected)
def add_device_listeners(self):
global mixer
num_of_tracks = len(self.song().tracks)
value = "add device listener"
for index in range(num_of_tracks):
self.song().tracks[index].add_devices_listener(
self._reload_active_devices)
def remove_device_listeners(self):
global mixer
num_of_tracks = len(self.song().tracks)
value = "remove device listener"
for index in range(num_of_tracks):
self.song().tracks[index].remove_devices_listener(
self._reload_active_devices)
def _on_selected_track_changed(self):
ControlSurface._on_selected_track_changed(self)
self._display_reset_delay = 0
value = "selected track changed"
self._reload_active_devices(value)
def _reload_active_devices(self, value=None):
self._remove_active_devices()
self._set_active_devices()
def _set_active_devices(self):
global active_mode
# activate mode
if (active_mode == "_mode1") and (hasattr(self, '_mode1_devices')):
self._mode1_devices()
def _remove_active_devices(self):
global active_mode
# remove activate mode
if (active_mode == "_mode1") and (hasattr(self, '_mode1_devices')):
self._remove_mode1_devices()
def _next_device_value(self, value):
if value > 0:
self._device = self.song().view.selected_track.view.selected_device
if self._device is not None:
self.song().view.select_device(
self.song().view.selected_track.devices[
self.selected_device_idx() + 1])
def _prev_device_value(self, value):
if value > 0:
self._device = self.song().view.selected_track.view.selected_device
if self._device is not None:
self.song().view.select_device(
self.song().view.selected_track.devices[
self.selected_device_idx() - 1])
def selected_device_idx(self):
self._device = self.song().view.selected_track.view.selected_device
return self.tuple_index(self.song().view.selected_track.devices,
self._device)
def _track_navigation_right_track_nav(self, value):
if value > 0:
self.song().view.selected_track = self.song().tracks[
self.selected_track_idx() + 1]
def _track_navigation_left_track_nav(self, value):
if value > 0:
self.song().view.selected_track = self.song().tracks[
self.selected_track_idx() - 1]
def selected_track_idx(self):
return self.tuple_index(self.song().tracks,
self.song().view.selected_track)
def _set_active_mode(self):
global active_mode
# activate mode
if active_mode == "_mode1":
self._mode1()
def _remove_active_mode(self):
global active_mode
# remove activate mode
if active_mode == "_mode1":
self._remove_mode1()
def _activate_mode1(self, value):
global active_mode
if value > 0:
self._remove_active_mode()
active_mode = "_mode1"
self._set_active_mode()
def _activate_shift_mode1(self, value):
global active_mode
if value > 0:
self._remove_active_mode()
self._mode1()
else:
self._remove_mode1()
self._set_active_mode()
def tuple_index(self, tuple, obj):
for i in xrange(0, len(tuple)):
if (tuple[i] == obj):
return i
return (False)
def disconnect(self):
super(midi_twister_110, self).disconnect()
class BlockMod(MonOhm):
__module__ = __name__
__doc__ = " Monomodular controller script for Livid Block "
def __init__(self, *a, **k):
self._shift_button = None
super(BlockMod, self).__init__(*a, **k)
self._host_name = 'BlockMod'
self._color_type = 'Monochrome'
self._link_mixer = LINK_MIXER
self._rgb = 1
self._ohm = 127
self._ohm_type = 'static'
self._pad_translations = PAD_TRANSLATION
self._mem = [4, 8, 12, 16]
self.modhandler._color_type = 'Monochrome'
"""script initialization methods"""
def _setup_monobridge(self):
self._monobridge = MonoBridgeElement(self)
self._monobridge.name = 'MonoBridge'
def _setup_controls(self):
is_momentary = True
self._fader = [None for index in range(8)]
self._dial = [None for index in range(8)]
self._button = [None for index in range(8)]
self._menu = [None for index in range(6)]
for index in range(2):
self._fader[index] = MonoEncoderElement(MIDI_CC_TYPE, CHANNEL, SLIDER_CC[index], Live.MidiMap.MapMode.absolute, 'Fader_' + str(index), index, self)
#for index in range(8):
# self._button[index] = MonoButtonElement(is_momentary, MIDI_NOTE_TYPE, CHANNEL, OHM_BUTTONS[index], 'Button_' + str(index), self)
for index in range(8):
self._dial[index] = MonoEncoderElement(MIDI_CC_TYPE, CHANNEL, KNOB_CC[index], Live.MidiMap.MapMode.absolute, 'Dial_' + str(index), index + 8, self)
for index in range(4):
self._menu[index] = MonoButtonElement(is_momentary, MIDI_NOTE_TYPE, CHANNEL, FUNCTION_NOTES[index], 'Menu_' + str(index), self)
#self._livid = MonoButtonElement(is_momentary, MIDI_NOTE_TYPE, CHANNEL, LIVID, 'Livid_Button', self)
self._livid = DoublePressElement(MonoButtonElement(is_momentary, MIDI_NOTE_TYPE, CHANNEL, LIVID, 'Livid_Button', self))
self._shift_l = MonoButtonElement(is_momentary, MIDI_NOTE_TYPE, CHANNEL, SHIFT_L, 'Shift_Button_Left', self)
self._shift_r = MonoButtonElement(is_momentary, MIDI_NOTE_TYPE, CHANNEL, SHIFT_R, 'Shift_Button_Right', self)
self._matrix = ButtonMatrixElement()
self._matrix.name = 'Matrix'
self._monomod = ButtonMatrixElement()
self._monomod.name = 'Monomod'
self._grid = [None for index in range(8)]
for column in range(8):
self._grid[column] = [None for index in range(8)]
for row in range(8):
self._grid[column][row] = MonoButtonElement(is_momentary, MIDI_NOTE_TYPE, CHANNEL, (column * 8) + row, 'Grid_' + str(column) + '_' + str(row), self)
for row in range(5):
button_row = []
for column in range(7):
button_row.append(self._grid[column][row])
self._matrix.add_row(tuple(button_row))
for row in range(8):
button_row = []
for column in range(8):
button_row.append(self._grid[column][row])
self._monomod.add_row(tuple(button_row))
self._dummy_button = ButtonElement(is_momentary, MIDI_NOTE_TYPE, 15, 125)
self._dummy_button.name = 'Dummy1'
self._dummy_button2 = ButtonElement(is_momentary, MIDI_NOTE_TYPE, 15, 126)
self._dummy_button2.name = 'Dummy2'
self._dummy_button3 = ButtonElement(is_momentary, MIDI_NOTE_TYPE, 15, 127)
self._dummy_button2.name = 'Dummy3'
self._dial_matrix = ButtonMatrixElement()
self._dial_matrix.add_row(self._dial)
def _setup_transport_control(self):
self._transport = TransportComponent()
self._transport.name = 'Transport'
def _setup_crossfader(self):
pass
def _setup_mod(self):
super(BlockMod, self)._setup_mod()
self.modhandler.nav_box.on_value = 8
def _setup_layers(self):
self._device_navigator.layer = Layer(priority = 5, prev_button = self._menu[2], next_button = self._menu[3])
self._device.mod_layer = AddLayerMode(self._device, Layer(priority = 5, bank_prev_button = self._menu[0], bank_next_button = self._menu[1]))
self._transport.mod_layer = AddLayerMode(self._transport, Layer(priority = 5, play_button = self._menu[2], stop_button = self._menu[3]))
self.modhandler.set_mod_button(self._livid)
self.modhandler.layer = Layer(priority = 5,
grid = self._monomod,
nav_up_button = self._menu[0],
nav_down_button = self._menu[1],
nav_left_button = self._menu[2],
nav_right_button = self._menu[3],
shift_button = self._shift_r,
alt_button = self._shift_l,
parameter_controls = self._dial_matrix)
self.modhandler.legacy_shift_mode = AddLayerMode(self.modhandler, Layer(priority = 6,
channel_buttons = self._monomod.submatrix[:, 1:2],
nav_matrix = self._monomod.submatrix[:4, 2:6]))
self.modhandler.shift_mode = AddLayerMode(self.modhandler, Layer(priority = 6,
lock_button = self._livid,
device_selector_matrix = self._monomod.submatrix[:, :1],
key_buttons = self._monomod.submatrix[:, 7:8]))
self.modhandler.shiftlock_mode = AddLayerMode(self.modhandler, Layer(priority = 6,
key_buttons = self._monomod.submatrix[:, 7:8]))
def _setup_modes(self):
self._monomod_mode = MonomodModeComponent(self, self.monomod_mode_update)
self._monomod_mode.name = 'Monomod_Mode'
self._monomod_mode.layer = Layer(priority = 5, mode_toggle = self._livid)
self._monomod_mode.set_enabled(True)
self._on_shift_doublepress_value.subject = self._livid.double_press
self._shift_mode = BlockModShiftModeComponent(self, self.shift_update)
self._shift_mode.name = 'Shift_Mode'
#self._shift_mode.set_mode_toggle(self._shift_l, self._shift_r)
self._shift_mode.layer = Layer(priority = 3, toggle1 = self._shift_l, toggle2 = self._shift_r)
self._shift_mode.set_enabled(True)
self._l_function_mode = FunctionModeComponent(self, self.l_function_update)
self._l_function_mode.name = 'Left_Function_Mode'
self._r_function_mode = FunctionModeComponent(self, self.r_function_update)
self._r_function_mode.name = 'Right_Function_Mode'
self._m_function_mode = FunctionModeComponent(self, self.m_function_update)
self._m_function_mode.name = 'Main_Function_Mode'
self._function_modes = [self._l_function_mode, self._r_function_mode, self._m_function_mode]
@subject_slot('value')
def _on_shift_doublepress_value(self, value):
#self._monomod_mode.set_mode(abs(self._monomod_mode._mode_index -1))
pass
"""shift/zoom methods"""
def deassign_matrix(self):
self._session_zoom.set_button_matrix(None)
self._session_zoom2.set_button_matrix(None)
#self._session.set_stop_track_clip_buttons(None)
#self._session2.set_stop_track_clip_buttons(None)
self._session_zoom_main.set_button_matrix(None)
#self._session_main.set_stop_track_clip_buttons(None)
for column in range(4):
self._mixer2.channel_strip(column).set_select_button(None)
self._mixer2.return_strip(column).set_mute_button(None)
self._mixer2.return_strip(column).set_solo_button(None)
self._mixer2.return_strip(column).set_arm_button(None)
self._mixer2.return_strip(column).set_crossfade_toggle(None)
self._mixer2.return_strip(column).set_select_button(None) #shouldn't this be somewhere else?
self._mixer2.channel_strip(column).set_crossfade_toggle(None)
self._mixer2.channel_strip(column).set_mute_button(None)
self._mixer2.channel_strip(column).set_solo_button(None)
self._mixer2.channel_strip(column).set_arm_button(None)
for row in range(5):
self._scene[row].clip_slot(column).set_launch_button(None)
self._scene2[row].clip_slot(column).set_launch_button(None)
for index in range(5):
self._scene[index].set_launch_button(None)
self._scene2[index].set_launch_button(None)
self._scene_main[index].set_launch_button(None)
self._session_zoom.set_nav_buttons(None, None, None, None)
self._session_zoom2.set_nav_buttons(None, None, None, None)
self._session_zoom_main.set_nav_buttons(None, None, None, None)
self._session.set_track_bank_buttons(None, None)
self._session.set_scene_bank_buttons(None, None)
self._session2.set_track_bank_buttons(None, None)
self._session2.set_scene_bank_buttons(None, None)
self._session_main.set_track_bank_buttons(None, None)
self._session_main.set_scene_bank_buttons(None, None)
for column in range(8):
self._mixer.channel_strip(column).set_select_button(None)
self._mixer.channel_strip(column).set_crossfade_toggle(None)
self._mixer.channel_strip(column).set_mute_button(None)
self._mixer.channel_strip(column).set_solo_button(None)
self._mixer.channel_strip(column).set_arm_button(None)
for row in range(5):
self._scene_main[row].clip_slot(column).set_launch_button(None)
for row in range(8):
self._grid[column][row].set_channel(0)
self._grid[column][row].release_parameter()
self._grid[column][row].use_default_message()
self._grid[column][row].set_enabled(True)
self._grid[column][row].set_on_off_values(127, 0)
self._grid[column][row].send_value(0, True)
#self._send_reset.set_buttons(tuple(None for index in range(4)))
def zoom_off(self):
for column in range(4):
self._grid[column][5].set_on_value(MUTE[self._rgb])
self._mixer.channel_strip(column).set_mute_button(self._grid[column][5])
self._grid[column][6].set_on_value(ARM[self._rgb])
self._mixer.channel_strip(column).set_arm_button(self._grid[column][6])
for row in range(5):
self._scene[row].clip_slot(column).set_launch_button(self._grid[column][row])
if(self._r_function_mode._mode_index in range(0,3)):
self._grid[column + 4][5].set_on_value(MUTE[self._rgb])
self._mixer2.channel_strip(column).set_mute_button(self._grid[column + 4][5])
self._grid[column + 4][6].set_on_value(ARM[self._rgb])
self._mixer2.channel_strip(column).set_arm_button(self._grid[column + 4][6])
for row in range(5):
self._scene2[row].clip_slot(column).set_launch_button(self._grid[column + 4][row])
elif(self._r_function_mode._mode_index is 3):
self._grid[column + 4][5].set_on_value(MUTE[self._rgb])
self._mixer2.return_strip(column).set_mute_button(self._grid[column + 4][5])
for row in range(5):
self._grid[column + 4][row].send_value(USER1_COLOR[self._rgb], True)
self._grid[column + 4][row].set_channel(RIGHT_USER1_CHANNEL)
self._grid[column + 4][row].set_identifier(RIGHT_USER1_MAP[column][row])
self._grid[column + 4][row].set_enabled(False) #this has to happen for translate to work
#self._session_zoom2.set_ignore_buttons(True)
if(self._r_function_mode._mode_index is 0):
for index in range(4):
self._grid[index + 4][7].send_value(SEND_RESET[self._rgb], True)
#self._send_reset.set_buttons(tuple(self._grid[index + 4][7] for index in range(4)))
def zoom_off_m(self):
self.deassign_dials()
for column in range(8):
self._grid[column][5].set_on_value(MUTE[self._rgb])
self._mixer.channel_strip(column).set_mute_button(self._grid[column][5])
self._grid[column][6].set_on_value(ARM[self._rgb])
self._mixer.channel_strip(column).set_arm_button(self._grid[column][6])
for row in range(5):
self._scene_main[row].clip_slot(column).set_launch_button(self._grid[column][row])
#self._session_zoom.set_button_matrix(self._matrix)
def zoom_left(self):
track_stop_buttons = []
track_stop_buttons2 = []
for index in range(4):
self._grid[index][6].set_off_value(TRACK_STOP[self._rgb])
track_stop_buttons.append(self._grid[index][6])
self._grid[index + 4][6].set_off_value(TRACK_STOP[self._rgb])
track_stop_buttons2.append(self._grid[index + 4][6])
for index in range(5):
self._grid[7][index].set_off_value(SCENE_LAUNCH[self._rgb])
self._scene[index].set_launch_button(self._grid[7][index])
#self._session.set_stop_track_clip_buttons(tuple(track_stop_buttons))
#self._session.set_stop_track_clip_buttons(self._matrix.submatrix[:4][7:])
#self._session2.set_stop_track_clip_buttons(tuple(track_stop_buttons2))
#self._session2.set_stop_track_clip_buttons(self._matrix.submatrix[4:8][7:])
self._session_zoom.set_button_matrix(self._matrix)
self._grid[0][5].set_on_value(RECORD[self._rgb])
self._transport.set_record_button(self._grid[0][5])
self._grid[1][5].set_on_value(OVERDUB[self._rgb])
self._transport.set_overdub_button(self._grid[1][5])
self._grid[2][5].set_on_value(LOOP[self._rgb])
self._transport.set_loop_button(self._grid[2][5])
self._grid[3][5].set_on_value(STOP_ALL[self._rgb])
self._session.set_stop_all_clips_button(self._grid[3][5])
for index in range(4):
self._grid[index + 4][5].send_value(SEND_RESET[self._rgb], True)
#self._send_reset.set_buttons(tuple(self._grid[index + 4][5] for index in range(4)))
for index in range(4):
self._grid[index + 4][7].set_off_value(DEVICE_SELECT[self._rgb])
self._device_selector.set_matrix(self._monomod.submatrix[4:8][7:])
self._device_selector.set_offset(4)
def zoom_right(self):
track_stop_buttons = []
track_stop_buttons2 = []
for index in range(4):
self._grid[index][6].set_off_value(TRACK_STOP[self._rgb])
track_stop_buttons.append(self._grid[index][6])
for index in range(5):
self._grid[7][index].set_off_value(SCENE_LAUNCH[self._rgb])
self._scene2[index].set_launch_button(self._grid[7][index])
#self._session.set_stop_track_clip_buttons(tuple(track_stop_buttons))
#self._session.set_stop_track_clip_buttons(self._matrix.submatrix[:4][7:])
if(self._r_function_mode._mode_index < 3):
for index in range(4):
self._grid[index + 4][6].set_off_value(TRACK_STOP[self._rgb])
track_stop_buttons2.append(self._grid[index + 4][6])
#self._session2.set_stop_track_clip_buttons(self._matrix.submatrix[4:8][7:])
#self._session2.set_stop_track_clip_buttons(tuple(track_stop_buttons2))
self._session_zoom2.set_button_matrix(self._matrix)
self._grid[0][5].set_on_value(RECORD[self._rgb])
self._transport.set_record_button(self._grid[0][5])
self._grid[1][5].set_on_value(OVERDUB[self._rgb])
self._transport.set_overdub_button(self._grid[1][5])
self._grid[2][5].set_on_value(LOOP[self._rgb])
self._transport.set_loop_button(self._grid[2][5])
self._grid[3][5].set_on_value(STOP_ALL[self._rgb])
self._session.set_stop_all_clips_button(self._grid[3][5])
for index in range(4):
self._grid[index + 4][5].send_value(SEND_RESET[self._rgb], True)
#self._send_reset.set_buttons(tuple(self._grid[index + 4][5] for index in range(4)))
for index in range(4):
self._grid[index][7].set_off_value(DEVICE_SELECT[self._rgb])
self._device_selector.set_matrix(self._monomod.submatrix[:4][7:])
self._device_selector.set_offset(0)
def zoom_main(self):
track_stop_buttons = []
for index in range(8):
self._grid[index][6].set_on_value(TRACK_STOP[self._rgb])
track_stop_buttons.append(self._grid[index][6])
for index in range(5):
self._grid[7][index].set_on_value(SCENE_LAUNCH[self._rgb])
self._scene_main[index].set_launch_button(self._grid[7][index])
#self._session_main.set_stop_track_clip_buttons(tuple(track_stop_buttons))
#self._session_main.set_stop_track_clip_buttons(self._matrix[0:8][7:])
self._session_zoom_main.set_button_matrix(self._matrix)
self._grid[0][5].set_on_value(RECORD[self._rgb])
self._transport.set_record_button(self._grid[0][5])
self._grid[1][5].set_on_value(OVERDUB[self._rgb])
self._transport.set_overdub_button(self._grid[1][5])
self._grid[2][5].set_on_value(LOOP[self._rgb])
self._transport.set_loop_button(self._grid[2][5])
self._grid[3][5].set_on_value(STOP_ALL[self._rgb])
self._session.set_stop_all_clips_button(self._grid[3][5])
for index in range(4):
self._grid[index + 4][5].send_value(SEND_RESET[self._rgb], True)
#self._send_reset.set_buttons(tuple(self._grid[index + 4][5] for index in range(4)))
for index in range(4):
self._grid[index + 4][7].set_off_value(DEVICE_SELECT[self._rgb])
self._device_selector.set_matrix(self._monomod.submatrix[4:8][7:])
self._device_selector.set_offset(4)
"""function mode callbacks"""
def l_function_update(self):
mode = self._l_function_mode._mode_index
if(self._l_function_mode.is_enabled() is False):
self._l_function_mode.set_mode_buttons(None)
if not self.modhandler.is_enabled():
if(self._l_function_mode.is_enabled() is True):
if(len(self._l_function_mode._modes_buttons) is 0):
for index in range(4):
self._mixer.channel_strip(index).set_select_button(None)
buttons = []
for index in range(4):
buttons.append(self._grid[index][7])
self._l_function_mode.set_mode_buttons(tuple(buttons))
if(self._shift_mode._mode_index is 2):
for index in range(4):
if(mode != index):
self._grid[index][7].turn_off()
else:
self._grid[index][7].turn_on()
if(mode is 0):
self.assign_device_dials()
self.show_message('Mixer Split:Dials Device Mode')
elif(mode is 1):
self.assign_send_dials()
self.show_message('Mixer Split:Dials Send Mode')
elif(mode is 2):
self.assign_split_volume_dials()
self.show_message('Mixer Split:Dials Volume Mode')
elif(mode is 3):
self.assign_user_dials()
self.show_message('Mixer Split:Dials User Map Mode')
def r_function_update(self):
mode = self._r_function_mode._mode_index
if(self._r_function_mode.is_enabled() is False):
self._r_function_mode.set_mode_buttons(None)
#self._session2.set_show_highlight(False)
#self._session._highlighting_callback(self._session._track_offset, self._session._scene_offset, 4, 5, 1)
if not self.modhandler.is_enabled():
if(self._r_function_mode.is_enabled() is True):
if(len(self._r_function_mode._modes_buttons) is 0):
for index in range(4):
self._mixer2.channel_strip(index).set_select_button(None)
buttons = []
for index in range(4):
buttons.append(self._grid[index + 4][7])
self._r_function_mode.set_mode_buttons(tuple(buttons))
if(self._shift_mode._mode_index is 3):
for index in range(4):
if(mode != index):
self._grid[index + 4][7].turn_off()
else:
self._grid[index + 4][7].turn_on()
self._session2.set_offsets(int(self._mem[mode]), self._session2._scene_offset)
self.show_message('Mixer Split: Track Offset' + str(RIGHT_MODE_OFFSETS[mode]))
def m_function_update(self):
mode = self._m_function_mode._mode_index
if(self._m_function_mode.is_enabled() is False):
self._m_function_mode.set_mode_buttons(None)
#self._session.set_show_highlight(False)
#self._session2.set_show_highlight(False)
#self._session_main._highlighting_callback(self._session_main._track_offset, self._session_main._scene_offset, 8, 5, 1)
if not self.modhandler.is_enabled():
if(self._m_function_mode.is_enabled() is True):
if(len(self._m_function_mode._modes_buttons) is 0):
for index in range(8):
self._mixer.channel_strip(index).set_select_button(None)
buttons = []
for index in range(4):
buttons.append(self._grid[index][7])
self._m_function_mode.set_mode_buttons(tuple(buttons))
if(self._shift_mode._mode_index is 4):
for index in range(4):
if(mode != index):
self._grid[index][7].turn_off()
else:
self._grid[index][7].turn_on()
if(mode is 0):
self.assign_device_dials()
self.show_message('Mixer Linked:Dials Device Mode')
elif(mode is 1):
self.assign_send_dials()
self.show_message('Mixer Linked:Dials Send Mode')
elif(mode is 2):
self.assign_volume_dials()
self.show_message('Mixer Linked:Dials Volume Mode')
elif(mode is 3):
self.assign_user_dials()
self.show_message('Mixer Linked:Dials User Map Mode')
def shift_update(self):
self._clutch_device_selection = True
#self.allow_updates(False)
#if(not self._in_build_midi_map):
# self.set_suppress_rebuild_requests(True)
self.deassign_channel_select_buttons()
self.deassign_matrix()
self.deassign_menu()
if(self._monomod_mode._mode_index is 0): #if monomod is not on
if(self._shift_mode._mode_index is 0): #if no shift is pressed
#self._shift_mode._mode_toggle1.turn_off()
#self._shift_mode._mode_toggle2.turn_off()
if(self.split_mixer() is False):
self.set_split_mixer(True)
for zoom in self._zooms:
zoom._on_zoom_value(0)
self.zoom_off()
self._device_selector.set_enabled(False)
for mode in self._function_modes:
mode.set_enabled(False)
self.assign_channel_select_buttons()
#self._recalculate_selected_channel()
#self.assign_transport_to_menu()
self.assign_session_nav_to_menu()
self.l_function_update()
self.r_function_update()
self.assign_crossfader()
self.set_highlighting_session_component(self._session)
self._session._do_show_highlight()
#self._session.set_show_highlight(True)
elif(self._shift_mode._mode_index is 1): #if no shift is pressed, but mixer is linked
#self._shift_mode._mode_toggle1.turn_on()
#self._shift_mode._mode_toggle2.turn_on()
if(self.split_mixer() is True):
self.set_split_mixer(False)
for zoom in self._zooms:
zoom._on_zoom_value(0)
self.zoom_off_m()
self._device_selector.set_enabled(False)
for mode in self._function_modes:
mode.set_enabled(False)
self.assign_main_channel_select_buttons()
self.assign_session_main_nav_to_menu()
self.m_function_update()
self.assign_crossfader()
self.set_highlighting_session_component(self._session_main)
self._session_main._do_show_highlight()
elif(self._shift_mode._mode_index > 1): #if a shift is pressed
self.assign_device_nav_to_menu()
self.deassign_channel_select_buttons()
if(self._shift_mode._mode_index is 2): #if shift left
#self._shift_mode._mode_toggle1.turn_on()
self.zoom_left()
self._session_zoom._on_zoom_value(1)
self._session.set_enabled(True) #this is a workaround so that the stop buttons still function
self._l_function_mode.set_enabled(True)
self.set_highlighting_session_component(self._session)
self._session._do_show_highlight()
elif(self._shift_mode._mode_index is 3): #if shift right
#self._shift_mode._mode_toggle2.turn_on()
self.zoom_right()
self._session_zoom2._on_zoom_value(1)
self._session2.set_enabled(True) #this is a workaround so that the stop buttons still function
self._r_function_mode.set_enabled(True)
self.assign_master_fader()
if(self._r_function_mode._mode_index < 4):
self.set_highlighting_session_component(self._session2)
self._session2._do_show_highlight()
elif(self._shift_mode._mode_index is 4): #if either shift pressed while mixer is linked
#self._shift_mode._mode_toggle1.turn_on()
#self._shift_mode._mode_toggle2.turn_on()
self.zoom_main()
self._session_zoom_main._on_zoom_value(1)
self._session_main.set_enabled(True) #this is a workaround so that the stop buttons still function
self._m_function_mode.set_enabled(True)
self.assign_master_fader()
self.set_highlighting_session_component(self._session_main)
self._session_main._do_show_highlight()
self._device_selector.set_enabled(True)
else:
for mode in self._function_modes:
mode.set_enabled(False)
#self.modhandler._shift_value(int(self._shift_mode._mode_index>1))
self.allow_updates(True)
#self.set_suppress_rebuild_requests(False)
self._clutch_device_selection = False
if(self._shift_mode._mode_index < 2):
self._monobridge._send('touch', 'off')
else:
self._monobridge._send('touch', 'on')
"""left control management methods"""
def deassign_dials(self):
for index in range(8):
self._dial[index].use_default_message()
self._dial[index].release_parameter()
self._dial[index].set_enabled(True)
if(self._device._parameter_controls != None):
for control in self._device._parameter_controls:
control.release_parameter()
self._device._parameter_controls = None
self._mixer.selected_strip().set_send_controls(None)
self._mixer.selected_strip().set_volume_control(None)
for track in range(4):
self._mixer.channel_strip(track).set_volume_control(None)
self._mixer.channel_strip(track+4).set_volume_control(None)
self._mixer2.channel_strip(track).set_volume_control(None)
self._mixer2.return_strip(track).set_volume_control(None)
def assign_device_dials(self):
self._ohm_type = OHM_TYPE[0]
self._ohm = OHM_VALUE[0]
self.deassign_dials()
self._device.set_enabled(True)
device_param_controls = []
for index in range(8):
device_param_controls.append(self._dial[index])
self._device.set_parameter_controls(tuple(device_param_controls))
self._mixer.selected_strip().set_volume_control(self._fader[0])
def assign_send_dials(self):
self._ohm_type = OHM_TYPE[1]
self._ohm = OHM_VALUE[1]
self.deassign_dials()
dials = []
for index in range(4):
dials.append(self._dial[index])
for index in range(4):
if(self._mixer2.return_strip(index)):
self._mixer2.return_strip(index).set_volume_control(self._dial[index + 4])
self._mixer.selected_strip().set_send_controls(tuple(dials))
self._mixer.selected_strip().set_volume_control(self._fader[0])
def assign_volume_dials(self):
self._ohm_type = OHM_TYPE[2]
self._ohm = OHM_VALUE[2]
self.deassign_dials()
for track in range(8):
self._mixer.channel_strip(track).set_volume_control(self._dial[track])
self._mixer.selected_strip().set_volume_control(self._fader[0])
def assign_split_volume_dials(self):
self._ohm_type = OHM_TYPE[2]
self._ohm = OHM_VALUE[2]
self.deassign_dials()
for track in range(4):
self._mixer.channel_strip(track).set_volume_control(self._dial[track])
self._mixer2.channel_strip(track).set_volume_control(self._dial[track+4])
self._mixer.selected_strip().set_volume_control(self._fader[0])
def assign_user_dials(self):
self._ohm_type = OHM_TYPE[3]
self._ohm = OHM_VALUE[3]
self.deassign_dials()
for index in range(8):
self._dial[index].set_channel(L_USER_DIAL_CHAN)
self._dial[index].set_identifier(L_USER_DIAL_MAP[index])
self._dial[index].set_enabled(False)
self._mixer.selected_strip().set_volume_control(self._fader[0])
"""menu button management methods"""
def deassign_menu(self):
self._device.set_lock_button(None)
self._device.set_on_off_button(None)
#self._device_navigator.set_device_nav_buttons(None, None)
self._device_navigator.set_enabled(False)
self._device.set_bank_nav_buttons(None, None)
self._transport.set_play_button(None)
self._transport.set_record_button(None)
self._transport.set_stop_button(None)
self._transport.set_loop_button(None)
self._transport.set_overdub_button(None)
self._session.set_stop_all_clips_button(None)
self._session_main.set_track_bank_buttons(None, None)
self._session_main.set_scene_bank_buttons(None, None)
def assign_device_nav_to_menu(self):
#self._device_navigator.set_device_nav_buttons(self._menu[2], self._menu[3])
self._device_navigator.set_enabled(True)
self._device.set_bank_nav_buttons(self._menu[0], self._menu[1])
def assign_transport_to_menu(self):
self._transport.set_play_button(self._menu[0])
self._transport.set_record_button(self._menu[2])
self._transport.set_stop_button(self._menu[1])
session.set_stop_all_clips_button(self._menu[3])
def assign_session_nav_to_menu(self):
self._session.set_track_bank_buttons(self._menu[3], self._menu[2])
self._session.set_scene_bank_buttons(self._menu[1], self._menu[0])
def assign_monomod_shift_to_menu(self):
#self._device_navigator.set_device_nav_buttons(self._menu[3], self._menu[2])
self._device_navigator.set_enabled(True)
self._device.set_bank_nav_buttons(self._menu[1], self._menu[0])
def assign_session_bank_to_menu(self):
self._session.set_track_bank_buttons(self._menu[3], self._menu[2])
self._session.set_scene_bank_buttons(self._menu[1], self._menu[0])
def assign_session2_bank_to_menu(self):
self._session2.set_track_bank_buttons(self._menu[3], self._menu[2])
self._session2.set_scene_bank_buttons(self._menu[1], self._menu[0])
def assign_session_main_nav_to_menu(self):
self._session_main.set_track_bank_buttons(self._menu[3], self._menu[2])
self._session_main.set_scene_bank_buttons(self._menu[1], self._menu[0])
"""channel selection management methods"""
def deassign_channel_select_buttons(self):
for index in range(8):
if(self._mixer.channel_strip(index)):
self._mixer.channel_strip(index).set_select_button(None)
self._grid[index][7].release_parameter()
for index in range(4):
self._mixer2.channel_strip(index).set_select_button(None)
self._mixer2.return_strip(index).set_select_button(None)
self._mixer2.master_strip().set_select_button(None)
self._grid[index + 4][7].release_parameter()
def assign_channel_select_buttons(self):
for index in range(4):
#if(self._mixer.channel_strip(index)):
self._grid[index][7].set_on_off_values(127, 0)
self._mixer.channel_strip(index).set_select_button(self._grid[index][7])
if(self._r_function_mode._mode_index < 3):
for index in range(4):
self._grid[index][7].set_on_off_values(127, 0)
self._mixer2.channel_strip(index).set_select_button(self._grid[index + 4][7])
else:
for index in range(4):
self._grid[index][7].set_on_off_values(1, 0)
self._mixer2.return_strip(index).set_select_button(self._grid[index + 4][7])
def assign_return_select_buttons(self):
for index in range(4):
self._grid[index + 4][7].set_off_value(0)
if(self._mixer.channel_strip(index)):
self._grid[index + 4][7].set_on_value(1)
self._mixer.channel_strip(index).set_select_button(self._grid[index + 4][7])
def assign_l_channel_select_buttons(self):
self._mixer.set_select_buttons(None, None)
self._session.set_select_buttons(None, None)
for index in range(4):
self._grid[index][7].set_off_value(0)
if(self._mixer.channel_strip(index)):
self._mixer.channel_strip(index).set_select_button(self._grid[index][7])
def assign_r_channel_select_buttons(self):
self._mixer2.set_select_buttons(None, None)
self._session2.set_select_buttons(None, None)
for index in range(4):
self._grid[index + 4][7].set_off_value(0)
if(self._mixer2.channel_strip(index)):
self._mixer2.channel_strip(index).set_select_button(self._grid[index + 4][7])
def assign_main_channel_select_buttons(self):
for index in range(8):
self._grid[index][7].set_off_value(0)
if(self._mixer.channel_strip(index)):
self._grid[index][7].set_on_value(127)
self._mixer.channel_strip(index).set_select_button(self._grid[index][7])
def assign_master_fader(self):
self._mixer.set_crossfader_control(None)
self._mixer.master_strip().set_volume_control(self._fader[1])
def assign_crossfader(self):
self._mixer.master_strip().set_volume_control(None)
self._mixer.set_crossfader_control(self._fader[1])
"""called on timer"""
def update_display(self):
super(BlockMod, self).update_display()
if(self._timer == 0):
self._shift_pressed_timer = -12
def strobe(self):
if(self._ohm_type != 'static'):
if(self._ohm_type is 'pulse'):
self._ohm = int(math.fabs(((self._timer * 8) % 64) -32) +32)
if(self._ohm_type is 'up'):
self._ohm = int(((self._timer * 4) % 64) + 16)
if(self._ohm_type is 'down'):
self._ohm = int(math.fabs(int(((self._timer * 4) % 64) - 64)) + 16)
self._send_midi(tuple([176, 63, int(self._ohm)]))
self._send_midi(tuple([176, 31, int(self._ohm)]))
def handle_sysex(self, midi_bytes):
pass
def _on_session_offset_changes(self):
if self._r_function_mode._mode_index in range(0,4):
self._mem[int(self._r_function_mode._mode_index)] = self._session2.track_offset()
# a
class ProjectX(ControlSurface):
__module__ = __name__
__doc__ = " ProjectX keyboard controller script "
def __init__(self, c_instance):
"""everything except the '_on_selected_track_changed' override and 'disconnect' runs from here"""
ControlSurface.__init__(self, c_instance)
self.log_message(
time.strftime("%d.%m.%Y %H:%M:%S", time.localtime()) +
"--------------= ProjectX log opened =--------------")
with self.component_guard():
self._create_transport_control()
self._create_mixer_control()
self._create_session_control()
self.request_rebuild_midi_map()
self.log_message("Captain's last log stardate ****")
def _create_transport_control(self):
is_momentary = True
self._transport = TransportComponent(is_enabled=True, name='Transport')
"""set up the buttons"""
self._transport.set_play_button(
ButtonElement(is_momentary, MIDI_NOTE_TYPE, CHANNEL, 61))
self._transport.set_stop_button(
ButtonElement(is_momentary, MIDI_NOTE_TYPE, CHANNEL, 63))
self._transport.set_record_button(
ButtonElement(is_momentary, MIDI_NOTE_TYPE, CHANNEL, 66))
self._transport.set_overdub_button(
ButtonElement(is_momentary, MIDI_NOTE_TYPE, CHANNEL, 68))
self._transport.set_nudge_buttons(
ButtonElement(is_momentary, MIDI_NOTE_TYPE, CHANNEL, 75),
ButtonElement(is_momentary, MIDI_NOTE_TYPE, CHANNEL, 73))
self._transport.set_tap_tempo_button(
ButtonElement(is_momentary, MIDI_NOTE_TYPE, CHANNEL, 78))
self._transport.set_metronome_button(
ButtonElement(is_momentary, MIDI_NOTE_TYPE, CHANNEL, 80))
self._transport.set_loop_button(
ButtonElement(is_momentary, MIDI_NOTE_TYPE, CHANNEL, 82))
self._transport.set_punch_buttons(
ButtonElement(is_momentary, MIDI_NOTE_TYPE, CHANNEL, 85),
ButtonElement(is_momentary, MIDI_NOTE_TYPE, CHANNEL, 87))
self._transport.set_seek_buttons(
ButtonElement(is_momentary, MIDI_NOTE_TYPE, CHANNEL, 90),
ButtonElement(is_momentary, MIDI_NOTE_TYPE, CHANNEL, 92))
"""set up the sliders"""
self._transport.set_tempo_control(
SliderElement(MIDI_CC_TYPE, CHANNEL, 26),
SliderElement(MIDI_CC_TYPE, CHANNEL, 25))
self._transport.set_song_position_control(
SliderElement(MIDI_CC_TYPE, CHANNEL, 24))
self.log_message("Captain's log stardate 1")
def _create_mixer_control(self):
is_momentary = True
num_tracks = 7
"""Here we set up the global mixer"""
global mixer
mixer = MixerComponent(name='Mixer',
num_tracks=num_tracks,
is_enabled=False,
num_returns=2)
mixer.set_enabled(True)
mixer.set_track_offset(0)
self.song().view.selected_track = mixer.channel_strip(0)._track
mixer.channel_strip(0)
"""set up the mixer buttons"""
mixer.set_select_buttons(
ButtonElement(is_momentary, MIDI_NOTE_TYPE, CHANNEL, 56),
ButtonElement(is_momentary, MIDI_NOTE_TYPE, CHANNEL, 54))
mixer.master_strip().set_select_button(
ButtonElement(is_momentary, MIDI_NOTE_TYPE, CHANNEL, 94))
mixer.selected_strip().set_mute_button(
ButtonElement(is_momentary, MIDI_NOTE_TYPE, CHANNEL, 42))
mixer.selected_strip().set_solo_button(
ButtonElement(is_momentary, MIDI_NOTE_TYPE, CHANNEL, 44))
mixer.selected_strip().set_arm_button(
ButtonElement(is_momentary, MIDI_NOTE_TYPE, CHANNEL, 46))
"""set up the mixer sliders"""
mixer.selected_strip().set_volume_control(
SliderElement(MIDI_CC_TYPE, CHANNEL, 14))
"""note that we have split the mixer functions across two scripts, in order to have two session highlight
boxes (one red, one yellow), so there are a few things which we are not doing here... """
self.log_message("Captain's log stardate 2")
def _create_session_control(self):
is_momentary = True
num_tracks = 1
num_scenes = 7
global session
session = SessionComponent(num_tracks, num_scenes)
session.set_offsets(0, 0)
"""set up the session navigation buttons"""
session.set_select_buttons(
ButtonElement(is_momentary, MIDI_NOTE_TYPE, CHANNEL, 25),
ButtonElement(is_momentary, MIDI_NOTE_TYPE, CHANNEL, 27))
session.set_scene_bank_buttons(
ButtonElement(is_momentary, MIDI_NOTE_TYPE, CHANNEL, 51),
ButtonElement(is_momentary, MIDI_NOTE_TYPE, CHANNEL, 49))
session.set_stop_all_clips_button(
ButtonElement(is_momentary, MIDI_NOTE_TYPE, CHANNEL, 70))
session.selected_scene().set_launch_button(
ButtonElement(is_momentary, MIDI_NOTE_TYPE, CHANNEL, 30))
"""Here we set up the scene launch assignments for the session"""
launch_notes = [60, 62, 64, 65, 67, 69, 71]
for index in range(num_scenes):
session.scene(index).set_launch_button(
ButtonElement(is_momentary, MIDI_NOTE_TYPE, CHANNEL,
launch_notes[index]))
"""Here we set up the track stop launch assignment(s) for the session"""
stop_track_buttons = []
for index in range(num_tracks):
stop_track_buttons.append(
ButtonElement(is_momentary, MIDI_NOTE_TYPE, CHANNEL,
58 + index))
session.set_stop_track_clip_buttons(tuple(stop_track_buttons))
"""Here we set up the clip launch assignments for the session"""
clip_launch_notes = [48, 50, 52, 53, 55, 57, 59]
for index in range(num_scenes):
session.scene(index).clip_slot(0).set_launch_button(
ButtonElement(is_momentary, MIDI_NOTE_TYPE, CHANNEL,
clip_launch_notes[index]))
"""Here we set up a mixer and channel strip(s) which move with the session"""
self.log_message("Captain's log stardate 3")
def _on_selected_track_changed(self):
"""This is an override, to add special functionality (we want to move the session to the selected track,
when it changes) Note that it is sometimes necessary to reload Live (not just the script) when making changes
to this function"""
ControlSurface._on_selected_track_changed(self)
"""here we set the mixer and session to the selected track, when the selected track changes"""
selected_track = self.song().view.selected_track
mixer.channel_strip(0).set_track(selected_track)
all_tracks = ((self.song().tracks + self.song().return_tracks) +
(self.song().master_track, ))
index = list(all_tracks).index(selected_track)
session.set_offsets(index, session._scene_offset)
def disconnect(self):
"""clean things up on disconnect"""
self.log_message(
time.strftime("%d.%m.%Y %H:%M:%S", time.localtime()) +
"--------------= ProjectX log closed =--------------")
ControlSurface.disconnect(self)
return None
class OP1(ControlSurface):
def __init__(self, c_instance):
ControlSurface.__init__(self, c_instance)
self.c_instance = c_instance
self.retries_count = 0
self.device_connected = False
self.clip_color_callbacks = {}
self.slot_callbacks = {}
self.text_start_sequence = (0xf0, 0x0, 0x20, 0x76, 0x00, 0x03)
self.text_end_sequence = (0xf7,)
self.enable_sequence = (0xf0, 0x00, 0x20, 0x76, 0x00, 0x01, 0x02, 0xf7)
self.disable_sequence = (0xf0, 0x00, 0x20, 0x76, 0x00, 0x01, 0x00, 0xf7)
self.id_sequence = (0xf0, 0x7e, 0x7f, 0x06, 0x01, 0xf7)
self.text_color_start_sequence = (0xf0, 0x0, 0x20, 0x76, 0x00, 0x04)
self.log('INITIALIZING')
self.app = Live.Application.get_application()
#maj = self.app.get_major_version()
#min = self.app.get_minor_version()
#bug = self.app.get_bugfix_version()
#self.show_message(str(1) + "." + str(0) + "." + str(9))
self.show_message("Version " + VERSION)
# reseting text
self.write_text(' ')
# reset display clips
self.reset_display_clips()
# getting browser visible state
self.session_browser_visible = self.app.view.is_view_visible("Browser")
# getting browser visible state
self.arrange_browser_visible = self.app.view.is_view_visible("Browser")
# getting session view visible state
self.session_visible = self.app.view.is_view_visible("Session")
# getting arrange view visible state
self.arrange_visible = self.app.view.is_view_visible("Arranger")
# getting detail view visible state
self.detail_visible = self.app.view.is_view_visible("Detail")
# getting back to arranger state
self.back_to_arranger_state = self.song().back_to_arranger
# initializing channel strip to null
self._channel_strip = None
# initializing transport component
self._transport = TransportComponent()
# initializing mixer component
self._mixer = MixerComponent(NUM_TRACKS,2)
# initializing session component
self._session = SessionComponent(NUM_TRACKS,NUM_ROWS)
self._session.add_offset_listener(self.session_offset_changed)
# configuring operation mode selector buttons
self._operation_mode_buttons = ButtonElement(True, MIDI_CC_TYPE, CHANNEL, OP1_MODE_1_BUTTON), ButtonElement(True, MIDI_CC_TYPE, CHANNEL, OP1_MODE_2_BUTTON), ButtonElement(True, MIDI_CC_TYPE, CHANNEL, OP1_MODE_3_BUTTON), ButtonElement(True, MIDI_CC_TYPE, CHANNEL, OP1_MODE_4_BUTTON),
# initializing operation mode selector
self._operation_mode_selector = OP1ModeSelectorComponent(self, self._transport, self._mixer, self._session)
# setting operation mode selector buttons
self._operation_mode_selector.set_mode_buttons(self._operation_mode_buttons)
# adding value listener for operation mode index
self._operation_mode_selector.add_mode_index_listener(self.mode_index_changed)
# setting global transport assignments
self._transport.set_record_button(ButtonElement(True, MIDI_CC_TYPE, CHANNEL, OP1_REC_BUTTON))
self._transport.set_play_button(ButtonElement(True, MIDI_CC_TYPE, CHANNEL, OP1_PLAY_BUTTON))
self._transport.set_stop_button(ButtonElement(True, MIDI_CC_TYPE, CHANNEL, OP1_STOP_BUTTON))
self._transport.set_metronome_button(ButtonElement(True, MIDI_CC_TYPE, CHANNEL, OP1_METRONOME_BUTTON))
self._transport.set_tap_tempo_button(ButtonElement(True, MIDI_CC_TYPE, CHANNEL, OP1_HELP_BUTTON))
self._transport.set_punch_buttons(ButtonElement(True, MIDI_CC_TYPE, CHANNEL, OP1_SS1_BUTTON), ButtonElement(True,MIDI_CC_TYPE, CHANNEL, OP1_SS2_BUTTON))
self._transport.set_loop_button(ButtonElement(True, MIDI_CC_TYPE, CHANNEL, OP1_SS3_BUTTON))
self._transport.set_overdub_button(ButtonElement(True, MIDI_CC_TYPE, CHANNEL, OP1_SS4_BUTTON))
# setting global session assignments
self._session.set_scene_bank_buttons(ButtonElement(True, MIDI_CC_TYPE, CHANNEL, OP1_COM),ButtonElement(True, MIDI_CC_TYPE, CHANNEL, OP1_MICRO))
# setting misc listeners
self.browser_toggle_button = ButtonElement(False, MIDI_CC_TYPE, CHANNEL, 15)
self.browser_toggle_button.add_value_listener(self.browser_toggle_button_callback)
self.mainview_toggle_button = ButtonElement(False, MIDI_CC_TYPE, CHANNEL, 16)
self.mainview_toggle_button.add_value_listener(self.mainview_toggle_button_callback)
self.detailview_toggle_button = ButtonElement(False, MIDI_CC_TYPE, CHANNEL, 17)
self.detailview_toggle_button.add_value_listener(self.detailview_toggle_button_callback)
self.clear_track_button = ButtonElement(True, MIDI_CC_TYPE, CHANNEL, 25)
self.clear_track_button.add_value_listener(self.clear_track_button_callback)
self.back_to_arranger_button = ButtonElement(True, MIDI_CC_TYPE, CHANNEL, 26)
self.back_to_arranger_button.add_value_listener(self.back_to_arranger_button_callback)
# adding value listener for selected track change
self.song().view.add_selected_track_listener(self.selected_track_changed)
# adding value listener for selected scene change
self.song().view.add_selected_scene_listener(self.selected_scene_changed)
# setting assignments for currently selected track
self.selected_track_changed()
# setting assignments for currently selected scene
self.selected_scene_changed()
def handle_sysex(self, midi_bytes):
if ((midi_bytes[6]==32) and (midi_bytes[7]==118)):
self.device_connected = True
self.log("OP-1 CONNECTED. SENDING ABLETON LIVE MODE INIT SEQUENCE")
self._send_midi(self.enable_sequence)
def add_clip_slot_listeners(self):
#self.log('ADDING CLIP SLOT LISTENERS')
# creating an empty list for all clip slots
clip_slots = []
# getting a reference to all tracks
tracks = self.song().tracks
# appending all tracks clip slots to clip_slots
for track in tracks:
clip_slots.append(track.clip_slots)
# iterating over all clip slots
for t in range(len(clip_slots)):
for c in range(len(clip_slots[t])):
clip_slot = clip_slots[t][c]
# adding has clip listener to clip slot
self.add_slot_listener(clip_slot)
# if clip slot has clip
if clip_slot.has_clip:
# adding clip listeners
self.add_clip_listener(clip_slot.clip)
def rem_clip_slot_listeners(self):
#self.log('REMOVING CLIP SLOT LISTENERS')
# iterate over all clip color change callbacks
for c in self.clip_color_callbacks:
# if clip still exists
if c != None:
# and it has a has clip listener
if c.color_has_listener(self.clip_color_callbacks[c]) == 1:
# remove it
c.remove_color_listener(self.clip_color_callbacks[c])
# iterate over all clip slot callbacks
for cs in self.slot_callbacks:
# if clip slot still exists
if cs != None:
# and it has a has clip listener
if cs.has_clip_has_listener(self.slot_callbacks[cs]) == 1:
# remove it
cs.remove_has_clip_listener(self.slot_callbacks[cs])
def add_slot_listener(self, cs):
# setting has clip listener
callback = lambda :self.has_clip_listener(cs)
# if we don't have a clip slot has clip listener for this clip slot yet
if not(self.slot_callbacks.has_key(cs)):
# adding has clip callback to clip slot
cs.add_has_clip_listener(callback)
# saving callback for future release
self.slot_callbacks[cs] = callback
def add_clip_listener(self, clip):
# setting callback for clip color change
color_callback = lambda :self.update_display_clips()
# if we don't have a clip color change callback for this clip yet
if not(self.clip_color_callbacks.has_key(clip)):
# adding clip color change callback
clip.add_color_listener(color_callback)
# saving callback for future release
self.clip_color_callbacks[clip] = color_callback
def has_clip_listener(self, cs):
# clip slot has clip listener callback
if cs.has_clip:
# add clip listener
self.add_clip_listener(cs.clip)
else:
# update display if clip slot was removed
self.update_display_clips()
def session_offset_changed(self):
# if session component offset changes, update display
self.update_display_clips()
def selected_scene_changed(self):
# if on clip mode update display
if (self._operation_mode_selector.mode_index==OP1_MODE_CLIP):
self.update_display_clip_mode()
def mode_index_changed(self):
# update display to current mode info
if (self._operation_mode_selector.mode_index==OP1_MODE_PERFORM):
self.update_display_perform_mode()
elif (self._operation_mode_selector.mode_index==OP1_MODE_CLIP):
self.update_display_clip_mode()
elif (self._operation_mode_selector.mode_index==OP1_MODE_TRANSPORT):
self.update_display_transport_mode()
elif (self._operation_mode_selector.mode_index==OP1_MODE_MIXER):
self.update_display_mixer_mode()
def clear_track_button_callback(self, value):
# if clear track button was called, reset track
if (value==127):
for i in range(len(self.song().tracks)):
self.song().tracks[i].arm = 0
self.song().tracks[i].solo = 0
self.song().tracks[i].mute = 0
for i in range(len(self.song().return_tracks)):
self.song().tracks[i].solo = 0
self.song().tracks[i].mute = 0
def clear_return_track_assignment(self, strip):
# clear return track assingments
strip.set_volume_control(None)
strip.set_pan_control(None)
strip.set_mute_button(None)
strip.set_solo_button(None)
def clear_track_assignment(self, strip):
# clear track assignments
strip.set_volume_control(None)
strip.set_pan_control(None)
strip.set_mute_button(None)
strip.set_solo_button(None)
strip.set_arm_button(None)
def clear_tracks_assigments(self):
# for all normal tracks, clear assignments
for i in range(NUM_TRACKS):
strip = self._mixer.channel_strip(i)
if (strip!=None):
self.clear_track_assignment(strip)
# for all return tracks, clear assignments
for i in range(2):
return_strip = self._mixer.return_strip(i)
if (return_strip!=None):
self.clear_return_track_assignment(return_strip)
def selected_track_changed(self):
# if on mixer mode update display
if (self._operation_mode_selector.mode_index==OP1_MODE_MIXER):
self.update_display_mixer_mode()
# clear track assignments
self.clear_tracks_assigments()
# getting selected strip
self._channel_strip = self._mixer.selected_strip()
# perform track assignments
self._channel_strip.set_volume_control(EncoderElement(MIDI_CC_TYPE, CHANNEL, OP1_ENCODER_1, Live.MidiMap.MapMode.relative_two_compliment))
self._channel_strip.set_pan_control(EncoderElement(MIDI_CC_TYPE, CHANNEL, OP1_ENCODER_2, Live.MidiMap.MapMode.relative_two_compliment))
# setting a tuple of encoders to control sends
send_controls = EncoderElement(MIDI_CC_TYPE, CHANNEL, OP1_ENCODER_3, Live.MidiMap.MapMode.relative_two_compliment), EncoderElement(MIDI_CC_TYPE, CHANNEL, OP1_ENCODER_4, Live.MidiMap.MapMode.relative_two_compliment),
# setting send encoders
self._channel_strip.set_send_controls(tuple(send_controls))
# setting solo button
self._channel_strip.set_solo_button(ButtonElement(True, MIDI_CC_TYPE, CHANNEL, OP1_SS6_BUTTON))
# if track can be armed, set arm button
if (self._channel_strip._track.can_be_armed):
self._channel_strip.set_arm_button(ButtonElement(True, MIDI_CC_TYPE, CHANNEL, OP1_SS7_BUTTON))
# if track is no master, set mute button
if (self._channel_strip._track!=self.song().master_track):
self._channel_strip.set_mute_button(ButtonElement(True, MIDI_CC_TYPE, CHANNEL, OP1_SS5_BUTTON))
def browser_toggle_button_callback(self, value):
if (value==127):
if (self.session_visible):
if (self.session_browser_visible==True):
self.session_browser_visible=False
self.app.view.hide_view("Browser")
else:
self.session_browser_visible=True
self.app.view.show_view("Browser")
if (self.arrange_visible):
if (self.arrange_browser_visible==True):
self.arrange_browser_visible=False
self.app.view.hide_view("Browser")
else:
self.arrange_browser_visible=True
self.app.view.show_view("Browser")
def back_to_arranger_button_callback(self, value):
if (value==127):
self.song().back_to_arranger = False
def mainview_toggle_button_callback(self, value):
if (value==127):
if (self.session_visible==True):
self.session_visible=False
self.arrange_visible=True
self.app.view.show_view("Arranger")
self.arrange_browser_visible = self.app.view.is_view_visible("Browser");
else:
self.session_visible=True
self.arrange_visible=False
self.app.view.show_view("Session")
self.session_browser_visible = self.app.view.is_view_visible("Browser");
def detailview_toggle_button_callback(self, value):
if (value==127):
if (self.detail_visible==True):
self.detail_visible=False
self.app.view.hide_view("Detail")
else:
self.detail_visible=True
self.app.view.show_view("Detail")
def write_text(self, msg):
text_list = []
sequence = ()
text_list.append(len(msg.strip()))
for i in msg.strip():
text_list.append(ord(i))
sequence = self.text_start_sequence + tuple(text_list) + self.text_end_sequence
self._send_midi(sequence)
def suggest_input_port(self):
return "OP-1 Midi Device"
def suggest_output_port(self):
return "OP-1 Midi Device"
def update_display_perform_mode(self):
self.write_text("perform\rmode")
def reset_display_clips(self):
count = 0
colors = []
length = []
sequence = ()
for i in range (NUM_TRACKS):
count+=1
colors.append(0x00)
colors.append(0x00)
colors.append(0x00)
length.append(count)
sequence = self.text_color_start_sequence + tuple(length) + tuple(colors) + self.text_end_sequence
self._send_midi(sequence)
def update_display_clips(self):
#self.log("UPDATING DISPLAY CLIPS")
count = 0
colors = []
length = []
sequence = ()
tracks_len = len(self.song().tracks)-self._session._track_offset
if (tracks_len>NUM_TRACKS):
tracks_len = NUM_TRACKS
for i in range (tracks_len):
count+=1
clip_slot = self._session.scene(0).clip_slot(i)
if (clip_slot!=None):
if (clip_slot.has_clip()!=False):
clip_color = clip_slot._clip_slot.clip.color
colors.append(((clip_color>>16)&0x000000ff)>>1)
colors.append(((clip_color>>8)&0x000000ff)>>1)
colors.append((clip_color&0x000000ff)>>1)
else:
colors.append(0x00)
colors.append(0x00)
colors.append(0x00)
else:
colors.append(0x00)
colors.append(0x00)
colors.append(0x00)
length.append(count)
sequence = self.text_color_start_sequence + tuple(length) + tuple(colors) + self.text_end_sequence
self._send_midi(sequence)
def update_display_clip_mode(self):
self.write_text("sel. scene\r" + str(self.song().view.selected_scene.name.lower().strip()))
def update_display_transport_mode(self):
song_time = str(self.song().get_current_beats_song_time())
self.write_text("song pos.\r" + song_time[:len(song_time)-4])
def update_display_mixer_mode(self):
self.write_text("sel. track\r" + str(self.song().view.selected_track.name.lower()))
def update_display(self):
if not(self.device_connected):
if (self.retries_count<5):
self.log("TRYING OP-1 CONNECTION")
self.retries_count+=1
self._send_midi(self.id_sequence)
time.sleep(1)
# if in transport mode, update display with song position
if (self._operation_mode_selector.mode_index==OP1_MODE_TRANSPORT):
self.update_display_transport_mode()
# checking if app current view is session
if (self.app.view.is_view_visible("Session")):
# checking if session browser state is diferent from the internal
if (self.session_browser_visible != self.app.view.is_view_visible("Browser")):
self.session_browser_visible = self.app.view.is_view_visible("Browser")
# checking if app current view is arrange
if (self.app.view.is_view_visible("Arranger")):
# checking if arrange browser state is diferent from the internal
if (self.arrange_browser_visible != self.app.view.is_view_visible("Browser")):
self.arrange_browser_visible = self.app.view.is_view_visible("Browser")
# checking if app current view is detail
if (self.app.view.is_view_visible("Detail")):
# checking if detail state is diferent from the internal
if (self.detail_visible != self.app.view.is_view_visible("Detail")):
self.detail_visible = self.app.view.is_view_visible("Detail")
def refresh_state(self):
self.log("REFRESH STATE")
self.retries_count = 0
self.device_connected = False
def build_midi_map(self, midi_map_handle):
#self.log("BUILD MIDI MAP")
assert (self._suppress_requests_counter == 0)
self._in_build_midi_map = True
self._midi_map_handle = midi_map_handle
self._forwarding_registry = {}
for control in self.controls:
if isinstance(control, InputControlElement):
control.install_connections()
self._midi_map_handle = None
self._in_build_midi_map = False
if (self._pad_translations != None):
self._c_instance.set_pad_translation(self._pad_translations)
# remove clip listeners
self.rem_clip_slot_listeners()
# add clip listeners
self.add_clip_slot_listeners()
# update display
self.update_display_clips()
def log(self, msg):
self.c_instance.log_message("[TE OP-1] " + msg)
def disconnect(self):
# removing clip slots listeners
self.rem_clip_slot_listeners()
# removing value listener for track changed
self.song().view.remove_selected_track_listener(self.selected_track_changed)
# removing value listener for scene changed
self.song().view.remove_selected_scene_listener(self.selected_scene_changed)
# removing value listener for operation mode index
self._operation_mode_selector.remove_mode_index_listener(self.mode_index_changed)
# removing global transport assignments
self._transport.set_punch_buttons(None, None)
self._transport.set_loop_button(None)
self._transport.set_overdub_button(None)
self._transport.set_record_button(None)
self._transport.set_play_button(None)
self._transport.set_stop_button(None)
self._transport.set_metronome_button(None)
self._transport.set_tap_tempo_button(None)
# removing global session assignments
self._session.set_scene_bank_buttons(None, None)
# removing misc listeners
self.browser_toggle_button.remove_value_listener(self.browser_toggle_button_callback)
self.mainview_toggle_button.remove_value_listener(self.mainview_toggle_button_callback)
self.detailview_toggle_button.remove_value_listener(self.detailview_toggle_button_callback)
self.clear_track_button.remove_value_listener(self.clear_track_button_callback)
self.back_to_arranger_button.remove_value_listener(self.back_to_arranger_button_callback)
# sending special ableton mode disable sequence
self._send_midi(self.disable_sequence)
# disconnecting control surface
ControlSurface.disconnect(self)
self.log("DISCONNECTED")
class BlockMod(MonOhm):
__module__ = __name__
__doc__ = " Monomodular controller script for Livid Block "
def __init__(self, *a, **k):
self._shift_button = None
self._shift_pressed = 0
self._shift_pressed_timer = 0
self._shift_thresh = SHIFT_THRESH
super(BlockMod, self).__init__(*a, **k)
self._host_name = 'BlockMod'
self._color_type = 'Monochrome'
self._link_mixer = LINK_MIXER
self._rgb = 1
self._ohm = 127
self._ohm_type = 'static'
self._pad_translations = PAD_TRANSLATION
self._mem = [4, 8, 12, 16]
self._host._navbox_selected = 8
"""script initialization methods"""
def _setup_monobridge(self):
self._monobridge = MonoBridgeElement(self)
self._monobridge.name = 'MonoBridge'
def _setup_controls(self):
is_momentary = True
self._fader = [None for index in range(8)]
self._dial = [None for index in range(16)]
self._button = [None for index in range(8)]
self._menu = [None for index in range(6)]
for index in range(2):
self._fader[index] = MonoEncoderElement(MIDI_CC_TYPE, CHANNEL, SLIDER_CC[index], Live.MidiMap.MapMode.absolute, 'Fader_' + str(index), index, self)
#for index in range(8):
# self._button[index] = MonoButtonElement(is_momentary, MIDI_NOTE_TYPE, CHANNEL, OHM_BUTTONS[index], 'Button_' + str(index), self)
for index in range(8):
self._dial[index] = MonoEncoderElement(MIDI_CC_TYPE, CHANNEL, KNOB_CC[index], Live.MidiMap.MapMode.absolute, 'Dial_' + str(index), index + 8, self)
for index in range(4):
self._menu[index] = MonoButtonElement(is_momentary, MIDI_NOTE_TYPE, CHANNEL, FUNCTION_NOTES[index], 'Menu_' + str(index), self)
self._livid = MonoButtonElement(is_momentary, MIDI_NOTE_TYPE, CHANNEL, LIVID, 'Livid_Button', self)
self._shift_l = MonoButtonElement(is_momentary, MIDI_NOTE_TYPE, CHANNEL, SHIFT_L, 'Shift_Button_Left', self)
self._shift_r = MonoButtonElement(is_momentary, MIDI_NOTE_TYPE, CHANNEL, SHIFT_R, 'Shift_Button_Right', self)
self._matrix = ButtonMatrixElement()
self._matrix.name = 'Matrix'
self._monomod = ButtonMatrixElement()
self._monomod.name = 'Monomod'
self._grid = [None for index in range(8)]
for column in range(8):
self._grid[column] = [None for index in range(8)]
for row in range(8):
self._grid[column][row] = MonoButtonElement(is_momentary, MIDI_NOTE_TYPE, CHANNEL, (column * 8) + row, 'Grid_' + str(column) + '_' + str(row), self)
for row in range(5):
button_row = []
for column in range(7):
button_row.append(self._grid[column][row])
self._matrix.add_row(tuple(button_row))
for row in range(8):
button_row = []
for column in range(8):
button_row.append(self._grid[column][row])
self._monomod.add_row(tuple(button_row))
self._dummy_button = ButtonElement(is_momentary, MIDI_NOTE_TYPE, 15, 125)
self._dummy_button.name = 'Dummy1'
self._dummy_button2 = ButtonElement(is_momentary, MIDI_NOTE_TYPE, 15, 126)
self._dummy_button2.name = 'Dummy2'
self._dummy_button3 = ButtonElement(is_momentary, MIDI_NOTE_TYPE, 15, 127)
self._dummy_button2.name = 'Dummy3'
def _setup_transport_control(self):
self._transport = TransportComponent()
self._transport.name = 'Transport'
def _setup_crossfader(self):
pass
def _setup_modes(self):
self._monomod_mode = MonomodModeComponent(self, self.monomod_mode_update)
self._monomod_mode.name = 'Monomod_Mode'
self.set_shift_button(self._livid)
self._shift_mode = BlockModShiftModeComponent(self, self.shift_update)
self._shift_mode.name = 'Shift_Mode'
self._shift_mode.set_mode_toggle(self._shift_l, self._shift_r)
self._l_function_mode = FunctionModeComponent(self, self.l_function_update)
self._l_function_mode.name = 'Left_Function_Mode'
self._r_function_mode = FunctionModeComponent(self, self.r_function_update)
self._r_function_mode.name = 'Right_Function_Mode'
self._m_function_mode = FunctionModeComponent(self, self.m_function_update)
self._m_function_mode.name = 'Main_Function_Mode'
self._function_modes = [self._l_function_mode, self._r_function_mode, self._m_function_mode]
"""livid double press mechanism"""
def set_shift_button(self, button):
assert ((button == None) or (isinstance(button, MonoButtonElement)))
if self._shift_button != None:
self._shift_button.remove_value_listener(self._shift_value)
self._shift_button = button
if self._shift_button != None:
self._shift_button.add_value_listener(self._shift_value)
def _shift_value(self, value):
self._shift_pressed = int(value != 0)
if self._shift_pressed > 0:
if (self._shift_pressed_timer + self._shift_thresh) > self._timer:
if(self._host._active_client != None):
if(self._host.is_enabled() != True):
self._monomod_mode.set_mode(1)
else:
self._monomod_mode.set_mode(0)
else:
self._shift_pressed_timer = self._timer % 256
if(self._cntrlr != None):
self._cntrlr._monohm_shift(2)
else:
if(self._cntrlr != None):
self._cntrlr._monohm_shift(0)
"""shift/zoom methods"""
def deassign_matrix(self):
self._session_zoom.set_button_matrix(None)
self._session_zoom2.set_button_matrix(None)
self._session.set_stop_track_clip_buttons(None)
self._session2.set_stop_track_clip_buttons(None)
self._session_zoom_main.set_button_matrix(None)
self._session_main.set_stop_track_clip_buttons(None)
for column in range(4):
self._mixer2.channel_strip(column).set_select_button(None)
self._mixer2.return_strip(column).set_mute_button(None)
self._mixer2.return_strip(column).set_solo_button(None)
self._mixer2.return_strip(column).set_arm_button(None)
self._mixer2.return_strip(column).set_crossfade_toggle(None)
self._mixer2.return_strip(column).set_select_button(None) #shouldn't this be somewhere else?
self._mixer2.channel_strip(column).set_crossfade_toggle(None)
self._mixer2.channel_strip(column).set_mute_button(None)
self._mixer2.channel_strip(column).set_solo_button(None)
self._mixer2.channel_strip(column).set_arm_button(None)
for row in range(5):
self._scene[row].clip_slot(column).set_launch_button(None)
self._scene2[row].clip_slot(column).set_launch_button(None)
for index in range(5):
self._scene[index].set_launch_button(None)
self._scene2[index].set_launch_button(None)
self._scene_main[index].set_launch_button(None)
self._session_zoom.set_nav_buttons(None, None, None, None)
self._session_zoom2.set_nav_buttons(None, None, None, None)
self._session_zoom_main.set_nav_buttons(None, None, None, None)
self._session.set_track_bank_buttons(None, None)
self._session.set_scene_bank_buttons(None, None)
self._session2.set_track_bank_buttons(None, None)
self._session2.set_scene_bank_buttons(None, None)
self._session_main.set_track_bank_buttons(None, None)
self._session_main.set_scene_bank_buttons(None, None)
for column in range(8):
self._mixer.channel_strip(column).set_select_button(None)
self._mixer.channel_strip(column).set_crossfade_toggle(None)
self._mixer.channel_strip(column).set_mute_button(None)
self._mixer.channel_strip(column).set_solo_button(None)
self._mixer.channel_strip(column).set_arm_button(None)
for row in range(5):
self._scene_main[row].clip_slot(column).set_launch_button(None)
for row in range(8):
self._grid[column][row].set_channel(0)
self._grid[column][row].release_parameter()
self._grid[column][row].use_default_message()
self._grid[column][row].set_enabled(True)
self._grid[column][row].set_on_off_values(127, 0)
self._grid[column][row].send_value(0, True)
self._send_reset.set_buttons(tuple(None for index in range(4)))
def zoom_off(self):
for column in range(4):
self._grid[column][5].set_on_value(MUTE[self._rgb])
self._mixer.channel_strip(column).set_mute_button(self._grid[column][5])
self._grid[column][6].set_on_value(ARM[self._rgb])
self._mixer.channel_strip(column).set_arm_button(self._grid[column][6])
for row in range(5):
self._scene[row].clip_slot(column).set_launch_button(self._grid[column][row])
if(self._r_function_mode._mode_index in range(0,3)):
self._grid[column + 4][5].set_on_value(MUTE[self._rgb])
self._mixer2.channel_strip(column).set_mute_button(self._grid[column + 4][5])
self._grid[column + 4][6].set_on_value(ARM[self._rgb])
self._mixer2.channel_strip(column).set_arm_button(self._grid[column + 4][6])
for row in range(5):
self._scene2[row].clip_slot(column).set_launch_button(self._grid[column + 4][row])
elif(self._r_function_mode._mode_index is 3):
self._grid[column + 4][5].set_on_value(MUTE[self._rgb])
self._mixer2.return_strip(column).set_mute_button(self._grid[column + 4][5])
for row in range(5):
self._grid[column + 4][row].send_value(USER1_COLOR[self._rgb], True)
self._grid[column + 4][row].set_channel(RIGHT_USER1_CHANNEL)
self._grid[column + 4][row].set_identifier(RIGHT_USER1_MAP[column][row])
self._grid[column + 4][row].set_enabled(False) #this has to happen for translate to work
#self._session_zoom2.set_ignore_buttons(True)
if(self._r_function_mode._mode_index is 0):
for index in range(4):
self._grid[index + 4][7].send_value(SEND_RESET[self._rgb], True)
self._send_reset.set_buttons(tuple(self._grid[index + 4][7] for index in range(4)))
def zoom_off_m(self):
self.deassign_dials()
for column in range(8):
self._grid[column][5].set_on_value(MUTE[self._rgb])
self._mixer.channel_strip(column).set_mute_button(self._grid[column][5])
self._grid[column][6].set_on_value(ARM[self._rgb])
self._mixer.channel_strip(column).set_arm_button(self._grid[column][6])
for row in range(5):
self._scene_main[row].clip_slot(column).set_launch_button(self._grid[column][row])
#self._session_zoom.set_button_matrix(self._matrix)
def zoom_left(self):
track_stop_buttons = []
track_stop_buttons2 = []
for index in range(4):
self._grid[index][6].set_off_value(TRACK_STOP[self._rgb])
track_stop_buttons.append(self._grid[index][6])
self._grid[index + 4][6].set_off_value(TRACK_STOP[self._rgb])
track_stop_buttons2.append(self._grid[index + 4][6])
for index in range(5):
self._grid[7][index].set_off_value(SCENE_LAUNCH[self._rgb])
self._scene[index].set_launch_button(self._grid[7][index])
self._session.set_stop_track_clip_buttons(tuple(track_stop_buttons))
self._session2.set_stop_track_clip_buttons(tuple(track_stop_buttons2))
self._session_zoom.set_button_matrix(self._matrix)
self._grid[0][5].set_on_value(RECORD[self._rgb])
self._transport.set_record_button(self._grid[0][5])
self._grid[1][5].set_on_value(OVERDUB[self._rgb])
self._transport.set_overdub_button(self._grid[1][5])
self._grid[2][5].set_on_value(LOOP[self._rgb])
self._transport.set_loop_button(self._grid[2][5])
self._grid[3][5].set_on_value(STOP_ALL[self._rgb])
self._session.set_stop_all_clips_button(self._grid[3][5])
for index in range(4):
self._grid[index + 4][5].send_value(SEND_RESET[self._rgb], True)
self._send_reset.set_buttons(tuple(self._grid[index + 4][5] for index in range(4)))
for index in range(4):
self._grid[index + 4][7].set_off_value(DEVICE_SELECT[self._rgb])
self._device_selector.assign_buttons(tuple(self._grid[index + 4][7] for index in range(4)), 4)
def zoom_right(self):
track_stop_buttons = []
track_stop_buttons2 = []
for index in range(4):
self._grid[index][6].set_off_value(TRACK_STOP[self._rgb])
track_stop_buttons.append(self._grid[index][6])
for index in range(5):
self._grid[7][index].set_off_value(SCENE_LAUNCH[self._rgb])
self._scene2[index].set_launch_button(self._grid[7][index])
self._session.set_stop_track_clip_buttons(tuple(track_stop_buttons))
if(self._r_function_mode._mode_index < 3):
for index in range(4):
self._grid[index + 4][6].set_off_value(TRACK_STOP[self._rgb])
track_stop_buttons2.append(self._grid[index + 4][6])
self._session2.set_stop_track_clip_buttons(tuple(track_stop_buttons2))
self._session_zoom2.set_button_matrix(self._matrix)
self._grid[0][5].set_on_value(RECORD[self._rgb])
self._transport.set_record_button(self._grid[0][5])
self._grid[1][5].set_on_value(OVERDUB[self._rgb])
self._transport.set_overdub_button(self._grid[1][5])
self._grid[2][5].set_on_value(LOOP[self._rgb])
self._transport.set_loop_button(self._grid[2][5])
self._grid[3][5].set_on_value(STOP_ALL[self._rgb])
self._session.set_stop_all_clips_button(self._grid[3][5])
for index in range(4):
self._grid[index + 4][5].send_value(SEND_RESET[self._rgb], True)
self._send_reset.set_buttons(tuple(self._grid[index + 4][5] for index in range(4)))
for index in range(4):
self._grid[index][7].set_off_value(DEVICE_SELECT[self._rgb])
self._device_selector.assign_buttons(tuple(self._grid[index][7] for index in range(4)), 0)
def zoom_main(self):
track_stop_buttons = []
for index in range(8):
self._grid[index][6].set_on_value(TRACK_STOP[self._rgb])
track_stop_buttons.append(self._grid[index][6])
for index in range(5):
self._grid[7][index].set_on_value(SCENE_LAUNCH[self._rgb])
self._scene_main[index].set_launch_button(self._grid[7][index])
self._session_main.set_stop_track_clip_buttons(tuple(track_stop_buttons))
self._session_zoom_main.set_button_matrix(self._matrix)
self._grid[0][5].set_on_value(RECORD[self._rgb])
self._transport.set_record_button(self._grid[0][5])
self._grid[1][5].set_on_value(OVERDUB[self._rgb])
self._transport.set_overdub_button(self._grid[1][5])
self._grid[2][5].set_on_value(LOOP[self._rgb])
self._transport.set_loop_button(self._grid[2][5])
self._grid[3][5].set_on_value(STOP_ALL[self._rgb])
self._session.set_stop_all_clips_button(self._grid[3][5])
for index in range(4):
self._grid[index + 4][5].send_value(SEND_RESET[self._rgb], True)
self._send_reset.set_buttons(tuple(self._grid[index + 4][5] for index in range(4)))
for index in range(4):
self._grid[index + 4][7].set_off_value(DEVICE_SELECT[self._rgb])
self._device_selector.assign_buttons(tuple(self._grid[index + 4][7] for index in range(4)), 4)
"""function mode callbacks"""
def l_function_update(self):
mode = self._l_function_mode._mode_index
#if(self._l_function_mode.is_enabled() is False):
# self._l_function_mode.set_mode_buttons(None)
if(self._l_function_mode.is_enabled() is True):
if(len(self._l_function_mode._modes_buttons) is 0):
for index in range(4):
self._mixer.channel_strip(index).set_select_button(None)
buttons = []
for index in range(4):
buttons.append(self._grid[index][7])
self._l_function_mode.set_mode_buttons(tuple(buttons))
if(self._shift_mode._mode_index is 2):
for index in range(4):
if(mode != index):
self._grid[index][7].turn_off()
else:
self._grid[index][7].turn_on()
if(mode is 0):
self.assign_device_dials()
self.show_message('Mixer Split:Dials Device Mode')
elif(mode is 1):
self.assign_send_dials()
self.show_message('Mixer Split:Dials Send Mode')
elif(mode is 2):
self.assign_split_volume_dials()
self.show_message('Mixer Split:Dials Volume Mode')
elif(mode is 3):
self.assign_user_dials()
self.show_message('Mixer Split:Dials User Map Mode')
def r_function_update(self):
mode = self._r_function_mode._mode_index
#if(self._r_function_mode.is_enabled() is False):
# self._r_function_mode.set_mode_buttons(None)
#self._session2.set_show_highlight(False)
#self._session._highlighting_callback(self._session._track_offset, self._session._scene_offset, 4, 5, 1)
if(self._r_function_mode.is_enabled() is True):
if(len(self._r_function_mode._modes_buttons) is 0):
for index in range(4):
self._mixer2.channel_strip(index).set_select_button(None)
buttons = []
for index in range(4):
buttons.append(self._grid[index + 4][7])
self._r_function_mode.set_mode_buttons(tuple(buttons))
if(self._shift_mode._mode_index is 3):
for index in range(4):
if(mode != index):
self._grid[index + 4][7].turn_off()
else:
self._grid[index + 4][7].turn_on()
self._session2.set_offsets(int(self._mem[mode]), self._session2._scene_offset)
self.show_message('Mixer Split: Track Offset' + str(RIGHT_MODE_OFFSETS[mode]))
def m_function_update(self):
mode = self._m_function_mode._mode_index
#if(self._m_function_mode.is_enabled() is False):
# self._m_function_mode.set_mode_buttons(None)
#self._session.set_show_highlight(False)
#self._session2.set_show_highlight(False)
#self._session_main._highlighting_callback(self._session_main._track_offset, self._session_main._scene_offset, 8, 5, 1)
if(self._m_function_mode.is_enabled() is True):
if(len(self._m_function_mode._modes_buttons) is 0):
for index in range(8):
self._mixer.channel_strip(index).set_select_button(None)
buttons = []
for index in range(4):
buttons.append(self._grid[index][7])
self._m_function_mode.set_mode_buttons(tuple(buttons))
if(self._shift_mode._mode_index is 4):
for index in range(4):
if(mode != index):
self._grid[index][7].turn_off()
else:
self._grid[index][7].turn_on()
if(mode is 0):
self.assign_device_dials()
self.show_message('Mixer Linked:Dials Device Mode')
elif(mode is 1):
self.assign_send_dials()
self.show_message('Mixer Linked:Dials Send Mode')
elif(mode is 2):
self.assign_volume_dials()
self.show_message('Mixer Linked:Dials Volume Mode')
elif(mode is 3):
self.assign_user_dials()
self.show_message('Mixer Linked:Dials User Map Mode')
def shift_update(self):
self._clutch_device_selection = True
#self.allow_updates(False)
#if(not self._in_build_midi_map):
# self.set_suppress_rebuild_requests(True)
self.deassign_channel_select_buttons()
self.deassign_matrix()
self.deassign_menu()
if(self._monomod_mode._mode_index is 0): #if monomod is not on
if(self._shift_mode._mode_index is 0): #if no shift is pressed
self._shift_mode._mode_toggle1.turn_off()
self._shift_mode._mode_toggle2.turn_off()
if(self.split_mixer() is False):
self.set_split_mixer(True)
for zoom in self._zooms:
zoom._on_zoom_value(0)
self.zoom_off()
self._device_selector.set_enabled(False)
for mode in self._function_modes:
mode.set_enabled(False)
self.assign_channel_select_buttons()
#self._recalculate_selected_channel()
#self.assign_transport_to_menu()
self.assign_session_nav_to_menu()
self.l_function_update()
self.r_function_update()
self.assign_crossfader()
self.set_highlighting_session_component(self._session)
self._session._do_show_highlight()
#self._session.set_show_highlight(True)
elif(self._shift_mode._mode_index is 1): #if no shift is pressed, but mixer is linked
self._shift_mode._mode_toggle1.turn_on()
self._shift_mode._mode_toggle2.turn_on()
if(self.split_mixer() is True):
self.set_split_mixer(False)
for zoom in self._zooms:
zoom._on_zoom_value(0)
self.zoom_off_m()
self._device_selector.set_enabled(False)
for mode in self._function_modes:
mode.set_enabled(False)
self.assign_main_channel_select_buttons()
self.assign_session_main_nav_to_menu()
self.m_function_update()
self.assign_crossfader()
self.set_highlighting_session_component(self._session_main)
self._session_main._do_show_highlight()
elif(self._shift_mode._mode_index > 1): #if a shift is pressed
self.assign_device_nav_to_menu()
self.deassign_channel_select_buttons()
if(self._shift_mode._mode_index is 2): #if shift left
self._shift_mode._mode_toggle1.turn_on()
self.zoom_left()
self._session_zoom._on_zoom_value(1)
self._session.set_enabled(True) #this is a workaround so that the stop buttons still function
self._l_function_mode.set_enabled(True)
self.set_highlighting_session_component(self._session)
self._session._do_show_highlight()
elif(self._shift_mode._mode_index is 3): #if shift right
self._shift_mode._mode_toggle2.turn_on()
self.zoom_right()
self._session_zoom2._on_zoom_value(1)
self._session2.set_enabled(True) #this is a workaround so that the stop buttons still function
self._r_function_mode.set_enabled(True)
self.assign_master_fader()
if(self._r_function_mode._mode_index < 4):
self.set_highlighting_session_component(self._session2)
self._session2._do_show_highlight()
elif(self._shift_mode._mode_index is 4): #if either shift pressed while mixer is linked
self._shift_mode._mode_toggle1.turn_on()
self._shift_mode._mode_toggle2.turn_on()
self.zoom_main()
self._session_zoom_main._on_zoom_value(1)
self._session_main.set_enabled(True) #this is a workaround so that the stop buttons still function
self._m_function_mode.set_enabled(True)
self.assign_master_fader()
self.set_highlighting_session_component(self._session_main)
self._session_main._do_show_highlight()
self._device_selector.set_enabled(True)
self.allow_updates(True)
#self.set_suppress_rebuild_requests(False)
self._clutch_device_selection = False
if(self._shift_mode._mode_index < 2):
self._monobridge._send('touch', 'off')
else:
self._monobridge._send('touch', 'on')
def monomod_mode_update(self):
if (self._monomod_mode._mode_index == 0) or (self._host._active_client == None):
self._host.set_enabled(False)
self._host._set_button_matrix(None)
self._host._set_nav_buttons(None)
self._host._set_lock_button(None)
self._host._set_alt_button(None)
self._host._set_shift_button(None)
self._livid.turn_off()
self._shift_mode.set_mode_toggle(self._shift_l, self._shift_r)
self._shift_mode.update()
#self._session._reassign_scenes()
elif(self._monomod_mode._mode_index == 1):
self._livid.turn_on()
self.deassign_matrix()
self.deassign_menu()
self._monomod.reset()
self._host._set_button_matrix(self._monomod)
self._host._set_nav_buttons(self._menu[0:4])
self._host._set_lock_button(self._shift_l)
self._host._set_alt_button(self._shift_r)
self._host._set_shift_button(self._livid)
self._shift_mode.set_mode_toggle(None, None)
self._host.set_enabled(True)
self._shift_mode.update()
#self.show_message('Monomod grid enabled')
"""left control management methods"""
def deassign_dials(self):
for index in range(8):
self._dial[index].use_default_message()
self._dial[index].release_parameter()
self._dial[index].set_enabled(True)
if(self._device._parameter_controls != None):
for control in self._device._parameter_controls:
control.release_parameter()
self._device._parameter_controls = None
self._mixer.selected_strip().set_send_controls(None)
self._mixer.selected_strip().set_volume_control(None)
for track in range(4):
self._mixer.channel_strip(track).set_volume_control(None)
self._mixer.channel_strip(track+4).set_volume_control(None)
self._mixer2.channel_strip(track).set_volume_control(None)
self._mixer2.return_strip(track).set_volume_control(None)
def assign_device_dials(self):
self._ohm_type = OHM_TYPE[0]
self._ohm = OHM_VALUE[0]
self.deassign_dials()
self._device.set_enabled(True)
device_param_controls = []
for index in range(8):
device_param_controls.append(self._dial[index])
self._device.set_parameter_controls(tuple(device_param_controls))
self._mixer.selected_strip().set_volume_control(self._fader[0])
def assign_send_dials(self):
self._ohm_type = OHM_TYPE[1]
self._ohm = OHM_VALUE[1]
self.deassign_dials()
dials = []
for index in range(4):
dials.append(self._dial[index])
for index in range(4):
if(self._mixer2.return_strip(index)):
self._mixer2.return_strip(index).set_volume_control(self._dial[index + 4])
self._mixer.selected_strip().set_send_controls(tuple(dials))
self._mixer.selected_strip().set_volume_control(self._fader[0])
def assign_volume_dials(self):
self._ohm_type = OHM_TYPE[2]
self._ohm = OHM_VALUE[2]
self.deassign_dials()
for track in range(8):
self._mixer.channel_strip(track).set_volume_control(self._dial[track])
self._mixer.selected_strip().set_volume_control(self._fader[0])
def assign_split_volume_dials(self):
self._ohm_type = OHM_TYPE[2]
self._ohm = OHM_VALUE[2]
self.deassign_dials()
for track in range(4):
self._mixer.channel_strip(track).set_volume_control(self._dial[track])
self._mixer2.channel_strip(track).set_volume_control(self._dial[track+4])
self._mixer.selected_strip().set_volume_control(self._fader[0])
def assign_user_dials(self):
self._ohm_type = OHM_TYPE[3]
self._ohm = OHM_VALUE[3]
self.deassign_dials()
for index in range(8):
self._dial[index].set_channel(L_USER_DIAL_CHAN)
self._dial[index].set_identifier(L_USER_DIAL_MAP[index])
self._dial[index].set_enabled(False)
self._mixer.selected_strip().set_volume_control(self._fader[0])
"""menu button management methods"""
def deassign_menu(self):
self._device.set_lock_button(None)
self._device.set_on_off_button(None)
self._device_navigator.set_device_nav_buttons(None, None)
self._device.set_bank_nav_buttons(None, None)
self._transport.set_play_button(None)
self._transport.set_record_button(None)
self._transport.set_stop_button(None)
self._transport.set_loop_button(None)
self._transport.set_overdub_button(None)
self._session.set_stop_all_clips_button(None)
self._transport.set_play_button(None)
self._transport.set_stop_button(None)
self._session_main.set_track_bank_buttons(None, None)
self._session_main.set_scene_bank_buttons(None, None)
def assign_device_nav_to_menu(self):
self._device_navigator.set_device_nav_buttons(self._menu[2], self._menu[3])
self._device.set_bank_nav_buttons(self._menu[0], self._menu[1])
def assign_transport_to_menu(self):
self._transport.set_play_button(self._menu[0])
self._transport.set_record_button(self._menu[2])
self._transport.set_stop_button(self._menu[1])
session.set_stop_all_clips_button(self._menu[3])
def assign_session_nav_to_menu(self):
self._session.set_track_bank_buttons(self._menu[3], self._menu[2])
self._session.set_scene_bank_buttons(self._menu[1], self._menu[0])
def assign_monomod_shift_to_menu(self):
self._device_navigator.set_device_nav_buttons(self._menu[3], self._menu[2])
self._device.set_bank_nav_buttons(self._menu[1], self._menu[0])
def assign_session_bank_to_menu(self):
self._session.set_track_bank_buttons(self._menu[3], self._menu[2])
self._session.set_scene_bank_buttons(self._menu[1], self._menu[0])
def assign_session2_bank_to_menu(self):
self._session2.set_track_bank_buttons(self._menu[3], self._menu[2])
self._session2.set_scene_bank_buttons(self._menu[1], self._menu[0])
def assign_session_main_nav_to_menu(self):
self._session_main.set_track_bank_buttons(self._menu[3], self._menu[2])
self._session_main.set_scene_bank_buttons(self._menu[1], self._menu[0])
"""channel selection management methods"""
def deassign_channel_select_buttons(self):
for index in range(8):
if(self._mixer.channel_strip(index)):
self._mixer.channel_strip(index).set_select_button(None)
self._grid[index][7].release_parameter()
for index in range(4):
self._mixer2.channel_strip(index).set_select_button(None)
self._mixer2.return_strip(index).set_select_button(None)
self._mixer2.master_strip().set_select_button(None)
self._grid[index + 4][7].release_parameter()
def assign_channel_select_buttons(self):
for index in range(4):
#if(self._mixer.channel_strip(index)):
self._grid[index][7].set_on_off_values(127, 0)
self._mixer.channel_strip(index).set_select_button(self._grid[index][7])
if(self._r_function_mode._mode_index < 3):
for index in range(4):
self._grid[index][7].set_on_off_values(127, 0)
self._mixer2.channel_strip(index).set_select_button(self._grid[index + 4][7])
else:
for index in range(4):
self._grid[index][7].set_on_off_values(1, 0)
self._mixer2.return_strip(index).set_select_button(self._grid[index + 4][7])
def assign_return_select_buttons(self):
for index in range(4):
self._grid[index + 4][7].set_off_value(0)
if(self._mixer.channel_strip(index)):
self._grid[index + 4][7].set_on_value(1)
self._mixer.channel_strip(index).set_select_button(self._grid[index + 4][7])
def assign_l_channel_select_buttons(self):
self._mixer.set_select_buttons(None, None)
self._session.set_select_buttons(None, None)
for index in range(4):
self._grid[index][7].set_off_value(0)
if(self._mixer.channel_strip(index)):
self._mixer.channel_strip(index).set_select_button(self._grid[index][7])
def assign_r_channel_select_buttons(self):
self._mixer2.set_select_buttons(None, None)
self._session2.set_select_buttons(None, None)
for index in range(4):
self._grid[index + 4][7].set_off_value(0)
if(self._mixer2.channel_strip(index)):
self._mixer2.channel_strip(index).set_select_button(self._grid[index + 4][7])
def assign_main_channel_select_buttons(self):
for index in range(8):
self._grid[index][7].set_off_value(0)
if(self._mixer.channel_strip(index)):
self._grid[index][7].set_on_value(127)
self._mixer.channel_strip(index).set_select_button(self._grid[index][7])
def assign_master_fader(self):
self._mixer.set_crossfader_control(None)
self._mixer.master_strip().set_volume_control(self._fader[1])
def assign_crossfader(self):
self._mixer.master_strip().set_volume_control(None)
self._mixer.set_crossfader_control(self._fader[1])
"""called on timer"""
def update_display(self):
super(BlockMod, self).update_display()
if(self._timer == 0):
self._shift_pressed_timer = -12
def strobe(self):
if(self._ohm_type != 'static'):
if(self._ohm_type is 'pulse'):
self._ohm = int(math.fabs(((self._timer * 8) % 64) -32) +32)
if(self._ohm_type is 'up'):
self._ohm = int(((self._timer * 4) % 64) + 16)
if(self._ohm_type is 'down'):
self._ohm = int(math.fabs(int(((self._timer * 4) % 64) - 64)) + 16)
self._send_midi(tuple([176, 63, int(self._ohm)]))
self._send_midi(tuple([176, 31, int(self._ohm)]))
def handle_sysex(self, midi_bytes):
pass
def _on_session_offset_changes(self):
if self._r_function_mode._mode_index in range(0,4):
self._mem[int(self._r_function_mode._mode_index)] = self._session2.track_offset()
# a
class OP1(ControlSurface):
def __init__(self, c_instance):
ControlSurface.__init__(self, c_instance)
self.c_instance = c_instance
self.retries_count = 0
self.device_connected = False
self.clip_color_callbacks = {}
self.slot_callbacks = {}
self.text_start_sequence = (0xf0, 0x0, 0x20, 0x76, 0x00, 0x03)
self.text_end_sequence = (0xf7, )
self.enable_sequence = (0xf0, 0x00, 0x20, 0x76, 0x00, 0x01, 0x02, 0xf7)
self.disable_sequence = (0xf0, 0x00, 0x20, 0x76, 0x00, 0x01, 0x00,
0xf7)
self.id_sequence = (0xf0, 0x7e, 0x7f, 0x06, 0x01, 0xf7)
self.text_color_start_sequence = (0xf0, 0x0, 0x20, 0x76, 0x00, 0x04)
self.log('INITIALIZING')
self.app = Live.Application.get_application()
#maj = self.app.get_major_version()
#min = self.app.get_minor_version()
#bug = self.app.get_bugfix_version()
#self.show_message(str(1) + "." + str(0) + "." + str(9))
self.show_message("Version " + VERSION)
# reseting text
self.write_text(' ')
# reset display clips
self.reset_display_clips()
# getting browser visible state
self.session_browser_visible = self.app.view.is_view_visible("Browser")
# getting browser visible state
self.arrange_browser_visible = self.app.view.is_view_visible("Browser")
# getting session view visible state
self.session_visible = self.app.view.is_view_visible("Session")
# getting arrange view visible state
self.arrange_visible = self.app.view.is_view_visible("Arranger")
# getting detail view visible state
self.detail_visible = self.app.view.is_view_visible("Detail")
# getting back to arranger state
self.back_to_arranger_state = self.song().back_to_arranger
# initializing channel strip to null
self._channel_strip = None
# initializing transport component
self._transport = TransportComponent()
# initializing mixer component
self._mixer = MixerComponent(NUM_TRACKS, 2)
# initializing session component
self._session = SessionComponent(NUM_TRACKS, NUM_ROWS)
self._session.add_offset_listener(self.session_offset_changed)
# configuring operation mode selector buttons
self._operation_mode_buttons = ButtonElement(
True, MIDI_CC_TYPE, CHANNEL, OP1_MODE_1_BUTTON), ButtonElement(
True, MIDI_CC_TYPE, CHANNEL, OP1_MODE_2_BUTTON), ButtonElement(
True, MIDI_CC_TYPE, CHANNEL,
OP1_MODE_3_BUTTON), ButtonElement(True, MIDI_CC_TYPE,
CHANNEL,
OP1_MODE_4_BUTTON),
# initializing operation mode selector
self._operation_mode_selector = OP1ModeSelectorComponent(
self, self._transport, self._mixer, self._session)
# setting operation mode selector buttons
self._operation_mode_selector.set_mode_buttons(
self._operation_mode_buttons)
# adding value listener for operation mode index
self._operation_mode_selector.add_mode_index_listener(
self.mode_index_changed)
# setting global transport assignments
self._transport.set_record_button(
ButtonElement(True, MIDI_CC_TYPE, CHANNEL, OP1_REC_BUTTON))
self._transport.set_play_button(
ButtonElement(True, MIDI_CC_TYPE, CHANNEL, OP1_PLAY_BUTTON))
self._transport.set_stop_button(
ButtonElement(True, MIDI_CC_TYPE, CHANNEL, OP1_STOP_BUTTON))
self._transport.set_metronome_button(
ButtonElement(True, MIDI_CC_TYPE, CHANNEL, OP1_METRONOME_BUTTON))
self._transport.set_tap_tempo_button(
ButtonElement(True, MIDI_CC_TYPE, CHANNEL, OP1_HELP_BUTTON))
self._transport.set_punch_buttons(
ButtonElement(True, MIDI_CC_TYPE, CHANNEL, OP1_SS1_BUTTON),
ButtonElement(True, MIDI_CC_TYPE, CHANNEL, OP1_SS2_BUTTON))
self._transport.set_loop_button(
ButtonElement(True, MIDI_CC_TYPE, CHANNEL, OP1_SS3_BUTTON))
self._transport.set_overdub_button(
ButtonElement(True, MIDI_CC_TYPE, CHANNEL, OP1_SS4_BUTTON))
# setting global session assignments
self._session.set_scene_bank_buttons(
ButtonElement(True, MIDI_CC_TYPE, CHANNEL, OP1_COM),
ButtonElement(True, MIDI_CC_TYPE, CHANNEL, OP1_MICRO))
# setting misc listeners
self.browser_toggle_button = ButtonElement(False, MIDI_CC_TYPE,
CHANNEL, 15)
self.browser_toggle_button.add_value_listener(
self.browser_toggle_button_callback)
self.mainview_toggle_button = ButtonElement(False, MIDI_CC_TYPE,
CHANNEL, 16)
self.mainview_toggle_button.add_value_listener(
self.mainview_toggle_button_callback)
self.detailview_toggle_button = ButtonElement(False, MIDI_CC_TYPE,
CHANNEL, 17)
self.detailview_toggle_button.add_value_listener(
self.detailview_toggle_button_callback)
self.clear_track_button = ButtonElement(True, MIDI_CC_TYPE, CHANNEL,
25)
self.clear_track_button.add_value_listener(
self.clear_track_button_callback)
self.back_to_arranger_button = ButtonElement(True, MIDI_CC_TYPE,
CHANNEL, 26)
self.back_to_arranger_button.add_value_listener(
self.back_to_arranger_button_callback)
# adding value listener for selected track change
self.song().view.add_selected_track_listener(
self.selected_track_changed)
# adding value listener for selected scene change
self.song().view.add_selected_scene_listener(
self.selected_scene_changed)
# setting assignments for currently selected track
self.selected_track_changed()
# setting assignments for currently selected scene
self.selected_scene_changed()
def handle_sysex(self, midi_bytes):
if ((midi_bytes[6] == 32) and (midi_bytes[7] == 118)):
self.device_connected = True
self.log("OP-1 CONNECTED. SENDING ABLETON LIVE MODE INIT SEQUENCE")
self._send_midi(self.enable_sequence)
def add_clip_slot_listeners(self):
#self.log('ADDING CLIP SLOT LISTENERS')
# creating an empty list for all clip slots
clip_slots = []
# getting a reference to all tracks
tracks = self.song().tracks
# appending all tracks clip slots to clip_slots
for track in tracks:
clip_slots.append(track.clip_slots)
# iterating over all clip slots
for t in range(len(clip_slots)):
for c in range(len(clip_slots[t])):
clip_slot = clip_slots[t][c]
# adding has clip listener to clip slot
self.add_slot_listener(clip_slot)
# if clip slot has clip
if clip_slot.has_clip:
# adding clip listeners
self.add_clip_listener(clip_slot.clip)
def rem_clip_slot_listeners(self):
#self.log('REMOVING CLIP SLOT LISTENERS')
# iterate over all clip color change callbacks
for c in self.clip_color_callbacks:
# if clip still exists
if c != None:
# and it has a has clip listener
if c.color_has_listener(self.clip_color_callbacks[c]) == 1:
# remove it
c.remove_color_listener(self.clip_color_callbacks[c])
# iterate over all clip slot callbacks
for cs in self.slot_callbacks:
# if clip slot still exists
if cs != None:
# and it has a has clip listener
if cs.has_clip_has_listener(self.slot_callbacks[cs]) == 1:
# remove it
cs.remove_has_clip_listener(self.slot_callbacks[cs])
def add_slot_listener(self, cs):
# setting has clip listener
callback = lambda: self.has_clip_listener(cs)
# if we don't have a clip slot has clip listener for this clip slot yet
if not (self.slot_callbacks.has_key(cs)):
# adding has clip callback to clip slot
cs.add_has_clip_listener(callback)
# saving callback for future release
self.slot_callbacks[cs] = callback
def add_clip_listener(self, clip):
# setting callback for clip color change
color_callback = lambda: self.update_display_clips()
# if we don't have a clip color change callback for this clip yet
if not (self.clip_color_callbacks.has_key(clip)):
# adding clip color change callback
clip.add_color_listener(color_callback)
# saving callback for future release
self.clip_color_callbacks[clip] = color_callback
def has_clip_listener(self, cs):
# clip slot has clip listener callback
if cs.has_clip:
# add clip listener
self.add_clip_listener(cs.clip)
else:
# update display if clip slot was removed
self.update_display_clips()
def session_offset_changed(self):
# if session component offset changes, update display
self.update_display_clips()
def selected_scene_changed(self):
# if on clip mode update display
if (self._operation_mode_selector.mode_index == OP1_MODE_CLIP):
self.update_display_clip_mode()
def mode_index_changed(self):
# update display to current mode info
if (self._operation_mode_selector.mode_index == OP1_MODE_PERFORM):
self.update_display_perform_mode()
elif (self._operation_mode_selector.mode_index == OP1_MODE_CLIP):
self.update_display_clip_mode()
elif (self._operation_mode_selector.mode_index == OP1_MODE_TRANSPORT):
self.update_display_transport_mode()
elif (self._operation_mode_selector.mode_index == OP1_MODE_MIXER):
self.update_display_mixer_mode()
def clear_track_button_callback(self, value):
# if clear track button was called, reset track
if (value == 127):
for i in range(len(self.song().tracks)):
self.song().tracks[i].arm = 0
self.song().tracks[i].solo = 0
self.song().tracks[i].mute = 0
for i in range(len(self.song().return_tracks)):
self.song().tracks[i].solo = 0
self.song().tracks[i].mute = 0
def clear_return_track_assignment(self, strip):
# clear return track assingments
strip.set_volume_control(None)
strip.set_pan_control(None)
strip.set_mute_button(None)
strip.set_solo_button(None)
def clear_track_assignment(self, strip):
# clear track assignments
strip.set_volume_control(None)
strip.set_pan_control(None)
strip.set_mute_button(None)
strip.set_solo_button(None)
strip.set_arm_button(None)
def clear_tracks_assigments(self):
# for all normal tracks, clear assignments
for i in range(NUM_TRACKS):
strip = self._mixer.channel_strip(i)
if (strip != None):
self.clear_track_assignment(strip)
# for all return tracks, clear assignments
for i in range(2):
return_strip = self._mixer.return_strip(i)
if (return_strip != None):
self.clear_return_track_assignment(return_strip)
def selected_track_changed(self):
# if on mixer mode update display
if (self._operation_mode_selector.mode_index == OP1_MODE_MIXER):
self.update_display_mixer_mode()
# clear track assignments
self.clear_tracks_assigments()
# getting selected strip
self._channel_strip = self._mixer.selected_strip()
# perform track assignments
self._channel_strip.set_volume_control(
EncoderElement(MIDI_CC_TYPE, CHANNEL, OP1_ENCODER_1,
Live.MidiMap.MapMode.relative_two_compliment))
self._channel_strip.set_pan_control(
EncoderElement(MIDI_CC_TYPE, CHANNEL, OP1_ENCODER_2,
Live.MidiMap.MapMode.relative_two_compliment))
# setting a tuple of encoders to control sends
send_controls = EncoderElement(
MIDI_CC_TYPE, CHANNEL, OP1_ENCODER_3,
Live.MidiMap.MapMode.relative_two_compliment), EncoderElement(
MIDI_CC_TYPE, CHANNEL, OP1_ENCODER_4,
Live.MidiMap.MapMode.relative_two_compliment),
# setting send encoders
self._channel_strip.set_send_controls(tuple(send_controls))
# setting solo button
self._channel_strip.set_solo_button(
ButtonElement(True, MIDI_CC_TYPE, CHANNEL, OP1_SS6_BUTTON))
# if track can be armed, set arm button
if (self._channel_strip._track.can_be_armed):
self._channel_strip.set_arm_button(
ButtonElement(True, MIDI_CC_TYPE, CHANNEL, OP1_SS7_BUTTON))
# if track is no master, set mute button
if (self._channel_strip._track != self.song().master_track):
self._channel_strip.set_mute_button(
ButtonElement(True, MIDI_CC_TYPE, CHANNEL, OP1_SS5_BUTTON))
def browser_toggle_button_callback(self, value):
if (value == 127):
if (self.session_visible):
if (self.session_browser_visible == True):
self.session_browser_visible = False
self.app.view.hide_view("Browser")
else:
self.session_browser_visible = True
self.app.view.show_view("Browser")
if (self.arrange_visible):
if (self.arrange_browser_visible == True):
self.arrange_browser_visible = False
self.app.view.hide_view("Browser")
else:
self.arrange_browser_visible = True
self.app.view.show_view("Browser")
def back_to_arranger_button_callback(self, value):
if (value == 127):
self.song().back_to_arranger = False
def mainview_toggle_button_callback(self, value):
if (value == 127):
if (self.session_visible == True):
self.session_visible = False
self.arrange_visible = True
self.app.view.show_view("Arranger")
self.arrange_browser_visible = self.app.view.is_view_visible(
"Browser")
else:
self.session_visible = True
self.arrange_visible = False
self.app.view.show_view("Session")
self.session_browser_visible = self.app.view.is_view_visible(
"Browser")
def detailview_toggle_button_callback(self, value):
if (value == 127):
if (self.detail_visible == True):
self.detail_visible = False
self.app.view.hide_view("Detail")
else:
self.detail_visible = True
self.app.view.show_view("Detail")
def write_text(self, msg):
text_list = []
sequence = ()
text_list.append(len(msg.strip()))
for i in msg.strip():
text_list.append(ord(i))
sequence = self.text_start_sequence + tuple(
text_list) + self.text_end_sequence
self._send_midi(sequence)
def suggest_input_port(self):
return "OP-1 Midi Device"
def suggest_output_port(self):
return "OP-1 Midi Device"
def update_display_perform_mode(self):
self.write_text("perform\rmode")
def reset_display_clips(self):
count = 0
colors = []
length = []
sequence = ()
for i in range(NUM_TRACKS):
count += 1
colors.append(0x00)
colors.append(0x00)
colors.append(0x00)
length.append(count)
sequence = self.text_color_start_sequence + tuple(length) + tuple(
colors) + self.text_end_sequence
self._send_midi(sequence)
def update_display_clips(self):
#self.log("UPDATING DISPLAY CLIPS")
count = 0
colors = []
length = []
sequence = ()
tracks_len = len(self.song().tracks) - self._session._track_offset
if (tracks_len > NUM_TRACKS):
tracks_len = NUM_TRACKS
for i in range(tracks_len):
count += 1
clip_slot = self._session.scene(0).clip_slot(i)
if (clip_slot != None):
if (clip_slot.has_clip() != False):
clip_color = clip_slot._clip_slot.clip.color
colors.append(((clip_color >> 16) & 0x000000ff) >> 1)
colors.append(((clip_color >> 8) & 0x000000ff) >> 1)
colors.append((clip_color & 0x000000ff) >> 1)
else:
colors.append(0x00)
colors.append(0x00)
colors.append(0x00)
else:
colors.append(0x00)
colors.append(0x00)
colors.append(0x00)
length.append(count)
sequence = self.text_color_start_sequence + tuple(length) + tuple(
colors) + self.text_end_sequence
self._send_midi(sequence)
def update_display_clip_mode(self):
self.write_text(
"sel. scene\r" +
str(self.song().view.selected_scene.name.lower().strip()))
def update_display_transport_mode(self):
song_time = str(self.song().get_current_beats_song_time())
self.write_text("song pos.\r" + song_time[:len(song_time) - 4])
def update_display_mixer_mode(self):
self.write_text("sel. track\r" +
str(self.song().view.selected_track.name.lower()))
def update_display(self):
if not (self.device_connected):
if (self.retries_count < 5):
self.log("TRYING OP-1 CONNECTION")
self.retries_count += 1
self._send_midi(self.id_sequence)
time.sleep(1)
# if in transport mode, update display with song position
if (self._operation_mode_selector.mode_index == OP1_MODE_TRANSPORT):
self.update_display_transport_mode()
# checking if app current view is session
if (self.app.view.is_view_visible("Session")):
# checking if session browser state is diferent from the internal
if (self.session_browser_visible !=
self.app.view.is_view_visible("Browser")):
self.session_browser_visible = self.app.view.is_view_visible(
"Browser")
# checking if app current view is arrange
if (self.app.view.is_view_visible("Arranger")):
# checking if arrange browser state is diferent from the internal
if (self.arrange_browser_visible !=
self.app.view.is_view_visible("Browser")):
self.arrange_browser_visible = self.app.view.is_view_visible(
"Browser")
# checking if app current view is detail
if (self.app.view.is_view_visible("Detail")):
# checking if detail state is diferent from the internal
if (self.detail_visible !=
self.app.view.is_view_visible("Detail")):
self.detail_visible = self.app.view.is_view_visible("Detail")
def refresh_state(self):
self.log("REFRESH STATE")
self.retries_count = 0
self.device_connected = False
def build_midi_map(self, midi_map_handle):
#self.log("BUILD MIDI MAP")
assert (self._suppress_requests_counter == 0)
self._in_build_midi_map = True
self._midi_map_handle = midi_map_handle
self._forwarding_registry = {}
for control in self.controls:
if isinstance(control, InputControlElement):
control.install_connections()
self._midi_map_handle = None
self._in_build_midi_map = False
if (self._pad_translations != None):
self._c_instance.set_pad_translation(self._pad_translations)
# remove clip listeners
self.rem_clip_slot_listeners()
# add clip listeners
self.add_clip_slot_listeners()
# update display
self.update_display_clips()
def log(self, msg):
self.c_instance.log_message("[TE OP-1] " + msg)
def disconnect(self):
# removing clip slots listeners
self.rem_clip_slot_listeners()
# removing value listener for track changed
self.song().view.remove_selected_track_listener(
self.selected_track_changed)
# removing value listener for scene changed
self.song().view.remove_selected_scene_listener(
self.selected_scene_changed)
# removing value listener for operation mode index
self._operation_mode_selector.remove_mode_index_listener(
self.mode_index_changed)
# removing global transport assignments
self._transport.set_punch_buttons(None, None)
self._transport.set_loop_button(None)
self._transport.set_overdub_button(None)
self._transport.set_record_button(None)
self._transport.set_play_button(None)
self._transport.set_stop_button(None)
self._transport.set_metronome_button(None)
self._transport.set_tap_tempo_button(None)
# removing global session assignments
self._session.set_scene_bank_buttons(None, None)
# removing misc listeners
self.browser_toggle_button.remove_value_listener(
self.browser_toggle_button_callback)
self.mainview_toggle_button.remove_value_listener(
self.mainview_toggle_button_callback)
self.detailview_toggle_button.remove_value_listener(
self.detailview_toggle_button_callback)
self.clear_track_button.remove_value_listener(
self.clear_track_button_callback)
self.back_to_arranger_button.remove_value_listener(
self.back_to_arranger_button_callback)
# sending special ableton mode disable sequence
self._send_midi(self.disable_sequence)
# disconnecting control surface
ControlSurface.disconnect(self)
self.log("DISCONNECTED")
def _setup_components(self):
# Session
self._session = SessionComponent(8, len(self._scene_launch_buttons))
self._session.name = 'Session_Control'
self._session.selected_scene().name = 'Selected_Scene'
self._session.selected_scene().set_launch_button(
self._scene_launch_button)
self._session.set_stop_all_clips_button(self._scene_stop_button)
for index in range(8):
clip_slot = self._session.selected_scene().clip_slot(index)
clip_slot.set_launch_button(self._clip_launch_buttons[index])
clip_slot.name = 'Selected_Clip_Slot_' + str(index)
self._session.set_stop_track_clip_buttons(
tuple(self._clip_stop_buttons))
# Undo
self._do_undo.subject = self._clip_undo_button
# Transport
transport = TransportComponent()
transport.name = 'Transport'
transport.set_stop_button(self._stop_button)
transport.set_play_button(self._play_button)
transport.set_record_button(self._rec_button)
transport.set_loop_button(self._loop_button)
self._transport_view_modes = TransportViewModeSelector(
transport, self._session, self._ffwd_button, self._rwd_button)
self._transport_view_modes.name = 'Transport_View_Modes'
session_recording = SessionRecordingComponent(
ClipCreator(),
ViewControlComponent(),
name='Session_Recording',
is_enabled=False,
layer=Layer(record_button=self._overdub_button))
# Device
# device = DeviceComponent()
# device.name = 'Device_Component'
# self.set_device_component(device)
# device.set_parameter_controls(self._encoders)
# Navigation
self._session_navigation = SessionNavigationComponent(
name='Session_Navigation')
self._session_navigation.set_next_track_button(self._next_track_button)
self._session_navigation.set_prev_track_button(self._prev_track_button)
# Playing
# self._session.set_scene_launch_buttons(tuple(self._scene_launch_buttons))
for index in range(len(self._scene_launch_buttons)):
scene = self._session.scene(index)
scene.set_launch_button(self._scene_launch_buttons[index])
