class MainSelectorComponent(ModeSelectorComponent): """ Class that reassigns the button on the launchpad to different functions """ #def log(self, message): # self._control_surface.log_message((' ' + message + ' ').center(50, '=')) def __init__(self, matrix, top_buttons, side_buttons, config_button, osd, control_surface): #verify matrix dimentions assert isinstance(matrix, ButtonMatrixElement) assert ((matrix.width() == 8) and (matrix.height() == 8)) assert isinstance(top_buttons, tuple) assert (len(top_buttons) == 8) assert isinstance(side_buttons, tuple) assert (len(side_buttons) == 8) assert isinstance(config_button, ButtonElement) ModeSelectorComponent.__init__(self) #super constructor #inject ControlSurface and OSD components (M4L) self._osd = osd self._control_surface = control_surface #initialize index variables self._mode_index = 0 #Inherited from parent self._main_mode_index = 0 #LP original modes self._sub_mode_list = [0, 0, 0, 0] for index in range(4): self._sub_mode_list[index] = 0 self.set_mode_buttons(top_buttons[4:]) if Settings.SESSION__STOP_BUTTONS:#session with bottom stop buttons clip_stop_buttons = [] for column in range(8): clip_stop_buttons.append(matrix.get_button(column,matrix.height()-1)) self._session = SpecialSessionComponent(matrix.width(), matrix.height()-1, clip_stop_buttons, self._control_surface, self) else:#no stop buttons self._session = SpecialSessionComponent(matrix.width(), matrix.height(), None, self._control_surface, self) #initialize _session variables self._session.set_osd(self._osd) self._session.name = 'Session_Control' #initialize _zooming variables self._zooming = DeprecatedSessionZoomingComponent(self._session, enable_skinning = True) self._zooming.name = 'Session_Overview' self._zooming.set_empty_value("Default.Button.Off") self._matrix = matrix self._side_buttons = side_buttons#launch buttons self._nav_buttons = top_buttons[:4]#arrow buttons self._config_button = config_button#used to reset launchpad self._all_buttons = [] for button in self._side_buttons + self._nav_buttons: self._all_buttons.append(button) #SubSelector changes the Mode using side buttons (ie. Pan, Volume, Send1, Send2, Stop, Solo, Activate, Arm) self._sub_modes = SubSelectorComponent(matrix, side_buttons, self._session, self._control_surface) self._sub_modes.name = 'Mixer_Modes' self._sub_modes._mixer.set_osd(self._osd) self._sub_modes.set_update_callback(self._update_control_channels) #User2 stepSequencer (Drum) self._stepseq = StepSequencerComponent(self._matrix, self._side_buttons, self._nav_buttons, self._control_surface) self._stepseq.set_osd(self._osd) #User2 stepSequencer (Melodic) self._stepseq2 = StepSequencerComponent2(self._matrix, self._side_buttons, self._nav_buttons, self._control_surface) self._stepseq2.set_osd(self._osd) #User1 Instrument controller (Scale) self._instrument_controller = InstrumentControllerComponent(self._matrix, self._side_buttons, self._nav_buttons, self._control_surface) self._instrument_controller.set_osd(self._osd) #self._instrument_controller = None #User1 Device controller (Fx or Instrument parameters) self._device_controller = DeviceComponent(control_surface = self._control_surface, matrix = self._matrix, side_buttons = self._side_buttons, top_buttons = self._nav_buttons) self._device_controller.set_osd(self._osd) self._init_session() self._all_buttons = tuple(self._all_buttons) def disconnect(self): for button in self._modes_buttons: button.remove_value_listener(self._mode_value) self._session = None self._zooming = None for button in self._all_buttons: button.set_on_off_values("DefaultButton.Disabled", "DefaultButton.Disabled") self._config_button.turn_off() self._matrix = None self._side_buttons = None self._nav_buttons = None self._config_button = None ModeSelectorComponent.disconnect(self) def session_component(self): return self._session def _update_mode(self): mode = self._modes_heap[-1][0] #get first value of last _modes_heap tuple. _modes_heap tuple structure is (mode, sender, observer) assert mode in range(self.number_of_modes()) # 8 for this script if self._main_mode_index == mode: if self._main_mode_index == 1: #user mode 1 and device controller and instrument mode self._sub_mode_list[self._main_mode_index] = (self._sub_mode_list[self._main_mode_index] + 1) % 3 self.update() elif self._main_mode_index == 2: #user mode 2 and step sequencer self._sub_mode_list[self._main_mode_index] = (self._sub_mode_list[self._main_mode_index] + 1) % 3 self.update() elif self._main_mode_index == 3: #Mixer mode self.update() else: #Session mode self._sub_mode_list[self._main_mode_index] = 0 self._mode_index = 0 else: self._main_mode_index = mode self.update() def set_mode(self, mode): self._clean_heap() self._modes_heap = [(mode, None, None)] # if ((self.__main_mode_index != mode) or (mode == 3) or True): # self._main_mode_index = mode # self._update_mode() # self.update() def number_of_modes(self): return 1 + 3 + 3 + 1 def on_enabled_changed(self): self.update() def _update_mode_buttons(self): self._modes_buttons[0].set_on_off_values("Mode.Session.On","Mode.Session.Off") self._modes_buttons[3].set_on_off_values("Mode.Mixer.On","Mode.Mixer.Off") mode1 = self.getSkinName(Settings.USER_MODES[self._sub_mode_list[1]]) mode2 = self.getSkinName(Settings.USER_MODES[3 + self._sub_mode_list[2]]) self._modes_buttons[1].set_on_off_values("Mode."+mode1+".On","Mode."+mode1+".Off") self._modes_buttons[2].set_on_off_values("Mode."+mode2+".On","Mode."+mode2+".Off") for index in range(4): if (index == self._main_mode_index): self._modes_buttons[index].turn_on() else: self._modes_buttons[index].turn_off() def getSkinName(self, user2Mode): if user2Mode=="instrument": user2Mode = "Note" if user2Mode=="device": user2Mode = "Device" if user2Mode=="user 1": user2Mode = "User" if user2Mode=="user 2": user2Mode = "User2" if user2Mode=="drum stepseq": user2Mode = "StepSequencer" if user2Mode=="melodic stepseq": user2Mode = "StepSequencer2" return user2Mode def channel_for_current_mode(self): # in this code, midi channels start at 0. # so channels range from 0 - 15. # mapping to 1-16 in the real world if self._main_mode_index == 0: new_channel = 0 # session elif self._main_mode_index == 1: if self._sub_mode_list[self._main_mode_index] == 0: new_channel = 11 # instrument controller # instrument controller uses base channel plus the 4 next ones. 11,12,13,14,15 if self._instrument_controller != None: self._instrument_controller.base_channel = new_channel elif self._sub_mode_list[self._main_mode_index] == 1: new_channel = 3 # device controller elif self._sub_mode_list[self._main_mode_index] == 2: new_channel = 4 # plain user mode 1 elif self._main_mode_index == 2: if self._sub_mode_list[self._main_mode_index] == 0: new_channel = 1 # step seq elif self._sub_mode_list[self._main_mode_index] == 1: new_channel = 2 # melodic step seq elif self._sub_mode_list[self._main_mode_index] == 2: new_channel = 5 # plain user mode 2 elif self._main_mode_index == 3: # mixer modes # mixer uses base channel 7 and the 4 next ones. new_channel = 6 + self._sub_modes.mode() # 6,7,8,9,10 return new_channel def update(self): assert (self._modes_buttons != None) if self.is_enabled(): self._update_mode_buttons() as_active = True as_enabled = True self._session.set_allow_update(False) self._zooming.set_allow_update(False) self._config_button.send_value(40) #Set LP double buffering mode (investigate this) self._config_button.send_value(1) #Set LP X-Y layout grid mapping mode if self._main_mode_index == 0: # session self._control_surface.show_message("SESSION MODE" ) self._setup_mixer(not as_active) self._setup_device_controller(not as_active) self._setup_step_sequencer(not as_active) self._setup_step_sequencer2(not as_active) self._setup_instrument_controller(not as_active) self._setup_session(as_active, as_enabled) self._update_control_channels() self._mode_index = 0 elif self._main_mode_index == 1 or self._main_mode_index == 2: self._setup_sub_mode(Settings.USER_MODES[ (self._main_mode_index-1) * 3 + self._sub_mode_list[self._main_mode_index] ] ) elif self._main_mode_index == 3: # mixer self._control_surface.show_message("MIXER MODE") self._setup_device_controller(not as_active) self._setup_step_sequencer(not as_active) self._setup_step_sequencer2(not as_active) self._setup_instrument_controller(not as_active) self._setup_session(not as_active, as_enabled) self._setup_mixer(as_active) self._update_control_channels() self._mode_index = 3 else: assert False self._session.set_allow_update(True) self._zooming.set_allow_update(True) def _setup_sub_mode(self, mode): as_active = True as_enabled = True if mode == "instrument": self._control_surface.show_message("INSTRUMENT MODE") self._setup_session(not as_active, not as_enabled) self._setup_step_sequencer(not as_active) self._setup_step_sequencer2(not as_active) self._setup_mixer(not as_active) self._setup_device_controller(not as_active) self._update_control_channels() self._setup_instrument_controller(as_active) self._mode_index = 4 elif mode == "melodic stepseq": self._control_surface.show_message("MELODIC SEQUENCER MODE") self._setup_session(not as_active, not as_enabled) self._setup_instrument_controller(not as_active) self._setup_device_controller(not as_active) self._setup_mixer(not as_active) self._setup_step_sequencer(not as_active) self._setup_step_sequencer2(as_active) self._update_control_channels() self._mode_index = 7 elif mode == "user 1": self._control_surface.show_message("USER 1 MODE" ) self._setup_session(not as_active, not as_enabled) self._setup_step_sequencer(not as_active) self._setup_step_sequencer2(not as_active) self._setup_mixer(not as_active) self._setup_device_controller(not as_active) self._setup_instrument_controller(not as_active) self._setup_user_mode(True, True, False, True) self._update_control_channels() self._mode_index = 1 self._osd.clear() self._osd.mode = "User 1" self._osd.update() elif mode == "drum stepseq": self._control_surface.show_message("DRUM SEQUENCER MODE") self._setup_session(not as_active, not as_enabled) self._setup_instrument_controller(not as_active) self._setup_device_controller(not as_active) self._setup_mixer(not as_active) self._setup_step_sequencer2(not as_active) self._setup_step_sequencer(as_active) self._update_control_channels() self._mode_index = 6 elif mode == "device": self._control_surface.show_message("DEVICE CONTROLLER MODE") self._setup_session(not as_active, not as_enabled) self._setup_step_sequencer(not as_active) self._setup_step_sequencer2(not as_active) self._setup_mixer(not as_active) self._setup_instrument_controller(not as_active) self._setup_device_controller(as_active) self._update_control_channels() self._mode_index = 5 elif mode == "user 2": self._control_surface.show_message("USER 2 MODE" ) self._setup_session(not as_active, not as_enabled) self._setup_instrument_controller(not as_active) self._setup_device_controller(not as_active) self._setup_mixer(not as_active) self._setup_step_sequencer(not as_active) self._setup_step_sequencer2(not as_active) self._setup_user_mode(False, False, False, False) self._update_control_channels() self._mode_index = 2 self._osd.clear() self._osd.mode = "User 2" self._osd.update() def _setup_session(self, as_active, as_navigation_enabled): assert isinstance(as_active, type(False))#assert is boolean for button in self._nav_buttons: if as_navigation_enabled: button.set_on_off_values("Mode.Session.On", "Mode.Session.Off") else: button.set_on_off_values("DefaultButton.Disabled", "DefaultButton.Disabled") # matrix self._activate_matrix(True) for scene_index in range(self._session._num_scenes):#iterate over scenes scene = self._session.scene(scene_index) if as_active:#set scene launch buttons scene_button = self._side_buttons[scene_index] scene_button.set_enabled(as_active) scene_button.set_on_off_values("DefaultButton.Disabled", "DefaultButton.Disabled") scene.set_launch_button(scene_button) else: scene.set_launch_button(None) for track_index in range(self._session._num_tracks):#iterate over tracks of a scene -> clip slots if as_active:#set clip slot launch button button = self._matrix.get_button(track_index, scene_index) button.set_on_off_values("DefaultButton.Disabled", "DefaultButton.Disabled") button.set_enabled(as_active) scene.clip_slot(track_index).set_launch_button(button) else: scene.clip_slot(track_index).set_launch_button(None) if as_active:#Set up stop clip buttons and stop all clips button if self._session._stop_clip_buttons != None: for button in self._session._stop_clip_buttons: button.set_enabled(as_active) # button.set_on_off_values("Session.StopClip", "DefaultButton.Disabled") self._session.set_stop_track_clip_buttons(self._session._stop_clip_buttons) self._side_buttons[self._session._num_scenes].set_enabled(as_active) self._side_buttons[self._session._num_scenes].set_on_off_values("Session.StopClip", "DefaultButton.Disabled") self._session.set_stop_all_clips_button(self._side_buttons[self._session._num_scenes]) else: self._session.set_stop_track_clip_buttons(None) self._session.set_stop_all_clips_button(None) else: self._session.set_stop_track_clip_buttons(None) self._session.set_stop_all_clips_button(None) if as_active:# zoom self._zooming.set_zoom_button(self._modes_buttons[0])# Set Session button as zoom button, wrong behavior??? self._zooming.set_button_matrix(self._matrix) self._zooming.set_scene_bank_buttons(self._side_buttons) self._zooming.set_nav_buttons(self._nav_buttons[0], self._nav_buttons[1], self._nav_buttons[2], self._nav_buttons[3]) self._zooming.update() else: self._zooming.set_zoom_button(None) self._zooming.set_button_matrix(None) self._zooming.set_scene_bank_buttons(None) self._zooming.set_nav_buttons(None, None, None, None) if as_navigation_enabled: # nav buttons (track/scene) self._session.set_track_bank_buttons(self._nav_buttons[3], self._nav_buttons[2]) self._session.set_scene_bank_buttons(self._nav_buttons[1], self._nav_buttons[0]) else: self._session.set_track_bank_buttons(None, None) self._session.set_scene_bank_buttons(None, None) def _setup_instrument_controller(self, as_active): if self._instrument_controller != None: if as_active: self._activate_matrix(False) #Disable matrix buttons (clip slots) self._activate_scene_buttons(True)#Enable side buttons self._activate_navigation_buttons(True)#Enable nav buttons else: for scene_index in range(8):#Restore all matrix buttons and scene launch buttons scene_button = self._side_buttons[scene_index] scene_button.use_default_message() # Reset to original channel scene_button.force_next_send() #Flush for track_index in range(8): button = self._matrix.get_button(track_index, scene_index) button.use_default_message()# Reset to original channel button.force_next_send()#Flush self._instrument_controller.set_enabled(as_active)#Enable/disable instrument controller def _setup_device_controller(self, as_active): if self._device_controller != None: if as_active: self._activate_scene_buttons(True) self._activate_matrix(True) self._activate_navigation_buttons(True) self._device_controller._is_active = True self._config_button.send_value(32) self._device_controller.set_enabled(True) self._device_controller.update() else: self._device_controller._is_active = False self._device_controller.set_enabled(False) def _setup_user_mode(self, release_matrix=True, release_side_buttons=True, release_nav_buttons=True, drum_rack_mode=True): # user1 -> All True but release_nav_buttons / user2 -> All false for scene_index in range(8): scene_button = self._side_buttons[scene_index] scene_button.set_on_off_values("DefaultButton.Disabled", "DefaultButton.Disabled") scene_button.force_next_send() scene_button.turn_off() scene_button.set_enabled((not release_side_buttons))#User2 enabled for track_index in range(8): button = self._matrix.get_button(track_index, scene_index) button.set_on_off_values("DefaultButton.Disabled", "DefaultButton.Disabled") button.turn_off() button.set_enabled((not release_matrix))#User2 enabled for button in self._nav_buttons: button.set_on_off_values("DefaultButton.Disabled", "DefaultButton.Disabled") button.turn_off() button.set_enabled((not release_nav_buttons)) #User1 & User2 enabled if drum_rack_mode:#User1 enabled self._config_button.send_value(2)#Set LP drum rack layout grid mapping mode self._config_button.send_value(32)#Send enable flashing led config message to LP def _setup_step_sequencer(self, as_active): if(self._stepseq != None): #if(self._stepseq.is_enabled() != as_active): if as_active: self._activate_scene_buttons(True) self._activate_matrix(True) self._activate_navigation_buttons(True) self._config_button.send_value(32) self._stepseq.set_enabled(True) else: self._stepseq.set_enabled(False) def _setup_step_sequencer2(self, as_active): if(self._stepseq2 != None): #if(self._stepseq2.is_enabled() != as_active): if as_active: self._activate_scene_buttons(True) self._activate_matrix(True) self._activate_navigation_buttons(True) self._config_button.send_value(32) self._stepseq2.set_enabled(True) else: self._stepseq2.set_enabled(False) def _setup_mixer(self, as_active): assert isinstance(as_active, type(False)) if as_active: self._activate_navigation_buttons(True) self._activate_scene_buttons(True) self._activate_matrix(True) if(self._sub_modes.is_enabled()):# go back to default mode self._sub_modes.set_mode(-1) else: self._sub_modes.release_controls() self._sub_modes.set_enabled(as_active) def _init_session(self): #self._session.set_stop_clip_value("Session.StopClip") #self._session.set_stop_clip_triggered_value("Session.ClipTriggeredStop") session_height = self._matrix.height() if self._session._stop_clip_buttons != None: session_height = self._matrix.height()-1 for scene_index in range(session_height): # scene = self._session.scene(scene_index) # scene.set_triggered_value("Session.SceneTriggered") # scene.name = 'Scene_' + str(scene_index) for track_index in range(self._matrix.width()): # clip_slot = scene.clip_slot(track_index) # clip_slot.set_triggered_to_play_value("Session.ClipTriggeredPlay") # clip_slot.set_triggered_to_record_value("Session.ClipTriggeredRecord") # clip_slot.set_stopped_value("Session.ClipStopped") # clip_slot.set_started_value("Session.ClipStarted") # clip_slot.set_recording_value("Session.ClipRecording") # clip_slot.set_record_button_value("Session.RecordButton") # clip_slot.name = str(track_index) + '_Clip_Slot_' + str(scene_index) self._all_buttons.append(self._matrix.get_button(track_index, scene_index)) #self._zooming.set_stopped_value("Zooming.Stopped") #self._zooming.set_selected_value("Zooming.Selected") #self._zooming.set_playing_value("Zooming.Playing") def _activate_navigation_buttons(self, active): for button in self._nav_buttons: button.set_enabled(active) def _activate_scene_buttons(self, active): for button in self._side_buttons: button.set_enabled(active) def _activate_matrix(self, active): for scene_index in range(8): for track_index in range(8): self._matrix.get_button(track_index, scene_index).set_enabled(active) def log_message(self, msg): self._control_surface.log_message(msg) # Update the channels of the buttons in the user modes.. def _update_control_channels(self): new_channel = self.channel_for_current_mode() for button in self._all_buttons: button.set_channel(new_channel) button.force_next_send()
class MainSelectorComponent(ModeSelectorComponent): """ Class that reassigns the button on the launchpad to different functions """ def __init__(self, matrix, top_buttons, side_buttons, config_button, script): assert isinstance(matrix, ButtonMatrixElement) assert matrix.width() == 8 and matrix.height() == 8 assert isinstance(top_buttons, tuple) assert len(top_buttons) == 8 assert isinstance(side_buttons, tuple) assert len(side_buttons) == 8 assert isinstance(config_button, ButtonElement) ModeSelectorComponent.__init__(self) self._script = script self._session = SpecialSessionComponent(matrix.width(), matrix.height()) """for scene in self._session._scenes: for slot in scene._clip_slots: slot._triggered_to_play_value = 24 slot._triggered_to_record_value = 27 slot._started_value = 7 slot._recording_value = 9 slot._stopped_value = 8""" self._zooming = SessionZoomingComponent(self._session) self._session.name = "Session_Control" self._zooming.name = "Session_Overview" """self._zooming._stopped_value = 9 self._zooming._playing_value = 7 self._zooming._selected_value = 8""" self._matrix = matrix self._side_buttons = side_buttons self._nav_buttons = top_buttons[:4] self._config_button = config_button self._zooming.set_empty_value(LED_OFF) self._all_buttons = [] for button in self._side_buttons + self._nav_buttons: self._all_buttons.append(button) self._sub_modes = SubSelectorComponent(matrix, side_buttons, self._session) self._sub_modes.name = "Mixer_Modes" self._sub_modes.set_update_callback(self._update_control_channels) self._init_session() self._all_buttons = tuple(self._all_buttons) self.set_modes_buttons(top_buttons[4:]) if START_IN_MOD is True: self._set_protected_mode_index(4) def disconnect(self): for button in self._modes_buttons: button.remove_value_listener(self._mode_value) self._session = None self._zooming = None for button in self._all_buttons: button.set_on_off_values(127, LED_OFF) self._config_button.turn_off() self._matrix = None self._side_buttons = None self._nav_buttons = None self._config_button = None ModeSelectorComponent.disconnect(self) def session_component(self): return self._session def set_modes_buttons(self, buttons): assert buttons == None or isinstance(buttons, tuple) or len(buttons) == self.number_of_modes() identify_sender = True for button in self._modes_buttons: button.remove_value_listener(self._mode_value) self._modes_buttons = [] if buttons != None: for button in buttons: assert isinstance(button, ButtonElement) self._modes_buttons.append(button) button.add_value_listener(self._mode_value, identify_sender) self.set_mode(0) def number_of_modes(self): return 5 def on_enabled_changed(self): self.update() def set_mode(self, mode): assert mode in range(self.number_of_modes()) if (self._mode_index != mode) or (mode == 3): self._mode_index = mode self.update() def channel_for_current_mode(self): new_channel = self._mode_index + self._sub_modes.mode() if new_channel > 0: new_channel += 3 return new_channel def update(self): assert self._modes_buttons != None if self.is_enabled(): # for index in range(len(self._modes_buttons)): # self._modes_buttons[index].set_force_next_value() # if index == self._mode_index: # self._modes_buttons[index].turn_on() # else: # self._modes_buttons[index].turn_off() for scene_index in range(8): self._side_buttons[scene_index].set_enabled(True) for track_index in range(8): self._matrix.get_button(track_index, scene_index).set_enabled(True) for button in self._nav_buttons: button.set_enabled(True) as_active = True as_enabled = True self._session.set_allow_update(False) self._zooming.set_allow_update(False) self._config_button.send_value(40) self._config_button.send_value(1) release_buttons = self._mode_index == 1 if self._mode_index < 4: self._script._suppress_session_highlight = False self._session.set_show_highlight(True) # self._script.set_highlighting_session_component(self.session_component()) self._script._host._set_key_buttons(None) self._script._host.set_enabled(False) self._script._host._set_button_matrix(None) self._script._host._set_alt_button(None) self._script._host._set_shift_button(None) self._script._host._set_nav_buttons(None) for button in self._modes_buttons: button.set_on_off_values(127, 4) if self._mode_index == 0: self._setup_mixer(not as_active) self._setup_session(as_active, as_enabled) elif self._mode_index == 1: self._setup_session(not as_active, not as_enabled) self._setup_mixer(not as_active) self._setup_user(release_buttons) elif self._mode_index == 2: self._setup_session(not as_active, not as_enabled) self._setup_mixer(not as_active) self._setup_user(release_buttons) elif self._mode_index == 3: self._setup_session(not as_active, as_enabled) self._setup_mixer(as_active) elif self._mode_index == 4: # self._script.set_highlighting_session_component(None) self._session.set_show_highlight(False) self._script._suppress_session_highlight = True self._setup_session((not as_active), (not as_enabled)) self._setup_mixer((not as_active)) self._setup_user(release_buttons) self._script._host._set_button_matrix(self._matrix) self._script._host._set_key_buttons(self._side_buttons) self._script._host._set_shift_button(self._modes_buttons[0]) self._script._host._set_lock_button(self._modes_buttons[1]) self._script._host._set_alt_button(self._modes_buttons[2]) self._modes_buttons[3].send_value(9) self._script._host._set_nav_buttons(self._nav_buttons) self._script._host.set_enabled(True) else: assert False self._session.set_allow_update(True) self._zooming.set_allow_update(True) self._update_control_channels() if self._mode_index < 4: for index in range(len(self._modes_buttons)): if index == self._mode_index: self._modes_buttons[index].turn_on() else: self._modes_buttons[index].turn_off() # self._script.request_rebuild_midi_map() self._script.schedule_message(1, self._session.update) def _update_control_channels(self): if self._mode_index < 4: new_channel = self.channel_for_current_mode() else: new_channel = 15 for button in self._all_buttons: button.set_channel(new_channel) button.set_force_next_value() def _setup_session(self, as_active, as_enabled): assert isinstance(as_active, type(False)) for button in self._nav_buttons: if as_enabled: button.set_on_off_values(GREEN_FULL, GREEN_THIRD) else: button.set_on_off_values(127, LED_OFF) for scene_index in range(8): scene = self._session.scene(scene_index) if as_active: scene_button = self._side_buttons[scene_index] scene_button.set_on_off_values(127, LED_OFF) scene.set_launch_button(scene_button) else: scene.set_launch_button(None) for track_index in range(8): if as_active: button = self._matrix.get_button(track_index, scene_index) button.set_on_off_values(127, LED_OFF) scene.clip_slot(track_index).set_launch_button(button) else: scene.clip_slot(track_index).set_launch_button(None) if as_active: self._zooming.set_zoom_button(self._modes_buttons[0]) self._zooming.set_button_matrix(self._matrix) self._zooming.set_scene_bank_buttons(self._side_buttons) self._zooming.set_nav_buttons( self._nav_buttons[0], self._nav_buttons[1], self._nav_buttons[2], self._nav_buttons[3] ) self._zooming.update() else: self._zooming.set_zoom_button(None) self._zooming.set_button_matrix(None) self._zooming.set_scene_bank_buttons(None) self._zooming.set_nav_buttons(None, None, None, None) if as_enabled: self._session.set_track_bank_buttons(self._nav_buttons[3], self._nav_buttons[2]) self._session.set_scene_bank_buttons(self._nav_buttons[1], self._nav_buttons[0]) # self._session.set_show_highlight(True) #Needs to be replaced with L9 equivalent else: self._session.set_track_bank_buttons(None, None) self._session.set_scene_bank_buttons(None, None) # self._session.set_show_highlight(False) #Needs to be replaced with L9 equivalent def _setup_mixer(self, as_active): assert isinstance(as_active, type(False)) as_active and self._sub_modes.is_enabled() and self._sub_modes.set_mode(-1) self._sub_modes.set_enabled(as_active) def _setup_user(self, release_buttons): for scene_index in range(8): scene_button = self._side_buttons[scene_index] scene_button.set_on_off_values(127, LED_OFF) scene_button.turn_off() scene_button.set_enabled(not release_buttons) for track_index in range(8): button = self._matrix.get_button(track_index, scene_index) button.set_on_off_values(127, LED_OFF) button.turn_off() button.set_enabled(not release_buttons) for button in self._nav_buttons: button.set_on_off_values(127, LED_OFF) button.turn_off() button.set_enabled(not release_buttons) if release_buttons: self._config_button.send_value(2) self._config_button.send_value(32, force=True) def _init_session(self): self._session.set_stop_track_clip_value(AMBER_BLINK) for scene_index in range(self._matrix.height()): scene = self._session.scene(scene_index) scene.set_triggered_value(GREEN_BLINK) scene.name = "Scene_" + str(scene_index) for track_index in range(self._matrix.width()): clip_slot = scene.clip_slot(track_index) clip_slot.set_triggered_to_play_value(GREEN_BLINK) clip_slot.set_triggered_to_record_value(RED_BLINK) clip_slot.set_stopped_value(AMBER_FULL) clip_slot.set_started_value(GREEN_FULL) clip_slot.set_recording_value(RED_FULL) clip_slot.name = str(track_index) + "_Clip_Slot_" + str(scene_index) self._all_buttons.append(self._matrix.get_button(track_index, scene_index)) self._zooming.set_stopped_value(RED_FULL) self._zooming.set_selected_value(AMBER_FULL) self._zooming.set_playing_value(GREEN_FULL) """Mono Overrides and Additions""" def _mode_value(self, value, sender): assert len(self._modes_buttons) > 0 assert isinstance(value, int) assert isinstance(sender, ButtonElement) assert self._modes_buttons.count(sender) == 1 if self._script._host.is_enabled() != True: if (value is not 0) or (not sender.is_momentary()): if ((self._modes_buttons[1]._last_received_value > 0) and (self._modes_buttons.index(sender) == 2)) or ( (self._modes_buttons[2]._last_received_value > 0) and (self._modes_buttons.index(sender) == 1) ): if self._script._host._active_client != None: self.set_mode(4) else: self._script.show_message("Monomodular Script not inserted") else: self.set_mode(self._modes_buttons.index(sender)) else: if self._modes_buttons.index(sender) == 3 and value > 0: self.set_mode(0)
class MainSelectorComponent(ModeSelectorComponent): " CLASS THAT REASSIGNS THE BUTTON ON THE LAUNCHPAD TO DIFFERENT FUNCTIONS " " INIT " def __init__(self, matrix, top_buttons, side_buttons, config_button): assert isinstance(matrix, ButtonMatrixElement) assert ((matrix.width() == 8) and (matrix.height() == 8)) assert isinstance(top_buttons, tuple) assert (len(top_buttons) == 8) assert isinstance(side_buttons, tuple) assert (len(side_buttons) == 8) assert isinstance(config_button, ButtonElement) ModeSelectorComponent.__init__(self) self._session = SpecialSessionComponent(self, len(self.song().tracks), matrix.height(), side_buttons) self._session.name = "Session_Control" self._matrix = matrix self._side_buttons = side_buttons self._nav_buttons = top_buttons[:4] self._config_button = config_button self._all_buttons = [] for button in (self._side_buttons + self._nav_buttons): self._all_buttons.append(button) self._sub_modes = SpecialMixerSelectorComponent( matrix, side_buttons, self._session) self._sub_modes.name = "Mixer_Modes" self._sub_modes.set_update_callback(self._update_control_channels) self._init_session() self._all_buttons = tuple(self._all_buttons) self.set_modes_buttons(top_buttons[4:]) # mixer-session hack self._buttons_for_mixer = [] for button in (self._side_buttons[5:]): self._buttons_for_mixer.append(button) for scene_index in range(self._matrix.height()): for track_index in range(self._matrix.width()): if scene_index > SESSION_HEIGHT_FOR_MIXER: self._buttons_for_mixer.append( self._matrix.get_button(track_index, scene_index)) " DISCONNECT " def disconnect(self): for button in self._modes_buttons: button.remove_value_listener(self._mode_value) self._session = None for button in self._all_buttons: button.set_on_off_values(127, LED_OFF) self._config_button.turn_off() self._matrix = None self._side_buttons = None self._nav_buttons = None self._config_button = None self._buttons_for_mixer = None ModeSelectorComponent.disconnect(self) " GET SESSION COMPONENT " def session_component(self): return self._session " SET THE MODE BUTTONS " def set_modes_buttons(self, buttons): assert ((buttons == None) or (isinstance(buttons, tuple) or (len(buttons) == self.number_of_modes()))) identify_sender = True for button in self._modes_buttons: button.remove_value_listener(self._mode_value) self._modes_buttons = [] if (buttons != None): for button in buttons: assert isinstance(button, ButtonElement) self._modes_buttons.append(button) button.add_value_listener(self._mode_value, identify_sender) self.set_mode(0) " GET AMOUNT OF MODES " def number_of_modes(self): return 4 " CHANGE CALLBACK " def on_enabled_changed(self): self.update() " SET THE MODE " def set_mode(self, mode): assert (mode in range(self.number_of_modes())) if ((self._mode_index != mode) or (mode == 3) or True): self._mode_index = mode self.update() " UPDATE MODE BUTTONS " def _update_mode_buttons(self): for index in range(4): if (index == self._mode_index): self._modes_buttons[index].turn_on() else: self._modes_buttons[index].turn_off() " SET CHANNEL FOR THE CURRONT MODE " def channel_for_current_mode(self): #trying to keep if self._mode_index == 0: return 0 elif self._mode_index == 1: new_channel = 4 #user 1 elif self._mode_index == 2: new_channel = 5 #user 2 elif self._mode_index == 3: new_channel = 6 + self._sub_modes.mode() #mixer modes return new_channel " UPDATE THE SHIT " def update(self): assert (self._modes_buttons != None) if self.is_enabled(): self._update_mode_buttons() #update matrix and side buttons for scene_index in range(self._matrix.height()): #update scene button self._side_buttons[scene_index].set_enabled(True) for track_index in range(self._matrix.width()): #update matrix self._matrix.get_button(track_index, scene_index).set_enabled(True) for button in self._nav_buttons: button.set_enabled(True) as_active = True as_enabled = True self._session.set_allow_update(False) self._config_button.send_value(40) self._config_button.send_value(1) release_buttons = (self._mode_index == 1) if (self._mode_index == 0): #session self._setup_mixer((not as_active)) self._setup_session(as_active, as_enabled, False) elif (self._mode_index == 1): #user mode 1 self._setup_mixer((not as_active)) self._setup_session((not as_active), (not as_enabled), False) self._setup_user1(True, True, True) elif (self._mode_index == 2): #user mode 2 self._setup_mixer((not as_active)) self._setup_session((not as_active), (not as_enabled), False) self._setup_user2(release_buttons) elif (self._mode_index == 3): #mixer self._setup_session((as_active), as_enabled, True) self._setup_mixer(as_active) else: assert False self._session.set_allow_update(True) self._update_control_channels() " UPDATE THE CHANNELS OF THE BUTTONS IN THE USER MODES.. " def _update_control_channels(self): new_channel = self.channel_for_current_mode() if self._mode_index == 3: # skip the upper part of the matrix and buttons for button in self._buttons_for_mixer: button.set_channel(new_channel) button.set_force_next_value() else: for button in self._all_buttons: button.set_channel(new_channel) button.set_force_next_value() " SETUP THE SESSION " def _setup_session(self, as_active, as_enabled, for_mixer): #log("setup_session (active: " + str(as_active) + ", enabled: " + str(as_enabled) + ", forMixer: " + str(for_mixer) + ")") assert isinstance(as_active, type(False)) assert isinstance(as_enabled, type(False)) assert isinstance(for_mixer, type(False)) # --------------------------------------------------------------------- nav button color for button in self._nav_buttons: if as_enabled: button.set_on_off_values(GREEN_FULL, GREEN_THIRD) else: button.set_on_off_values(127, LED_OFF) # --------------------------------------------------------------------- matrix for scene_index in range(self._matrix.height()): scene = self._session.scene(scene_index) if for_mixer: if scene_index <= SESSION_HEIGHT_FOR_MIXER: scene_button = self._side_buttons[scene_index] scene_button.set_on_off_values(127, GREEN_THIRD) scene.set_launch_button(scene_button) else: scene.set_launch_button(None) elif as_active and (not for_mixer): scene_button = self._side_buttons[scene_index] scene_button.set_on_off_values(127, GREEN_THIRD) scene.set_launch_button(scene_button) else: scene.set_launch_button(None) # SLOT BUTTONS button_index = 0 for track_index in range(len(self.song().tracks)): if self.song().tracks[track_index].is_foldable: if button_index < GROUPS_CONSIDERED: if for_mixer: if scene_index <= SESSION_HEIGHT_FOR_MIXER: button = self._matrix.get_button( button_index, scene_index) button.set_on_off_values(127, LED_OFF) scene.clip_slot(track_index).set_launch_button( button) else: scene.clip_slot(track_index).set_launch_button( None) elif as_active and (not for_mixer): button = self._matrix.get_button( button_index, scene_index) button.set_on_off_values(127, LED_OFF) scene.clip_slot(track_index).set_launch_button( button) else: scene.clip_slot(track_index).set_launch_button( None) button_index = button_index + 1 else: scene.clip_slot(track_index).set_launch_button(None) # --------------------------------------------------------------------- nav buttons if as_enabled or for_mixer: self._session.set_scene_bank_buttons(self._nav_buttons[1], self._nav_buttons[0]) else: self._session.set_scene_bank_buttons(None, None) " SETUP THE MIXER " def _setup_mixer(self, as_active): assert isinstance(as_active, type(False)) self._sub_modes.set_enabled(as_active) " SETUP USER 1 " def _setup_user1(self, release_matrix=True, release_side_buttons=True, release_nav_buttons=True): for scene_index in range(8): if (release_side_buttons): scene_button = self._side_buttons[scene_index] scene_button.set_on_off_values(127, LED_OFF) scene_button.turn_off() scene_button.set_enabled((not release_side_buttons)) for track_index in range(8): button = self._matrix.get_button(track_index, scene_index) button.set_on_off_values(127, LED_OFF) button.turn_off() button.set_enabled((not release_matrix)) for button in self._nav_buttons: if (release_nav_buttons): button.set_on_off_values(127, LED_OFF) button.turn_off() button.set_enabled((not release_nav_buttons)) if release_matrix: self._config_button.send_value(2) self._config_button.send_value(32, force_send=True) " SETUP USER 2 " def _setup_user2(self, release_buttons): for scene_index in range(8): scene_button = self._side_buttons[scene_index] scene_button.set_on_off_values(127, LED_OFF) scene_button.turn_off() scene_button.set_enabled((not release_buttons)) for track_index in range(8): button = self._matrix.get_button(track_index, scene_index) button.set_on_off_values(127, LED_OFF) button.turn_off() button.set_enabled((not release_buttons)) for button in self._nav_buttons: button.set_on_off_values(127, LED_OFF) button.turn_off() button.set_enabled((not release_buttons)) if release_buttons: self._config_button.send_value(2) self._config_button.send_value(32, force_send=True) " INIT THE SESSION " def _init_session(self): self._session.set_stop_track_clip_value(AMBER_BLINK) # SCENES for scene_index in range(self._matrix.height()): scene = self._session.scene(scene_index) scene.set_triggered_value(GREEN_BLINK) scene.name = ("Scene_" + str(scene_index)) # SLOTS button_index = 0 for track_index in range(len(self.song().tracks)): if button_index < GROUPS_CONSIDERED: if self.song().tracks[track_index].is_foldable: clip_slot = scene.clip_slot(track_index) clip_slot.set_triggered_to_play_value(GREEN_BLINK) clip_slot.set_triggered_to_record_value(RED_BLINK) clip_slot.set_stopped_value(AMBER_FULL) clip_slot.set_started_value(GREEN_FULL) clip_slot.set_recording_value(RED_FULL) clip_slot.name = ((str(track_index) + "_Clip_Slot_") + str(scene_index)) self._all_buttons.append( self._matrix.get_button(button_index, scene_index)) button_index = button_index + 1
class MainSelectorComponent(ModeSelectorComponent): """ Class that reassigns the button on the launchpad to different functions """ def __init__(self, matrix, top_buttons, side_buttons, config_button): raise isinstance(matrix, ButtonMatrixElement) or AssertionError raise matrix.width() == 8 and matrix.height() == 8 or AssertionError raise isinstance(top_buttons, tuple) or AssertionError raise len(top_buttons) == 8 or AssertionError raise isinstance(side_buttons, tuple) or AssertionError raise len(side_buttons) == 8 or AssertionError raise isinstance(config_button, ButtonElement) or AssertionError ModeSelectorComponent.__init__(self) self._session = SpecialSessionComponent(matrix.width(), matrix.height()) self._zooming = DeprecatedSessionZoomingComponent(self._session) self._session.name = 'Session_Control' self._zooming.name = 'Session_Overview' self._matrix = matrix self._side_buttons = side_buttons self._nav_buttons = top_buttons[:4] self._config_button = config_button self._zooming.set_empty_value(LED_OFF) self._all_buttons = [] for button in self._side_buttons + self._nav_buttons: self._all_buttons.append(button) self._sub_modes = SubSelectorComponent(matrix, side_buttons, self._session) self._sub_modes.name = 'Mixer_Modes' self._sub_modes.set_update_callback(self._update_control_channels) self._init_session() self._all_buttons = tuple(self._all_buttons) self.set_modes_buttons(top_buttons[4:]) def disconnect(self): for button in self._modes_buttons: button.remove_value_listener(self._mode_value) self._session = None self._zooming = None for button in self._all_buttons: button.set_on_off_values(127, LED_OFF) self._config_button.turn_off() self._matrix = None self._side_buttons = None self._nav_buttons = None self._config_button = None ModeSelectorComponent.disconnect(self) return def session_component(self): return self._session def set_modes_buttons(self, buttons): raise buttons == None or isinstance(buttons, tuple) or len(buttons) == self.number_of_modes() or AssertionError identify_sender = True for button in self._modes_buttons: button.remove_value_listener(self._mode_value) self._modes_buttons = [] if buttons != None: for button in buttons: raise isinstance(button, ButtonElement) or AssertionError self._modes_buttons.append(button) button.add_value_listener(self._mode_value, identify_sender) self.set_mode(0) return def number_of_modes(self): return 4 def on_enabled_changed(self): self.update() def set_mode(self, mode): if not mode in range(self.number_of_modes()): raise AssertionError self._mode_index = (self._mode_index != mode or mode == 3) and mode self.update() def channel_for_current_mode(self): new_channel = self._mode_index + self._sub_modes.mode() if new_channel > 0: new_channel += 3 return new_channel def update(self): super(MainSelectorComponent, self).update() if not self._modes_buttons != None: raise AssertionError if self.is_enabled(): for index in range(len(self._modes_buttons)): self._modes_buttons[index].set_force_next_value() if index == self._mode_index: self._modes_buttons[index].turn_on() else: self._modes_buttons[index].turn_off() for scene_index in range(8): self._side_buttons[scene_index].set_enabled(True) for track_index in range(8): self._matrix.get_button(track_index, scene_index).set_enabled(True) for button in self._nav_buttons: button.set_enabled(True) as_active = True as_enabled = True self._session.set_allow_update(False) self._zooming.set_allow_update(False) self._config_button.send_value(40) self._config_button.send_value(1) release_buttons = self._mode_index == 1 self._mode_index == 0 and self._setup_mixer(not as_active) self._setup_session(as_active, as_enabled) elif self._mode_index == 1: self._setup_session(not as_active, not as_enabled) self._setup_mixer(not as_active) self._setup_user(release_buttons) elif self._mode_index == 2: self._setup_session(not as_active, not as_enabled) self._setup_mixer(not as_active) self._setup_user(release_buttons) elif self._mode_index == 3: self._setup_session(not as_active, as_enabled) self._setup_mixer(as_active) else: raise False or AssertionError self._session.set_allow_update(True) self._zooming.set_allow_update(True) self._update_control_channels() return def _update_control_channels(self): new_channel = self.channel_for_current_mode() for button in self._all_buttons: button.set_channel(new_channel) button.set_force_next_value() def _setup_session(self, as_active, as_enabled): if not isinstance(as_active, type(False)): raise AssertionError for button in self._nav_buttons: if as_enabled: button.set_on_off_values(GREEN_FULL, GREEN_THIRD) else: button.set_on_off_values(127, LED_OFF) for scene_index in range(8): scene = self._session.scene(scene_index) if as_active: scene_button = self._side_buttons[scene_index] scene_button.set_on_off_values(127, LED_OFF) scene.set_launch_button(scene_button) else: scene.set_launch_button(None) for track_index in range(8): if as_active: button = self._matrix.get_button(track_index, scene_index) button.set_on_off_values(127, LED_OFF) scene.clip_slot(track_index).set_launch_button(button) else: scene.clip_slot(track_index).set_launch_button(None) if as_active: self._zooming.set_zoom_button(self._modes_buttons[0]) self._zooming.set_button_matrix(self._matrix) self._zooming.set_scene_bank_buttons(self._side_buttons) self._zooming.set_nav_buttons(self._nav_buttons[0], self._nav_buttons[1], self._nav_buttons[2], self._nav_buttons[3]) self._zooming.update() else: self._zooming.set_zoom_button(None) self._zooming.set_button_matrix(None) self._zooming.set_scene_bank_buttons(None) self._zooming.set_nav_buttons(None, None, None, None) as_enabled and self._session.set_track_bank_buttons(self._nav_buttons[3], self._nav_buttons[2]) self._session.set_scene_bank_buttons(self._nav_buttons[1], self._nav_buttons[0]) else: self._session.set_track_bank_buttons(None, None) self._session.set_scene_bank_buttons(None, None) return def _setup_mixer(self, as_active): if not isinstance(as_active, type(False)): raise AssertionError as_active and self._sub_modes.is_enabled() and self._sub_modes.set_mode(-1) self._sub_modes.set_enabled(as_active) def _setup_user(self, release_buttons): for scene_index in range(8): scene_button = self._side_buttons[scene_index] scene_button.set_on_off_values(127, LED_OFF) scene_button.turn_off() scene_button.set_enabled(not release_buttons) for track_index in range(8): button = self._matrix.get_button(track_index, scene_index) button.set_on_off_values(127, LED_OFF) button.turn_off() button.set_enabled(not release_buttons) for button in self._nav_buttons: button.set_on_off_values(127, LED_OFF) button.turn_off() button.set_enabled(not release_buttons) if release_buttons: self._config_button.send_value(2) self._config_button.send_value(32, force=True) def _init_session(self): self._session.set_stop_clip_value(AMBER_THIRD) self._session.set_stop_clip_triggered_value(AMBER_BLINK) for scene_index in range(self._matrix.height()): scene = self._session.scene(scene_index) scene.set_triggered_value(GREEN_BLINK) scene.name = 'Scene_' + str(scene_index) for track_index in range(self._matrix.width()): clip_slot = scene.clip_slot(track_index) clip_slot.set_triggered_to_play_value(GREEN_BLINK) clip_slot.set_triggered_to_record_value(RED_BLINK) clip_slot.set_stopped_value(AMBER_FULL) clip_slot.set_started_value(GREEN_FULL) clip_slot.set_recording_value(RED_FULL) clip_slot.name = str(track_index) + '_Clip_Slot_' + str(scene_index) self._all_buttons.append(self._matrix.get_button(track_index, scene_index)) self._zooming.set_stopped_value(RED_FULL) self._zooming.set_selected_value(AMBER_FULL) self._zooming.set_playing_value(GREEN_FULL)
class MainSelectorComponent(ModeSelectorComponent): __module__ = __name__ __doc__ = ' Class that reassigns the button on the launchpad to different functions ' def __init__(self, matrix, top_buttons, side_buttons, config_button, knobs, sliders, script): assert isinstance(matrix, ButtonMatrixElement) assert ((matrix.width() == 8) and (matrix.height() == 8)) assert isinstance(top_buttons, tuple) assert (len(top_buttons) == 8) assert isinstance(side_buttons, tuple) assert (len(side_buttons) == 8) assert isinstance(config_button, ButtonElement) ModeSelectorComponent.__init__(self) self._script = script self._session = SpecialSessionComponent(matrix.width(), matrix.height()) for scene in self._session._scenes: for slot in scene._clip_slots: slot._triggered_to_play_value = 4 slot._triggered_to_record_value = 3 slot._started_value = 2 slot._recording_value = 1 slot._stopped_value = 127 self._zooming = SessionZoomingComponent(self._session) self._zooming._stopped_value = 127 self._zooming._playing_value = 2 self._zooming._selected_value = 1 self._matrix = matrix self._knobs = knobs self._sliders = sliders self._side_buttons = side_buttons self._nav_buttons = top_buttons[:4] self._config_button = config_button self._shift_button = top_buttons[5] self._zooming.set_empty_value(LED_OFF) self._all_buttons = [] for button in (self._side_buttons + self._nav_buttons): self._all_buttons.append(button) self._shift_pressed = 0 self._shift_pressed_timer = 0 self._last_normal_mode = 0 self._shift_button = None self.set_shift_button(top_buttons[6]) self._sub_modes = SubSelectorComponent(matrix, side_buttons, self._session) self._sub_modes.set_update_callback(self._update_control_channels) self._init_session() self._all_buttons = tuple(self._all_buttons) self.set_modes_buttons(top_buttons[4:6]) def disconnect(self): for button in self._modes_buttons: button.remove_value_listener(self._mode_value) self._session = None self._zooming = None for button in self._all_buttons: button.set_on_off_values(127, LED_OFF) self._config_button.turn_off() self._matrix = None self._side_buttons = None self._nav_buttons = None self._config_button = None ModeSelectorComponent.disconnect(self) def set_shift_button(self, button): assert ((button == None) or (isinstance(button, FlashingButtonElement))) if self._shift_button != None: self._shift_button.remove_value_listener(self._shift_value) self._shift_button = button if self._shift_button != None: self._shift_button.add_value_listener(self._shift_value) def _shift_value(self, value): self._shift_pressed = int(value != 0) if self._shift_pressed > 0: if (self._shift_pressed_timer + 5) > self._script._timer: if (self._script._host.is_enabled() != True): self.set_mode(4) else: self._script.log_message('here') self.set_mode(self._last_normal_mode) else: self._shift_pressed_timer = self._script._timer % 256 if (self._script._host.is_enabled() != True): if (self._mode_index == 1): if value > 0: self._session.set_track_bank_buttons(None, None) self._session.set_scene_bank_buttons(None, None) self._sub_modes.set_modes_buttons(self._nav_buttons) self._sub_modes.update() else: self._sub_modes.set_modes_buttons(None) self._session.set_track_bank_buttons( self._nav_buttons[3], self._nav_buttons[2]) self._session.set_scene_bank_buttons( self._nav_buttons[1], self._nav_buttons[0]) self._sub_modes.update() elif (self._mode_index == 0): self._setup_session(True, True) self._session.update() def set_modes_buttons(self, buttons): assert ((buttons == None) or (isinstance(buttons, tuple) or (len(buttons) == 2))) identify_sender = True for button in self._modes_buttons: button.remove_value_listener(self._mode_value) self._modes_buttons = [] if (buttons != None): for button in buttons: assert isinstance(button, ButtonElement) self._modes_buttons.append(button) button.add_value_listener(self._mode_value, identify_sender) self.set_mode(0) def _mode_value(self, value, sender): assert (len(self._modes_buttons) > 0) assert isinstance(value, int) assert isinstance(sender, ButtonElement) assert (self._modes_buttons.count(sender) == 1) if self._script._host.is_enabled() != True: if ((value is not 0) or (not sender.is_momentary())): if self._shift_pressed > 0: if self._modes_buttons.index(sender) == 0: self.set_mode(2) if self._modes_buttons.index(sender) == 1: self.set_mode(3) else: self._last_normal_mode = int( self._modes_buttons.index(sender)) self.set_mode(self._modes_buttons.index(sender)) else: pass def number_of_modes(self): return 5 def on_enabled_changed(self): self.update() def set_mode(self, mode): assert (mode in range(self.number_of_modes())) if ((self._mode_index != mode) or (mode == 1)): self._mode_index = mode self.update() def update(self): assert (self._modes_buttons != None) if self.is_enabled(): for scene_index in range(8): for track_index in range(8): self._matrix.get_button(track_index, scene_index).set_enabled(True) for button in self._nav_buttons: button.set_enabled(True) as_active = True as_enabled = True self._session.set_allow_update(False) self._zooming.set_allow_update(False) self._config_button.send_value(40) self._config_button.send_value(1) release_buttons = (self._mode_index == 1) if (self._mode_index < 4): self._script._host.set_enabled(False) self._script._host._set_button_matrix(None) self._script._host._set_alt_button(None) self._script._host._set_shift_button(None) self._script._host._set_nav_buttons(None) if (self._mode_index == 0): #session self._setup_mixer((not as_active)) self._setup_session(as_active, as_enabled) elif (self._mode_index == 1): #mixer self._setup_session((not as_active), as_enabled) self._setup_mixer(as_active) elif (self._mode_index == 2): #user1 self._setup_session((not as_active), (not as_enabled)) self._setup_mixer((not as_active)) self._setup_user(release_buttons) elif (self._mode_index == 3): #user2 self._setup_session((not as_active), (not as_enabled)) self._setup_mixer((not as_active)) self._setup_user(release_buttons) elif (self._mode_index == 4): #monomodular self._setup_session((not as_active), (not as_enabled)) self._setup_mixer((not as_active)) self._setup_user(release_buttons) self._script._host._set_button_matrix(self._matrix) self._script._host._set_shift_button(self._shift_button) self._script._host._set_lock_button(self._modes_buttons[0]) self._script._host._set_alt_button(self._modes_buttons[1]) self._script._host._set_nav_buttons(self._nav_buttons) self._script._host.set_enabled(True) else: assert False self._session.set_allow_update(True) self._zooming.set_allow_update(True) self._update_control_channels() #self._script.request_rebuild_midi_map() def _update_control_channels(self): if self._mode_index < 4: new_channel = (self._mode_index + self._sub_modes.mode()) if (new_channel > 0): new_channel += 3 else: new_channel = 15 for button in self._all_buttons: button.set_channel(new_channel) button.set_force_next_value() def _setup_session(self, as_active, as_enabled): assert isinstance(as_active, type(False)) for button in self._nav_buttons: if as_enabled: button.set_on_off_values(127, 0) else: button.set_on_off_values(127, 0) for scene_index in range(8): scene = self._session.scene(scene_index) if as_active and (self._shift_pressed == 1): scene_button = self._matrix.get_button(7, scene_index) scene_button.set_on_off_values(127, 0) scene.set_launch_button(scene_button) else: scene.set_launch_button(None) for track_index in range(SHIFT[self._shift_pressed]): if as_active: button = self._matrix.get_button(track_index, scene_index) button.set_on_off_values(127, 0) scene.clip_slot(track_index).set_launch_button(button) else: scene.clip_slot(track_index).set_launch_button(None) if as_active: self._zooming.set_zoom_button(self._modes_buttons[0]) self._zooming.set_button_matrix(self._matrix) self._zooming.set_scene_bank_buttons(self._side_buttons) self._zooming.set_nav_buttons(self._nav_buttons[0], self._nav_buttons[1], self._nav_buttons[2], self._nav_buttons[3]) self._zooming.update() else: self._zooming.set_zoom_button(None) self._zooming.set_button_matrix(None) self._zooming.set_scene_bank_buttons(None) self._zooming.set_nav_buttons(None, None, None, None) if as_enabled: self._session.set_track_bank_buttons(self._nav_buttons[3], self._nav_buttons[2]) self._session.set_scene_bank_buttons(self._nav_buttons[1], self._nav_buttons[0]) else: self._session.set_track_bank_buttons(None, None) self._session.set_scene_bank_buttons(None, None) def _setup_mixer(self, as_active): assert isinstance(as_active, type(False)) self._sub_modes.set_enabled(as_active) def _setup_user(self, release_buttons): for scene_index in range(8): scene_button = self._side_buttons[scene_index] scene_button.set_on_off_values(127, LED_OFF) scene_button.turn_off() scene_button.set_enabled((not release_buttons)) for track_index in range(8): button = self._matrix.get_button(track_index, scene_index) button.set_on_off_values(127, LED_OFF) button.turn_off() button.set_enabled((not release_buttons)) for button in self._nav_buttons: button.set_on_off_values(127, LED_OFF) button.turn_off() button.set_enabled((not release_buttons)) self._config_button.send_value(32) if release_buttons: self._config_button.send_value(2) def _init_session(self): self._session.set_stop_track_clip_value(3) for scene_index in range(self._matrix.height()): scene = self._session.scene(scene_index) scene.set_triggered_value(1) for track_index in range(self._matrix.width()): clip_slot = scene.clip_slot(track_index) clip_slot.set_triggered_to_play_value(4) clip_slot.set_triggered_to_record_value(3) clip_slot.set_stopped_value(127) clip_slot.set_started_value(2) clip_slot.set_recording_value(1) self._all_buttons.append( self._matrix.get_button(track_index, scene_index)) self._zooming.set_stopped_value(127) self._zooming.set_selected_value(1) self._zooming.set_playing_value(2)
class MainSelectorComponent(ModeSelectorComponent): """ Class that reassigns the button on the launchpad to different functions """ #def log(self, message): # self._control_surface.log_message((' ' + message + ' ').center(50, '=')) def __init__(self, matrix, top_buttons, side_buttons, config_button, osd, control_surface): #verify matrix dimentions assert isinstance(matrix, ButtonMatrixElement) assert ((matrix.width() == 8) and (matrix.height() == 8)) assert isinstance(top_buttons, tuple) assert (len(top_buttons) == 8) assert isinstance(side_buttons, tuple) assert (len(side_buttons) == 8) assert isinstance(config_button, ButtonElement) ModeSelectorComponent.__init__(self) #super constructor #inject ControlSurface and OSD components (M4L) self._osd = osd self._control_surface = control_surface #initialize index variables self._mode_index = 0 #Inherited from parent self._main_mode_index = 0 #LP original modes self._sub_mode_list = [0, 0, 0, 0] for index in range(4): self._sub_mode_list[index] = 0 self.set_mode_buttons(top_buttons[4:]) if Settings.SESSION__STOP_BUTTONS: #session with bottom stop buttons clip_stop_buttons = [] for column in range(8): clip_stop_buttons.append( matrix.get_button(column, matrix.height() - 1)) self._session = SpecialSessionComponent(matrix.width(), matrix.height() - 1, clip_stop_buttons, self._control_surface, self) else: #no stop buttons self._session = SpecialSessionComponent(matrix.width(), matrix.height(), None, self._control_surface, self) #initialize _session variables self._session.set_osd(self._osd) self._session.name = 'Session_Control' #initialize _zooming variables self._zooming = DeprecatedSessionZoomingComponent(self._session, enable_skinning=True) self._zooming.name = 'Session_Overview' self._zooming.set_empty_value("Default.Button.Off") self._matrix = matrix self._side_buttons = side_buttons #launch buttons self._nav_buttons = top_buttons[:4] #arrow buttons self._config_button = config_button #used to reset launchpad self._all_buttons = [] for button in self._side_buttons + self._nav_buttons: self._all_buttons.append(button) #SubSelector changes the Mode using side buttons (ie. Pan, Volume, Send1, Send2, Stop, Solo, Activate, Arm) self._sub_modes = SubSelectorComponent(matrix, side_buttons, self._session, self._control_surface) self._sub_modes.name = 'Mixer_Modes' self._sub_modes._mixer.set_osd(self._osd) self._sub_modes.set_update_callback(self._update_control_channels) #User2 stepSequencer (Drum & Melodic) self._stepseq = StepSequencerComponent(self._matrix, self._side_buttons, self._nav_buttons, self._control_surface) self._stepseq.set_osd(self._osd) #User2 stepSequencer (Retro style) self._stepseq2 = StepSequencerComponent2(self._matrix, self._side_buttons, self._nav_buttons, self._control_surface) self._stepseq2.set_osd(self._osd) #User1 Instrument controller (Scale) self._instrument_controller = InstrumentControllerComponent( self._matrix, self._side_buttons, self._nav_buttons, self._control_surface) self._instrument_controller.set_osd(self._osd) #self._instrument_controller = None #User1 Device controller (Fx or Instrument parameters) self._device_controller = DeviceComponent( control_surface=self._control_surface, matrix=self._matrix, side_buttons=self._side_buttons, top_buttons=self._nav_buttons) self._device_controller.set_osd(self._osd) self._init_session() self._all_buttons = tuple(self._all_buttons) def disconnect(self): for button in self._modes_buttons: button.remove_value_listener(self._mode_value) self._session = None self._zooming = None for button in self._all_buttons: button.set_on_off_values("DefaultButton.Disabled", "DefaultButton.Disabled") self._config_button.turn_off() self._matrix = None self._side_buttons = None self._nav_buttons = None self._config_button = None ModeSelectorComponent.disconnect(self) def session_component(self): return self._session def _update_mode(self): mode = self._modes_heap[-1][ 0] #get first value of last _modes_heap tuple. _modes_heap tuple structure is (mode, sender, observer) assert mode in range(self.number_of_modes()) # 8 for this script if self._main_mode_index == mode: if self._main_mode_index == 1: #user mode 1 and device controller and instrument mode self._sub_mode_list[self._main_mode_index] = ( self._sub_mode_list[self._main_mode_index] + 1) % 3 self.update() elif self._main_mode_index == 2: #user mode 2 and step sequencer self._sub_mode_list[self._main_mode_index] = ( self._sub_mode_list[self._main_mode_index] + 1) % 3 self.update() elif self._main_mode_index == 3: #Mixer mode self.update() else: #Session mode self._sub_mode_list[self._main_mode_index] = 0 self._mode_index = 0 else: self._main_mode_index = mode self.update() def set_mode(self, mode): self._clean_heap() self._modes_heap = [(mode, None, None)] # if ((self.__main_mode_index != mode) or (mode == 3) or True): # self._main_mode_index = mode # self._update_mode() # self.update() def number_of_modes(self): return 1 + 3 + 3 + 1 def on_enabled_changed(self): self.update() def _update_mode_buttons(self): self._modes_buttons[0].set_on_off_values("Mode.Session.On", "Mode.Session.Off") self._modes_buttons[3].set_on_off_values("Mode.Mixer.On", "Mode.Mixer.Off") mode1 = self.getSkinName(Settings.USER_MODES[self._sub_mode_list[1]]) mode2 = self.getSkinName(Settings.USER_MODES[3 + self._sub_mode_list[2]]) self._modes_buttons[1].set_on_off_values("Mode." + mode1 + ".On", "Mode." + mode1 + ".Off") self._modes_buttons[2].set_on_off_values("Mode." + mode2 + ".On", "Mode." + mode2 + ".Off") for index in range(4): if (index == self._main_mode_index): self._modes_buttons[index].turn_on() else: self._modes_buttons[index].turn_off() def getSkinName(self, user2Mode): if user2Mode == "instrument": user2Mode = "Note" if user2Mode == "device": user2Mode = "Device" if user2Mode == "user 1": user2Mode = "User" if user2Mode == "user 2": user2Mode = "User2" if user2Mode == "drum stepseq": user2Mode = "StepSequencer" if user2Mode == "melodic stepseq": user2Mode = "StepSequencer2" return user2Mode def channel_for_current_mode(self): # in this code, midi channels start at 0. # so channels range from 0 - 15. # mapping to 1-16 in the real world if self._main_mode_index == 0: new_channel = 0 # session elif self._main_mode_index == 1: if self._sub_mode_list[self._main_mode_index] == 0: new_channel = 11 # instrument controller # instrument controller uses base channel plus the 4 next ones. 11,12,13,14,15 if self._instrument_controller != None: self._instrument_controller.base_channel = new_channel elif self._sub_mode_list[self._main_mode_index] == 1: new_channel = 3 # device controller elif self._sub_mode_list[self._main_mode_index] == 2: new_channel = 4 # plain user mode 1 elif self._main_mode_index == 2: if self._sub_mode_list[self._main_mode_index] == 0: new_channel = 1 # step seq elif self._sub_mode_list[self._main_mode_index] == 1: new_channel = 2 # melodic step seq elif self._sub_mode_list[self._main_mode_index] == 2: new_channel = 5 # plain user mode 2 elif self._main_mode_index == 3: # mixer modes # mixer uses base channel 7 and the 4 next ones. new_channel = 6 + self._sub_modes.mode() # 6,7,8,9,10 return new_channel def update(self): assert (self._modes_buttons != None) if self.is_enabled(): self._update_mode_buttons() as_active = True as_enabled = True self._session.set_allow_update(False) self._zooming.set_allow_update(False) self._config_button.send_value( 40) #Set LP double buffering mode (investigate this) self._config_button.send_value( 1) #Set LP X-Y layout grid mapping mode if self._main_mode_index == 0: # session self._control_surface.show_message("SESSION MODE") self._setup_mixer(not as_active) self._setup_device_controller(not as_active) self._setup_step_sequencer(not as_active) self._setup_step_sequencer2(not as_active) self._setup_instrument_controller(not as_active) self._setup_session(as_active, as_enabled) self._update_control_channels() self._mode_index = 0 elif self._main_mode_index == 1 or self._main_mode_index == 2: self._setup_sub_mode(Settings.USER_MODES[ (self._main_mode_index - 1) * 3 + self._sub_mode_list[self._main_mode_index]]) elif self._main_mode_index == 3: # mixer self._control_surface.show_message("MIXER MODE") self._setup_device_controller(not as_active) self._setup_step_sequencer(not as_active) self._setup_step_sequencer2(not as_active) self._setup_instrument_controller(not as_active) self._setup_session(not as_active, as_enabled) self._setup_mixer(as_active) self._update_control_channels() self._mode_index = 3 else: assert False self._session.set_allow_update(True) self._zooming.set_allow_update(True) def _setup_sub_mode(self, mode): as_active = True as_enabled = True if mode == "instrument": self._control_surface.show_message("INSTRUMENT MODE") self._setup_session(not as_active, not as_enabled) self._setup_step_sequencer(not as_active) self._setup_step_sequencer2(not as_active) self._setup_mixer(not as_active) self._setup_device_controller(not as_active) self._update_control_channels() self._setup_instrument_controller(as_active) self._mode_index = 4 elif mode == "melodic stepseq": self._control_surface.show_message("MELODIC SEQUENCER MODE") self._setup_session(not as_active, not as_enabled) self._setup_instrument_controller(not as_active) self._setup_device_controller(not as_active) self._setup_mixer(not as_active) self._setup_step_sequencer(not as_active) self._setup_step_sequencer2(as_active) self._update_control_channels() self._mode_index = 7 elif mode == "user 1": self._control_surface.show_message("USER 1 MODE") self._setup_session(not as_active, not as_enabled) self._setup_step_sequencer(not as_active) self._setup_step_sequencer2(not as_active) self._setup_mixer(not as_active) self._setup_device_controller(not as_active) self._setup_instrument_controller(not as_active) self._setup_user_mode(True, True, False, True) self._update_control_channels() self._mode_index = 1 self._osd.clear() self._osd.mode = "User 1" self._osd.update() elif mode == "drum stepseq": self._control_surface.show_message("DRUM STEP SEQUENCER MODE") self._setup_session(not as_active, not as_enabled) self._setup_instrument_controller(not as_active) self._setup_device_controller(not as_active) self._setup_mixer(not as_active) self._setup_step_sequencer2(not as_active) self._setup_step_sequencer(as_active) self._update_control_channels() self._mode_index = 6 elif mode == "device": self._control_surface.show_message("DEVICE CONTROLLER MODE") self._setup_session(not as_active, not as_enabled) self._setup_step_sequencer(not as_active) self._setup_step_sequencer2(not as_active) self._setup_mixer(not as_active) self._setup_instrument_controller(not as_active) self._setup_device_controller(as_active) self._update_control_channels() self._mode_index = 5 elif mode == "user 2": self._control_surface.show_message("USER 2 MODE") self._setup_session(not as_active, not as_enabled) self._setup_instrument_controller(not as_active) self._setup_device_controller(not as_active) self._setup_mixer(not as_active) self._setup_step_sequencer(not as_active) self._setup_step_sequencer2(not as_active) self._setup_user_mode(False, False, False, False) self._update_control_channels() self._mode_index = 2 self._osd.clear() self._osd.mode = "User 2" self._osd.update() def _setup_session(self, as_active, as_navigation_enabled): assert isinstance(as_active, type(False)) #assert is boolean for button in self._nav_buttons: if as_navigation_enabled: button.set_on_off_values("Mode.Session.On", "Mode.Session.Off") else: button.set_on_off_values("DefaultButton.Disabled", "DefaultButton.Disabled") # matrix self._activate_matrix(True) for scene_index in range( self._session._num_scenes): #iterate over scenes scene = self._session.scene(scene_index) if as_active: #set scene launch buttons scene_button = self._side_buttons[scene_index] scene_button.set_enabled(as_active) scene_button.set_on_off_values("DefaultButton.Disabled", "DefaultButton.Disabled") scene.set_launch_button(scene_button) else: scene.set_launch_button(None) for track_index in range( self._session._num_tracks ): #iterate over tracks of a scene -> clip slots if as_active: #set clip slot launch button button = self._matrix.get_button(track_index, scene_index) button.set_on_off_values("DefaultButton.Disabled", "DefaultButton.Disabled") button.set_enabled(as_active) scene.clip_slot(track_index).set_launch_button(button) else: scene.clip_slot(track_index).set_launch_button(None) if as_active: #Set up stop clip buttons and stop all clips button if self._session._stop_clip_buttons != None: for button in self._session._stop_clip_buttons: button.set_enabled(as_active) # button.set_on_off_values("Session.StopClip", "DefaultButton.Disabled") self._session.set_stop_track_clip_buttons( self._session._stop_clip_buttons) self._side_buttons[self._session._num_scenes].set_enabled( as_active) self._side_buttons[ self._session._num_scenes].set_on_off_values( "Session.StopClip", "DefaultButton.Disabled") self._session.set_stop_all_clips_button( self._side_buttons[self._session._num_scenes]) else: self._session.set_stop_track_clip_buttons(None) self._session.set_stop_all_clips_button(None) else: self._session.set_stop_track_clip_buttons(None) self._session.set_stop_all_clips_button(None) if as_active: # zoom self._zooming.set_zoom_button( self._modes_buttons[0] ) # Set Session button as zoom shift button self._zooming.set_button_matrix(self._matrix) self._zooming.set_scene_bank_buttons(self._side_buttons) self._zooming.set_nav_buttons(self._nav_buttons[0], self._nav_buttons[1], self._nav_buttons[2], self._nav_buttons[3]) self._zooming.update() else: self._zooming.set_zoom_button(None) self._zooming.set_button_matrix(None) self._zooming.set_scene_bank_buttons(None) self._zooming.set_nav_buttons(None, None, None, None) if as_navigation_enabled: # nav buttons (track/scene) self._session.set_track_bank_buttons(self._nav_buttons[3], self._nav_buttons[2]) self._session.set_scene_bank_buttons(self._nav_buttons[1], self._nav_buttons[0]) else: self._session.set_track_bank_buttons(None, None) self._session.set_scene_bank_buttons(None, None) def _setup_instrument_controller(self, as_active): if self._instrument_controller != None: if as_active: self._activate_matrix( False) #Disable matrix buttons (clip slots) self._activate_scene_buttons(True) #Enable side buttons self._activate_navigation_buttons(True) #Enable nav buttons else: for scene_index in range( 8 ): #Restore all matrix buttons and scene launch buttons scene_button = self._side_buttons[scene_index] scene_button.use_default_message( ) # Reset to original channel scene_button.force_next_send() #Flush for track_index in range(8): button = self._matrix.get_button( track_index, scene_index) button.use_default_message( ) # Reset to original channel button.force_next_send() #Flush self._instrument_controller.set_enabled( as_active) #Enable/disable instrument controller def _setup_device_controller(self, as_active): if self._device_controller != None: if as_active: self._activate_scene_buttons(True) self._activate_matrix(True) self._activate_navigation_buttons(True) self._device_controller._is_active = True self._config_button.send_value(32) self._device_controller.set_enabled(True) self._device_controller.update() else: self._device_controller._is_active = False self._device_controller.set_enabled(False) def _setup_user_mode(self, release_matrix=True, release_side_buttons=True, release_nav_buttons=True, drum_rack_mode=True): # user1 -> All True but release_nav_buttons / user2 -> All false for scene_index in range(8): scene_button = self._side_buttons[scene_index] scene_button.set_on_off_values("DefaultButton.Disabled", "DefaultButton.Disabled") scene_button.force_next_send() scene_button.turn_off() scene_button.set_enabled( (not release_side_buttons)) #User2 enabled for track_index in range(8): button = self._matrix.get_button(track_index, scene_index) button.set_on_off_values("DefaultButton.Disabled", "DefaultButton.Disabled") button.turn_off() button.set_enabled((not release_matrix)) #User2 enabled for button in self._nav_buttons: button.set_on_off_values("DefaultButton.Disabled", "DefaultButton.Disabled") button.turn_off() button.set_enabled( (not release_nav_buttons)) #User1 & User2 enabled if drum_rack_mode: #User1 enabled self._config_button.send_value( 2) #Set LP drum rack layout grid mapping mode self._config_button.send_value( 32) #Send enable flashing led config message to LP def _setup_step_sequencer(self, as_active): if (self._stepseq != None): #if(self._stepseq.is_enabled() != as_active): if as_active: self._activate_scene_buttons(True) self._activate_matrix(True) self._activate_navigation_buttons(True) self._config_button.send_value(32) self._stepseq.set_enabled(True) else: self._stepseq.set_enabled(False) def _setup_step_sequencer2(self, as_active): if (self._stepseq2 != None): #if(self._stepseq2.is_enabled() != as_active): if as_active: self._activate_scene_buttons(True) self._activate_matrix(True) self._activate_navigation_buttons(True) self._config_button.send_value(32) self._stepseq2.set_enabled(True) else: self._stepseq2.set_enabled(False) def _setup_mixer(self, as_active): assert isinstance(as_active, type(False)) if as_active: self._activate_navigation_buttons(True) self._activate_scene_buttons(True) self._activate_matrix(True) if (self._sub_modes.is_enabled()): # go back to default mode self._sub_modes.set_mode(-1) else: self._sub_modes.release_controls() self._sub_modes.set_enabled(as_active) def _init_session(self): #self._session.set_stop_clip_value("Session.StopClip") #self._session.set_stop_clip_triggered_value("Session.ClipTriggeredStop") session_height = self._matrix.height() if self._session._stop_clip_buttons != None: session_height = self._matrix.height() - 1 for scene_index in range(session_height): # scene = self._session.scene(scene_index) # scene.set_triggered_value("Session.SceneTriggered") # scene.name = 'Scene_' + str(scene_index) for track_index in range(self._matrix.width()): # clip_slot = scene.clip_slot(track_index) # clip_slot.set_triggered_to_play_value("Session.ClipTriggeredPlay") # clip_slot.set_triggered_to_record_value("Session.ClipTriggeredRecord") # clip_slot.set_stopped_value("Session.ClipStopped") # clip_slot.set_started_value("Session.ClipStarted") # clip_slot.set_recording_value("Session.ClipRecording") # clip_slot.set_record_button_value("Session.RecordButton") # clip_slot.name = str(track_index) + '_Clip_Slot_' + str(scene_index) self._all_buttons.append( self._matrix.get_button(track_index, scene_index)) #self._zooming.set_stopped_value("Zooming.Stopped") #self._zooming.set_selected_value("Zooming.Selected") #self._zooming.set_playing_value("Zooming.Playing") def _activate_navigation_buttons(self, active): for button in self._nav_buttons: button.set_enabled(active) def _activate_scene_buttons(self, active): for button in self._side_buttons: button.set_enabled(active) def _activate_matrix(self, active): for scene_index in range(8): for track_index in range(8): self._matrix.get_button(track_index, scene_index).set_enabled(active) def log_message(self, msg): self._control_surface.log_message(msg) # Update the channels of the buttons in the user modes.. def _update_control_channels(self): new_channel = self.channel_for_current_mode() for button in self._all_buttons: button.set_channel(new_channel) button.force_next_send()
class MainSelectorComponent(ModeSelectorComponent): """ Class that reassigns the button on the launchpad to different functions """ def __init__(self, matrix, top_buttons, side_buttons, config_button, script): assert isinstance(matrix, ButtonMatrixElement) assert matrix.width() == 8 and matrix.height() == 8 assert isinstance(top_buttons, tuple) assert len(top_buttons) == 8 assert isinstance(side_buttons, tuple) assert len(side_buttons) == 8 assert isinstance(config_button, ButtonElement) ModeSelectorComponent.__init__(self) self._script = script self._session = SpecialSessionComponent(matrix.width(), matrix.height()) for scene in self._session._scenes: for slot in scene._clip_slots: slot._triggered_to_play_value = 24 slot._triggered_to_record_value = 27 slot._started_value = 7 slot._recording_value = 9 slot._stopped_value = 8 self._zooming = SessionZoomingComponent(self._session) self._session.name = 'Session_Control' self._zooming.name = 'Session_Overview' self._zooming._stopped_value = 9 self._zooming._playing_value = 7 self._zooming._selected_value = 8 self._matrix = matrix self._side_buttons = side_buttons self._nav_buttons = top_buttons[:4] self._config_button = config_button self._zooming.set_empty_value(LED_OFF) self._all_buttons = [] for button in self._side_buttons + self._nav_buttons: self._all_buttons.append(button) self._sub_modes = SubSelectorComponent(matrix, side_buttons, self._session) self._sub_modes.name = 'Mixer_Modes' self._sub_modes.set_update_callback(self._update_control_channels) self._init_session() self._all_buttons = tuple(self._all_buttons) self.set_modes_buttons(top_buttons[4:]) def disconnect(self): for button in self._modes_buttons: button.remove_value_listener(self._mode_value) self._session = None self._zooming = None for button in self._all_buttons: button.set_on_off_values(127, LED_OFF) self._config_button.turn_off() self._matrix = None self._side_buttons = None self._nav_buttons = None self._config_button = None ModeSelectorComponent.disconnect(self) def session_component(self): return self._session def set_modes_buttons(self, buttons): assert buttons == None or isinstance( buttons, tuple) or len(buttons) == self.number_of_modes() identify_sender = True for button in self._modes_buttons: button.remove_value_listener(self._mode_value) self._modes_buttons = [] if buttons != None: for button in buttons: assert isinstance(button, ButtonElement) self._modes_buttons.append(button) button.add_value_listener(self._mode_value, identify_sender) self.set_mode(0) def number_of_modes(self): return 5 def on_enabled_changed(self): self.update() def set_mode(self, mode): assert (mode in range(self.number_of_modes())) if ((self._mode_index != mode) or (mode == 3)): self._mode_index = mode self.update() def channel_for_current_mode(self): new_channel = self._mode_index + self._sub_modes.mode() if new_channel > 0: new_channel += 3 return new_channel def update(self): assert (self._modes_buttons != None) if self.is_enabled(): #for index in range(len(self._modes_buttons)): # self._modes_buttons[index].set_force_next_value() # if index == self._mode_index: # self._modes_buttons[index].turn_on() # else: # self._modes_buttons[index].turn_off() for scene_index in range(8): self._side_buttons[scene_index].set_enabled(True) for track_index in range(8): self._matrix.get_button(track_index, scene_index).set_enabled(True) for button in self._nav_buttons: button.set_enabled(True) as_active = True as_enabled = True self._session.set_allow_update(False) self._zooming.set_allow_update(False) self._config_button.send_value(40) self._config_button.send_value(1) release_buttons = self._mode_index == 1 if (self._mode_index < 4): self._script._host._set_key_buttons(None) self._script._host.set_enabled(False) self._script._host._set_button_matrix(None) self._script._host._set_alt_button(None) self._script._host._set_shift_button(None) self._script._host._set_nav_buttons(None) for button in self._modes_buttons: button.set_on_off_values(5, 0) if self._mode_index == 0: self._setup_mixer(not as_active) self._setup_session(as_active, as_enabled) elif self._mode_index == 1: self._setup_session(not as_active, not as_enabled) self._setup_mixer(not as_active) self._setup_user(release_buttons) elif self._mode_index == 2: self._setup_session(not as_active, not as_enabled) self._setup_mixer(not as_active) self._setup_user(release_buttons) elif self._mode_index == 3: self._setup_session(not as_active, as_enabled) self._setup_mixer(as_active) elif (self._mode_index == 4): self._setup_session((not as_active), (not as_enabled)) self._setup_mixer((not as_active)) self._setup_user(release_buttons) self._script._host._set_button_matrix(self._matrix) self._script._host._set_key_buttons(self._side_buttons) self._script._host._set_shift_button(self._modes_buttons[0]) self._script._host._set_lock_button(self._modes_buttons[1]) self._script._host._set_alt_button(self._modes_buttons[2]) self._modes_buttons[3].send_value(9) self._script._host._set_nav_buttons(self._nav_buttons) self._script._host.set_enabled(True) else: assert False self._session.set_allow_update(True) self._zooming.set_allow_update(True) self._update_control_channels() if (self._mode_index < 4): for index in range(len(self._modes_buttons)): if (index == self._mode_index): self._modes_buttons[index].turn_on() else: self._modes_buttons[index].turn_off() #self._script.request_rebuild_midi_map() self._script.schedule_message(1, self._session.update) def _update_control_channels(self): if self._mode_index < 4: new_channel = self.channel_for_current_mode() else: new_channel = 15 for button in self._all_buttons: button.set_channel(new_channel) button.set_force_next_value() def _setup_session(self, as_active, as_enabled): assert isinstance(as_active, type(False)) for button in self._nav_buttons: if as_enabled: button.set_on_off_values(GREEN_FULL, GREEN_THIRD) else: button.set_on_off_values(127, LED_OFF) for scene_index in range(8): scene = self._session.scene(scene_index) if as_active: scene_button = self._side_buttons[scene_index] scene_button.set_on_off_values(127, LED_OFF) scene.set_launch_button(scene_button) else: scene.set_launch_button(None) for track_index in range(8): if as_active: button = self._matrix.get_button(track_index, scene_index) button.set_on_off_values(127, LED_OFF) scene.clip_slot(track_index).set_launch_button(button) else: scene.clip_slot(track_index).set_launch_button(None) if as_active: self._zooming.set_zoom_button(self._modes_buttons[0]) self._zooming.set_button_matrix(self._matrix) self._zooming.set_scene_bank_buttons(self._side_buttons) self._zooming.set_nav_buttons(self._nav_buttons[0], self._nav_buttons[1], self._nav_buttons[2], self._nav_buttons[3]) self._zooming.update() else: self._zooming.set_zoom_button(None) self._zooming.set_button_matrix(None) self._zooming.set_scene_bank_buttons(None) self._zooming.set_nav_buttons(None, None, None, None) if as_enabled: self._session.set_track_bank_buttons(self._nav_buttons[3], self._nav_buttons[2]) self._session.set_scene_bank_buttons(self._nav_buttons[1], self._nav_buttons[0]) #self._session.set_show_highlight(True) #Needs to be replaced with L9 equivalent else: self._session.set_track_bank_buttons(None, None) self._session.set_scene_bank_buttons(None, None) #self._session.set_show_highlight(False) #Needs to be replaced with L9 equivalent def _setup_mixer(self, as_active): assert isinstance(as_active, type(False)) as_active and self._sub_modes.is_enabled( ) and self._sub_modes.set_mode(-1) self._sub_modes.set_enabled(as_active) def _setup_user(self, release_buttons): for scene_index in range(8): scene_button = self._side_buttons[scene_index] scene_button.set_on_off_values(127, LED_OFF) scene_button.turn_off() scene_button.set_enabled(not release_buttons) for track_index in range(8): button = self._matrix.get_button(track_index, scene_index) button.set_on_off_values(127, LED_OFF) button.turn_off() button.set_enabled(not release_buttons) for button in self._nav_buttons: button.set_on_off_values(127, LED_OFF) button.turn_off() button.set_enabled(not release_buttons) if release_buttons: self._config_button.send_value(2) self._config_button.send_value(32, force_send=True) def _init_session(self): self._session.set_stop_track_clip_value(AMBER_BLINK) for scene_index in range(self._matrix.height()): scene = self._session.scene(scene_index) scene.set_triggered_value(GREEN_BLINK) scene.name = 'Scene_' + str(scene_index) for track_index in range(self._matrix.width()): clip_slot = scene.clip_slot(track_index) clip_slot.set_triggered_to_play_value(GREEN_BLINK) clip_slot.set_triggered_to_record_value(RED_BLINK) clip_slot.set_stopped_value(AMBER_FULL) clip_slot.set_started_value(GREEN_FULL) clip_slot.set_recording_value(RED_FULL) clip_slot.name = str(track_index) + '_Clip_Slot_' + str( scene_index) self._all_buttons.append( self._matrix.get_button(track_index, scene_index)) self._zooming.set_stopped_value(RED_FULL) self._zooming.set_selected_value(AMBER_FULL) self._zooming.set_playing_value(GREEN_FULL) """Mono Overrides and Additions""" def _mode_value(self, value, sender): assert (len(self._modes_buttons) > 0) assert isinstance(value, int) assert isinstance(sender, ButtonElement) assert (self._modes_buttons.count(sender) == 1) if self._script._host.is_enabled() != True: if ((value is not 0) or (not sender.is_momentary())): if ((self._modes_buttons[1]._last_received_value > 0) and (self._modes_buttons.index(sender) == 2)) or ( (self._modes_buttons[2]._last_received_value > 0) and (self._modes_buttons.index(sender) == 1)): if (self._script._host._active_client != None): self.set_mode(4) else: self._script.show_message( 'Monomodular Script not inserted') else: self.set_mode(self._modes_buttons.index(sender)) else: if self._modes_buttons.index(sender) == 3 and value > 0: self.set_mode(0)
class MainSelectorComponent(ModeSelectorComponent): """ Class that reassigns the button on the launchpad to different functions """ def __init__(self, matrix, top_buttons, side_buttons, config_button, parent): assert isinstance(matrix, ButtonMatrixElement) assert (matrix.width() == 8) and (matrix.height() == 8) assert isinstance(top_buttons, tuple) assert len(top_buttons) == 8 assert isinstance(side_buttons, tuple) assert len(side_buttons) == 8 assert isinstance(config_button, ButtonElement) ModeSelectorComponent.__init__(self) self._parent = parent self._session = SpecialSessionComponent(matrix.width(), matrix.height()) self._zooming = SessionZoomingComponent(self._session) self._session.name = "Session_Control" self._zooming.name = "Session_Overview" self._matrix = matrix self._side_buttons = side_buttons self._nav_buttons = top_buttons[:4] self._config_button = config_button self._zooming.set_empty_value(LED_OFF) self._all_buttons = [] for button in self._side_buttons + self._nav_buttons: self._all_buttons.append(button) self._sub_modes = SubSelectorComponent(matrix, side_buttons, self._session) self._sub_modes.name = "Mixer_Modes" self._sub_modes.set_update_callback(self._update_control_channels) self._stepseq = StepSequencerComponent(self, self._matrix, self._side_buttons, self._nav_buttons) self._quick_mix = None # QuickMixerComponent(self._nav_buttons,self._side_buttons,self) self._device_controller = DeviceControllerComponent(self._matrix, self._side_buttons, self._nav_buttons, self) self._init_session() self._all_buttons = tuple(self._all_buttons) self._mode_index = 0 self._previous_mode_index = -1 self._sub_mode_index = [0, 0, 0, 0] for index in range(4): self._sub_mode_index[index] = 0 self.set_mode_buttons(top_buttons[4:]) def disconnect(self): for button in self._modes_buttons: button.remove_value_listener(self._mode_value) self._session = None self._zooming = None for button in self._all_buttons: button.set_on_off_values(127, LED_OFF) self._config_button.turn_off() self._matrix = None self._side_buttons = None self._nav_buttons = None self._config_button = None ModeSelectorComponent.disconnect(self) def session_component(self): return self._session def _update_mode(self): mode = self._modes_heap[-1][0] assert mode in range(self.number_of_modes()) # self.log_message(str(mode)) if self._mode_index == mode: if self._mode_index == 1: # user mode 1 and device controller self._sub_mode_index[self._mode_index] = (self._sub_mode_index[self._mode_index] + 1) % 2 self.update() elif self._mode_index == 2: # user mode 2 and step sequencer self._sub_mode_index[self._mode_index] = (self._sub_mode_index[self._mode_index] + 1) % 3 self.update() elif self._mode_index == 3: self.update() else: self._sub_mode_index[self._mode_index] = 0 self._previous_mode_index = self._mode_index else: self._mode_index = mode self.update() def set_mode(self, mode): self._clean_heap() self._modes_heap = [(mode, None, None)] # if ((self._mode_index != mode) or (mode == 3) or True): # self._mode_index = mode # self._update_mode() # self.update() def number_of_modes(self): return 4 def on_enabled_changed(self): self.update() def _update_mode_buttons(self): for index in range(4): if self._sub_mode_index[index] == 0: self._modes_buttons[index].set_on_off_values(AMBER_FULL, AMBER_THIRD) if self._sub_mode_index[index] == 1: self._modes_buttons[index].set_on_off_values(GREEN_FULL, GREEN_THIRD) if self._sub_mode_index[index] == 2: self._modes_buttons[index].set_on_off_values(RED_FULL, RED_THIRD) if index == self._mode_index: self._modes_buttons[index].turn_on() else: self._modes_buttons[index].turn_off() def channel_for_current_mode(self): # trying to keep if self._mode_index == 0: return 0 elif self._mode_index == 1: if self._sub_mode_index[self._mode_index] == 0: new_channel = 4 # user 1 else: new_channel = 1 # device ctrl elif self._mode_index == 2: if self._sub_mode_index[self._mode_index] == 0: new_channel = 5 # user 2 else: new_channel = 1 + self._sub_mode_index[self._mode_index] # step seq elif self._mode_index == 3: # mixer modes new_channel = 6 + self._sub_modes.mode() # if (new_channel > 0): # new_channel += 3 return new_channel def update(self): assert self._modes_buttons != None if self.is_enabled(): # for index in range(len(self._modes_buttons)): # self._modes_buttons[index].set_force_next_value() # if index == self._mode_index: # self._modes_buttons[index].turn_on() # else: # self._modes_buttons[index].turn_off() self._update_mode_buttons() # update matrix and side buttons for scene_index in range(8): # update scene button self._side_buttons[scene_index].set_enabled(True) for track_index in range(8): # update matrix self._matrix.get_button(track_index, scene_index).set_enabled(True) for button in self._nav_buttons: button.set_enabled(True) as_active = True as_enabled = True self._session.set_allow_update(False) self._zooming.set_allow_update(False) self._config_button.send_value(40) self._config_button.send_value(1) release_buttons = self._mode_index == 1 if self._mode_index == 0: # session self._setup_mixer((not as_active)) self._setup_device_controller((not as_active)) self._setup_step_sequencer((not as_active), 0) self._setup_device_controller((not as_active)) self._setup_session(as_active, as_enabled) elif self._mode_index == 1: # user mode + device controller self._setup_mixer((not as_active)) if self._sub_mode_index[self._mode_index] == 0: self._setup_step_sequencer((not as_active), 0) self._setup_device_controller((not as_active)) self._setup_session((not as_active), (as_enabled)) self._setup_user1(True, True, True) else: self._setup_session(not as_active, not as_enabled) self._setup_step_sequencer(not as_active, 0) self._setup_device_controller(as_active) elif self._mode_index == 2: self._setup_session((not as_active), (not as_enabled)) self._setup_mixer((not as_active)) self._setup_device_controller((not as_active)) if self._sub_mode_index[self._mode_index] == 0: self._setup_device_controller((not as_active)) self._setup_step_sequencer((not as_active), 0) self._setup_user2(release_buttons) else: self._setup_device_controller((not as_active)) self._setup_step_sequencer(as_active, self._sub_mode_index[self._mode_index]) elif self._mode_index == 3: self._setup_step_sequencer((not as_active), 0) self._setup_device_controller((not as_active)) self._setup_session((not as_active), as_enabled) self._setup_mixer(as_active) else: assert False self._previous_mode_index = self._mode_index self._session.set_allow_update(True) self._zooming.set_allow_update(True) self._update_control_channels() # Update the channels of the buttons in the user modes.. def _update_control_channels(self): new_channel = self.channel_for_current_mode() for button in self._all_buttons: button.set_channel(new_channel) button.set_force_next_value() def _setup_session(self, as_active, as_enabled): assert isinstance(as_active, type(False)) for button in self._nav_buttons: if as_enabled: button.set_on_off_values(GREEN_FULL, GREEN_THIRD) else: button.set_on_off_values(127, LED_OFF) # matrix for scene_index in range(8): scene = self._session.scene(scene_index) if as_active: scene_button = self._side_buttons[scene_index] scene_button.set_on_off_values(127, LED_OFF) scene.set_launch_button(scene_button) else: scene.set_launch_button(None) for track_index in range(8): if as_active: button = self._matrix.get_button(track_index, scene_index) button.set_on_off_values(127, LED_OFF) scene.clip_slot(track_index).set_launch_button(button) else: scene.clip_slot(track_index).set_launch_button(None) # zoom if as_active: self._zooming.set_zoom_button(self._modes_buttons[0]) self._zooming.set_button_matrix(self._matrix) self._zooming.set_scene_bank_buttons(self._side_buttons) self._zooming.set_nav_buttons( self._nav_buttons[0], self._nav_buttons[1], self._nav_buttons[2], self._nav_buttons[3] ) self._zooming.update() else: self._zooming.set_zoom_button(None) self._zooming.set_button_matrix(None) self._zooming.set_scene_bank_buttons(None) self._zooming.set_nav_buttons(None, None, None, None) # nav buttons if as_enabled: self._session.set_track_bank_buttons(self._nav_buttons[3], self._nav_buttons[2]) self._session.set_scene_bank_buttons(self._nav_buttons[1], self._nav_buttons[0]) else: self._session.set_track_bank_buttons(None, None) self._session.set_scene_bank_buttons(None, None) def _setup_quick_mix(self, as_active): if self._quick_mix != None: if as_active: for button in range(8): self._side_buttons[button].set_enabled(True) self._quick_mix._is_active = True self._quick_mix.set_enabled(True) else: self._quick_mix._is_active = False self._quick_mix.set_enabled(False) def _setup_step_sequencer(self, as_active, mode): if self._stepseq != None: if self._stepseq._is_active != as_active or self._stepseq._mode != mode: if as_active: self._stepseq._mode = mode self._stepseq._force_update = True self._stepseq._is_active = True self._stepseq.set_enabled(True) self._stepseq._on_notes_changed() self._stepseq.update_buttons() self._config_button.send_value(32) else: self._stepseq._mode = 1 self._stepseq._is_active = False self._stepseq.set_enabled(False) def _setup_device_controller(self, as_active): if self._device_controller != None: if as_active: # for button in range(8): # self._side_buttons[button].set_enabled(True) self._device_controller._is_active = True self._device_controller.set_enabled(True) self._device_controller.update() self._config_button.send_value(32) else: self._device_controller._is_active = False self._device_controller.set_enabled(False) def _setup_mixer(self, as_active): assert isinstance(as_active, type(False)) if as_active and self._sub_modes.is_enabled(): self._sub_modes.set_mode(-1) self._sub_modes.set_enabled(as_active) def _setup_user1(self, release_matrix=True, release_side_buttons=True, release_nav_buttons=True): for scene_index in range(8): if release_side_buttons: scene_button = self._side_buttons[scene_index] scene_button.set_on_off_values(127, LED_OFF) scene_button.turn_off() scene_button.set_enabled((not release_side_buttons)) for track_index in range(8): button = self._matrix.get_button(track_index, scene_index) button.set_on_off_values(127, LED_OFF) button.turn_off() button.set_enabled((not release_matrix)) for button in self._nav_buttons: if release_nav_buttons: button.set_on_off_values(127, LED_OFF) button.turn_off() button.set_enabled((not release_nav_buttons)) if release_matrix: self._config_button.send_value(2) self._config_button.send_value(32, force_send=True) def _setup_user2(self, release_buttons): for scene_index in range(8): scene_button = self._side_buttons[scene_index] scene_button.set_on_off_values(127, LED_OFF) scene_button.turn_off() scene_button.set_enabled(not release_buttons) for track_index in range(8): button = self._matrix.get_button(track_index, scene_index) button.set_on_off_values(127, LED_OFF) button.turn_off() button.set_enabled(not release_buttons) for button in self._nav_buttons: button.set_on_off_values(127, LED_OFF) button.turn_off() button.set_enabled(not release_buttons) if release_buttons: self._config_button.send_value(2) self._config_button.send_value(32, force_send=True) def _init_session(self): self._session.set_stop_track_clip_value(AMBER_BLINK) for scene_index in range(self._matrix.height()): scene = self._session.scene(scene_index) scene.set_triggered_value(GREEN_BLINK) scene.name = "Scene_" + str(scene_index) for track_index in range(self._matrix.width()): clip_slot = scene.clip_slot(track_index) clip_slot.set_triggered_to_play_value(GREEN_BLINK) clip_slot.set_triggered_to_record_value(RED_BLINK) clip_slot.set_stopped_value(AMBER_FULL) clip_slot.set_started_value(GREEN_FULL) clip_slot.set_recording_value(RED_FULL) clip_slot.name = str(track_index) + "_Clip_Slot_" + str(scene_index) self._all_buttons.append(self._matrix.get_button(track_index, scene_index)) self._zooming.set_stopped_value(RED_FULL) self._zooming.set_selected_value(AMBER_FULL) self._zooming.set_playing_value(GREEN_FULL) def log_message(self, message): self._parent.log_message(message)
class MainSelectorComponent(ModeSelectorComponent): """ Class that reassigns the button on the launchpad to different functions """ def log(self, message): self._parent.log_message((' ' + message + ' ').center(50, '=')) def __init__(self, matrix, top_buttons, side_buttons, config_button, osd, parent): assert isinstance(matrix, ButtonMatrixElement) assert ((matrix.width() == 8) and (matrix.height() == 8)) assert isinstance(top_buttons, tuple) assert (len(top_buttons) == 8) assert isinstance(side_buttons, tuple) assert (len(side_buttons) == 8) assert isinstance(config_button, ButtonElement) ModeSelectorComponent.__init__(self) self._osd = osd self._parent = parent self._mode_index = 0 self._previous_mode_index = -1 self._main_mode_index = 0 self._sub_mode_index = [0, 0, 0, 0] for index in range(4): self._sub_mode_index[index] = 0 self.set_mode_buttons(top_buttons[4:]) if Settings.SESSION__STOP_BUTTONS: #session with bottom stop buttons clip_stop_buttons = [] for column in range(8): clip_stop_buttons.append( matrix.get_button(column, matrix.height() - 1)) self._session = SpecialSessionComponent(matrix.width(), matrix.height() - 1, clip_stop_buttons, self) else: #no stop buttons self._session = SpecialSessionComponent(matrix.width(), matrix.height(), None, self) self._session.set_osd(self._osd) self._session.name = 'Session_Control' self._zooming = DeprecatedSessionZoomingComponent(self._session) self._zooming.name = 'Session_Overview' self._zooming.set_empty_value(LED_OFF) self._matrix = matrix self._side_buttons = side_buttons self._nav_buttons = top_buttons[:4] self._config_button = config_button self._all_buttons = [] for button in self._side_buttons + self._nav_buttons: self._all_buttons.append(button) self._sub_modes = SubSelectorComponent(matrix, side_buttons, self._session) self._sub_modes.name = 'Mixer_Modes' self._sub_modes._mixer.set_osd(self._osd) self._sub_modes.set_update_callback(self._update_control_channels) self._stepseq = StepSequencerComponent(self._matrix, self._side_buttons, self._nav_buttons, self) self._stepseq.set_osd(self._osd) self._stepseq2 = StepSequencerComponent2(self._matrix, self._side_buttons, self._nav_buttons, self) self._stepseq2.set_osd(self._osd) self._instrument_controller = InstrumentControllerComponent( self._matrix, self._side_buttons, self._nav_buttons, self) self._instrument_controller.set_osd(self._osd) self._device_controller = DeviceControllerComponent( self._matrix, self._side_buttons, self._nav_buttons, self) self._device_controller.set_osd(self._osd) self._init_session() self._all_buttons = tuple(self._all_buttons) def disconnect(self): for button in self._modes_buttons: button.remove_value_listener(self._mode_value) self._session = None self._zooming = None for button in self._all_buttons: button.set_on_off_values(127, LED_OFF) self._config_button.turn_off() self._matrix = None self._side_buttons = None self._nav_buttons = None self._config_button = None ModeSelectorComponent.disconnect(self) def session_component(self): return self._session def _update_mode(self): mode = self._modes_heap[-1][0] assert mode in range(self.number_of_modes()) if self._main_mode_index == mode: if self._main_mode_index == 1: # user mode 1 and device controller and instrument mode self._sub_mode_index[self._main_mode_index] = ( self._sub_mode_index[self._main_mode_index] + 1) % 3 self.update() elif self._main_mode_index == 2: # user mode 2 and step sequencer self._sub_mode_index[self._main_mode_index] = ( self._sub_mode_index[self._main_mode_index] + 1) % 3 self.update() elif self._main_mode_index == 3: self.update() else: self._sub_mode_index[self._main_mode_index] = 0 self._mode_index = 0 self._previous_mode_index = self._main_mode_index else: self._main_mode_index = mode self.update() def set_mode(self, mode): self._clean_heap() self._modes_heap = [(mode, None, None)] # if ((self.__main_mode_index != mode) or (mode == 3) or True): # self._main_mode_index = mode # self._update_mode() # self.update() def number_of_modes(self): return 1 + 3 + 3 + 1 def on_enabled_changed(self): self.update() def _update_mode_buttons(self): for index in range(4): if (self._sub_mode_index[index] == 0): self._modes_buttons[index].set_on_off_values( AMBER_FULL, AMBER_THIRD) if (self._sub_mode_index[index] == 1): self._modes_buttons[index].set_on_off_values( GREEN_FULL, GREEN_THIRD) if (self._sub_mode_index[index] == 2): self._modes_buttons[index].set_on_off_values( RED_FULL, RED_THIRD) if (index == self._main_mode_index): self._modes_buttons[index].turn_on() else: self._modes_buttons[index].turn_off() def channel_for_current_mode(self): # in this code, midi channels start at 0. # so channels range from 0 - 15. # mapping to 1-16 in the real world if self._main_mode_index == 0: new_channel = 0 # session elif self._main_mode_index == 1: if self._sub_mode_index[self._main_mode_index] == 0: new_channel = 11 # instrument controller # instrument controller uses base channel plus the 4 next ones. 11,12,13,14,15 if self._instrument_controller != None: self._instrument_controller.base_channel = new_channel elif self._sub_mode_index[self._main_mode_index] == 1: new_channel = 3 # device controller elif self._sub_mode_index[self._main_mode_index] == 2: new_channel = 4 # plain user mode 1 elif self._main_mode_index == 2: if self._sub_mode_index[self._main_mode_index] == 0: new_channel = 1 # step seq elif self._sub_mode_index[self._main_mode_index] == 1: new_channel = 2 # melodic step seq elif self._sub_mode_index[self._main_mode_index] == 2: new_channel = 5 # plain user mode 2 elif self._main_mode_index == 3: # mixer modes # mixer uses base channel 7 and the 4 next ones. new_channel = 6 + self._sub_modes.mode() # 6,7,8,9,10 return new_channel def update(self): assert (self._modes_buttons != None) if self.is_enabled(): self._update_mode_buttons() as_active = True as_enabled = True self._session.set_allow_update(False) self._zooming.set_allow_update(False) self._config_button.send_value(40) self._config_button.send_value(1) if self._main_mode_index == 0: # session self._setup_mixer(not as_active) self._setup_device_controller(not as_active) self._setup_step_sequencer(not as_active) self._setup_step_sequencer2(not as_active) self._setup_instrument_controller(not as_active) self._setup_session(as_active, as_enabled) self._update_control_channels() self._mode_index = 0 elif self._main_mode_index == 1 or self._main_mode_index == 2: self._setup_usermode(Settings.USER_MODES[ (self._main_mode_index - 1) * 3 + self._sub_mode_index[self._main_mode_index]]) #if self._sub_mode_index[self._main_mode_index] == 0: # self._setup_usermode(Settings.USER_MODES[0]) #elif self._sub_mode_index[self._main_mode_index] == 1: # self._setup_usermode(Settings.USER_MODES[1]) #else: # self._setup_usermode(Settings.USER_MODES[2]) #elif self._main_mode_index == 2: # if self._sub_mode_index[self._main_mode_index] == 0: # self._setup_usermode(Settings.USER_MODES[3]) # elif self._sub_mode_index[self._main_mode_index] == 1: # self._setup_usermode(Setting.USER_MODES[4]) # else: # self._setup_usermode(Settings.USER_MODES[5]) elif self._main_mode_index == 3: # mixer self._setup_device_controller(not as_active) self._setup_step_sequencer(not as_active) self._setup_step_sequencer2(not as_active) self._setup_instrument_controller(not as_active) self._setup_session(not as_active, as_enabled) self._setup_mixer(as_active) self._update_control_channels() self._mode_index = 3 else: assert False self._previous_mode_index = self._main_mode_index self._session.set_allow_update(True) self._zooming.set_allow_update(True) #self.log_message("main selector update") #for line in traceback.format_stack(): # self.log_message(line.strip()) def _setup_usermode(self, mode): as_active = True as_enabled = True if mode == "instrument": self._setup_session(not as_active, not as_enabled) self._setup_step_sequencer(not as_active) self._setup_step_sequencer2(not as_active) self._setup_mixer(not as_active) self._setup_device_controller(not as_active) self._update_control_channels() self._setup_instrument_controller(as_active) self._mode_index = 4 elif mode == "melodic stepseq": self._setup_session(not as_active, not as_enabled) self._setup_instrument_controller(not as_active) self._setup_device_controller(not as_active) self._setup_mixer(not as_active) self._setup_step_sequencer(not as_active) self._setup_step_sequencer2(as_active) self._update_control_channels() self._mode_index = 7 elif mode == "user 1": self._setup_session(not as_active, not as_enabled) self._setup_step_sequencer(not as_active) self._setup_step_sequencer2(not as_active) self._setup_mixer(not as_active) self._setup_device_controller(not as_active) self._setup_instrument_controller(not as_active) self._setup_user_mode(True, True, False, True) self._update_control_channels() self._mode_index = 1 self._osd.clear() self._osd.mode = "User 1" self._osd.update() elif mode == "drum stepseq": self._setup_session(not as_active, not as_enabled) self._setup_instrument_controller(not as_active) self._setup_device_controller(not as_active) self._setup_mixer(not as_active) self._setup_step_sequencer2(not as_active) self._setup_step_sequencer(as_active) self._update_control_channels() self._mode_index = 6 elif mode == "device": self._setup_session(not as_active, not as_enabled) self._setup_step_sequencer(not as_active) self._setup_step_sequencer2(not as_active) self._setup_mixer(not as_active) self._setup_instrument_controller(not as_active) self._setup_device_controller(as_active) self._update_control_channels() self._mode_index = 5 elif mode == "user 2": self._setup_session(not as_active, not as_enabled) self._setup_instrument_controller(not as_active) self._setup_device_controller(not as_active) self._setup_mixer(not as_active) self._setup_step_sequencer(not as_active) self._setup_step_sequencer2(not as_active) self._setup_user_mode(False, False, False, False) self._update_control_channels() self._mode_index = 2 self._osd.clear() self._osd.mode = "User 2" self._osd.update() def _setup_session(self, as_active, as_enabled): assert isinstance(as_active, type(False)) for button in self._nav_buttons: if as_enabled: button.set_on_off_values(GREEN_FULL, GREEN_THIRD) else: button.set_on_off_values(127, LED_OFF) # matrix self._activate_matrix(True) for scene_index in range(self._session._num_scenes): scene = self._session.scene(scene_index) if as_active: scene_button = self._side_buttons[scene_index] scene_button.set_enabled(as_active) scene_button.set_on_off_values(127, LED_OFF) scene.set_launch_button(scene_button) else: scene.set_launch_button(None) for track_index in range(self._session._num_tracks): if as_active: button = self._matrix.get_button(track_index, scene_index) button.set_on_off_values(127, LED_OFF) button.set_enabled(as_active) scene.clip_slot(track_index).set_launch_button(button) else: scene.clip_slot(track_index).set_launch_button(None) if as_active: if self._session._stop_clip_buttons != None: for button in self._session._stop_clip_buttons: button.set_enabled(as_active) button.set_on_off_values(AMBER_THIRD, LED_OFF) self._session.set_stop_track_clip_buttons( self._session._stop_clip_buttons) self._side_buttons[self._session._num_scenes].set_enabled( as_active) self._side_buttons[ self._session._num_scenes].set_on_off_values( AMBER_THIRD, LED_OFF) self._session.set_stop_all_clips_button( self._side_buttons[self._session._num_scenes]) else: self._session.set_stop_track_clip_buttons(None) self._session.set_stop_all_clips_button(None) else: self._session.set_stop_track_clip_buttons(None) self._session.set_stop_all_clips_button(None) # zoom if as_active: self._zooming.set_zoom_button(self._modes_buttons[0]) self._zooming.set_button_matrix(self._matrix) self._zooming.set_scene_bank_buttons(self._side_buttons) self._zooming.set_nav_buttons(self._nav_buttons[0], self._nav_buttons[1], self._nav_buttons[2], self._nav_buttons[3]) self._zooming.update() else: self._zooming.set_zoom_button(None) self._zooming.set_button_matrix(None) self._zooming.set_scene_bank_buttons(None) self._zooming.set_nav_buttons(None, None, None, None) # nav buttons if as_enabled: self._session.set_track_bank_buttons(self._nav_buttons[3], self._nav_buttons[2]) self._session.set_scene_bank_buttons(self._nav_buttons[1], self._nav_buttons[0]) else: self._session.set_track_bank_buttons(None, None) self._session.set_scene_bank_buttons(None, None) def _setup_instrument_controller(self, enabled): if self._instrument_controller != None: if enabled: self._activate_matrix(False) self._activate_scene_buttons(True) self._activate_navigation_buttons(True) else: for scene_index in range(8): scene_button = self._side_buttons[scene_index] scene_button.use_default_message() scene_button.force_next_send() for track_index in range(8): button = self._matrix.get_button( track_index, scene_index) button.use_default_message() button.force_next_send() self._instrument_controller.set_enabled(enabled) def _setup_device_controller(self, as_active): if self._device_controller != None: if as_active: self._activate_scene_buttons(True) self._activate_matrix(True) self._activate_navigation_buttons(True) self._device_controller._is_active = True self._config_button.send_value(32) self._device_controller.set_enabled(True) self._device_controller.update() else: self._device_controller._is_active = False self._device_controller.set_enabled(False) def _setup_user_mode(self, release_matrix=True, release_side_buttons=True, release_nav_buttons=True, drum_rack_mode=True): for scene_index in range(8): scene_button = self._side_buttons[scene_index] scene_button.set_on_off_values(127, LED_OFF) scene_button.force_next_send() scene_button.turn_off() scene_button.set_enabled((not release_side_buttons)) for track_index in range(8): button = self._matrix.get_button(track_index, scene_index) button.set_on_off_values(127, LED_OFF) button.turn_off() button.set_enabled((not release_matrix)) for button in self._nav_buttons: button.set_on_off_values(127, LED_OFF) button.turn_off() button.set_enabled((not release_nav_buttons)) if drum_rack_mode: self._config_button.send_value(2) self._config_button.send_value(32) def _setup_step_sequencer(self, as_active): if (self._stepseq != None): #if(self._stepseq.is_enabled() != as_active): if as_active: self._activate_scene_buttons(True) self._activate_matrix(True) self._activate_navigation_buttons(True) self._config_button.send_value(32) self._stepseq.set_enabled(True) else: self._stepseq.set_enabled(False) def _setup_step_sequencer2(self, as_active): if (self._stepseq2 != None): #if(self._stepseq2.is_enabled() != as_active): if as_active: self._activate_scene_buttons(True) self._activate_matrix(True) self._activate_navigation_buttons(True) self._config_button.send_value(32) self._stepseq2.set_enabled(True) else: self._stepseq2.set_enabled(False) def _setup_mixer(self, as_active): assert isinstance(as_active, type(False)) if as_active: self._activate_navigation_buttons(True) self._activate_scene_buttons(True) self._activate_matrix(True) if (self._sub_modes.is_enabled()): # go back to default mode self._sub_modes.set_mode(-1) else: self._sub_modes.release_controls() self._sub_modes.set_enabled(as_active) def _init_session(self): major = self._parent._live_major_version minor = self._parent._live_minor_version bugfix = self._parent._live_bugfix_version if (major >= 9 and minor > 1) or (major >= 9 and minor >= 1 and bugfix >= 2): # api changed in 9.1.2 self._session.set_stop_clip_value(AMBER_THIRD) self._session.set_stop_clip_triggered_value(AMBER_BLINK) else: # api for 9.1.1 below self._session.set_stop_track_clip_value(AMBER_BLINK) session_height = self._matrix.height() if self._session._stop_clip_buttons != None: session_height = self._matrix.height() - 1 for scene_index in range(session_height): scene = self._session.scene(scene_index) scene.set_triggered_value(GREEN_BLINK) scene.name = 'Scene_' + str(scene_index) for track_index in range(self._matrix.width()): clip_slot = scene.clip_slot(track_index) clip_slot.set_triggered_to_play_value(GREEN_BLINK) clip_slot.set_triggered_to_record_value(RED_BLINK) clip_slot.set_stopped_value(AMBER_FULL) clip_slot.set_started_value(GREEN_FULL) clip_slot.set_recording_value(RED_FULL) clip_slot.set_record_button_value(RED_THIRD) clip_slot.name = str(track_index) + '_Clip_Slot_' + str( scene_index) self._all_buttons.append( self._matrix.get_button(track_index, scene_index)) self._zooming.set_stopped_value(RED_FULL) self._zooming.set_selected_value(AMBER_FULL) self._zooming.set_playing_value(GREEN_FULL) def _activate_navigation_buttons(self, active): for button in self._nav_buttons: button.set_enabled(active) def _activate_scene_buttons(self, active): for button in self._side_buttons: button.set_enabled(active) def _activate_matrix(self, active): for scene_index in range(8): for track_index in range(8): self._matrix.get_button(track_index, scene_index).set_enabled(active) def log_message(self, msg): self._parent.log_message(msg) # Update the channels of the buttons in the user modes.. def _update_control_channels(self): new_channel = self.channel_for_current_mode() for button in self._all_buttons: button.set_channel(new_channel) button.set_force_next_value()
class KontrolF1(ControlSurface): __module__ = __name__ __doc__ = " Script for Native Instruments Traktor Kontrol F1 Controller " def __init__(self, c_instance): ControlSurface.__init__(self, c_instance) self.set_suppress_rebuild_requests(True) self._suppress_send_midi = True self._suppress_session_highlight = True self._suggested_input_port = 'Traktor Kontrol F1' self._suggested_output_port = 'Traktor Kontrol F1' self._blink_state = False self._matrix = ButtonMatrixElement() for row in range(HEIGHT): button_row = [ ConfigurableButtonElement(c_instance, True, MIDI_CC_TYPE, 2, ((row * HEIGHT) + column)) for column in range(WIDTH) ] self._matrix.add_row(tuple(button_row)) self._nav_buttons = [ ConfigurableButtonElement(c_instance, True, MIDI_CC_TYPE, 0, NAV_ENCODER), ConfigurableButtonElement(c_instance, True, MIDI_CC_TYPE, 0, TOGGLE_LEFT_DOWN) ] self._scene_buttons = [ ConfigurableButtonElement(c_instance, True, MIDI_CC_TYPE, 0, SCENE_LAUNCH[index]) for index in range(HEIGHT) ] self._stop_buttons = [] for index in range(WIDTH): self._stop_buttons.append(ConfigurableButtonElement(c_instance, True, MIDI_CC_TYPE, 0, STOP_LAUNCH[index])) self._session = SpecialSessionComponent(self._matrix.width(), self._matrix.height()) self._all_buttons = [] for button in (self._scene_buttons + self._nav_buttons + self._stop_buttons): self._all_buttons.append(button) for scene_index in range(self._matrix.height()): for track_index in range(self._matrix.width()): self._all_buttons.append(self._matrix.get_button(track_index, scene_index)) self._all_buttons = tuple(self._all_buttons) self._suppress_session_highlight = False self.set_suppress_rebuild_requests(False) self._suppress_send_midi = False self.set_enabled(True) self.update() self._set_session_highlight(0,0,WIDTH,HEIGHT,True) def disconnect(self): self._suppress_send_midi = True self._session = None for button in self._all_buttons: button.set_on_off_values(127, 0) self._matrix = None self._stop_buttons = None self._scene_buttons = None self._nav_buttons = None ControlSurface.disconnect(self) self._suppress_send_midi = False def update_display(self): tracks = self.song().visible_tracks number_tracks = len(tracks) if self._blink_state: self._blink_state = False else: self._blink_state = True for track in range(WIDTH): to = track + self._session._track_offset if (to < number_tracks): for y in range(HEIGHT): ys = self._session._scene_offset+y yx = (y*4)+track slot = tracks[to].clip_slots[ys] if (slot.controls_other_clips) or (slot.has_clip): if slot.is_triggered: if self._blink_state: self._send_midi(tuple([178,yx,40])) else: self._send_midi(tuple([178,yx,127])) def refresh_state(self): ControlSurface.refresh_state(self) def _send_midi(self, midi_bytes): if (not self._suppress_send_midi): ControlSurface._send_midi(self, midi_bytes) def _update_hardware(self): pass def _send_challenge(self): pass def _config_value(self, value): assert (value in range(128)) def _set_session_highlight(self, track_offset, scene_offset, width, height, include_return_tracks): ControlSurface._set_session_highlight(self, track_offset, scene_offset, width, height, include_return_tracks) def _install_forwarding(self, control): result = ControlSurface._install_forwarding(self, control) return result def _translate_message(self, type, from_identifier, from_channel, to_identifier, to_channel): ControlSurface._translate_message(self, type, from_identifier, from_channel, to_identifier, to_channel) def on_enabled_changed(self): self.update() def update(self): for scene_index in range(HEIGHT): self._scene_buttons[scene_index].set_enabled(True) self._stop_buttons[scene_index].set_enabled(True) for track_index in range(WIDTH): self._matrix.get_button(track_index, scene_index).set_enabled(True) for button in self._nav_buttons: button.set_enabled(True) self._session.set_allow_update(False) for scene_index in range(HEIGHT): scene = self._session.scene(scene_index) scene.set_launch_button(self._scene_buttons[scene_index]) for track_index in range(WIDTH): scene.clip_slot(track_index).set_launch_button(self._matrix.get_button(track_index, scene_index)) #self.log_message(str(tuple(self._stop_buttons))) self._session.set_stop_track_clip_buttons(tuple(self._stop_buttons)) self._session.set_track_bank_buttons(self._nav_buttons[1], self._nav_buttons[1]) self._session.set_scene_bank_buttons(self._nav_buttons[0], self._nav_buttons[0]) self._session.set_allow_update(True)
class MainSelectorComponent(ModeSelectorComponent): " CLASS THAT REASSIGNS THE BUTTON ON THE LAUNCHPAD TO DIFFERENT FUNCTIONS " " INIT " def __init__(self, matrix, top_buttons, side_buttons, config_button): assert isinstance(matrix, ButtonMatrixElement) assert ((matrix.width() == 8) and (matrix.height() == 8)) assert isinstance(top_buttons, tuple) assert (len(top_buttons) == 8) assert isinstance(side_buttons, tuple) assert (len(side_buttons) == 8) assert isinstance(config_button, ButtonElement) ModeSelectorComponent.__init__(self) self._session = SpecialSessionComponent(self, len(self.song().tracks), matrix.height(), side_buttons) self._session.name = "Session_Control" self._matrix = matrix self._side_buttons = side_buttons self._nav_buttons = top_buttons[:4] self._config_button = config_button self._all_buttons = [] for button in (self._side_buttons + self._nav_buttons): self._all_buttons.append(button) self._sub_modes = SpecialMixerSelectorComponent(matrix, side_buttons, self._session) self._sub_modes.name = "Mixer_Modes" self._sub_modes.set_update_callback(self._update_control_channels) self._init_session() self._all_buttons = tuple(self._all_buttons) self.set_modes_buttons(top_buttons[4:]) # mixer-session hack self._buttons_for_mixer = [] for button in (self._side_buttons[5:]): self._buttons_for_mixer.append(button) for scene_index in range(self._matrix.height()): for track_index in range(self._matrix.width()): if scene_index > SESSION_HEIGHT_FOR_MIXER: self._buttons_for_mixer.append(self._matrix.get_button(track_index, scene_index)) " DISCONNECT " def disconnect(self): for button in self._modes_buttons: button.remove_value_listener(self._mode_value) self._session = None for button in self._all_buttons: button.set_on_off_values(127, LED_OFF) self._config_button.turn_off() self._matrix = None self._side_buttons = None self._nav_buttons = None self._config_button = None self._buttons_for_mixer = None ModeSelectorComponent.disconnect(self) " GET SESSION COMPONENT " def session_component(self): return self._session " SET THE MODE BUTTONS " def set_modes_buttons(self, buttons): assert ((buttons == None) or (isinstance(buttons, tuple) or (len(buttons) == self.number_of_modes()))) identify_sender = True for button in self._modes_buttons: button.remove_value_listener(self._mode_value) self._modes_buttons = [] if (buttons != None): for button in buttons: assert isinstance(button, ButtonElement) self._modes_buttons.append(button) button.add_value_listener(self._mode_value, identify_sender) self.set_mode(0) " GET AMOUNT OF MODES " def number_of_modes(self): return 4 " CHANGE CALLBACK " def on_enabled_changed(self): self.update() " SET THE MODE " def set_mode(self, mode): assert (mode in range(self.number_of_modes())) if ((self._mode_index != mode) or (mode == 3) or True): self._mode_index = mode self.update() " UPDATE MODE BUTTONS " def _update_mode_buttons(self): for index in range(4): if (index == self._mode_index): self._modes_buttons[index].turn_on() else: self._modes_buttons[index].turn_off() " SET CHANNEL FOR THE CURRONT MODE " def channel_for_current_mode(self): #trying to keep if self._mode_index==0: return 0 elif self._mode_index==1: new_channel=4#user 1 elif self._mode_index==2: new_channel=5#user 2 elif self._mode_index==3: new_channel = 6 + self._sub_modes.mode() #mixer modes return new_channel " UPDATE THE SHIT " def update(self): assert (self._modes_buttons != None) if self.is_enabled(): self._update_mode_buttons() #update matrix and side buttons for scene_index in range(self._matrix.height()): #update scene button self._side_buttons[scene_index].set_enabled(True) for track_index in range(self._matrix.width()): #update matrix self._matrix.get_button(track_index, scene_index).set_enabled(True) for button in self._nav_buttons: button.set_enabled(True) as_active = True as_enabled = True self._session.set_allow_update(False) self._config_button.send_value(40) self._config_button.send_value(1) release_buttons = (self._mode_index == 1) if (self._mode_index == 0): #session self._setup_mixer((not as_active)) self._setup_session(as_active, as_enabled, False) elif (self._mode_index == 1): #user mode 1 self._setup_mixer((not as_active)) self._setup_session((not as_active), (not as_enabled), False) self._setup_user1(True,True,True) elif (self._mode_index == 2): #user mode 2 self._setup_mixer((not as_active)) self._setup_session((not as_active), (not as_enabled), False) self._setup_user2(release_buttons) elif (self._mode_index == 3): #mixer self._setup_session((as_active), as_enabled, True) self._setup_mixer(as_active) else: assert False self._session.set_allow_update(True) self._update_control_channels() " UPDATE THE CHANNELS OF THE BUTTONS IN THE USER MODES.. " def _update_control_channels(self): new_channel = self.channel_for_current_mode() if self._mode_index == 3: # skip the upper part of the matrix and buttons for button in self._buttons_for_mixer: button.set_channel(new_channel) button.set_force_next_value() else: for button in self._all_buttons: button.set_channel(new_channel) button.set_force_next_value() " SETUP THE SESSION " def _setup_session(self, as_active, as_enabled, for_mixer): #log("setup_session (active: " + str(as_active) + ", enabled: " + str(as_enabled) + ", forMixer: " + str(for_mixer) + ")") assert isinstance(as_active, type(False)) assert isinstance(as_enabled, type(False)) assert isinstance(for_mixer, type(False)) # --------------------------------------------------------------------- nav button color for button in self._nav_buttons: if as_enabled: button.set_on_off_values(GREEN_FULL, GREEN_THIRD) else: button.set_on_off_values(127, LED_OFF) # --------------------------------------------------------------------- matrix for scene_index in range(self._matrix.height()): scene = self._session.scene(scene_index) if for_mixer: if scene_index <= SESSION_HEIGHT_FOR_MIXER: scene_button = self._side_buttons[scene_index] scene_button.set_on_off_values(127, GREEN_THIRD) scene.set_launch_button(scene_button) else: scene.set_launch_button(None) elif as_active and (not for_mixer): scene_button = self._side_buttons[scene_index] scene_button.set_on_off_values(127, GREEN_THIRD) scene.set_launch_button(scene_button) else: scene.set_launch_button(None) # SLOT BUTTONS button_index = 0 for track_index in range(len(self.song().tracks)): if self.song().tracks[track_index].is_foldable: if button_index < GROUPS_CONSIDERED: if for_mixer: if scene_index <= SESSION_HEIGHT_FOR_MIXER: button = self._matrix.get_button(button_index, scene_index) button.set_on_off_values(127, LED_OFF) scene.clip_slot(track_index).set_launch_button(button) else: scene.clip_slot(track_index).set_launch_button(None) elif as_active and (not for_mixer): button = self._matrix.get_button(button_index, scene_index) button.set_on_off_values(127, LED_OFF) scene.clip_slot(track_index).set_launch_button(button) else: scene.clip_slot(track_index).set_launch_button(None) button_index = button_index + 1 else: scene.clip_slot(track_index).set_launch_button(None) # --------------------------------------------------------------------- nav buttons if as_enabled or for_mixer: self._session.set_scene_bank_buttons(self._nav_buttons[1], self._nav_buttons[0]) else: self._session.set_scene_bank_buttons(None, None) " SETUP THE MIXER " def _setup_mixer(self, as_active): assert isinstance(as_active, type(False)) self._sub_modes.set_enabled(as_active) " SETUP USER 1 " def _setup_user1(self, release_matrix=True,release_side_buttons =True,release_nav_buttons = True): for scene_index in range(8): if(release_side_buttons): scene_button = self._side_buttons[scene_index] scene_button.set_on_off_values(127, LED_OFF) scene_button.turn_off() scene_button.set_enabled((not release_side_buttons)) for track_index in range(8): button = self._matrix.get_button(track_index, scene_index) button.set_on_off_values(127, LED_OFF) button.turn_off() button.set_enabled((not release_matrix)) for button in self._nav_buttons: if(release_nav_buttons): button.set_on_off_values(127, LED_OFF) button.turn_off() button.set_enabled((not release_nav_buttons)) if release_matrix: self._config_button.send_value(2) self._config_button.send_value(32, force_send=True) " SETUP USER 2 " def _setup_user2(self, release_buttons): for scene_index in range(8): scene_button = self._side_buttons[scene_index] scene_button.set_on_off_values(127, LED_OFF) scene_button.turn_off() scene_button.set_enabled((not release_buttons)) for track_index in range(8): button = self._matrix.get_button(track_index, scene_index) button.set_on_off_values(127, LED_OFF) button.turn_off() button.set_enabled((not release_buttons)) for button in self._nav_buttons: button.set_on_off_values(127, LED_OFF) button.turn_off() button.set_enabled((not release_buttons)) if release_buttons: self._config_button.send_value(2) self._config_button.send_value(32, force_send=True) " INIT THE SESSION " def _init_session(self): self._session.set_stop_track_clip_value(AMBER_BLINK) # SCENES for scene_index in range(self._matrix.height()): scene = self._session.scene(scene_index) scene.set_triggered_value(GREEN_BLINK) scene.name = ("Scene_" + str(scene_index)) # SLOTS button_index = 0 for track_index in range(len(self.song().tracks)): if button_index < GROUPS_CONSIDERED: if self.song().tracks[track_index].is_foldable: clip_slot = scene.clip_slot(track_index) clip_slot.set_triggered_to_play_value(GREEN_BLINK) clip_slot.set_triggered_to_record_value(RED_BLINK) clip_slot.set_stopped_value(AMBER_FULL) clip_slot.set_started_value(GREEN_FULL) clip_slot.set_recording_value(RED_FULL) clip_slot.name = ((str(track_index) + "_Clip_Slot_") + str(scene_index)) self._all_buttons.append(self._matrix.get_button(button_index, scene_index)) button_index = button_index + 1
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 MainSelectorComponent(ModeSelectorComponent): __module__ = __name__ __doc__ = ' Class that reassigns the button on the launchpad to different functions ' def __init__(self, matrix, top_buttons, side_buttons, config_button, knobs, sliders, script): assert isinstance(matrix, ButtonMatrixElement) assert ((matrix.width() == 8) and (matrix.height() == 8)) assert isinstance(top_buttons, tuple) assert (len(top_buttons) == 8) assert isinstance(side_buttons, tuple) assert (len(side_buttons) == 8) assert isinstance(config_button, ButtonElement) ModeSelectorComponent.__init__(self) self._script = script self._session = SpecialSessionComponent(matrix.width(), matrix.height()) for scene in self._session._scenes: for slot in scene._clip_slots: slot._triggered_to_play_value = 4 slot._triggered_to_record_value = 3 slot._started_value = 2 slot._recording_value = 1 slot._stopped_value = 127 self._zooming = SessionZoomingComponent(self._session) self._zooming._stopped_value = 127 self._zooming._playing_value = 2 self._zooming._selected_value = 1 self._matrix = matrix self._knobs = knobs self._sliders = sliders self._side_buttons = side_buttons self._nav_buttons = top_buttons[:4] self._config_button = config_button self._shift_button = top_buttons[5] self._zooming.set_empty_value(LED_OFF) self._all_buttons = [] for button in (self._side_buttons + self._nav_buttons): self._all_buttons.append(button) self._shift_pressed = 0 self._shift_pressed_timer = 0 self._last_normal_mode = 0 self._shift_button = None self.set_shift_button(top_buttons[6]) self._sub_modes = SubSelectorComponent(matrix, side_buttons, self._session) self._sub_modes.set_update_callback(self._update_control_channels) self._init_session() self._all_buttons = tuple(self._all_buttons) self.set_modes_buttons(top_buttons[4:6]) def disconnect(self): for button in self._modes_buttons: button.remove_value_listener(self._mode_value) self._session = None self._zooming = None for button in self._all_buttons: button.set_on_off_values(127, LED_OFF) self._config_button.turn_off() self._matrix = None self._side_buttons = None self._nav_buttons = None self._config_button = None ModeSelectorComponent.disconnect(self) def set_shift_button(self, button): assert ((button == None) or (isinstance(button, FlashingButtonElement))) if self._shift_button != None: self._shift_button.remove_value_listener(self._shift_value) self._shift_button = button if self._shift_button != None: self._shift_button.add_value_listener(self._shift_value) def _shift_value(self, value): self._shift_pressed = int(value != 0) if self._shift_pressed > 0: if (self._shift_pressed_timer + 5) > self._script._timer: if(self._script._host.is_enabled() != True): self.set_mode(4) else: self._script.log_message('here') self.set_mode(self._last_normal_mode) else: self._shift_pressed_timer = self._script._timer % 256 if(self._script._host.is_enabled() != True): if(self._mode_index == 1): if value > 0: self._session.set_track_bank_buttons(None, None) self._session.set_scene_bank_buttons(None, None) self._sub_modes.set_modes_buttons(self._nav_buttons) self._sub_modes.update() else: self._sub_modes.set_modes_buttons(None) self._session.set_track_bank_buttons(self._nav_buttons[3], self._nav_buttons[2]) self._session.set_scene_bank_buttons(self._nav_buttons[1], self._nav_buttons[0]) self._sub_modes.update() elif(self._mode_index == 0): self._setup_session(True, True) self._session.update() def set_modes_buttons(self, buttons): assert ((buttons == None) or (isinstance(buttons, tuple) or (len(buttons) == 2))) identify_sender = True for button in self._modes_buttons: button.remove_value_listener(self._mode_value) self._modes_buttons = [] if (buttons != None): for button in buttons: assert isinstance(button, ButtonElement) self._modes_buttons.append(button) button.add_value_listener(self._mode_value, identify_sender) self.set_mode(0) def _mode_value(self, value, sender): assert (len(self._modes_buttons) > 0) assert isinstance(value, int) assert isinstance(sender, ButtonElement) assert (self._modes_buttons.count(sender) == 1) if self._script._host.is_enabled() != True: if ((value is not 0) or (not sender.is_momentary())): if self._shift_pressed > 0: if self._modes_buttons.index(sender) == 0: self.set_mode(2) if self._modes_buttons.index(sender) == 1: self.set_mode(3) else: self._last_normal_mode = int(self._modes_buttons.index(sender)) self.set_mode(self._modes_buttons.index(sender)) else: pass def number_of_modes(self): return 5 def on_enabled_changed(self): self.update() def set_mode(self, mode): assert (mode in range(self.number_of_modes())) if ((self._mode_index != mode) or (mode == 1)): self._mode_index = mode self.update() def update(self): assert (self._modes_buttons != None) if self.is_enabled(): for scene_index in range(8): for track_index in range(8): self._matrix.get_button(track_index, scene_index).set_enabled(True) for button in self._nav_buttons: button.set_enabled(True) as_active = True as_enabled = True self._session.set_allow_update(False) self._zooming.set_allow_update(False) self._config_button.send_value(40) self._config_button.send_value(1) release_buttons = (self._mode_index == 1) if (self._mode_index < 4): self._script._host.set_enabled(False) self._script._host._set_button_matrix(None) self._script._host._set_alt_button(None) self._script._host._set_shift_button(None) self._script._host._set_nav_buttons(None) if (self._mode_index == 0): #session self._setup_mixer((not as_active)) self._setup_session(as_active, as_enabled) elif (self._mode_index == 1): #mixer self._setup_session((not as_active), as_enabled) self._setup_mixer(as_active) elif (self._mode_index == 2): #user1 self._setup_session((not as_active), (not as_enabled)) self._setup_mixer((not as_active)) self._setup_user(release_buttons) elif (self._mode_index == 3): #user2 self._setup_session((not as_active), (not as_enabled)) self._setup_mixer((not as_active)) self._setup_user(release_buttons) elif (self._mode_index == 4): #monomodular self._setup_session((not as_active), (not as_enabled)) self._setup_mixer((not as_active)) self._setup_user(release_buttons) self._script._host._set_button_matrix(self._matrix) self._script._host._set_shift_button(self._shift_button) self._script._host._set_lock_button(self._modes_buttons[0]) self._script._host._set_alt_button(self._modes_buttons[1]) self._script._host._set_nav_buttons(self._nav_buttons) self._script._host.set_enabled(True) else: assert False self._session.set_allow_update(True) self._zooming.set_allow_update(True) self._update_control_channels() #self._script.request_rebuild_midi_map() def _update_control_channels(self): if self._mode_index < 4: new_channel = (self._mode_index + self._sub_modes.mode()) if (new_channel > 0): new_channel += 3 else: new_channel = 15 for button in self._all_buttons: button.set_channel(new_channel) button.set_force_next_value() def _setup_session(self, as_active, as_enabled): assert isinstance(as_active, type(False)) for button in self._nav_buttons: if as_enabled: button.set_on_off_values(127, 0) else: button.set_on_off_values(127, 0) for scene_index in range(8): scene = self._session.scene(scene_index) if as_active and (self._shift_pressed == 1): scene_button = self._matrix.get_button(7, scene_index) scene_button.set_on_off_values(127, 0) scene.set_launch_button(scene_button) else: scene.set_launch_button(None) for track_index in range(SHIFT[self._shift_pressed]): if as_active: button = self._matrix.get_button(track_index, scene_index) button.set_on_off_values(127, 0) scene.clip_slot(track_index).set_launch_button(button) else: scene.clip_slot(track_index).set_launch_button(None) if as_active: self._zooming.set_zoom_button(self._modes_buttons[0]) self._zooming.set_button_matrix(self._matrix) self._zooming.set_scene_bank_buttons(self._side_buttons) self._zooming.set_nav_buttons(self._nav_buttons[0], self._nav_buttons[1], self._nav_buttons[2], self._nav_buttons[3]) self._zooming.update() else: self._zooming.set_zoom_button(None) self._zooming.set_button_matrix(None) self._zooming.set_scene_bank_buttons(None) self._zooming.set_nav_buttons(None, None, None, None) if as_enabled: self._session.set_track_bank_buttons(self._nav_buttons[3], self._nav_buttons[2]) self._session.set_scene_bank_buttons(self._nav_buttons[1], self._nav_buttons[0]) else: self._session.set_track_bank_buttons(None, None) self._session.set_scene_bank_buttons(None, None) def _setup_mixer(self, as_active): assert isinstance(as_active, type(False)) self._sub_modes.set_enabled(as_active) def _setup_user(self, release_buttons): for scene_index in range(8): scene_button = self._side_buttons[scene_index] scene_button.set_on_off_values(127, LED_OFF) scene_button.turn_off() scene_button.set_enabled((not release_buttons)) for track_index in range(8): button = self._matrix.get_button(track_index, scene_index) button.set_on_off_values(127, LED_OFF) button.turn_off() button.set_enabled((not release_buttons)) for button in self._nav_buttons: button.set_on_off_values(127, LED_OFF) button.turn_off() button.set_enabled((not release_buttons)) self._config_button.send_value(32) if release_buttons: self._config_button.send_value(2) def _init_session(self): self._session.set_stop_track_clip_value(3) for scene_index in range(self._matrix.height()): scene = self._session.scene(scene_index) scene.set_triggered_value(1) for track_index in range(self._matrix.width()): clip_slot = scene.clip_slot(track_index) clip_slot.set_triggered_to_play_value(4) clip_slot.set_triggered_to_record_value(3) clip_slot.set_stopped_value(127) clip_slot.set_started_value(2) clip_slot.set_recording_value(1) self._all_buttons.append(self._matrix.get_button(track_index, scene_index)) self._zooming.set_stopped_value(127) self._zooming.set_selected_value(1) self._zooming.set_playing_value(2)
class MainSelectorComponent(ModeSelectorComponent): """ Class that reassigns the button on the launchpad to different functions """ def __init__(self, matrix, top_buttons, side_buttons, config_button, parent): assert isinstance(matrix, ButtonMatrixElement) assert ((matrix.width() == 8) and (matrix.height() == 8)) assert isinstance(top_buttons, tuple) assert (len(top_buttons) == 8) assert isinstance(side_buttons, tuple) assert (len(side_buttons) == 8) assert isinstance(config_button, ButtonElement) ModeSelectorComponent.__init__(self) self._parent = parent self._session = SpecialSessionComponent(matrix.width(), matrix.height()) self._zooming = SessionZoomingComponent(self._session) self._session.name = 'Session_Control' self._zooming.name = 'Session_Overview' self._matrix = matrix self._side_buttons = side_buttons self._nav_buttons = top_buttons[:4] self._config_button = config_button self._zooming.set_empty_value(LED_OFF) self._all_buttons = [] for button in self._side_buttons + self._nav_buttons: self._all_buttons.append(button) self._sub_modes = SubSelectorComponent(matrix, side_buttons, self._session) self._sub_modes.name = 'Mixer_Modes' self._sub_modes.set_update_callback(self._update_control_channels) self._stepseq = StepSequencerComponent(self, self._matrix, self._side_buttons, self._nav_buttons) self._quick_mix = None #QuickMixerComponent(self._nav_buttons,self._side_buttons,self) self._device_controller = DeviceControllerComponent( self._matrix, self._side_buttons, self._nav_buttons, self) self._init_session() self._all_buttons = tuple(self._all_buttons) self._previous_mode_index = -1 self._sub_mode_index = [0, 0, 0, 0] for index in range(4): self._sub_mode_index[index] = 0 self.set_mode_buttons(top_buttons[4:]) def disconnect(self): for button in self._modes_buttons: button.remove_value_listener(self._mode_value) self._session = None self._zooming = None for button in self._all_buttons: button.set_on_off_values(127, LED_OFF) self._config_button.turn_off() self._matrix = None self._side_buttons = None self._nav_buttons = None self._config_button = None ModeSelectorComponent.disconnect(self) def session_component(self): return self._session def set_mode(self, mode): assert mode in range(self.number_of_modes()) if ((self._mode_index != mode) or (mode == 3) or True): self._mode_index = mode self.update() def number_of_modes(self): return 4 def on_enabled_changed(self): self.update() def _update_mode_buttons(self): if self._mode_index == self._previous_mode_index: if self._mode_index == 1: #user mode 1 and device controller self._sub_mode_index[self._mode_index] = ( self._sub_mode_index[self._mode_index] + 1) % 2 elif self._mode_index == 2: #user mode 2 and step sequencer self._sub_mode_index[self._mode_index] = ( self._sub_mode_index[self._mode_index] + 1) % 3 else: self._sub_mode_index[self._mode_index] = 0 for index in range(4): if (self._sub_mode_index[index] == 0): self._modes_buttons[index].set_on_off_values( AMBER_FULL, AMBER_THIRD) if (self._sub_mode_index[index] == 1): self._modes_buttons[index].set_on_off_values( GREEN_FULL, GREEN_THIRD) if (self._sub_mode_index[index] == 2): self._modes_buttons[index].set_on_off_values( RED_FULL, RED_THIRD) if (index == self._mode_index): self._modes_buttons[index].turn_on() else: self._modes_buttons[index].turn_off() def channel_for_current_mode(self): #trying to keep if self._mode_index == 0: return 0 elif self._mode_index == 1: if self._sub_mode_index[self._mode_index] == 0: new_channel = 4 #user 1 else: new_channel = 1 #device ctrl elif self._mode_index == 2: if self._sub_mode_index[self._mode_index] == 0: new_channel = 5 #user 2 else: new_channel = 1 + self._sub_mode_index[ self._mode_index] #step seq elif self._mode_index == 3: #mixer modes new_channel = 6 + self._sub_modes.mode() #if (new_channel > 0): # new_channel += 3 return new_channel def update(self): assert (self._modes_buttons != None) if self.is_enabled(): #for index in range(len(self._modes_buttons)): # self._modes_buttons[index].set_force_next_value() # if index == self._mode_index: # self._modes_buttons[index].turn_on() # else: # self._modes_buttons[index].turn_off() self._update_mode_buttons() #update matrix and side buttons for scene_index in range(8): #update scene button self._side_buttons[scene_index].set_enabled(True) for track_index in range(8): #update matrix self._matrix.get_button(track_index, scene_index).set_enabled(True) for button in self._nav_buttons: button.set_enabled(True) as_active = True as_enabled = True self._session.set_allow_update(False) self._zooming.set_allow_update(False) self._config_button.send_value(40) self._config_button.send_value(1) release_buttons = (self._mode_index == 1) if (self._mode_index == 0): #session self._setup_mixer((not as_active)) self._setup_device_controller((not as_active)) self._setup_step_sequencer((not as_active), 0) self._setup_device_controller((not as_active)) self._setup_session(as_active, as_enabled) elif (self._mode_index == 1): #user mode + device controller self._setup_mixer((not as_active)) if (self._sub_mode_index[self._mode_index] == 0): self._setup_step_sequencer((not as_active), 0) self._setup_device_controller((not as_active)) self._setup_session((not as_active), (as_enabled)) self._setup_user1(True, True, True) else: self._setup_session(not as_active, not as_enabled) self._setup_step_sequencer(not as_active, 0) self._setup_device_controller(as_active) elif (self._mode_index == 2): self._setup_session((not as_active), (not as_enabled)) self._setup_mixer((not as_active)) self._setup_device_controller((not as_active)) if (self._sub_mode_index[self._mode_index] == 0): self._setup_device_controller((not as_active)) self._setup_step_sequencer((not as_active), 0) self._setup_user2(release_buttons) else: self._setup_device_controller((not as_active)) self._setup_step_sequencer( as_active, self._sub_mode_index[self._mode_index]) elif (self._mode_index == 3): self._setup_step_sequencer((not as_active), 0) self._setup_device_controller((not as_active)) self._setup_session((not as_active), as_enabled) self._setup_mixer(as_active) else: assert False self._previous_mode_index = self._mode_index self._session.set_allow_update(True) self._zooming.set_allow_update(True) self._update_control_channels() #Update the channels of the buttons in the user modes.. def _update_control_channels(self): new_channel = self.channel_for_current_mode() for button in self._all_buttons: button.set_channel(new_channel) button.set_force_next_value() def _setup_session(self, as_active, as_enabled): assert isinstance(as_active, type(False)) for button in self._nav_buttons: if as_enabled: button.set_on_off_values(GREEN_FULL, GREEN_THIRD) else: button.set_on_off_values(127, LED_OFF) #matrix for scene_index in range(8): scene = self._session.scene(scene_index) if as_active: scene_button = self._side_buttons[scene_index] scene_button.set_on_off_values(127, LED_OFF) scene.set_launch_button(scene_button) else: scene.set_launch_button(None) for track_index in range(8): if as_active: button = self._matrix.get_button(track_index, scene_index) button.set_on_off_values(127, LED_OFF) scene.clip_slot(track_index).set_launch_button(button) else: scene.clip_slot(track_index).set_launch_button(None) #zoom if as_active: self._zooming.set_zoom_button(self._modes_buttons[0]) self._zooming.set_button_matrix(self._matrix) self._zooming.set_scene_bank_buttons(self._side_buttons) self._zooming.set_nav_buttons(self._nav_buttons[0], self._nav_buttons[1], self._nav_buttons[2], self._nav_buttons[3]) self._zooming.update() else: self._zooming.set_zoom_button(None) self._zooming.set_button_matrix(None) self._zooming.set_scene_bank_buttons(None) self._zooming.set_nav_buttons(None, None, None, None) #nav buttons if as_enabled: self._session.set_track_bank_buttons(self._nav_buttons[3], self._nav_buttons[2]) self._session.set_scene_bank_buttons(self._nav_buttons[1], self._nav_buttons[0]) else: self._session.set_track_bank_buttons(None, None) self._session.set_scene_bank_buttons(None, None) def _setup_quick_mix(self, as_active): if self._quick_mix != None: if as_active: for button in range(8): self._side_buttons[button].set_enabled(True) self._quick_mix._is_active = True self._quick_mix.set_enabled(True) else: self._quick_mix._is_active = False self._quick_mix.set_enabled(False) def _setup_step_sequencer(self, as_active, mode): if (self._stepseq != None): if (self._stepseq._is_active != as_active or self._stepseq._mode != mode): if as_active: self._stepseq._mode = mode self._stepseq._force_update = True self._stepseq._is_active = True self._stepseq.set_enabled(True) self._stepseq._on_notes_changed() self._config_button.send_value(32) else: self._stepseq._mode = 1 self._stepseq._is_active = False self._stepseq.set_enabled(False) def _setup_device_controller(self, as_active): if self._device_controller != None: if as_active: #for button in range(8): # self._side_buttons[button].set_enabled(True) self._device_controller._is_active = True self._device_controller.set_enabled(True) self._device_controller.update() self._config_button.send_value(32) else: self._device_controller._is_active = False self._device_controller.set_enabled(False) def _setup_mixer(self, as_active): assert isinstance(as_active, type(False)) if (as_active and self._sub_modes.is_enabled()): self._sub_modes.set_mode(-1) self._sub_modes.set_enabled(as_active) def _setup_user1(self, release_matrix=True, release_side_buttons=True, release_nav_buttons=True): for scene_index in range(8): if (release_side_buttons): scene_button = self._side_buttons[scene_index] scene_button.set_on_off_values(127, LED_OFF) scene_button.turn_off() scene_button.set_enabled((not release_side_buttons)) for track_index in range(8): button = self._matrix.get_button(track_index, scene_index) button.set_on_off_values(127, LED_OFF) button.turn_off() button.set_enabled((not release_matrix)) for button in self._nav_buttons: if (release_nav_buttons): button.set_on_off_values(127, LED_OFF) button.turn_off() button.set_enabled((not release_nav_buttons)) if release_matrix: self._config_button.send_value(2) self._config_button.send_value(32, force_send=True) def _setup_user2(self, release_buttons): for scene_index in range(8): scene_button = self._side_buttons[scene_index] scene_button.set_on_off_values(127, LED_OFF) scene_button.turn_off() scene_button.set_enabled(not release_buttons) for track_index in range(8): button = self._matrix.get_button(track_index, scene_index) button.set_on_off_values(127, LED_OFF) button.turn_off() button.set_enabled(not release_buttons) for button in self._nav_buttons: button.set_on_off_values(127, LED_OFF) button.turn_off() button.set_enabled(not release_buttons) if release_buttons: self._config_button.send_value(2) self._config_button.send_value(32, force_send=True) def _init_session(self): self._session.set_stop_track_clip_value(AMBER_BLINK) for scene_index in range(self._matrix.height()): scene = self._session.scene(scene_index) scene.set_triggered_value(GREEN_BLINK) scene.name = 'Scene_' + str(scene_index) for track_index in range(self._matrix.width()): clip_slot = scene.clip_slot(track_index) clip_slot.set_triggered_to_play_value(GREEN_BLINK) clip_slot.set_triggered_to_record_value(RED_BLINK) clip_slot.set_stopped_value(AMBER_FULL) clip_slot.set_started_value(GREEN_FULL) clip_slot.set_recording_value(RED_FULL) clip_slot.name = str(track_index) + '_Clip_Slot_' + str( scene_index) self._all_buttons.append( self._matrix.get_button(track_index, scene_index)) self._zooming.set_stopped_value(RED_FULL) self._zooming.set_selected_value(AMBER_FULL) self._zooming.set_playing_value(GREEN_FULL) def log_message(self, message): self._parent.log_message(message)
class MainSelectorComponent(ModeSelectorComponent): __module__ = __name__ __doc__ = ' Class that reassigns the button on the launchpad to different functions ' def __init__(self, matrix, top_buttons, side_buttons, config_button, script): assert isinstance(matrix, ButtonMatrixElement) assert ((matrix.width() == 8) and (matrix.height() == 8)) assert isinstance(top_buttons, tuple) assert (len(top_buttons) == 8) assert isinstance(side_buttons, tuple) assert (len(side_buttons) == 8) assert isinstance(config_button, ButtonElement) ModeSelectorComponent.__init__(self) self._script = script self._session = SpecialSessionComponent(matrix.width(), matrix.height()) for scene in self._session._scenes: for slot in scene._clip_slots: slot._triggered_to_play_value = 24 slot._triggered_to_record_value = 27 slot._started_value = 7 slot._recording_value = 9 slot._stopped_value = 8 self._zooming = SessionZoomingComponent(self._session) self._zooming._stopped_value = 9 self._zooming._playing_value = 7 self._zooming._selected_value = 8 self._matrix = matrix self._side_buttons = side_buttons self._nav_buttons = top_buttons[:4] self._config_button = config_button self._zooming.set_empty_value(LED_OFF) self._all_buttons = [] for button in (self._side_buttons + self._nav_buttons): self._all_buttons.append(button) self._sub_modes = SubSelectorComponent(matrix, side_buttons, self._session) self._sub_modes.set_update_callback(self._update_control_channels) self._init_session() self._all_buttons = tuple(self._all_buttons) self.set_modes_buttons(top_buttons[4:]) def disconnect(self): for button in self._modes_buttons: button.remove_value_listener(self._mode_value) self._session = None self._zooming = None for button in self._all_buttons: button.set_on_off_values(127, LED_OFF) self._config_button.turn_off() self._matrix = None self._side_buttons = None self._nav_buttons = None self._config_button = None ModeSelectorComponent.disconnect(self) def set_modes_buttons(self, buttons): assert ((buttons == None) or (isinstance(buttons, tuple) or (len(buttons) == self.number_of_modes() + 1))) identify_sender = True for button in self._modes_buttons: button.remove_value_listener(self._mode_value) self._modes_buttons = [] if (buttons != None): for button in buttons: assert isinstance(button, ButtonElement) self._modes_buttons.append(button) button.add_value_listener(self._mode_value, identify_sender) self.set_mode(0) def _mode_value(self, value, sender): assert (len(self._modes_buttons) > 0) assert isinstance(value, int) assert isinstance(sender, ButtonElement) assert (self._modes_buttons.count(sender) == 1) if self._script._host.is_enabled() != True: if ((value is not 0) or (not sender.is_momentary())): if ((self._modes_buttons[1]._last_received_value > 0) and (self._modes_buttons.index(sender) == 2)) or ((self._modes_buttons[2]._last_received_value > 0) and (self._modes_buttons.index(sender) == 1)): if(self._script._host._active_client != None): self.set_mode(4) else: self._script.show_message('Monomodular Script not inserted') else: self.set_mode(self._modes_buttons.index(sender)) else: if self._modes_buttons.index(sender) == 3 and value > 0: self.set_mode(0) def number_of_modes(self): return 5 def on_enabled_changed(self): self.update() def set_mode(self, mode): assert (mode in range(self.number_of_modes())) if ((self._mode_index != mode) or (mode == 3)): self._mode_index = mode self.update() def update(self): assert (self._modes_buttons != None) if self.is_enabled(): for scene_index in range(8): self._side_buttons[scene_index].set_enabled(True) for track_index in range(8): self._matrix.get_button(track_index, scene_index).set_enabled(True) for button in self._nav_buttons: button.set_enabled(True) as_active = True as_enabled = True self._session.set_allow_update(False) self._zooming.set_allow_update(False) self._config_button.send_value(40) self._config_button.send_value(1) release_buttons = (self._mode_index == 1) if (self._mode_index < 4): self._script._host._set_key_buttons(None) self._script._host.set_enabled(False) self._script._host._set_button_matrix(None) self._script._host._set_alt_button(None) self._script._host._set_shift_button(None) self._script._host._set_nav_buttons(None) for button in self._modes_buttons: button.set_on_off_values(5, 0) if (self._mode_index == 0): self._setup_mixer((not as_active)) self._setup_session(as_active, as_enabled) elif (self._mode_index == 1): self._setup_session((not as_active), (not as_enabled)) self._setup_mixer((not as_active)) self._setup_user(release_buttons) elif (self._mode_index == 2): self._setup_session((not as_active), (not as_enabled)) self._setup_mixer((not as_active)) self._setup_user(release_buttons) elif (self._mode_index == 3): self._setup_session((not as_active), as_enabled) self._setup_mixer(as_active) elif (self._mode_index == 4): self._setup_session((not as_active), (not as_enabled)) self._setup_mixer((not as_active)) self._setup_user(release_buttons) self._script._host._set_button_matrix(self._matrix) self._script._host._set_key_buttons(self._side_buttons) self._script._host._set_shift_button(self._modes_buttons[0]) self._script._host._set_lock_button(self._modes_buttons[1]) self._script._host._set_alt_button(self._modes_buttons[2]) self._modes_buttons[3].send_value(9) self._script._host._set_nav_buttons(self._nav_buttons) self._script._host.set_enabled(True) else: assert False self._session.set_allow_update(True) self._zooming.set_allow_update(True) self._update_control_channels() if(self._mode_index < 4): for index in range(len(self._modes_buttons)): if (index == self._mode_index): self._modes_buttons[index].turn_on() else: self._modes_buttons[index].turn_off() #self._script.request_rebuild_midi_map() self._script.schedule_message(1, self._session.update) def _update_control_channels(self): if self._mode_index < 4: new_channel = (self._mode_index + self._sub_modes.mode()) if (new_channel > 0): new_channel += 3 else: new_channel = 15 for button in self._all_buttons: button.set_channel(new_channel) button.set_force_next_value() def _setup_session(self, as_active, as_enabled): assert isinstance(as_active, type(False)) for button in self._nav_buttons: if as_enabled: button.set_on_off_values(GREEN_FULL, GREEN_THIRD) else: button.set_on_off_values(127, LED_OFF) for scene_index in range(8): scene = self._session.scene(scene_index) if as_active: scene_button = self._side_buttons[scene_index] scene_button.set_on_off_values(127, LED_OFF) scene.set_launch_button(scene_button) else: scene.set_launch_button(None) for track_index in range(8): if as_active: button = self._matrix.get_button(track_index, scene_index) button.set_on_off_values(127, LED_OFF) scene.clip_slot(track_index).set_launch_button(button) else: scene.clip_slot(track_index).set_launch_button(None) if as_active: self._zooming.set_zoom_button(self._modes_buttons[0]) self._zooming.set_button_matrix(self._matrix) self._zooming.set_scene_bank_buttons(self._side_buttons) self._zooming.set_nav_buttons(self._nav_buttons[0], self._nav_buttons[1], self._nav_buttons[2], self._nav_buttons[3]) self._zooming.update() else: self._zooming.set_zoom_button(None) self._zooming.set_button_matrix(None) self._zooming.set_scene_bank_buttons(None) self._zooming.set_nav_buttons(None, None, None, None) if as_enabled: self._session.set_track_bank_buttons(self._nav_buttons[3], self._nav_buttons[2]) self._session.set_scene_bank_buttons(self._nav_buttons[1], self._nav_buttons[0]) self._session.set_show_highlight(True) else: self._session.set_track_bank_buttons(None, None) self._session.set_scene_bank_buttons(None, None) self._session.set_show_highlight(False) def _setup_mixer(self, as_active): assert isinstance(as_active, type(False)) self._sub_modes.set_enabled(as_active) def _setup_user(self, release_buttons): for scene_index in range(8): scene_button = self._side_buttons[scene_index] scene_button.set_on_off_values(127, LED_OFF) scene_button.turn_off() scene_button.set_enabled((not release_buttons)) for track_index in range(8): button = self._matrix.get_button(track_index, scene_index) button.set_on_off_values(127, LED_OFF) button.turn_off() button.set_enabled((not release_buttons)) for button in self._nav_buttons: button.set_on_off_values(127, LED_OFF) button.turn_off() button.set_enabled((not release_buttons)) self._config_button.send_value(32) if release_buttons: self._config_button.send_value(2) def _init_session(self): self._session.set_stop_track_clip_value(AMBER_BLINK) for scene_index in range(self._matrix.height()): scene = self._session.scene(scene_index) scene.set_triggered_value(GREEN_BLINK) for track_index in range(self._matrix.width()): clip_slot = scene.clip_slot(track_index) clip_slot.set_triggered_to_play_value(GREEN_BLINK) clip_slot.set_triggered_to_record_value(RED_BLINK) clip_slot.set_stopped_value(AMBER_FULL) clip_slot.set_started_value(GREEN_FULL) clip_slot.set_recording_value(RED_FULL) self._all_buttons.append(self._matrix.get_button(track_index, scene_index)) self._zooming.set_stopped_value(RED_FULL) self._zooming.set_selected_value(AMBER_FULL) self._zooming.set_playing_value(GREEN_FULL)
class MainSelectorComponent(ModeSelectorComponent): """ Class that reassigns the button on the launchpad to different functions """ def __init__(self, matrix, top_buttons, side_buttons, config_button, parent): assert isinstance(matrix, ButtonMatrixElement) assert ((matrix.width() == 8) and (matrix.height() == 8)) assert isinstance(top_buttons, tuple) assert (len(top_buttons) == 8) assert isinstance(side_buttons, tuple) assert (len(side_buttons) == 8) assert isinstance(config_button, ButtonElement) ModeSelectorComponent.__init__(self) self._parent = parent self._compact = False self._session = SpecialSessionComponent(matrix.width(), matrix.height()) self._zooming = SessionZoomingComponent(self._session) self._session.name = 'Session_Control' self._zooming.name = 'Session_Overview' self._matrix = matrix self._side_buttons = side_buttons self._nav_buttons = top_buttons[:4] self._config_button = config_button self._zooming.set_empty_value(LED_OFF) self._all_buttons = [] for button in self._side_buttons + self._nav_buttons: self._all_buttons.append(button) self._sub_modes = SubSelectorComponent(matrix, side_buttons, self._session) self._sub_modes.name = 'Mixer_Modes' self._sub_modes.set_update_callback(self._update_control_channels) self._stepseq = StepSequencerComponent(self._matrix, self._side_buttons, self._nav_buttons, self) self._instrument_controller = InstrumentControllerComponent( self._matrix, self._side_buttons, self._nav_buttons,self) self._device_controller = DeviceControllerComponent(self._matrix, self._side_buttons, self._nav_buttons, self) self._init_session() self._all_buttons = tuple(self._all_buttons) self._mode_index=0 self._previous_mode_index=-1 self._sub_mode_index=[0,0,0,0] for index in range(4): self._sub_mode_index[index]=0 self.set_mode_buttons(top_buttons[4:]) def disconnect(self): for button in self._modes_buttons: button.remove_value_listener(self._mode_value) self._session = None self._zooming = None for button in self._all_buttons: button.set_on_off_values(127, LED_OFF) self._config_button.turn_off() self._matrix = None self._side_buttons = None self._nav_buttons = None self._config_button = None ModeSelectorComponent.disconnect(self) def session_component(self): return self._session def _update_mode(self): mode = self._modes_heap[-1][0] assert mode in range(self.number_of_modes()) if self._mode_index==mode: if self._mode_index==1: #user mode 1 and device controller and instrument mode self._sub_mode_index[self._mode_index] = (self._sub_mode_index[self._mode_index]+1)%3 self.update() elif self._mode_index==2: #user mode 2 and step sequencer self._sub_mode_index[self._mode_index] = (self._sub_mode_index[self._mode_index]+1)%2 self.update() elif self._mode_index==3: self.update() else: self._sub_mode_index[self._mode_index] = 0 self._previous_mode_index=self._mode_index else: self._mode_index = mode self.update() def set_mode(self, mode): self._clean_heap() self._modes_heap = [(mode, None, None)] #if ((self._mode_index != mode) or (mode == 3) or True): #self._mode_index = mode #self._update_mode() # self.update() def number_of_modes(self): return 4 def on_enabled_changed(self): self.update() def _update_mode_buttons(self): for index in range(4): if(self._sub_mode_index[index]==0): self._modes_buttons[index].set_on_off_values(AMBER_FULL,AMBER_THIRD) if(self._sub_mode_index[index]==1): self._modes_buttons[index].set_on_off_values(GREEN_FULL,GREEN_THIRD) if(self._sub_mode_index[index]==2): self._modes_buttons[index].set_on_off_values(RED_FULL,RED_THIRD) if (index == self._mode_index): self._modes_buttons[index].turn_on() else: self._modes_buttons[index].turn_off() def channel_for_current_mode(self): if self._compact: if self._mode_index==0: new_channel = 2 #session elif self._mode_index==1: if self._sub_mode_index[self._mode_index]==0: new_channel = 2 #instrument controller 11,12,13,14 if self._instrument_controller != None: self._instrument_controller.base_channel = new_channel elif self._sub_mode_index[self._mode_index]==1: new_channel = 2 #device controler else : new_channel = 0 #plain user mode 1 elif self._mode_index==2: if self._sub_mode_index[self._mode_index]==0: new_channel = 1 #user 2 else: new_channel = 2 + self._sub_mode_index[self._mode_index] #step seq 2,3 elif self._mode_index==3: #mixer modes new_channel = 2 + self._sub_modes.mode() # 2,3,4,5,6 else: if self._mode_index==0: new_channel = 0 #session elif self._mode_index==1: if self._sub_mode_index[self._mode_index]==0: new_channel = 11 #instrument controller 11,12,13,14 if self._instrument_controller != None: self._instrument_controller.base_channel = new_channel elif self._sub_mode_index[self._mode_index]==1: new_channel = 3 #device controler else : new_channel = 4 #plain user mode 1 elif self._mode_index==2: if self._sub_mode_index[self._mode_index]==0: new_channel = 5 #user 2 else: new_channel = 1 + self._sub_mode_index[self._mode_index] #step seq 1,2 elif self._mode_index==3: #mixer modes new_channel = 6 + self._sub_modes.mode() # 6,7,8,9,10 return new_channel def update(self): assert (self._modes_buttons != None) if self.is_enabled(): self._update_mode_buttons() as_active = True as_enabled = True self._session.set_allow_update(False) self._zooming.set_allow_update(False) self._config_button.send_value(40) self._config_button.send_value(1) if (self._mode_index == 0): #session self._setup_mixer(not as_active) self._setup_device_controller(not as_active) self._setup_step_sequencer(not as_active) self._setup_instrument_controller(not as_active) self._setup_session(as_active, as_enabled) self._update_control_channels() elif (self._mode_index == 1): self._setup_session(not as_active, not as_enabled) self._setup_step_sequencer(not as_active) self._setup_mixer(not as_active) #user mode + device controller + instrument controller if (self._sub_mode_index[self._mode_index]==0): self._setup_device_controller(not as_active) self._update_control_channels() self._setup_instrument_controller(as_active) elif (self._sub_mode_index[self._mode_index]==1): self._setup_instrument_controller(not as_active) self._setup_device_controller(as_active) self._update_control_channels() else: self._setup_device_controller(not as_active) self._setup_instrument_controller(not as_active) self._setup_user_mode(True, True, False, True) self._update_control_channels() elif (self._mode_index == 2): self._setup_session(not as_active, not as_enabled) self._setup_instrument_controller(not as_active) self._setup_device_controller(not as_active) self._setup_mixer(not as_active) if (self._sub_mode_index[self._mode_index]==0): self._setup_step_sequencer(not as_active) self._setup_user_mode(False, False, False, False) else: self._setup_step_sequencer(as_active, self._sub_mode_index[self._mode_index]) self._update_control_channels() elif (self._mode_index == 3): self._setup_device_controller(not as_active) self._setup_step_sequencer(not as_active) self._setup_instrument_controller(not as_active) self._setup_session(not as_active, as_enabled) self._setup_mixer(as_active) self._update_control_channels() else: assert False self._previous_mode_index=self._mode_index self._session.set_allow_update(True) self._zooming.set_allow_update(True) def _setup_session(self, as_active, as_enabled): assert isinstance(as_active, type(False)) for button in self._nav_buttons: if as_enabled: button.set_on_off_values(GREEN_FULL, GREEN_THIRD) else: button.set_on_off_values(127, LED_OFF) #matrix for scene_index in range(8): scene = self._session.scene(scene_index) if as_active: self._activate_matrix(True) scene_button = self._side_buttons[scene_index] scene_button.set_on_off_values(127, LED_OFF) scene.set_launch_button(scene_button) else: scene.set_launch_button(None) for track_index in range(8): if as_active: button = self._matrix.get_button(track_index, scene_index) button.set_on_off_values(127, LED_OFF) scene.clip_slot(track_index).set_launch_button(button) else: scene.clip_slot(track_index).set_launch_button(None) #zoom if as_active: self._zooming.set_zoom_button(self._modes_buttons[0]) self._zooming.set_button_matrix(self._matrix) self._zooming.set_scene_bank_buttons(self._side_buttons) self._zooming.set_nav_buttons(self._nav_buttons[0], self._nav_buttons[1], self._nav_buttons[2], self._nav_buttons[3]) self._zooming.update() else: self._zooming.set_zoom_button(None) self._zooming.set_button_matrix(None) self._zooming.set_scene_bank_buttons(None) self._zooming.set_nav_buttons(None, None, None, None) #nav buttons if as_enabled: self._session.set_track_bank_buttons(self._nav_buttons[3], self._nav_buttons[2]) self._session.set_scene_bank_buttons(self._nav_buttons[1], self._nav_buttons[0]) else: self._session.set_track_bank_buttons(None, None) self._session.set_scene_bank_buttons(None, None) def _setup_instrument_controller(self, enabled): if self._instrument_controller != None: if enabled: self._activate_matrix(False) self._activate_scene_buttons(True) self._activate_navigation_buttons(True) else: for scene_index in range(8): scene_button = self._side_buttons[scene_index] scene_button.use_default_message() scene_button.force_next_send() for track_index in range(8): button = self._matrix.get_button(track_index, scene_index) button.use_default_message() button.force_next_send() self._instrument_controller.set_enabled(enabled) def _setup_device_controller(self, as_active): if self._device_controller!=None: if as_active: self._activate_scene_buttons(True) self._activate_matrix(True) self._activate_navigation_buttons(True) self._device_controller._is_active = True self._config_button.send_value(32) self._device_controller.set_enabled(True) self._device_controller.update() else: self._device_controller._is_active = False self._device_controller.set_enabled(False) def _setup_user_mode(self, release_matrix=True, release_side_buttons=True, release_nav_buttons = True, drum_rack_mode = True): for scene_index in range(8): scene_button = self._side_buttons[scene_index] scene_button.set_on_off_values(127, LED_OFF) scene_button.force_next_send() scene_button.turn_off() scene_button.set_enabled((not release_side_buttons)) for track_index in range(8): button = self._matrix.get_button(track_index, scene_index) button.set_on_off_values(127, LED_OFF) button.turn_off() button.set_enabled((not release_matrix)) for button in self._nav_buttons: button.set_on_off_values(127, LED_OFF) button.turn_off() button.set_enabled((not release_nav_buttons)) if drum_rack_mode: self._config_button.send_value(2) self._config_button.send_value(32) def _setup_step_sequencer(self, as_active, mode=0): if(self._stepseq!=None): if(self._stepseq.is_enabled()!=as_active or self._stepseq._mode!=mode): if as_active: self._activate_scene_buttons(True) self._activate_matrix(True) self._activate_navigation_buttons(True) self._config_button.send_value(32) self._stepseq.set_enabled(True) else: self._stepseq.set_enabled(False) def _setup_mixer(self, as_active): assert isinstance(as_active, type(False)) if as_active: self._activate_navigation_buttons(True) self._activate_scene_buttons(True) self._activate_matrix(True) if(self._sub_modes.is_enabled()): #go back to default mode self._sub_modes.set_mode(-1) self._sub_modes.set_enabled(as_active) def _init_session(self): self._session.set_stop_track_clip_value(AMBER_BLINK) for scene_index in range(self._matrix.height()): scene = self._session.scene(scene_index) scene.set_triggered_value(GREEN_BLINK) scene.name = 'Scene_' + str(scene_index) for track_index in range(self._matrix.width()): clip_slot = scene.clip_slot(track_index) clip_slot.set_triggered_to_play_value(GREEN_BLINK) clip_slot.set_triggered_to_record_value(RED_BLINK) clip_slot.set_stopped_value(AMBER_FULL) clip_slot.set_started_value(GREEN_FULL) clip_slot.set_recording_value(RED_FULL) clip_slot.set_record_button_value(RED_THIRD) clip_slot.set_clip_palette(CLIP_COLOR_TABLE) #clip_slot.set_clip_rgb_table(RGB_COLOR_TABLE) clip_slot.name = str(track_index) + '_Clip_Slot_' + str(scene_index) self._all_buttons.append(self._matrix.get_button(track_index, scene_index)) self._zooming.set_stopped_value(RED_FULL) self._zooming.set_selected_value(AMBER_FULL) self._zooming.set_playing_value(GREEN_FULL) def _activate_navigation_buttons(self,active): for button in self._nav_buttons: button.set_enabled(active) def _activate_scene_buttons(self,active): for button in self._side_buttons: button.set_enabled(active) def _activate_matrix(self,active): for scene_index in range(8): for track_index in range(8): self._matrix.get_button(track_index, scene_index).set_enabled(active) def log_message(self, msg): self._parent.log_message(msg) #Update the channels of the buttons in the user modes.. def _update_control_channels(self): new_channel = self.channel_for_current_mode() for button in self._all_buttons: button.set_channel(new_channel) button.set_force_next_value()
class MainSelectorComponent(ModeSelectorComponent): """ Class that reassigns the button on the launchpad to different functions """ def __init__(self, matrix, top_buttons, side_buttons, config_button): raise isinstance(matrix, ButtonMatrixElement) or AssertionError raise matrix.width() == 8 and matrix.height() == 8 or AssertionError raise isinstance(top_buttons, tuple) or AssertionError raise len(top_buttons) == 8 or AssertionError raise isinstance(side_buttons, tuple) or AssertionError raise len(side_buttons) == 8 or AssertionError raise isinstance(config_button, ButtonElement) or AssertionError ModeSelectorComponent.__init__(self) self._session = SpecialSessionComponent(matrix.width(), matrix.height()) self._zooming = DeprecatedSessionZoomingComponent(self._session) self._session.name = 'Session_Control' self._zooming.name = 'Session_Overview' self._matrix = matrix self._side_buttons = side_buttons self._nav_buttons = top_buttons[:4] self._config_button = config_button self._zooming.set_empty_value(LED_OFF) self._all_buttons = [] for button in self._side_buttons + self._nav_buttons: self._all_buttons.append(button) self._sub_modes = SubSelectorComponent(matrix, side_buttons, self._session) self._sub_modes.name = 'Mixer_Modes' self._sub_modes.set_update_callback(self._update_control_channels) self._init_session() self._all_buttons = tuple(self._all_buttons) self.set_modes_buttons(top_buttons[4:]) def disconnect(self): for button in self._modes_buttons: button.remove_value_listener(self._mode_value) self._session = None self._zooming = None for button in self._all_buttons: button.set_on_off_values(127, LED_OFF) self._config_button.turn_off() self._matrix = None self._side_buttons = None self._nav_buttons = None self._config_button = None ModeSelectorComponent.disconnect(self) def session_component(self): return self._session def set_modes_buttons(self, buttons): raise buttons == None or isinstance( buttons, tuple) or len(buttons) == self.number_of_modes() or AssertionError identify_sender = True for button in self._modes_buttons: button.remove_value_listener(self._mode_value) self._modes_buttons = [] if buttons != None: for button in buttons: raise isinstance(button, ButtonElement) or AssertionError self._modes_buttons.append(button) button.add_value_listener(self._mode_value, identify_sender) self.set_mode(0) def number_of_modes(self): return 4 def on_enabled_changed(self): self.update() def set_mode(self, mode): if not mode in range(self.number_of_modes()): raise AssertionError self._mode_index = (self._mode_index != mode or mode == 3) and mode self.update() def channel_for_current_mode(self): new_channel = self._mode_index + self._sub_modes.mode() if new_channel > 0: new_channel += 3 return new_channel def update(self): super(MainSelectorComponent, self).update() if not self._modes_buttons != None: raise AssertionError if self.is_enabled(): for index in range(len(self._modes_buttons)): self._modes_buttons[index].set_force_next_value() if index == self._mode_index: self._modes_buttons[index].turn_on() else: self._modes_buttons[index].turn_off() for scene_index in range(8): self._side_buttons[scene_index].set_enabled(True) for track_index in range(8): self._matrix.get_button(track_index, scene_index).set_enabled(True) for button in self._nav_buttons: button.set_enabled(True) as_active = True as_enabled = True self._session.set_allow_update(False) self._zooming.set_allow_update(False) self._config_button.send_value(40) self._config_button.send_value(1) release_buttons = self._mode_index == 1 self._mode_index == 0 and self._setup_mixer(not as_active) self._setup_session(as_active, as_enabled) elif self._mode_index == 1: self._setup_session(not as_active, not as_enabled) self._setup_mixer(not as_active) self._setup_user(release_buttons) elif self._mode_index == 2: self._setup_session(not as_active, not as_enabled) self._setup_mixer(not as_active) self._setup_user(release_buttons) elif self._mode_index == 3: self._setup_session(not as_active, as_enabled) self._setup_mixer(as_active) else: raise False or AssertionError self._session.set_allow_update(True) self._zooming.set_allow_update(True) self._update_control_channels() def _update_control_channels(self): new_channel = self.channel_for_current_mode() for button in self._all_buttons: button.set_channel(new_channel) button.set_force_next_value() def _setup_session(self, as_active, as_enabled): if not isinstance(as_active, type(False)): raise AssertionError for button in self._nav_buttons: if as_enabled: button.set_on_off_values(GREEN_FULL, GREEN_THIRD) else: button.set_on_off_values(127, LED_OFF) for scene_index in range(8): scene = self._session.scene(scene_index) if as_active: scene_button = self._side_buttons[scene_index] scene_button.set_on_off_values(127, LED_OFF) scene.set_launch_button(scene_button) else: scene.set_launch_button(None) for track_index in range(8): if as_active: button = self._matrix.get_button( track_index, scene_index) button.set_on_off_values(127, LED_OFF) scene.clip_slot(track_index).set_launch_button(button) else: scene.clip_slot(track_index).set_launch_button(None) if as_active: self._zooming.set_zoom_button(self._modes_buttons[0]) self._zooming.set_button_matrix(self._matrix) self._zooming.set_scene_bank_buttons(self._side_buttons) self._zooming.set_nav_buttons(self._nav_buttons[0], self._nav_buttons[1], self._nav_buttons[2], self._nav_buttons[3]) self._zooming.update() else: self._zooming.set_zoom_button(None) self._zooming.set_button_matrix(None) self._zooming.set_scene_bank_buttons(None) self._zooming.set_nav_buttons(None, None, None, None) as_enabled and self._session.set_track_bank_buttons( self._nav_buttons[3], self._nav_buttons[2]) self._session.set_scene_bank_buttons(self._nav_buttons[1], self._nav_buttons[0]) else: self._session.set_track_bank_buttons(None, None) self._session.set_scene_bank_buttons(None, None) def _setup_mixer(self, as_active): if not isinstance(as_active, type(False)): raise AssertionError as_active and self._sub_modes.is_enabled( ) and self._sub_modes.set_mode(-1) self._sub_modes.set_enabled(as_active) def _setup_user(self, release_buttons): for scene_index in range(8): scene_button = self._side_buttons[scene_index] scene_button.set_on_off_values(127, LED_OFF) scene_button.turn_off() scene_button.set_enabled(not release_buttons) for track_index in range(8): button = self._matrix.get_button(track_index, scene_index) button.set_on_off_values(127, LED_OFF) button.turn_off() button.set_enabled(not release_buttons) for button in self._nav_buttons: button.set_on_off_values(127, LED_OFF) button.turn_off() button.set_enabled(not release_buttons) if release_buttons: self._config_button.send_value(2) self._config_button.send_value(32, force=True) def _init_session(self): self._session.set_stop_clip_value(AMBER_THIRD) self._session.set_stop_clip_triggered_value(AMBER_BLINK) for scene_index in range(self._matrix.height()): scene = self._session.scene(scene_index) scene.set_triggered_value(GREEN_BLINK) scene.name = 'Scene_' + str(scene_index) for track_index in range(self._matrix.width()): clip_slot = scene.clip_slot(track_index) clip_slot.set_triggered_to_play_value(GREEN_BLINK) clip_slot.set_triggered_to_record_value(RED_BLINK) clip_slot.set_stopped_value(AMBER_FULL) clip_slot.set_started_value(GREEN_FULL) clip_slot.set_recording_value(RED_FULL) clip_slot.name = str(track_index) + '_Clip_Slot_' + str( scene_index) self._all_buttons.append( self._matrix.get_button(track_index, scene_index)) self._zooming.set_stopped_value(RED_FULL) self._zooming.set_selected_value(AMBER_FULL) self._zooming.set_playing_value(GREEN_FULL)
class MainSelectorComponent(ModeSelectorComponent): """ Class that reassigns the button on the launchpad to different functions """ def log(self, message): self._parent.log_message((' ' + message + ' ').center(50, '=')) def __init__(self, matrix, top_buttons, side_buttons, config_button, osd, parent, skin): assert isinstance(matrix, ButtonMatrixElement) assert ((matrix.width() == 8) and (matrix.height() == 8)) assert isinstance(top_buttons, tuple) assert (len(top_buttons) == 8) assert isinstance(side_buttons, tuple) assert (len(side_buttons) == 8) assert isinstance(config_button, ButtonElement) ModeSelectorComponent.__init__(self) self._skin = skin self._osd = osd self._parent = parent self._mode_index = 0 self._previous_mode_index = -1 self._main_mode_index = 0 self._sub_mode_index = [0, 0, 0, 0] for index in range(4): self._sub_mode_index[index] = 0 self.set_mode_buttons(top_buttons[4:]) if Settings.SESSION__STOP_BUTTONS: #session with bottom stop buttons clip_stop_buttons = [] for column in range(8): clip_stop_buttons.append(matrix.get_button(column,matrix.height()-1)) self._session = SpecialSessionComponent(matrix.width(), matrix.height()-1, clip_stop_buttons, self, self._skin) else: #no stop buttons self._session = SpecialSessionComponent(matrix.width(), matrix.height(), None, self, self._skin) self._session.set_osd(self._osd) self._session.name = 'Session_Control' self._zooming = DeprecatedSessionZoomingComponent(self._session) self._zooming.name = 'Session_Overview' self._zooming.set_empty_value(self._skin.off) self._matrix = matrix self._side_buttons = side_buttons self._nav_buttons = top_buttons[:4] self._config_button = config_button self._all_buttons = [] for button in self._side_buttons + self._nav_buttons: self._all_buttons.append(button) self._sub_modes = SubSelectorComponent(matrix, side_buttons, self._session, skin) self._sub_modes.name = 'Mixer_Modes' self._sub_modes._mixer.set_osd(self._osd) self._sub_modes.set_update_callback(self._update_control_channels) self._stepseq = StepSequencerComponent(self._matrix, self._side_buttons, self._nav_buttons, self, skin) self._stepseq.set_osd(self._osd) self._stepseq2 = StepSequencerComponent2(self._matrix, self._side_buttons, self._nav_buttons, self, skin) self._stepseq2.set_osd(self._osd) self._instrument_controller = InstrumentControllerComponent(self._matrix, self._side_buttons, self._nav_buttons, self, skin) self._instrument_controller.set_osd(self._osd) self._device_controller = DeviceControllerComponent(self._matrix, self._side_buttons, self._nav_buttons, self, skin) self._device_controller.set_osd(self._osd) self._init_session() self._all_buttons = tuple(self._all_buttons) def disconnect(self): for button in self._modes_buttons: button.remove_value_listener(self._mode_value) self._session = None self._zooming = None for button in self._all_buttons: button.set_on_off_values(127, self._skin.off) self._config_button.turn_off() self._matrix = None self._side_buttons = None self._nav_buttons = None self._config_button = None ModeSelectorComponent.disconnect(self) def session_component(self): return self._session def _update_mode(self): mode = self._modes_heap[-1][0] assert mode in range(self.number_of_modes()) if self._main_mode_index == mode: if self._main_mode_index == 1: # user mode 1 and device controller and instrument mode self._sub_mode_index[self._main_mode_index] = (self._sub_mode_index[self._main_mode_index] + 1) % 3 self.update() elif self._main_mode_index == 2: # user mode 2 and step sequencer self._sub_mode_index[self._main_mode_index] = (self._sub_mode_index[self._main_mode_index] + 1) % 3 self.update() elif self._main_mode_index == 3: self.update() else: self._sub_mode_index[self._main_mode_index] = 0 self._mode_index = 0 self._previous_mode_index = self._main_mode_index else: self._main_mode_index = mode self.update() def set_mode(self, mode): self._clean_heap() self._modes_heap = [(mode, None, None)] # if ((self.__main_mode_index != mode) or (mode == 3) or True): # self._main_mode_index = mode # self._update_mode() # self.update() def number_of_modes(self): return 1 + 3 + 3 + 1 def on_enabled_changed(self): self.update() def _update_mode_buttons(self): for index in range(4): if(self._sub_mode_index[index] == 0): self._modes_buttons[index].set_on_off_values(self._skin.AMBER_FULL, self._skin.AMBER_THIRD) if(self._sub_mode_index[index] == 1): self._modes_buttons[index].set_on_off_values(self._skin.GREEN_FULL, self._skin.GREEN_THIRD) if(self._sub_mode_index[index] == 2): self._modes_buttons[index].set_on_off_values(self._skin.RED_FULL, self._skin.RED_THIRD) if (index == self._main_mode_index): self._modes_buttons[index].turn_on() else: self._modes_buttons[index].turn_off() def channel_for_current_mode(self): # in this code, midi channels start at 0. # so channels range from 0 - 15. # mapping to 1-16 in the real world if self._main_mode_index == 0: new_channel = 0 # session elif self._main_mode_index == 1: if self._sub_mode_index[self._main_mode_index] == 0: new_channel = 11 # instrument controller # instrument controller uses base channel plus the 4 next ones. 11,12,13,14,15 if self._instrument_controller != None: self._instrument_controller.base_channel = new_channel elif self._sub_mode_index[self._main_mode_index] == 1: new_channel = 3 # device controller elif self._sub_mode_index[self._main_mode_index] == 2: new_channel = 4 # plain user mode 1 elif self._main_mode_index == 2: if self._sub_mode_index[self._main_mode_index] == 0: new_channel = 1 # step seq elif self._sub_mode_index[self._main_mode_index] == 1: new_channel = 2 # melodic step seq elif self._sub_mode_index[self._main_mode_index] == 2: new_channel = 5 # plain user mode 2 elif self._main_mode_index == 3: # mixer modes # mixer uses base channel 7 and the 4 next ones. new_channel = 6 + self._sub_modes.mode() # 6,7,8,9,10 return new_channel def update(self): assert (self._modes_buttons != None) if self.is_enabled(): self._update_mode_buttons() as_active = True as_enabled = True self._session.set_allow_update(False) self._zooming.set_allow_update(False) self._config_button.send_value(40) self._config_button.send_value(1) if self._main_mode_index == 0: # session self._setup_mixer(not as_active) self._setup_device_controller(not as_active) self._setup_step_sequencer(not as_active) self._setup_step_sequencer2(not as_active) self._setup_instrument_controller(not as_active) self._setup_session(as_active, as_enabled) self._update_control_channels() self._mode_index = 0 elif self._main_mode_index == 1 or self._main_mode_index == 2: self._setup_usermode(Settings.USER_MODES[ (self._main_mode_index-1) * 3 + self._sub_mode_index[self._main_mode_index] ] ) #if self._sub_mode_index[self._main_mode_index] == 0: # self._setup_usermode(Settings.USER_MODES[0]) #elif self._sub_mode_index[self._main_mode_index] == 1: # self._setup_usermode(Settings.USER_MODES[1]) #else: # self._setup_usermode(Settings.USER_MODES[2]) #elif self._main_mode_index == 2: # if self._sub_mode_index[self._main_mode_index] == 0: # self._setup_usermode(Settings.USER_MODES[3]) # elif self._sub_mode_index[self._main_mode_index] == 1: # self._setup_usermode(Setting.USER_MODES[4]) # else: # self._setup_usermode(Settings.USER_MODES[5]) elif self._main_mode_index == 3: # mixer self._setup_device_controller(not as_active) self._setup_step_sequencer(not as_active) self._setup_step_sequencer2(not as_active) self._setup_instrument_controller(not as_active) self._setup_session(not as_active, as_enabled) self._setup_mixer(as_active) self._update_control_channels() self._mode_index = 3 else: assert False self._previous_mode_index = self._main_mode_index self._session.set_allow_update(True) self._zooming.set_allow_update(True) #self.log_message("main selector update") #for line in traceback.format_stack(): # self.log_message(line.strip()) def _setup_usermode(self, mode): as_active = True as_enabled = True if mode == "instrument": self._setup_session(not as_active, not as_enabled) self._setup_step_sequencer(not as_active) self._setup_step_sequencer2(not as_active) self._setup_mixer(not as_active) self._setup_device_controller(not as_active) self._update_control_channels() self._setup_instrument_controller(as_active) self._mode_index = 4 elif mode == "melodic stepseq": self._setup_session(not as_active, not as_enabled) self._setup_instrument_controller(not as_active) self._setup_device_controller(not as_active) self._setup_mixer(not as_active) self._setup_step_sequencer(not as_active) self._setup_step_sequencer2(as_active) self._update_control_channels() self._mode_index = 7 elif mode == "user 1": self._setup_session(not as_active, not as_enabled) self._setup_step_sequencer(not as_active) self._setup_step_sequencer2(not as_active) self._setup_mixer(not as_active) self._setup_device_controller(not as_active) self._setup_instrument_controller(not as_active) self._setup_user_mode(True, True, False, True) self._update_control_channels() self._mode_index = 1 self._osd.clear() self._osd.mode = "User 1" self._osd.update() elif mode == "drum stepseq": self._setup_session(not as_active, not as_enabled) self._setup_instrument_controller(not as_active) self._setup_device_controller(not as_active) self._setup_mixer(not as_active) self._setup_step_sequencer2(not as_active) self._setup_step_sequencer(as_active) self._update_control_channels() self._mode_index = 6 elif mode == "device": self._setup_session(not as_active, not as_enabled) self._setup_step_sequencer(not as_active) self._setup_step_sequencer2(not as_active) self._setup_mixer(not as_active) self._setup_instrument_controller(not as_active) self._setup_device_controller(as_active) self._update_control_channels() self._mode_index = 5 elif mode == "user 2": self._setup_session(not as_active, not as_enabled) self._setup_instrument_controller(not as_active) self._setup_device_controller(not as_active) self._setup_mixer(not as_active) self._setup_step_sequencer(not as_active) self._setup_step_sequencer2(not as_active) self._setup_user_mode(False, False, False, False) self._update_control_channels() self._mode_index = 2 self._osd.clear() self._osd.mode = "User 2" self._osd.update() def _setup_session(self, as_active, as_enabled): assert isinstance(as_active, type(False)) for button in self._nav_buttons: if as_enabled: button.set_on_off_values(self._skin.GREEN_FULL, self._skin.GREEN_THIRD) else: button.set_on_off_values(127, self._skin.off) # matrix self._activate_matrix(True) for scene_index in range(self._session._num_scenes): scene = self._session.scene(scene_index) if as_active: scene_button = self._side_buttons[scene_index] scene_button.set_enabled(as_active) scene_button.set_on_off_values(127, self._skin.off) scene.set_launch_button(scene_button) else: scene.set_launch_button(None) for track_index in range(self._session._num_tracks): if as_active: button = self._matrix.get_button(track_index, scene_index) button.set_on_off_values(127, self._skin.off) button.set_enabled(as_active) scene.clip_slot(track_index).set_launch_button(button) else: scene.clip_slot(track_index).set_launch_button(None) if as_active: if self._session._stop_clip_buttons != None: for button in self._session._stop_clip_buttons: button.set_enabled(as_active) button.set_on_off_values(self._skin.session.track_stop, self._skin.off) self._session.set_stop_track_clip_buttons(self._session._stop_clip_buttons) self._side_buttons[self._session._num_scenes].set_enabled(as_active) self._side_buttons[self._session._num_scenes].set_on_off_values(self._skin.session._stop_clip_buttons, self._skin.off) self._session.set_stop_all_clips_button(self._side_buttons[self._session._num_scenes]) else: self._session.set_stop_track_clip_buttons(None) self._session.set_stop_all_clips_button(None) else: self._session.set_stop_track_clip_buttons(None) self._session.set_stop_all_clips_button(None) # zoom if as_active: self._zooming.set_zoom_button(self._modes_buttons[0]) self._zooming.set_button_matrix(self._matrix) self._zooming.set_scene_bank_buttons(self._side_buttons) self._zooming.set_nav_buttons(self._nav_buttons[0], self._nav_buttons[1], self._nav_buttons[2], self._nav_buttons[3]) self._zooming.update() else: self._zooming.set_zoom_button(None) self._zooming.set_button_matrix(None) self._zooming.set_scene_bank_buttons(None) self._zooming.set_nav_buttons(None, None, None, None) # nav buttons if as_enabled: self._session.set_track_bank_buttons(self._nav_buttons[3], self._nav_buttons[2]) self._session.set_scene_bank_buttons(self._nav_buttons[1], self._nav_buttons[0]) else: self._session.set_track_bank_buttons(None, None) self._session.set_scene_bank_buttons(None, None) def _setup_instrument_controller(self, enabled): if self._instrument_controller != None: if enabled: self._activate_matrix(False) self._activate_scene_buttons(True) self._activate_navigation_buttons(True) else: for scene_index in range(8): scene_button = self._side_buttons[scene_index] scene_button.use_default_message() scene_button.force_next_send() for track_index in range(8): button = self._matrix.get_button(track_index, scene_index) button.use_default_message() button.force_next_send() self._instrument_controller.set_enabled(enabled) def _setup_device_controller(self, as_active): if self._device_controller != None: if as_active: self._activate_scene_buttons(True) self._activate_matrix(True) self._activate_navigation_buttons(True) self._device_controller._is_active = True self._config_button.send_value(32) self._device_controller.set_enabled(True) self._device_controller.update() else: self._device_controller._is_active = False self._device_controller.set_enabled(False) def _setup_user_mode(self, release_matrix=True, release_side_buttons=True, release_nav_buttons=True, drum_rack_mode=True): for scene_index in range(8): scene_button = self._side_buttons[scene_index] scene_button.set_on_off_values(127, self._skin.off) scene_button.force_next_send() scene_button.turn_off() scene_button.set_enabled((not release_side_buttons)) for track_index in range(8): button = self._matrix.get_button(track_index, scene_index) button.set_on_off_values(127, self._skin.off) button.turn_off() button.set_enabled((not release_matrix)) for button in self._nav_buttons: button.set_on_off_values(127, self._skin.off) button.turn_off() button.set_enabled((not release_nav_buttons)) if drum_rack_mode: self._config_button.send_value(2) self._config_button.send_value(32) def _setup_step_sequencer(self, as_active): if(self._stepseq != None): #if(self._stepseq.is_enabled() != as_active): if as_active: self._activate_scene_buttons(True) self._activate_matrix(True) self._activate_navigation_buttons(True) self._config_button.send_value(32) self._stepseq.set_enabled(True) else: self._stepseq.set_enabled(False) def _setup_step_sequencer2(self, as_active): if(self._stepseq2 != None): #if(self._stepseq2.is_enabled() != as_active): if as_active: self._activate_scene_buttons(True) self._activate_matrix(True) self._activate_navigation_buttons(True) self._config_button.send_value(32) self._stepseq2.set_enabled(True) else: self._stepseq2.set_enabled(False) def _setup_mixer(self, as_active): assert isinstance(as_active, type(False)) if as_active: self._activate_navigation_buttons(True) self._activate_scene_buttons(True) self._activate_matrix(True) if(self._sub_modes.is_enabled()): # go back to default mode self._sub_modes.set_mode(-1) else: self._sub_modes.release_controls() self._sub_modes.set_enabled(as_active) def _init_session(self): major = self._parent._live_major_version minor = self._parent._live_minor_version bugfix = self._parent._live_bugfix_version if (major >= 9 and minor > 1) or (major >= 9 and minor >= 1 and bugfix >= 2): # api changed in 9.1.2 self._session.set_stop_clip_value(self._skin.session.track_stop) self._session.set_stop_clip_triggered_value(self._skin.session.clip_triggered_to_stop) else: # api for 9.1.1 below self._session.set_stop_track_clip_value(self._skin.session.clip_triggered_to_stop) #if self._mk2: # self._session.set_rgb_mode(self._skin.CLIP_COLOR_TABLE, self._skin.RGB_COLOR_TABLE) session_height = self._matrix.height() if self._session._stop_clip_buttons != None: session_height = self._matrix.height()-1 for scene_index in range(session_height): scene = self._session.scene(scene_index) scene.set_triggered_value(self._skin.session.scene_triggered) scene.name = 'Scene_' + str(scene_index) for track_index in range(self._matrix.width()): clip_slot = scene.clip_slot(track_index) clip_slot.set_triggered_to_play_value(self._skin.session.clip_triggered_to_play) clip_slot.set_triggered_to_record_value(self._skin.session.clip_triggered_to_record) clip_slot.set_stopped_value(self._skin.session.clip_stopped) clip_slot.set_started_value(self._skin.session.clip_playing) clip_slot.set_recording_value(self._skin.session.clip_recording) clip_slot.set_record_button_value(self._skin.session.clip_record) clip_slot.name = str(track_index) + '_Clip_Slot_' + str(scene_index) self._all_buttons.append(self._matrix.get_button(track_index, scene_index)) self._zooming.set_stopped_value(self._skin.RED_FULL) self._zooming.set_selected_value(self._skin.AMBER_FULL) self._zooming.set_playing_value(self._skin.GREEN_FULL) def _activate_navigation_buttons(self, active): for button in self._nav_buttons: button.set_enabled(active) def _activate_scene_buttons(self, active): for button in self._side_buttons: button.set_enabled(active) def _activate_matrix(self, active): for scene_index in range(8): for track_index in range(8): self._matrix.get_button(track_index, scene_index).set_enabled(active) def log_message(self, msg): self._parent.log_message(msg) # Update the channels of the buttons in the user modes.. def _update_control_channels(self): new_channel = self.channel_for_current_mode() for button in self._all_buttons: button.set_channel(new_channel) button.set_force_next_value()
class MainSelectorComponent(ModeSelectorComponent,Launchpad95M4LInterfaceMixin): """ Class that reassigns the button on the launchpad to different functions """ def log(self, message): self._parent.log_message((' '+message+' ').center(50,'=')) def __init__(self, matrix, top_buttons, side_buttons, config_button, parent): assert isinstance(matrix, ButtonMatrixElement) assert ((matrix.width() == 8) and (matrix.height() == 8)) assert isinstance(top_buttons, tuple) assert (len(top_buttons) == 8) assert isinstance(side_buttons, tuple) assert (len(side_buttons) == 8) assert isinstance(config_button, ButtonElement) ModeSelectorComponent.__init__(self) self._m4lmode_index = 0 self.init_m4l_interface() self._attributes = [ '-' for _ in range(8) ] self._attribute_names = [ '-' for _ in range(8) ] self._info = [' ', ' '] self._map_name = MAP_NAMES[self._m4lmode_index] self._parent = parent self._compact = False self._session = SpecialSessionComponent(matrix.width(), matrix.height()) self._zooming = SessionZoomingComponent(self._session) self._session.name = 'Session_Control' self._zooming.name = 'Session_Overview' self._matrix = matrix self._side_buttons = side_buttons self._nav_buttons = top_buttons[:4] self._config_button = config_button self._zooming.set_empty_value(LED_OFF) self._all_buttons = [] for button in self._side_buttons + self._nav_buttons: self._all_buttons.append(button) self._sub_modes = SubSelectorComponent(matrix, side_buttons, self._session) self._sub_modes.name = 'Mixer_Modes' self._sub_modes.set_update_callback(self._update_control_channels) self._stepseq = StepSequencerComponent(self._matrix, self._side_buttons, self._nav_buttons, self) self._stepseq2 = StepSequencerComponent2(self._matrix, self._side_buttons, self._nav_buttons, self) self._instrument_controller = InstrumentControllerComponent( self._matrix, self._side_buttons, self._nav_buttons,self) self._device_controller = DeviceControllerComponent(self._matrix, self._side_buttons, self._nav_buttons, self) self._init_session() self._all_buttons = tuple(self._all_buttons) self._mode_index=0 self._previous_mode_index=-1 self._main_mode_index=0 self._sub_mode_index=[0,0,0,0] for index in range(4): self._sub_mode_index[index]=0 self.set_mode_buttons(top_buttons[4:]) def disconnect(self): for button in self._modes_buttons: button.remove_value_listener(self._mode_value) self._session = None self._zooming = None for button in self._all_buttons: button.set_on_off_values(127, LED_OFF) self._config_button.turn_off() self._matrix = None self._side_buttons = None self._nav_buttons = None self._config_button = None ModeSelectorComponent.disconnect(self) def set_m4lmode(self,mode_str): #self.log(mode_str) if mode_str == 'SCALE': self._m4lmode_index = 8 elif mode_str == 'QUICK_SCALE': self._m4lmode_index = 9 elif mode_str == 'MULTINOTE': self._m4lmode_index = 10 elif mode_str == 'INST': self._m4lmode_index = 1 elif mode_str == 'STEP': self._m4lmode_index = 4 self.refresh_map_display() @property def mode_name(self): """ Returns the name of the current mode. """ #self.log(MODE_NAMES[self._m4lmode_index]) return MODE_NAMES[self._m4lmode_index] @property def mode_attributes(self): """ Returns the attributes of the current mode. """ #self.log(self._attributes) return self._attributes @property def mode_attribute_names(self): """ Returns the names of the attributes of the current mode. """ #self.log(self._attributes_names) return self._attribute_names @property def mode_info(self): """ Returns info about the current mode. """ #self.log(self._info) return self._info @property def mode_map(self): """ Returns the name of the relevant map for the current mode. """ #self.log(MAP_NAMES[self._m4lmode_index]) return MAP_NAMES[self._m4lmode_index] def session_component(self): return self._session def _update_mode(self): mode = self._modes_heap[-1][0] assert mode in range(self.number_of_modes()) if self._main_mode_index==mode: if self._main_mode_index==1: #user mode 1 and device controller and instrument mode self._sub_mode_index[self._main_mode_index] = (self._sub_mode_index[self._main_mode_index]+1)%3 self.update() elif self._main_mode_index==2: #user mode 2 and step sequencer self._sub_mode_index[self._main_mode_index] = (self._sub_mode_index[self._main_mode_index]+1)%3 self.update() elif self._main_mode_index==3: self.update() else: self._sub_mode_index[self._main_mode_index] = 0 self._mode_index = 0 self._previous_mode_index=self._main_mode_index else: self._main_mode_index = mode self.update() def set_mode(self, mode): self._clean_heap() self._modes_heap = [(mode, None, None)] self._compute_mode_index() #if ((self.__main_mode_index != mode) or (mode == 3) or True): #self._main_mode_index = mode #self._update_mode() # self.update() def number_of_modes(self): return 1+3+3+1 def on_enabled_changed(self): self.update() def _update_mode_buttons(self): for index in range(4): if(self._sub_mode_index[index]==0): self._modes_buttons[index].set_on_off_values(AMBER_FULL,AMBER_THIRD) if(self._sub_mode_index[index]==1): self._modes_buttons[index].set_on_off_values(GREEN_FULL,GREEN_THIRD) if(self._sub_mode_index[index]==2): self._modes_buttons[index].set_on_off_values(RED_FULL,RED_THIRD) if (index == self._main_mode_index): self._modes_buttons[index].turn_on() else: self._modes_buttons[index].turn_off() def channel_for_current_mode(self): # in this code, midi channels start at 0. # so channels range from 0 - 15. # mapping to 1-16 in the real world if self._main_mode_index==0: new_channel = 0 # session elif self._main_mode_index==1: if self._sub_mode_index[self._main_mode_index]==0: new_channel = 11 # instrument controller #instrument controller uses base channel plus the 4 next ones. 11,12,13,14,15 if self._instrument_controller != None: self._instrument_controller.base_channel = new_channel elif self._sub_mode_index[self._main_mode_index]==1: new_channel = 3 #device controller elif self._sub_mode_index[self._main_mode_index]==2: new_channel = 4 #plain user mode 1 elif self._main_mode_index==2: if self._sub_mode_index[self._main_mode_index]==0: new_channel = 1 #step seq elif self._sub_mode_index[self._main_mode_index]==1: new_channel = 2 #melodic step seq elif self._sub_mode_index[self._main_mode_index]==2: new_channel = 5 #plain user mode 2 elif self._main_mode_index==3: #mixer modes #mixer uses base channel 7 and the 4 next ones. new_channel = 6 + self._sub_modes.mode() # 6,7,8,9,10 return new_channel def _compute_mode_index(self): if self._main_mode_index == 0: #session self._mode_index = 0 elif self._main_mode_index == 1: if self._sub_mode_index[self._main_mode_index]==0: #instrument controller self._mode_index = 4 elif self._sub_mode_index[self._main_mode_index]==1: #device controller self._mode_index = 5 else: #plain user mode 1 self._mode_index = 1 elif self._main_mode_index == 2: if self._sub_mode_index[self._main_mode_index]==0: #stepseq self._mode_index = 6 elif self._sub_mode_index[self._main_mode_index]==1: #melodic step seq self._mode_index = 7 else: #plain user mode 2 self._mode_index = 2 elif self._main_mode_index == 3: self._mode_index = 3 else: assert False def update(self): assert (self._modes_buttons != None) if self.is_enabled(): self._update_mode_buttons() as_active = True as_enabled = True self._session.set_allow_update(False) self._zooming.set_allow_update(False) self._config_button.send_value(40) self._config_button.send_value(1) if self._main_mode_index == 0: #session self._m4lmode_index = 0 self.refresh_map_display() self._setup_mixer(not as_active) self._setup_device_controller(not as_active) self._setup_step_sequencer(not as_active) self._setup_step_sequencer2(not as_active) self._setup_instrument_controller(not as_active) self._setup_session(as_active, as_enabled) self._update_control_channels() elif self._main_mode_index == 1: self._setup_session(not as_active, not as_enabled) self._setup_step_sequencer(not as_active) self._setup_step_sequencer2(not as_active) self._setup_mixer(not as_active) if self._sub_mode_index[self._main_mode_index]==0: #instrument controller self._setup_device_controller(not as_active) self._update_control_channels() self._setup_instrument_controller(as_active) elif self._sub_mode_index[self._main_mode_index]==1: #device controller self._setup_instrument_controller(not as_active) self._setup_device_controller(as_active) self._update_control_channels() else: #plain user mode 1 self._m4lmode_index = 3 self.refresh_map_display() self._setup_device_controller(not as_active) self._setup_instrument_controller(not as_active) self._setup_user_mode(True, True, False, True) self._update_control_channels() elif self._main_mode_index == 2: self._setup_session(not as_active, not as_enabled) self._setup_instrument_controller(not as_active) self._setup_device_controller(not as_active) self._setup_mixer(not as_active) if self._sub_mode_index[self._main_mode_index]==0: #stepseq self._m4lmode_index = 4 self.refresh_map_display() self._setup_step_sequencer2(not as_active) self._setup_step_sequencer(as_active) elif self._sub_mode_index[self._main_mode_index]==1: #melodic step seq self._m4lmode_index = 5 self.refresh_map_display() self._setup_step_sequencer(not as_active) self._setup_step_sequencer2(as_active) else: #plain user mode 2 self._m4lmode_index = 6 self.refresh_map_display() self._setup_step_sequencer(not as_active) self._setup_step_sequencer2(not as_active) self._setup_user_mode(False, False, False, False) self._update_control_channels() elif self._main_mode_index == 3: #mixer self._m4lmode_index = 7 self.refresh_map_display() self._setup_device_controller(not as_active) self._setup_step_sequencer(not as_active) self._setup_step_sequencer2(not as_active) self._setup_instrument_controller(not as_active) self._setup_session(not as_active, as_enabled) self._setup_mixer(as_active) self._update_control_channels() else: assert False self._compute_mode_index() self._previous_mode_index=self._main_mode_index self._session.set_allow_update(True) self._zooming.set_allow_update(True) def _setup_session(self, as_active, as_enabled): assert isinstance(as_active, type(False)) for button in self._nav_buttons: if as_enabled: button.set_on_off_values(GREEN_FULL, GREEN_THIRD) else: button.set_on_off_values(127, LED_OFF) #matrix self._activate_matrix(True) for scene_index in range(8): scene = self._session.scene(scene_index) if as_active: scene_button = self._side_buttons[scene_index] scene_button.set_enabled(as_active) scene_button.set_on_off_values(127, LED_OFF) scene.set_launch_button(scene_button) else: scene.set_launch_button(None) for track_index in range(8): if as_active: button = self._matrix.get_button(track_index, scene_index) button.set_on_off_values(127, LED_OFF) button.set_enabled(as_active) scene.clip_slot(track_index).set_launch_button(button) else: scene.clip_slot(track_index).set_launch_button(None) #zoom if as_active: self._zooming.set_zoom_button(self._modes_buttons[0]) self._zooming.set_button_matrix(self._matrix) self._zooming.set_scene_bank_buttons(self._side_buttons) self._zooming.set_nav_buttons(self._nav_buttons[0], self._nav_buttons[1], self._nav_buttons[2], self._nav_buttons[3]) self._zooming.update() else: self._zooming.set_zoom_button(None) self._zooming.set_button_matrix(None) self._zooming.set_scene_bank_buttons(None) self._zooming.set_nav_buttons(None, None, None, None) #nav buttons if as_enabled: self._session.set_track_bank_buttons(self._nav_buttons[3], self._nav_buttons[2]) self._session.set_scene_bank_buttons(self._nav_buttons[1], self._nav_buttons[0]) else: self._session.set_track_bank_buttons(None, None) self._session.set_scene_bank_buttons(None, None) def _setup_instrument_controller(self, enabled): if self._instrument_controller != None: if enabled: self._m4lmode_index = 1 self.refresh_map_display() self._activate_matrix(False) self._activate_scene_buttons(True) self._activate_navigation_buttons(True) else: for scene_index in range(8): scene_button = self._side_buttons[scene_index] scene_button.use_default_message() scene_button.force_next_send() for track_index in range(8): button = self._matrix.get_button(track_index, scene_index) button.use_default_message() button.force_next_send() self._instrument_controller.set_enabled(enabled) def _setup_device_controller(self, as_active): if self._device_controller!=None: if as_active: self._m4lmode_index = 2 self.refresh_map_display() self._activate_scene_buttons(True) self._activate_matrix(True) self._activate_navigation_buttons(True) self._device_controller._is_active = True self._config_button.send_value(32) self._device_controller.set_enabled(True) self._device_controller.update() else: self._device_controller._is_active = False self._device_controller.set_enabled(False) def _setup_user_mode(self, release_matrix=True, release_side_buttons=True, release_nav_buttons = True, drum_rack_mode = True): for scene_index in range(8): scene_button = self._side_buttons[scene_index] scene_button.set_on_off_values(127, LED_OFF) scene_button.force_next_send() scene_button.turn_off() scene_button.set_enabled((not release_side_buttons)) for track_index in range(8): button = self._matrix.get_button(track_index, scene_index) button.set_on_off_values(127, LED_OFF) button.turn_off() button.set_enabled((not release_matrix)) for button in self._nav_buttons: button.set_on_off_values(127, LED_OFF) button.turn_off() button.set_enabled((not release_nav_buttons)) if drum_rack_mode: self._config_button.send_value(2) self._config_button.send_value(32) def _setup_step_sequencer(self, as_active): if(self._stepseq!=None): if(self._stepseq.is_enabled()!=as_active): if as_active: self._activate_scene_buttons(True) self._activate_matrix(True) self._activate_navigation_buttons(True) self._config_button.send_value(32) self._stepseq.set_enabled(True) else: self._stepseq.set_enabled(False) def _setup_step_sequencer2(self, as_active): if(self._stepseq2!=None): if(self._stepseq2.is_enabled()!=as_active): if as_active: self._activate_scene_buttons(True) self._activate_matrix(True) self._activate_navigation_buttons(True) self._config_button.send_value(32) self._stepseq2.set_enabled(True) else: self._stepseq2.set_enabled(False) def _setup_mixer(self, as_active): assert isinstance(as_active, type(False)) if as_active: self._activate_navigation_buttons(True) self._activate_scene_buttons(True) self._activate_matrix(True) if(self._sub_modes.is_enabled()): #go back to default mode self._sub_modes.set_mode(-1) self._sub_modes.set_enabled(as_active) def _init_session(self): if self._parent._live_major_version >= 9 and self._parent._live_minor_version >= 1 and self._parent._live_bugfix_version >= 2: #api changed in 9.1.2 self._session.set_stop_clip_value(AMBER_THIRD) self._session.set_stop_clip_triggered_value(AMBER_BLINK) else: # api for 9.1.1 below self._session.set_stop_track_clip_value(AMBER_BLINK) for scene_index in range(self._matrix.height()): scene = self._session.scene(scene_index) scene.set_triggered_value(GREEN_BLINK) scene.name = 'Scene_' + str(scene_index) for track_index in range(self._matrix.width()): clip_slot = scene.clip_slot(track_index) clip_slot.set_triggered_to_play_value(GREEN_BLINK) clip_slot.set_triggered_to_record_value(RED_BLINK) clip_slot.set_stopped_value(AMBER_FULL) clip_slot.set_started_value(GREEN_FULL) clip_slot.set_recording_value(RED_FULL) clip_slot.set_record_button_value(RED_THIRD) #clip_slot.set_clip_palette(CLIP_COLOR_TABLE) #clip_slot.set_clip_rgb_table(RGB_COLOR_TABLE) clip_slot.name = str(track_index) + '_Clip_Slot_' + str(scene_index) self._all_buttons.append(self._matrix.get_button(track_index, scene_index)) self._zooming.set_stopped_value(RED_FULL) self._zooming.set_selected_value(AMBER_FULL) self._zooming.set_playing_value(GREEN_FULL) def _activate_navigation_buttons(self,active): for button in self._nav_buttons: button.set_enabled(active) def _activate_scene_buttons(self,active): for button in self._side_buttons: button.set_enabled(active) def _activate_matrix(self,active): for scene_index in range(8): for track_index in range(8): self._matrix.get_button(track_index, scene_index).set_enabled(active) def log_message(self, msg): self._parent.log_message(msg) #Update the channels of the buttons in the user modes.. def _update_control_channels(self): new_channel = self.channel_for_current_mode() for button in self._all_buttons: button.set_channel(new_channel) button.set_force_next_value()