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:]) self._session = SpecialSessionComponent(matrix.width(), matrix.height(), self) self._session.set_osd(self._osd) 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._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 __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:]) self._session = SpecialSessionComponent(matrix.width(), matrix.height(),self) self._session.set_osd(self._osd) 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._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 __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)
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()
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)
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 APC_64_40_9(APC): """ Script for Akai's APC40 Controller """ def __init__(self, c_instance): self._c_instance = c_instance self._shift_modes = None self._encoder_modes = None self._slider_modes = None self._sequencer = None APC.__init__(self, c_instance) self._device_selection_follows_track_selection = True def disconnect(self): self._shift_modes = None self._encoder_modes = None self._slider_modes = None self._sequencer = None APC.disconnect(self) def _setup_session_control(self): is_momentary = True self._shift_button = ButtonElement(is_momentary, MIDI_NOTE_TYPE, 0, 98) self._right_button = ButtonElement(is_momentary, MIDI_NOTE_TYPE, 0, 96) self._left_button = ButtonElement(is_momentary, MIDI_NOTE_TYPE, 0, 97) self._up_button = ButtonElement(is_momentary, MIDI_NOTE_TYPE, 0, 94) self._down_button = ButtonElement(is_momentary, MIDI_NOTE_TYPE, 0, 95) self._right_button.name = 'Bank_Select_Right_button' self._left_button.name = 'Bank_Select_Left_button' self._up_button.name = 'Bank_Select_Up_button' self._down_button.name = 'Bank_Select_Down_button' self._session = PedaledSessionComponent(8, 5) self._session.name = 'Session_Control' self._session.set_track_bank_buttons(self._right_button, self._left_button) self._session.set_scene_bank_buttons(self._down_button, self._up_button) self._matrix = ButtonMatrixElement() self._matrix.name = 'Button_Matrix' self._scene_launch_buttons = [ ButtonElement(is_momentary, MIDI_NOTE_TYPE, 0, index + 82) for index in range(5) ] self._track_stop_buttons = [ ConfigurableButtonElement(is_momentary, MIDI_NOTE_TYPE, index, 52) for index in range(8) ] for index in range(len(self._scene_launch_buttons)): self._scene_launch_buttons[index].name = 'Scene_' + str( index) + '_Launch_Button' for index in range(len(self._track_stop_buttons)): self._track_stop_buttons[index].name = 'Track_' + str( index) + '_Stop_Button' self._stop_all_button = ButtonElement(is_momentary, MIDI_NOTE_TYPE, 0, 81) self._stop_all_button.name = 'Stop_All_Clips_Button' self._session.set_stop_all_clips_button(self._stop_all_button) self._session.set_stop_track_clip_buttons( tuple(self._track_stop_buttons)) self._session.set_stop_track_clip_value(2) for scene_index in range(5): scene = self._session.scene(scene_index) scene.name = 'Scene_' + str(scene_index) button_row = [] scene.set_launch_button(self._scene_launch_buttons[scene_index]) scene.set_triggered_value(2) for track_index in range(8): button = ConfigurableButtonElement(is_momentary, MIDI_NOTE_TYPE, track_index, (scene_index + 53)) button.name = str(track_index) + '_Clip_' + str( scene_index) + '_Button' button_row.append(button) clip_slot = scene.clip_slot(track_index) clip_slot.name = str(track_index) + '_Clip_Slot_' + str( scene_index) clip_slot.set_triggered_to_play_value(2) clip_slot.set_triggered_to_record_value(4) clip_slot.set_stopped_value(5) clip_slot.set_started_value(1) clip_slot.set_recording_value(3) clip_slot.set_launch_button(button) self._matrix.add_row(tuple(button_row)) self._session.set_slot_launch_button( ButtonElement(is_momentary, MIDI_CC_TYPE, 0, 67)) self._session.selected_scene().name = 'Selected_Scene' self._session.selected_scene().set_launch_button( ButtonElement(is_momentary, MIDI_CC_TYPE, 0, 64)) self._session_zoom = ShiftableZoomingComponent( self._session, tuple(self._track_stop_buttons)) self._session_zoom.name = 'Session_Overview' self._session_zoom.set_button_matrix(self._matrix) self._session_zoom.set_zoom_button(self._shift_button) self._session_zoom.set_nav_buttons(self._up_button, self._down_button, self._left_button, self._right_button) self._session_zoom.set_scene_bank_buttons( tuple(self._scene_launch_buttons)) self._session_zoom.set_stopped_value(3) self._session_zoom.set_selected_value(5) def _setup_mixer_control(self): is_momentary = True self._mixer = SpecialMixerComponent(self, 8) self._mixer.name = 'Mixer' self._mixer.master_strip().name = 'Master_Channel_Strip' master_select_button = ButtonElement(is_momentary, MIDI_NOTE_TYPE, 0, 80) master_select_button.name = 'Master_Select_Button' self._mixer.master_strip().set_select_button(master_select_button) self._mixer.selected_strip().name = 'Selected_Channel_Strip' select_buttons = [] arm_buttons = [] solo_buttons = [] mute_buttons = [] sliders = [] for track in range(8): strip = self._mixer.channel_strip(track) strip.name = 'Channel_Strip_' + str(track) solo_button = ButtonElement(is_momentary, MIDI_NOTE_TYPE, track, 49) solo_buttons.append(solo_button) mute_button = ButtonElement(is_momentary, MIDI_NOTE_TYPE, track, 50) mute_buttons.append(mute_button) solo_button.name = str(track) + '_Solo_Button' mute_button.name = str(track) + '_Mute_Button' strip.set_solo_button(solo_button) strip.set_mute_button(mute_button) strip.set_shift_button(self._shift_button) strip.set_invert_mute_feedback(True) select_buttons.append( ButtonElement(is_momentary, MIDI_NOTE_TYPE, track, 51)) select_buttons[-1].name = str(track) + '_Select_Button' arm_buttons.append( ButtonElement(is_momentary, MIDI_NOTE_TYPE, track, 48)) arm_buttons[-1].name = str(track) + '_Arm_Button' sliders.append(SliderElement(MIDI_CC_TYPE, track, 7)) sliders[-1].name = str(track) + '_Volume_Control' self._crossfader = SliderElement(MIDI_CC_TYPE, 0, 15) master_volume_control = SliderElement(MIDI_CC_TYPE, 0, 14) self._prehear_control = EncoderElement( MIDI_CC_TYPE, 0, 47, Live.MidiMap.MapMode.relative_two_compliment) self._crossfader.name = 'Crossfader' master_volume_control.name = 'Master_Volume_Control' self._prehear_control.name = 'Prehear_Volume_Control' self._mixer.set_shift_button(self._shift_button) self._mixer.set_crossfader_control(self._crossfader) self._mixer.set_prehear_volume_control(self._prehear_control) self._mixer.master_strip().set_volume_control(master_volume_control) self._slider_modes = SliderModesComponent(self._mixer, tuple(sliders)) self._slider_modes.name = 'Slider_Modes' matrix_modes = MatrixModesComponent(self._matrix, self._session, self._session_zoom, tuple(self._track_stop_buttons), self) matrix_modes.name = 'Matrix_Modes' self._sequencer = StepSequencerComponent( self, self._session, self._matrix, tuple(self._track_stop_buttons)) self._sequencer.set_bank_buttons(tuple(select_buttons)) self._sequencer.set_nav_buttons(self._up_button, self._down_button, self._left_button, self._right_button) self._sequencer.set_button_matrix(self._matrix) self._sequencer.set_follow_button(master_select_button) self._sequencer.set_velocity_buttons(tuple(arm_buttons)) self._sequencer.set_shift_button(self._shift_button) self._sequencer.set_lane_mute_buttons(tuple( self._scene_launch_buttons)) self._sequencer.set_loop_start_buttons(tuple(mute_buttons)) self._sequencer.set_loop_length_buttons(tuple(solo_buttons)) self._shift_modes = ShiftableSelectorComponent( self, tuple(select_buttons), master_select_button, tuple(self._track_stop_buttons), self._stop_all_button, tuple(mute_buttons), tuple(solo_buttons), tuple(arm_buttons), tuple(self._scene_launch_buttons), self._matrix, self._session, self._session_zoom, self._mixer, self._slider_modes, matrix_modes, self._sequencer) self._shift_modes.name = 'Shift_Modes' self._shift_modes.set_mode_toggle(self._shift_button) def _setup_custom_components(self): self._setup_device_and_transport_control() self._setup_global_control() def _setup_device_and_transport_control(self): is_momentary = True device_bank_buttons = [] device_param_controls = [] bank_button_labels = ('Clip_Track_Button', 'Device_On_Off_Button', 'Previous_Device_Button', 'Next_Device_Button', 'Detail_View_Button', 'Rec_Quantization_Button', 'Midi_Overdub_Button', 'Metronome_Button') for index in range(8): device_bank_buttons.append( ButtonElement(is_momentary, MIDI_NOTE_TYPE, 0, 58 + index)) device_bank_buttons[-1].name = bank_button_labels[index] ring_mode_button = ButtonElement(not is_momentary, MIDI_CC_TYPE, 0, 24 + index) ringed_encoder = RingedEncoderElement( MIDI_CC_TYPE, 0, 16 + index, Live.MidiMap.MapMode.absolute) ringed_encoder.set_ring_mode_button(ring_mode_button) ringed_encoder.set_feedback_delay(-1) ringed_encoder.name = 'Device_Control_' + str(index) ring_mode_button.name = ringed_encoder.name + '_Ring_Mode_Button' device_param_controls.append(ringed_encoder) self._device = ShiftableDeviceComponent() self._device.name = 'Device_Component' self._device.set_bank_buttons(tuple(device_bank_buttons)) self._device.set_shift_button(self._shift_button) self._device.set_parameter_controls(tuple(device_param_controls)) self._device.set_on_off_button(device_bank_buttons[1]) self.set_device_component(self._device) detail_view_toggler = DetailViewCntrlComponent() detail_view_toggler.name = 'Detail_View_Control' detail_view_toggler.set_shift_button(self._shift_button) detail_view_toggler.set_device_clip_toggle_button( device_bank_buttons[0]) detail_view_toggler.set_detail_toggle_button(device_bank_buttons[4]) detail_view_toggler.set_device_nav_buttons(device_bank_buttons[2], device_bank_buttons[3]) transport = ShiftableTransportComponent() transport.name = 'Transport' play_button = ButtonElement(is_momentary, MIDI_NOTE_TYPE, 0, 91) stop_button = ButtonElement(is_momentary, MIDI_NOTE_TYPE, 0, 92) record_button = ButtonElement(is_momentary, MIDI_NOTE_TYPE, 0, 93) nudge_up_button = ButtonElement(is_momentary, MIDI_NOTE_TYPE, 0, 100) nudge_down_button = ButtonElement(is_momentary, MIDI_NOTE_TYPE, 0, 101) tap_tempo_button = ButtonElement(is_momentary, MIDI_NOTE_TYPE, 0, 99) play_button.name = 'Play_Button' stop_button.name = 'Stop_Button' record_button.name = 'Record_Button' nudge_up_button.name = 'Nudge_Up_button' nudge_down_button.name = 'Nudge_Down_button' tap_tempo_button.name = 'Tap_Tempo_Button' transport.set_shift_button(self._shift_button) transport.set_play_button(play_button) transport.set_stop_button(stop_button) transport.set_record_button(record_button) transport.set_nudge_buttons(nudge_up_button, nudge_down_button) transport.set_undo_button(nudge_down_button) transport.set_redo_button(nudge_up_button) transport.set_tap_tempo_button(tap_tempo_button) self._device.set_lock_button(tap_tempo_button) transport.set_quant_toggle_button(device_bank_buttons[5]) transport.set_overdub_button(device_bank_buttons[6]) transport.set_metronome_button(device_bank_buttons[7]) transport.set_tempo_encoder(self._prehear_control) bank_button_translator = ShiftTranslatorComponent() bank_button_translator.set_controls_to_translate( tuple(device_bank_buttons)) bank_button_translator.set_shift_button(self._shift_button) def _setup_global_control(self): is_momentary = True self._global_bank_buttons = [] self._global_param_controls = [] for index in range(8): ring_button = ButtonElement(not is_momentary, MIDI_CC_TYPE, 0, 56 + index) ringed_encoder = RingedEncoderElement( MIDI_CC_TYPE, 0, 48 + index, Live.MidiMap.MapMode.absolute) ringed_encoder.name = 'Track_Control_' + str(index) ringed_encoder.set_feedback_delay(-1) ring_button.name = ringed_encoder.name + '_Ring_Mode_Button' ringed_encoder.set_ring_mode_button(ring_button) self._global_param_controls.append(ringed_encoder) self._global_bank_buttons = [] global_bank_labels = ('Pan_Button', 'Send_A_Button', 'Send_B_Button', 'Send_C_Button') for index in range(4): self._global_bank_buttons.append( ConfigurableButtonElement(is_momentary, MIDI_NOTE_TYPE, 0, 87 + index)) self._global_bank_buttons[-1].name = global_bank_labels[index] self._encoder_modes = EncModeSelectorComponent(self._mixer) self._encoder_modes.name = 'Track_Control_Modes' self._encoder_modes.set_controls(tuple(self._global_param_controls)) self._encoder_device_modes = EncoderDeviceComponent( self._mixer, self._device, self) self._encoder_device_modes.name = 'Alt_Device_Control_Modes' self._encoder_eq_modes = EncoderEQComponent(self._mixer, self) self._encoder_eq_modes.name = 'EQ_Control_Modes' global_translation_selector = ChannelTranslationSelector() global_translation_selector.name = 'Global_Translations' global_translation_selector.set_controls_to_translate( tuple(self._global_param_controls)) global_translation_selector.set_mode_buttons( tuple(self._global_bank_buttons)) encoder_user_modes = EncoderUserModesComponent( self, self._encoder_modes, tuple(self._global_param_controls), tuple(self._global_bank_buttons), self._mixer, self._device, self._encoder_device_modes, self._encoder_eq_modes) encoder_user_modes.name = 'Encoder_User_Modes' self._encoder_shift_modes = ShiftableEncoderSelectorComponent( self, tuple(self._global_bank_buttons), encoder_user_modes, self._encoder_modes, self._encoder_eq_modes, self._encoder_device_modes) self._encoder_shift_modes.name = 'Encoder_Shift_Modes' self._encoder_shift_modes.set_mode_toggle(self._shift_button) def _on_selected_track_changed(self): ControlSurface._on_selected_track_changed(self) track = self.song().view.selected_track device_to_select = track.view.selected_device if device_to_select == None and len(track.devices) > 0: device_to_select = track.devices[0] if device_to_select != None: self.song().view.select_device(device_to_select) self._device_component.set_device(device_to_select) return None def _product_model_id_byte(self): return 115
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()
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()
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)
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()
def __init__(self, matrix, top_buttons, side_buttons, config_button, osd, control_surface, note_repeat, c_instance): #Live.Base.log("MainSelectorComponent - __init__ ") #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) assert isinstance(note_repeat, NoteRepeatComponent) ModeSelectorComponent.__init__(self) #super constructor #inject ControlSurface and OSD components (M4L) self._matrix = matrix self._nav_buttons = top_buttons[:4]#arrow buttons self._mode_buttons = top_buttons[4:]#session,user1,user2,mixer buttons self._side_buttons = side_buttons#launch buttons self._config_button = config_button#used to reset launchpad self._osd = osd self._control_surface = control_surface self._note_repeat = note_repeat self._c_instance = c_instance self._pro_session_on = False self._long_press = 500 self._last_session_mode_button_press = int(round(time.time() * 1000)) self._aux_scene = None #Non-Matrix buttons self._all_buttons = [] for button in self._side_buttons + self._nav_buttons: self._all_buttons.append(button) #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] # One for each LP Mode button for index in range(4): self._sub_mode_list[index] = 0 self.set_mode_buttons(self._mode_buttons) self._last_mode_index = 0 self._clip_stop_buttons = [] for column in range(8): self._clip_stop_buttons.append(matrix.get_button(column,matrix.height()-1)) self._session = SpecialProSessionComponent(matrix.width(), matrix.height(), None, self._side_buttons, self._control_surface, self, self._c_instance.song()) #initialize _session variables self._session.set_osd(self._osd) self._session.name = 'Session_Control' ###ZOOMING COMPONENT self._zooming = DeprecatedSessionZoomingComponent(self._session, enable_skinning = True) self._zooming.name = 'Session_Overview' self._zooming.set_empty_value("DefaultButton.Disabled") #SubSelector changes the Mode using side buttons -> MIXER MODE (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._note_repeat) 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 __init__(self, matrix, top_buttons, side_buttons, config_button, osd, control_surface): 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._control_surface = control_surface 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._control_surface, self) else: #no stop buttons self._session = SpecialSessionComponent(matrix.width(), matrix.height(), None, self._control_surface, 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(self._control_surface._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, 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) self._stepseq = StepSequencerComponent(self._matrix, self._side_buttons, self._nav_buttons, self._control_surface) self._stepseq.set_osd(self._osd) self._stepseq2 = StepSequencerComponent2(self._matrix, self._side_buttons, self._nav_buttons, self._control_surface) self._stepseq2.set_osd(self._osd) self._instrument_controller = InstrumentControllerComponent( self._matrix, self._side_buttons, self._nav_buttons, self._control_surface) self._instrument_controller.set_osd(self._osd) self._device_controller = DeviceControllerComponent( self._matrix, self._side_buttons, self._nav_buttons, self._control_surface) self._device_controller.set_osd(self._osd) self._init_session() self._all_buttons = tuple(self._all_buttons)
class APC_64_40_9_vu(APC): """ Script for Akai's APC40 Controller """ def __init__(self, c_instance): self._c_instance = c_instance self._shift_modes = None self._encoder_modes = None self._slider_modes = None self._sequencer = None APC.__init__(self, c_instance) self._device_selection_follows_track_selection = True def disconnect(self): self._shift_modes = None self._encoder_modes = None self._slider_modes = None self._sequencer = None APC.disconnect(self) def _setup_session_control(self): is_momentary = True self._shift_button = ButtonElement(is_momentary, MIDI_NOTE_TYPE, 0, 98) self._right_button = ButtonElement(is_momentary, MIDI_NOTE_TYPE, 0, 96) self._left_button = ButtonElement(is_momentary, MIDI_NOTE_TYPE, 0, 97) self._up_button = ButtonElement(is_momentary, MIDI_NOTE_TYPE, 0, 94) self._down_button = ButtonElement(is_momentary, MIDI_NOTE_TYPE, 0, 95) self._right_button.name = 'Bank_Select_Right_button' self._left_button.name = 'Bank_Select_Left_button' self._up_button.name = 'Bank_Select_Up_button' self._down_button.name = 'Bank_Select_Down_button' self._session = PedaledSessionComponent(8, 5) self._session.name = 'Session_Control' self._session.set_track_bank_buttons(self._right_button, self._left_button) self._session.set_scene_bank_buttons(self._down_button, self._up_button) self._matrix = ButtonMatrixElement() self._matrix.name = 'Button_Matrix' self._scene_launch_buttons = [ ButtonElement(is_momentary, MIDI_NOTE_TYPE, 0, index + 82) for index in range(5) ] self._track_stop_buttons = [ ConfigurableButtonElement(is_momentary, MIDI_NOTE_TYPE, index, 52) for index in range(8) ] for index in range(len(self._scene_launch_buttons)): self._scene_launch_buttons[index].name = 'Scene_' + str(index) + '_Launch_Button' for index in range(len(self._track_stop_buttons)): self._track_stop_buttons[index].name = 'Track_' + str(index) + '_Stop_Button' self._stop_all_button = ButtonElement(is_momentary, MIDI_NOTE_TYPE, 0, 81) self._stop_all_button.name = 'Stop_All_Clips_Button' self._session.set_stop_all_clips_button(self._stop_all_button) self._session.set_stop_track_clip_buttons(tuple(self._track_stop_buttons)) self._session.set_stop_clip_value(0) self._session.set_stop_clip_triggered_value(2) self._button_rows = [] for scene_index in range(5): scene = self._session.scene(scene_index) scene.name = 'Scene_' + str(scene_index) button_row = [] scene.set_launch_button(self._scene_launch_buttons[scene_index]) scene.set_triggered_value(2) for track_index in range(8): button = ConfigurableButtonElement(is_momentary, MIDI_NOTE_TYPE, track_index, (scene_index + 53)) button.name = str(track_index) + '_Clip_' + str(scene_index) + '_Button' button_row.append(button) clip_slot = scene.clip_slot(track_index) clip_slot.name = str(track_index) + '_Clip_Slot_' + str(scene_index) clip_slot.set_triggered_to_play_value(2) clip_slot.set_triggered_to_record_value(4) clip_slot.set_stopped_value(5) clip_slot.set_started_value(1) clip_slot.set_recording_value(3) clip_slot.set_launch_button(button) self._matrix.add_row(tuple(button_row)) self._button_rows.append(button_row) self._session.set_slot_launch_button(ButtonElement(is_momentary, MIDI_CC_TYPE, 0, 67)) self._session.selected_scene().name = 'Selected_Scene' self._session.selected_scene().set_launch_button(ButtonElement(is_momentary, MIDI_CC_TYPE, 0, 64)) self._session_zoom = ShiftableZoomingComponent(self._session, tuple(self._track_stop_buttons)) self._session_zoom.name = 'Session_Overview' self._session_zoom.set_button_matrix(self._matrix) self._session_zoom.set_zoom_button(self._shift_button) self._session_zoom.set_nav_buttons(self._up_button, self._down_button, self._left_button, self._right_button) self._session_zoom.set_scene_bank_buttons(tuple(self._scene_launch_buttons)) self._session_zoom.set_stopped_value(3) self._session_zoom.set_selected_value(5) def _setup_mixer_control(self): is_momentary = True self._mixer = SpecialMixerComponent(self, 8) self._mixer.name = 'Mixer' self._mixer.master_strip().name = 'Master_Channel_Strip' master_select_button = ButtonElement(is_momentary, MIDI_NOTE_TYPE, 0, 80) master_select_button.name = 'Master_Select_Button' self._mixer.master_strip().set_select_button(master_select_button) self._mixer.selected_strip().name = 'Selected_Channel_Strip' select_buttons = [] arm_buttons = [] solo_buttons = [] mute_buttons = [] sliders = [] for track in range(8): strip = self._mixer.channel_strip(track) strip.name = 'Channel_Strip_' + str(track) solo_button = ButtonElement(is_momentary, MIDI_NOTE_TYPE, track, 49) solo_buttons.append(solo_button) mute_button = ButtonElement(is_momentary, MIDI_NOTE_TYPE, track, 50) mute_buttons.append(mute_button) solo_button.name = str(track) + '_Solo_Button' mute_button.name = str(track) + '_Mute_Button' strip.set_solo_button(solo_button) strip.set_mute_button(mute_button) strip.set_shift_button(self._shift_button) strip.set_invert_mute_feedback(True) select_buttons.append(ButtonElement(is_momentary, MIDI_NOTE_TYPE, track, 51)) select_buttons[-1].name = str(track) + '_Select_Button' arm_buttons.append(ButtonElement(is_momentary, MIDI_NOTE_TYPE, track, 48)) arm_buttons[-1].name = str(track) + '_Arm_Button' sliders.append(SliderElement(MIDI_CC_TYPE, track, 7)) sliders[-1].name = str(track) + '_Volume_Control' self._crossfader = SliderElement(MIDI_CC_TYPE, 0, 15) master_volume_control = SliderElement(MIDI_CC_TYPE, 0, 14) self._prehear_control = EncoderElement(MIDI_CC_TYPE, 0, 47, Live.MidiMap.MapMode.relative_two_compliment) self._crossfader.name = 'Crossfader' master_volume_control.name = 'Master_Volume_Control' self._prehear_control.name = 'Prehear_Volume_Control' self._mixer.set_shift_button(self._shift_button) self._mixer.set_crossfader_control(self._crossfader) self._mixer.set_prehear_volume_control(self._prehear_control) self._mixer.master_strip().set_volume_control(master_volume_control) self._slider_modes = SliderModesComponent(self._mixer, tuple(sliders)) self._slider_modes.name = 'Slider_Modes' self._matrix_modes = MatrixModesComponent(self._matrix, self._session, self._session_zoom, tuple(self._track_stop_buttons), self) self._matrix_modes.name = 'Matrix_Modes' self._sequencer = StepSequencerComponent(self, self._session, self._matrix, tuple(self._track_stop_buttons)) self._sequencer.set_bank_buttons(tuple(select_buttons)) self._sequencer.set_nav_buttons(self._up_button, self._down_button, self._left_button, self._right_button) self._sequencer.set_button_matrix(self._matrix) self._sequencer.set_follow_button(master_select_button) self._sequencer.set_velocity_buttons(tuple(arm_buttons)) self._sequencer.set_shift_button(self._shift_button) self._sequencer.set_lane_mute_buttons(tuple(self._scene_launch_buttons)) self._sequencer.set_loop_start_buttons(tuple(mute_buttons)) self._sequencer.set_loop_length_buttons(tuple(solo_buttons)) self._shift_modes = ShiftableSelectorComponent(self, tuple(select_buttons), master_select_button, tuple(self._track_stop_buttons), self._stop_all_button, tuple(mute_buttons), tuple(solo_buttons), tuple(arm_buttons), tuple(self._scene_launch_buttons), self._matrix, self._session, self._session_zoom, self._mixer, self._slider_modes, self._matrix_modes, self._sequencer) self._shift_modes.name = 'Shift_Modes' self._shift_modes.set_mode_toggle(self._shift_button) def _setup_custom_components(self): self._setup_device_and_transport_control() self._setup_global_control() def _setup_device_and_transport_control(self): is_momentary = True device_bank_buttons = [] device_param_controls = [] bank_button_labels = ('Clip_Track_Button', 'Device_On_Off_Button', 'Previous_Device_Button', 'Next_Device_Button', 'Detail_View_Button', 'Rec_Quantization_Button', 'Midi_Overdub_Button', 'Metronome_Button') for index in range(8): device_bank_buttons.append(ButtonElement(is_momentary, MIDI_NOTE_TYPE, 0, 58 + index)) device_bank_buttons[-1].name = bank_button_labels[index] ring_mode_button = ButtonElement(not is_momentary, MIDI_CC_TYPE, 0, 24 + index) ringed_encoder = RingedEncoderElement(MIDI_CC_TYPE, 0, 16 + index, Live.MidiMap.MapMode.absolute) ringed_encoder.set_ring_mode_button(ring_mode_button) ringed_encoder.set_feedback_delay(-1) ringed_encoder.name = 'Device_Control_' + str(index) ring_mode_button.name = ringed_encoder.name + '_Ring_Mode_Button' device_param_controls.append(ringed_encoder) self._device = ShiftableDeviceComponent() self._device.name = 'Device_Component' self._device.set_bank_buttons(tuple(device_bank_buttons)) self._device.set_shift_button(self._shift_button) self._device.set_parameter_controls(tuple(device_param_controls)) self._device.set_on_off_button(device_bank_buttons[1]) self.set_device_component(self._device) detail_view_toggler = DetailViewCntrlComponent() detail_view_toggler.name = 'Detail_View_Control' detail_view_toggler.set_shift_button(self._shift_button) detail_view_toggler.set_device_clip_toggle_button(device_bank_buttons[0]) detail_view_toggler.set_detail_toggle_button(device_bank_buttons[4]) detail_view_toggler.set_device_nav_buttons(device_bank_buttons[2], device_bank_buttons[3]) transport = ShiftableTransportComponent() transport.name = 'Transport' play_button = ButtonElement(is_momentary, MIDI_NOTE_TYPE, 0, 91) stop_button = ButtonElement(is_momentary, MIDI_NOTE_TYPE, 0, 92) record_button = ButtonElement(is_momentary, MIDI_NOTE_TYPE, 0, 93) nudge_up_button = ButtonElement(is_momentary, MIDI_NOTE_TYPE, 0, 100) nudge_down_button = ButtonElement(is_momentary, MIDI_NOTE_TYPE, 0, 101) tap_tempo_button = ButtonElement(is_momentary, MIDI_NOTE_TYPE, 0, 99) play_button.name = 'Play_Button' stop_button.name = 'Stop_Button' record_button.name = 'Record_Button' nudge_up_button.name = 'Nudge_Up_button' nudge_down_button.name = 'Nudge_Down_button' tap_tempo_button.name = 'Tap_Tempo_Button' transport.set_shift_button(self._shift_button) transport.set_play_button(play_button) transport.set_stop_button(stop_button) transport.set_record_button(record_button) transport.set_nudge_buttons(nudge_up_button, nudge_down_button) transport.set_undo_button(nudge_down_button) transport.set_redo_button(nudge_up_button) transport.set_tap_tempo_button(tap_tempo_button) self._device.set_lock_button(tap_tempo_button) transport.set_quant_toggle_button(device_bank_buttons[5]) transport.set_overdub_button(device_bank_buttons[6]) transport.set_metronome_button(device_bank_buttons[7]) transport.set_tempo_encoder(self._prehear_control) bank_button_translator = ShiftTranslatorComponent() bank_button_translator.set_controls_to_translate(tuple(device_bank_buttons)) bank_button_translator.set_shift_button(self._shift_button) def _setup_global_control(self): is_momentary = True self._global_bank_buttons = [] self._global_param_controls = [] for index in range(8): ring_button = ButtonElement(not is_momentary, MIDI_CC_TYPE, 0, 56 + index) ringed_encoder = RingedEncoderElement(MIDI_CC_TYPE, 0, 48 + index, Live.MidiMap.MapMode.absolute) ringed_encoder.name = 'Track_Control_' + str(index) ringed_encoder.set_feedback_delay(-1) ring_button.name = ringed_encoder.name + '_Ring_Mode_Button' ringed_encoder.set_ring_mode_button(ring_button) self._global_param_controls.append(ringed_encoder) self._global_bank_buttons = [] global_bank_labels = ('Pan_Button', 'Send_A_Button', 'Send_B_Button', 'Send_C_Button') for index in range(4): self._global_bank_buttons.append(ConfigurableButtonElement(is_momentary, MIDI_NOTE_TYPE, 0, 87 + index)) self._global_bank_buttons[-1].name = global_bank_labels[index] self._encoder_modes = EncModeSelectorComponent(self._mixer) self._encoder_modes.name = 'Track_Control_Modes' self._encoder_modes.set_controls(tuple(self._global_param_controls)) self._encoder_device_modes = EncoderDeviceComponent(self._mixer, self._device, self) self._encoder_device_modes.name = 'Alt_Device_Control_Modes' self._encoder_eq_modes = EncoderEQComponent(self._mixer, self) self._encoder_eq_modes.name = 'EQ_Control_Modes' global_translation_selector = ChannelTranslationSelector() global_translation_selector.name = 'Global_Translations' global_translation_selector.set_controls_to_translate(tuple(self._global_param_controls)) global_translation_selector.set_mode_buttons(tuple(self._global_bank_buttons)) encoder_user_modes = EncoderUserModesComponent(self, self._encoder_modes, tuple(self._global_param_controls), tuple(self._global_bank_buttons), self._mixer, self._device, self._encoder_device_modes, self._encoder_eq_modes) encoder_user_modes.name = 'Encoder_User_Modes' self._encoder_shift_modes = ShiftableEncoderSelectorComponent(self, tuple(self._global_bank_buttons), encoder_user_modes, self._encoder_modes, self._encoder_eq_modes, self._encoder_device_modes) self._encoder_shift_modes.name = 'Encoder_Shift_Modes' self._encoder_shift_modes.set_mode_toggle(self._shift_button) def _on_selected_track_changed(self): ControlSurface._on_selected_track_changed(self) track = self.song().view.selected_track device_to_select = track.view.selected_device if device_to_select == None and len(track.devices) > 0: device_to_select = track.devices[0] if device_to_select != None: self.song().view.select_device(device_to_select) self._device_component.set_device(device_to_select) return None def _on_track_offset_changed(self): self._matrix_modes._on_track_offset_changed() def _product_model_id_byte(self): return 115
def _setup_mixer_control(self): is_momentary = True self._mixer = SpecialMixerComponent(self, 8) self._mixer.name = 'Mixer' self._mixer.master_strip().name = 'Master_Channel_Strip' master_select_button = ButtonElement(is_momentary, MIDI_NOTE_TYPE, 0, 80) master_select_button.name = 'Master_Select_Button' self._mixer.master_strip().set_select_button(master_select_button) self._mixer.selected_strip().name = 'Selected_Channel_Strip' select_buttons = [] arm_buttons = [] solo_buttons = [] mute_buttons = [] sliders = [] for track in range(8): strip = self._mixer.channel_strip(track) strip.name = 'Channel_Strip_' + str(track) solo_button = ButtonElement(is_momentary, MIDI_NOTE_TYPE, track, 49) solo_buttons.append(solo_button) mute_button = ButtonElement(is_momentary, MIDI_NOTE_TYPE, track, 50) mute_buttons.append(mute_button) solo_button.name = str(track) + '_Solo_Button' mute_button.name = str(track) + '_Mute_Button' strip.set_solo_button(solo_button) strip.set_mute_button(mute_button) strip.set_shift_button(self._shift_button) strip.set_invert_mute_feedback(True) select_buttons.append(ButtonElement(is_momentary, MIDI_NOTE_TYPE, track, 51)) select_buttons[-1].name = str(track) + '_Select_Button' arm_buttons.append(ButtonElement(is_momentary, MIDI_NOTE_TYPE, track, 48)) arm_buttons[-1].name = str(track) + '_Arm_Button' sliders.append(SliderElement(MIDI_CC_TYPE, track, 7)) sliders[-1].name = str(track) + '_Volume_Control' self._crossfader = SliderElement(MIDI_CC_TYPE, 0, 15) master_volume_control = SliderElement(MIDI_CC_TYPE, 0, 14) self._prehear_control = EncoderElement(MIDI_CC_TYPE, 0, 47, Live.MidiMap.MapMode.relative_two_compliment) self._crossfader.name = 'Crossfader' master_volume_control.name = 'Master_Volume_Control' self._prehear_control.name = 'Prehear_Volume_Control' self._mixer.set_shift_button(self._shift_button) self._mixer.set_crossfader_control(self._crossfader) self._mixer.set_prehear_volume_control(self._prehear_control) self._mixer.master_strip().set_volume_control(master_volume_control) self._slider_modes = SliderModesComponent(self._mixer, tuple(sliders)) self._slider_modes.name = 'Slider_Modes' self._matrix_modes = MatrixModesComponent(self._matrix, self._session, self._session_zoom, tuple(self._track_stop_buttons), self) self._matrix_modes.name = 'Matrix_Modes' self._sequencer = StepSequencerComponent(self, self._session, self._matrix, tuple(self._track_stop_buttons)) self._sequencer.set_bank_buttons(tuple(select_buttons)) self._sequencer.set_nav_buttons(self._up_button, self._down_button, self._left_button, self._right_button) self._sequencer.set_button_matrix(self._matrix) self._sequencer.set_follow_button(master_select_button) self._sequencer.set_velocity_buttons(tuple(arm_buttons)) self._sequencer.set_shift_button(self._shift_button) self._sequencer.set_lane_mute_buttons(tuple(self._scene_launch_buttons)) self._sequencer.set_loop_start_buttons(tuple(mute_buttons)) self._sequencer.set_loop_length_buttons(tuple(solo_buttons)) self._shift_modes = ShiftableSelectorComponent(self, tuple(select_buttons), master_select_button, tuple(self._track_stop_buttons), self._stop_all_button, tuple(mute_buttons), tuple(solo_buttons), tuple(arm_buttons), tuple(self._scene_launch_buttons), self._matrix, self._session, self._session_zoom, self._mixer, self._slider_modes, self._matrix_modes, self._sequencer) self._shift_modes.name = 'Shift_Modes' self._shift_modes.set_mode_toggle(self._shift_button)
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): """ 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()
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 _setup_mixer_control(self): is_momentary = True self._mixer = SpecialMixerComponent(self, 8) self._mixer.name = 'Mixer' self._mixer.master_strip().name = 'Master_Channel_Strip' master_select_button = ButtonElement(is_momentary, MIDI_NOTE_TYPE, 0, 80) master_select_button.name = 'Master_Select_Button' self._mixer.master_strip().set_select_button(master_select_button) self._mixer.selected_strip().name = 'Selected_Channel_Strip' select_buttons = [] arm_buttons = [] solo_buttons = [] mute_buttons = [] sliders = [] for track in range(8): strip = self._mixer.channel_strip(track) strip.name = 'Channel_Strip_' + str(track) solo_button = ButtonElement(is_momentary, MIDI_NOTE_TYPE, track, 49) solo_buttons.append(solo_button) mute_button = ButtonElement(is_momentary, MIDI_NOTE_TYPE, track, 50) mute_buttons.append(mute_button) solo_button.name = str(track) + '_Solo_Button' mute_button.name = str(track) + '_Mute_Button' strip.set_solo_button(solo_button) strip.set_mute_button(mute_button) strip.set_shift_button(self._shift_button) strip.set_invert_mute_feedback(True) select_buttons.append( ButtonElement(is_momentary, MIDI_NOTE_TYPE, track, 51)) select_buttons[-1].name = str(track) + '_Select_Button' arm_buttons.append( ButtonElement(is_momentary, MIDI_NOTE_TYPE, track, 48)) arm_buttons[-1].name = str(track) + '_Arm_Button' sliders.append(SliderElement(MIDI_CC_TYPE, track, 7)) sliders[-1].name = str(track) + '_Volume_Control' self._crossfader = SliderElement(MIDI_CC_TYPE, 0, 15) master_volume_control = SliderElement(MIDI_CC_TYPE, 0, 14) self._prehear_control = EncoderElement( MIDI_CC_TYPE, 0, 47, Live.MidiMap.MapMode.relative_two_compliment) self._crossfader.name = 'Crossfader' master_volume_control.name = 'Master_Volume_Control' self._prehear_control.name = 'Prehear_Volume_Control' self._mixer.set_shift_button(self._shift_button) self._mixer.set_crossfader_control(self._crossfader) self._mixer.set_prehear_volume_control(self._prehear_control) self._mixer.master_strip().set_volume_control(master_volume_control) self._slider_modes = SliderModesComponent(self._mixer, tuple(sliders)) self._slider_modes.name = 'Slider_Modes' matrix_modes = MatrixModesComponent(self._matrix, self._session, self._session_zoom, tuple(self._track_stop_buttons), self) matrix_modes.name = 'Matrix_Modes' self._sequencer = StepSequencerComponent( self, self._session, self._matrix, tuple(self._track_stop_buttons)) self._sequencer.set_bank_buttons(tuple(select_buttons)) self._sequencer.set_nav_buttons(self._up_button, self._down_button, self._left_button, self._right_button) self._sequencer.set_button_matrix(self._matrix) self._sequencer.set_follow_button(master_select_button) self._sequencer.set_velocity_buttons(tuple(arm_buttons)) self._sequencer.set_shift_button(self._shift_button) self._sequencer.set_lane_mute_buttons(tuple( self._scene_launch_buttons)) self._sequencer.set_loop_start_buttons(tuple(mute_buttons)) self._sequencer.set_loop_length_buttons(tuple(solo_buttons)) self._shift_modes = ShiftableSelectorComponent( self, tuple(select_buttons), master_select_button, tuple(self._track_stop_buttons), self._stop_all_button, tuple(mute_buttons), tuple(solo_buttons), tuple(arm_buttons), tuple(self._scene_launch_buttons), self._matrix, self._session, self._session_zoom, self._mixer, self._slider_modes, matrix_modes, self._sequencer) self._shift_modes.name = 'Shift_Modes' self._shift_modes.set_mode_toggle(self._shift_button)