def _setup_device(self):
self._encoders = []
for offset in range(8):
self._encoders.append(
PeekableEncoderElement(
MIDI_CC_TYPE, 15, 17 + offset,
Live.MidiMap.MapMode.relative_smooth_two_compliment))
self._encoders[-1].set_feedback_delay(-1)
self._encoders[-1].add_value_listener(self._encoder_value,
identify_sender=True)
self._encoders[-1].name = 'Device_Control_' + str(offset)
prev_bank_button = ButtonElement(IS_MOMENTARY, MIDI_CC_TYPE, 15, 14)
next_bank_button = ButtonElement(IS_MOMENTARY, MIDI_CC_TYPE, 15, 15)
prev_bank_button.name = 'Device_Bank_Down_Button'
next_bank_button.name = 'Device_Bank_Up_Button'
device = BestBankDeviceComponent()
device.name = 'Device_Component'
self.set_device_component(device)
device.set_parameter_controls(tuple(self._encoders))
device.set_bank_nav_buttons(prev_bank_button, next_bank_button)
self._device_bank_buttons = (prev_bank_button, next_bank_button)
prev_bank_button.add_value_listener(self._device_bank_value)
next_bank_button.add_value_listener(self._device_bank_value)
self._inst_button = ButtonElement(IS_MOMENTARY, MIDI_CC_TYPE, 15, 109)
self._inst_button.name = 'Inst_Button'
self._inst_button.add_value_listener(self._inst_value)
self._device_navigation = DetailViewCntrlComponent()
self._device_navigation.name = 'Device_Navigation_Component'
def _setup_device_and_transport_control(self):
is_momentary = True
device_bank_buttons = []
device_param_controls = []
bank_button_labels = ('Clip_Track_Button', 'Device_On_Off_Button', 'Previous_Device_Button', 'Next_Device_Button', 'Detail_View_Button', 'Rec_Quantization_Button', 'Midi_Overdub_Button', 'Metronome_Button')
for index in range(8):
device_bank_buttons.append(ButtonElement(is_momentary, MIDI_NOTE_TYPE, 0, 58 + index))
device_bank_buttons[-1].name = bank_button_labels[index]
ring_mode_button = ButtonElement(not is_momentary, MIDI_CC_TYPE, 0, 24 + index)
ringed_encoder = RingedEncoderElement(MIDI_CC_TYPE, 0, 16 + index, Live.MidiMap.MapMode.absolute)
ringed_encoder.set_ring_mode_button(ring_mode_button)
ringed_encoder.set_feedback_delay(-1)
ringed_encoder.name = 'Device_Control_' + str(index)
ring_mode_button.name = ringed_encoder.name + '_Ring_Mode_Button'
device_param_controls.append(ringed_encoder)
self._device = ShiftableDeviceComponent()
self._device.name = 'Device_Component'
self._device.set_bank_buttons(tuple(device_bank_buttons))
self._device.set_shift_button(self._shift_button)
self._device.set_parameter_controls(tuple(device_param_controls))
self._device.set_on_off_button(device_bank_buttons[1])
self.set_device_component(self._device)
detail_view_toggler = DetailViewCntrlComponent()
detail_view_toggler.name = 'Detail_View_Control'
detail_view_toggler.set_shift_button(self._shift_button)
detail_view_toggler.set_device_clip_toggle_button(device_bank_buttons[0])
detail_view_toggler.set_detail_toggle_button(device_bank_buttons[4])
detail_view_toggler.set_device_nav_buttons(device_bank_buttons[2], device_bank_buttons[3])
transport = ShiftableTransportComponent()
transport.name = 'Transport'
play_button = ButtonElement(is_momentary, MIDI_NOTE_TYPE, 0, 91)
stop_button = ButtonElement(is_momentary, MIDI_NOTE_TYPE, 0, 92)
record_button = ButtonElement(is_momentary, MIDI_NOTE_TYPE, 0, 93)
nudge_up_button = ButtonElement(is_momentary, MIDI_NOTE_TYPE, 0, 100)
nudge_down_button = ButtonElement(is_momentary, MIDI_NOTE_TYPE, 0, 101)
tap_tempo_button = ButtonElement(is_momentary, MIDI_NOTE_TYPE, 0, 99)
play_button.name = 'Play_Button'
stop_button.name = 'Stop_Button'
record_button.name = 'Record_Button'
nudge_up_button.name = 'Nudge_Up_button'
nudge_down_button.name = 'Nudge_Down_button'
tap_tempo_button.name = 'Tap_Tempo_Button'
transport.set_shift_button(self._shift_button)
transport.set_play_button(play_button)
transport.set_stop_button(stop_button)
transport.set_record_button(record_button)
transport.set_nudge_buttons(nudge_up_button, nudge_down_button)
transport.set_undo_button(nudge_down_button)
transport.set_redo_button(nudge_up_button)
transport.set_tap_tempo_button(tap_tempo_button)
self._device.set_lock_button(tap_tempo_button)
transport.set_quant_toggle_button(device_bank_buttons[5])
transport.set_overdub_button(device_bank_buttons[6])
transport.set_metronome_button(device_bank_buttons[7])
transport.set_tempo_encoder(self._prehear_control)
bank_button_translator = ShiftTranslatorComponent()
bank_button_translator.set_controls_to_translate(tuple(device_bank_buttons))
bank_button_translator.set_shift_button(self._shift_button)
def _setup_device(self):
self._encoders = []
for offset in range(8):
self._encoders.append(
PeekableEncoderElement(
MIDI_CC_TYPE, 15, 17 + offset, Live.MidiMap.MapMode.relative_smooth_two_compliment
)
)
self._encoders[-1].set_feedback_delay(-1)
self._encoders[-1].add_value_listener(self._encoder_value, identify_sender=True)
self._encoders[-1].name = "Device_Control_" + str(offset)
prev_bank_button = ButtonElement(IS_MOMENTARY, MIDI_CC_TYPE, 15, 14)
next_bank_button = ButtonElement(IS_MOMENTARY, MIDI_CC_TYPE, 15, 15)
prev_bank_button.name = "Device_Bank_Down_Button"
next_bank_button.name = "Device_Bank_Up_Button"
device = BestBankDeviceComponent()
device.name = "Device_Component"
self.set_device_component(device)
device.set_parameter_controls(tuple(self._encoders))
device.set_bank_nav_buttons(prev_bank_button, next_bank_button)
self._device_bank_buttons = (prev_bank_button, next_bank_button)
prev_bank_button.add_value_listener(self._device_bank_value)
next_bank_button.add_value_listener(self._device_bank_value)
self._inst_button = ButtonElement(IS_MOMENTARY, MIDI_CC_TYPE, 15, 109)
self._inst_button.name = "Inst_Button"
self._inst_button.add_value_listener(self._inst_value)
self._device_navigation = DetailViewCntrlComponent()
self._device_navigation.name = "Device_Navigation_Component"
def _setup_device_and_transport_control(self):
is_momentary = True
device_bank_buttons = []
device_param_controls = []
bank_button_labels = ('Clip_Track_Button', 'Device_On_Off_Button',
'Previous_Device_Button', 'Next_Device_Button',
'Detail_View_Button', 'Rec_Quantization_Button',
'Midi_Overdub_Button', 'Metronome_Button')
for index in range(8):
device_bank_buttons.append(
ButtonElement(is_momentary, MIDI_NOTE_TYPE, 0, 58 + index))
device_bank_buttons[-1].name = bank_button_labels[index]
ring_mode_button = ButtonElement(not is_momentary, MIDI_CC_TYPE, 0,
24 + index)
ringed_encoder = RingedEncoderElement(
MIDI_CC_TYPE, 0, 16 + index, Live.MidiMap.MapMode.absolute)
ringed_encoder.set_ring_mode_button(ring_mode_button)
ringed_encoder.name = 'Device_Control_' + str(index)
ring_mode_button.name = ringed_encoder.name + '_Ring_Mode_Button'
device_param_controls.append(ringed_encoder)
device = ShiftableDeviceComponent()
device.name = 'Device_Component'
device.set_bank_buttons(tuple(device_bank_buttons))
device.set_shift_button(self._shift_button)
device.set_parameter_controls(tuple(device_param_controls))
device.set_on_off_button(device_bank_buttons[1])
self.set_device_component(device)
detail_view_toggler = DetailViewCntrlComponent()
detail_view_toggler.name = 'Detail_View_Control'
detail_view_toggler.set_shift_button(self._shift_button)
detail_view_toggler.set_device_clip_toggle_button(
device_bank_buttons[0])
detail_view_toggler.set_detail_toggle_button(device_bank_buttons[4])
detail_view_toggler.set_device_nav_buttons(device_bank_buttons[2],
device_bank_buttons[3])
transport = ShiftableTransportComponent()
transport.name = 'Transport'
play_button = ButtonElement(is_momentary, MIDI_NOTE_TYPE, 0, 91)
stop_button = ButtonElement(is_momentary, MIDI_NOTE_TYPE, 0, 92)
record_button = ButtonElement(is_momentary, MIDI_NOTE_TYPE, 0, 93)
nudge_up_button = ButtonElement(is_momentary, MIDI_NOTE_TYPE, 0, 100)
nudge_down_button = ButtonElement(is_momentary, MIDI_NOTE_TYPE, 0, 101)
tap_tempo_button = ButtonElement(is_momentary, MIDI_NOTE_TYPE, 0, 99)
play_button.name = 'Play_Button'
stop_button.name = 'Stop_Button'
record_button.name = 'Record_Button'
nudge_up_button.name = 'Nudge_Up_Button'
nudge_down_button.name = 'Nudge_Down_Button'
tap_tempo_button.name = 'Tap_Tempo_Button'
transport.set_shift_button(self._shift_button)
transport.set_play_button(play_button)
transport.set_stop_button(stop_button)
transport.set_record_button(record_button)
transport.set_nudge_buttons(nudge_up_button, nudge_down_button)
transport.set_tap_tempo_button(tap_tempo_button)
transport.set_quant_toggle_button(device_bank_buttons[5])
transport.set_overdub_button(device_bank_buttons[6])
transport.set_metronome_button(device_bank_buttons[7])
bank_button_translator = ShiftTranslatorComponent()
bank_button_translator.set_controls_to_translate(
tuple(device_bank_buttons))
bank_button_translator.set_shift_button(self._shift_button)
class Axiom_DirectLink(ControlSurface):
""" Script for the M-Audio Axiom DirectLink """
def __init__(self, c_instance):
ControlSurface.__init__(self, c_instance)
with self.component_guard():
self.set_pad_translations(PAD_TRANSLATIONS)
self._device_selection_follows_track_selection = True
self._suggested_input_port = "DirectLink"
self._suggested_output_port = "DirectLink"
self._waiting_for_first_response = True
self._has_sliders = True
self._current_midi_map = None
self._display_reset_delay = -1
self._shift_pressed = False
self._shift_button = ButtonElement(IS_MOMENTARY, MIDI_CC_TYPE, 15, 13)
self._master_slider = SliderElement(MIDI_CC_TYPE, 15, 41)
self._next_nav_button = ButtonElement(IS_MOMENTARY, MIDI_CC_TYPE, 15, 111)
self._prev_nav_button = ButtonElement(IS_MOMENTARY, MIDI_CC_TYPE, 15, 110)
self._device_bank_buttons = None
self._device_navigation = None
self._shift_button.name = "Shift_Button"
self._master_slider.name = "Master_Volume_Control"
self._next_nav_button.name = "Next_Track_Button"
self._prev_nav_button.name = "Prev_Track_Button"
self._master_slider.add_value_listener(self._slider_value, identify_sender=True)
self._shift_button.add_value_listener(self._shift_value)
self._setup_mixer()
self._setup_transport_and_session()
self._setup_device()
self._setup_display()
for component in self.components:
component.set_enabled(False)
return
def refresh_state(self):
ControlSurface.refresh_state(self)
self._waiting_for_first_response = True
self.schedule_message(3, self._send_midi, SYSEX_START + (32, 46, 247))
def handle_sysex(self, midi_bytes):
if midi_bytes[0:-2] == SYSEX_START + (32,) and midi_bytes[-2] != 0:
self._has_sliders = midi_bytes[-2] & 8 != 0
if self._waiting_for_first_response:
self._waiting_for_first_response = False
self.schedule_message(1, self._show_startup_message)
for component in self.components:
component.set_enabled(True)
if self._has_sliders:
self._mixer.master_strip().set_volume_control(self._master_slider)
self._mixer.update()
else:
self._mixer.master_strip().set_volume_control(None)
self._mixer.selected_strip().set_volume_control(self._master_slider)
self.request_rebuild_midi_map()
return
def disconnect(self):
self._display_data_source.set_display_string(" ")
self._shift_button.remove_value_listener(self._shift_value)
self._inst_button.remove_value_listener(self._inst_value)
for encoder in self._encoders:
encoder.remove_value_listener(self._encoder_value)
for slider in tuple(self._sliders) + (self._master_slider,):
slider.remove_value_listener(self._slider_value)
for button in tuple(self._strip_buttons) + (self._selected_mute_solo_button,):
button.remove_value_listener(self._mixer_button_value)
for button in self._device_bank_buttons:
button.remove_value_listener(self._device_bank_value)
self._encoders = None
self._sliders = None
self._strip_buttons = None
self._master_slider = None
self._current_midi_map = None
self._selected_mute_solo_button = None
self._inst_button = None
self._shift_button = None
self._device_navigation = None
self._display = None
ControlSurface.disconnect(self)
self._send_midi(SYSEX_START + (32, 0, 247))
return
def build_midi_map(self, midi_map_handle):
self._current_midi_map = midi_map_handle
ControlSurface.build_midi_map(self, midi_map_handle)
def update_display(self):
ControlSurface.update_display(self)
if self._display_reset_delay >= 0:
self._display_reset_delay -= 1
if self._display_reset_delay == -1:
self._show_current_track_name()
def _setup_mixer(self):
self._selected_mute_solo_button = ButtonElement(IS_MOMENTARY, MIDI_CC_TYPE, 15, 12)
mute_solo_flip_button = ButtonElement(IS_MOMENTARY, MIDI_CC_TYPE, 15, 57)
self._strip_buttons = []
self._selected_mute_solo_button.name = "Selected_Mute_Button"
mute_solo_flip_button.name = "Mute_Solo_Flip_Button"
self._selected_mute_solo_button.add_value_listener(self._mixer_button_value, identify_sender=True)
self._mixer = ShiftableMixerComponent(8)
self._mixer.name = "Mixer"
self._mixer.set_shift_button(self._shift_button)
self._mixer.set_selected_mute_solo_button(self._selected_mute_solo_button)
self._mixer.set_select_buttons(self._next_nav_button, self._prev_nav_button)
self._mixer.selected_strip().name = "Selected_Channel_Strip"
self._mixer.master_strip().name = "Master_Channel_Strip"
self._mixer.master_strip().set_volume_control(self._master_slider)
self._sliders = []
for index in range(8):
strip = self._mixer.channel_strip(index)
strip.name = "Channel_Strip_" + str(index)
strip.set_invert_mute_feedback(True)
self._sliders.append(SliderElement(MIDI_CC_TYPE, 15, 33 + index))
self._sliders[-1].name = str(index) + "_Volume_Control"
self._sliders[-1].set_feedback_delay(-1)
self._sliders[-1].add_value_listener(self._slider_value, identify_sender=True)
strip.set_volume_control(self._sliders[-1])
self._strip_buttons.append(ButtonElement(IS_MOMENTARY, MIDI_CC_TYPE, 15, 49 + index))
self._strip_buttons[-1].name = str(index) + "_Mute_Button"
self._strip_buttons[-1].add_value_listener(self._mixer_button_value, identify_sender=True)
self._mixer.set_strip_mute_solo_buttons(tuple(self._strip_buttons), mute_solo_flip_button)
def _setup_transport_and_session(self):
ffwd_button = ButtonElement(IS_MOMENTARY, MIDI_CC_TYPE, 15, 115)
rwd_button = ButtonElement(IS_MOMENTARY, MIDI_CC_TYPE, 15, 114)
loop_button = ButtonElement(IS_MOMENTARY, MIDI_CC_TYPE, 15, 113)
play_button = ButtonElement(IS_MOMENTARY, MIDI_CC_TYPE, 15, 117)
stop_button = ButtonElement(IS_MOMENTARY, MIDI_CC_TYPE, 15, 116)
rec_button = ButtonElement(IS_MOMENTARY, MIDI_CC_TYPE, 15, 118)
ffwd_button.name = "FFwd_Button"
rwd_button.name = "Rwd_Button"
loop_button.name = "Loop_Button"
play_button.name = "Play_Button"
stop_button.name = "Stop_Button"
rec_button.name = "Record_Button"
transport = ShiftableTransportComponent()
transport.name = "Transport"
transport.set_shift_button(self._shift_button)
transport.set_stop_button(stop_button)
transport.set_play_button(play_button)
transport.set_record_button(rec_button)
pads = []
for index in range(len(PAD_TRANSLATIONS)):
pads.append(ButtonElement(IS_MOMENTARY, MIDI_NOTE_TYPE, 15, PAD_TRANSLATIONS[index][2]))
pads[-1].name = "Pad_" + str(index)
self._session = ShiftableSessionComponent(8, 0)
self._session.name = "Session_Control"
self._session.selected_scene().name = "Selected_Scene"
self._session.set_mixer(self._mixer)
self._session.set_shift_button(self._shift_button)
self._session.set_clip_slot_buttons(tuple(pads))
transport_view_modes = TransportViewModeSelector(transport, self._session, ffwd_button, rwd_button, loop_button)
transport_view_modes.name = "Transport_View_Modes"
def _setup_device(self):
self._encoders = []
for offset in range(8):
self._encoders.append(
PeekableEncoderElement(
MIDI_CC_TYPE, 15, 17 + offset, Live.MidiMap.MapMode.relative_smooth_two_compliment
)
)
self._encoders[-1].set_feedback_delay(-1)
self._encoders[-1].add_value_listener(self._encoder_value, identify_sender=True)
self._encoders[-1].name = "Device_Control_" + str(offset)
prev_bank_button = ButtonElement(IS_MOMENTARY, MIDI_CC_TYPE, 15, 14)
next_bank_button = ButtonElement(IS_MOMENTARY, MIDI_CC_TYPE, 15, 15)
prev_bank_button.name = "Device_Bank_Down_Button"
next_bank_button.name = "Device_Bank_Up_Button"
device = BestBankDeviceComponent()
device.name = "Device_Component"
self.set_device_component(device)
device.set_parameter_controls(tuple(self._encoders))
device.set_bank_nav_buttons(prev_bank_button, next_bank_button)
self._device_bank_buttons = (prev_bank_button, next_bank_button)
prev_bank_button.add_value_listener(self._device_bank_value)
next_bank_button.add_value_listener(self._device_bank_value)
self._inst_button = ButtonElement(IS_MOMENTARY, MIDI_CC_TYPE, 15, 109)
self._inst_button.name = "Inst_Button"
self._inst_button.add_value_listener(self._inst_value)
self._device_navigation = DetailViewCntrlComponent()
self._device_navigation.name = "Device_Navigation_Component"
def _setup_display(self):
self._display = PhysicalDisplayElement(5, 1)
self._display.name = "Display"
self._display.set_message_parts(SYSEX_START + (17, 1, 0, 0), (247,))
self._display_data_source = DisplayDataSource()
self._display.segment(0).set_data_source(self._display_data_source)
def _on_selected_track_changed(self):
ControlSurface._on_selected_track_changed(self)
self._show_current_track_name()
def _shift_value(self, value):
if not value in range(128):
raise AssertionError
self._shift_pressed = value > 0
for encoder in self._encoders:
encoder.set_peek_mode(self._shift_pressed)
self._shift_pressed and self._mixer.set_select_buttons(None, None)
self._session.set_track_bank_buttons(self._next_nav_button, self._prev_nav_button)
self._device_component.set_bank_nav_buttons(None, None)
self._device_navigation.set_device_nav_buttons(self._device_bank_buttons[0], self._device_bank_buttons[1])
else:
self._session.set_track_bank_buttons(None, None)
self._mixer.set_select_buttons(self._next_nav_button, self._prev_nav_button)
self._device_navigation.set_device_nav_buttons(None, None)
self._device_component.set_bank_nav_buttons(self._device_bank_buttons[0], self._device_bank_buttons[1])
self.request_rebuild_midi_map()
return
def _encoder_value(self, value, sender):
if not sender in self._encoders:
raise AssertionError
if not value in range(128):
raise AssertionError
display_string = self._device_component.is_enabled() and " - "
display_string = sender.mapped_parameter() != None and sender.mapped_parameter().name
self._display_data_source.set_display_string(display_string)
self._set_display_data_source(self._display_data_source)
self._display_reset_delay = STANDARD_DISPLAY_DELAY
return
def _slider_value(self, value, sender):
if not sender in tuple(self._sliders) + (self._master_slider,):
raise AssertionError
if not value in range(128):
raise AssertionError
if self._mixer.is_enabled():
display_string = " - "
if sender.mapped_parameter() != None:
master = self.song().master_track
tracks = self.song().tracks
returns = self.song().return_tracks
track = None
if sender == self._master_slider:
track = self._has_sliders and master
else:
track = self.song().view.selected_track
else:
track = self._mixer.channel_strip(self._sliders.index(sender))._track
display_string = track == master and "Ma"
elif track in tracks:
display_string = str(list(tracks).index(track) + 1)
elif track in returns:
display_string = str(chr(ord("A") + list(returns).index(track)))
else:
raise False or AssertionError
display_string += " Vol"
self._display_data_source.set_display_string(display_string)
self._set_display_data_source(self._display_data_source)
self._display_reset_delay = STANDARD_DISPLAY_DELAY
return
def _mixer_button_value(self, value, sender):
if not sender in tuple(self._strip_buttons) + (self._selected_mute_solo_button,):
raise AssertionError
if not value in range(128):
raise AssertionError
if self._mixer.is_enabled() and value > 0:
strip = None
strip = sender == self._selected_mute_solo_button and self._mixer.selected_strip()
else:
strip = self._mixer.channel_strip(self._strip_buttons.index(sender))
strip != None and self._set_display_data_source(strip.track_name_data_source())
else:
self._display_data_source.set_display_string(" - ")
self._set_display_data_source(self._display_data_source)
self._display_reset_delay = STANDARD_DISPLAY_DELAY
return
def _device_bank_value(self, value):
if not value in range(128):
raise AssertionError
if self._device_component.is_enabled() and value > 0:
data_source = self._device_component.bank_name_data_source()
data_source = self._shift_pressed and self._device_component.device_name_data_source()
self._set_display_data_source(data_source)
self._display_reset_delay = STANDARD_DISPLAY_DELAY
def _inst_value(self, value):
if not value in range(128):
raise AssertionError
value > 0 and self._device_component.is_enabled() and self.song().view.selected_track.view.select_instrument() and self._set_display_data_source(
self._device_component.device_name_data_source()
)
self._display_reset_delay = STANDARD_DISPLAY_DELAY
def _show_current_track_name(self):
if self._display != None and self._mixer != None:
self._set_display_data_source(self._mixer.selected_strip().track_name_data_source())
return
def _show_startup_message(self):
self._display.display_message("LIVE")
self._display_reset_delay = INITIAL_DISPLAY_DELAY
def _set_display_data_source(self, data_source):
raise isinstance(data_source, DisplayDataSource) or AssertionError
self._display.segment(0).set_data_source(data_source)
data_source.update()
def _setup_transport_control(self):
is_momentary = True # We'll only be using momentary buttons here
transport = ShiftableTransportComponent() #Instantiate a Transport Component
#addtransport = AddlTransportComponent() #Instantiate an AddlTransport Component
device_param_controls = []
#effects_knob_cc = [16,20,24,28,17,21,25,29]
effects_knob_cc = [17,21,25,29,18,22,26,30]
device = DeviceComponent()
for index in range(8):
device_param_controls.append(EncoderElement(MIDI_CC_TYPE, CHAN, effects_knob_cc[index], Live.MidiMap.MapMode.absolute))
device.set_parameter_controls(tuple(device_param_controls))
#self.set_device_component(device)
#from apc
device_bank_buttons = []
#device_param_controls = []
#device_buttons =[16,20,24,28,17,21,25,29];
device_buttons =[17,21,25,29,18,22,26,30];
bank_button_labels = ('Clip_Track_Button', 'Device_On_Off_Button', 'Previous_Device_Button', 'Next_Device_Button', 'Detail_View_Button', 'Rec_Quantization_Button', 'Midi_Overdub_Button', 'Device_Lock_Button') #'Metronome_Button')
for index in range(8):
device_bank_buttons.append(ButtonElement(is_momentary, MIDI_NOTE_TYPE, CHAN, device_buttons[index]))
device_bank_buttons[-1].name = bank_button_labels[index]
#ring_mode_button = ButtonElement(not is_momentary, MIDI_CC_TYPE, 0, 24 + index)
#ringed_encoder = RingedEncoderElement(MIDI_CC_TYPE, 0, 16 + index, Live.MidiMap.MapMode.absolute)
#ringed_encoder.set_ring_mode_button(ring_mode_button)
#ringed_encoder.name = 'Device_Control_' + str(index)
#ring_mode_button.name = ringed_encoder.name + '_Ring_Mode_Button'
#device_param_controls.append(ringed_encoder)
device.name = 'Device_Component'
device.set_bank_buttons(tuple(device_bank_buttons))
detail_view_toggler = DetailViewCntrlComponent()
detail_view_toggler.name = 'Detail_View_Control'
detail_view_toggler.set_device_clip_toggle_button(device_bank_buttons[0])
device.set_on_off_button(device_bank_buttons[1])
detail_view_toggler.set_device_nav_buttons(device_bank_buttons[2], device_bank_buttons[3])
detail_view_toggler.set_detail_toggle_button(device_bank_buttons[4])
device.set_lock_button(device_bank_buttons[7]) #assign device lock to bank_button 8 (in place of metronome)...
self.set_device_component(device)
#detail_view_toggler.set_shift_button(self._shift_button)
#from apc
self._shift_button = ButtonElement(is_momentary, MIDI_NOTE_TYPE, 0, 37)
"""set up the buttons"""
play_button = ButtonElement(is_momentary, MIDI_NOTE_TYPE, CHAN, 24) #ButtonElement(is_momentary, msg_type, channel, identifier) Note that the MIDI_NOTE_TYPE constant is defined in the InputControlElement module
stop_button = ButtonElement(is_momentary, MIDI_NOTE_TYPE, CHAN, 28)
record_button = ButtonElement(is_momentary, MIDI_NOTE_TYPE, CHAN, 32)
nudge_up_button = ButtonElement(is_momentary, MIDI_NOTE_TYPE, CHAN, 27)
nudge_down_button = ButtonElement(is_momentary, MIDI_NOTE_TYPE, CHAN, 23)
# tap_tempo_button = ButtonElement(is_momentary, MIDI_NOTE_TYPE, CHAN, 19)
redo_button = ButtonElement(is_momentary, MIDI_NOTE_TYPE, CHAN, 19)
undo_button = ButtonElement(is_momentary, MIDI_NOTE_TYPE, CHAN, 20)
play_button.name = 'Play_Button'
stop_button.name = 'Stop_Button'
record_button.name = 'Record_Button'
nudge_up_button.name = 'Nudge_Up_Button'
nudge_down_button.name = 'Nudge_Down_Button'
# tap_tempo_button.name = 'Tap_Tempo_Button'
redo_button.name = 'Redo_Button'
undo_button.name = 'Undo_Button'
transport.set_shift_button(self._shift_button)
transport.set_play_button(play_button)
transport.set_stop_button(stop_button)
transport.set_record_button(record_button)
transport.set_nudge_buttons(nudge_up_button, nudge_down_button)
#addtransport.set_undo_button(undo_button)
#addtransport.set_redo_button(redo_button)
transport.set_tap_tempo_button(nudge_up_button) #shifted nudge
transport.set_quant_toggle_button(device_bank_buttons[5])
transport.set_overdub_button(device_bank_buttons[6])
# transport.set_metronome_button(device_bank_buttons[7])
#transport.set_tempo_encoder(self.prehear_control) #shifted prehear
bank_button_translator = ShiftableTranslatorComponent()
bank_button_translator.set_controls_to_translate(tuple(device_bank_buttons))
bank_button_translator.set_shift_button(self._shift_button)
class Axiom_DirectLink(ControlSurface):
""" Script for the M-Audio Axiom DirectLink """
def __init__(self, c_instance):
ControlSurface.__init__(self, c_instance)
with self.component_guard():
self.set_pad_translations(PAD_TRANSLATIONS)
self._device_selection_follows_track_selection = True
self._suggested_input_port = 'DirectLink'
self._suggested_output_port = 'DirectLink'
self._waiting_for_first_response = True
self._has_sliders = True
self._current_midi_map = None
self._display_reset_delay = -1
self._shift_pressed = False
self._shift_button = ButtonElement(IS_MOMENTARY, MIDI_CC_TYPE, 15,
13)
self._master_slider = SliderElement(MIDI_CC_TYPE, 15, 41)
self._next_nav_button = ButtonElement(IS_MOMENTARY, MIDI_CC_TYPE,
15, 111)
self._prev_nav_button = ButtonElement(IS_MOMENTARY, MIDI_CC_TYPE,
15, 110)
self._device_bank_buttons = None
self._device_navigation = None
self._shift_button.name = 'Shift_Button'
self._master_slider.name = 'Master_Volume_Control'
self._next_nav_button.name = 'Next_Track_Button'
self._prev_nav_button.name = 'Prev_Track_Button'
self._master_slider.add_value_listener(self._slider_value,
identify_sender=True)
self._shift_button.add_value_listener(self._shift_value)
self._setup_mixer()
self._setup_transport_and_session()
self._setup_device()
self._setup_display()
for component in self.components:
component.set_enabled(False)
def refresh_state(self):
ControlSurface.refresh_state(self)
self._waiting_for_first_response = True
self.schedule_message(3, self._send_midi, SYSEX_START + (32, 46, 247))
def handle_sysex(self, midi_bytes):
if midi_bytes[0:-2] == SYSEX_START + (32, ) and midi_bytes[-2] != 0:
self._has_sliders = midi_bytes[-2] & 8 != 0
if self._waiting_for_first_response:
self._waiting_for_first_response = False
self.schedule_message(1, self._show_startup_message)
for component in self.components:
component.set_enabled(True)
if self._has_sliders:
self._mixer.master_strip().set_volume_control(
self._master_slider)
self._mixer.update()
else:
self._mixer.master_strip().set_volume_control(None)
self._mixer.selected_strip().set_volume_control(
self._master_slider)
self.request_rebuild_midi_map()
def disconnect(self):
self._display_data_source.set_display_string(' ')
self._shift_button.remove_value_listener(self._shift_value)
self._inst_button.remove_value_listener(self._inst_value)
for encoder in self._encoders:
encoder.remove_value_listener(self._encoder_value)
for slider in tuple(self._sliders) + (self._master_slider, ):
slider.remove_value_listener(self._slider_value)
for button in tuple(
self._strip_buttons) + (self._selected_mute_solo_button, ):
button.remove_value_listener(self._mixer_button_value)
for button in self._device_bank_buttons:
button.remove_value_listener(self._device_bank_value)
self._encoders = None
self._sliders = None
self._strip_buttons = None
self._master_slider = None
self._current_midi_map = None
self._selected_mute_solo_button = None
self._inst_button = None
self._shift_button = None
self._device_navigation = None
self._display = None
ControlSurface.disconnect(self)
self._send_midi(SYSEX_START + (32, 0, 247))
def build_midi_map(self, midi_map_handle):
self._current_midi_map = midi_map_handle
ControlSurface.build_midi_map(self, midi_map_handle)
def update_display(self):
ControlSurface.update_display(self)
if self._display_reset_delay >= 0:
self._display_reset_delay -= 1
if self._display_reset_delay == -1:
self._show_current_track_name()
def _setup_mixer(self):
self._selected_mute_solo_button = ButtonElement(
IS_MOMENTARY, MIDI_CC_TYPE, 15, 12)
mute_solo_flip_button = ButtonElement(IS_MOMENTARY, MIDI_CC_TYPE, 15,
57)
self._strip_buttons = []
self._selected_mute_solo_button.name = 'Selected_Mute_Button'
mute_solo_flip_button.name = 'Mute_Solo_Flip_Button'
self._selected_mute_solo_button.add_value_listener(
self._mixer_button_value, identify_sender=True)
self._mixer = ShiftableMixerComponent(8)
self._mixer.name = 'Mixer'
self._mixer.set_shift_button(self._shift_button)
self._mixer.set_selected_mute_solo_button(
self._selected_mute_solo_button)
self._mixer.set_select_buttons(self._next_nav_button,
self._prev_nav_button)
self._mixer.selected_strip().name = 'Selected_Channel_Strip'
self._mixer.master_strip().name = 'Master_Channel_Strip'
self._mixer.master_strip().set_volume_control(self._master_slider)
self._sliders = []
for index in range(8):
strip = self._mixer.channel_strip(index)
strip.name = 'Channel_Strip_' + str(index)
strip.set_invert_mute_feedback(True)
self._sliders.append(SliderElement(MIDI_CC_TYPE, 15, 33 + index))
self._sliders[-1].name = str(index) + '_Volume_Control'
self._sliders[-1].set_feedback_delay(-1)
self._sliders[-1].add_value_listener(self._slider_value,
identify_sender=True)
strip.set_volume_control(self._sliders[-1])
self._strip_buttons.append(
ButtonElement(IS_MOMENTARY, MIDI_CC_TYPE, 15, 49 + index))
self._strip_buttons[-1].name = str(index) + '_Mute_Button'
self._strip_buttons[-1].add_value_listener(
self._mixer_button_value, identify_sender=True)
self._mixer.set_strip_mute_solo_buttons(tuple(self._strip_buttons),
mute_solo_flip_button)
def _setup_transport_and_session(self):
ffwd_button = ButtonElement(IS_MOMENTARY, MIDI_CC_TYPE, 15, 115)
rwd_button = ButtonElement(IS_MOMENTARY, MIDI_CC_TYPE, 15, 114)
loop_button = ButtonElement(IS_MOMENTARY, MIDI_CC_TYPE, 15, 113)
play_button = ButtonElement(IS_MOMENTARY, MIDI_CC_TYPE, 15, 117)
stop_button = ButtonElement(IS_MOMENTARY, MIDI_CC_TYPE, 15, 116)
rec_button = ButtonElement(IS_MOMENTARY, MIDI_CC_TYPE, 15, 118)
ffwd_button.name = 'FFwd_Button'
rwd_button.name = 'Rwd_Button'
loop_button.name = 'Loop_Button'
play_button.name = 'Play_Button'
stop_button.name = 'Stop_Button'
rec_button.name = 'Record_Button'
transport = ShiftableTransportComponent()
transport.name = 'Transport'
transport.set_shift_button(self._shift_button)
transport.set_stop_button(stop_button)
transport.set_play_button(play_button)
transport.set_record_button(rec_button)
pads = []
for index in range(len(PAD_TRANSLATIONS)):
pads.append(
ButtonElement(IS_MOMENTARY, MIDI_NOTE_TYPE, 15,
PAD_TRANSLATIONS[index][2]))
pads[-1].name = 'Pad_' + str(index)
self._session = ShiftableSessionComponent(8, 0)
self._session.name = 'Session_Control'
self._session.selected_scene().name = 'Selected_Scene'
self._session.set_mixer(self._mixer)
self._session.set_shift_button(self._shift_button)
self._session.set_clip_slot_buttons(tuple(pads))
transport_view_modes = TransportViewModeSelector(
transport, self._session, ffwd_button, rwd_button, loop_button)
transport_view_modes.name = 'Transport_View_Modes'
def _setup_device(self):
self._encoders = []
for offset in range(8):
self._encoders.append(
PeekableEncoderElement(
MIDI_CC_TYPE, 15, 17 + offset,
Live.MidiMap.MapMode.relative_smooth_two_compliment))
self._encoders[-1].set_feedback_delay(-1)
self._encoders[-1].add_value_listener(self._encoder_value,
identify_sender=True)
self._encoders[-1].name = 'Device_Control_' + str(offset)
prev_bank_button = ButtonElement(IS_MOMENTARY, MIDI_CC_TYPE, 15, 14)
next_bank_button = ButtonElement(IS_MOMENTARY, MIDI_CC_TYPE, 15, 15)
prev_bank_button.name = 'Device_Bank_Down_Button'
next_bank_button.name = 'Device_Bank_Up_Button'
device = BestBankDeviceComponent()
device.name = 'Device_Component'
self.set_device_component(device)
device.set_parameter_controls(tuple(self._encoders))
device.set_bank_nav_buttons(prev_bank_button, next_bank_button)
self._device_bank_buttons = (prev_bank_button, next_bank_button)
prev_bank_button.add_value_listener(self._device_bank_value)
next_bank_button.add_value_listener(self._device_bank_value)
self._inst_button = ButtonElement(IS_MOMENTARY, MIDI_CC_TYPE, 15, 109)
self._inst_button.name = 'Inst_Button'
self._inst_button.add_value_listener(self._inst_value)
self._device_navigation = DetailViewCntrlComponent()
self._device_navigation.name = 'Device_Navigation_Component'
def _setup_display(self):
self._display = PhysicalDisplayElement(5, 1)
self._display.name = 'Display'
self._display.set_message_parts(SYSEX_START + (17, 1, 0, 0), (247, ))
self._display_data_source = DisplayDataSource()
self._display.segment(0).set_data_source(self._display_data_source)
def _on_selected_track_changed(self):
ControlSurface._on_selected_track_changed(self)
self._show_current_track_name()
def _shift_value(self, value):
if not value in range(128):
raise AssertionError
self._shift_pressed = value > 0
for encoder in self._encoders:
encoder.set_peek_mode(self._shift_pressed)
self._shift_pressed and self._mixer.set_select_buttons(None, None)
self._session.set_track_bank_buttons(self._next_nav_button,
self._prev_nav_button)
self._device_component.set_bank_nav_buttons(None, None)
self._device_navigation.set_device_nav_buttons(
self._device_bank_buttons[0], self._device_bank_buttons[1])
else:
self._session.set_track_bank_buttons(None, None)
self._mixer.set_select_buttons(self._next_nav_button,
self._prev_nav_button)
self._device_navigation.set_device_nav_buttons(None, None)
self._device_component.set_bank_nav_buttons(
self._device_bank_buttons[0], self._device_bank_buttons[1])
self.request_rebuild_midi_map()
def _encoder_value(self, value, sender):
if not sender in self._encoders:
raise AssertionError
if not value in range(128):
raise AssertionError
display_string = self._device_component.is_enabled() and ' - '
display_string = sender.mapped_parameter(
) != None and sender.mapped_parameter().name
self._display_data_source.set_display_string(display_string)
self._set_display_data_source(self._display_data_source)
self._display_reset_delay = STANDARD_DISPLAY_DELAY
def _slider_value(self, value, sender):
if not sender in tuple(self._sliders) + (self._master_slider, ):
raise AssertionError
if not value in range(128):
raise AssertionError
if self._mixer.is_enabled():
display_string = ' - '
if sender.mapped_parameter() != None:
master = self.song().master_track
tracks = self.song().tracks
returns = self.song().return_tracks
track = None
if sender == self._master_slider:
track = self._has_sliders and master
else:
track = self.song().view.selected_track
else:
track = self._mixer.channel_strip(
self._sliders.index(sender))._track
display_string = track == master and 'Ma'
elif track in tracks:
display_string = str(list(tracks).index(track) + 1)
elif track in returns:
display_string = str(
chr(ord('A') + list(returns).index(track)))
else:
raise False or AssertionError
display_string += ' Vol'
self._display_data_source.set_display_string(display_string)
self._set_display_data_source(self._display_data_source)
self._display_reset_delay = STANDARD_DISPLAY_DELAY
def _mixer_button_value(self, value, sender):
if not sender in tuple(
self._strip_buttons) + (self._selected_mute_solo_button, ):
raise AssertionError
if not value in range(128):
raise AssertionError
if self._mixer.is_enabled() and value > 0:
strip = None
strip = sender == self._selected_mute_solo_button and self._mixer.selected_strip(
)
else:
strip = self._mixer.channel_strip(
self._strip_buttons.index(sender))
strip != None and self._set_display_data_source(
strip.track_name_data_source())
else:
self._display_data_source.set_display_string(' - ')
self._set_display_data_source(self._display_data_source)
self._display_reset_delay = STANDARD_DISPLAY_DELAY
def _device_bank_value(self, value):
if not value in range(128):
raise AssertionError
if self._device_component.is_enabled() and value > 0:
data_source = self._device_component.bank_name_data_source()
data_source = self._shift_pressed and self._device_component.device_name_data_source(
)
self._set_display_data_source(data_source)
self._display_reset_delay = STANDARD_DISPLAY_DELAY
def _inst_value(self, value):
if not value in range(128):
raise AssertionError
value > 0 and self._device_component.is_enabled() and self.song(
).view.selected_track.view.select_instrument(
) and self._set_display_data_source(
self._device_component.device_name_data_source())
self._display_reset_delay = STANDARD_DISPLAY_DELAY
def _show_current_track_name(self):
if self._display != None and self._mixer != None:
self._set_display_data_source(
self._mixer.selected_strip().track_name_data_source())
def _show_startup_message(self):
self._display.display_message('LIVE')
self._display_reset_delay = INITIAL_DISPLAY_DELAY
def _set_display_data_source(self, data_source):
raise isinstance(data_source, DisplayDataSource) or AssertionError
self._display.segment(0).set_data_source(data_source)
data_source.update()
def _setup_transport_control(self):
is_momentary = True # We'll only be using momentary buttons here
transport = ShiftableTransportComponent(
) #Instantiate a Transport Component
#addtransport = AddlTransportComponent() #Instantiate an AddlTransport Component
device_param_controls = []
#effects_knob_cc = [16,20,24,28,17,21,25,29]
effects_knob_cc = [17, 21, 25, 29, 18, 22, 26, 30]
device = DeviceComponent()
for index in range(8):
device_param_controls.append(
EncoderElement(MIDI_CC_TYPE, CHAN, effects_knob_cc[index],
Live.MidiMap.MapMode.absolute))
device.set_parameter_controls(tuple(device_param_controls))
#self.set_device_component(device)
#from apc
device_bank_buttons = []
#device_param_controls = []
#device_buttons =[16,20,24,28,17,21,25,29];
device_buttons = [17, 21, 25, 29, 18, 22, 26, 30]
bank_button_labels = ('Clip_Track_Button', 'Device_On_Off_Button',
'Previous_Device_Button', 'Next_Device_Button',
'Detail_View_Button', 'Rec_Quantization_Button',
'Midi_Overdub_Button', 'Device_Lock_Button'
) #'Metronome_Button')
for index in range(8):
device_bank_buttons.append(
ButtonElement(is_momentary, MIDI_NOTE_TYPE, CHAN,
device_buttons[index]))
device_bank_buttons[-1].name = bank_button_labels[index]
#ring_mode_button = ButtonElement(not is_momentary, MIDI_CC_TYPE, 0, 24 + index)
#ringed_encoder = RingedEncoderElement(MIDI_CC_TYPE, 0, 16 + index, Live.MidiMap.MapMode.absolute)
#ringed_encoder.set_ring_mode_button(ring_mode_button)
#ringed_encoder.name = 'Device_Control_' + str(index)
#ring_mode_button.name = ringed_encoder.name + '_Ring_Mode_Button'
#device_param_controls.append(ringed_encoder)
device.name = 'Device_Component'
device.set_bank_buttons(tuple(device_bank_buttons))
detail_view_toggler = DetailViewCntrlComponent()
detail_view_toggler.name = 'Detail_View_Control'
detail_view_toggler.set_device_clip_toggle_button(
device_bank_buttons[0])
device.set_on_off_button(device_bank_buttons[1])
detail_view_toggler.set_device_nav_buttons(device_bank_buttons[2],
device_bank_buttons[3])
detail_view_toggler.set_detail_toggle_button(device_bank_buttons[4])
device.set_lock_button(
device_bank_buttons[7]
) #assign device lock to bank_button 8 (in place of metronome)...
self.set_device_component(device)
#detail_view_toggler.set_shift_button(self._shift_button)
#from apc
self._shift_button = ButtonElement(is_momentary, MIDI_NOTE_TYPE, 0, 37)
"""set up the buttons"""
play_button = ButtonElement(
is_momentary, MIDI_NOTE_TYPE, CHAN, 24
) #ButtonElement(is_momentary, msg_type, channel, identifier) Note that the MIDI_NOTE_TYPE constant is defined in the InputControlElement module
stop_button = ButtonElement(is_momentary, MIDI_NOTE_TYPE, CHAN, 28)
record_button = ButtonElement(is_momentary, MIDI_NOTE_TYPE, CHAN, 32)
nudge_up_button = ButtonElement(is_momentary, MIDI_NOTE_TYPE, CHAN, 27)
nudge_down_button = ButtonElement(is_momentary, MIDI_NOTE_TYPE, CHAN,
23)
# tap_tempo_button = ButtonElement(is_momentary, MIDI_NOTE_TYPE, CHAN, 19)
redo_button = ButtonElement(is_momentary, MIDI_NOTE_TYPE, CHAN, 19)
undo_button = ButtonElement(is_momentary, MIDI_NOTE_TYPE, CHAN, 20)
play_button.name = 'Play_Button'
stop_button.name = 'Stop_Button'
record_button.name = 'Record_Button'
nudge_up_button.name = 'Nudge_Up_Button'
nudge_down_button.name = 'Nudge_Down_Button'
# tap_tempo_button.name = 'Tap_Tempo_Button'
redo_button.name = 'Redo_Button'
undo_button.name = 'Undo_Button'
transport.set_shift_button(self._shift_button)
transport.set_play_button(play_button)
transport.set_stop_button(stop_button)
transport.set_record_button(record_button)
transport.set_nudge_buttons(nudge_up_button, nudge_down_button)
#addtransport.set_undo_button(undo_button)
#addtransport.set_redo_button(redo_button)
transport.set_tap_tempo_button(nudge_up_button) #shifted nudge
transport.set_quant_toggle_button(device_bank_buttons[5])
transport.set_overdub_button(device_bank_buttons[6])
# transport.set_metronome_button(device_bank_buttons[7])
#transport.set_tempo_encoder(self.prehear_control) #shifted prehear
bank_button_translator = ShiftableTranslatorComponent()
bank_button_translator.set_controls_to_translate(
tuple(device_bank_buttons))
bank_button_translator.set_shift_button(self._shift_button)
class APC40(APC):
__doc__ = " Script for Akai's APC40 Controller "
def __init__(self, c_instance):
APC.__init__(self, c_instance)
self._device_selection_follows_track_selection = True
def _setup_session_control(self):
is_momentary = True
self._shift_button = ButtonElement(is_momentary, MIDI_NOTE_TYPE, 0, 98)
right_button = ButtonElement(is_momentary, MIDI_NOTE_TYPE, 0, 96)
left_button = ButtonElement(is_momentary, MIDI_NOTE_TYPE, 0, 97)
up_button = ButtonElement(is_momentary, MIDI_NOTE_TYPE, 0, 94)
down_button = ButtonElement(is_momentary, MIDI_NOTE_TYPE, 0, 95)
right_button.name = 'Bank_Select_Right_Button'
left_button.name = 'Bank_Select_Left_Button'
up_button.name = 'Bank_Select_Up_Button'
down_button.name = 'Bank_Select_Down_Button'
self._session = PedaledSessionComponent(8, 5)
self._session.name = 'Session_Control'
self._session.set_track_bank_buttons(right_button, left_button)
self._session.set_scene_bank_buttons(down_button, up_button)
matrix = ButtonMatrixElement()
matrix.name = 'Button_Matrix'
self.scene_launch_buttons = [ ButtonElement(is_momentary, MIDI_NOTE_TYPE, 0, (index + 82)) for index in range(5) ]
track_stop_buttons = [ ButtonElement(is_momentary, MIDI_NOTE_TYPE, index, 52) for index in range(8) ]
for index in range(len(self.scene_launch_buttons)):
self.scene_launch_buttons[index].name = 'Scene_'+ str(index) + '_Launch_Button'
for index in range(len(track_stop_buttons)):
track_stop_buttons[index].name = 'Track_' + str(index) + '_Stop_Button'
self.stop_all_button = ButtonElement(is_momentary, MIDI_NOTE_TYPE, 0, 81)
self.stop_all_button.name = 'Stop_All_Clips_Button'
self._session.set_stop_all_clips_button(self.stop_all_button)
self._session.set_stop_track_clip_buttons(tuple(track_stop_buttons))
self._session.set_stop_track_clip_value(2)
## Quirksmode
self.newZoom_buttons = []
for scene_index in range(5):
scene = self._session.scene(scene_index)
scene.name = 'Scene_' + str(scene_index)
button_row = []
scene.set_launch_button(self.scene_launch_buttons[scene_index])
scene.set_triggered_value(2)
for track_index in range(8):
button = ButtonElement(is_momentary, MIDI_NOTE_TYPE, track_index, (scene_index + 53))
## Quirksmode - This moves the zoomer to allow for scene launch customisation (Currently not working 100%)
if(track_index == 4):
self.newZoom_buttons.append(button)
button.name = str(track_index) + '_Clip_' + str(scene_index) + '_Button'
button_row.append(button)
clip_slot = scene.clip_slot(track_index)
clip_slot.name = str(track_index) + '_Clip_Slot_' + str(scene_index)
clip_slot.set_triggered_to_play_value(2)
clip_slot.set_triggered_to_record_value(4)
clip_slot.set_stopped_value(3)
clip_slot.set_started_value(1)
clip_slot.set_recording_value(3)
clip_slot.set_launch_button(button)
matrix.add_row(tuple(button_row))
self._session.set_slot_launch_button(ButtonElement(is_momentary, MIDI_CC_TYPE, 0, 67))
self._session.selected_scene().name = 'Selected_Scene'
self._session.selected_scene().set_launch_button(ButtonElement(is_momentary, MIDI_CC_TYPE, 0, 64))
self._session_zoom = SessionZoomingComponent(self._session)
self._session_zoom.name = 'Session_Overview'
self._session_zoom.set_button_matrix(matrix)
self._session_zoom.set_zoom_button(self._shift_button)
self._session_zoom.set_nav_buttons(up_button, down_button, left_button, right_button)
self._session_zoom.set_scene_bank_buttons(tuple(self.newZoom_buttons))
self._session_zoom.set_stopped_value(3)
self._session_zoom.set_selected_value(5)
return None #return session
def _setup_mixer_control(self):
is_momentary = True
## Quirksmode
self.arm_buttons = []
self._mixer = SpecialMixerComponent(self, 8) #added self for parent
self._mixer.name = 'Mixer'
self._mixer.master_strip().name = 'Master_Channel_Strip'
self._mixer.selected_strip().name = 'Selected_Channel_Strip'
for track in range(8):
self.strip = self._mixer.channel_strip(track)
self.strip.name = 'Channel_Strip_' + str(track)
volume_control = SliderElement(MIDI_CC_TYPE, track, 7)
arm_button = ButtonElement(is_momentary, MIDI_NOTE_TYPE, track, 48)
solo_button = ButtonElement(is_momentary, MIDI_NOTE_TYPE, track, 49)
mute_button = ButtonElement(is_momentary, MIDI_NOTE_TYPE, track, 50)
select_button = ButtonElement(is_momentary, MIDI_NOTE_TYPE, track, 51)
volume_control.name = str(track) + '_Volume_Control'
arm_button.name = str(track) + '_Arm_Button'
solo_button.name = str(track) + '_Solo_Button'
mute_button.name = str(track) + '_Mute_Button'
select_button.name = str(track) + '_Select_Button'
self.strip.set_volume_control(volume_control)
##Quirksmode
self.arm_buttons.append(arm_button)
self.strip.set_arm_button(arm_button)
self.strip.set_solo_button(solo_button)
self.strip.set_mute_button(mute_button)
self.strip.set_select_button(select_button)
self.strip.set_shift_button(self._shift_button)
self.strip.set_invert_mute_feedback(True)
crossfader = SliderElement(MIDI_CC_TYPE, 0, 15)
master_volume_control = SliderElement(MIDI_CC_TYPE, 0, 14)
master_select_button = ButtonElement(is_momentary, MIDI_NOTE_TYPE, 0, 80)
##self._prehear_control = EncoderElement(MIDI_CC_TYPE, 0, 47, Live.MidiMap.MapMode.relative_two_compliment)
crossfader.name = 'Crossfader'
master_volume_control.name = 'Master_Volume_Control'
master_select_button.name = 'Master_Select_Button'
##self._prehear_control.name = 'Prehear_Volume_Control'
self._mixer.set_crossfader_control(crossfader)
##self._mixer.set_prehear_volume_control(self._prehear_control)
self._mixer.master_strip().set_volume_control(master_volume_control)
self._mixer.master_strip().set_select_button(master_select_button)
def _setup_custom_components(self):
self._setup_device_and_transport_control()
self._setup_global_control()
self._setup_djModeToggle()
def _setup_djModeToggle(self):
self._newDjModeToggle_state = False
## How many tracks?
self._trackTotal = len(self.song().tracks)
## Re-Assign Metronome to Dj Mode toggle
self._newDjModeToggle_button = self.transport._metronome_button
self.transport.set_metronome_button(None)
self._newDjModeToggle_button.add_value_listener(self._toggleDjMode)
## Assign Cue Volume (Temporary hack until I get the correct Api Values)
self.transport._tempo_encoder_control.connect_to(self.song().master_track.mixer_device.cue_volume)
def _toggleDjMode(self, value):
if value == 1:
if(self._newDjModeToggle_state):
self._newDjModeToggle_button.turn_off()
self._newDjModeToggle_state = False
self.show_message("########################################################################################## DJ MODE: OFF ##############################")
self._disconnect_djMode()
self.transport._cueLevelMode = 1
self.device_bank_buttons[4].turn_on()
self.transport._tempo_encoder_control.connect_to(self.song().master_track.mixer_device.cue_volume)
else:
self._newDjModeToggle_button.turn_on()
self._newDjModeToggle_state = True
self.show_message("########################################################################################## DJ MODE: ON ##############################")
self._setup_djMode()
self.transport._cueLevelMode = 2
self.device_bank_buttons[4].turn_off()
self.transport._tempo_encoder_control.release_parameter()
def _setup_djMode(self):
## Assign imports
self.sceneEffect = SceneEffectComponent(self)
self.reset = ResetComponent(self)
self.armmode = ArmToggleComponent(self)
self.trackControl = TrackControlComponent(self)
is_momentary = True
##### Scene Effect Component
self.sceneEffect.set_shift_button(self._shift_button)
for scene_index in range(5):
self.sceneEffect.newScene_button = self._session.scene(scene_index)._launch_button
self._session.scene(scene_index).set_launch_button(None)
self.sceneEffect.newScene_button.add_value_listener(self.sceneEffect._device_toggle, True)
self.sceneEffect._device_buttons.append(self.sceneEffect.newScene_button)
# Re-assign the stop all clips button
self.sceneEffect._newStopAll_button = self._session._stop_all_button
self._session.set_stop_all_clips_button(None)
self.sceneEffect._newStopAll_button.add_value_listener(self.sceneEffect._masterRepeat)
##### Reset Component
self.reset.set_shift_button(self._shift_button)
#Re-assign Play and Stop buttons to Reset Track and All
self.reset.reset_button = self.transport._play_button
self.transport.set_play_button(None)
self.reset.reset_button.add_value_listener(self.reset.reset_track)
self.reset.resetAll_button = self.transport._stop_button
self.transport.set_stop_button(None)
self.reset.resetAll_button.add_value_listener(self.reset.reset_all)
##### Arm Toggle Component
self.armmode.set_shift_button(self._shift_button)
# Re-Assign Clip/Track Button to Loop/Utility toggle
self.armmode._newDetailView_button = self.detail_view_toggler._detail_toggle_button
self.detail_view_toggler.set_detail_toggle_button(None)
self.armmode._newDetailView_button.add_value_listener(self.armmode._toggleArmMode)
# Re-assign Arm button functionality
for track in range(8):
self.armmode.newArm_button = self._mixer.channel_strip(track)._arm_button
self._mixer.channel_strip(track).set_arm_button(None)
self.armmode.newArm_button.add_value_listener(self.armmode._device_toggle, True)
self.armmode._arm_buttons.append(self.armmode.newArm_button)
##### Re-assign Track Control Ringed Encoders
self.trackControl._trackEncoders = []
for encoder_index in range(8):
self.newTrackEncoder_encoder = self.global_param_controls[encoder_index]
self.encoder_modes.set_controls(None)
self.trackControl._trackEncoders.append(self.newTrackEncoder_encoder)
self.get_current_track()
if(self.song().view.selected_track != self.song().master_track):
for device in self.song().tracks[self.current_track].devices:
if device.name == "DJ EQ and FX":
for parameter in range(8):
self.trackControl._trackEncoders[parameter].connect_to(device.parameters[parameter+1])
def _disconnect_djMode(self):
##### Disconnect Scene Effect Component
# Re-assign the Scene Start Buttons
for scene_index in range(5):
self.sceneEffect._device_buttons[scene_index].remove_value_listener(self.sceneEffect._device_toggle)
self._session.scene(scene_index).set_launch_button(self.scene_launch_buttons[scene_index])
self.sceneEffect._device_buttons = []
# Re-assign the stop all clips button
self.sceneEffect._newStopAll_button.remove_value_listener(self.sceneEffect._masterRepeat)
self.sceneEffect._newStopAll_button = None
self._session.set_stop_all_clips_button(self.stop_all_button)
self.song().view.remove_selected_track_listener(self.sceneEffect.sceneLight)
##### Disconnect Reset Component
# Re-assign the Play Button
self.reset.reset_button.remove_value_listener(self.reset.reset_track)
self.reset.reset_button = None
self.transport.set_play_button(self.play_button)
# Re-assign the Stop Button
self.reset.resetAll_button.remove_value_listener(self.reset.reset_all)
self.reset.resetAll_button = None
self.transport.set_stop_button(self.stop_button)
##### Disconnect Arm Toggle Component
for track in range(8):
self.armmode._arm_buttons[track].remove_value_listener(self.armmode._device_toggle)
self._mixer.channel_strip(track).set_arm_button(self.arm_buttons[track])
self.armmode._arm_buttons = []
self.armmode._newDetailView_button.remove_value_listener(self.armmode._toggleArmMode)
self.armmode._newDetailView_button = None
self.detail_view_toggler.set_detail_toggle_button(self.device_bank_buttons[4])
self.song().view.remove_selected_track_listener(self.armmode._armLightMode)
##### Disconnect Track Control Ringed Encoders
self.trackControl._trackEncoders = []
self.song().view.remove_selected_track_listener(self.trackControl.get_current_track)
##### Link the cutoffs for the Scene Effect Parameters
def _linkCutoff(self, value):
for device in self.song().tracks[self.current_track].devices:
if device.name == "Scene Launch Effects":
device.parameters[1].value = value
def _setup_device_and_transport_control(self):
is_momentary = True
self.device_bank_buttons = []
self.device_param_controls = []
bank_button_labels = ('Clip_Track_Button', 'Device_On_Off_Button', 'Previous_Device_Button', 'Next_Device_Button', 'Detail_View_Button', 'Rec_Quantization_Button', 'Midi_Overdub_Button', 'Metronome_Button')
for index in range(8):
self.device_bank_buttons.append(ButtonElement(is_momentary, MIDI_NOTE_TYPE, 0, 58 + index))
self.device_bank_buttons[-1].name = bank_button_labels[index]
ring_mode_button = ButtonElement(not is_momentary, MIDI_CC_TYPE, 0, 24 + index)
ringed_encoder = RingedEncoderElement(MIDI_CC_TYPE, 0, 16 + index, Live.MidiMap.MapMode.absolute)
ringed_encoder.set_ring_mode_button(ring_mode_button)
ringed_encoder.name = 'Device_Control_' + str(index)
ring_mode_button.name = ringed_encoder.name + '_Ring_Mode_Button'
## Quirksmode
##### Link the cutoffs for the Scene Effect Parameters
if (index == 0):
ringed_encoder.add_value_listener(self._linkCutoff)
self.device_param_controls.append(ringed_encoder)
self.device = ShiftableDeviceComponent()
self.device.name = 'Device_Component'
self.device.set_bank_buttons(tuple(self.device_bank_buttons))
self.device.set_shift_button(self._shift_button)
self.device.set_parameter_controls(tuple(self.device_param_controls))
self.device.set_on_off_button(self.device_bank_buttons[1])
self.set_device_component(self.device)
self.detail_view_toggler = DetailViewCntrlComponent()
self.detail_view_toggler.name = 'Detail_View_Control'
self.detail_view_toggler.set_shift_button(self._shift_button)
self.detail_view_toggler.set_device_clip_toggle_button(self.device_bank_buttons[0])
self.detail_view_toggler.set_detail_toggle_button(self.device_bank_buttons[4])
self.detail_view_toggler.set_device_nav_buttons(self.device_bank_buttons[2], self.device_bank_buttons[3])
self.transport = ShiftableTransportComponent(self) ## Quirksmode added self
self.transport.name = 'Transport'
self.play_button = ButtonElement(is_momentary, MIDI_NOTE_TYPE, 0, 91)
self.play_button.name = 'Play_Button'
self.stop_button = ButtonElement(is_momentary, MIDI_NOTE_TYPE, 0, 92)
self.record_button = ButtonElement(is_momentary, MIDI_NOTE_TYPE, 0, 93)
nudge_up_button = ButtonElement(is_momentary, MIDI_NOTE_TYPE, 0, 100)
nudge_down_button = ButtonElement(is_momentary, MIDI_NOTE_TYPE, 0, 101)
tap_tempo_button = ButtonElement(is_momentary, MIDI_NOTE_TYPE, 0, 99)
self.stop_button.name = 'Stop_Button'
self.record_button.name = 'Record_Button'
nudge_up_button.name = 'Nudge_Up_Button'
nudge_down_button.name = 'Nudge_Down_Button'
tap_tempo_button.name = 'Tap_Tempo_Button'
self.transport.set_shift_button(self._shift_button)
self.transport.set_play_button(self.play_button)
self.transport.set_stop_button(self.stop_button)
self.transport.set_record_button(self.record_button)
self.transport.set_nudge_buttons(nudge_up_button, nudge_down_button)
self.transport.set_undo_button(nudge_down_button) #shifted nudge
self.transport.set_redo_button(nudge_up_button) #shifted nudge
self.transport.set_tap_tempo_button(tap_tempo_button)
self.transport.set_quant_toggle_button(self.device_bank_buttons[5])
self.transport.set_overdub_button(self.device_bank_buttons[6])
self.transport.set_metronome_button(self.device_bank_buttons[7])
self._prehear_control = EncoderElement(MIDI_CC_TYPE, 0, 47, Live.MidiMap.MapMode.relative_two_compliment)
self.transport.set_tempo_encoder(self._prehear_control) #shifted prehear
bank_button_translator = ShiftTranslatorComponent()
bank_button_translator.set_controls_to_translate(tuple(self.device_bank_buttons))
bank_button_translator.set_shift_button(self._shift_button)
def _setup_global_control(self):
is_momentary = True
global_bank_buttons = []
self.global_param_controls = []
for index in range(8):
ring_button = ButtonElement(not is_momentary, MIDI_CC_TYPE, 0, 56 + index)
ringed_encoder = RingedEncoderElement(MIDI_CC_TYPE, 0, 48 + index, Live.MidiMap.MapMode.absolute)
ringed_encoder.name = 'Track_Control_' + str(index)
ring_button.name = ringed_encoder.name + '_Ring_Mode_Button'
ringed_encoder.set_ring_mode_button(ring_button)
self.global_param_controls.append(ringed_encoder)
global_bank_buttons = []
global_bank_labels = ('Pan_Button', 'Send_A_Button', 'Send_B_Button', 'Send_C_Button')
for index in range(4):
global_bank_buttons.append(ButtonElement(not is_momentary, MIDI_NOTE_TYPE, 0, 87 + index))
global_bank_buttons[-1].name = global_bank_labels[index]
self.encoder_modes = EncModeSelectorComponent(self._mixer)
self.encoder_modes.name = 'Track_Control_Modes'
self.encoder_modes.set_modes_buttons(global_bank_buttons)
self.encoder_modes.set_controls(tuple(self.global_param_controls))
self.global_translation_selector = ChannelTranslationSelector()
self.global_translation_selector.name = 'Global_Translations'
self.global_translation_selector.set_controls_to_translate(tuple(self.global_param_controls))
self.global_translation_selector.set_mode_buttons(tuple(global_bank_buttons))
def _on_selected_track_changed(self):
ControlSurface._on_selected_track_changed(self)
## Quirksmode
if(self._newDjModeToggle_state):
if self.application().view.is_view_visible('Detail/Clip'):
self.application().view.show_view('Detail/DeviceChain')
self.application().view.is_view_visible('Detail/DeviceChain')
else:
self.application().view.show_view('Detail/Clip')
self.application().view.is_view_visible('Detail/Clip')
if(self.song().view.selected_track != self.song().master_track):
if (self.song().view.selected_track.playing_slot_index > -1):
self.song().view.selected_scene = self.song().scenes[self.song().view.selected_track.playing_slot_index]
track_index = 0
for track in self.song().tracks:
if track == self.song().view.selected_track:
break
track_index += 1
self.current_track = track_index
track = self.song().view.selected_track
device_to_select = track.view.selected_device
if device_to_select == None and len(track.devices) > 0:
device_to_select = track.devices[0]
if device_to_select != None:
self.song().view.select_device(device_to_select)
self._device_component.set_device(device_to_select)
return None
######################### Utils
# Get the current track
def get_current_track(self):
track_index = 0
for track in self.song().tracks:
if track == self.song().view.selected_track:
break
track_index += 1
self.current_track = track_index
# Get the device on the given track by the given name.
def GetDeviceByName(self, trackIndex, deviceName):
for device in self.song().tracks[trackIndex].devices:
if (device.name == deviceName):
return device
return None
# Get the value of the given device in the given track by the given parameter name.
def GetDeviceParameter(self, device, paramName):
for deviceParam in device.parameters:
if (deviceParam.name == paramName):
return deviceParam.value
return None
# Set the given parameter name of the given device to the given value.
def SetDeviceParameter(self, device, paramName, value):
for deviceParam in device.parameters:
if (deviceParam.name == paramName):
deviceParam.value = value
pass
# Toggles the given param of the given device. Usefull for on/off effects, etc.
def ToggleDeviceParameter(self, device, paramName):
for deviceParam in device.parameters:
if (deviceParam.name == paramName):
if (deviceParam.value == 1):
deviceParam.value = 0
else:
deviceParam.value = 1
pass
# Returns if the given track has a triggered clip.
def TrackHasTriggeredClip(self, track):
for clipSlot in track.clip_slots:
if (clipSlot.has_clip):
if (clipSlot.clip.is_triggered):
return True
return False
# Returns if the given track has a playing clip.
def TrackHasPlayingClip(self, track):
for clipSlot in track.clip_slots:
if (clipSlot.has_clip):
if (clipSlot.clip.is_playing):
return True
return False
def _product_model_id_byte(self):
return 115
def _setup_device_and_transport_control(self):
is_momentary = True
self.device_bank_buttons = []
self.device_param_controls = []
bank_button_labels = ('Clip_Track_Button', 'Device_On_Off_Button', 'Previous_Device_Button', 'Next_Device_Button', 'Detail_View_Button', 'Rec_Quantization_Button', 'Midi_Overdub_Button', 'Metronome_Button')
for index in range(8):
self.device_bank_buttons.append(ButtonElement(is_momentary, MIDI_NOTE_TYPE, 0, 58 + index))
self.device_bank_buttons[-1].name = bank_button_labels[index]
ring_mode_button = ButtonElement(not is_momentary, MIDI_CC_TYPE, 0, 24 + index)
ringed_encoder = RingedEncoderElement(MIDI_CC_TYPE, 0, 16 + index, Live.MidiMap.MapMode.absolute)
ringed_encoder.set_ring_mode_button(ring_mode_button)
ringed_encoder.name = 'Device_Control_' + str(index)
ring_mode_button.name = ringed_encoder.name + '_Ring_Mode_Button'
## Quirksmode
##### Link the cutoffs for the Scene Effect Parameters
if (index == 0):
ringed_encoder.add_value_listener(self._linkCutoff)
self.device_param_controls.append(ringed_encoder)
self.device = ShiftableDeviceComponent()
self.device.name = 'Device_Component'
self.device.set_bank_buttons(tuple(self.device_bank_buttons))
self.device.set_shift_button(self._shift_button)
self.device.set_parameter_controls(tuple(self.device_param_controls))
self.device.set_on_off_button(self.device_bank_buttons[1])
self.set_device_component(self.device)
self.detail_view_toggler = DetailViewCntrlComponent()
self.detail_view_toggler.name = 'Detail_View_Control'
self.detail_view_toggler.set_shift_button(self._shift_button)
self.detail_view_toggler.set_device_clip_toggle_button(self.device_bank_buttons[0])
self.detail_view_toggler.set_detail_toggle_button(self.device_bank_buttons[4])
self.detail_view_toggler.set_device_nav_buttons(self.device_bank_buttons[2], self.device_bank_buttons[3])
self.transport = ShiftableTransportComponent(self) ## Quirksmode added self
self.transport.name = 'Transport'
self.play_button = ButtonElement(is_momentary, MIDI_NOTE_TYPE, 0, 91)
self.play_button.name = 'Play_Button'
self.stop_button = ButtonElement(is_momentary, MIDI_NOTE_TYPE, 0, 92)
self.record_button = ButtonElement(is_momentary, MIDI_NOTE_TYPE, 0, 93)
nudge_up_button = ButtonElement(is_momentary, MIDI_NOTE_TYPE, 0, 100)
nudge_down_button = ButtonElement(is_momentary, MIDI_NOTE_TYPE, 0, 101)
tap_tempo_button = ButtonElement(is_momentary, MIDI_NOTE_TYPE, 0, 99)
self.stop_button.name = 'Stop_Button'
self.record_button.name = 'Record_Button'
nudge_up_button.name = 'Nudge_Up_Button'
nudge_down_button.name = 'Nudge_Down_Button'
tap_tempo_button.name = 'Tap_Tempo_Button'
self.transport.set_shift_button(self._shift_button)
self.transport.set_play_button(self.play_button)
self.transport.set_stop_button(self.stop_button)
self.transport.set_record_button(self.record_button)
self.transport.set_nudge_buttons(nudge_up_button, nudge_down_button)
self.transport.set_undo_button(nudge_down_button) #shifted nudge
self.transport.set_redo_button(nudge_up_button) #shifted nudge
self.transport.set_tap_tempo_button(tap_tempo_button)
self.transport.set_quant_toggle_button(self.device_bank_buttons[5])
self.transport.set_overdub_button(self.device_bank_buttons[6])
self.transport.set_metronome_button(self.device_bank_buttons[7])
self._prehear_control = EncoderElement(MIDI_CC_TYPE, 0, 47, Live.MidiMap.MapMode.relative_two_compliment)
self.transport.set_tempo_encoder(self._prehear_control) #shifted prehear
bank_button_translator = ShiftTranslatorComponent()
bank_button_translator.set_controls_to_translate(tuple(self.device_bank_buttons))
bank_button_translator.set_shift_button(self._shift_button)
def _setup_device_and_transport_control(self):
is_momentary = True
device_bank_buttons = []
device_param_controls = []
bank_button_labels = (
"Clip_Track_Button",
"Device_On_Off_Button",
"Previous_Device_Button",
"Next_Device_Button",
"Detail_View_Button",
"Rec_Quantization_Button",
"Midi_Overdub_Button",
"Metronome_Button",
)
for index in range(8):
device_bank_buttons.append(ButtonElement(is_momentary, MIDI_NOTE_TYPE, 0, 58 + index))
device_bank_buttons[-1].name = bank_button_labels[index]
ring_mode_button = ButtonElement(not is_momentary, MIDI_CC_TYPE, 0, 24 + index)
ringed_encoder = RingedEncoderElement(MIDI_CC_TYPE, 0, 16 + index, Live.MidiMap.MapMode.absolute)
ringed_encoder.set_ring_mode_button(ring_mode_button)
ringed_encoder.name = "Device_Control_" + str(index)
ring_mode_button.name = ringed_encoder.name + "_Ring_Mode_Button"
device_param_controls.append(ringed_encoder)
device = ShiftableDeviceComponent()
device.name = "Device_Component"
device.set_bank_buttons(tuple(device_bank_buttons))
device.set_shift_button(self._shift_button)
device.set_parameter_controls(tuple(device_param_controls))
device.set_on_off_button(device_bank_buttons[1])
self.set_device_component(device)
detail_view_toggler = DetailViewCntrlComponent()
detail_view_toggler.name = "Detail_View_Control"
detail_view_toggler.set_shift_button(self._shift_button)
detail_view_toggler.set_device_clip_toggle_button(device_bank_buttons[0])
detail_view_toggler.set_detail_toggle_button(device_bank_buttons[4])
detail_view_toggler.set_device_nav_buttons(device_bank_buttons[2], device_bank_buttons[3])
transport = ShiftableTransportComponent()
transport.name = "Transport"
play_button = ButtonElement(is_momentary, MIDI_NOTE_TYPE, 0, 91)
stop_button = ButtonElement(is_momentary, MIDI_NOTE_TYPE, 0, 92)
record_button = ButtonElement(is_momentary, MIDI_NOTE_TYPE, 0, 93)
nudge_up_button = ButtonElement(is_momentary, MIDI_NOTE_TYPE, 0, 100)
nudge_down_button = ButtonElement(is_momentary, MIDI_NOTE_TYPE, 0, 101)
tap_tempo_button = ButtonElement(is_momentary, MIDI_NOTE_TYPE, 0, 99)
play_button.name = "Play_Button"
stop_button.name = "Stop_Button"
record_button.name = "Record_Button"
nudge_up_button.name = "Nudge_Up_Button"
nudge_down_button.name = "Nudge_Down_Button"
tap_tempo_button.name = "Tap_Tempo_Button"
transport.set_shift_button(self._shift_button)
transport.set_play_button(play_button)
transport.set_stop_button(stop_button)
transport.set_record_button(record_button)
transport.set_nudge_buttons(nudge_up_button, nudge_down_button)
transport.set_tap_tempo_button(tap_tempo_button)
transport.set_quant_toggle_button(device_bank_buttons[5])
transport.set_overdub_button(device_bank_buttons[6])
transport.set_metronome_button(device_bank_buttons[7])
bank_button_translator = ShiftTranslatorComponent()
bank_button_translator.set_controls_to_translate(tuple(device_bank_buttons))
bank_button_translator.set_shift_button(self._shift_button)
