def _setup_device_and_transport_control(self): is_momentary = True device_param_controls = [] for index in range(8): device_param_controls.append( EncoderElement(MIDI_CC_TYPE, 15, 62 - index, Live.MidiMap.MapMode.absolute)) device = SpecialDeviceComponent() device.set_bank_nav_buttons( ButtonElement(is_momentary, MIDI_CC_TYPE, 15, 107), ButtonElement(is_momentary, MIDI_CC_TYPE, 15, 106)) device.set_parameter_controls(tuple(device_param_controls)) self.set_device_component(device) transport = SpecialTransportComponent() transport.set_play_button( ButtonElement(is_momentary, MIDI_CC_TYPE, 15, 20)) transport.set_stop_button( ButtonElement(is_momentary, MIDI_CC_TYPE, 15, 21)) transport.set_record_button( ButtonElement(is_momentary, MIDI_CC_TYPE, 15, 22)) transport.set_seek_buttons( ButtonElement(is_momentary, MIDI_CC_TYPE, 15, 24), ButtonElement(is_momentary, MIDI_CC_TYPE, 15, 25)) transport.set_tap_tempo_button( ButtonElement(is_momentary, MIDI_CC_TYPE, 15, 94)) transport.set_undo_button( ButtonElement(is_momentary, MIDI_CC_TYPE, 15, 23)) transport.set_redo_button( ButtonElement(is_momentary, MIDI_CC_TYPE, 15, 27)) transport.set_bts_button( ButtonElement(is_momentary, MIDI_CC_TYPE, 15, 26))
def _setup_device_and_transport_control(self): is_momentary = True self._device = DeviceComponent() self._device.name = 'Device_Component' device_bank_buttons = [] device_param_controls = [] for index in range(PARAMS_NUMBER): device_param_controls.append(self._ctrl_map_parameter[index]) for index in range(BANKS_NUMBER): device_bank_buttons.append(self._note_map_bank_buttons[index]) if None not in device_bank_buttons: self._device.set_bank_buttons(tuple(device_bank_buttons)) if None not in device_param_controls: self._device.set_parameter_controls(tuple(device_param_controls)) self._device.set_on_off_button(self._note_map_buttons[17]) self._device.set_bank_nav_buttons(self._note_map_buttons[20], self._note_map_buttons[21]) self._device.set_lock_button(self._note_map_buttons[16]) self.set_device_component(self._device) detail_view_toggler = DetailViewControllerComponent() detail_view_toggler.name = 'Detail_View_Control' detail_view_toggler.set_device_clip_toggle_button( self._note_map_buttons[15]) detail_view_toggler.set_detail_toggle_button( self._note_map_buttons[14]) detail_view_toggler.set_device_nav_buttons(self._note_map_buttons[18], self._note_map_buttons[19]) transport = SpecialTransportComponent() transport.name = 'Transport' transport.set_play_button(self._note_map_buttons[0]) transport.set_stop_button(self._note_map_buttons[1]) transport.set_record_button(self._note_map_buttons[2]) transport.set_nudge_buttons(self._note_map_buttons[4], self._note_map_buttons[5]) transport.set_undo_button(self._note_map_buttons[6]) transport.set_redo_button(self._note_map_buttons[7]) transport.set_tap_tempo_button(self._note_map_buttons[3]) transport.set_quant_toggle_button(self._note_map_buttons[13]) transport.set_overdub_button(self._note_map_buttons[11]) transport.set_metronome_button(self._note_map_buttons[12]) transport.set_tempo_control(self._ctrl_map_sliders[3]) transport.set_loop_button(self._note_map_buttons[8]) transport.set_seek_buttons(self._note_map_buttons[22], self._note_map_buttons[23]) transport.set_punch_buttons(self._note_map_buttons[9], self._note_map_buttons[10])
def _setup_device_and_transport_control(self): is_momentary = True self._device = DeviceComponent() self._device.name = 'Device_Component' device_bank_buttons = [] device_param_controls = [] for index in range(8): device_param_controls.append(self._ctrl_map[PARAMCONTROL[index]]) device_bank_buttons.append(self._note_map[DEVICEBANK[index]]) if None not in device_bank_buttons: self._device.set_bank_buttons(tuple(device_bank_buttons)) if None not in device_param_controls: self._device.set_parameter_controls(tuple(device_param_controls)) self._device.set_on_off_button(self._note_map[DEVICEONOFF]) self._device.set_bank_nav_buttons(self._note_map[DEVICEBANKNAVLEFT], self._note_map[DEVICEBANKNAVRIGHT]) self._device.set_lock_button(self._note_map[DEVICELOCK]) self.set_device_component(self._device) detail_view_toggler = DetailViewControllerComponent() detail_view_toggler.name = 'Detail_View_Control' detail_view_toggler.set_device_clip_toggle_button( self._note_map[CLIPTRACKVIEW]) detail_view_toggler.set_detail_toggle_button( self._note_map[DETAILVIEW]) detail_view_toggler.set_device_nav_buttons( self._note_map[DEVICENAVLEFT], self._note_map[DEVICENAVRIGHT]) transport = SpecialTransportComponent() transport.name = 'Transport' transport.set_play_button(self._note_map[PLAY]) transport.set_stop_button(self._note_map[STOP]) transport.set_record_button(self._note_map[REC]) transport.set_nudge_buttons(self._note_map[NUDGEUP], self._note_map[NUDGEDOWN]) transport.set_undo_button(self._note_map[UNDO]) transport.set_redo_button(self._note_map[REDO]) transport.set_tap_tempo_button(self._note_map[TAPTEMPO]) transport.set_quant_toggle_button(self._note_map[RECQUANT]) transport.set_overdub_button(self._note_map[OVERDUB]) transport.set_metronome_button(self._note_map[METRONOME]) transport.set_tempo_control(self._ctrl_map[TEMPOCONTROL]) transport.set_loop_button(self._note_map[LOOP]) transport.set_seek_buttons(self._note_map[SEEKFWD], self._note_map[SEEKRWD]) transport.set_punch_buttons(self._note_map[PUNCHIN], self._note_map[PUNCHOUT])
def _setup_device_and_transport_control(self): is_momentary = True device_param_controls = [] for index in range(8): device_param_controls.append(EncoderElement(MIDI_CC_TYPE, 15, 62 - index, Live.MidiMap.MapMode.absolute)) device = SpecialDeviceComponent() device.set_bank_nav_buttons(ButtonElement(is_momentary, MIDI_CC_TYPE, 15, 107), ButtonElement(is_momentary, MIDI_CC_TYPE, 15, 106)) device.set_parameter_controls(tuple(device_param_controls)) self.set_device_component(device) transport = SpecialTransportComponent() transport.set_play_button(ButtonElement(is_momentary, MIDI_CC_TYPE, 15, 20)) transport.set_stop_button(ButtonElement(is_momentary, MIDI_CC_TYPE, 15, 21)) transport.set_record_button(ButtonElement(is_momentary, MIDI_CC_TYPE, 15, 22)) transport.set_seek_buttons(ButtonElement(is_momentary, MIDI_CC_TYPE, 15, 24), ButtonElement(is_momentary, MIDI_CC_TYPE, 15, 25)) transport.set_tap_tempo_button(ButtonElement(is_momentary, MIDI_CC_TYPE, 15, 94)) transport.set_undo_button(ButtonElement(is_momentary, MIDI_CC_TYPE, 15, 23)) transport.set_redo_button(ButtonElement(is_momentary, MIDI_CC_TYPE, 15, 27)) transport.set_bts_button(ButtonElement(is_momentary, MIDI_CC_TYPE, 15, 26))
def _setup_device_and_transport_control(self): is_momentary = True self._device = DeviceComponent() self._device.name = 'Device_Component' device_bank_buttons = [] device_param_controls = [] for index in range(4): device_param_controls.append(self._ctrl_map[PARAMCONTROL[index]]) device_bank_buttons.append(self._note_map[DEVICEBANK[index]]) if None not in device_bank_buttons: self._device.set_bank_buttons(tuple(device_bank_buttons)) if None not in device_param_controls: self._device.set_parameter_controls(tuple(device_param_controls)) self._device.set_on_off_button(self._note_map[DEVICEONOFF]) self._device.set_bank_nav_buttons(self._note_map[DEVICEBANKNAVLEFT], self._note_map[DEVICEBANKNAVRIGHT]) self._device.set_lock_button(self._note_map[DEVICELOCK]) self.set_device_component(self._device) detail_view_toggler = DetailViewControllerComponent() detail_view_toggler.name = 'Detail_View_Control' detail_view_toggler.set_device_clip_toggle_button(self._note_map[CLIPTRACKVIEW]) detail_view_toggler.set_detail_toggle_button(self._note_map[DETAILVIEW]) detail_view_toggler.set_device_nav_buttons(self._note_map[DEVICENAVLEFT], self._note_map[DEVICENAVRIGHT] ) transport = SpecialTransportComponent() transport.name = 'Transport' transport.set_play_button(self._note_map[PLAY]) transport.set_stop_button(self._note_map[STOP]) transport.set_record_button(self._note_map[REC]) transport.set_nudge_buttons(self._note_map[NUDGEUP], self._note_map[NUDGEDOWN]) transport.set_undo_button(self._note_map[UNDO]) transport.set_redo_button(self._note_map[REDO]) transport.set_tap_tempo_button(self._note_map[TAPTEMPO]) transport.set_quant_toggle_button(self._note_map[RECQUANT]) transport.set_overdub_button(self._note_map[OVERDUB]) transport.set_metronome_button(self._note_map[METRONOME]) transport.set_tempo_control(self._ctrl_map[TEMPOCONTROL]) transport.set_tempo_bumpers(ButtonElement(True, MIDI_NOTE_TYPE, 2, 50),ButtonElement(True, MIDI_NOTE_TYPE, 2, 49)) transport.set_loop_button(self._note_map[LOOP]) transport.set_seek_buttons(self._note_map[SEEKFWD], self._note_map[SEEKRWD]) transport.set_punch_buttons(self._note_map[PUNCHIN], self._note_map[PUNCHOUT])
class MainSelectorComponent(ModeSelectorComponent): """ Class that reassigns the buttons on the Spark to different functions """ def __init__(self, launch_buttons, mode_buttons, pads, transport_buttons, select_button, translate_button, mute_button, solo_button, tempo_control, volume_control, param_controls, copy_button, erase_button, rewind_button, forward_button, browser_control, browser_button, pattern_leds, track_leds, divide_control, move_control, parent): "verifies that the buttons given are compatible with the selector component" assert isinstance(launch_buttons, tuple) assert (len(launch_buttons) == 16) assert isinstance(mode_buttons, tuple) assert (len(mode_buttons) == 4) assert isinstance(pads, tuple) assert (len(pads) == 8) assert (len(transport_buttons) == 4) assert (len(param_controls) == 3) ModeSelectorComponent.__init__(self) "the parent atribute allows us to control the control surface component" "it can be used for example to get the currently selected track" self._parent = parent "definition of all the components we will map buttons with" self._session = SpecialSessionComponent(8, 16) self._session.name = 'Session_Control' self._mixer = SpecialMixerComponent(8) self._mixer.name = 'Mixer_Control' self._transport = SpecialTransportComponent(self) self._transport.name = 'Transport_Control' self._device = DeviceComponent() self._device.name = 'Device_Control' "definition of all the buttons that will be used" self._launch_buttons = launch_buttons self._mode_buttons = mode_buttons self._pads = pads self._all_buttons = [] self._select_button = select_button self._translate_button = translate_button self._mute_button = mute_button self._solo_button = solo_button self._transport_buttons = transport_buttons self._copy_button = copy_button self._erase_button = erase_button self._rewind_button = rewind_button self._forward_button = forward_button self._browser_control = browser_control self._browser_button = browser_button self._divide_control = divide_control self._move_control = move_control self._track_leds = track_leds self._pattern_leds = pattern_leds "definition of all the controls that will be used" self._tempo_control = tempo_control self._volume_control = volume_control self._param_controls = param_controls for button in self._launch_buttons + self._mode_buttons + self._pads + self._transport_buttons + self._track_leds + self._pattern_leds: self._all_buttons.append(button) self._all_buttons.append(self._select_button) self._all_buttons.append(self._translate_button) self._all_buttons.append(self._mute_button) self._all_buttons.append(self._solo_button) self._all_buttons.append(self._copy_button) self._all_buttons.append(self._erase_button) self._all_buttons.append(self._rewind_button) self._all_buttons.append(self._forward_button) self._stepseq = StepSequencerComponent(self, self._launch_buttons,self._pads, self._translate_button, self._select_button, self._mute_button, self._solo_button, tuple(self._transport_buttons), forward_button, rewind_button, pattern_leds) self._translation_selector = TranslationSelectorComponent(tuple(self._launch_buttons), tuple(self._pads), self._translate_button, self) self._init_session() self._all_buttons = tuple(self._all_buttons) self._mode_index=0 self._previous_mode_index=-1 self.set_mode_buttons(mode_buttons) self._parent = parent self._selected_track_index=0 self._previous_track_index=0 self._parent.set_device_component(self._device) for button in self._all_buttons: button.send_value(0,True) def disconnect(self): for button in self._mode_buttons: button.remove_value_listener(self._mode_value) for button in self._all_buttons: button.send_value(0,True) self._session = None self._mixer = None self._transport = None self._launch_buttons = None self._mode_buttons = None self._pads = None self._transport_buttons = None ModeSelectorComponent.disconnect(self) def _update_mode(self): """check if the mode selected is a new mode and if so update the controls""" mode = self._modes_heap[-1][0] assert mode in range(self.number_of_modes()) if self._mode_index==mode or (mode == 2 and not self.song().view.selected_track.has_midi_input): self._previous_mode_index=self._mode_index else: self._mode_index = mode for button in self._all_buttons: button.send_value(0,True) self.update() def set_mode(self, mode): self._clean_heap() self._modes_heap = [(mode, None, None)] def number_of_modes(self): return 4 def _update_mode_buttons(self): """lights up the mode buttons if selected""" for index in range(4): if (index == self._mode_index): self._modes_buttons[index].turn_on() else: self._modes_buttons[index].turn_off() def update(self): """main method of the class that calls the assignation methods corresponding to the current mode""" """it is called when the mode changes and when the selected track changes""" assert (self._modes_buttons != None) "links the session to the mixer, so that when change the selected track the session also changes position" self._session.set_mixer(self._mixer) if self.is_enabled(): self._update_mode_buttons() self._translation_selector.update() as_active = True as_enabled = True self._session.set_allow_update(False)#we dont want the controlls to change while we are updating the assignations if (self._mode_index == 0): "A: Transport mode" "we activate the transport buttons and tha launch scenes buttons" #self._parent.log_message("Launching mode") self._setup_step_sequencer(not as_active) self._setup_launch_clips(not as_active,not as_enabled) self._setup_track_controls(not as_active) self._setup_device_buttons(not as_active) self._set_scale_control(not as_active) self._setup_transport_buttons(as_active) self._setup_launch_scenes(as_active, as_enabled) self._setup_master_controls(as_active) self._set_browser_control(as_active) self._set_browser_button(as_active) self._setup_select_buttons(as_active) elif (self._mode_index == 1): "B: Mixer mode" "we activate the track selection, arm, and mute buttons and the launch clips buttons" #self._parent.log_message("Launching clips mode") self._setup_step_sequencer(not as_active) self._setup_launch_scenes(not as_active, not as_enabled) self._setup_master_controls(not as_active) self._setup_device_buttons(not as_active) self._set_scale_control(not as_active) self._setup_transport_buttons(as_active) self._setup_launch_clips(as_active, as_enabled) self._setup_track_controls(as_active) self._setup_select_buttons(as_active) self._set_browser_control(as_active) self._set_browser_button(as_active) elif (self._mode_index == 2): "C: Step sequencer mode" self._setup_launch_scenes(not as_active, not as_enabled) self._setup_launch_clips(not as_active,not as_enabled) self._setup_track_controls(not as_active) self._setup_master_controls(not as_active) self._setup_select_buttons(not as_active) self._setup_device_buttons(not as_active) self._setup_transport_buttons(not as_active) self._set_scale_control(not as_active) self._setup_step_sequencer(as_active) self._set_browser_control(as_active) self._set_browser_button(as_active) else: "D: Instrument mode" "the keyboard now control the selected midi instrument" self._setup_step_sequencer(not as_active) self._setup_launch_clips(not as_active,not as_enabled) self._setup_launch_scenes(not as_active, not as_enabled) self._setup_track_controls(not as_active) self._setup_master_controls(not as_active) self._setup_select_buttons(not as_active) self._set_browser_control(as_active) self._set_browser_button(as_active) self._setup_device_buttons(as_active) self._setup_transport_buttons(as_active) self._set_scale_control(as_active) self._update_session_translation() self._session.set_allow_update(True) self._previous_mode_index=self._mode_index #self._parent.log_message("Updated") def _setup_launch_scenes(self, as_active, as_enabled): "if as_active, we'll assignate the keyboard notes to the launch scene buttons" assert isinstance(as_active, type(False)) #launch_buttons for scene_index in range(16): scene = self._session.scene(scene_index) if as_active: scene_button = self._launch_buttons[scene_index] scene_button.turn_off() scene.set_launch_button(scene_button) else: scene.set_launch_button(None) def _setup_launch_clips(self, as_active, as_enabled): "if as_active, we'll assignate the keyboard notes to the launch clip buttons" assert isinstance(as_active, type(False)) #launch_buttons for scene_index in range(16): scene = self._session.scene(scene_index) for track_index in range(8): if as_active and track_index==self._selected_track_index: clip_button = self._launch_buttons[scene_index] clip_button.turn_off() scene.clip_slot(track_index).set_launch_button(clip_button) else: scene.clip_slot(track_index).set_launch_button(None) def _setup_select_buttons(self, as_active): "if as_active, we'll assign the pads to track selection and track control buttons" "pads 15 and 16 will shift and arm tha selected track" for index in range(8): select_button = self._pads[index] if as_active: if self._selected_track_index == index: "we only assign the arm and mute buttons of the selected track" #self._parent.log_message("set arm on "+str(index)) self._mixer.channel_strip(index).set_arm_button(select_button) self._mixer.channel_strip(index).set_mute_button(self._mute_button) self._mixer.channel_strip(index).set_solo_button(self._solo_button) self._mixer.channel_strip(index).set_select_button(None) self._mixer.channel_strip(index).set_shift_button(self._select_button) self._track_leds[index].send_value(127,True) else: self._mixer.channel_strip(index).set_arm_button(None) self._mixer.channel_strip(index).set_select_button(select_button) self._mixer.channel_strip(index).set_mute_button(None) self._mixer.channel_strip(index).set_solo_button(None) self._mixer.channel_strip(index).set_shift_button(None) self._track_leds[index].send_value(0,True) else: self._mixer.channel_strip(index).set_select_button(None) self._mixer.channel_strip(index).set_arm_button(None) self._mixer.channel_strip(index).set_mute_button(None) self._mixer.channel_strip(index).set_mute_button(None) self._mixer.channel_strip(index).set_solo_button(None) self._track_leds[index].turn_off() def _setup_transport_buttons(self, as_active): "if as_active, we'll assign the pads to the transport buttons" if as_active: self._transport.set_play_button(self._transport_buttons[2]) self._transport.set_stop_button(self._transport_buttons[1]) self._transport.set_record_button(self._transport_buttons[0]) self._transport.set_loop_button(self._transport_buttons[3]) self._transport.set_tempo_encoder(self._tempo_control) self._transport.set_undo_button(self._erase_button) self._transport.set_redo_button(self._copy_button) else: self._transport.set_play_button(None) self._transport.set_stop_button(None) self._transport.set_record_button(None) self._transport.set_loop_button(None) self._transport.set_tempo_encoder(None) self._transport.set_undo_button(None) self._transport.set_redo_button(None) def _setup_master_controls(self, as_active): "if as_active, we'll assign the control knobs to the master track parameters" if as_active: self._mixer.master_strip().set_volume_control(self._volume_control) self._mixer.master_strip().set_pan_control(self._param_controls[0]) self._mixer.set_prehear_volume_control(self._param_controls[1]) self._mixer.set_crossfader_control(self._param_controls[2]) self._transport.set_seek_buttons(self._forward_button,self._rewind_button) else: self._mixer.master_strip().set_volume_control(None) self._mixer.master_strip().set_pan_control(None) self._mixer.set_prehear_volume_control(None) self._mixer.set_crossfader_control(None) self._transport.set_seek_buttons(None,None) def _setup_track_controls(self, as_active): "if as_active, we'll assign the control knobs to the master track parameters" if as_active: self._parent.log_message(self._previous_track_index) self._mixer.channel_strip(self._previous_track_index).set_volume_control(None) self._mixer.channel_strip(self._previous_track_index).set_pan_control(None) self._mixer.channel_strip(self._previous_track_index).set_send_controls(None) self._parent.log_message(self._selected_track_index) self._mixer.channel_strip(self._selected_track_index).set_volume_control(self._volume_control) self._mixer.channel_strip(self._selected_track_index).set_pan_control(self._param_controls[0]) self._mixer.channel_strip(self._selected_track_index).set_send_controls(self._param_controls[1:]) else: self._mixer.channel_strip(self._selected_track_index).set_volume_control(None) self._mixer.channel_strip(self._selected_track_index).set_pan_control(None) self._mixer.channel_strip(self._selected_track_index).set_send_controls(None) def _setup_device_buttons(self, as_active): "if as_active, we'll assign the pads to the device selection and activation buttons" if as_active: self._device.set_parameter_controls(self._param_controls) self._device.set_bank_nav_buttons(self._rewind_button, self._forward_button) else: self._device.set_parameter_controls(None) self._device.set_bank_nav_buttons(None, None) def _init_session(self): for scene_index in range(len(self._launch_buttons)): scene = self._session.scene(scene_index) scene.set_triggered_value(127) scene.name = 'Scene_' + str(scene_index) for track_index in range(8): "TODO: this still doesn't light the launch clip buttons when supposed to..." clip_slot = scene.clip_slot(track_index) clip_slot.set_triggered_to_play_value(127) clip_slot.set_triggered_to_record_value(127) clip_slot.set_stopped_value(0) clip_slot.set_started_value(127) clip_slot.set_recording_value(127) clip_slot.name = str(track_index) + '_Clip_Slot_' + str(scene_index) def _mode_value(self, value, sender): "method called each time the value of the mode selection changed" "it's been momentary overriden to avoid dysfunctionnement in the framework method" new_mode = self._modes_buttons.index(sender) if sender.is_momentary(): #self._parent.log_message(sender.message_identifier()) if value > 0: #self._parent.log_message("value = "+str(value)) mode_observer = MomentaryModeObserver() mode_observer.set_mode_details(new_mode, self._controls_for_mode(new_mode), self._get_public_mode_index) self._modes_heap.append((new_mode, sender, mode_observer)) self._update_mode() elif self._modes_heap[-1][1] == sender and not self._modes_heap[-1][2].is_mode_momentary(): #self._parent.log_message("sender trouve") self.set_mode(new_mode) else: #TODO: comprendre comment le framework est sense fonctionner et remplacer supprimer cet modif du framework self.set_mode(new_mode) self._update_mode() else: #self._parent.log_message("boutton pas trouve") self.set_mode(new_mode) def _setup_step_sequencer(self, as_active): if(self._stepseq!=None): if as_active: self._stepseq._force_update = True self._stepseq._is_active = True self._stepseq.set_enabled(True) self._stepseq._on_notes_changed() self._stepseq._update_seq_buttons() else: self._stepseq._is_active = False self._stepseq.set_enabled(False) def _set_browser_control(self, as_active): self._browser_control.remove_value_listener(self._browser_control_value) if as_active: self._browser_control.add_value_listener(self._browser_control_value) def _browser_control_value(self, value): if value != 64: all_scenes = self.song().scenes selected_scene = self.song().view.selected_scene selected_scene_index = list(all_scenes).index(selected_scene) new_selected_scene_index = max(0, min(selected_scene_index + (value-64), len(list(all_scenes))-1) ) self.song().view.selected_scene = all_scenes[new_selected_scene_index] session_offset = self._session.scene_offset() if new_selected_scene_index > session_offset + 15: self._session.set_offsets(self._session.track_offset(), new_selected_scene_index - 15) if new_selected_scene_index < session_offset: self._session.set_offsets(self._session.track_offset(), new_selected_scene_index) def _set_browser_button(self, as_active): self._browser_button.remove_value_listener(self._browser_button_value) if as_active: self._browser_button.add_value_listener(self._browser_button_value) def _browser_button_value(self, value): if value != 0: if self._mode_index == 2: self.song().view.highlighted_clip_slot.fire() else: self.song().view.selected_scene.fire_as_selected() def _set_scale_control(self, as_active): self._divide_control.remove_value_listener(self._translation_selector._scale_index_value) self._move_control.remove_value_listener(self._translation_selector._scale_offset_value) if as_active: self._divide_control.add_value_listener(self._translation_selector._scale_index_value) self._move_control.add_value_listener(self._translation_selector._scale_offset_value) def _update_session_translation(self): if self._mode_index == 0 or self._mode_index == 1: if self._translation_selector.mode(): self._session.set_offsets(8,self._session.scene_offset()) else: self._session.set_offsets(0,self._session.scene_offset()) def on_selected_track_changed(self): all_tracks = ((self.song().tracks + self.song().return_tracks)) selected_track = self.song().view.selected_track self._previous_track_index = self._selected_track_index self._selected_track_index = list(all_tracks).index(selected_track) self.update()
class QuNeo(ControlSurface): """ Script for Keith McMillen's QuNeo Multi-Touchpad Controller """ __module__ = __name__ _active_instances = [] def _combine_active_instances(): support_devices = False for instance in QuNeo._active_instances: support_devices |= instance._device_component != None track_offset = 0 for instance in QuNeo._active_instances: instance._activate_combination_mode(track_offset, support_devices) track_offset += instance._session.width() _combine_active_instances = staticmethod(_combine_active_instances) def __init__(self, c_instance): ControlSurface.__init__(self, c_instance) self.set_suppress_rebuild_requests(True) self._suppress_session_highlight = True self._suppress_send_midi = True self._suggested_input_port = 'QUNEO' self._suggested_output_port = 'QUNEO' self.num_tracks = 7 self.num_scenes = 4 self.session = None self.mixer = None self.transport = None self.led_value = None self._note_input = [] self.shift_button = None self.sequencer_button = None self.launch_button = None self.seq_offset_down = None self.seq_offset_up = None self.seq_offset_left = None self.seq_offset_right = None self.stop_all_clips = None self.track_bank_right = None self.track_bank_left = None self.scene_bank_down = None self.scene_bank_up = None self.beat_table = [] self.sends = [] self.arm_buttons = None self.mute_buttons = None self.solo_buttons = None self.shift_buttons = [] self.sequencer_buttons = None self.scene_launch_buttons = None self.stop_track_buttons = None self.clip_slot_buttons = None self.instrument_buttons = None self.volume_control = None self.pan_control = None self.current_mode = 0 self.set_shift_button(ConfigurableButtonElement(True, MIDI_NOTE_TYPE, PAD_CHANNEL, SHIFT_BUTTON, 127)) self._setup_transport_control() self._setup_mixer_control() self._setup_session_control() self.session.set_mixer(self.mixer) self._shift_mode(0) self._set_mode(0) app = Live.Application.get_application() maj = app.get_major_version() min = app.get_minor_version() bug = app.get_bugfix_version() self.show_message(str(maj) + '.' + str(min) + '.' + str(bug)) self.set_suppress_rebuild_requests(False) def disconnect(self): self.mixer self.session if self.shift_button != None: self.shift_button.remove_value_listener(self._shift_value) self.shift_button = None if self.shift_buttons != None: for button in self.shift_buttons: button.remove_value_listener(self._shift_buttons_value) self.shift_buttons = None self._note_input = None ControlSurface.disconnect(self) def refresh_state(self): ControlSurface.refresh_state(self) def set_shift_button(self, button): if not (button == None or isinstance(button, ButtonElement)): raise AssertionError if self.shift_button != button: if self.shift_button != None: self.shift_button.remove_value_listener(self._shift_value) self.shift_button = button self.shift_button != None and self.shift_button.add_value_listener(self._shift_value) def update_mode(self, mode): if mode != None: self._set_mode(mode) self.current_mode = mode def set_shift_buttons(self, buttons): if buttons != None: if self.shift_buttons != buttons: self.shift_buttons.remove_value_listener(self._shift_buttons_value) self.shift_buttons = buttons if self.shift_buttons != None: for button in self.shift_buttons: raise isinstance(button, ButtonElement) or AssertionError button.add_value_listener(self._shift_buttons_value, identify_sender=True) else: if self.shift_buttons != None: for button in self.shift_buttons: button.remove_value_listener(self._shift_buttons_value) self.shift_buttons = None def _shift_buttons_value(self, value, sender): raise self.shift_buttons != None or AssertionError raise value in range(128) or AssertionError mode = int(sender._note * 0.5) self.update_mode(mode) def _shift_value(self, value): if not value in range(128): raise AssertionError raise self.shift_button != None or AssertionError value != 0 and self._shift_mode(1) self.shift_button.turn_on() else: self._shift_mode(0) self.shift_button.turn_off() def _shift_mode(self, value): if value != 0: self.set_suppress_rebuild_requests(True) self._reassign_grid(0) self._reassign_mixer_control(1) self.set_suppress_rebuild_requests(False) else: None self._set_mode(self.current_mode) self._reassign_mixer_control(1) def _update_grid(self): if self.sequencer_buttons != None: self.session.set_sequencer_buttons(self.sequencer_buttons) else: self.session.set_sequencer_buttons(None) if self.seq_offset_left != None and self.seq_offset_right != None: self.session.set_seq_measure_offset(self.seq_offset_left, self.seq_offset_right) else: self.session.set_seq_measure_offset(None, None) if self.seq_offset_up != None and self.seq_offset_down != None: self.session.set_seq_note_offset(self.seq_offset_up, self.seq_offset_down) else: self.session.set_seq_note_offset(None, None) if self.launch_button != None: self.session.set_slot_launch_button(self.launch_button) else: self.session.set_slot_launch_button(None) if self.scene_launch_buttons != None: for index in range(len(self.scene_launch_buttons)): self.session.scene(index).set_launch_button(self.scene_launch_buttons[index]) else: for index in range(4): self.session.scene(index).set_launch_button(None) if self.stop_track_buttons != None: self.session.set_stop_track_clip_buttons(tuple(self.stop_track_buttons)) else: self.session.set_stop_track_clip_buttons(None) if self.stop_all_clips != None: self.session.set_stop_all_clips_button(self.stop_all_clips) else: self.session.set_stop_all_clips_button(None) if self.track_bank_right != None and self.track_bank_left != None: self.session.set_track_bank_buttons(self.track_bank_right, self.track_bank_left) else: self.session.set_track_bank_buttons(None, None) if self.scene_bank_up != None and self.scene_bank_down != None: self.session.set_scene_bank_buttons(self.scene_bank_up, self.scene_bank_down) else: self.session.set_scene_bank_buttons(None, None) for row in range(4): for col in range(7): self.clip = self.session.scene(row).clip_slot(col) if self.clip_slot_buttons != None: self.clip.set_triggered_to_play_value(30) self.clip.set_triggered_to_record_value(RED_HI) self.clip.set_started_value(30) self.clip.set_recording_value(RED_HI) self.clip.set_stopped_value(80) self.clip.set_triggered_to_record_value(6) self.clip.set_launch_button(self.clip_slot_buttons[row][col]) else: self.clip.set_launch_button(None) def turn_off_all_buttons(self): self.arm_buttons = None self.mute_buttons = None self.solo_buttons = None self.scene_launch_buttons = None self.stop_track_buttons = None if self.clip_slot_buttons != None: for row in range(4): for col in range(7): button = self.clip_slot_buttons[row][col] button.turn_off() self.clip_slot_buttons = None if self.shift_buttons != None: for button in self.shift_buttons: button.turn_off() button.remove_value_listener(self._shift_buttons_value) if self.sequencer_buttons != None: for button in self.sequencer_buttons: button.count = 0 button.note_on() self.instrument_buttons = None self.shift_buttons = None self.sequencer_buttons = None self.clip_slot_buttons = None self.launch_button = None self.stop_all_clips = None self.track_bank_left = None self.track_bank_right = None self.scene_bank_up = None self.scene_bank_down = None self.seq_offset_left = None self.seq_offset_right = None self.seq_offset_up = None self.seq_offset_down = None def _set_mode(self, mode): self.turn_off_all_buttons() if mode == 0: self.stop_track_buttons = [] self.scene_launch_buttons = [] self.track_bank_left = self.button(PAD_CHANNEL, SESSION_LEFT) self.track_bank_right = self.button(PAD_CHANNEL, SESSION_RIGHT) self.scene_bank_up = self.button(PAD_CHANNEL, SESSION_UP) self.scene_bank_down = self.button(PAD_CHANNEL, SESSION_DOWN) self.stop_all_clips = self.led_button(GRID_CHANNEL, STOP_ALL_CLIPS, 100) self.launch_button = self.led_button(GRID_CHANNEL, SLOT_LAUNCH, RED_HI) self.clip_slot_buttons = [] for row in range(4): self.clip_slot_buttons.append([]) for col in range(7): self.clip_slot_buttons[row].append(self.button(GRID_CHANNEL, CLIP_NOTE_MAP[row][col])) self.mute_buttons = [] self.solo_buttons = [] self.arm_buttons = [] for index in range(7): self.mute_buttons.append(self.led_button(GRID_CHANNEL, TRACK_MUTE[index], GREEN_HI)) self.solo_buttons.append(self.led_button(GRID_CHANNEL, TRACK_SOLO[index], ORANGE_HI)) self.arm_buttons.append(self.led_button(GRID_CHANNEL, TRACK_ARM[index], RED_HI)) self.stop_track_buttons.append(self.led_button(GRID_CHANNEL, STOP_TRACK[index], 100)) for scene in range(4): self.scene_launch_buttons.append(self.led_button(GRID_CHANNEL, SCENE_LAUNCH[scene], GREEN_LO)) self._update_session() self._update_grid() elif mode == 1: self.seq_offset_left = self.button(PAD_CHANNEL, SESSION_LEFT) self.seq_offset_right = self.button(PAD_CHANNEL, SESSION_RIGHT) self.seq_offset_up = self.button(PAD_CHANNEL, SESSION_UP) self.seq_offset_down = self.button(PAD_CHANNEL, SESSION_DOWN) self.sequencer_buttons = [] for row in range(8): for col in range(8): self.sequencer_buttons.append(self.led_button(GRID_CHANNEL, CLIP_NOTE_MAP[row][col], GREEN_HI)) self._update_session() self._update_grid() self.session.clear_led() self.session.update_notes() self.session.on_device_changed() else: self.track_bank_left = self.button(PAD_CHANNEL, SESSION_LEFT) self.track_bank_right = self.button(PAD_CHANNEL, SESSION_RIGHT) self.scene_bank_up = self.button(PAD_CHANNEL, SESSION_UP) self.scene_bank_down = self.button(PAD_CHANNEL, SESSION_DOWN) self._update_session() self._update_grid() def _reassign_grid(self, value): if value == 0: self.turn_off_all_buttons() self.shift_buttons = [] for index in range(2): self.shift_buttons.append(self.led_button(GRID_CHANNEL, TRACK_ARM[index], 127)) if index == self.current_mode: self.shift_buttons[index].send_value(127, True) else: self.shift_buttons[index].send_value(40, True) self._update_session() self._update_grid() else: None def button(self, channel, value): is_momentary = True if value != -1: return ButtonElement(is_momentary, MIDI_NOTE_TYPE, channel, value) else: return None def led_button(self, channel, value, vel): is_momentary = True if value != -1: return ConfigurableButtonElement(is_momentary, MIDI_NOTE_TYPE, channel, value, vel) else: return None def slider(self, channel, value): if value != -1: return SliderElement(MIDI_CC_TYPE, channel, value) else: return None def assign_encoder(self, channel, value): if value != -1: return EncoderElement(MIDI_CC_TYPE, channel, value, Live.MidiMap.MapMode.relative_two_compliment) else: return None def _reassign_mixer_control(self, shift_value): if shift_value == 1: for index in range(2): self.sends.append(self.slider(SLIDER_CHANNEL, SELECTED_SENDS[index])) self.volume_control = self.slider(SLIDER_CHANNEL, SELECTED_VOL) self.pan_control = self.slider(SLIDER_CHANNEL, SELECTED_PAN) if self.sends != None: self.mixer.selected_strip().set_send_controls(tuple(self.sends)) else: self.mixer.selected_strip().set_send_controls(tuple(None)) if self.volume_control != None: self.mixer.selected_strip().set_volume_control(self.volume_control) else: self.mixer.selected_strip().set_volume_control(None) if self.pan_control != None: self.mixer.selected_strip().set_pan_control(self.pan_control) else: self.mixer.selected_strip().set_pan_control(None) def _update_session(self): if self.shift_buttons != None: self.set_shift_buttons(self.shift_buttons) else: self.set_shift_buttons(None) for index in range(7): if self.arm_buttons != None: self.mixer.channel_strip(index).set_arm_button(self.arm_buttons[index]) else: self.mixer.channel_strip(index).set_arm_button(None) if self.solo_buttons != None: self.mixer.channel_strip(index).set_solo_button(self.solo_buttons[index]) else: self.mixer.channel_strip(index).set_solo_button(None) if self.mute_buttons != None: self.mixer.channel_strip(index).set_invert_mute_feedback(True) self.mixer.channel_strip(index).set_mute_button(self.mute_buttons[index]) else: self.mixer.channel_strip(index).set_mute_button(None) def _setup_transport_control(self): self.transport = SpecialTransportComponent() self.transport.set_metronome_button(self.led_button(PAD_CHANNEL, METRONOME, 127)) self.transport.set_play_button(self.led_button(PAD_CHANNEL, PLAY, 127)) self.transport.set_stop_button(self.led_button(PAD_CHANNEL, STOP, 127)) self.transport.set_record_button(self.led_button(PAD_CHANNEL, REC, 127)) self.transport.set_overdub_button(self.led_button(PAD_CHANNEL, OVERDUB, 127)) self.transport.set_tempo_buttons(self.led_button(PAD_CHANNEL, TEMPO_UP, 127), self.led_button(PAD_CHANNEL, TEMPO_DOWN, 127)) def _setup_mixer_control(self): self.mixer = SpecialMixerComponent(self.num_tracks, self) self.mixer.name = 'Mixer' self.mixer.set_track_offset(0) self.mixer.set_select_buttons(self.button(PAD_CHANNEL, TRACK_RIGHT), self.button(PAD_CHANNEL, TRACK_LEFT)) self.mixer.set_crossfader_control(self.slider(SLIDER_CHANNEL, CROSSFADER)) for index in range(4): self.mixer.channel_strip(index).set_volume_control(self.slider(SLIDER_CHANNEL, TRACK_VOL[index])) self.num_o_tracks = self.song().visible_tracks if self.num_o_tracks != None: index_count = -1 index_table = [] for index in self.song().visible_tracks: index_count += 1 if index.has_midi_output != True: index_table.append(index_count) else: None if index_table != None: for index in range(len(index_table)): x = index_table[index] if x > 3: None else: None def _setup_session_control(self): self.session = SpecialSessionComponent(self.num_tracks, self.num_scenes, self) self.session.set_offsets(0, 0) self.session.set_select_buttons(self.button(PAD_CHANNEL, SCENE_DOWN), self.button(PAD_CHANNEL, SCENE_UP)) self.session.set_clip_loop_start(self.slider(SLIDER_CHANNEL, 6)) self.session.set_clip_loop_length(self.slider(SLIDER_CHANNEL, 7)) def _on_selected_scene_changed(self): ControlSurface._on_selected_scene_changed(self) def _on_selected_track_changed(self): ControlSurface._on_selected_track_changed(self) def _activate_combination_mode(self, track_offset, support_devices): self._session.link_with_track_offset(track_offset)
def _setup_device_and_transport_control(self): is_momentary = True # self._device = DeviceComponent() # self._device.name = 'Device_Component' # uses BestBankDeviceComponent as pseudo for Device_Component self._device = BestBankDeviceComponent( device_selection_follows_track_selection=True) self._device.name = u'Device_Component' # device_bank_buttons = [] device_param_controls = [] # Accounts for mappings on top two rows of MFT for index in range(16): # handles all 16 encoder knobs device_param_controls.append(self._ctrl_map[PARAMCONTROL[index]]) for index in range(4): # 1st row, shift encoder hold device_param_controls.append( self._shift_encoder_map[PARAMCONTROL[index]]) for index in range(6): # 2nd row & left-half of 3rd row, CC hold device_param_controls.append(self._note_map[PARAMCONTROL[index + 4]]) # Accounts for mappings on third row of MFT # for index in range(4): # device_param_controls.append(self._shift_encoder_map[PARAMCONTROL[index + 8]]) # device_bank_buttons.append(self._note_map[DEVICEBANK[index]]) # if None not in device_bank_buttons: # self._device.set_bank_buttons(tuple(device_bank_buttons)) if None not in device_param_controls: self._device.set_parameter_controls(tuple(device_param_controls)) self._device.set_on_off_button(self._shift_bank_map[DEVICEONOFF]) # self._device.set_bank_nav_buttons(self._shift_bank_map[DEVICEBANKNAVLEFT], self._shift_bank_map[DEVICEBANKNAVRIGHT]) self._device.set_bank_nav_buttons(self._note_map[DEVICEBANKNAVLEFT], self._note_map[DEVICEBANKNAVRIGHT]) self._device.set_lock_button(self._note_map[DEVICELOCK]) self.set_device_component(self._device) detail_view_toggler = DetailViewControllerComponent() detail_view_toggler.name = 'Detail_View_Control' detail_view_toggler.set_device_clip_toggle_button( self._shift_bank_map[CLIPTRACKVIEW]) detail_view_toggler.set_detail_toggle_button( self._shift_bank_map[DETAILVIEW]) # detail_view_toggler.set_device_nav_buttons(self._note_map[DEVICENAVLEFT], self._note_map[DEVICENAVRIGHT] ) detail_view_toggler.set_device_nav_buttons( self._shift_bank_map[DEVICENAVLEFT], self._shift_bank_map[DEVICENAVRIGHT]) transport = SpecialTransportComponent() transport.name = 'Transport' transport.set_play_button(self._note_map[PLAY]) transport.set_stop_button(self._note_map[STOP]) transport.set_record_button(self._note_map[REC]) transport.set_nudge_buttons(self._note_map[NUDGEUP], self._note_map[NUDGEDOWN]) transport.set_undo_button(self._shift_bank_map[UNDO]) transport.set_redo_button(self._note_map[REDO]) transport.set_tap_tempo_button(self._note_map[TAPTEMPO]) transport.set_quant_toggle_button(self._note_map[RECQUANT]) transport.set_overdub_button(self._note_map[OVERDUB]) transport.set_metronome_button(self._note_map[METRONOME]) transport.set_tempo_control(self._ctrl_map[TEMPOCONTROL]) transport.set_loop_button(self._note_map[LOOP]) transport.set_seek_buttons(self._note_map[SEEKFWD], self._note_map[SEEKRWD]) transport.set_punch_buttons(self._note_map[PUNCHIN], self._note_map[PUNCHOUT])
class NanoKontrolShift(ControlSurface): __module__ = __name__ __doc__ = " NanoKontrolShift controller script " def __init__(self, c_instance): ControlSurface.__init__(self, c_instance) self._suppress_session_highlight = True self._suppress_send_midi = True # Turn off rebuild MIDI map until after we're done setting up self.log_message(time.strftime("%d.%m.%Y %H:%M:%S", time.localtime()) + "--------------= NanoKontrolShift log opened =--------------") # Writes message into Live's main log file. This is a ControlSurface method. with self.component_guard(): # OBJECTS self.session = None #session object self.mixer = None #mixer object self.view = None #clip/device view object self.device = None #device object self.transport = None #transport object # MODES self._shift_button = None self._shift_button_pressed = False self._alt_button = None self._alt_button_pressed = False self._ctrl_button = None self._ctrl_button_pressed = False # INITIALIZE MIXER, SESSIONS self._setup_session_control() # Setup the session object self._setup_mixer_control() # Setup the mixer object self._setup_view_control() # Setup the clip/view toggler self.session.set_mixer(self.mixer) # Bind mixer to session self._setup_device_control() # Setup the device object self._setup_transport_control() # Setup transport object self.set_device_component(self.device) # Bind device to control surface # SET INITIAL SESSION/MIXER AND MODIFIERS BUTTONS self._set_modifiers_buttons() self.__update_matrix() # self.set_highlighting_session_component(self.session) for component in self.components: component.set_enabled(True) # self._suppress_session_highlight = True self._suppress_send_midi = True # Turn rebuild back on, once we're done setting up def _setup_session_control(self): self.show_message("#################### SESSION: ON ##############################") is_momentary = True # CREATE SESSION, SET OFFSETS, BUTTONS NAVIGATION AND BUTTON MATRIX self.session = SessionComponent(num_tracks, num_scenes) #(num_tracks, num_scenes) self.session.set_offsets(0, 0) # self.session.set_scene_bank_buttons(ButtonElement(is_momentary, MIDI_CC_TYPE, CHANNEL, session_down), ButtonElement(is_momentary, MIDI_CC_TYPE, CHANNEL, session_up)) # self.session.set_track_bank_buttons(ButtonElement(is_momentary, MIDI_CC_TYPE, CHANNEL, session_right), ButtonElement(is_momentary, MIDI_CC_TYPE, CHANNEL, session_left)) # (right_button, left_button) This moves the "red box" selection set left & right. We'll use the mixer track selection instead... def _setup_mixer_control(self): is_momentary = True #CREATE MIXER, SET OFFSET (SPECIALMIXERCOMPONENT USES SPECIALCHANNELSTRIP THAT ALLOWS US TO UNFOLD TRACKS WITH TRACK SELECT BUTTON) self.mixer = SpecialMixerComponent(num_tracks, 0, False, False) # 4 tracks, 2 returns, no EQ, no filters self.mixer.name = 'Mixer' self.mixer.set_track_offset(0) #Sets start point for mixer strip (offset from left) def _setup_view_control(self): # CREATES OBJECT SO WE CAN TOGGLE DEVICE/CLIP, LOCK DEVICE self.view = ViewTogglerComponent(num_tracks, self) def _setup_device_control(self): # CREATE DEVICE TO ASSIGN PARAMETERS BANK self.device = DeviceComponent() self.device.name = 'Device_Component' def _setup_transport_control(self): # CREATE TRANSPORT DEVICE self.transport = SpecialTransportComponent(self) def _on_selected_scene_changed(self): # ALLOWS TO GRAB THE FIRST DEVICE OF A SELECTED TRACK IF THERE'S ANY ControlSurface._on_selected_track_changed(self) track = self.song().view.selected_track if (track.devices is not None): self._ignore_track_selection = True device_to_select = track.devices[0] self.song().view.select_device(device_to_select) self._device_component.set_device(device_to_select) self._ignore_track_selection = False """ LED ON, OFF, FLASH WITH SESSION CLIPS """ # UPDATING BUTTONS FROM CLIP MATRIX IN NK AS SESSION MOVES def __update_matrix(self): for scene_index in range(num_scenes): scene = self.session.scene(scene_index) for track_index in range(num_tracks): clip_slot = scene.clip_slot(track_index) button = clip_slot._launch_button_value.subject value_to_send = -1 if clip_slot._clip_slot != None: if clip_slot.has_clip(): value_to_send = 127 if clip_slot._clip_slot.clip.is_triggered: if clip_slot._clip_slot.clip.will_record_on_start: value_to_send = clip_slot._triggered_to_record_value else: value_to_send = clip_slot._triggered_to_play_value ''' elif clip_slot._clip_slot.clip.is_playing: if clip_slot._clip_slot.clip.is_recording: value_to_send = 127 ######### CLIPS PLAYING WILL FLASH for i in range(2000): if i % 50 == 0: button.send_value(127) else: button.send_value(0) else: for i in range(2000): if i % 50 == 0: button.send_value(127) else: button.send_value(0) ''' elif clip_slot._clip_slot.is_triggered: if clip_slot._clip_slot.will_record_on_start: value_to_send = clip_slot._triggered_to_record_value else: value_to_send = clip_slot._triggered_to_play_value elif clip_slot._clip_slot.is_playing: if clip_slot._clip_slot.is_recording: value_to_send = clip_slot._recording_value else: value_to_send = clip_slot._started_value elif clip_slot._clip_slot.controls_other_clips: value_to_send = 0 ''' if value_to_send in range(128): button.send_value(value_to_send) else: button.turn_off() ''' """ MODIFIERS, MODES, KEYS CONFIG """ #MODES ARE HERE: INITIALIZATIONS, DISCONNECTS BUTTONS, SLIDERS, ENCODERS def _clear_controls(self): # TURNING OFF ALL LEDS IN MATRIX self._turn_off_matrix() # SESSION resetsend_controls = [] self.mixer.send_controls = [] for scene_index in range(num_scenes): scene = self.session.scene(scene_index) scene.set_launch_button(None) for track_index in range(num_tracks): clip_slot = scene.clip_slot(track_index) clip_slot.set_launch_button(None) self.session.set_stop_track_clip_buttons(None) self.session.set_stop_all_clips_button(None) # REMOVE LISTENER TO SESSION MOVES if self.session.offset_has_listener(self.__update_matrix): self.session.remove_offset_listener(self.__update_matrix) self.session.set_stop_all_clips_button(None) # MIXER self.mixer._set_send_nav(None, None) for track_index in range(num_tracks): strip = self.mixer.channel_strip(track_index) strip.set_solo_button(None) strip.set_mute_button(None) strip.set_arm_button(None) resetsend_controls.append(None) strip.set_select_button(None) for i in range(12): self.mixer.send_controls.append(None) strip.set_send_controls(tuple(self.mixer.send_controls)) self.mixer.set_resetsend_buttons(tuple(resetsend_controls)) # VIEW self.view.set_device_nav_buttons(None, None) detailclip_view_controls = [] for track_index in range(num_tracks): detailclip_view_controls.append(None) self.view.set_buttons(tuple(detailclip_view_controls)) # DEVICE PARAMETERS device_param_controls = [] self.device.set_parameter_controls(tuple(device_param_controls)) self.device.set_on_off_button(None) self.device.set_lock_button(None) # TRANSPORT self.transport.set_stop_button(None) self.transport.set_play_button(None) self.transport.set_record_button(None) self.transport._set_quant_toggle_button(None) self.transport.set_metronome_button(None) self.transport._set_tempo_buttons(None, None) self.log_message("Controls Cleared") def _set_normal_mode(self): is_momentary = True self.mixer._set_send_nav(ButtonElement(is_momentary, MIDI_CC_TYPE, CHANNEL, send_up), ButtonElement(is_momentary, MIDI_CC_TYPE, CHANNEL, send_down)) for index in range(num_tracks): strip = self.mixer.channel_strip(index) strip.name = 'Mixer_ChannelStrip_' + str(index) self.mixer._update_send_index(self.mixer.sends_index) strip.set_volume_control(SliderElement(MIDI_CC_TYPE, CHANNEL, mixer_volumefader_cc[index])) self.mixer.send_controls[self.mixer.sends_index] = EncoderElement(MIDI_CC_TYPE, CHANNEL, mixer_sendknob_cc[index], Live.MidiMap.MapMode.absolute) strip.set_send_controls(tuple(self.mixer.send_controls)) strip._invert_mute_feedback = True ### SET ARM, SOLO, MUTE for index in range(num_tracks): strip = self.mixer.channel_strip(index) strip.set_send_controls(tuple(self.mixer.send_controls)) strip.set_solo_button(ButtonElement(is_momentary, MIDI_CC_TYPE, CHANNEL, track_solo_cc[index])) strip.set_mute_button(ButtonElement(is_momentary, MIDI_CC_TYPE, CHANNEL, track_mute_cc[index])) strip.set_arm_button(ButtonElement(is_momentary, MIDI_CC_TYPE, CHANNEL, track_arm_cc[index])) # self.transport.set_stop_button(ButtonElement(is_momentary, MIDI_CC_TYPE, CHANNEL, transport_stop_cc)) for i in range(12): self.mixer.send_controls.append(None) self.mixer.send_controls[self.mixer.sends_index] = EncoderElement(MIDI_CC_TYPE, CHANNEL, mixer_sendknob_cc[index], Live.MidiMap.MapMode.absolute) strip.set_send_controls(tuple(self.mixer.send_controls)) strip._invert_mute_feedback = True self.mixer._update_send_index(self.mixer.sends_index) def _set_alt_mode(self): is_momentary = True self.mixer._set_send_nav(ButtonElement(is_momentary, MIDI_CC_TYPE, CHANNEL, send_up), ButtonElement(is_momentary, MIDI_CC_TYPE, CHANNEL, send_down)) stop_track_controls = [] resetsend_controls = [] button = None buttons = None # SET SESSION TRACKSTOP, TRACK SELECT, RESET SEND KNOB for index in range(num_tracks): strip = self.mixer.channel_strip(index) strip.set_select_button(ButtonElement(is_momentary, MIDI_CC_TYPE, CHANNEL, track_select_cc[index])) button = ButtonElement(is_momentary, MIDI_CC_TYPE, CHANNEL, stop_track_cc[index]) stop_track_controls.append(button) buttons = ButtonElement(is_momentary, MIDI_CC_TYPE, CHANNEL, track_resetsend_cc[index]) resetsend_controls.append(buttons) self.session.set_stop_track_clip_buttons(tuple(stop_track_controls)) self.mixer.set_resetsend_buttons(tuple(resetsend_controls)) self.mixer._update_send_index(self.mixer.sends_index) def _set_ctrl_mode(self): # CLIP/DEVICE VIEW TOGGLE is_momentary = True self.view.set_device_nav_buttons(ButtonElement(is_momentary, MIDI_CC_TYPE, CHANNEL, device_left_cc), ButtonElement(is_momentary, MIDI_CC_TYPE, CHANNEL, device_right_cc)) button = None detailclip_view_controls = [] for index in range(num_tracks): button = ButtonElement(not is_momentary, MIDI_CC_TYPE, CHANNEL, detailclip_view_cc[index]) detailclip_view_controls.append(button) self.view.set_buttons(tuple(detailclip_view_controls)) # DEVICE ON/OFF, LOCK AND PARAMETERS device_param_controls = [] onoff_control = ButtonElement(is_momentary, MIDI_CC_TYPE, CHANNEL, onoff_device_cc) setlock_control = ButtonElement(is_momentary, MIDI_CC_TYPE, CHANNEL, lock_device_cc) for index in range(num_tracks): knob = None knob = EncoderElement(MIDI_CC_TYPE, CHANNEL, device_param_cc[index], Live.MidiMap.MapMode.absolute) device_param_controls.append(knob) if None not in device_param_controls: self.device.set_parameter_controls(tuple(device_param_controls)) self.device.set_on_off_button(onoff_control) self.device.set_lock_button(setlock_control) # TRANSPORT # self.transport.set_stop_button(ButtonElement(is_momentary, MIDI_CC_TYPE, CHANNEL, transport_stop_cc)) # self.transport.set_play_button(ButtonElement(not is_momentary, MIDI_CC_TYPE, CHANNEL, transport_play_cc)) # self.transport.set_record_button(ButtonElement(is_momentary, MIDI_CC_TYPE, CHANNEL, transport_record_cc)) self.transport._set_quant_toggle_button(ButtonElement(is_momentary, MIDI_CC_TYPE, CHANNEL, transport_quantization_cc)) self.transport.set_metronome_button(ButtonElement(not is_momentary, MIDI_CC_TYPE, CHANNEL, transport_metronome_cc)) self.transport._set_tempo_buttons(ButtonElement(is_momentary, MIDI_CC_TYPE, CHANNEL, transport_tempodown_cc), ButtonElement(is_momentary, MIDI_CC_TYPE, CHANNEL, transport_tempoup_cc)) # SESSION STOP ALL CLIPS AND SCENE LAUNCH self.session.set_stop_all_clips_button(ButtonElement(is_momentary, MIDI_CC_TYPE, CHANNEL, session_stopall_cc)) for index in range(num_scenes): self.session.scene(index).set_launch_button(ButtonElement(is_momentary, MIDI_CC_TYPE, CHANNEL, session_scenelaunch_cc[index])) def _set_modifiers_buttons(self): is_momentary = True self._shift_button = ButtonElement(not is_momentary, MIDI_CC_TYPE, CHANNEL, shift_mod) self._alt_button = ButtonElement(not is_momentary, MIDI_CC_TYPE, CHANNEL, alt_mod) self._ctrl_button = ButtonElement(not is_momentary, MIDI_CC_TYPE, CHANNEL, ctrl_mod) if (self._shift_button != None): self._shift_button.add_value_listener(self._shift_value) if (self._alt_button != None): self._alt_button.add_value_listener(self._alt_value) if (self._ctrl_button != None): self._ctrl_button.add_value_listener(self._ctrl_value) #INIT NORMAL MODE self._manage_modes(0) # MODIFIERS LISTENERS FUNCS ARE HERE def _shift_value(self, value): assert isinstance(value, int) assert isinstance(self._shift_button, ButtonElement) if value == 127: if self._shift_button_pressed is False: self._unpress_modes() self._shift_button_pressed = True self._manage_modes(0) def _alt_value(self, value): assert isinstance(value, int) assert isinstance(self._alt_button, ButtonElement) if value == 127: if self._alt_button_pressed is False: self._unpress_modes() self._alt_button_pressed = True self._manage_modes(2) def _ctrl_value(self, value): assert isinstance(value, int) assert isinstance(self._ctrl_button, ButtonElement) if value == 127: if self._ctrl_button_pressed is False: self._unpress_modes() self._ctrl_button_pressed = True self._manage_modes(3) def _manage_modes(self, mode_index): if mode_index == 0: self._clear_controls() self._set_normal_mode() # self._shift_button.turn_on() self._alt_button.turn_on() self._ctrl_button.turn_on() self.log_message("NORMAL ON") elif mode_index == 2: self._clear_controls() self._set_alt_mode() self._alt_button.turn_on() self._shift_button.turn_off() self._ctrl_button.turn_off() self.log_message("ALT ON") elif mode_index == 3: self._clear_controls() self._set_ctrl_mode() self._ctrl_button.turn_on() self._shift_button.turn_off() self._alt_button.turn_off() self.log_message("CTRL ON") def _unpress_modes(self): self._shift_button_pressed = False self._alt_button_pressed = False self._ctrl_button_pressed = False def _turn_off_matrix(self): for index in range(24): self._send_midi(tuple([176,index+16,0])) def disconnect(self): """clean things up on disconnect""" self.log_message(time.strftime("%d.%m.%Y %H:%M:%S", time.localtime()) + "--------------= NanoKontrolShift log closed =--------------") #Create entry in log file self._clear_controls() self.session = None self.mixer = None self.view = None self.device = None self.transport = None # MODES self._shift_button = None self._alt_button = None self._ctrl_button = None # SENDS self.send_button_up = None self.send_button_down = None self.send_controls = [] self.send_reset = [] self.set_device_component(None) ControlSurface.disconnect(self) return None
class NanoKontrolShift(ControlSurface): __module__ = __name__ __doc__ = " NanoKontrolShift controller script " def __init__(self, c_instance): ControlSurface.__init__(self, c_instance) self._suppress_session_highlight = True self._suppress_send_midi = True # Turn off rebuild MIDI map until after we're done setting up self.log_message( time.strftime("%d.%m.%Y %H:%M:%S", time.localtime()) + "--------------= NanoKontrolShift log opened =--------------" ) # Writes message into Live's main log file. This is a ControlSurface method. with self.component_guard(): # OBJECTS self.session = None # session object self.mixer = None # mixer object self.view = None # clip/device view object self.device = None # device object self.transport = None # transport object # MODES self._shift_button = None self._shift_button_pressed = False self._alt_button = None self._alt_button_pressed = False self._ctrl_button = None self._ctrl_button_pressed = False # INITIALIZE MIXER, SESSIONS self._setup_session_control() # Setup the session object self._setup_mixer_control() # Setup the mixer object self._setup_view_control() # Setup the clip/view toggler self.session.set_mixer(self.mixer) # Bind mixer to session self._setup_device_control() # Setup the device object self._setup_transport_control() # Setup transport object self.set_device_component( self.device) # Bind device to control surface # SET INITIAL SESSION/MIXER AND MODIFIERS BUTTONS self._set_modifiers_buttons() self.__update_matrix() self.set_highlighting_session_component(self.session) for component in self.components: component.set_enabled(True) # self._suppress_session_highlight = True self._suppress_send_midi = True # Turn rebuild back on, once we're done setting up def _setup_session_control(self): self.show_message( "#################### SESSION: ON ##############################") is_momentary = True # CREATE SESSION, SET OFFSETS, BUTTONS NAVIGATION AND BUTTON MATRIX self.session = SessionComponent(num_tracks, num_scenes) # (num_tracks, num_scenes) self.session.set_offsets(0, 0) # self.session.set_scene_bank_buttons(ButtonElement(is_momentary, MIDI_CC_TYPE, CHANNEL, session_down), ButtonElement(is_momentary, MIDI_CC_TYPE, CHANNEL, session_up)) self.session.set_track_bank_buttons( ButtonElement(is_momentary, MIDI_CC_TYPE, CHANNEL, session_right), ButtonElement(is_momentary, MIDI_CC_TYPE, CHANNEL, session_left) ) # (right_button, left_button) This moves the "red box" selection set left & right. We'll use the mixer track selection instead... def _setup_mixer_control(self): is_momentary = True # CREATE MIXER, SET OFFSET (SPECIALMIXERCOMPONENT USES SPECIALCHANNELSTRIP THAT ALLOWS US TO UNFOLD TRACKS WITH TRACK SELECT BUTTON) self.mixer = SpecialMixerComponent( num_tracks, 0, False, False) # 4 tracks, 2 returns, no EQ, no filters self.mixer.name = 'Mixer' self.mixer.set_track_offset( 0) # Sets start point for mixer strip (offset from left) def _setup_view_control(self): # CREATES OBJECT SO WE CAN TOGGLE DEVICE/CLIP, LOCK DEVICE self.view = ViewTogglerComponent(num_tracks, self) def _setup_device_control(self): # CREATE DEVICE TO ASSIGN PARAMETERS BANK self.device = DeviceComponent() self.device.name = 'Device_Component' def _setup_transport_control(self): # CREATE TRANSPORT DEVICE self.transport = SpecialTransportComponent(self) def _on_selected_scene_changed(self): # ALLOWS TO GRAB THE FIRST DEVICE OF A SELECTED TRACK IF THERE'S ANY ControlSurface._on_selected_track_changed(self) track = self.song().view.selected_track if (track.devices is not None): self._ignore_track_selection = True device_to_select = track.devices[0] self.song().view.select_device(device_to_select) self._device_component.set_device(device_to_select) self._ignore_track_selection = False """ LED ON, OFF, FLASH WITH SESSION CLIPS """ # UPDATING BUTTONS FROM CLIP MATRIX IN NK AS SESSION MOVES def __update_matrix(self): for scene_index in range(num_scenes): scene = self.session.scene(scene_index) for track_index in range(num_tracks): clip_slot = scene.clip_slot(track_index) button = clip_slot._launch_button_value.subject value_to_send = -1 if clip_slot._clip_slot != None: if clip_slot.has_clip(): value_to_send = 127 if clip_slot._clip_slot.clip.is_triggered: if clip_slot._clip_slot.clip.will_record_on_start: value_to_send = clip_slot._triggered_to_record_value else: value_to_send = clip_slot._triggered_to_play_value ''' elif clip_slot._clip_slot.clip.is_playing: if clip_slot._clip_slot.clip.is_recording: value_to_send = 127 ######### CLIPS PLAYING WILL FLASH for i in range(2000): if i % 50 == 0: button.send_value(127) else: button.send_value(0) else: for i in range(2000): if i % 50 == 0: button.send_value(127) else: button.send_value(0) ''' elif clip_slot._clip_slot.is_triggered: if clip_slot._clip_slot.will_record_on_start: value_to_send = clip_slot._triggered_to_record_value else: value_to_send = clip_slot._triggered_to_play_value elif clip_slot._clip_slot.is_playing: if clip_slot._clip_slot.is_recording: value_to_send = clip_slot._recording_value else: value_to_send = clip_slot._started_value elif clip_slot._clip_slot.controls_other_clips: value_to_send = 0 ''' if value_to_send in range(128): button.send_value(value_to_send) else: button.turn_off() ''' """ MODIFIERS, MODES, KEYS CONFIG """ # MODES ARE HERE: INITIALIZATIONS, DISCONNECTS BUTTONS, SLIDERS, ENCODERS def _clear_controls(self): # TURNING OFF ALL LEDS IN MATRIX self._turn_off_matrix() # SESSION resetsend_controls = [] self.mixer.send_controls = [] for scene_index in range(num_scenes): scene = self.session.scene(scene_index) scene.set_launch_button(None) for track_index in range(num_tracks): clip_slot = scene.clip_slot(track_index) clip_slot.set_launch_button(None) self.session.set_stop_track_clip_buttons(None) self.session.set_stop_all_clips_button(None) # REMOVE LISTENER TO SESSION MOVES if self.session.offset_has_listener(self.__update_matrix): self.session.remove_offset_listener(self.__update_matrix) self.session.set_stop_all_clips_button(None) # MIXER self.mixer._set_send_nav(None, None) for track_index in range(num_tracks): strip = self.mixer.channel_strip(track_index) strip.set_solo_button(None) strip.set_mute_button(None) strip.set_arm_button(None) resetsend_controls.append(None) strip.set_select_button(None) for i in range(12): self.mixer.send_controls.append(None) strip.set_send_controls(tuple(self.mixer.send_controls)) self.mixer.set_resetsend_buttons(tuple(resetsend_controls)) # VIEW self.view.set_device_nav_buttons(None, None) detailclip_view_controls = [] for track_index in range(num_tracks): detailclip_view_controls.append(None) self.view.set_buttons(tuple(detailclip_view_controls)) # DEVICE PARAMETERS device_param_controls = [] self.device.set_parameter_controls(tuple(device_param_controls)) self.device.set_on_off_button(None) self.device.set_lock_button(None) # TRANSPORT self.transport.set_stop_button(None) self.transport.set_play_button(None) self.transport.set_record_button(None) self.transport._set_quant_toggle_button(None) self.transport.set_metronome_button(None) self.transport._set_tempo_buttons(None, None) self.log_message("Controls Cleared") def _set_normal_mode(self): is_momentary = True self.mixer._set_send_nav( ButtonElement(is_momentary, MIDI_CC_TYPE, CHANNEL, send_up), ButtonElement(is_momentary, MIDI_CC_TYPE, CHANNEL, send_down)) for index in range(num_tracks): strip = self.mixer.channel_strip(index) strip.name = 'Mixer_ChannelStrip_' + str(index) self.mixer._update_send_index(self.mixer.sends_index) strip.set_volume_control( SliderElement(MIDI_CC_TYPE, CHANNEL, mixer_volumefader_cc[index])) self.mixer.send_controls[self.mixer.sends_index] = EncoderElement( MIDI_CC_TYPE, CHANNEL, mixer_sendknob_cc[index], Live.MidiMap.MapMode.absolute) strip.set_send_controls(tuple(self.mixer.send_controls)) strip._invert_mute_feedback = True ### SET ARM, SOLO, MUTE for index in range(num_tracks): strip = self.mixer.channel_strip(index) strip.set_send_controls(tuple(self.mixer.send_controls)) strip.set_solo_button( ButtonElement(is_momentary, MIDI_CC_TYPE, CHANNEL, track_solo_cc[index])) strip.set_mute_button( ButtonElement(is_momentary, MIDI_CC_TYPE, CHANNEL, track_mute_cc[index])) strip.set_arm_button( ButtonElement(is_momentary, MIDI_CC_TYPE, CHANNEL, track_arm_cc[index])) # self.transport.set_stop_button(ButtonElement(is_momentary, MIDI_CC_TYPE, CHANNEL, transport_stop_cc)) for i in range(12): self.mixer.send_controls.append(None) self.mixer.send_controls[self.mixer.sends_index] = EncoderElement( MIDI_CC_TYPE, CHANNEL, mixer_sendknob_cc[index], Live.MidiMap.MapMode.absolute) strip.set_send_controls(tuple(self.mixer.send_controls)) strip._invert_mute_feedback = True self.mixer._update_send_index(self.mixer.sends_index) def _set_alt_mode(self): is_momentary = True self.mixer._set_send_nav( ButtonElement(is_momentary, MIDI_CC_TYPE, CHANNEL, send_up), ButtonElement(is_momentary, MIDI_CC_TYPE, CHANNEL, send_down)) stop_track_controls = [] resetsend_controls = [] button = None buttons = None # SET SESSION TRACKSTOP, TRACK SELECT, RESET SEND KNOB for index in range(num_tracks): strip = self.mixer.channel_strip(index) strip.set_select_button( ButtonElement(is_momentary, MIDI_CC_TYPE, CHANNEL, track_select_cc[index])) button = ButtonElement(is_momentary, MIDI_CC_TYPE, CHANNEL, stop_track_cc[index]) stop_track_controls.append(button) buttons = ButtonElement(is_momentary, MIDI_CC_TYPE, CHANNEL, track_resetsend_cc[index]) resetsend_controls.append(buttons) self.session.set_stop_track_clip_buttons(tuple(stop_track_controls)) self.mixer.set_resetsend_buttons(tuple(resetsend_controls)) self.mixer._update_send_index(self.mixer.sends_index) def _set_ctrl_mode(self): # CLIP/DEVICE VIEW TOGGLE is_momentary = True self.view.set_device_nav_buttons( ButtonElement(is_momentary, MIDI_CC_TYPE, CHANNEL, device_left_cc), ButtonElement(is_momentary, MIDI_CC_TYPE, CHANNEL, device_right_cc)) button = None detailclip_view_controls = [] for index in range(num_tracks): button = ButtonElement(not is_momentary, MIDI_CC_TYPE, CHANNEL, detailclip_view_cc[index]) detailclip_view_controls.append(button) self.view.set_buttons(tuple(detailclip_view_controls)) # DEVICE ON/OFF, LOCK AND PARAMETERS device_param_controls = [] onoff_control = ButtonElement(is_momentary, MIDI_CC_TYPE, CHANNEL, onoff_device_cc) setlock_control = ButtonElement(is_momentary, MIDI_CC_TYPE, CHANNEL, lock_device_cc) for index in range(num_tracks): knob = None knob = EncoderElement(MIDI_CC_TYPE, CHANNEL, device_param_cc[index], Live.MidiMap.MapMode.absolute) device_param_controls.append(knob) if None not in device_param_controls: self.device.set_parameter_controls(tuple(device_param_controls)) self.device.set_on_off_button(onoff_control) self.device.set_lock_button(setlock_control) # TRANSPORT # self.transport.set_stop_button(ButtonElement(is_momentary, MIDI_CC_TYPE, CHANNEL, transport_stop_cc)) # self.transport.set_play_button(ButtonElement(not is_momentary, MIDI_CC_TYPE, CHANNEL, transport_play_cc)) # self.transport.set_record_button(ButtonElement(is_momentary, MIDI_CC_TYPE, CHANNEL, transport_record_cc)) self.transport._set_quant_toggle_button( ButtonElement(is_momentary, MIDI_CC_TYPE, CHANNEL, transport_quantization_cc)) self.transport.set_metronome_button( ButtonElement(not is_momentary, MIDI_CC_TYPE, CHANNEL, transport_metronome_cc)) self.transport._set_tempo_buttons( ButtonElement(is_momentary, MIDI_CC_TYPE, CHANNEL, transport_tempodown_cc), ButtonElement(is_momentary, MIDI_CC_TYPE, CHANNEL, transport_tempoup_cc)) # SESSION STOP ALL CLIPS AND SCENE LAUNCH self.session.set_stop_all_clips_button( ButtonElement(is_momentary, MIDI_CC_TYPE, CHANNEL, session_stopall_cc)) for index in range(num_scenes): self.session.scene(index).set_launch_button( ButtonElement(is_momentary, MIDI_CC_TYPE, CHANNEL, session_scenelaunch_cc[index])) def _set_modifiers_buttons(self): is_momentary = True self._shift_button = ButtonElement(not is_momentary, MIDI_CC_TYPE, CHANNEL, shift_mod) self._alt_button = ButtonElement(not is_momentary, MIDI_CC_TYPE, CHANNEL, alt_mod) self._ctrl_button = ButtonElement(not is_momentary, MIDI_CC_TYPE, CHANNEL, ctrl_mod) if (self._shift_button != None): self._shift_button.add_value_listener(self._shift_value) if (self._alt_button != None): self._alt_button.add_value_listener(self._alt_value) if (self._ctrl_button != None): self._ctrl_button.add_value_listener(self._ctrl_value) # INIT NORMAL MODE self._manage_modes(0) # MODIFIERS LISTENERS FUNCS ARE HERE def _shift_value(self, value): assert isinstance(value, int) assert isinstance(self._shift_button, ButtonElement) if value == 127: if self._shift_button_pressed is False: self._unpress_modes() self._shift_button_pressed = True self._manage_modes(0) def _alt_value(self, value): assert isinstance(value, int) assert isinstance(self._alt_button, ButtonElement) if value == 127: if self._alt_button_pressed is False: self._unpress_modes() self._alt_button_pressed = True self._manage_modes(2) def _ctrl_value(self, value): assert isinstance(value, int) assert isinstance(self._ctrl_button, ButtonElement) if value == 127: if self._ctrl_button_pressed is False: self._unpress_modes() self._ctrl_button_pressed = True self._manage_modes(3) def _manage_modes(self, mode_index): if mode_index == 0: self._clear_controls() self._set_normal_mode() # self._shift_button.turn_on() self._alt_button.turn_on() self._ctrl_button.turn_on() self.log_message("NORMAL ON") elif mode_index == 2: self._clear_controls() self._set_alt_mode() self._alt_button.turn_on() self._shift_button.turn_off() self._ctrl_button.turn_off() self.log_message("ALT ON") elif mode_index == 3: self._clear_controls() self._set_ctrl_mode() self._ctrl_button.turn_on() self._shift_button.turn_off() self._alt_button.turn_off() self.log_message("CTRL ON") def _unpress_modes(self): self._shift_button_pressed = False self._alt_button_pressed = False self._ctrl_button_pressed = False def _turn_off_matrix(self): for index in range(24): self._send_midi(tuple([176, index + 16, 0])) def disconnect(self): """clean things up on disconnect""" self.log_message( time.strftime("%d.%m.%Y %H:%M:%S", time.localtime()) + "--------------= NanoKontrolShift log closed =--------------" ) # Create entry in log file self._clear_controls() self.session = None self.mixer = None self.view = None self.device = None self.transport = None # MODES self._shift_button = None self._alt_button = None self._ctrl_button = None # SENDS self.send_button_up = None self.send_button_down = None self.send_controls = [] self.send_reset = [] self.set_device_component(None) ControlSurface.disconnect(self) return None