def update(self):
if not self._ignore_buttons:
SessionZoomingComponent.update(self)
elif self.is_enabled():
if self._scene_bank_buttons != None:
for button in self._scene_bank_buttons:
button.turn_off()
def __init__(self, matrix, top_buttons, side_buttons, config_button):
raise isinstance(matrix, ButtonMatrixElement) or AssertionError
raise matrix.width() == 8 and matrix.height() == 8 or AssertionError
raise isinstance(top_buttons, tuple) or AssertionError
raise len(top_buttons) == 8 or AssertionError
raise isinstance(side_buttons, tuple) or AssertionError
raise len(side_buttons) == 8 or AssertionError
raise isinstance(config_button, ButtonElement) or AssertionError
ModeSelectorComponent.__init__(self)
self._session = SpecialSessionComponent(matrix.width(),
matrix.height())
self._zooming = 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._init_session()
self._all_buttons = tuple(self._all_buttons)
self.set_modes_buttons(top_buttons[4:])
def __init__(self, session, stop_buttons):
SessionZoomingComponent.__init__(self, session)
self._stop_buttons = stop_buttons
self._ignore_buttons = False
for button in self._stop_buttons:
assert isinstance(button, ButtonElement)
button.add_value_listener(self._stop_value, identify_sender=True)
def update(self):
if (not self._ignore_buttons):
SessionZoomingComponent.update(self)
elif self.is_enabled():
if (self._scene_bank_buttons != None):
for button in self._scene_bank_buttons:
button.turn_off()
def __init__(self, session, stop_buttons):
SessionZoomingComponent.__init__(self, session)
self._stop_buttons = stop_buttons
self._ignore_buttons = False
for button in self._stop_buttons:
raise isinstance(button, ButtonElement) or AssertionError
button.add_value_listener(self._stop_value, identify_sender=True)
def _setup_session_control(self): is_momentary = True self._shift_button = AumPCMonoButtonElement(is_momentary, MIDI_NOTE_TYPE, 0, 98, 'Shift_Button', self) right_button = AumPCMonoButtonElement(is_momentary, MIDI_NOTE_TYPE, 0, 96, 'Right_Button', self) self._right_button = right_button left_button = AumPCMonoButtonElement(is_momentary, MIDI_NOTE_TYPE, 0, 97, 'Left_Button', self) self._left_button = left_button up_button = AumPCMonoButtonElement(is_momentary, MIDI_NOTE_TYPE, 0, 94, 'Up_Button', self) self._up_button = up_button down_button = AumPCMonoButtonElement(is_momentary, MIDI_NOTE_TYPE, 0, 95, 'Down_Button', self) self._down_button = down_button self._session = PedaledSessionComponent(8, 5) self._session.name = 'Session_Control' self._session.set_track_bank_buttons(right_button, left_button) self._session.set_scene_bank_buttons(down_button, up_button) matrix = ButtonMatrixElement() self._matrix = matrix # added a matrix.name = 'Button_Matrix' scene_launch_buttons = [ ButtonElement(is_momentary, MIDI_NOTE_TYPE, 0, (index + 82)) for index in range(5) ] track_stop_buttons = [ AumPCMonoButtonElement(is_momentary, MIDI_NOTE_TYPE, index, 52, 'Track_' + str(index) + '_Stop_Button', self) for index in range(8) ] self._track_stop_buttons = track_stop_buttons # added a for index in range(len(scene_launch_buttons)): scene_launch_buttons[index].name = 'Scene_'+ str(index) + '_Launch_Button' stop_all_button = ButtonElement(is_momentary, MIDI_NOTE_TYPE, 0, 81) stop_all_button.name = 'Stop_All_Clips_Button' self._session.set_stop_all_clips_button(stop_all_button) self._session.set_stop_track_clip_buttons(tuple(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(scene_launch_buttons[scene_index]) scene.set_triggered_value(2) for track_index in range(8): button = AumPCMonoButtonElement(is_momentary, MIDI_NOTE_TYPE, track_index, (scene_index + 53), str(track_index) + '_Clip_' + str(scene_index) + '_Button', self) #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) matrix.add_row(tuple(button_row)) self._session.set_slot_launch_button(ButtonElement(is_momentary, MIDI_CC_TYPE, 0, 67)) self._session.selected_scene().name = 'Selected_Scene' self._session.selected_scene().set_launch_button(ButtonElement(is_momentary, MIDI_CC_TYPE, 0, 64)) self._session_zoom = SessionZoomingComponent(self._session) self._session_zoom.name = 'Session_Overview' self._session_zoom.set_button_matrix(matrix) self._session_zoom.set_zoom_button(self._shift_button) self._session_zoom.set_nav_buttons(up_button, down_button, left_button, right_button) self._session_zoom.set_scene_bank_buttons(tuple(scene_launch_buttons)) self._session_zoom.set_stopped_value(3) self._session_zoom.set_selected_value(5)
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 _setup_session_control(self):
"""SESSION ViEW"""
global session
session = SessionComponent(GRIDSIZE[0], GRIDSIZE[1])
session.name = 'Session_Control'
matrix = ButtonMatrixElement()
matrix.name = 'Button_Matrix'
up_button = ButtonElement(True, MIDI_CC_TYPE, CHANNEL, UP_BUTTON)
down_button = ButtonElement(True, MIDI_CC_TYPE, CHANNEL, DOWN_BUTTON)
left_button = ButtonElement(True, MIDI_CC_TYPE, CHANNEL, LEFT_BUTTON)
right_button = ButtonElement(True, MIDI_CC_TYPE, CHANNEL, RIGHT_BUTTON)
session_zoom = SessionZoomingComponent(session)
session_zoom.set_nav_buttons(up_button, down_button, left_button,
right_button)
session_stop_buttons = []
self.log("SETTING UP GRID")
for row in xrange(GRIDSIZE[1]):
button_row = []
self.log("CZ ROW")
self.log(str(row))
scene = session.scene(row)
scene.name = 'Scene_' + str(row)
scene.set_launch_button(
ButtonElement(True, MIDI_NOTE_TYPE, CHANNEL,
SCENE_BUTTONS[row]))
scene.set_triggered_value(2)
for column in xrange(GRIDSIZE[0]):
self.log("CZ COLUMN")
self.log(str(column))
button = ConfigurableButtonElement(True, MIDI_NOTE_TYPE,
CHANNEL,
LAUNCH_BUTTONS[row][column])
button.name = str(column) + '_Clip_' + str(row) + '_Button'
button_row.append(button)
clip_slot = scene.clip_slot(column)
clip_slot.name = str(column) + '_Clip_Slot_' + str(row)
clip_slot.set_launch_button(button)
matrix.add_row(tuple(button_row))
for column in xrange(GRIDSIZE[0]):
session_stop_buttons.append(
(ButtonElement(True, MIDI_NOTE_TYPE, CHANNEL,
TRACK_STOPS[column])))
self._suppress_session_highlight = False
self._suppress_send_midi = False
self.set_highlighting_session_component(session)
session.set_stop_track_clip_buttons(tuple(session_stop_buttons))
session.set_mixer(mixer)
def _setup_session(self):
self._left_session = CrateSessionComponent(
script=self,
name='Session_Component_A',
num_tracks=1,
num_scenes=20,
autonaming=True,
is_enabled=False,
layer=Layer(priority=1,
clip_launch_buttons=self._matrix,
track_nav_buttons=self._track_select_matrix))
self._left_session.set_group_track('DECK A')
self._left_session_zooming = SessionZoomingComponent(
session=self._left_session)
self._right_session = CrateSessionComponent(
script=self,
name='Session_Component_B',
num_tracks=1,
num_scenes=20,
autonaming=True,
is_enabled=False,
layer=Layer(priority=1,
clip_launch_buttons=self._matrix,
track_nav_buttons=self._track_select_matrix))
self._right_session.set_group_track('DECK B')
self._right_session_zooming = SessionZoomingComponent(
session=self._right_session)
self._left_set_session = CrateSetSessionComponent(
script=self,
name='Session_Component_SETA',
num_tracks=1,
num_scenes=10,
autonaming=True,
is_enabled=False,
layer=Layer(priority=1, clip_launch_buttons=self._left_matrix))
self._left_set_session.set_group_track('SET A')
self._left_set_session_zooming = SessionZoomingComponent(
session=self._left_set_session)
self._right_set_session = CrateSetSessionComponent(
script=self,
name='Session_Component_SETB',
num_tracks=1,
num_scenes=10,
autonaming=True,
is_enabled=False,
layer=Layer(priority=1, clip_launch_buttons=self._right_matrix))
self._right_set_session.set_group_track('SET B')
self._right_set_session_zooming = SessionZoomingComponent(
session=self._right_set_session)
def _setup_session_control(self): is_momentary = True num_tracks = NUM_TRACKS num_scenes = NUM_SCENES self._session = SessionComponent(num_tracks, num_scenes) self._session.name = "Session" self._session.set_offsets(0, 0) self._session.set_stop_track_clip_value(STOP_CLIP) self._scene = [None for index in range(3)] for row in range(num_scenes): self._scene[row] = self._session.scene(row) self._scene[row].name = 'Scene_' + str(row) for column in range(num_tracks): clip_slot = self._scene[row].clip_slot(column) clip_slot.name = str(column) + '_Clip_Slot_' + str(row) clip_slot.set_triggered_to_play_value(CLIP_TRG_PLAY) clip_slot.set_triggered_to_record_value(CLIP_TRG_REC) clip_slot.set_stopped_value(CLIP_STOP) clip_slot.set_started_value(CLIP_STARTED) clip_slot.set_recording_value(CLIP_RECORDING) self._session._stop_track_value = self._session_stop_track_value(self._session) self._session._on_fired_slot_index_changed = self._session_on_fired_slot_index_changed(self._session) self._session._change_offsets = self._session_change_offsets(self._session) self._session.update = self._session_update(self._session) #self._session.add_offset_listener(self._update_navigation_view) self._session.set_mixer(self._mixer) self.set_highlighting_session_component(self._session) self._session_zoom = SessionZoomingComponent(self._session) self._session_zoom.name = 'Session_Overview' self._session_zoom.set_stopped_value(ZOOM_STOPPED) self._session_zoom.set_playing_value(ZOOM_PLAYING) self._session_zoom.set_selected_value(ZOOM_SELECTED)
def _setup_session_control(self): is_momentary = True num_tracks = 8 #we are working with a 4x4 grid, num_scenes = 4 #so the height and width are both set to 4 self._session = SessionComponent(num_tracks, num_scenes) #we create our SessionComponent with the variables we set above it self._session.name = "Session" #we name it so we can access it in m4l self._session.set_offsets(0, 0) #we set the initial offset to the far left, top of the session grid self._session._track_banking_increment = 4 self._session.set_stop_clip_value(STOP_CLIP[self._rgb]) #we assign the colors that will be displayed when the stop_clip button is pressed. This value comes from CNTRLR_Map.py, which is imported in the header of our script self._scene = [None for index in range(4)] #we create an array to hold the Scene subcomponents so that we can get to them if we need them. for row in range(num_scenes): #now we'll fill the array with different objects that were created when we called the SessionComponent() module self._scene[row] = self._session.scene(row) #each session row is a SceneComponent self._scene[row].name = 'Scene_' + str(row) #name it so we can access it in m4l for column in range(num_tracks): #now we'll create holders and names for the contents of each scene clip_slot = self._scene[row].clip_slot(column) #we use our assignment of the scene above to gain access to the individual clipslots. Here, we are just assigning 'clip_slot' each time as a local variable so we can manipulated it's properties clip_slot.name = str(column) + '_Clip_Slot' + str(row) #name it so that we can acces it in m4l clip_slot.set_triggered_to_play_value(CLIP_TRG_PLAY[self._rgb]) #set its triggered to play color clip_slot.set_triggered_to_record_value(CLIP_TRG_REC[self._rgb])#set its triggered to record color clip_slot.set_stopped_value(CLIP_STOP[self._rgb]) #set its stop color clip_slot.set_started_value(CLIP_STARTED[self._rgb]) #set its started color clip_slot.set_recording_value(CLIP_RECORDING[self._rgb]) #set its recording value self._session.set_mixer(self._mixer) #now we link the MixerComponent we created in _setup_mixer_control() to our session component so that they will follow each other when either is navigated self.set_highlighting_session_component(self._session) self._session_zoom = SessionZoomingComponent(self._session) #this creates the ZoomingComponent that allows navigation when the shift button is pressed self._session_zoom.name = 'Session_Overview' #name it so we can access it in m4l self._session_zoom.set_stopped_value(ZOOM_STOPPED[self._rgb]) #set the zooms stopped color self._session_zoom.set_playing_value(ZOOM_PLAYING[self._rgb]) #set the zooms playing color self._session_zoom.set_selected_value(ZOOM_SELECTED[self._rgb]) #set the zooms selected color self._session_zoom.set_button_matrix(self._matrix) #assign the ButtonMatrixElement that we created in _setup_controls() to the zooming component so that we can control it self._session_zoom.set_zoom_button(self._button[31]) #assign a shift button so that we can switch states between the SessionComponent and the SessionZoomingComponent
def _setup_session_control(self): is_momentary = True num_tracks = COLS num_scenes = ROWS global session session = SessionComponent(num_tracks, num_scenes) session.name = "Session" session.set_offsets(0, 0) self._session = session self._session.set_stop_track_clip_value(0) self._scene = [None for index in range(ROWS)] for row in range(num_scenes): self._scene[row] = session.scene(row) self._scene[row].name = 'Scene_' + str(row) for column in range(num_tracks): clip_slot = self._scene[row].clip_slot(column) clip_slot.name = str(column) + '_Clip_Slot_' + str(row) clip_slot.set_triggered_to_play_value(64) clip_slot.set_triggered_to_record_value(64) clip_slot.set_stopped_value(0) clip_slot.set_started_value(64) clip_slot.set_recording_value(64) #clip_slot.set_launch_button(self._grid[column][row]) #comment out if you don't want clip launch session.set_mixer(mixer) self._session_zoom = SessionZoomingComponent(session) self._session_zoom.name = 'Session_Overview' self._session_zoom.set_stopped_value(0) self._session_zoom.set_playing_value(64) self._session_zoom.set_selected_value(64) if STANDALONE is True: self.set_highlighting_session_component(self._session) self._session.set_track_bank_buttons(self._grid[5][3], self._grid[4][3]) #comment out when using with Griid self._session.set_scene_bank_buttons(self._grid[7][3], self._grid[6][3]) # comment out when using with Griid
def _setup_session_control(self): is_momentary = True num_tracks = COLS num_scenes = ROWS global session session = SessionComponent(num_tracks, num_scenes) session.name = "Session" session.set_offsets(0, 0) self._session = session self._session.set_stop_clip_value(0) self._scene = [None for index in range(ROWS)] for row in range(num_scenes): self._scene[row] = session.scene(row) self._scene[row].name = 'Scene_' + str(row) for column in range(num_tracks): clip_slot = self._scene[row].clip_slot(column) clip_slot.name = str(column) + '_Clip_Slot_' + str(row) clip_slot.set_triggered_to_play_value(64) clip_slot.set_triggered_to_record_value(64) clip_slot.set_stopped_value(0) clip_slot.set_started_value(64) clip_slot.set_recording_value(64) #clip_slot.set_launch_button(self._grid[column][row]) #comment out if you don't want clip launch session.set_mixer(mixer) self._session_zoom = SessionZoomingComponent(session) self._session_zoom.name = 'Session_Overview' self._session_zoom.set_stopped_value(0) self._session_zoom.set_playing_value(64) self._session_zoom.set_selected_value(64) if STANDALONE is True: self.set_highlighting_session_component(self._session) self._session.set_track_bank_buttons(self._grid[5][3], self._grid[4][3]) #comment out when using with Griid self._session.set_scene_bank_buttons(self._grid[7][3], self._grid[6][3]) # comment out when using with Griid
def _create_alt_session(self):
self._alt_session = SelectingSessionComponent(
self,
SESSION_WIDTH,
SESSION_HEIGHT,
auto_name=True,
enable_skinning=True,
is_enabled=False,
layer=Layer(
priority=2,
track_bank_left_button=self._left_button,
track_bank_right_button=self._right_button,
scene_bank_up_button=self._up_button,
scene_bank_down_button=self._down_button,
stop_all_clips_button=self._stop_all_button,
stop_track_clip_buttons=self._track_stop_buttons,
scene_launch_buttons=self._scene_launch_buttons,
clip_launch_buttons=self._session_matrix,
slot_launch_button=self._selected_slot_launch_button,
))
self._alt_session.name = 'Alt_Session_Control'
self._alt_session_zoom = SessionZoomingComponent(
self._alt_session,
name='Alt_Session_Overview',
enable_skinning=True,
is_enabled=False,
layer=Layer(priority=2,
button_matrix=self._shifted_matrix,
nav_up_button=self._with_shift(self._up_button),
nav_down_button=self._with_shift(self._down_button),
nav_left_button=self._with_shift(self._left_button),
nav_right_button=self._with_shift(self._right_button),
scene_bank_buttons=self._shifted_scene_buttons))
self._alt_session.link_with_track_offset(0)
def _create_session(self):
self._session = SessionComponent(
SESSION_WIDTH,
SESSION_HEIGHT,
auto_name=True,
enable_skinning=True,
is_enabled=False,
layer=Layer(track_bank_left_button=self._left_button,
track_bank_right_button=self._right_button,
scene_bank_up_button=self._up_button,
scene_bank_down_button=self._down_button,
stop_all_clips_button=self._stop_all_button,
stop_track_clip_buttons=self._track_stop_buttons,
scene_launch_buttons=self._scene_launch_buttons,
clip_launch_buttons=self._session_matrix,
slot_launch_button=self._selected_slot_launch_button,
selected_scene_launch_button=self.
_selected_scene_launch_button))
self._session_zoom = SessionZoomingComponent(
self._session,
name=u'Session_Overview',
enable_skinning=True,
is_enabled=False,
layer=Layer(button_matrix=self._shifted_matrix,
nav_up_button=self._with_shift(self._up_button),
nav_down_button=self._with_shift(self._down_button),
nav_left_button=self._with_shift(self._left_button),
nav_right_button=self._with_shift(self._right_button),
scene_bank_buttons=self._shifted_scene_buttons))
def __init__(self, matrix, top_buttons, side_buttons, config_button):
raise isinstance(matrix, ButtonMatrixElement) or AssertionError
raise matrix.width() == 8 and matrix.height() == 8 or AssertionError
raise isinstance(top_buttons, tuple) or AssertionError
raise len(top_buttons) == 8 or AssertionError
raise isinstance(side_buttons, tuple) or AssertionError
raise len(side_buttons) == 8 or AssertionError
raise isinstance(config_button, ButtonElement) or AssertionError
ModeSelectorComponent.__init__(self)
self._session = SpecialSessionComponent(matrix.width(), matrix.height())
self._zooming = 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._init_session()
self._all_buttons = tuple(self._all_buttons)
self.set_modes_buttons(top_buttons[4:])
def __init__(self, matrix, top_buttons, side_buttons, config_button, knobs,
sliders, script):
assert isinstance(matrix, ButtonMatrixElement)
assert ((matrix.width() == 8) and (matrix.height() == 8))
assert isinstance(top_buttons, tuple)
assert (len(top_buttons) == 8)
assert isinstance(side_buttons, tuple)
assert (len(side_buttons) == 8)
assert isinstance(config_button, ButtonElement)
ModeSelectorComponent.__init__(self)
self._script = script
self._session = SpecialSessionComponent(matrix.width(),
matrix.height())
for scene in self._session._scenes:
for slot in scene._clip_slots:
slot._triggered_to_play_value = 4
slot._triggered_to_record_value = 3
slot._started_value = 2
slot._recording_value = 1
slot._stopped_value = 127
self._zooming = SessionZoomingComponent(self._session)
self._zooming._stopped_value = 127
self._zooming._playing_value = 2
self._zooming._selected_value = 1
self._matrix = matrix
self._knobs = knobs
self._sliders = sliders
self._side_buttons = side_buttons
self._nav_buttons = top_buttons[:4]
self._config_button = config_button
self._shift_button = top_buttons[5]
self._zooming.set_empty_value(LED_OFF)
self._all_buttons = []
for button in (self._side_buttons + self._nav_buttons):
self._all_buttons.append(button)
self._shift_pressed = 0
self._shift_pressed_timer = 0
self._last_normal_mode = 0
self._shift_button = None
self.set_shift_button(top_buttons[6])
self._sub_modes = SubSelectorComponent(matrix, side_buttons,
self._session)
self._sub_modes.set_update_callback(self._update_control_channels)
self._init_session()
self._all_buttons = tuple(self._all_buttons)
self.set_modes_buttons(top_buttons[4:6])
def _create_zooming(self):
""" Lazily evaluated the first time session mode is selected """
return SessionZoomingComponent(
session=self._session_mode.component,
name='Session_Overview',
enable_skinning=True,
is_enabled=False,
layer=Layer(button_matrix=self._create_shifted_matrix()))
def _setup_session_control(self): is_momentary = True self._shift_button = AumPCMonoButtonElement(is_momentary, MIDI_NOTE_TYPE, 0, 98, 'Shift_Button', self) right_button = AumPCMonoButtonElement(is_momentary, MIDI_NOTE_TYPE, 0, 96, 'Right_Button', self) self._right_button = right_button left_button = AumPCMonoButtonElement(is_momentary, MIDI_NOTE_TYPE, 0, 97, 'Left_Button', self) self._left_button = left_button up_button = AumPCMonoButtonElement(is_momentary, MIDI_NOTE_TYPE, 0, 94, 'Up_Button', self) self._up_button = up_button down_button = AumPCMonoButtonElement(is_momentary, MIDI_NOTE_TYPE, 0, 95, 'Down_Button', self) self._down_button = down_button self._session = PedaledSessionComponent(8, 5) self._session.name = 'Session_Control' self._session.set_track_bank_buttons(right_button, left_button) self._session.set_scene_bank_buttons(down_button, up_button) matrix = ButtonMatrixElement() self._matrix = matrix # added a matrix.name = 'Button_Matrix' scene_launch_buttons = [ ButtonElement(is_momentary, MIDI_NOTE_TYPE, 0, (index + 82)) for index in range(5) ] track_stop_buttons = [ AumPCMonoButtonElement(is_momentary, MIDI_NOTE_TYPE, index, 52, 'Track_' + str(index) + '_Stop_Button', self) for index in range(8) ] self._track_stop_buttons = track_stop_buttons # added a for index in range(len(scene_launch_buttons)): scene_launch_buttons[index].name = 'Scene_'+ str(index) + '_Launch_Button' stop_all_button = ButtonElement(is_momentary, MIDI_NOTE_TYPE, 0, 81) stop_all_button.name = 'Stop_All_Clips_Button' self._session.set_stop_all_clips_button(stop_all_button) self._session.set_stop_track_clip_buttons(tuple(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(scene_launch_buttons[scene_index]) scene.set_triggered_value(2) for track_index in range(8): button = AumPCMonoButtonElement(is_momentary, MIDI_NOTE_TYPE, track_index, (scene_index + 53), str(track_index) + '_Clip_' + str(scene_index) + '_Button', self) #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) matrix.add_row(tuple(button_row)) self._session.set_slot_launch_button(ButtonElement(is_momentary, MIDI_CC_TYPE, 0, 67)) self._session.selected_scene().name = 'Selected_Scene' self._session.selected_scene().set_launch_button(ButtonElement(is_momentary, MIDI_CC_TYPE, 0, 64)) self._session_zoom = SessionZoomingComponent(self._session) self._session_zoom.name = 'Session_Overview' self._session_zoom.set_button_matrix(matrix) self._session_zoom.set_zoom_button(self._shift_button) self._session_zoom.set_nav_buttons(up_button, down_button, left_button, right_button) self._session_zoom.set_scene_bank_buttons(tuple(scene_launch_buttons)) self._session_zoom.set_stopped_value(3) self._session_zoom.set_selected_value(5)
def __init__(self, matrix, top_buttons, side_buttons, config_button,
script):
assert isinstance(matrix, ButtonMatrixElement)
assert matrix.width() == 8 and matrix.height() == 8
assert isinstance(top_buttons, tuple)
assert len(top_buttons) == 8
assert isinstance(side_buttons, tuple)
assert len(side_buttons) == 8
assert isinstance(config_button, ButtonElement)
ModeSelectorComponent.__init__(self)
self._script = script
self._session = SpecialSessionComponent(matrix.width(),
matrix.height())
"""for scene in self._session._scenes:
for slot in scene._clip_slots:
slot._triggered_to_play_value = 24
slot._triggered_to_record_value = 27
slot._started_value = 7
slot._recording_value = 9
slot._stopped_value = 8"""
self._zooming = SessionZoomingComponent(self._session)
self._session.name = 'Session_Control'
self._zooming.name = 'Session_Overview'
"""self._zooming._stopped_value = 9
self._zooming._playing_value = 7
self._zooming._selected_value = 8"""
self._matrix = matrix
self._side_buttons = side_buttons
self._nav_buttons = top_buttons[:4]
self._config_button = config_button
self._zooming.set_empty_value(LED_OFF)
self._all_buttons = []
for button in self._side_buttons + self._nav_buttons:
self._all_buttons.append(button)
self._sub_modes = SubSelectorComponent(matrix, side_buttons,
self._session)
self._sub_modes.name = 'Mixer_Modes'
self._sub_modes.set_update_callback(self._update_control_channels)
self._init_session()
self._all_buttons = tuple(self._all_buttons)
self.set_modes_buttons(top_buttons[4:])
if START_IN_MOD is True:
self._set_protected_mode_index(4)
def __init__(self,
session = None,
shift = None,
unselected_color = RED,
selected_color = GREEN,
**kwargs):
Elementary.__init__(self, **kwargs)
SessionZoomingComponent.__init__(self, session)
self.set_button_matrix(session.button_matrix)
self.set_zoom_button(self.button(shift, blink_on = True))
self.set_stopped_value(unselected_color)
self.set_selected_value(selected_color)
self.set_nav_buttons(session.up_button, session.down_button, session.left_button, session.right_button)
if hasattr(session, 'scene_launch_buttons'):
self.set_scene_bank_buttons(tuple(session.scene_launch_buttons))
def _setup_session_control(self):
is_momentary = True
num_tracks = 7
num_scenes = 7 ###changed from 5 for HH
global session
session = SessionComponent(num_tracks, num_scenes)
session.name = "Session"
session.set_offsets(0, 0)
self._session = session
self._scene = [None for index in range(num_scenes)]
for row in range(num_scenes):
self._scene[row] = session.scene(row)
self._scene[row].name = 'Scene_' + str(row)
for column in range(num_tracks):
clip_slot = self._scene[row].clip_slot(column)
clip_slot.name = str(column) + '_Clip_Slot_' + str(row)
session.set_mixer(mixer)
self._session_zoom = SessionZoomingComponent(session)
self._session_zoom.name = 'Session_Overview'
#self._session_zoom.set_enabled(False)
self.set_highlighting_session_component(self._session)
def _create_session(self):
def when_bank_on(button):
return self._bank_toggle.create_toggle_element(on_control=button)
def when_bank_off(button):
return self._bank_toggle.create_toggle_element(off_control=button)
self._session = SessionComponent(NUM_TRACKS, NUM_SCENES, auto_name=True, is_enabled=False, enable_skinning=True, layer=Layer(track_bank_left_button=when_bank_off(self._left_button), track_bank_right_button=when_bank_off(self._right_button), scene_bank_up_button=when_bank_off(self._up_button), scene_bank_down_button=when_bank_off(self._down_button), page_left_button=when_bank_on(self._left_button), page_right_button=when_bank_on(self._right_button), page_up_button=when_bank_on(self._up_button), page_down_button=when_bank_on(self._down_button), stop_track_clip_buttons=self._stop_buttons, stop_all_clips_button=self._stop_all_button, scene_launch_buttons=self._scene_launch_buttons, clip_launch_buttons=self._session_matrix))
clip_color_table = colors.CLIP_COLOR_TABLE.copy()
clip_color_table[16777215] = 119
self._session.set_rgb_mode(clip_color_table, colors.RGB_COLOR_TABLE)
self._session_zoom = SessionZoomingComponent(self._session, name='Session_Overview', enable_skinning=True, is_enabled=False, layer=Layer(button_matrix=self._shifted_matrix, nav_left_button=self._with_shift(self._left_button), nav_right_button=self._with_shift(self._right_button), nav_up_button=self._with_shift(self._up_button), nav_down_button=self._with_shift(self._down_button), scene_bank_buttons=self._shifted_scene_buttons))
def _setup_session_control(self): global session is_momentary = True num_tracks = 7 num_scenes = 5 session = SessionComponent(num_tracks, num_scenes) session.name = 'Session' self._session = session session.set_offsets(0, 0) self._scene = [ None for index in range(6) ] for row in range(num_scenes): self._scene[row] = session.scene(row) self._scene[row].name = 'Scene_' + str(row) for column in range(num_tracks): clip_slot = self._scene[row].clip_slot(column) clip_slot.name = str(column) + '_Clip_Slot_' + str(row) session.set_mixer(self._mixer) session.set_show_highlight(True) self._session_zoom = SessionZoomingComponent(session) self._session_zoom.name = 'Session_Overview' self.set_highlighting_session_component(self._session)
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, *a, **k):
# call parent contructor
super(APC_mini_jojo, self).__init__(*a, **k)
# copied from midiscripts.net
# assign script name used by Logger
self.script_name = "APC mini + J0J0's hacks v0.2"
self.log_start()
self._suppress_session_highlight = False
self._suppress_send_midi = False
self._color_skin = make_biled_skin()
self._default_skin = make_default_skin()
self._stop_button_skin = make_stop_button_skin()
with self.component_guard():
self._create_controls()
self._session = self._create_session()
self._mixer = self._create_mixer()
self._device = self._create_device_component()
if self.HAS_TRANSPORT:
self._transport = self._create_transport()
self.set_device_component(self._device)
self.set_highlighting_session_component(self._session)
self._session.set_mixer(self._mixer)
self._encoder_modes = self._create_encoder_modes()
self._track_modes = self._create_track_button_modes()
self._device_selection_follows_track_selection = True
with self.component_guard():
self.register_disconnectable(SimpleLayerOwner(
layer=Layer(_unused_buttons=self.wrap_matrix(self._unused_buttons))))
# added from midiscripts.net
# create session overview component
# basically this component implements all complexity
# of a session view, in this script we just re-use it
# self._session was created by parent class
with self.component_guard():
self._session_overview = SessionZoomingComponent(
self._session,
name='Session_Overview',
enable_skinning=True,
is_enabled=True)
self.log_message('_session_overview created')
def __init__(self, matrix, top_buttons, side_buttons, config_button, knobs, sliders, script): assert isinstance(matrix, ButtonMatrixElement) assert ((matrix.width() == 8) and (matrix.height() == 8)) assert isinstance(top_buttons, tuple) assert (len(top_buttons) == 8) assert isinstance(side_buttons, tuple) assert (len(side_buttons) == 8) assert isinstance(config_button, ButtonElement) ModeSelectorComponent.__init__(self) self._script = script self._session = SpecialSessionComponent(matrix.width(), matrix.height()) for scene in self._session._scenes: for slot in scene._clip_slots: slot._triggered_to_play_value = 4 slot._triggered_to_record_value = 3 slot._started_value = 2 slot._recording_value = 1 slot._stopped_value = 127 self._zooming = SessionZoomingComponent(self._session) self._zooming._stopped_value = 127 self._zooming._playing_value = 2 self._zooming._selected_value = 1 self._matrix = matrix self._knobs = knobs self._sliders = sliders self._side_buttons = side_buttons self._nav_buttons = top_buttons[:4] self._config_button = config_button self._shift_button = top_buttons[5] self._zooming.set_empty_value(LED_OFF) self._all_buttons = [] for button in (self._side_buttons + self._nav_buttons): self._all_buttons.append(button) self._shift_pressed = 0 self._shift_pressed_timer = 0 self._last_normal_mode = 0 self._shift_button = None self.set_shift_button(top_buttons[6]) self._sub_modes = SubSelectorComponent(matrix, side_buttons, self._session) self._sub_modes.set_update_callback(self._update_control_channels) self._init_session() self._all_buttons = tuple(self._all_buttons) self.set_modes_buttons(top_buttons[4:6])
def _setup_session_control(self): is_momentary = True num_tracks = 7 num_scenes = 5 global session session = SessionComponent(num_tracks, num_scenes) session.name = "Session" self._session = session session.set_offsets(0, 0) self._scene = [None for index in range(6)] for row in range(num_scenes): self._scene[row] = session.scene(row) self._scene[row].name = 'Scene_' + str(row) for column in range(num_tracks): clip_slot = self._scene[row].clip_slot(column) clip_slot.name = str(column) + '_Clip_Slot_' + str(row) session.set_mixer(self._mixer) self._session_zoom = SessionZoomingComponent(session) self._session_zoom.name = 'Session_Overview'
def __init__(self, matrix, top_buttons, side_buttons, config_button, script):
assert isinstance(matrix, ButtonMatrixElement)
assert matrix.width() == 8 and matrix.height() == 8
assert isinstance(top_buttons, tuple)
assert len(top_buttons) == 8
assert isinstance(side_buttons, tuple)
assert len(side_buttons) == 8
assert isinstance(config_button, ButtonElement)
ModeSelectorComponent.__init__(self)
self._script = script
self._session = SpecialSessionComponent(matrix.width(), matrix.height())
"""for scene in self._session._scenes:
for slot in scene._clip_slots:
slot._triggered_to_play_value = 24
slot._triggered_to_record_value = 27
slot._started_value = 7
slot._recording_value = 9
slot._stopped_value = 8"""
self._zooming = SessionZoomingComponent(self._session)
self._session.name = "Session_Control"
self._zooming.name = "Session_Overview"
"""self._zooming._stopped_value = 9
self._zooming._playing_value = 7
self._zooming._selected_value = 8"""
self._matrix = matrix
self._side_buttons = side_buttons
self._nav_buttons = top_buttons[:4]
self._config_button = config_button
self._zooming.set_empty_value(LED_OFF)
self._all_buttons = []
for button in self._side_buttons + self._nav_buttons:
self._all_buttons.append(button)
self._sub_modes = SubSelectorComponent(matrix, side_buttons, self._session)
self._sub_modes.name = "Mixer_Modes"
self._sub_modes.set_update_callback(self._update_control_channels)
self._init_session()
self._all_buttons = tuple(self._all_buttons)
self.set_modes_buttons(top_buttons[4:])
if START_IN_MOD is True:
self._set_protected_mode_index(4)
def _setup_session_control(self):
is_momentary = True
self._shift_button = ButtonElement(is_momentary, MIDI_NOTE_TYPE, 0, 98)
right_button = ButtonElement(is_momentary, MIDI_NOTE_TYPE, 0, 96)
left_button = ButtonElement(is_momentary, MIDI_NOTE_TYPE, 0, 97)
up_button = ButtonElement(is_momentary, MIDI_NOTE_TYPE, 0, 94)
down_button = ButtonElement(is_momentary, MIDI_NOTE_TYPE, 0, 95)
right_button.name = "Bank_Select_Right_Button"
left_button.name = "Bank_Select_Left_Button"
up_button.name = "Bank_Select_Up_Button"
down_button.name = "Bank_Select_Down_Button"
self._session = PedaledSessionComponent(8, 5)
self._session.name = "Session_Control"
self._session.set_track_bank_buttons(right_button, left_button)
self._session.set_scene_bank_buttons(down_button, up_button)
matrix = ButtonMatrixElement()
matrix.name = "Button_Matrix"
scene_launch_buttons = [
ConfigurableButtonElement(is_momentary, MIDI_NOTE_TYPE, 0, (index + 82)) for index in range(5)
]
self._double_buttons = [
ConfigurableButtonElement(is_momentary, MIDI_NOTE_TYPE, 0, (index + 82)) for index in range(5)
]
track_stop_buttons = [ButtonElement(is_momentary, MIDI_NOTE_TYPE, index, 52) for index in range(8)]
for index in range(len(scene_launch_buttons)):
scene_launch_buttons[index].name = "Scene_" + str(index) + "_Launch_Button"
for index in range(len(track_stop_buttons)):
track_stop_buttons[index].name = "Track_" + str(index) + "_Stop_Button"
stop_all_button = ButtonElement(is_momentary, MIDI_NOTE_TYPE, 0, 81)
stop_all_button.name = "Stop_All_Clips_Button"
self._session.set_stop_all_clips_button(stop_all_button)
self._session.set_stop_track_clip_buttons(tuple(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(scene_launch_buttons[scene_index])
scene.set_triggered_value(2)
for track_index in range(8):
button = ButtonElement(is_momentary, MIDI_NOTE_TYPE, track_index, (scene_index + 53))
button.name = str(track_index) + "_Clip_" + str(scene_index) + "_Button"
button_row.append(button)
clip_slot = scene.clip_slot(track_index)
clip_slot.name = str(track_index) + "_Clip_Slot_" + str(scene_index)
clip_slot.set_triggered_to_play_value(2)
clip_slot.set_triggered_to_record_value(4)
clip_slot.set_stopped_value(3)
clip_slot.set_started_value(1)
clip_slot.set_recording_value(5)
clip_slot.set_launch_button(button)
matrix.add_row(tuple(button_row))
self._session.set_slot_launch_button(ButtonElement(is_momentary, MIDI_CC_TYPE, 0, 67))
self._session.selected_scene().name = "Selected_Scene"
self._session.selected_scene().set_launch_button(ButtonElement(is_momentary, MIDI_CC_TYPE, 0, 64))
self._session_zoom = SessionZoomingComponent(self._session)
self._session_zoom.name = "Session_Overview"
self._session_zoom.set_button_matrix(matrix)
self._session_zoom.set_zoom_button(self._shift_button)
self._session_zoom.set_nav_buttons(up_button, down_button, left_button, right_button)
self._session_zoom.set_scene_bank_buttons(tuple(scene_launch_buttons))
self._session_zoom.set_stopped_value(3)
self._session_zoom.set_selected_value(5)
scene_user_mode = SceneUserModeComponent(self._session, self._session_zoom, self)
return None # return session
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)
def disconnect(self):
SessionZoomingComponent.disconnect(self)
for button in self._stop_buttons:
button.remove_value_listener(self._stop_value)
def _setup_session_control(self):
is_momentary = True
self._shift_button = ButtonElement(is_momentary, MIDI_NOTE_TYPE, 0, 98)
right_button = ButtonElement(is_momentary, MIDI_NOTE_TYPE, 0, 96)
left_button = ButtonElement(is_momentary, MIDI_NOTE_TYPE, 0, 97)
up_button = ButtonElement(is_momentary, MIDI_NOTE_TYPE, 0, 94)
down_button = ButtonElement(is_momentary, MIDI_NOTE_TYPE, 0, 95)
right_button.name = 'Bank_Select_Right_Button'
left_button.name = 'Bank_Select_Left_Button'
up_button.name = 'Bank_Select_Up_Button'
down_button.name = 'Bank_Select_Down_Button'
self._session = PedaledSessionComponent(8, 5)
self._session.name = 'Session_Control'
self._session.set_track_bank_buttons(right_button, left_button)
self._session.set_scene_bank_buttons(down_button, up_button)
matrix = ButtonMatrixElement()
matrix.name = 'Button_Matrix'
scene_launch_buttons = [
ButtonElement(is_momentary, MIDI_NOTE_TYPE, 0, index + 82)
for index in range(5)
]
track_stop_buttons = [
ButtonElement(is_momentary, MIDI_NOTE_TYPE, index, 52)
for index in range(8)
]
for index in range(len(scene_launch_buttons)):
scene_launch_buttons[index].name = 'Scene_' + str(
index) + '_Launch_Button'
for index in range(len(track_stop_buttons)):
track_stop_buttons[index].name = 'Track_' + str(
index) + '_Stop_Button'
stop_all_button = ButtonElement(is_momentary, MIDI_NOTE_TYPE, 0, 81)
stop_all_button.name = 'Stop_All_Clips_Button'
self._session.set_stop_all_clips_button(stop_all_button)
self._session.set_stop_track_clip_buttons(tuple(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(scene_launch_buttons[scene_index])
scene.set_triggered_value(2)
for track_index in range(8):
button = ButtonElement(is_momentary, MIDI_NOTE_TYPE,
track_index, scene_index + 53)
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)
matrix.add_row(tuple(button_row))
self._session.set_slot_launch_button(
ButtonElement(is_momentary, MIDI_CC_TYPE, 0, 67))
self._session.selected_scene().name = 'Selected_Scene'
self._session.selected_scene().set_launch_button(
ButtonElement(is_momentary, MIDI_CC_TYPE, 0, 64))
self._session_zoom = SessionZoomingComponent(self._session)
self._session_zoom.name = 'Session_Overview'
self._session_zoom.set_button_matrix(matrix)
self._session_zoom.set_zoom_button(self._shift_button)
self._session_zoom.set_nav_buttons(up_button, down_button, left_button,
right_button)
self._session_zoom.set_scene_bank_buttons(tuple(scene_launch_buttons))
self._session_zoom.set_stopped_value(3)
self._session_zoom.set_selected_value(5)
class MainSelectorComponent(ModeSelectorComponent):
__module__ = __name__
__doc__ = ' Class that reassigns the button on the launchpad to different functions '
def __init__(self, matrix, top_buttons, side_buttons, config_button, script):
assert isinstance(matrix, ButtonMatrixElement)
assert ((matrix.width() == 8) and (matrix.height() == 8))
assert isinstance(top_buttons, tuple)
assert (len(top_buttons) == 8)
assert isinstance(side_buttons, tuple)
assert (len(side_buttons) == 8)
assert isinstance(config_button, ButtonElement)
ModeSelectorComponent.__init__(self)
self._script = script
self._session = SpecialSessionComponent(matrix.width(), matrix.height())
for scene in self._session._scenes:
for slot in scene._clip_slots:
slot._triggered_to_play_value = 24
slot._triggered_to_record_value = 27
slot._started_value = 7
slot._recording_value = 9
slot._stopped_value = 8
self._zooming = SessionZoomingComponent(self._session)
self._zooming._stopped_value = 9
self._zooming._playing_value = 7
self._zooming._selected_value = 8
self._matrix = matrix
self._side_buttons = side_buttons
self._nav_buttons = top_buttons[:4]
self._config_button = config_button
self._zooming.set_empty_value(LED_OFF)
self._all_buttons = []
for button in (self._side_buttons + self._nav_buttons):
self._all_buttons.append(button)
self._sub_modes = SubSelectorComponent(matrix, side_buttons, self._session)
self._sub_modes.set_update_callback(self._update_control_channels)
self._init_session()
self._all_buttons = tuple(self._all_buttons)
self.set_modes_buttons(top_buttons[4:])
def disconnect(self):
for button in self._modes_buttons:
button.remove_value_listener(self._mode_value)
self._session = None
self._zooming = None
for button in self._all_buttons:
button.set_on_off_values(127, LED_OFF)
self._config_button.turn_off()
self._matrix = None
self._side_buttons = None
self._nav_buttons = None
self._config_button = None
ModeSelectorComponent.disconnect(self)
def set_modes_buttons(self, buttons):
assert ((buttons == None) or (isinstance(buttons, tuple) or (len(buttons) == self.number_of_modes() + 1)))
identify_sender = True
for button in self._modes_buttons:
button.remove_value_listener(self._mode_value)
self._modes_buttons = []
if (buttons != None):
for button in buttons:
assert isinstance(button, ButtonElement)
self._modes_buttons.append(button)
button.add_value_listener(self._mode_value, identify_sender)
self.set_mode(0)
def _mode_value(self, value, sender):
assert (len(self._modes_buttons) > 0)
assert isinstance(value, int)
assert isinstance(sender, ButtonElement)
assert (self._modes_buttons.count(sender) == 1)
if self._script._host.is_enabled() != True:
if ((value is not 0) or (not sender.is_momentary())):
if ((self._modes_buttons[1]._last_received_value > 0) and (self._modes_buttons.index(sender) == 2)) or ((self._modes_buttons[2]._last_received_value > 0) and (self._modes_buttons.index(sender) == 1)):
if(self._script._host._active_client != None):
self.set_mode(4)
else:
self._script.show_message('Monomodular Script not inserted')
else:
self.set_mode(self._modes_buttons.index(sender))
else:
if self._modes_buttons.index(sender) == 3 and value > 0:
self.set_mode(0)
def number_of_modes(self):
return 5
def on_enabled_changed(self):
self.update()
def set_mode(self, mode):
assert (mode in range(self.number_of_modes()))
if ((self._mode_index != mode) or (mode == 3)):
self._mode_index = mode
self.update()
def update(self):
assert (self._modes_buttons != None)
if self.is_enabled():
for scene_index in range(8):
self._side_buttons[scene_index].set_enabled(True)
for track_index in range(8):
self._matrix.get_button(track_index, scene_index).set_enabled(True)
for button in self._nav_buttons:
button.set_enabled(True)
as_active = True
as_enabled = True
self._session.set_allow_update(False)
self._zooming.set_allow_update(False)
self._config_button.send_value(40)
self._config_button.send_value(1)
release_buttons = (self._mode_index == 1)
if (self._mode_index < 4):
self._script._host._set_key_buttons(None)
self._script._host.set_enabled(False)
self._script._host._set_button_matrix(None)
self._script._host._set_alt_button(None)
self._script._host._set_shift_button(None)
self._script._host._set_nav_buttons(None)
for button in self._modes_buttons:
button.set_on_off_values(5, 0)
if (self._mode_index == 0):
self._setup_mixer((not as_active))
self._setup_session(as_active, as_enabled)
elif (self._mode_index == 1):
self._setup_session((not as_active), (not as_enabled))
self._setup_mixer((not as_active))
self._setup_user(release_buttons)
elif (self._mode_index == 2):
self._setup_session((not as_active), (not as_enabled))
self._setup_mixer((not as_active))
self._setup_user(release_buttons)
elif (self._mode_index == 3):
self._setup_session((not as_active), as_enabled)
self._setup_mixer(as_active)
elif (self._mode_index == 4):
self._setup_session((not as_active), (not as_enabled))
self._setup_mixer((not as_active))
self._setup_user(release_buttons)
self._script._host._set_button_matrix(self._matrix)
self._script._host._set_key_buttons(self._side_buttons)
self._script._host._set_shift_button(self._modes_buttons[0])
self._script._host._set_lock_button(self._modes_buttons[1])
self._script._host._set_alt_button(self._modes_buttons[2])
self._modes_buttons[3].send_value(9)
self._script._host._set_nav_buttons(self._nav_buttons)
self._script._host.set_enabled(True)
else:
assert False
self._session.set_allow_update(True)
self._zooming.set_allow_update(True)
self._update_control_channels()
if(self._mode_index < 4):
for index in range(len(self._modes_buttons)):
if (index == self._mode_index):
self._modes_buttons[index].turn_on()
else:
self._modes_buttons[index].turn_off()
#self._script.request_rebuild_midi_map()
self._script.schedule_message(1, self._session.update)
def _update_control_channels(self):
if self._mode_index < 4:
new_channel = (self._mode_index + self._sub_modes.mode())
if (new_channel > 0):
new_channel += 3
else:
new_channel = 15
for button in self._all_buttons:
button.set_channel(new_channel)
button.set_force_next_value()
def _setup_session(self, as_active, as_enabled):
assert isinstance(as_active, type(False))
for button in self._nav_buttons:
if as_enabled:
button.set_on_off_values(GREEN_FULL, GREEN_THIRD)
else:
button.set_on_off_values(127, LED_OFF)
for scene_index in range(8):
scene = self._session.scene(scene_index)
if as_active:
scene_button = self._side_buttons[scene_index]
scene_button.set_on_off_values(127, LED_OFF)
scene.set_launch_button(scene_button)
else:
scene.set_launch_button(None)
for track_index in range(8):
if as_active:
button = self._matrix.get_button(track_index, scene_index)
button.set_on_off_values(127, LED_OFF)
scene.clip_slot(track_index).set_launch_button(button)
else:
scene.clip_slot(track_index).set_launch_button(None)
if as_active:
self._zooming.set_zoom_button(self._modes_buttons[0])
self._zooming.set_button_matrix(self._matrix)
self._zooming.set_scene_bank_buttons(self._side_buttons)
self._zooming.set_nav_buttons(self._nav_buttons[0], self._nav_buttons[1], self._nav_buttons[2], self._nav_buttons[3])
self._zooming.update()
else:
self._zooming.set_zoom_button(None)
self._zooming.set_button_matrix(None)
self._zooming.set_scene_bank_buttons(None)
self._zooming.set_nav_buttons(None, None, None, None)
if as_enabled:
self._session.set_track_bank_buttons(self._nav_buttons[3], self._nav_buttons[2])
self._session.set_scene_bank_buttons(self._nav_buttons[1], self._nav_buttons[0])
self._session.set_show_highlight(True)
else:
self._session.set_track_bank_buttons(None, None)
self._session.set_scene_bank_buttons(None, None)
self._session.set_show_highlight(False)
def _setup_mixer(self, as_active):
assert isinstance(as_active, type(False))
self._sub_modes.set_enabled(as_active)
def _setup_user(self, release_buttons):
for scene_index in range(8):
scene_button = self._side_buttons[scene_index]
scene_button.set_on_off_values(127, LED_OFF)
scene_button.turn_off()
scene_button.set_enabled((not release_buttons))
for track_index in range(8):
button = self._matrix.get_button(track_index, scene_index)
button.set_on_off_values(127, LED_OFF)
button.turn_off()
button.set_enabled((not release_buttons))
for button in self._nav_buttons:
button.set_on_off_values(127, LED_OFF)
button.turn_off()
button.set_enabled((not release_buttons))
self._config_button.send_value(32)
if release_buttons:
self._config_button.send_value(2)
def _init_session(self):
self._session.set_stop_track_clip_value(AMBER_BLINK)
for scene_index in range(self._matrix.height()):
scene = self._session.scene(scene_index)
scene.set_triggered_value(GREEN_BLINK)
for track_index in range(self._matrix.width()):
clip_slot = scene.clip_slot(track_index)
clip_slot.set_triggered_to_play_value(GREEN_BLINK)
clip_slot.set_triggered_to_record_value(RED_BLINK)
clip_slot.set_stopped_value(AMBER_FULL)
clip_slot.set_started_value(GREEN_FULL)
clip_slot.set_recording_value(RED_FULL)
self._all_buttons.append(self._matrix.get_button(track_index, scene_index))
self._zooming.set_stopped_value(RED_FULL)
self._zooming.set_selected_value(AMBER_FULL)
self._zooming.set_playing_value(GREEN_FULL)
def _scene_bank_value(self, value, sender):
if (not self._ignore_buttons):
SessionZoomingComponent._scene_bank_value(self, value, sender)
class MainSelectorComponent(ModeSelectorComponent): """ Class that reassigns the button on the launchpad to different functions """ def __init__(self, matrix, top_buttons, side_buttons, config_button, parent): assert isinstance(matrix, ButtonMatrixElement) assert ((matrix.width() == 8) and (matrix.height() == 8)) assert isinstance(top_buttons, tuple) assert (len(top_buttons) == 8) assert isinstance(side_buttons, tuple) assert (len(side_buttons) == 8) assert isinstance(config_button, ButtonElement) ModeSelectorComponent.__init__(self) self._parent = parent self._compact = False self._session = SpecialSessionComponent(matrix.width(), matrix.height()) self._zooming = SessionZoomingComponent(self._session) self._session.name = 'Session_Control' self._zooming.name = 'Session_Overview' self._matrix = matrix self._side_buttons = side_buttons self._nav_buttons = top_buttons[:4] self._config_button = config_button self._zooming.set_empty_value(LED_OFF) self._all_buttons = [] for button in self._side_buttons + self._nav_buttons: self._all_buttons.append(button) self._sub_modes = SubSelectorComponent(matrix, side_buttons, self._session) self._sub_modes.name = 'Mixer_Modes' self._sub_modes.set_update_callback(self._update_control_channels) self._stepseq = StepSequencerComponent(self._matrix, self._side_buttons, self._nav_buttons, self) self._instrument_controller = InstrumentControllerComponent( self._matrix, self._side_buttons, self._nav_buttons,self) self._device_controller = DeviceControllerComponent(self._matrix, self._side_buttons, self._nav_buttons, self) self._init_session() self._all_buttons = tuple(self._all_buttons) self._mode_index=0 self._previous_mode_index=-1 self._sub_mode_index=[0,0,0,0] for index in range(4): self._sub_mode_index[index]=0 self.set_mode_buttons(top_buttons[4:]) def disconnect(self): for button in self._modes_buttons: button.remove_value_listener(self._mode_value) self._session = None self._zooming = None for button in self._all_buttons: button.set_on_off_values(127, LED_OFF) self._config_button.turn_off() self._matrix = None self._side_buttons = None self._nav_buttons = None self._config_button = None ModeSelectorComponent.disconnect(self) def session_component(self): return self._session def _update_mode(self): mode = self._modes_heap[-1][0] assert mode in range(self.number_of_modes()) if self._mode_index==mode: if self._mode_index==1: #user mode 1 and device controller and instrument mode self._sub_mode_index[self._mode_index] = (self._sub_mode_index[self._mode_index]+1)%3 self.update() elif self._mode_index==2: #user mode 2 and step sequencer self._sub_mode_index[self._mode_index] = (self._sub_mode_index[self._mode_index]+1)%2 self.update() elif self._mode_index==3: self.update() else: self._sub_mode_index[self._mode_index] = 0 self._previous_mode_index=self._mode_index else: self._mode_index = mode self.update() def set_mode(self, mode): self._clean_heap() self._modes_heap = [(mode, None, None)] #if ((self._mode_index != mode) or (mode == 3) or True): #self._mode_index = mode #self._update_mode() # self.update() def number_of_modes(self): return 4 def on_enabled_changed(self): self.update() def _update_mode_buttons(self): for index in range(4): if(self._sub_mode_index[index]==0): self._modes_buttons[index].set_on_off_values(AMBER_FULL,AMBER_THIRD) if(self._sub_mode_index[index]==1): self._modes_buttons[index].set_on_off_values(GREEN_FULL,GREEN_THIRD) if(self._sub_mode_index[index]==2): self._modes_buttons[index].set_on_off_values(RED_FULL,RED_THIRD) if (index == self._mode_index): self._modes_buttons[index].turn_on() else: self._modes_buttons[index].turn_off() def channel_for_current_mode(self): if self._compact: if self._mode_index==0: new_channel = 2 #session elif self._mode_index==1: if self._sub_mode_index[self._mode_index]==0: new_channel = 2 #instrument controller 11,12,13,14 if self._instrument_controller != None: self._instrument_controller.base_channel = new_channel elif self._sub_mode_index[self._mode_index]==1: new_channel = 2 #device controler else : new_channel = 0 #plain user mode 1 elif self._mode_index==2: if self._sub_mode_index[self._mode_index]==0: new_channel = 1 #user 2 else: new_channel = 2 + self._sub_mode_index[self._mode_index] #step seq 2,3 elif self._mode_index==3: #mixer modes new_channel = 2 + self._sub_modes.mode() # 2,3,4,5,6 else: if self._mode_index==0: new_channel = 0 #session elif self._mode_index==1: if self._sub_mode_index[self._mode_index]==0: new_channel = 11 #instrument controller 11,12,13,14 if self._instrument_controller != None: self._instrument_controller.base_channel = new_channel elif self._sub_mode_index[self._mode_index]==1: new_channel = 3 #device controler else : new_channel = 4 #plain user mode 1 elif self._mode_index==2: if self._sub_mode_index[self._mode_index]==0: new_channel = 5 #user 2 else: new_channel = 1 + self._sub_mode_index[self._mode_index] #step seq 1,2 elif self._mode_index==3: #mixer modes new_channel = 6 + self._sub_modes.mode() # 6,7,8,9,10 return new_channel def update(self): assert (self._modes_buttons != None) if self.is_enabled(): self._update_mode_buttons() as_active = True as_enabled = True self._session.set_allow_update(False) self._zooming.set_allow_update(False) self._config_button.send_value(40) self._config_button.send_value(1) if (self._mode_index == 0): #session self._setup_mixer(not as_active) self._setup_device_controller(not as_active) self._setup_step_sequencer(not as_active) self._setup_instrument_controller(not as_active) self._setup_session(as_active, as_enabled) self._update_control_channels() elif (self._mode_index == 1): self._setup_session(not as_active, not as_enabled) self._setup_step_sequencer(not as_active) self._setup_mixer(not as_active) #user mode + device controller + instrument controller if (self._sub_mode_index[self._mode_index]==0): self._setup_device_controller(not as_active) self._update_control_channels() self._setup_instrument_controller(as_active) elif (self._sub_mode_index[self._mode_index]==1): self._setup_instrument_controller(not as_active) self._setup_device_controller(as_active) self._update_control_channels() else: self._setup_device_controller(not as_active) self._setup_instrument_controller(not as_active) self._setup_user_mode(True, True, False, True) self._update_control_channels() elif (self._mode_index == 2): self._setup_session(not as_active, not as_enabled) self._setup_instrument_controller(not as_active) self._setup_device_controller(not as_active) self._setup_mixer(not as_active) if (self._sub_mode_index[self._mode_index]==0): self._setup_step_sequencer(not as_active) self._setup_user_mode(False, False, False, False) else: self._setup_step_sequencer(as_active, self._sub_mode_index[self._mode_index]) self._update_control_channels() elif (self._mode_index == 3): self._setup_device_controller(not as_active) self._setup_step_sequencer(not as_active) self._setup_instrument_controller(not as_active) self._setup_session(not as_active, as_enabled) self._setup_mixer(as_active) self._update_control_channels() else: assert False self._previous_mode_index=self._mode_index self._session.set_allow_update(True) self._zooming.set_allow_update(True) def _setup_session(self, as_active, as_enabled): assert isinstance(as_active, type(False)) for button in self._nav_buttons: if as_enabled: button.set_on_off_values(GREEN_FULL, GREEN_THIRD) else: button.set_on_off_values(127, LED_OFF) #matrix for scene_index in range(8): scene = self._session.scene(scene_index) if as_active: self._activate_matrix(True) scene_button = self._side_buttons[scene_index] scene_button.set_on_off_values(127, LED_OFF) scene.set_launch_button(scene_button) else: scene.set_launch_button(None) for track_index in range(8): if as_active: button = self._matrix.get_button(track_index, scene_index) button.set_on_off_values(127, LED_OFF) scene.clip_slot(track_index).set_launch_button(button) else: scene.clip_slot(track_index).set_launch_button(None) #zoom if as_active: self._zooming.set_zoom_button(self._modes_buttons[0]) self._zooming.set_button_matrix(self._matrix) self._zooming.set_scene_bank_buttons(self._side_buttons) self._zooming.set_nav_buttons(self._nav_buttons[0], self._nav_buttons[1], self._nav_buttons[2], self._nav_buttons[3]) self._zooming.update() else: self._zooming.set_zoom_button(None) self._zooming.set_button_matrix(None) self._zooming.set_scene_bank_buttons(None) self._zooming.set_nav_buttons(None, None, None, None) #nav buttons if as_enabled: self._session.set_track_bank_buttons(self._nav_buttons[3], self._nav_buttons[2]) self._session.set_scene_bank_buttons(self._nav_buttons[1], self._nav_buttons[0]) else: self._session.set_track_bank_buttons(None, None) self._session.set_scene_bank_buttons(None, None) def _setup_instrument_controller(self, enabled): if self._instrument_controller != None: if enabled: self._activate_matrix(False) self._activate_scene_buttons(True) self._activate_navigation_buttons(True) else: for scene_index in range(8): scene_button = self._side_buttons[scene_index] scene_button.use_default_message() scene_button.force_next_send() for track_index in range(8): button = self._matrix.get_button(track_index, scene_index) button.use_default_message() button.force_next_send() self._instrument_controller.set_enabled(enabled) def _setup_device_controller(self, as_active): if self._device_controller!=None: if as_active: self._activate_scene_buttons(True) self._activate_matrix(True) self._activate_navigation_buttons(True) self._device_controller._is_active = True self._config_button.send_value(32) self._device_controller.set_enabled(True) self._device_controller.update() else: self._device_controller._is_active = False self._device_controller.set_enabled(False) def _setup_user_mode(self, release_matrix=True, release_side_buttons=True, release_nav_buttons = True, drum_rack_mode = True): for scene_index in range(8): scene_button = self._side_buttons[scene_index] scene_button.set_on_off_values(127, LED_OFF) scene_button.force_next_send() scene_button.turn_off() scene_button.set_enabled((not release_side_buttons)) for track_index in range(8): button = self._matrix.get_button(track_index, scene_index) button.set_on_off_values(127, LED_OFF) button.turn_off() button.set_enabled((not release_matrix)) for button in self._nav_buttons: button.set_on_off_values(127, LED_OFF) button.turn_off() button.set_enabled((not release_nav_buttons)) if drum_rack_mode: self._config_button.send_value(2) self._config_button.send_value(32) def _setup_step_sequencer(self, as_active, mode=0): if(self._stepseq!=None): if(self._stepseq.is_enabled()!=as_active or self._stepseq._mode!=mode): if as_active: self._activate_scene_buttons(True) self._activate_matrix(True) self._activate_navigation_buttons(True) self._config_button.send_value(32) self._stepseq.set_enabled(True) else: self._stepseq.set_enabled(False) def _setup_mixer(self, as_active): assert isinstance(as_active, type(False)) if as_active: self._activate_navigation_buttons(True) self._activate_scene_buttons(True) self._activate_matrix(True) if(self._sub_modes.is_enabled()): #go back to default mode self._sub_modes.set_mode(-1) self._sub_modes.set_enabled(as_active) def _init_session(self): self._session.set_stop_track_clip_value(AMBER_BLINK) for scene_index in range(self._matrix.height()): scene = self._session.scene(scene_index) scene.set_triggered_value(GREEN_BLINK) scene.name = 'Scene_' + str(scene_index) for track_index in range(self._matrix.width()): clip_slot = scene.clip_slot(track_index) clip_slot.set_triggered_to_play_value(GREEN_BLINK) clip_slot.set_triggered_to_record_value(RED_BLINK) clip_slot.set_stopped_value(AMBER_FULL) clip_slot.set_started_value(GREEN_FULL) clip_slot.set_recording_value(RED_FULL) clip_slot.set_record_button_value(RED_THIRD) clip_slot.set_clip_palette(CLIP_COLOR_TABLE) #clip_slot.set_clip_rgb_table(RGB_COLOR_TABLE) clip_slot.name = str(track_index) + '_Clip_Slot_' + str(scene_index) self._all_buttons.append(self._matrix.get_button(track_index, scene_index)) self._zooming.set_stopped_value(RED_FULL) self._zooming.set_selected_value(AMBER_FULL) self._zooming.set_playing_value(GREEN_FULL) def _activate_navigation_buttons(self,active): for button in self._nav_buttons: button.set_enabled(active) def _activate_scene_buttons(self,active): for button in self._side_buttons: button.set_enabled(active) def _activate_matrix(self,active): for scene_index in range(8): for track_index in range(8): self._matrix.get_button(track_index, scene_index).set_enabled(active) def log_message(self, msg): self._parent.log_message(msg) #Update the channels of the buttons in the user modes.. def _update_control_channels(self): new_channel = self.channel_for_current_mode() for button in self._all_buttons: button.set_channel(new_channel) button.set_force_next_value()
def _nav_right_value(self, value):
if not self._ignore_buttons:
SessionZoomingComponent._nav_right_value(self, value)
class OhmModesHH(ControlSurface):
__module__ = __name__
__doc__ = " OhmModes controller script, custom script for Herbie Hancock by amounra "
def __init__(self, c_instance):
ControlSurface.__init__(self, c_instance)
with self.component_guard():
self.log_message(time.strftime("%d.%m.%Y %H:%M:%S", time.localtime()) + "--------------= OhmModesHH2 log opened =--------------") # Writes message into Live's main log file. This is a ControlSurface method.
#self.set_suppress_rebuild_requests(True) # Turn off rebuild MIDI map until after we're done setting up
self.revision = 'HH'
self.flash_status = 1
self._backlight = 127
self._backlight_type = 'static'
self._ohm = 127
self._ohm_type = 'static'
self._pad_translations = PAD_TRANSLATION
self._rgb = 1
self._keys_octave = 5
self._keys_scale = 0
self._tempo_buttons = None
self._scene_indexes = [[[0,0], [8, 0], [16, 0], [24, 0], [32, 0], [40, 0]],
[[0,0], [8, 0], [16, 0], [24, 0], [32, 0], [40, 0]],
[[0,0], [8, 0], [16, 0], [24, 0], [32, 0], [40, 0]],
[[0,0], [8, 0], [16, 0], [24, 0], [32, 0], [40, 0]],
[[0,0], [8, 0], [16, 0], [24, 0], [32, 0], [40, 0]]]
self._scene_bank = 0
self._bank_is_on = False
self._setup_monobridge()
self._setup_controls()
self._setup_transport_control() # Run the transport setup part of the script
self._setup_mixer_control() # Setup the mixer object
self._setup_session_control() # Setup the session object
self._setup_device_control() # Setup the device object
self._setup_crossfader()
self._setup_looper()
#self._setup_scene_selector()
#self._setup_modes()
self._assign_page_constants()
self.assign_page_0()
self._setup_hilight_knobs()
self._last_device = None
self._timer = 0
#self.set_suppress_rebuild_requests(False) #Turn rebuild back on, now that we're done setting up
self.song().view.add_selected_track_listener(self._update_selected_device)
self._on_selected_scene_changed()
self.show_message('OhmModes Control Surface Loaded')
self._send_midi(tuple(switchxfader))
#self.schedule_message(10, self.query_ohm, None)
#self.song().view.selected_scene = self.song().scenes[0]
self._assign_session_colors()
def query_ohm(self):
#self.log_message('querying Ohm')
self._send_midi(tuple(check_model))
def _setup_monobridge(self):
self._monobridge = MonoBridgeElement(self)
self._monobridge.name = 'MonoBridge'
def update_display(self):
ControlSurface.update_display(self)
self._timer = (self._timer + 1) % 256
self.flash()
def get_device_bank(self):
return self._device._bank_index
def _setup_controls(self):
is_momentary = True
self._fader = [None for index in range(8)]
self._dial = [None for index in range(16)]
self._button = [None for index in range(8)]
self._menu = [None for index in range(6)]
for index in range(8):
self._fader[index] = EncoderElement(MIDI_CC_TYPE, CHANNEL, OHM_FADERS[index], Live.MidiMap.MapMode.absolute)
self._fader[index].name = 'Fader_' + str(index), self
for index in range(8):
self._button[index] = MonoButtonElement(is_momentary, MIDI_NOTE_TYPE, CHANNEL, OHM_BUTTONS[index], 'Button_' + str(index), self)
for index in range(16):
self._dial[index] = EncoderElement(MIDI_CC_TYPE, CHANNEL, OHM_DIALS[index], Live.MidiMap.MapMode.absolute)
self._dial[index].name = 'Dial_' + str(index)
for index in range(6):
self._menu[index] = MonoButtonElement(is_momentary, MIDI_NOTE_TYPE, CHANNEL, OHM_MENU[index], 'Menu_' + str(index), self)
self._crossfader = EncoderElement(MIDI_CC_TYPE, CHANNEL, CROSSFADER, Live.MidiMap.MapMode.absolute)
self._crossfader.name = "Crossfader"
self._livid = MonoButtonElement(is_momentary, MIDI_NOTE_TYPE, CHANNEL, LIVID, 'Livid_Button', self)
self._shift_l = MonoButtonElement(is_momentary, MIDI_NOTE_TYPE, CHANNEL, SHIFT_L, 'Page_Button_Left', self)
self._shift_r = MonoButtonElement(is_momentary, MIDI_NOTE_TYPE, CHANNEL, SHIFT_R, 'Page_Button_Right', self)
self._matrix = ButtonMatrixElement()
self._matrix.name = 'Matrix'
self._grid = [None for index in range(8)]
for column in range(8):
self._grid[column] = [None for index in range(8)]
for row in range(8):
self._grid[column][row] = MonoButtonElement(is_momentary, MIDI_NOTE_TYPE, CHANNEL, (column * 8) + row, 'Grid_' + str(column) + '_' + str(row), self)
for row in range(6):
button_row = []
for column in range(7):
button_row.append(self._grid[column][row])
self._matrix.add_row(tuple(button_row))
def _setup_modes(self):
self._shift_mode = ShiftModeComponent(self)
self._shift_mode.name = 'Shift_Mode'
#self._shift_mode.set_mode_toggle(self._shift_l, self._shift_r)
#self._select_mode = ModeSelectorComponent(self)
#self._select_mode.name = 'Select_Mode'
#self._select_mode.set_mode_toggle(self._menu[5])
#self._select_mode.update = self.select_mode_update(self._select_mode)
#self._menu[5].add_value_listener(self._select_mode)
#self._scale_mode = ScaleModeComponent(self)
#self._scale_mode.name = "Scale_Mode"
#self._octave_mode = OctaveModeComponent(self)
#self._octave_mode.name = "Octave_Mode"
def select_mode_update(self, mode_selector):
def update():
if mode_selector._mode_index>0:
pass
return update
def _setup_looper(self):
self._looper = [None for index in range(2)]
for index in range(2):
self._looper[index] = LooperListenerComponent(self, index + 1)
self._looper[index].assign_buttons(self._button[index*4], self._button[(index*4)+1], self._button[(index*4)+2], self._button[(index*4)+3])
def _setup_transport_control(self):
self._transport = TransportComponent()
self._transport.name = 'Transport'
def _setup_mixer_control(self):
is_momentary = True
self._num_tracks = (7) #A mixer is one-dimensional;
global mixer
mixer = SpecialMixerComponent(7, 0, True, False)
mixer.name = 'Mixer'
self._mixer = mixer
mixer.set_track_offset(0) #Sets start point for mixer strip (offset from left)
for index in range(7):
mixer.channel_strip(index).set_volume_control(self._fader[index])
for index in range(7):
mixer.channel_strip(index).name = 'Mixer_ChannelStrip_' + str(index)
mixer.track_eq(index).name = 'Mixer_EQ_' + str(index)
mixer.channel_strip(index)._invert_mute_feedback = True
self.song().view.selected_track = mixer.channel_strip(0)._track #set the selected strip to the first track, so that we don't, for example, try to assign a button to arm the master track, which would cause an assertion error
def _setup_session_control(self):
is_momentary = True
num_tracks = 7
num_scenes = 7 ###changed from 5 for HH
global session
session = SessionComponent(num_tracks, num_scenes)
session.name = "Session"
session.set_offsets(0, 0)
self._session = session
self._scene = [None for index in range(num_scenes)]
for row in range(num_scenes):
self._scene[row] = session.scene(row)
self._scene[row].name = 'Scene_' + str(row)
for column in range(num_tracks):
clip_slot = self._scene[row].clip_slot(column)
clip_slot.name = str(column) + '_Clip_Slot_' + str(row)
session.set_mixer(mixer)
self._session_zoom = SessionZoomingComponent(session)
self._session_zoom.name = 'Session_Overview'
#self._session_zoom.set_enabled(False)
self.set_highlighting_session_component(self._session)
def _assign_session_colors(self):
num_tracks = 7
num_scenes = 7
self._session.set_stop_clip_value(STOP_CLIP_COLOR[self._rgb])
for row in range(num_scenes):
for column in range(num_tracks):
self._scene[row].clip_slot(column).set_triggered_to_play_value(CLIP_TRIGD_TO_PLAY_COLOR[self._rgb])
self._scene[row].clip_slot(column).set_triggered_to_record_value(CLIP_TRIGD_TO_RECORD_COLOR[self._rgb])
self._scene[row].clip_slot(column).set_stopped_value(CLIP_STOPPED_COLOR[self._rgb])
self._scene[row].clip_slot(column).set_started_value(CLIP_STARTED_COLOR[self._rgb])
self._scene[row].clip_slot(column).set_recording_value(CLIP_RECORDING_COLOR[self._rgb])
self._session_zoom.set_stopped_value(ZOOM_STOPPED_COLOR[self._rgb])
self._session_zoom.set_playing_value(ZOOM_PLAYING_COLOR[self._rgb])
self._session_zoom.set_selected_value(ZOOM_SELECTED_COLOR[self._rgb])
def _setup_device_control(self):
self._device = DeviceComponent()
self._device.name = 'Device_Component'
self.set_device_component(self._device)
self._device_navigator = DetailViewControllerComponent()
self._device_navigator.name = 'Device_Navigator'
self._device_selection_follows_track_selection = FOLLOW
def device_follows_track(self, val):
self._device_selection_follows_track_selection = (val == 1)
return self
def _setup_crossfader(self):
self._mixer.set_crossfader_control(self._crossfader)
def _setup_scene_selector(self):
for index in range(5):
self._menu[index].add_value_listener(self._select_new_scene, True)
def set_bank(self, val):
self._scene_bank = int(val)
self._monobridge._send('bank', self._scene_bank)
self._display_bank()
def _select_mode(self, value):
self.log_message('select mode update' + str(value))
self._bank_is_on = value!=0
if self._bank_is_on is True:
self._display_bank()
else:
self._on_selected_scene_changed()
def _select_new_scene(self, value, sender):
if self._bank_is_on is False:
if value > 0:
new_scene = int(self._scene_indexes[self._scene_bank][self._menu.index(sender)][0])
new_track = int(self._scene_indexes[self._scene_bank][self._menu.index(sender)][1])
self.log_message('select new scene ' + str(new_scene) + ' and track ' + str(new_track))
all_scenes = self.song().scenes
all_tracks = self.song().tracks
if (new_scene < len(all_scenes)) and (new_track < len(all_tracks)):
self.song().view.selected_scene = all_scenes[(new_scene)]
self.song().view.selected_track = all_tracks[(new_track)]
self._session.set_offsets(self._scene_indexes[self._scene_bank][self._menu.index(sender)][1], self._scene_indexes[self._scene_bank][self._menu.index(sender)][0])
else:
if value > 0:
self._scene_bank = int(self._menu.index(sender))
self._monobridge._send('bank', self._scene_bank)
self._display_bank()
def _display_bank(self):
if(self._bank_is_on):
for index in range(5):
if index == self._scene_bank:
self._menu[index].send_value(11)
else:
self._menu[index].send_value(0)
def _on_selected_scene_changed(self):
ControlSurface._on_selected_scene_changed(self)
#self.log_message('scene offset: ' + str(self._session._scene_offset))
for index in range(6):
if self._session._scene_offset == self._scene_indexes[self._scene_bank][index][0]: ## and self._session._scene_offset < self._scene_indexes[index + 1]:
self._menu[index].turn_on()
else:
self._menu[index].turn_off()
#if self._session._scene_offset >= self._scene_indexes[5]:
# self._menu[5].turn_on
#else:
# self._menu[5].turn_off
def _setup_hilight_knobs(self):
self._dial[15].add_value_listener(self._knob_set_scene, True)
self._dial[14].add_value_listener(self._knob_set_track, True)
def _knob_set_scene(self, value, sender):
all_scenes = self.song().scenes
num_scenes = len(all_scenes)
new_scene = float(value/127.0) * float(num_scenes - 1)
self.song().view.selected_scene = all_scenes[int(new_scene)]
self._session.set_offsets(self._session._track_offset, int(new_scene))
def _knob_set_track(self, value, sender):
#self.log_message(str(value))
all_tracks = self.song().visible_tracks #self.song().tracks
num_tracks = len(self.song().visible_tracks)
new_track = float(value/127.0) * float(num_tracks - 1)
#self.log_message(str(int(new_track)))
#self.log_message(str(value) + str(float(value/127.0)))
self.song().view.selected_track = all_tracks[int(new_track)]
self._session.set_offsets(int(new_track), self._session._scene_offset)
def disconnect(self):
"""clean things up on disconnect"""
for index in range(5):
if self._menu[index].value_has_listener(self._select_new_scene):
self._menu[index].remove_value_listener(self._select_new_scene)
if self._menu[5].value_has_listener(self._select_mode):
self._menu[5].remove_value_listener(self._select_mode)
if self._dial[15].value_has_listener(self._knob_set_scene):
self._dial[15].remove_value_listener(self._knob_set_scene)
if self._dial[15].value_has_listener(self._knob_set_scene):
self._dial[15].remove_value_listener(self._knob_set_scene)
self.song().view.remove_selected_track_listener(self._update_selected_device)
ControlSurface.disconnect(self)
self.log_message(time.strftime("%d.%m.%Y %H:%M:%S", time.localtime()) + "--------------= OhmModes log closed =--------------") #Create entry in log file
return None
def _get_num_tracks(self):
return self.num_tracks
def flash(self):
#if(self.flash_status > 0):
for index in range(6):
if(self._menu[index]._flash_state>0):
self._menu[index].flash(self._timer)
for row in range(8):
if(self._button[row]._flash_state > 0):
self._button[row].flash(self._timer)
for column in range(8):
button = self._grid[column][row]
if(button._flash_state > 0):
button.flash(self._timer)
def strobe(self):
if(self._backlight_type != 'static'):
if(self._backlight_type is 'pulse'):
self._backlight = int(math.fabs(((self._timer * 16) % 64) -32) +32)
if(self._backlight_type is 'up'):
self._backlight = int(((self._timer * 8) % 64) + 16)
if(self._backlight_type is 'down'):
self._backlight = int(math.fabs(int(((self._timer * 8) % 64) - 64)) + 16)
self._send_midi(tuple([176, 27, int(self._backlight)]))
if(self._ohm_type != 'static'):
if(self._ohm_type is 'pulse'):
self._ohm = int(math.fabs(((self._timer * 16) % 64) -32) +32)
if(self._ohm_type is 'up'):
self._ohm = int(((self._timer * 8) % 64) + 16)
if(self._ohm_type is 'down'):
self._ohm = int(math.fabs(int(((self._timer * 8) % 64) - 64)) + 16)
self._send_midi(tuple([176, 63, int(self._ohm)]))
self._send_midi(tuple([176, 31, int(self._ohm)]))
def deassign_matrix(self):
#self._scale_mode.set_mode_buttons(None)
#self._scale_mode.set_enabled(False)
#self._octave_mode.set_mode_buttons(None)
#self._octave_mode.set_enabled(False)
#self._session_zoom.set_button_matrix(None)
#if self._dial[15].has_value_listener(self._knob_set_scene):
# self._dial[15].remove_value_listener(self._knob_set_scene)
#if self._dial[14].has_value_listener(self._knob_set_track):
# self._dial[14].remove_value_listener(self._knob_set_track)
self._session_zoom.set_enabled(False)
self._session_zoom.set_nav_buttons(None, None, None, None)
self._session.set_track_bank_buttons(None, None)
self._session.set_scene_bank_buttons(None, None)
for column in range(7):
self._mixer.channel_strip(column).set_crossfade_toggle(None)
self._mixer.channel_strip(column).set_mute_button(None)
self._mixer.channel_strip(column).set_solo_button(None)
self._mixer.channel_strip(column).set_arm_button(None)
self._mixer.channel_strip(column).set_send_controls(None)
self._mixer.channel_strip(column).set_pan_control(None)
self._mixer.track_eq(column).set_enabled(False)
for row in range(7):
self._scene[row].clip_slot(column).set_launch_button(None)
for column in range(8):
#self._button[column]._on_value = SELECT_COLOR[self._rgb]
for row in range(8):
self._grid[column][row].set_channel(0)
self._grid[column][row].release_parameter()
self._grid[column][row].use_default_message()
self._grid[column][row].set_enabled(True)
self._grid[column][row].send_value(0, True)
self._grid[column][row]._on_value = 127
self._grid[column][row]._off_value = 0
#for index in range(8):
# self._button[index].set_channel(0)
# self._button[index].use_default_message()
# self._button[index].set_enabled(True)
# self._button[index].reset()
#for index in range(6):
# self._menu[index]._on_value = 127
# self._menu[index]._off_value = 0
# self._menu[index].reset()
#for index in range(16):
# self._dial[index].use_default_message()
# self._dial[index].release_parameter()
#self._dial[index].set_enabled(True)
if(self._device._parameter_controls != None):
for control in self._device._parameter_controls:
control.release_parameter()
self._device._parameter_controls = None
self._device_navigator.set_enabled(False)
self._mixer.update()
self._matrix.reset()
"""HH Specific"""
#self._mixer.master_strip().set_select_button(None)
#for column in range(7):
# self._mixer.channel_strip(column).set_select_button(None)
self._session_zoom.set_zoom_button(None)
self._transport.set_play_button(None)
self._transport.set_stop_button(None)
self._device_navigator.set_device_nav_buttons(None, None)
#for index in range(2):
# self._looper[index].find_looper()
def _assign_page_constants(self):
#self._session_zoom.set_zoom_button(self._button[7]) #commented out pn 070111
#self._session_zoom.set_zoom_button(self._grid[7][7]) #added pn 070111
#self._session_zoom.set_button_matrix(self._matrix)
#self._session_zoom.set_enabled(True)
#for column in range(7):
#self._mixer.channel_strip(column).set_select_button(self._button[column])
# self._mixer.channel_strip(column).set_volume_control(self._fader[column])
#self._mixer.master_strip().set_volume_control(self._fader[7])
#for column in range(8):
# self._button[column]._on_value = SELECT_COLOR[self._rgb]
#self._mixer.master_strip().set_select_button(self._button[7]) #added pn 070111
#self._mixer.set_prehear_volume_control(self._dial[15])
#self._transport.set_play_button(self._menu[0])
#self._menu[0].send_value(PLAY_COLOR[self._rgb], True)
#self._menu[0]._on_value = PLAY_COLOR[self._rgb]
#self._transport.set_stop_button(self._menu[1])
#self._menu[1]._off_value = STOP_COLOR[self._rgb]
#self._menu[1]._on_value = STOP_COLOR[self._rgb]
#self._menu[1].send_value(STOP_COLOR[self._rgb], True)
self._livid._on_value = TAP_COLOR[self._rgb]
self._transport.set_tap_tempo_button(self._livid)
#self._livid.send_value(TAP_COLOR, True)
#self._device_navigator.set_device_nav_buttons(self._menu[3], self._menu[4])
for index in range(2):
self._menu[index + 4]._on_value = SESSION_NAV[self._rgb]
self._menu[index * 3]._on_value = SESSION_NAV[self._rgb]
self._session.set_track_bank_buttons(self._menu[5], self._menu[4])
self._session.set_scene_bank_buttons(self._menu[3], self._menu[0])
def assign_page_0(self):
self._backlight_type = 'static'
#self._session_zoom.set_button_matrix(self._matrix)
self._session_zoom.set_enabled(True)
for column in range(7):
#self._grid[column][5]._on_value = MUTE_COLOR[self._rgb]
#self._mixer.channel_strip(column).set_mute_button(self._grid[column][5])
#self._grid[column][6]._on_value = SOLO_COLOR[self._rgb]
#self._mixer.channel_strip(column).set_solo_button(self._grid[column][6])
#self._grid[column][7]._on_value = ARM_COLOR[self._rgb]
#self._mixer.channel_strip(column).set_arm_button(self._grid[column][7])
#self._mixer.channel_strip(column).set_pan_control(self._dial[column + 8])
for row in range(7):
self._scene[row].clip_slot(column).set_launch_button(self._grid[column][row])
#for column in range(4):
# self._mixer.channel_strip(column).set_send_controls(tuple([self._dial[column], self._dial[column + 4]]))
track_stop_buttons = []
for index in range(7):
self._grid[7][index]._off_value = SCENE_LAUNCH_COLOR[self._rgb]
self._scene[index].set_launch_button(self._grid[7][index])
self._grid[index][7]._on_value = TRACK_STOP[self._rgb]
self._grid[index][7]._off_value = TRACK_STOP[self._rgb]
track_stop_buttons.append(self._grid[index][7])
self._session.set_stop_track_clip_buttons(tuple(track_stop_buttons))
self._session.set_stop_all_clips_button(self._grid[7][7])
#for index in range(4):
# self._menu[2 + index]._on_value = NAV_BUTTON_COLOR[self._rgb]
#self._session.set_track_bank_buttons(self._menu[4], self._menu[3])
#self._session.set_scene_bank_buttons(self._menu[5], self._menu[2])
#for index in range(6):
# self._menu[index]._on_value = HHMENU[index][1]
# self._menu[index]._off_value = HHMENU[index][0]
for index in range(8):
self._button[index].set_channel(2)
self._button[index].set_identifier(index)
#self._button[index].reset()
self._button[index].set_enabled(False)
self.request_rebuild_midi_map()
for index in range(7):
self._grid[index][7].turn_on()
for index in range(2):
self._looper[index]._state_change()
self._button[1 + (index * 4)].send_value(3)
self._button[2 + (index * 4)].send_value(6)
self._button[3 + (index * 4)].send_value(1)
def assign_page_1(self):
self._backlight_type = 'pulse'
self._session_zoom.set_enabled(False)
for column in range(4):
for row in range(4):
self._grid[column][row].set_channel(PAGE1_DRUM_CHANNEL)
self._grid[column][row].set_identifier(PAGE1_DRUM_MAP[column][row])
self._grid[column][row].send_value(DRUM_COLOR[self._rgb], True)
self._grid[column][row].set_enabled(False)
self._grid[column + 4][row].set_channel(PAGE1_BASS_CHANNEL)
self._grid[column + 4][row].set_identifier(PAGE1_BASS_MAP[column][row])
self._grid[column + 4][row].send_value(BASS_COLOR[self._rgb], True)
self._grid[column + 4][row].set_enabled(False)
scale_mode_buttons = []
for column in range(8):
for row in range(3):
self._grid[column][row + 4].set_enabled(False)
self._grid[column][row + 4].set_channel(PAGE1_KEYS_CHANNEL)
self._grid[column][row + 4].set_identifier(int(PAGE1_KEYS_MAP[column][row]) + int(PAGE1_MODES_MAP[self._scale_mode._mode_index][column]) + int(self._octave_mode._mode_index * 12))
self._grid[column][row + 4].send_value(KEYS_COLOR[self._rgb], True)
for row in range(1):
scale_mode_buttons.append(self._grid[column][7])
self._scale_mode.set_mode_buttons(tuple(scale_mode_buttons))
self._scale_mode.set_enabled(True)
#self._octave_mode.set_mode_buttons(tuple([self._menu[5], self._menu[2]]))
#self._octave_mode.set_enabled(True)
for column in range(7):
self._mixer.channel_strip(column).set_send_controls(tuple([self._dial[column + 8]]))
#self._button[column].set_on_off_values(REC_ARM, 0)
#self._mixer.channel_strip(column).set_arm_button(self._button[column])
self._device.set_enabled(True)
device_param_controls = []
for index in range(8):
device_param_controls.append(self._dial[index])
self._device.set_parameter_controls(tuple(device_param_controls))
#for index in range(4):
# self._menu[2 + index]._on_value = (DEVICE_NAV_COLOR[self._rgb])
#self._device_navigator.set_enabled(True)
"""HH Specific from Constants"""
#self._mixer.master_strip().set_select_button(self._button[7])
#for column in range(7):
# self._button[column].set_on_off_values(REC_ARM, 0)
#self._session_zoom.set_zoom_button(self._grid[7][7])
#self._transport.set_play_button(self._menu[0])
#self._menu[0].send_value(PLAY_COLOR[self._rgb], True)
#self._menu[0]._on_value = PLAY_COLOR[self._rgb]
#self._transport.set_stop_button(self._menu[1])
#self._menu[1]._off_value = STOP_COLOR[self._rgb]
#self._menu[1]._on_value = STOP_COLOR[self._rgb]
#self._menu[1].send_value(STOP_COLOR[self._rgb], True)
#self._device_navigator.set_device_nav_buttons(self._menu[3], self._menu[4])
for index in range(8):
self._button[index].set_channel(2)
self._button[index].set_identifier(index)
#self._button[index].reset()
self._button[index].set_enabled(False)
self.request_rebuild_midi_map()
#for index in range(8):
# self._grid[index][7].send(self.
for index in range(2):
self._looper[index]._state_change()
self._button[1 + (index * 4)].send_value(3)
self._button[2 + (index * 4)].send_value(6)
self._button[3 + (index * 4)].send_value(1)
def assign_page_2(self):
self._backlight_type = 'up'
#self._session_zoom.set_button_matrix(self._matrix)
self._session_zoom.set_enabled(False)
for column in range(7):
self._grid[column][5]._on_value = MUTE_COLOR[self._rgb]
self._mixer.channel_strip(column).set_mute_button(self._grid[column][5])
self._grid[column][6]._on_value = CROSSFADE_ASSIGN_COLOR[self._rgb]
self._mixer.channel_strip(column).set_crossfade_toggle(self._grid[column][6])
self._grid[column][7].set_channel(2)
self._grid[column][7].set_identifier(column)
self._grid[column][7].reset()
self._grid[column][7].set_enabled(False)
self._grid[column][7].send_value(4, True)
for row in range(5):
self._scene[row].clip_slot(column).set_launch_button(self._grid[column][row])
for row in range(5):
self._grid[7][row]._off_value = SCENE_LAUNCH_COLOR[self._rgb]
self._scene[row].set_launch_button(self._grid[7][row])
for column in range(4):
self._mixer.track_eq(column).set_gain_controls(tuple([self._dial[column + 8], self._dial[column + 4], self._dial[column]]))
self._mixer.track_eq(column).set_enabled(True)
for column in range(3):
self._mixer.channel_strip(column+4).set_pan_control(self._dial[column + 12])
#for index in range(4):
# self._menu[2 + index]._on_value = NAV_BUTTON_COLOR[self._rgb]
#self._session.set_track_bank_buttons(self._menu[4], self._menu[3])
#self._session.set_scene_bank_buttons(self._menu[5], self._menu[2])
self._set_tempo_buttons([self._grid[7][5], self._grid[7][6]])
"""HH Specific from Constants"""
#self._mixer.master_strip().set_select_button(self._button[7])
#for column in range(7):
# self._mixer.channel_strip(column).set_select_button(self._button[column])
#for index in range(8):
# self._button[index].set_on_off_values(SELECT_COLOR[self._rgb], 0)
self._session_zoom.set_zoom_button(self._grid[7][7])
#self._transport.set_play_button(self._menu[0])
#self._menu[0].send_value(PLAY_COLOR[self._rgb], True)
#self._menu[0]._on_value = PLAY_COLOR[self._rgb]
#self._transport.set_stop_button(self._menu[1])
#self._menu[1]._off_value = STOP_COLOR[self._rgb]
#self._menu[1]._on_value = STOP_COLOR[self._rgb]
#self._menu[1].send_value(STOP_COLOR[self._rgb], True)
#self._device_navigator.set_device_nav_buttons(self._menu[3], self._menu[4])
for index in range(8):
self._button[index].set_channel(2)
self._button[index].set_identifier(index)
#self._button[index].reset()
self._button[index].set_enabled(False)
self.request_rebuild_midi_map()
for index in range(2):
self._looper[index]._state_change()
self._button[1 + (index * 4)].send_value(3)
self._button[2 + (index * 4)].send_value(6)
self._button[3 + (index * 4)].send_value(1)
def _update_selected_device(self):
if self._device_selection_follows_track_selection is True:
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.set_device(device_to_select)
self.set_appointed_device(device_to_select)
#self._device_selector.set_enabled(True)
self.request_rebuild_midi_map()
return None
def handle_sysex(self, midi_bytes):
#self.log_message(str('>>sysexIN') + str(midi_bytes))
if len(midi_bytes) > 10:
#self.log_message(str('>>sysex>10') + str(midi_bytes[:11]))
if midi_bytes[:11] == tuple([240, 126, 0, 6, 2, 0, 1, 97, 1, 0, 7]):
self.log_message(str('>>>color detected'))
self._rgb = 1
elif midi_bytes[:11] == tuple([240, 126, 0, 6, 2, 0, 1, 97, 1, 0, 2]):
self.log_message(str('>>>mono detected'))
self._rgb = 0
self._assign_session_colors()
#self._shift_mode.update()
self.deassign_matrix()
self._assign_page_constants()
self.assign_page_0()
#self._setup_hilight_knobs()
for index in range(8):
self._grid[7][index].send_value(SCENE_LAUNCH_COLOR[self._rgb])
for index in range(7):
self._grid[index][7].turn_on()
# def handle_sysex(self, midi_bytes):
# #assert(isinstance (midi_bytes, tuple))
# ##self.log_message(str('sysex') + str(midi_bytes))
# if midi_bytes == tuple([240, 126, 0, 6, 2, 0, 1, 97, 1, 0, 7, 0, 15, 10, 0, 0, 247]):
# self.log_message(str('color detected'))
# self._rgb = 1
# elif midi_bytes == tuple([240, 126, 0, 6, 2, 0, 1, 97, 1, 0, 2, 0, 0, 1, 1, 0, 247]):
# self.log_message(str('mono detected'))
# self._rgb = 0
# self._assign_session_colors()
def receive_midi(self, midi_bytes):
""" Live -> Script
MIDI messages are only received through this function, when explicitly
forwarded in 'build_midi_map'.
"""
assert (midi_bytes != None)
assert isinstance(midi_bytes, tuple)
##self.log_message('got message' + str(midi_bytes))
#self.set_suppress_rebuild_requests(True)
with self.component_guard():
if (len(midi_bytes) is 3):
msg_type = (midi_bytes[0] & 240)
forwarding_key = [midi_bytes[0]]
if (msg_type is not MIDI_PB_TYPE):
forwarding_key.append(midi_bytes[1])
if (tuple(forwarding_key) in self._forwarding_registry.keys()):
recipient = self._forwarding_registry[tuple(forwarding_key)]
if (recipient != None):
recipient.receive_value(midi_bytes[2])
else:
self.log_message(('Got unknown message: ' + str(midi_bytes)))
else:
self.handle_sysex(midi_bytes)
#self.set_suppress_rebuild_requests(False)
def _set_tempo_buttons(self, buttons):
if self._tempo_buttons != None:
self._tempo_buttons[0].remove_value_listener(self._tempo_value)
self._tempo_buttons[1].remove_value_listener(self._tempo_value)
self._tempo_buttons = buttons
if buttons != None:
for button in buttons:
assert isinstance(button, FlashingButtonElement)
self._tempo_buttons[0].set_on_off_values(4, 0)
self._tempo_buttons[0].add_value_listener(self._tempo_value, True)
self._tempo_buttons[1].set_on_off_values(4, 0)
self._tempo_buttons[1].add_value_listener(self._tempo_value, True)
self._tempo_buttons[0].turn_on()
self._tempo_buttons[1].turn_on()
def _tempo_value(self, value, sender):
if (value > 0) and (self._tempo_buttons.index(sender) == 0):
self.song().tempo = round(min((self.song().tempo + 1), 999))
elif (value > 0) and (self._tempo_buttons.index(sender) == 1):
self.song().tempo = round(max((self.song().tempo - 1), 20))
def set_scene_index_value(self, bank_index, scene, track):
bank = int(bank_index)/5
index = int(bank_index)%5
self.log_message('set_scene_index_value' + str(bank) + str(index) + str(scene) + str(track))
#self.log_message( str(type(index)) + str(type(scene)) + str(type(track)))
self._scene_indexes[bank][index][0] = scene
self._scene_indexes[bank][index][1] = track
#self._on_selected_scene_changed()
def connect_script_instances(self, instanciated_scripts):
#link = False
#offsets = [0, 0]
#new_channel = CHAN
for s in instanciated_scripts:
if isinstance(s, APC) or s is self:
#link = True
if not s._session._is_linked():
s._session._link()
#self.log_message('found other linked instance')
#offsets[0] += (int(self._link_offset[0]) * 8)
#offsets[1] += (int(self._link_offset[1]) * 4)
#new_channel += 1
#if link and not self._session._is_linked():
#self._session.set_offsets(offsets[0], offsets[1])
#self._session._link()
#self._set_code_channels(new_channel)
#
#
def __init__(self, session):
SessionZoomingComponent.__init__(self, session)
def _nav_left_value(self, value):
if (not self._ignore_buttons):
SessionZoomingComponent._nav_left_value(self, value)
def _matrix_value(self, value, x, y, is_momentary):
if (not self._ignore_buttons):
SessionZoomingComponent._matrix_value(self, value, x, y, is_momentary)
def _nav_right_value(self, value):
if not self._ignore_buttons:
SessionZoomingComponent._nav_right_value(self, value)
def disconnect(self):
SessionZoomingComponent.disconnect(self)
for button in self._stop_buttons:
button.remove_value_listener(self._stop_value)
def _matrix_value(self, value, x, y, is_momentary):
if not self._ignore_buttons:
SessionZoomingComponent._matrix_value(self, value, x, y,
is_momentary)
class LemurPad(MonOhm):
__module__ = __name__
__doc__ = " Lemur version of the MonOhm companion controller script "
def __init__(self, *a, **k):
self._timer_callbacks = [] #Used for _monobridge, which uses L8 method for registering timer callbacks. deprecated, needs to be replaced by new L9 Task class.
self._osc_registry = {}
self._display_button_names = DISPLAY_BUTTON_NAMES
super(LemurPad, self).__init__(*a, **k)
self._host_name = "LemurPad"
self._color_type = 'AumPad'
self.connected = 0
with self.component_guard():
self._setup_touchosc()
self._assign_host2()
self._assign_session_colors()
def query_ohm(self):
pass
"""script initialization methods"""
def _setup_monobridge(self):
self._monobridge = OSCMonoBridgeElement(self)
self._monobridge.name = 'MonoBridge'
def _setup_controls(self):
is_momentary = True
self._fader = [None for index in range(8)]
self._dial = [None for index in range(16)]
self._button = [None for index in range(8)]
self._menu = [None for index in range(6)]
for index in range(8):
self._fader[index] = OSCMonoEncoderElement(MIDI_CC_TYPE, CHANNEL, OHM_FADERS[index], Live.MidiMap.MapMode.absolute, 'Fader_' + str(index), index, '/Fader_'+str(index)+'/x', '/Strip'+str(index+8)+'/set', '/Strip'+str(index)+'/set', self)
for index in range(8):
self._button[index] = OSCMonoButtonElement(is_momentary, MIDI_NOTE_TYPE, CHANNEL, OHM_BUTTONS[index], 'Button_'+str(index), '/Select_'+str(index)+'/value', '/Select/set '+str(index), '/Select/text '+str(index), self)
for index in range(16):
self._dial[index] = OSCMonoEncoderElement(MIDI_CC_TYPE, CHANNEL, OHM_DIALS[index], Live.MidiMap.MapMode.absolute, 'Dial_' + str(index), index + 8, '/Dial_'+str(index)+'/x', '/Dial'+str(index)+'val/set', '/Dial'+str(index)+'name/set', self)
for index in range(6):
self._menu[index] = OSCMonoButtonElement(is_momentary, MIDI_NOTE_TYPE, CHANNEL, OHM_MENU[index], 'Menu_' + str(index), '/Function_'+str(index)+'/value', '/Function/set '+str(index), '/Function/text '+str(index), self)
self._crossfader = OSCMonoEncoderElement(MIDI_CC_TYPE, CHANNEL, CROSSFADER, Live.MidiMap.MapMode.absolute, "Crossfader", 24, '/XFader/x', '/XFader/none', None, self)
self._livid = OSCMonoButtonElement(is_momentary, MIDI_NOTE_TYPE, CHANNEL, LIVID, 'Livid_Button', '/Livid/x', '/Livid/x', None, self)
self._shift_l = OSCMonoButtonElement(is_momentary, MIDI_NOTE_TYPE, CHANNEL, SHIFT_L, 'Shift_Button_Left', '/ShiftL/x', '/ShiftL/x', None, self)
self._shift_r = OSCMonoButtonElement(is_momentary, MIDI_NOTE_TYPE, CHANNEL, SHIFT_R, 'Shift_Button_Right', '/ShiftR/x', '/ShiftR/x', None, self)
self._matrix = ButtonMatrixElement()
self._matrix.name = 'Matrix'
self._monomod = ButtonMatrixElement()
self._monomod.name = 'Monomod'
self._grid = [None for index in range(8)]
for column in range(8):
self._grid[column] = [None for index in range(8)]
for row in range(8):
self._grid[column][row] = OSCMonoButtonElement(is_momentary, MIDI_NOTE_TYPE, CHANNEL, (column * 8) + row, 'Grid_' + str(column) + '_' + str(row), '/ClipGrid_'+str(column)+'_'+str(row)+'/value', '/ClipGrid/set '+str(column)+' '+str(row), '/ClipGrid/text '+str(column)+' '+str(row), self)
for row in range(5):
button_row = []
for column in range(7):
button_row.append(self._grid[column][row])
self._matrix.add_row(tuple(button_row))
for row in range(8):
button_row = []
for column in range(8):
button_row.append(self._grid[column][row])
self._monomod.add_row(tuple(button_row))
self._dummy_button = ButtonElement(is_momentary, MIDI_NOTE_TYPE, 15, 125)
self._dummy_button.name = 'Dummy1'
self._dummy_button2 = ButtonElement(is_momentary, MIDI_NOTE_TYPE, 15, 126)
self._dummy_button2.name = 'Dummy2'
self._dummy_button3 = ButtonElement(is_momentary, MIDI_NOTE_TYPE, 15, 127)
self._dummy_button2.name = 'Dummy3'
self._monomod256 = ButtonMatrixElement()
self._monomod256.name = 'Monomod256'
self._square = [None for index in range(16)]
for column in range(16):
self._square[column] = [None for index in range(16)]
for row in range(16):
self._square[column][row] = OSCMonoButtonElement(is_momentary, MIDI_NOTE_TYPE, int(column/8) + 1, row + ((column%8) * 16), '256Grid_' + str(column) + '_' + str(row), '/Grid_'+str(column)+'_'+str(row)+'/value', '/Grid/set '+str(column)+' '+str(row), None, self)
#self._square[column][row] = FlashingButtonElement(is_momentary, 0, 15, -1, '256Grid_' + str(column) + '_' + str(row), '/1/p_grid/'+str(column)+'/'+str(row), '/1/c_grid/'+str(column)+'/'+str(row), self)
for row in range(16):
button_row = []
for column in range(16):
button_row.append(self._square[column][row])
self._monomod256.add_row(tuple(button_row))
self._bank_buttons = ButtonMatrixElement()
self._key_buttons = ButtonMatrixElement()
self._bank_button = [None for index in range(2)]
for index in range(2):
self._bank_button[index] = OSCMonoButtonElement(is_momentary, MIDI_NOTE_TYPE, 15, index, '256Grid_Bank_' + str(index), '/Shift_'+str(index)+'/value', '/Shift/set '+str(index), None, self)
button_row = []
for index in range(2):
button_row.append(self._bank_button[index])
self._bank_buttons.add_row(tuple(button_row))
button_row = []
self._key_button = [None for index in range(8)]
for index in range(8):
self._key_button[index] = OSCMonoButtonElement(is_momentary, MIDI_NOTE_TYPE, 15, index+8, '256Grid_Key_' + str(index), '/Keys_'+str(index)+'/value', '/Keys/set '+str(index), None, self)
for index in range(8):
button_row.append(self._key_button[index])
self._key_buttons.add_row(tuple(button_row))
self._pedal = [None for index in range(8)]
if self._use_pedal is True:
for index in range(8):
self._pedal[index] = EncoderElement(MIDI_CC_TYPE, 0, 25+index, Live.MidiMap.MapMode.absolute)
self._pedal[index].name = 'Pedal_'+str(index)
self._pedal[index]._report = False
def _setup_session_control(self):
is_momentary = True
num_tracks = 4
num_scenes = 5
self._session = NameServerSessionComponent(num_tracks, num_scenes, self)
self._session.name = "Left_Session"
self._session.set_offsets(0, 0)
self._session.set_stop_clip_value(self._color_defs['STOP_CLIP'])
self._scene = [None for index in range(5)]
for row in range(num_scenes):
self._scene[row] = self._session.scene(row)
self._scene[row].name = 'L_Scene_' + str(row)
for column in range(num_tracks):
clip_slot = self._scene[row].clip_slot(column)
clip_slot.name = str(column) + '_Clip_Slot_L_' + str(row)
clip_slot.set_triggered_to_play_value(self._color_defs['CLIP_TRG_PLAY'])
clip_slot.set_triggered_to_record_value(self._color_defs['CLIP_TRG_REC'])
clip_slot.set_stopped_value(self._color_defs['CLIP_STOP'])
clip_slot.set_started_value(self._color_defs['CLIP_STARTED'])
clip_slot.set_recording_value(self._color_defs['CLIP_RECORDING'])
self._session.set_mixer(self._mixer)
self._session_zoom = SessionZoomingComponent(self._session)
self._session_zoom.name = 'L_Session_Overview'
self._session_zoom.set_stopped_value(self._color_defs['ZOOM_STOPPED'])
self._session_zoom.set_playing_value(self._color_defs['ZOOM_PLAYING'])
self._session_zoom.set_selected_value(self._color_defs['ZOOM_SELECTED'])
self._session_zoom._zoom_button = (self._dummy_button)
self._session_zoom.set_enabled(True)
self._session2 = SessionComponent(num_tracks, num_scenes)
self._session2.name = 'Right_Session'
self._session2.set_offsets(4, 0)
self._session2.set_stop_clip_value(self._color_defs['STOP_CLIP'])
self._scene2 = [None for index in range(5)]
for row in range(num_scenes):
self._scene2[row] = self._session2.scene(row)
self._scene2[row].name = 'R_Scene_' + str(row)
for column in range(num_tracks):
clip_slot = self._scene2[row].clip_slot(column)
clip_slot.name = str(column) + '_Clip_Slot_R_' + str(row)
clip_slot.set_triggered_to_play_value(self._color_defs['CLIP_TRG_PLAY'])
clip_slot.set_triggered_to_record_value(self._color_defs['CLIP_TRG_REC'])
clip_slot.set_stopped_value(self._color_defs['CLIP_STOP'])
clip_slot.set_started_value(self._color_defs['CLIP_STARTED'])
clip_slot.set_recording_value(self._color_defs['CLIP_RECORDING'])
self._session2.set_mixer(self._mixer2)
self._session2.add_offset_listener(self._on_session_offset_changes)
self._session_zoom2 = SessionZoomingComponent(self._session2)
self._session_zoom2.name = 'R_Session_Overview'
self._session_zoom2.set_stopped_value(self._color_defs['ZOOM_STOPPED'])
self._session_zoom2.set_playing_value(self._color_defs['ZOOM_PLAYING'])
self._session_zoom2.set_selected_value(self._color_defs['ZOOM_SELECTED'])
self._session_zoom.set_enabled(True)
self._session_zoom2._zoom_button = (self._dummy_button2)
self._session_main = SessionComponent(8, num_scenes)
self._session_main.name = 'Main_Session'
self._session_main.set_stop_clip_value(self._color_defs['STOP_CLIP'])
self._scene_main = [None for index in range(5)]
for row in range(num_scenes):
self._scene_main[row] = self._session_main.scene(row)
self._scene_main[row].name = 'M_Scene_' + str(row)
for column in range(8):
clip_slot = self._scene_main[row].clip_slot(column)
clip_slot.name = str(column) + '_Clip_Slot_M_' + str(row)
clip_slot.set_triggered_to_play_value(self._color_defs['CLIP_TRG_PLAY'])
clip_slot.set_triggered_to_record_value(self._color_defs['CLIP_TRG_REC'])
clip_slot.set_stopped_value(self._color_defs['CLIP_STOP'])
clip_slot.set_started_value(self._color_defs['CLIP_STARTED'])
clip_slot.set_recording_value(self._color_defs['CLIP_RECORDING'])
self._session_main.set_mixer(self._mixer)
self._session_zoom_main = SessionZoomingComponent(self._session_main)
self._session_zoom_main.name = 'M_Session_Overview'
self._session_zoom_main.set_stopped_value(self._color_defs['ZOOM_STOPPED'])
self._session_zoom_main.set_playing_value(self._color_defs['ZOOM_PLAYING'])
self._session_zoom_main.set_selected_value(self._color_defs['ZOOM_SELECTED'])
self._session_zoom_main.set_enabled(True)
self._session_zoom_main._zoom_button = (self._dummy_button3)
self._sessions = [self._session, self._session2, self._session_main]
self._zooms = [self._session_zoom, self._session_zoom2, self._session_zoom_main]
def _setup_monomod(self):
self._host = MonomodComponent(self)
self._host.name = 'Monomod_Host'
self._host2 = SpecialMonomodComponent(self)
self._host2.name = '256_Monomod_Host'
self.hosts = [self._host, self._host2]
def _assign_host2(self):
self._host2._set_shift_button(self._bank_button[0])
self._host2._set_alt_button(self._bank_button[1])
self._host2._set_button_matrix(self._monomod256)
self._host2._set_key_buttons(self._key_button)
self._host2.set_enabled(True)
def _setup_touchosc(self):
self._osc_registry = {}
#self._osc_registry['/ping'] = self._monobridge.ping
#self._osc_registry['/1'] = self._monobridge.page1
#self._osc_registry['/2'] = self._monobridge.page2
for control in self.controls:
if hasattr(control, 'osc'):
self._osc_registry[control.osc] = control.set_value
#if hasattr(control, 'osc_alt'):
# self._osc_registry[control.osc_alt] = control.set_value
#self.log_message('create dict key: ' + str(control.osc) + str(control.name))
"""shift/zoom methods"""
def deassign_matrix(self):
super(LemurPad, self).deassign_matrix()
self.clear_grid_names()
"""menu button management methods"""
def deassign_menu(self):
super(LemurPad, self).deassign_menu()
for index in range(6):
self._monobridge._send_osc(self._menu[index].osc_name, self.generate_strip_string(' '))
def assign_device_nav_to_menu(self):
super(LemurPad, self).assign_device_nav_to_menu()
for index in range(6):
self._monobridge._send_osc(self._menu[index].osc_name, self.generate_strip_string(str(DEVICE_NAV_NAMES[index])))
def assign_transport_to_menu(self):
super(LemurPad, self).assign_transport_to_menu()
for index in range(6):
self._monobridge._send_osc(self._menu[index].osc_name, self.generate_strip_string(str(TRANSPORT_NAMES[index])))
def assign_session_nav_to_menu(self):
super(LemurPad, self).assign_session_nav_to_menu()
for index in range(6):
self._monobridge._send_osc(self._menu[index].osc_name, self.generate_strip_string(str(SESSION_NAV_NAMES[index])))
def assign_session_main_nav_to_menu(self):
super(LemurPad, self).assign_session_main_nav_to_menu()
for index in range(6):
self._monobridge._send_osc(self._menu[index].osc_name, self.generate_strip_string(str(SESSION_NAV_NAMES[index])))
def assign_monomod_shift_to_menu(self):
super(LemurPad, self).assign_monomod_shift_to_menu()
for index in range(6):
self._monobridge._send_osc(self._menu[index].osc_name, self.generate_strip_string(str(MONOMOD_SHIFT_NAMES[index])))
def assign_monomod_to_menu(self):
super(LemurPad, self).assign_monomod_shift_to_menu()
for index in range(6):
self._monobridge._send_osc(self._menu[index].osc_name, self.generate_strip_string(str(MONOMOD_NAMES[index])))
def assign_session_bank_to_menu(self):
super(LemurPad, self).assign_session_bank_to_menu()
for index in range(6):
self._monobridge._send_osc(self._menu[index].osc_name, self.generate_strip_string(str(SESSION_BANK_NAMES[index])))
def assign_session2_bank_to_menu(self):
super(LemurPad, self).assign_session2_bank_to_menu()
for index in range(6):
self._monobridge._send_osc(self._menu[index].osc_name, self.generate_strip_string(str(SESSION_BANK2_NAMES[index])))
def assign_session_main_nav_to_menu(self):
super(LemurPad, self).assign_session_main_nav_to_menu()
for index in range(6):
self._monobridge._send_osc(self._menu[index].osc_name, self.generate_strip_string(str(SESSION_MAIN_BANK_NAMES[index])))
"""m4l bridge"""
def generate_strip_string(self, display_string):
NUM_CHARS_PER_DISPLAY_STRIP = 9
if (not display_string):
return ('`_')
if ((len(display_string.strip()) > (NUM_CHARS_PER_DISPLAY_STRIP - 1)) and (display_string.endswith('dB') and (display_string.find('.') != -1))):
display_string = display_string[:-2]
if (len(display_string) > (NUM_CHARS_PER_DISPLAY_STRIP - 1)):
for um in [' ',
'i',
'o',
'u',
'e',
'a']:
while ((len(display_string) > (NUM_CHARS_PER_DISPLAY_STRIP - 1)) and (display_string.rfind(um, 1) != -1)):
um_pos = display_string.rfind(um, 1)
display_string = (display_string[:um_pos] + display_string[(um_pos + 1):])
else:
display_string = display_string.center((NUM_CHARS_PER_DISPLAY_STRIP - 1))
ret = u''
for i in range((NUM_CHARS_PER_DISPLAY_STRIP - 1)):
if ((ord(display_string[i]) > 127) or (ord(display_string[i]) < 0)):
ret += ' '
else:
ret += display_string[i]
ret += ' '
assert (len(ret) == NUM_CHARS_PER_DISPLAY_STRIP)
return '`' + ret.replace(' ', '_')
def notification_to_bridge(self, name, value, sender):
if(isinstance(sender, MonoEncoderElement2)):
#self.log_message(str(name) + str(value) + str(sender.num))
self._monobridge._send('lcd_name', sender.name, self.generate_strip_string(str(name)))
self._monobridge._send('lcd_value', sender.name, self.generate_strip_string(str(value)))
def clip_name(self, sender, name):
#self.log_message('clip name ' + str(sender.osc_name) + ' ' + str(self.generate_strip_string(str(name))))
self._monobridge._send_osc(sender.osc_name, self.generate_strip_string(str(name)))
"""def get_clip_names(self):
clip_names = []
for scene in self._session._scenes:
for clip_slot in scene._clip_slots:
if clip_slot.has_clip():
clip_names.append(clip_slot._clip_slot)##.clip.name)
#return clip_slot._clip_slot
#self.log_message('clip name' + str(clip_slot._clip_slot.clip.name))
return clip_names"""
"""called on timer"""
def update_display(self):
super(LemurPad, self).update_display()
for callback in self._timer_callbacks:
callback()
def flash(self):
if(self.flash_status > 0):
for control in self.controls:
if isinstance(control, MonoButtonElement):
control.flash(self._timer)
def strobe(self):
pass
"""general functionality"""
def disconnect(self):
super(MonOhm, self).disconnect()
def clear_grid_names(self):
#self.log_message('clear grid names' + str(self))
for column in range(8):
for row in range(8):
self._monobridge._send_osc(self._grid[column][row].osc_name, '`_')
def _register_timer_callback(self, callback):
""" Registers a callback that is triggerd on every call of update_display """
assert (callback != None)
assert (dir(callback).count('im_func') is 1)
assert (self._timer_callbacks.count(callback) == 0)
self._timer_callbacks.append(callback)
return None
def _unregister_timer_callback(self, callback):
""" Unregisters a timer callback """
assert (callback != None)
assert (dir(callback).count('im_func') is 1)
assert (self._timer_callbacks.count(callback) == 1)
self._timer_callbacks.remove(callback)
return None
def _set_brightness(self, value):
#self._bright = (value != 0)
#for control in self.controls:
# if isinstance(control, OSCMonoButtonElement):
# self._monobridge._send_osc(control.osc_alt, int(self._bright), True)
pass
def reset(self):
#self._monobridge._send_osc('/reset')
for control in self.controls:
control.reset()
def assign_lower_grid_names(self, mode):
if self._display_button_names is True:
for column in range(8):
for row in range(3):
self._monobridge._send_osc(self._grid[column][row+5].osc_name, self.generate_strip_string(str(GRID_NAMES[mode][row][column])))
def reset_and_refresh_state(self, *a, **k):
self.schedule_message(1, self.reset)
self.schedule_message(2, self.refresh_state)
def _setup_session_control(self):
is_momentary = True
num_tracks = 4
num_scenes = 5
self._session = NameServerSessionComponent(num_tracks, num_scenes,
self)
self._session.name = "Left_Session"
self._session.set_offsets(0, 0)
self._session.set_stop_clip_value(self._color_defs['STOP_CLIP'])
self._scene = [None for index in range(5)]
for row in range(num_scenes):
self._scene[row] = self._session.scene(row)
self._scene[row].name = 'L_Scene_' + str(row)
for column in range(num_tracks):
clip_slot = self._scene[row].clip_slot(column)
clip_slot.name = str(column) + '_Clip_Slot_L_' + str(row)
clip_slot.set_triggered_to_play_value(
self._color_defs['CLIP_TRG_PLAY'])
clip_slot.set_triggered_to_record_value(
self._color_defs['CLIP_TRG_REC'])
clip_slot.set_stopped_value(self._color_defs['CLIP_STOP'])
clip_slot.set_started_value(self._color_defs['CLIP_STARTED'])
clip_slot.set_recording_value(
self._color_defs['CLIP_RECORDING'])
self._session.set_mixer(self._mixer)
self._session_zoom = SessionZoomingComponent(self._session)
self._session_zoom.name = 'L_Session_Overview'
self._session_zoom.set_stopped_value(self._color_defs['ZOOM_STOPPED'])
self._session_zoom.set_playing_value(self._color_defs['ZOOM_PLAYING'])
self._session_zoom.set_selected_value(
self._color_defs['ZOOM_SELECTED'])
self._session_zoom._zoom_button = (self._dummy_button)
self._session_zoom.set_enabled(True)
self._session2 = SessionComponent(num_tracks, num_scenes)
self._session2.name = 'Right_Session'
self._session2.set_offsets(4, 0)
self._session2.set_stop_clip_value(self._color_defs['STOP_CLIP'])
self._scene2 = [None for index in range(5)]
for row in range(num_scenes):
self._scene2[row] = self._session2.scene(row)
self._scene2[row].name = 'R_Scene_' + str(row)
for column in range(num_tracks):
clip_slot = self._scene2[row].clip_slot(column)
clip_slot.name = str(column) + '_Clip_Slot_R_' + str(row)
clip_slot.set_triggered_to_play_value(
self._color_defs['CLIP_TRG_PLAY'])
clip_slot.set_triggered_to_record_value(
self._color_defs['CLIP_TRG_REC'])
clip_slot.set_stopped_value(self._color_defs['CLIP_STOP'])
clip_slot.set_started_value(self._color_defs['CLIP_STARTED'])
clip_slot.set_recording_value(
self._color_defs['CLIP_RECORDING'])
self._session2.set_mixer(self._mixer2)
self._session2.add_offset_listener(self._on_session_offset_changes)
self._session_zoom2 = SessionZoomingComponent(self._session2)
self._session_zoom2.name = 'R_Session_Overview'
self._session_zoom2.set_stopped_value(self._color_defs['ZOOM_STOPPED'])
self._session_zoom2.set_playing_value(self._color_defs['ZOOM_PLAYING'])
self._session_zoom2.set_selected_value(
self._color_defs['ZOOM_SELECTED'])
self._session_zoom.set_enabled(True)
self._session_zoom2._zoom_button = (self._dummy_button2)
self._session_main = SessionComponent(8, num_scenes)
self._session_main.name = 'Main_Session'
self._session_main.set_stop_clip_value(self._color_defs['STOP_CLIP'])
self._scene_main = [None for index in range(5)]
for row in range(num_scenes):
self._scene_main[row] = self._session_main.scene(row)
self._scene_main[row].name = 'M_Scene_' + str(row)
for column in range(8):
clip_slot = self._scene_main[row].clip_slot(column)
clip_slot.name = str(column) + '_Clip_Slot_M_' + str(row)
clip_slot.set_triggered_to_play_value(
self._color_defs['CLIP_TRG_PLAY'])
clip_slot.set_triggered_to_record_value(
self._color_defs['CLIP_TRG_REC'])
clip_slot.set_stopped_value(self._color_defs['CLIP_STOP'])
clip_slot.set_started_value(self._color_defs['CLIP_STARTED'])
clip_slot.set_recording_value(
self._color_defs['CLIP_RECORDING'])
self._session_main.set_mixer(self._mixer)
self._session_zoom_main = SessionZoomingComponent(self._session_main)
self._session_zoom_main.name = 'M_Session_Overview'
self._session_zoom_main.set_stopped_value(
self._color_defs['ZOOM_STOPPED'])
self._session_zoom_main.set_playing_value(
self._color_defs['ZOOM_PLAYING'])
self._session_zoom_main.set_selected_value(
self._color_defs['ZOOM_SELECTED'])
self._session_zoom_main.set_enabled(True)
self._session_zoom_main._zoom_button = (self._dummy_button3)
self._sessions = [self._session, self._session2, self._session_main]
self._zooms = [
self._session_zoom, self._session_zoom2, self._session_zoom_main
]
class APC40plus22(APC):
__doc__ = " Script for Akai's APC40 Controller with extra features added "
def __init__(self, c_instance):
self._c_instance = c_instance
self._shift_modes = None #added from APC20 script
self._encoder_modes = None #added
self._slider_modes = None #added
APC.__init__(self, c_instance)
self.show_message("APC40_22 script loaded")
# Disabling the scene launch buttons and assigning them to the first 5 repeats on Master
self._device_buttons = []
self.setup_device_buttons()
def disconnect(self): #this is from the APC20 script
for button in self._device_buttons:
button.remove_value_listener(self._device_toggle)
self._device_buttons = None
self._shift_modes = None
self._encoder_modes = None
self._slider_modes = None
APC.disconnect(self)
def setup_device_buttons(self):
repeat = RepeatComponent(self)
repeat.set_shift_button(self._shift_button)
def _setup_session_control(self):
is_momentary = True
self._shift_button = ButtonElement(is_momentary, MIDI_NOTE_TYPE, 0, 98)
right_button = ButtonElement(is_momentary, MIDI_NOTE_TYPE, 0, 96)
left_button = ButtonElement(is_momentary, MIDI_NOTE_TYPE, 0, 97)
up_button = ButtonElement(is_momentary, MIDI_NOTE_TYPE, 0, 94)
down_button = ButtonElement(is_momentary, MIDI_NOTE_TYPE, 0, 95)
right_button.name = 'Bank_Select_Right_Button'
left_button.name = 'Bank_Select_Left_Button'
up_button.name = 'Bank_Select_Up_Button'
down_button.name = 'Bank_Select_Down_Button'
self._session = PedaledSessionComponent(8, 5)
self._session.name = 'Session_Control'
self._session.set_track_bank_buttons(right_button, left_button)
self._session.set_scene_bank_buttons(down_button, up_button)
self._matrix = ButtonMatrixElement() #was: matrix = ButtonMatrixElement()
self._matrix.name = 'Button_Matrix' #was: matrix.name = 'Button_Matrix'
scene_launch_buttons = [ ButtonElement(is_momentary, MIDI_NOTE_TYPE, 0, (index + 82)) for index in range(5) ]
#self._track_stop_buttons = [ ButtonElement(is_momentary, MIDI_NOTE_TYPE, index, 52) for index in range(8) ]
self._track_stop_buttons = [ ConfigurableButtonElement(is_momentary, MIDI_NOTE_TYPE, index, 52) for index in range(8) ]
for index in range(len(scene_launch_buttons)):
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'
stop_all_button = ButtonElement(is_momentary, MIDI_NOTE_TYPE, 0, 81)
stop_all_button.name = 'Stop_All_Clips_Button'
self._session.set_stop_all_clips_button(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(scene_launch_buttons[scene_index])
scene.set_triggered_value(2)
for track_index in range(8):
#button = ButtonElement(is_momentary, MIDI_NOTE_TYPE, track_index, (scene_index + 53))
button = ConfigurableButtonElement(is_momentary, MIDI_NOTE_TYPE, track_index, (scene_index + 53)) #use Launchpad configurable button instead
button.name = str(track_index) + '_Clip_' + str(scene_index) + '_Button'
button_row.append(button)
clip_slot = scene.clip_slot(track_index)
clip_slot.name = str(track_index) + '_Clip_Slot_' + str(scene_index)
clip_slot.set_triggered_to_play_value(2)
clip_slot.set_triggered_to_record_value(4)
clip_slot.set_stopped_value(3)
clip_slot.set_started_value(1)
clip_slot.set_recording_value(5)
clip_slot.set_launch_button(button)
self._matrix.add_row(tuple(button_row)) #matrix.add_row(tuple(button_row))
# Removing the launch selected clip footpedal option
#self._session.set_slot_launch_button(ButtonElement(is_momentary, MIDI_CC_TYPE, 0, 67))
self._session.selected_scene().name = 'Selected_Scene'
self._session.selected_scene().set_launch_button(ButtonElement(is_momentary, MIDI_CC_TYPE, 0, 64))
self._session_zoom = SessionZoomingComponent(self._session) #use APC20 Zooming instead
self._session_zoom.name = 'Session_Overview'
self._session_zoom.set_button_matrix(self._matrix) #was: self._session_zoom.set_button_matrix(matrix)
self._session_zoom.set_zoom_button(self._shift_button) #set in MatrixModesComponent instead
self._session_zoom.set_nav_buttons(up_button, down_button, left_button, right_button)
self._session_zoom.set_scene_bank_buttons(tuple(scene_launch_buttons))
self._session_zoom.set_stopped_value(3)
self._session_zoom.set_selected_value(5)
return None
def _setup_mixer_control(self):
is_momentary = True
self._mixer = SpecialMixerComponent(self, 8) #added self for parent
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) #set in ShiftableSelectorComponent instead if used for Note Mode
self._mixer.selected_strip().name = 'Selected_Channel_Strip'
select_buttons = [] #added
arm_buttons = [] #added
sliders = [] #added
for track in range(8):
strip = self._mixer.channel_strip(track)
strip.name = 'Channel_Strip_' + str(track)
#volume_control = SliderElement(MIDI_CC_TYPE, track, 7) #set in ShiftableSelectorComponent instead
#arm_button = ButtonElement(is_momentary, MIDI_NOTE_TYPE, track, 48) #see below
solo_button = ButtonElement(is_momentary, MIDI_NOTE_TYPE, track, 49)
solo_button.name = str(track) + '_Solo_Button'
strip.set_solo_button(solo_button)
if track < 4:
mute_button = ButtonElement(is_momentary, MIDI_NOTE_TYPE, track, 50)
mute_button.name = str(track) + '_Mute_Button'
strip.set_mute_button(mute_button)
strip.set_invert_mute_feedback(True)
strip.set_shift_button(self._shift_button)
select_buttons.append(ButtonElement(is_momentary, MIDI_NOTE_TYPE, track, 51)) #added
select_buttons[-1].name = str(track) + '_Select_Button' #added
#strip.set_select_button(select_buttons[-1]) #added
arm_buttons.append(ButtonElement(is_momentary, MIDI_NOTE_TYPE, track, 48)) #added
arm_buttons[-1].name = str(track) + '_Arm_Button' #added
sliders.append(SliderElement(MIDI_CC_TYPE, track, 7)) #added
sliders[-1].name = str(track) + '_Volume_Control' #added
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' #not used in APC20
master_volume_control.name = 'Master_Volume_Control'
self._prehear_control.name = 'Prehear_Volume_Control'
self._mixer.set_shift_button(self._shift_button) #added for shifting prehear
self._mixer.set_crossfader_control(self._crossfader) #not used in APC20
self._mixer.set_prehear_volume_control(self._prehear_control) #functionality overridden in SpecialMixerComponent
self._mixer.master_strip().set_volume_control(master_volume_control)
self._slider_modes = SliderModesComponent(self._mixer, tuple(sliders)) #added from APC20 script
self._slider_modes.name = 'Slider_Modes' #added from APC20 script
matrix_modes = MatrixModesComponent(self._matrix, self._session, self._session_zoom, tuple(self._track_stop_buttons), self) #added new
matrix_modes.name = 'Matrix_Modes' #added new
# Original method args for ShiftableSelectorComponent: (self, select_buttons, master_button, arm_buttons, matrix, session, zooming, mixer, transport, slider_modes, mode_callback)
#self._shift_modes = ShiftableSelectorComponent(tuple(select_buttons), master_select_button, tuple(arm_buttons), self._matrix, self._session, self._session_zoom, self._mixer, transport, slider_modes, self._send_introduction_message)
self._shift_modes = ShiftableSelectorComponent(self, tuple(select_buttons), master_select_button, tuple(arm_buttons), self._matrix, self._session, self._session_zoom, self._mixer, self._slider_modes, matrix_modes) #, self._send_introduction_message) #also added self for _parent
self._shift_modes.name = 'Shift_Modes'
self._shift_modes.set_mode_toggle(self._shift_button)
def _setup_custom_components(self):
self._setup_looper_control()
self._setup_device_and_transport_control()
self._setup_global_control()
def _setup_looper_control(self):
is_momentary = True
#pedal = ButtonElement(is_momentary, MIDI_CC_TYPE, 0, 67)
loop_on = ButtonElement(is_momentary, MIDI_NOTE_TYPE, 4, 50)
loop_start = ButtonElement(is_momentary, MIDI_NOTE_TYPE, 5, 50)
halve = ButtonElement(is_momentary, MIDI_NOTE_TYPE, 6, 50)
double = ButtonElement(is_momentary, MIDI_NOTE_TYPE, 7, 50)
looper = LooperComponent(self)
looper.set_shift_button(self._shift_button)
looper.set_loop_toggle_button(loop_on)
looper.set_loop_start_button(loop_start)
looper.set_loop_double_button(double)
looper.set_loop_halve_button(halve)
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', 'Device_Lock_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) #added from Axiom DirectLink example
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 = DetailViewControllerComponent()
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) #shifted nudge
transport.set_redo_button(nudge_up_button) #shifted nudge
transport.set_tap_tempo_button(tap_tempo_button)
self._device.set_lock_button(tap_tempo_button) #shifted tap tempo
transport.set_quant_toggle_button(device_bank_buttons[5])
transport.set_overdub_button(device_bank_buttons[6])
transport.set_metronome_button(device_bank_buttons[7])
transport.set_tempo_encoder(self._prehear_control) #shifted prehear
bank_button_translator = ShiftableTranslatorComponent()
bank_button_translator.set_controls_to_translate(tuple(device_bank_buttons))
bank_button_translator.set_shift_button(self._shift_button)
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))#(not is_momentary, MIDI_NOTE_TYPE, 0, 87 + index))
self._global_bank_buttons[-1].name = global_bank_labels[index]
self._encoder_modes = EncoderMixerModeSelectorComponent(self._mixer)
self._encoder_modes.name = 'Track_Control_Modes'
#self._encoder_modes.set_modes_buttons(self._global_bank_buttons) # set in ShiftableEncoderSelectorComponent
self._encoder_modes.set_controls(tuple(self._global_param_controls))
#self._encoder_device_modes = EncoderDeviceModeSelectorComponent(self._mixer, self._device) #new
self._encoder_device_modes = EncoderDeviceComponent(self._mixer, self._device, self)
self._encoder_device_modes.name = 'Alt_Device_Control_Modes' #new
self._encoder_eq_modes = EncoderEQComponent(self._mixer, self)#EncoderEQModeSelectorComponent(self._mixer) #new
self._encoder_eq_modes.name = 'EQ_Control_Modes' #new
global_translation_selector = ChannelTranslationSelector() #translate track encoders to channels 1 through 4, based on button selection (pan = 1, send A = 2, send B = 3, send C = 4)
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) #self._mixer, tuple(sliders)) #added
encoder_user_modes.name = 'Encoder_User_Modes' #added
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) #tuple(select_buttons), master_select_button, tuple(arm_buttons), self._matrix, self._session, self._session_zoom, self._mixer, slider_modes, matrix_modes) #, self._send_introduction_message) #also added self for _parent
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)
#self._slider_modes.update() #added to update alternate slider assignments
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
def _scene_bank_value(self, value, sender):
if not self._ignore_buttons:
SessionZoomingComponent._scene_bank_value(self, value, sender)
def __init__(self, session):
SessionZoomingComponent.__init__(self, session)
class code(ControlSurface):
__module__ = __name__
__doc__ = " Code controller script "
def __init__(self, c_instance):
ControlSurface.__init__(self, c_instance)
with self.component_guard():
self.log_message(time.strftime("%d.%m.%Y %H:%M:%S", time.localtime()) + "--------------= Code opened =--------------") # Writes message into Live's main log file. This is a ControlSurface method.
self._send_midi(factoryreset)
self._send_midi(btn_channels)
self._send_midi(enc_channels)
#self.set_suppress_rebuild_requests(True) # Turn off rebuild MIDI map until after we're done setting up
self._setup_controls()
self._setup_device_controls()
self._setup_mixer_control() # Setup the mixer object
self._setup_transport_control()
self._setup_session_control() # Setup the session object - do this last
self._setup_modes()
#self.set_suppress_rebuild_requests(False) # Turn rebuild back on, once we're done setting up
##self.assign_page_2()
def handle_sysex(self, midi_bytes):
self._send_midi(tuple([240, 00, 01, 97, 04, 15, 01, 247]))
#response = [long(0),long(0)]
#self.log_message(str(response))
def _setup_controls(self):
is_momentary = True
self._dial = [None for index in range(DIALCOUNT)]
self._trackbtns = [None for index in range(8)]
self._modebtns = [None for index in range(5)]
for index in range(DIALCOUNT):
self._dial[index] = EncoderElement(MIDI_CC_TYPE, CH, matrix_nums[index], Live.MidiMap.MapMode.absolute)
self._dial[index].name = 'Dial_' + str(index)
self._dial[index].set_feedback_delay(-1)
for index in range(8):
self._trackbtns[index] = ButtonElement(is_momentary, MIDI_NOTE_TYPE, CH, track_select_notes[index])
self._trackbtns[index].name = 'Button_' + str(index)
for index in range(5):
self._modebtns[index] = ButtonElement(is_momentary, MIDI_NOTE_TYPE, CH, mode_select_notes[index])
self._modebtns[index].name = 'ModeButton_' + str(index)
self._matrix = ButtonMatrixElement()
self._matrix.name = 'Matrix'
self._grid = [None for index in range(COLS)]
for column in range(COLS):
self._grid[column] = [None for index in range(COLS)]
for row in range(ROWS):
nn = 1+(column * ROWS) + row
self._grid[column][row] = ButtonElement(is_momentary, MIDI_NOTE_TYPE, CH, nn) #comment out if you don't want clip launch
self._grid[column][row].name = 'Grid_' + str(column) + '_' + str(row)
for row in range(ROWS):
button_row = []
for column in range(COLS):
button_row.append(self._grid[column][row])
self._matrix.add_row(tuple(button_row))
""" not sure about this bit, but somehow I'll need to set up the modes here...!"""
def _setup_modes(self):
self._shift_mode = ShiftModeComponent(self, tuple(button for button in self._modebtns))
self._shift_mode.name = 'Mix_Mode' #mode 1
#self._shift_mode.set_mode_buttons(self._modebtns)
def _setup_transport_control(self):
self._transport = TransportComponent()
self._transport.name = 'Transport'
def _setup_mixer_control(self):
is_momentary = True
self._num_tracks = (COLS)
global mixer
mixer = MixerComponent(COLS, 0, True, True)
mixer.name = 'Mixer'
self._mixer = mixer
mixer.set_track_offset(0) #Sets start point for mixer strip (offset from left)
for index in range(COLS):
#use the bottom row of encoders for volume, so add 24 to offset the index
mixer.channel_strip(index).set_volume_control(self._dial[index+24])
for index in range(COLS):
mixer.channel_strip(index).name = 'Mixer_ChannelStrip_' + str(index)
mixer.track_eq(index).name = 'Mixer_EQ_' + str(index)
mixer.track_filter(index).name = 'Mixer_Filter_' + str(index) #added by a
mixer.channel_strip(index)._invert_mute_feedback = True
#mixer.channel_strip(index).set_select_button(ButtonElement(is_momentary, MIDI_NOTE_TYPE, CH, track_select_notes[index]))
self.song().view.selected_track = mixer.channel_strip(0)._track #set the selected strip to the first track, so that we don't, for example, try to assign a button to arm the master track, which would cause an assertion error
""" Technically, we aren't using the session control, but I'm going to set it up in case inter-script communication needs it"""
def _setup_session_control(self):
is_momentary = True
num_tracks = COLS
num_scenes = ROWS
global session
session = SessionComponent(num_tracks, num_scenes)
session.name = "Session"
session.set_offsets(0, 0)
self._session = session
self._session.set_stop_track_clip_value(0)
self._scene = [None for index in range(ROWS)]
for row in range(num_scenes):
self._scene[row] = session.scene(row)
self._scene[row].name = 'Scene_' + str(row)
for column in range(num_tracks):
clip_slot = self._scene[row].clip_slot(column)
clip_slot.name = str(column) + '_Clip_Slot_' + str(row)
clip_slot.set_triggered_to_play_value(64)
clip_slot.set_triggered_to_record_value(64)
clip_slot.set_stopped_value(0)
clip_slot.set_started_value(64)
clip_slot.set_recording_value(64)
#clip_slot.set_launch_button(self._grid[column][row]) #comment out if you don't want clip launch
session.set_mixer(mixer)
self._session_zoom = SessionZoomingComponent(session)
self._session_zoom.name = 'Session_Overview'
self._session_zoom.set_stopped_value(0)
self._session_zoom.set_playing_value(64)
self._session_zoom.set_selected_value(64)
if STANDALONE is True:
self.set_highlighting_session_component(self._session)
self._session.set_track_bank_buttons(self._grid[5][3], self._grid[4][3]) #comment out when using with Griid
self._session.set_scene_bank_buttons(self._grid[7][3], self._grid[6][3]) # comment out when using with Griid
"""this is where we take care of setting up the the multiple devices per page, we will need 4"""
def _setup_device_controls(self):
self._device = [None for index in range(4)]
for index in range(ROWS):
self._device[index] = DeviceComponent()
self._device[index].name = 'Device_Component_' + str(index)
#self.set_device_component(self._device) #this doesn't work anymore, because we have multiple devices for the controller....we'll have to get fancy here, but that's for later
#self._device_navigator = DetailViewControllerComponent() #its unclear if we'll need this....how is device navigation (i.e. banking for device parameter banks) going to be handled by the script?
#self._device_navigator.name = 'Device_Navigator'
device_param_controls = []
for control in range(COLS):
"""this setups up 8 device parameters per row"""
#dial_index = control + (index*COLS)
"""alternatively, this setus up device controls in 4 4x2 groups"""
dial_index = device_encoders[control + (index*COLS)]
device_param_controls.append(self._dial[dial_index])
self._device[index].set_parameter_controls(tuple(device_param_controls))
"""this is where we deassign every control that will be changing function when we switch modes...best to just deassign them all, and reassign them on update"""
def deassign_matrix(self):
for index in range(DIALCOUNT): #this should totally work!!! I'm over appealing to Python's sadistic mannerisms right now....
self._dial[index].send_value(0, True) ##this is kind of a hack, and should be unnecessary; the bool at the end tells the send_value method to force the value out to the controller
for index in range(COLS):
self._mixer.track_eq(index).set_enabled(False) ##set_gain_controls(tuple([None for index in range(3)]))
self._mixer.channel_strip(index).set_volume_control(None)
self._mixer.track_filter(index).set_enabled(False) ##set_filter_controls(tuple([None, None]))
self._mixer.channel_strip(index).set_pan_control(None)
self._mixer.channel_strip(index).set_select_button(None)
self._mixer.channel_strip(index).set_send_controls(tuple([None for index in range(4)]))
for device in range(4):
self._device[device].set_bank_nav_buttons(None, None)
self._device[device].set_enabled(False) ##set_parameter_controls(tuple([None for index in range(8)]))
for track in range(8):
self._mixer.channel_strip(track).set_select_button(None)
for scene in range(4):
self._scene[scene].clip_slot(track).set_launch_button(None)
#self.request_rebuild_midi_map() # I think this is causing problems updating the leds when in build?
"""EQ Hi/Mid/Low and volume"""
def assign_page_0(self):
"""for each column"""
is_momentary = True
for index in range(COLS):
self._mixer.track_eq(index).set_gain_controls((self._dial[index+16],self._dial[index+8],self._dial[index]))
self._mixer.track_eq(index).set_enabled(True)
self._mixer.channel_strip(index).set_volume_control(self._dial[index+24])#use the bottom row of encoders for volume, so add 24 to offset the index
self._mixer.channel_strip(index).set_select_button(self._trackbtns[index])
self.assign_cliplaunch()
self._mixer.update()
"""sends 1-4"""
def assign_page_1(self):
is_momentary = True
for index in range(COLS):
send_controllers = [self._dial[index],self._dial[index+8],self._dial[index+16],self._dial[index+24]]
self._mixer.channel_strip(index).set_send_controls(tuple(send_controllers))
self._mixer.channel_strip(index).set_select_button(self._trackbtns[index])
self._mixer.update()
"""devices 1-8"""
def assign_pages_2_3(self): ##these need to be here anyway, whether or not there is a device present to control
for index in range(4):
self._device[index].set_enabled(True)
#device_param_controls = [] ###no need to reassign it, since we are turning it off and on
#for control in range(COLS): ###in fact, I think we can assign all this stuff in the header except for things directly connected to the mixer module
# device_param_controls.append(self._dial[control + (index*COLS)])
#self._device[index].set_parameter_controls(tuple(device_param_controls))
self._reassign_devices(self._shift_mode._mode_index)
""" filter res,filter q, pan, volume"""
def assign_page_4(self):
is_momentary = True
for index in range(COLS):
self._mixer.track_filter(index).set_filter_controls(self._dial[index], self._dial[index + 8]) #set_filter_controls(self, freq, reso)
self._mixer.track_filter(index).set_enabled(True)
#self._mixer.track_eq(index).set_gain_controls((self._dial[index],self._dial[index+8],self._dial[index+16]))
self._mixer.channel_strip(index).set_pan_control(self._dial[index+16])
self._mixer.channel_strip(index).set_volume_control(self._dial[index+24])
self._mixer.channel_strip(index).set_select_button(self._trackbtns[index])
self._mixer.update()
def assign_cliplaunch(self):
if STANDALONE is True:
for column in range(COLS):
for row in range(ROWS-1):
self._scene[row].clip_slot(column).set_launch_button(self._grid[column][row])
def _reassign_devices(self, mode_index):
if self._shift_mode._mode_index in range(2, 4): ##both of these lines would be better handled by a property
offset = (mode_index - 2) * 4 ## set up in an override module of the device_component....bleh
track = self.song().view.selected_track
for index in range(4):
if index + offset < len(track.devices):
#self.log_message('assigning device')
self._device[index].set_device(track.devices[index + offset])
else:
#self.log_message('assigning device to None')
self._device[index].set_device(None)
self._device[index].set_bank_nav_buttons(self._trackbtns[(index * 2)], self._trackbtns[(index * 2) + 1])
self._device[index].update()
def disconnect(self):
"""clean things up on disconnect"""
self.log_message(time.strftime("%d.%m.%Y %H:%M:%S", time.localtime()) + "--------------= Code log closed =--------------") #Create entry in log file
ControlSurface.disconnect(self)
return None
class MainSelectorComponent(ModeSelectorComponent):
""" Class that reassigns the button on the launchpad to different functions """
def __init__(self, matrix, top_buttons, side_buttons, config_button,
script):
assert isinstance(matrix, ButtonMatrixElement)
assert matrix.width() == 8 and matrix.height() == 8
assert isinstance(top_buttons, tuple)
assert len(top_buttons) == 8
assert isinstance(side_buttons, tuple)
assert len(side_buttons) == 8
assert isinstance(config_button, ButtonElement)
ModeSelectorComponent.__init__(self)
self._script = script
self._session = SpecialSessionComponent(matrix.width(),
matrix.height())
for scene in self._session._scenes:
for slot in scene._clip_slots:
slot._triggered_to_play_value = 24
slot._triggered_to_record_value = 27
slot._started_value = 7
slot._recording_value = 9
slot._stopped_value = 8
self._zooming = SessionZoomingComponent(self._session)
self._session.name = 'Session_Control'
self._zooming.name = 'Session_Overview'
self._zooming._stopped_value = 9
self._zooming._playing_value = 7
self._zooming._selected_value = 8
self._matrix = matrix
self._side_buttons = side_buttons
self._nav_buttons = top_buttons[:4]
self._config_button = config_button
self._zooming.set_empty_value(LED_OFF)
self._all_buttons = []
for button in self._side_buttons + self._nav_buttons:
self._all_buttons.append(button)
self._sub_modes = SubSelectorComponent(matrix, side_buttons,
self._session)
self._sub_modes.name = 'Mixer_Modes'
self._sub_modes.set_update_callback(self._update_control_channels)
self._init_session()
self._all_buttons = tuple(self._all_buttons)
self.set_modes_buttons(top_buttons[4:])
def disconnect(self):
for button in self._modes_buttons:
button.remove_value_listener(self._mode_value)
self._session = None
self._zooming = None
for button in self._all_buttons:
button.set_on_off_values(127, LED_OFF)
self._config_button.turn_off()
self._matrix = None
self._side_buttons = None
self._nav_buttons = None
self._config_button = None
ModeSelectorComponent.disconnect(self)
def session_component(self):
return self._session
def set_modes_buttons(self, buttons):
assert buttons == None or isinstance(
buttons, tuple) or len(buttons) == self.number_of_modes()
identify_sender = True
for button in self._modes_buttons:
button.remove_value_listener(self._mode_value)
self._modes_buttons = []
if buttons != None:
for button in buttons:
assert isinstance(button, ButtonElement)
self._modes_buttons.append(button)
button.add_value_listener(self._mode_value, identify_sender)
self.set_mode(0)
def number_of_modes(self):
return 5
def on_enabled_changed(self):
self.update()
def set_mode(self, mode):
assert (mode in range(self.number_of_modes()))
if ((self._mode_index != mode) or (mode == 3)):
self._mode_index = mode
self.update()
def channel_for_current_mode(self):
new_channel = self._mode_index + self._sub_modes.mode()
if new_channel > 0:
new_channel += 3
return new_channel
def update(self):
assert (self._modes_buttons != None)
if self.is_enabled():
#for index in range(len(self._modes_buttons)):
# self._modes_buttons[index].set_force_next_value()
# if index == self._mode_index:
# self._modes_buttons[index].turn_on()
# else:
# self._modes_buttons[index].turn_off()
for scene_index in range(8):
self._side_buttons[scene_index].set_enabled(True)
for track_index in range(8):
self._matrix.get_button(track_index,
scene_index).set_enabled(True)
for button in self._nav_buttons:
button.set_enabled(True)
as_active = True
as_enabled = True
self._session.set_allow_update(False)
self._zooming.set_allow_update(False)
self._config_button.send_value(40)
self._config_button.send_value(1)
release_buttons = self._mode_index == 1
if (self._mode_index < 4):
self._script._host._set_key_buttons(None)
self._script._host.set_enabled(False)
self._script._host._set_button_matrix(None)
self._script._host._set_alt_button(None)
self._script._host._set_shift_button(None)
self._script._host._set_nav_buttons(None)
for button in self._modes_buttons:
button.set_on_off_values(5, 0)
if self._mode_index == 0:
self._setup_mixer(not as_active)
self._setup_session(as_active, as_enabled)
elif self._mode_index == 1:
self._setup_session(not as_active, not as_enabled)
self._setup_mixer(not as_active)
self._setup_user(release_buttons)
elif self._mode_index == 2:
self._setup_session(not as_active, not as_enabled)
self._setup_mixer(not as_active)
self._setup_user(release_buttons)
elif self._mode_index == 3:
self._setup_session(not as_active, as_enabled)
self._setup_mixer(as_active)
elif (self._mode_index == 4):
self._setup_session((not as_active), (not as_enabled))
self._setup_mixer((not as_active))
self._setup_user(release_buttons)
self._script._host._set_button_matrix(self._matrix)
self._script._host._set_key_buttons(self._side_buttons)
self._script._host._set_shift_button(self._modes_buttons[0])
self._script._host._set_lock_button(self._modes_buttons[1])
self._script._host._set_alt_button(self._modes_buttons[2])
self._modes_buttons[3].send_value(9)
self._script._host._set_nav_buttons(self._nav_buttons)
self._script._host.set_enabled(True)
else:
assert False
self._session.set_allow_update(True)
self._zooming.set_allow_update(True)
self._update_control_channels()
if (self._mode_index < 4):
for index in range(len(self._modes_buttons)):
if (index == self._mode_index):
self._modes_buttons[index].turn_on()
else:
self._modes_buttons[index].turn_off()
#self._script.request_rebuild_midi_map()
self._script.schedule_message(1, self._session.update)
def _update_control_channels(self):
if self._mode_index < 4:
new_channel = self.channel_for_current_mode()
else:
new_channel = 15
for button in self._all_buttons:
button.set_channel(new_channel)
button.set_force_next_value()
def _setup_session(self, as_active, as_enabled):
assert isinstance(as_active, type(False))
for button in self._nav_buttons:
if as_enabled:
button.set_on_off_values(GREEN_FULL, GREEN_THIRD)
else:
button.set_on_off_values(127, LED_OFF)
for scene_index in range(8):
scene = self._session.scene(scene_index)
if as_active:
scene_button = self._side_buttons[scene_index]
scene_button.set_on_off_values(127, LED_OFF)
scene.set_launch_button(scene_button)
else:
scene.set_launch_button(None)
for track_index in range(8):
if as_active:
button = self._matrix.get_button(track_index, scene_index)
button.set_on_off_values(127, LED_OFF)
scene.clip_slot(track_index).set_launch_button(button)
else:
scene.clip_slot(track_index).set_launch_button(None)
if as_active:
self._zooming.set_zoom_button(self._modes_buttons[0])
self._zooming.set_button_matrix(self._matrix)
self._zooming.set_scene_bank_buttons(self._side_buttons)
self._zooming.set_nav_buttons(self._nav_buttons[0],
self._nav_buttons[1],
self._nav_buttons[2],
self._nav_buttons[3])
self._zooming.update()
else:
self._zooming.set_zoom_button(None)
self._zooming.set_button_matrix(None)
self._zooming.set_scene_bank_buttons(None)
self._zooming.set_nav_buttons(None, None, None, None)
if as_enabled:
self._session.set_track_bank_buttons(self._nav_buttons[3],
self._nav_buttons[2])
self._session.set_scene_bank_buttons(self._nav_buttons[1],
self._nav_buttons[0])
#self._session.set_show_highlight(True) #Needs to be replaced with L9 equivalent
else:
self._session.set_track_bank_buttons(None, None)
self._session.set_scene_bank_buttons(None, None)
#self._session.set_show_highlight(False) #Needs to be replaced with L9 equivalent
def _setup_mixer(self, as_active):
assert isinstance(as_active, type(False))
as_active and self._sub_modes.is_enabled(
) and self._sub_modes.set_mode(-1)
self._sub_modes.set_enabled(as_active)
def _setup_user(self, release_buttons):
for scene_index in range(8):
scene_button = self._side_buttons[scene_index]
scene_button.set_on_off_values(127, LED_OFF)
scene_button.turn_off()
scene_button.set_enabled(not release_buttons)
for track_index in range(8):
button = self._matrix.get_button(track_index, scene_index)
button.set_on_off_values(127, LED_OFF)
button.turn_off()
button.set_enabled(not release_buttons)
for button in self._nav_buttons:
button.set_on_off_values(127, LED_OFF)
button.turn_off()
button.set_enabled(not release_buttons)
if release_buttons:
self._config_button.send_value(2)
self._config_button.send_value(32, force_send=True)
def _init_session(self):
self._session.set_stop_track_clip_value(AMBER_BLINK)
for scene_index in range(self._matrix.height()):
scene = self._session.scene(scene_index)
scene.set_triggered_value(GREEN_BLINK)
scene.name = 'Scene_' + str(scene_index)
for track_index in range(self._matrix.width()):
clip_slot = scene.clip_slot(track_index)
clip_slot.set_triggered_to_play_value(GREEN_BLINK)
clip_slot.set_triggered_to_record_value(RED_BLINK)
clip_slot.set_stopped_value(AMBER_FULL)
clip_slot.set_started_value(GREEN_FULL)
clip_slot.set_recording_value(RED_FULL)
clip_slot.name = str(track_index) + '_Clip_Slot_' + str(
scene_index)
self._all_buttons.append(
self._matrix.get_button(track_index, scene_index))
self._zooming.set_stopped_value(RED_FULL)
self._zooming.set_selected_value(AMBER_FULL)
self._zooming.set_playing_value(GREEN_FULL)
"""Mono Overrides and Additions"""
def _mode_value(self, value, sender):
assert (len(self._modes_buttons) > 0)
assert isinstance(value, int)
assert isinstance(sender, ButtonElement)
assert (self._modes_buttons.count(sender) == 1)
if self._script._host.is_enabled() != True:
if ((value is not 0) or (not sender.is_momentary())):
if ((self._modes_buttons[1]._last_received_value > 0) and
(self._modes_buttons.index(sender) == 2)) or (
(self._modes_buttons[2]._last_received_value > 0) and
(self._modes_buttons.index(sender) == 1)):
if (self._script._host._active_client != None):
self.set_mode(4)
else:
self._script.show_message(
'Monomodular Script not inserted')
else:
self.set_mode(self._modes_buttons.index(sender))
else:
if self._modes_buttons.index(sender) == 3 and value > 0:
self.set_mode(0)
def _setup_session_control(self): is_momentary = True num_tracks = 4 num_scenes = 5 self._session = NameServerSessionComponent(num_tracks, num_scenes, self) self._session.name = "Left_Session" self._session.set_offsets(0, 0) self._session.set_stop_clip_value(self._color_defs['STOP_CLIP']) self._scene = [None for index in range(5)] for row in range(num_scenes): self._scene[row] = self._session.scene(row) self._scene[row].name = 'L_Scene_' + str(row) for column in range(num_tracks): clip_slot = self._scene[row].clip_slot(column) clip_slot.name = str(column) + '_Clip_Slot_L_' + str(row) clip_slot.set_triggered_to_play_value(self._color_defs['CLIP_TRG_PLAY']) clip_slot.set_triggered_to_record_value(self._color_defs['CLIP_TRG_REC']) clip_slot.set_stopped_value(self._color_defs['CLIP_STOP']) clip_slot.set_started_value(self._color_defs['CLIP_STARTED']) clip_slot.set_recording_value(self._color_defs['CLIP_RECORDING']) self._session.set_mixer(self._mixer) self._session_zoom = SessionZoomingComponent(self._session) self._session_zoom.name = 'L_Session_Overview' self._session_zoom.set_stopped_value(self._color_defs['ZOOM_STOPPED']) self._session_zoom.set_playing_value(self._color_defs['ZOOM_PLAYING']) self._session_zoom.set_selected_value(self._color_defs['ZOOM_SELECTED']) self._session_zoom._zoom_button = (self._dummy_button) self._session_zoom.set_enabled(True) self._session2 = SessionComponent(num_tracks, num_scenes) self._session2.name = 'Right_Session' self._session2.set_offsets(4, 0) self._session2.set_stop_clip_value(self._color_defs['STOP_CLIP']) self._scene2 = [None for index in range(5)] for row in range(num_scenes): self._scene2[row] = self._session2.scene(row) self._scene2[row].name = 'R_Scene_' + str(row) for column in range(num_tracks): clip_slot = self._scene2[row].clip_slot(column) clip_slot.name = str(column) + '_Clip_Slot_R_' + str(row) clip_slot.set_triggered_to_play_value(self._color_defs['CLIP_TRG_PLAY']) clip_slot.set_triggered_to_record_value(self._color_defs['CLIP_TRG_REC']) clip_slot.set_stopped_value(self._color_defs['CLIP_STOP']) clip_slot.set_started_value(self._color_defs['CLIP_STARTED']) clip_slot.set_recording_value(self._color_defs['CLIP_RECORDING']) self._session2.set_mixer(self._mixer2) self._session2.add_offset_listener(self._on_session_offset_changes) self._session_zoom2 = SessionZoomingComponent(self._session2) self._session_zoom2.name = 'R_Session_Overview' self._session_zoom2.set_stopped_value(self._color_defs['ZOOM_STOPPED']) self._session_zoom2.set_playing_value(self._color_defs['ZOOM_PLAYING']) self._session_zoom2.set_selected_value(self._color_defs['ZOOM_SELECTED']) self._session_zoom.set_enabled(True) self._session_zoom2._zoom_button = (self._dummy_button2) self._session_main = SessionComponent(8, num_scenes) self._session_main.name = 'Main_Session' self._session_main.set_stop_clip_value(self._color_defs['STOP_CLIP']) self._scene_main = [None for index in range(5)] for row in range(num_scenes): self._scene_main[row] = self._session_main.scene(row) self._scene_main[row].name = 'M_Scene_' + str(row) for column in range(8): clip_slot = self._scene_main[row].clip_slot(column) clip_slot.name = str(column) + '_Clip_Slot_M_' + str(row) clip_slot.set_triggered_to_play_value(self._color_defs['CLIP_TRG_PLAY']) clip_slot.set_triggered_to_record_value(self._color_defs['CLIP_TRG_REC']) clip_slot.set_stopped_value(self._color_defs['CLIP_STOP']) clip_slot.set_started_value(self._color_defs['CLIP_STARTED']) clip_slot.set_recording_value(self._color_defs['CLIP_RECORDING']) self._session_main.set_mixer(self._mixer) self._session_zoom_main = SessionZoomingComponent(self._session_main) self._session_zoom_main.name = 'M_Session_Overview' self._session_zoom_main.set_stopped_value(self._color_defs['ZOOM_STOPPED']) self._session_zoom_main.set_playing_value(self._color_defs['ZOOM_PLAYING']) self._session_zoom_main.set_selected_value(self._color_defs['ZOOM_SELECTED']) self._session_zoom_main.set_enabled(True) self._session_zoom_main._zoom_button = (self._dummy_button3) self._sessions = [self._session, self._session2, self._session_main] self._zooms = [self._session_zoom, self._session_zoom2, self._session_zoom_main]
class MainSelectorComponent(ModeSelectorComponent):
""" Class that reassigns the button on the launchpad to different functions """
def __init__(self, matrix, top_buttons, side_buttons, config_button, script):
assert isinstance(matrix, ButtonMatrixElement)
assert matrix.width() == 8 and matrix.height() == 8
assert isinstance(top_buttons, tuple)
assert len(top_buttons) == 8
assert isinstance(side_buttons, tuple)
assert len(side_buttons) == 8
assert isinstance(config_button, ButtonElement)
ModeSelectorComponent.__init__(self)
self._script = script
self._session = SpecialSessionComponent(matrix.width(), matrix.height())
"""for scene in self._session._scenes:
for slot in scene._clip_slots:
slot._triggered_to_play_value = 24
slot._triggered_to_record_value = 27
slot._started_value = 7
slot._recording_value = 9
slot._stopped_value = 8"""
self._zooming = SessionZoomingComponent(self._session)
self._session.name = "Session_Control"
self._zooming.name = "Session_Overview"
"""self._zooming._stopped_value = 9
self._zooming._playing_value = 7
self._zooming._selected_value = 8"""
self._matrix = matrix
self._side_buttons = side_buttons
self._nav_buttons = top_buttons[:4]
self._config_button = config_button
self._zooming.set_empty_value(LED_OFF)
self._all_buttons = []
for button in self._side_buttons + self._nav_buttons:
self._all_buttons.append(button)
self._sub_modes = SubSelectorComponent(matrix, side_buttons, self._session)
self._sub_modes.name = "Mixer_Modes"
self._sub_modes.set_update_callback(self._update_control_channels)
self._init_session()
self._all_buttons = tuple(self._all_buttons)
self.set_modes_buttons(top_buttons[4:])
if START_IN_MOD is True:
self._set_protected_mode_index(4)
def disconnect(self):
for button in self._modes_buttons:
button.remove_value_listener(self._mode_value)
self._session = None
self._zooming = None
for button in self._all_buttons:
button.set_on_off_values(127, LED_OFF)
self._config_button.turn_off()
self._matrix = None
self._side_buttons = None
self._nav_buttons = None
self._config_button = None
ModeSelectorComponent.disconnect(self)
def session_component(self):
return self._session
def set_modes_buttons(self, buttons):
assert buttons == None or isinstance(buttons, tuple) or len(buttons) == self.number_of_modes()
identify_sender = True
for button in self._modes_buttons:
button.remove_value_listener(self._mode_value)
self._modes_buttons = []
if buttons != None:
for button in buttons:
assert isinstance(button, ButtonElement)
self._modes_buttons.append(button)
button.add_value_listener(self._mode_value, identify_sender)
self.set_mode(0)
def number_of_modes(self):
return 5
def on_enabled_changed(self):
self.update()
def set_mode(self, mode):
assert mode in range(self.number_of_modes())
if (self._mode_index != mode) or (mode == 3):
self._mode_index = mode
self.update()
def channel_for_current_mode(self):
new_channel = self._mode_index + self._sub_modes.mode()
if new_channel > 0:
new_channel += 3
return new_channel
def update(self):
assert self._modes_buttons != None
if self.is_enabled():
# for index in range(len(self._modes_buttons)):
# self._modes_buttons[index].set_force_next_value()
# if index == self._mode_index:
# self._modes_buttons[index].turn_on()
# else:
# self._modes_buttons[index].turn_off()
for scene_index in range(8):
self._side_buttons[scene_index].set_enabled(True)
for track_index in range(8):
self._matrix.get_button(track_index, scene_index).set_enabled(True)
for button in self._nav_buttons:
button.set_enabled(True)
as_active = True
as_enabled = True
self._session.set_allow_update(False)
self._zooming.set_allow_update(False)
self._config_button.send_value(40)
self._config_button.send_value(1)
release_buttons = self._mode_index == 1
if self._mode_index < 4:
self._script._suppress_session_highlight = False
self._session.set_show_highlight(True)
# self._script.set_highlighting_session_component(self.session_component())
self._script._host._set_key_buttons(None)
self._script._host.set_enabled(False)
self._script._host._set_button_matrix(None)
self._script._host._set_alt_button(None)
self._script._host._set_shift_button(None)
self._script._host._set_nav_buttons(None)
for button in self._modes_buttons:
button.set_on_off_values(127, 4)
if self._mode_index == 0:
self._setup_mixer(not as_active)
self._setup_session(as_active, as_enabled)
elif self._mode_index == 1:
self._setup_session(not as_active, not as_enabled)
self._setup_mixer(not as_active)
self._setup_user(release_buttons)
elif self._mode_index == 2:
self._setup_session(not as_active, not as_enabled)
self._setup_mixer(not as_active)
self._setup_user(release_buttons)
elif self._mode_index == 3:
self._setup_session(not as_active, as_enabled)
self._setup_mixer(as_active)
elif self._mode_index == 4:
# self._script.set_highlighting_session_component(None)
self._session.set_show_highlight(False)
self._script._suppress_session_highlight = True
self._setup_session((not as_active), (not as_enabled))
self._setup_mixer((not as_active))
self._setup_user(release_buttons)
self._script._host._set_button_matrix(self._matrix)
self._script._host._set_key_buttons(self._side_buttons)
self._script._host._set_shift_button(self._modes_buttons[0])
self._script._host._set_lock_button(self._modes_buttons[1])
self._script._host._set_alt_button(self._modes_buttons[2])
self._modes_buttons[3].send_value(9)
self._script._host._set_nav_buttons(self._nav_buttons)
self._script._host.set_enabled(True)
else:
assert False
self._session.set_allow_update(True)
self._zooming.set_allow_update(True)
self._update_control_channels()
if self._mode_index < 4:
for index in range(len(self._modes_buttons)):
if index == self._mode_index:
self._modes_buttons[index].turn_on()
else:
self._modes_buttons[index].turn_off()
# self._script.request_rebuild_midi_map()
self._script.schedule_message(1, self._session.update)
def _update_control_channels(self):
if self._mode_index < 4:
new_channel = self.channel_for_current_mode()
else:
new_channel = 15
for button in self._all_buttons:
button.set_channel(new_channel)
button.set_force_next_value()
def _setup_session(self, as_active, as_enabled):
assert isinstance(as_active, type(False))
for button in self._nav_buttons:
if as_enabled:
button.set_on_off_values(GREEN_FULL, GREEN_THIRD)
else:
button.set_on_off_values(127, LED_OFF)
for scene_index in range(8):
scene = self._session.scene(scene_index)
if as_active:
scene_button = self._side_buttons[scene_index]
scene_button.set_on_off_values(127, LED_OFF)
scene.set_launch_button(scene_button)
else:
scene.set_launch_button(None)
for track_index in range(8):
if as_active:
button = self._matrix.get_button(track_index, scene_index)
button.set_on_off_values(127, LED_OFF)
scene.clip_slot(track_index).set_launch_button(button)
else:
scene.clip_slot(track_index).set_launch_button(None)
if as_active:
self._zooming.set_zoom_button(self._modes_buttons[0])
self._zooming.set_button_matrix(self._matrix)
self._zooming.set_scene_bank_buttons(self._side_buttons)
self._zooming.set_nav_buttons(
self._nav_buttons[0], self._nav_buttons[1], self._nav_buttons[2], self._nav_buttons[3]
)
self._zooming.update()
else:
self._zooming.set_zoom_button(None)
self._zooming.set_button_matrix(None)
self._zooming.set_scene_bank_buttons(None)
self._zooming.set_nav_buttons(None, None, None, None)
if as_enabled:
self._session.set_track_bank_buttons(self._nav_buttons[3], self._nav_buttons[2])
self._session.set_scene_bank_buttons(self._nav_buttons[1], self._nav_buttons[0])
# self._session.set_show_highlight(True) #Needs to be replaced with L9 equivalent
else:
self._session.set_track_bank_buttons(None, None)
self._session.set_scene_bank_buttons(None, None)
# self._session.set_show_highlight(False) #Needs to be replaced with L9 equivalent
def _setup_mixer(self, as_active):
assert isinstance(as_active, type(False))
as_active and self._sub_modes.is_enabled() and self._sub_modes.set_mode(-1)
self._sub_modes.set_enabled(as_active)
def _setup_user(self, release_buttons):
for scene_index in range(8):
scene_button = self._side_buttons[scene_index]
scene_button.set_on_off_values(127, LED_OFF)
scene_button.turn_off()
scene_button.set_enabled(not release_buttons)
for track_index in range(8):
button = self._matrix.get_button(track_index, scene_index)
button.set_on_off_values(127, LED_OFF)
button.turn_off()
button.set_enabled(not release_buttons)
for button in self._nav_buttons:
button.set_on_off_values(127, LED_OFF)
button.turn_off()
button.set_enabled(not release_buttons)
if release_buttons:
self._config_button.send_value(2)
self._config_button.send_value(32, force=True)
def _init_session(self):
self._session.set_stop_track_clip_value(AMBER_BLINK)
for scene_index in range(self._matrix.height()):
scene = self._session.scene(scene_index)
scene.set_triggered_value(GREEN_BLINK)
scene.name = "Scene_" + str(scene_index)
for track_index in range(self._matrix.width()):
clip_slot = scene.clip_slot(track_index)
clip_slot.set_triggered_to_play_value(GREEN_BLINK)
clip_slot.set_triggered_to_record_value(RED_BLINK)
clip_slot.set_stopped_value(AMBER_FULL)
clip_slot.set_started_value(GREEN_FULL)
clip_slot.set_recording_value(RED_FULL)
clip_slot.name = str(track_index) + "_Clip_Slot_" + str(scene_index)
self._all_buttons.append(self._matrix.get_button(track_index, scene_index))
self._zooming.set_stopped_value(RED_FULL)
self._zooming.set_selected_value(AMBER_FULL)
self._zooming.set_playing_value(GREEN_FULL)
"""Mono Overrides and Additions"""
def _mode_value(self, value, sender):
assert len(self._modes_buttons) > 0
assert isinstance(value, int)
assert isinstance(sender, ButtonElement)
assert self._modes_buttons.count(sender) == 1
if self._script._host.is_enabled() != True:
if (value is not 0) or (not sender.is_momentary()):
if ((self._modes_buttons[1]._last_received_value > 0) and (self._modes_buttons.index(sender) == 2)) or (
(self._modes_buttons[2]._last_received_value > 0) and (self._modes_buttons.index(sender) == 1)
):
if self._script._host._active_client != None:
self.set_mode(4)
else:
self._script.show_message("Monomodular Script not inserted")
else:
self.set_mode(self._modes_buttons.index(sender))
else:
if self._modes_buttons.index(sender) == 3 and value > 0:
self.set_mode(0)
class APC40(APC):
""" Script for Akai's APC40 Controller """
def __init__(self, c_instance):
APC.__init__(self, c_instance)
self._device_selection_follows_track_selection = True
def _setup_session_control(self):
is_momentary = True
self._shift_button = ButtonElement(is_momentary, MIDI_NOTE_TYPE, 0, 98)
right_button = ButtonElement(is_momentary, MIDI_NOTE_TYPE, 0, 96)
left_button = ButtonElement(is_momentary, MIDI_NOTE_TYPE, 0, 97)
up_button = ButtonElement(is_momentary, MIDI_NOTE_TYPE, 0, 94)
down_button = ButtonElement(is_momentary, MIDI_NOTE_TYPE, 0, 95)
right_button.name = 'Bank_Select_Right_Button'
left_button.name = 'Bank_Select_Left_Button'
up_button.name = 'Bank_Select_Up_Button'
down_button.name = 'Bank_Select_Down_Button'
self._session = PedaledSessionComponent(8, 5)
self._session.name = 'Session_Control'
self._session.set_track_bank_buttons(right_button, left_button)
self._session.set_scene_bank_buttons(down_button, up_button)
matrix = ButtonMatrixElement()
matrix.name = 'Button_Matrix'
scene_launch_buttons = [
ButtonElement(is_momentary, MIDI_NOTE_TYPE, 0, index + 82)
for index in range(5)
]
track_stop_buttons = [
ButtonElement(is_momentary, MIDI_NOTE_TYPE, index, 52)
for index in range(8)
]
for index in range(len(scene_launch_buttons)):
scene_launch_buttons[index].name = 'Scene_' + str(
index) + '_Launch_Button'
for index in range(len(track_stop_buttons)):
track_stop_buttons[index].name = 'Track_' + str(
index) + '_Stop_Button'
stop_all_button = ButtonElement(is_momentary, MIDI_NOTE_TYPE, 0, 81)
stop_all_button.name = 'Stop_All_Clips_Button'
self._session.set_stop_all_clips_button(stop_all_button)
self._session.set_stop_track_clip_buttons(tuple(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(scene_launch_buttons[scene_index])
scene.set_triggered_value(2)
for track_index in range(8):
button = ButtonElement(is_momentary, MIDI_NOTE_TYPE,
track_index, scene_index + 53)
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)
matrix.add_row(tuple(button_row))
self._session.set_slot_launch_button(
ButtonElement(is_momentary, MIDI_CC_TYPE, 0, 67))
self._session.selected_scene().name = 'Selected_Scene'
self._session.selected_scene().set_launch_button(
ButtonElement(is_momentary, MIDI_CC_TYPE, 0, 64))
self._session_zoom = SessionZoomingComponent(self._session)
self._session_zoom.name = 'Session_Overview'
self._session_zoom.set_button_matrix(matrix)
self._session_zoom.set_zoom_button(self._shift_button)
self._session_zoom.set_nav_buttons(up_button, down_button, left_button,
right_button)
self._session_zoom.set_scene_bank_buttons(tuple(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(8)
self._mixer.name = 'Mixer'
self._mixer.master_strip().name = 'Master_Channel_Strip'
self._mixer.selected_strip().name = 'Selected_Channel_Strip'
for track in range(8):
strip = self._mixer.channel_strip(track)
strip.name = 'Channel_Strip_' + str(track)
volume_control = SliderElement(MIDI_CC_TYPE, track, 7)
arm_button = ButtonElement(is_momentary, MIDI_NOTE_TYPE, track, 48)
solo_button = ButtonElement(is_momentary, MIDI_NOTE_TYPE, track,
49)
mute_button = ButtonElement(is_momentary, MIDI_NOTE_TYPE, track,
50)
select_button = ButtonElement(is_momentary, MIDI_NOTE_TYPE, track,
51)
volume_control.name = str(track) + '_Volume_Control'
arm_button.name = str(track) + '_Arm_Button'
solo_button.name = str(track) + '_Solo_Button'
mute_button.name = str(track) + '_Mute_Button'
select_button.name = str(track) + '_Select_Button'
strip.set_volume_control(volume_control)
strip.set_arm_button(arm_button)
strip.set_solo_button(solo_button)
strip.set_mute_button(mute_button)
strip.set_select_button(select_button)
strip.set_shift_button(self._shift_button)
strip.set_invert_mute_feedback(True)
crossfader = SliderElement(MIDI_CC_TYPE, 0, 15)
master_volume_control = SliderElement(MIDI_CC_TYPE, 0, 14)
master_select_button = ButtonElement(is_momentary, MIDI_NOTE_TYPE, 0,
80)
prehear_control = EncoderElement(
MIDI_CC_TYPE, 0, 47, Live.MidiMap.MapMode.relative_two_compliment)
crossfader.name = 'Crossfader'
master_volume_control.name = 'Master_Volume_Control'
master_select_button.name = 'Master_Select_Button'
prehear_control.name = 'Prehear_Volume_Control'
self._mixer.set_crossfader_control(crossfader)
self._mixer.set_prehear_volume_control(prehear_control)
self._mixer.master_strip().set_volume_control(master_volume_control)
self._mixer.master_strip().set_select_button(master_select_button)
def _setup_custom_components(self):
self._setup_device_and_transport_control()
self._setup_global_control()
def _setup_device_and_transport_control(self):
is_momentary = True
device_bank_buttons = []
device_param_controls = []
bank_button_labels = ('Clip_Track_Button', 'Device_On_Off_Button',
'Previous_Device_Button', 'Next_Device_Button',
'Detail_View_Button', 'Rec_Quantization_Button',
'Midi_Overdub_Button', 'Metronome_Button')
for index in range(8):
device_bank_buttons.append(
ButtonElement(is_momentary, MIDI_NOTE_TYPE, 0, 58 + index))
device_bank_buttons[-1].name = bank_button_labels[index]
ring_mode_button = ButtonElement(not is_momentary, MIDI_CC_TYPE, 0,
24 + index)
ringed_encoder = RingedEncoderElement(
MIDI_CC_TYPE, 0, 16 + index, Live.MidiMap.MapMode.absolute)
ringed_encoder.set_ring_mode_button(ring_mode_button)
ringed_encoder.name = 'Device_Control_' + str(index)
ring_mode_button.name = ringed_encoder.name + '_Ring_Mode_Button'
device_param_controls.append(ringed_encoder)
device = ShiftableDeviceComponent()
device.name = 'Device_Component'
device.set_bank_buttons(tuple(device_bank_buttons))
device.set_shift_button(self._shift_button)
device.set_parameter_controls(tuple(device_param_controls))
device.set_on_off_button(device_bank_buttons[1])
self.set_device_component(device)
detail_view_toggler = DetailViewCntrlComponent()
detail_view_toggler.name = 'Detail_View_Control'
detail_view_toggler.set_shift_button(self._shift_button)
detail_view_toggler.set_device_clip_toggle_button(
device_bank_buttons[0])
detail_view_toggler.set_detail_toggle_button(device_bank_buttons[4])
detail_view_toggler.set_device_nav_buttons(device_bank_buttons[2],
device_bank_buttons[3])
transport = ShiftableTransportComponent()
transport.name = 'Transport'
play_button = ButtonElement(is_momentary, MIDI_NOTE_TYPE, 0, 91)
stop_button = ButtonElement(is_momentary, MIDI_NOTE_TYPE, 0, 92)
record_button = ButtonElement(is_momentary, MIDI_NOTE_TYPE, 0, 93)
nudge_up_button = ButtonElement(is_momentary, MIDI_NOTE_TYPE, 0, 100)
nudge_down_button = ButtonElement(is_momentary, MIDI_NOTE_TYPE, 0, 101)
tap_tempo_button = ButtonElement(is_momentary, MIDI_NOTE_TYPE, 0, 99)
play_button.name = 'Play_Button'
stop_button.name = 'Stop_Button'
record_button.name = 'Record_Button'
nudge_up_button.name = 'Nudge_Up_Button'
nudge_down_button.name = 'Nudge_Down_Button'
tap_tempo_button.name = 'Tap_Tempo_Button'
transport.set_shift_button(self._shift_button)
transport.set_play_button(play_button)
transport.set_stop_button(stop_button)
transport.set_record_button(record_button)
transport.set_nudge_buttons(nudge_up_button, nudge_down_button)
transport.set_tap_tempo_button(tap_tempo_button)
transport.set_quant_toggle_button(device_bank_buttons[5])
transport.set_overdub_button(device_bank_buttons[6])
transport.set_metronome_button(device_bank_buttons[7])
bank_button_translator = ShiftTranslatorComponent()
bank_button_translator.set_controls_to_translate(
tuple(device_bank_buttons))
bank_button_translator.set_shift_button(self._shift_button)
def _setup_global_control(self):
is_momentary = True
global_bank_buttons = []
global_param_controls = []
for index in range(8):
ring_button = ButtonElement(not is_momentary, MIDI_CC_TYPE, 0,
56 + index)
ringed_encoder = RingedEncoderElement(
MIDI_CC_TYPE, 0, 48 + index, Live.MidiMap.MapMode.absolute)
ringed_encoder.name = 'Track_Control_' + str(index)
ring_button.name = ringed_encoder.name + '_Ring_Mode_Button'
ringed_encoder.set_ring_mode_button(ring_button)
global_param_controls.append(ringed_encoder)
global_bank_buttons = []
global_bank_labels = ('Pan_Button', 'Send_A_Button', 'Send_B_Button',
'Send_C_Button')
for index in range(4):
global_bank_buttons.append(
ButtonElement(is_momentary, MIDI_NOTE_TYPE, 0, 87 + index))
global_bank_buttons[-1].name = global_bank_labels[index]
encoder_modes = EncModeSelectorComponent(self._mixer)
encoder_modes.name = 'Track_Control_Modes'
encoder_modes.set_modes_buttons(global_bank_buttons)
encoder_modes.set_controls(tuple(global_param_controls))
global_translation_selector = ChannelTranslationSelector()
global_translation_selector.name = 'Global_Translations'
global_translation_selector.set_controls_to_translate(
tuple(global_param_controls))
global_translation_selector.set_mode_buttons(
tuple(global_bank_buttons))
def _product_model_id_byte(self):
return 115
def _setup_session_control(self):
is_momentary = True
num_tracks = 4
num_scenes = 4
global session #We want to instantiate the global session as a SessionComponent object (it was a global "None" type up until now...)
session = MaschineSessionComponent(num_tracks, num_scenes) #(num_tracks, num_scenes)
session.set_offsets(0, 0) #(track_offset, scene_offset) Sets the initial offset of the red box from top left
matrix = ButtonMatrixElement()
self._register_timer_callback(session.flash_clip_slots)
"""set up the session buttons"""
left_button = ButtonElement(is_momentary, MIDI_CC_TYPE, CHANNEL, 91)
right_button = ButtonElement(is_momentary, MIDI_CC_TYPE, CHANNEL, 93)
session.set_track_bank_buttons(right_button, left_button)
# Stop buttons
track_stop_buttons = [ ButtonElement(is_momentary, MIDI_CC_TYPE, 4, (55 + index)) for index in range(num_tracks) ]
session.set_stop_track_clip_buttons(tuple(track_stop_buttons))
up_button = ButtonElement(is_momentary, MIDI_CC_TYPE, CHANNEL, 81)
down_button = ButtonElement(is_momentary, MIDI_CC_TYPE, CHANNEL, 92)
session.set_scene_bank_buttons(down_button, up_button) # (up_button, down_button) This is to move the "red box" up or down (increment track up or down, not screen up or down, so they are inversed)
session.set_mixer(mixer) #Bind the mixer to the session so that they move together
selected_scene = self.song().view.selected_scene #this is from the Live API
all_scenes = self.song().scenes
index = list(all_scenes).index(selected_scene)
session.set_offsets(0, index) #(track_offset, scene_offset)
scene_launch_buttons = []
for scene_index in range(4):
scene = session.scene(scene_index)
launch_button = ButtonElement(is_momentary, MIDI_CC_TYPE, 1, (124 + scene_index))
scene.set_launch_button(launch_button)
scene_launch_buttons.append(launch_button)
clip_launch_notes = [
[24, 25, 26, 27],
[20, 21, 22, 23],
[16, 17, 18, 19],
[12, 13, 14, 15],
]
for scene_index in range(num_scenes):
button_row = []
for track_index in range(num_tracks):
clip_slot = session.scene(scene_index).clip_slot(track_index)
clip_slot.set_triggered_to_record_value(127)
clip_slot.set_recording_value(127)
clip_slot.set_started_value(127)
clip_slot.set_stopped_value(127)
button = ButtonElement(is_momentary, MIDI_NOTE_TYPE, 2, clip_launch_notes[scene_index][track_index])
clip_slot.set_launch_button(button)
button_row.append(button)
matrix.add_row(tuple(button_row))
session_zoom = SessionZoomingComponent(session)
session_zoom.set_zoom_button(self.shift_button)
session_zoom.set_nav_buttons(up_button, down_button, left_button, right_button)
session_zoom.set_scene_bank_buttons(tuple(scene_launch_buttons))
session_zoom.set_button_matrix(matrix)
session_zoom.set_stopped_value(0)
session_zoom.set_selected_value(127)
def __init__(self, c_instance):
ControlSurface.__init__(self, c_instance)
self._device_selection_follows_track_selection = True
with self.component_guard():
self._suppress_send_midi = True
self._suppress_session_highlight = True
self._control_is_with_automap = False
is_momentary = True
self._suggested_input_port = 'Akai MPD26'
self._suggested_output_port = 'Akai MPD26'
self.log("BEFORE mixer")
self._setup_mixer_control()
self._setup_device_control()
# self.clipcontrol(8)
self.log("AFTER MIXER")
"""SESSION ViEW"""
global session
session = SessionComponent(GRIDSIZE[0], GRIDSIZE[1])
session.name = 'Session_Control'
matrix = ButtonMatrixElement()
matrix.name = 'Button_Matrix'
up_button = ButtonElement(True, MIDI_NOTE_TYPE, CHANNEL, UP_BUTTON)
down_button = ButtonElement(True, MIDI_NOTE_TYPE, CHANNEL,
DOWN_BUTTON)
left_button = ButtonElement(True, MIDI_NOTE_TYPE, CHANNEL,
LEFT_BUTTON)
right_button = ButtonElement(True, MIDI_NOTE_TYPE, CHANNEL,
RIGHT_BUTTON)
# session.set_scene_bank_buttons(down_button, up_button) #enabling these and disabling the below zoom buttons will move one scene/track per button press
# session.set_track_bank_buttons(right_button, left_button) #
session_zoom = SessionZoomingComponent(session)
session_zoom.set_nav_buttons(
up_button, down_button, left_button, right_button
) #these make it so you move the maximum number of scenes/tracks per button press. much more useful than moving by single scenes/tracks
session_stop_buttons = []
for row in range(GRIDSIZE[0]):
button_row = []
scene = session.scene(row)
scene.name = 'Scene_' + str(row)
scene.set_launch_button(
ButtonElement(True, MIDI_NOTE_TYPE, CHANNEL,
SCENE_BUTTONS[row]))
scene.set_triggered_value(2)
session_stop_buttons.append(
(ButtonElement(True, MIDI_NOTE_TYPE, CHANNEL,
TRACK_STOPS[row])))
for column in range(GRIDSIZE[1]):
button = ConfigurableButtonElement(
True, MIDI_NOTE_TYPE, CHANNEL,
LAUNCH_BUTTONS[row][column])
button.name = str(column) + '_Clip_' + str(row) + '_Button'
button_row.append(button)
clip_slot = scene.clip_slot(column)
clip_slot.name = str(column) + '_Clip_Slot_' + str(row)
clip_slot.set_launch_button(button)
matrix.add_row(tuple(button_row))
self._suppress_session_highlight = False
self._suppress_send_midi = False
self.set_highlighting_session_component(session)
session.set_mixer(mixer)
session.set_stop_track_clip_buttons(tuple(session_stop_buttons))
def _setup_session_control(self):
is_momentary = True
self._shift_button = ButtonElement(is_momentary, MIDI_NOTE_TYPE, 0, 98)
right_button = ButtonElement(is_momentary, MIDI_NOTE_TYPE, 0, 96)
left_button = ButtonElement(is_momentary, MIDI_NOTE_TYPE, 0, 97)
up_button = ButtonElement(is_momentary, MIDI_NOTE_TYPE, 0, 94)
down_button = ButtonElement(is_momentary, MIDI_NOTE_TYPE, 0, 95)
right_button.name = 'Bank_Select_Right_Button'
left_button.name = 'Bank_Select_Left_Button'
up_button.name = 'Bank_Select_Up_Button'
down_button.name = 'Bank_Select_Down_Button'
self._session = PedaledSessionComponent(8, 5)
self._session.name = 'Session_Control'
self._session.set_track_bank_buttons(right_button, left_button)
self._session.set_scene_bank_buttons(down_button, up_button)
self._matrix = ButtonMatrixElement() #was: matrix = ButtonMatrixElement()
self._matrix.name = 'Button_Matrix' #was: matrix.name = 'Button_Matrix'
scene_launch_buttons = [ ButtonElement(is_momentary, MIDI_NOTE_TYPE, 0, (index + 82)) for index in range(5) ]
#self._track_stop_buttons = [ ButtonElement(is_momentary, MIDI_NOTE_TYPE, index, 52) for index in range(8) ]
self._track_stop_buttons = [ ConfigurableButtonElement(is_momentary, MIDI_NOTE_TYPE, index, 52) for index in range(8) ]
for index in range(len(scene_launch_buttons)):
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'
stop_all_button = ButtonElement(is_momentary, MIDI_NOTE_TYPE, 0, 81)
stop_all_button.name = 'Stop_All_Clips_Button'
self._session.set_stop_all_clips_button(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(scene_launch_buttons[scene_index])
scene.set_triggered_value(2)
for track_index in range(8):
#button = ButtonElement(is_momentary, MIDI_NOTE_TYPE, track_index, (scene_index + 53))
button = ConfigurableButtonElement(is_momentary, MIDI_NOTE_TYPE, track_index, (scene_index + 53)) #use Launchpad configurable button instead
button.name = str(track_index) + '_Clip_' + str(scene_index) + '_Button'
button_row.append(button)
clip_slot = scene.clip_slot(track_index)
clip_slot.name = str(track_index) + '_Clip_Slot_' + str(scene_index)
clip_slot.set_triggered_to_play_value(2)
clip_slot.set_triggered_to_record_value(4)
clip_slot.set_stopped_value(3)
clip_slot.set_started_value(1)
clip_slot.set_recording_value(5)
clip_slot.set_launch_button(button)
self._matrix.add_row(tuple(button_row)) #matrix.add_row(tuple(button_row))
# Removing the launch selected clip footpedal option
#self._session.set_slot_launch_button(ButtonElement(is_momentary, MIDI_CC_TYPE, 0, 67))
self._session.selected_scene().name = 'Selected_Scene'
self._session.selected_scene().set_launch_button(ButtonElement(is_momentary, MIDI_CC_TYPE, 0, 64))
self._session_zoom = SessionZoomingComponent(self._session) #use APC20 Zooming instead
self._session_zoom.name = 'Session_Overview'
self._session_zoom.set_button_matrix(self._matrix) #was: self._session_zoom.set_button_matrix(matrix)
self._session_zoom.set_zoom_button(self._shift_button) #set in MatrixModesComponent instead
self._session_zoom.set_nav_buttons(up_button, down_button, left_button, right_button)
self._session_zoom.set_scene_bank_buttons(tuple(scene_launch_buttons))
self._session_zoom.set_stopped_value(3)
self._session_zoom.set_selected_value(5)
return None
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 AumPC40(APC):
__doc__ = " Script for Akai's APC40 Controller "
def __init__(self, c_instance, *a, **k):
super(AumPC40, self).__init__(c_instance, *a, **k)
self._device_selection_follows_track_selection = True
def _setup_session_control(self):
is_momentary = True
self._shift_button = AumPCMonoButtonElement(is_momentary,
MIDI_NOTE_TYPE, 0, 98,
'Shift_Button', self)
right_button = AumPCMonoButtonElement(is_momentary, MIDI_NOTE_TYPE, 0,
96, 'Right_Button', self)
self._right_button = right_button
left_button = AumPCMonoButtonElement(is_momentary, MIDI_NOTE_TYPE, 0,
97, 'Left_Button', self)
self._left_button = left_button
up_button = AumPCMonoButtonElement(is_momentary, MIDI_NOTE_TYPE, 0, 94,
'Up_Button', self)
self._up_button = up_button
down_button = AumPCMonoButtonElement(is_momentary, MIDI_NOTE_TYPE, 0,
95, 'Down_Button', self)
self._down_button = down_button
self._session = PedaledSessionComponent(8, 5)
self._session.name = 'Session_Control'
self._session.set_track_bank_buttons(right_button, left_button)
self._session.set_scene_bank_buttons(down_button, up_button)
matrix = ButtonMatrixElement()
self._matrix = matrix # added a
matrix.name = 'Button_Matrix'
scene_launch_buttons = [
ButtonElement(is_momentary, MIDI_NOTE_TYPE, 0, (index + 82))
for index in range(5)
]
track_stop_buttons = [
AumPCMonoButtonElement(is_momentary, MIDI_NOTE_TYPE, index, 52,
'Track_' + str(index) + '_Stop_Button',
self) for index in range(8)
]
self._track_stop_buttons = track_stop_buttons # added a
for index in range(len(scene_launch_buttons)):
scene_launch_buttons[index].name = 'Scene_' + str(
index) + '_Launch_Button'
stop_all_button = ButtonElement(is_momentary, MIDI_NOTE_TYPE, 0, 81)
stop_all_button.name = 'Stop_All_Clips_Button'
self._session.set_stop_all_clips_button(stop_all_button)
self._session.set_stop_track_clip_buttons(tuple(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(scene_launch_buttons[scene_index])
scene.set_triggered_value(2)
for track_index in range(8):
button = AumPCMonoButtonElement(
is_momentary, MIDI_NOTE_TYPE, track_index,
(scene_index + 53),
str(track_index) + '_Clip_' + str(scene_index) + '_Button',
self)
#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)
matrix.add_row(tuple(button_row))
self._session.set_slot_launch_button(
ButtonElement(is_momentary, MIDI_CC_TYPE, 0, 67))
self._session.selected_scene().name = 'Selected_Scene'
self._session.selected_scene().set_launch_button(
ButtonElement(is_momentary, MIDI_CC_TYPE, 0, 64))
self._session_zoom = SessionZoomingComponent(self._session)
self._session_zoom.name = 'Session_Overview'
self._session_zoom.set_button_matrix(matrix)
self._session_zoom.set_zoom_button(self._shift_button)
self._session_zoom.set_nav_buttons(up_button, down_button, left_button,
right_button)
self._session_zoom.set_scene_bank_buttons(tuple(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(8)
self._mixer.name = 'Mixer'
self._mixer.master_strip().name = 'Master_Channel_Strip'
self._mixer.selected_strip().name = 'Selected_Channel_Strip'
self._solo_buttons = [] # added a
self._select_buttons = [] # added a
for track in range(8):
strip = self._mixer.channel_strip(track)
strip.name = 'Channel_Strip_' + str(track)
volume_control = EncoderElement(
MIDI_CC_TYPE, track, 7, Live.MidiMap.MapMode.absolute
) # 'Slider_' + str(track), track, self)
arm_button = ButtonElement(is_momentary, MIDI_NOTE_TYPE, track, 48)
solo_button = AumPCMonoButtonElement(is_momentary, MIDI_NOTE_TYPE,
track, 50,
str(track) + '_Solo_Button',
self)
self._solo_buttons.append(solo_button) # added a
mute_button = ButtonElement(is_momentary, MIDI_NOTE_TYPE, track,
49)
select_button = AumPCMonoButtonElement(
is_momentary, MIDI_NOTE_TYPE, track, 51,
str(track) + '_Select_Button', self)
self._select_buttons.append(select_button) # added a
#volume_control.name = str(track) + '_Volume_Control'
arm_button.name = str(track) + '_Arm_Button'
#solo_button.name = str(track) + '_Solo_Button'
mute_button.name = str(track) + '_Mute_Button'
#select_button.name = str(track) + '_Select_Button'
strip.set_volume_control(volume_control)
strip.set_arm_button(arm_button)
strip.set_solo_button(solo_button)
strip.set_mute_button(mute_button)
strip.set_select_button(select_button)
strip.set_shift_button(self._shift_button)
strip.set_invert_mute_feedback(True)
crossfader = SliderElement(MIDI_CC_TYPE, 0, 15)
self._crossfader = crossfader
self._crossfader.name = 'Crossfader'
master_volume_control = SliderElement(MIDI_CC_TYPE, 0, 14)
master_select_button = ButtonElement(is_momentary, MIDI_NOTE_TYPE, 0,
80)
self._master_select_button = master_select_button
prehear_control = EncoderElement(
MIDI_CC_TYPE, 0, 47, Live.MidiMap.MapMode.relative_two_compliment)
crossfader.name = 'Crossfader'
master_volume_control.name = 'Master_Volume_Control'
master_select_button.name = 'Master_Select_Button'
prehear_control.name = 'Prehear_Volume_Control'
self._mixer.set_crossfader_control(crossfader)
self._mixer.set_prehear_volume_control(prehear_control)
self._mixer.master_strip().set_volume_control(master_volume_control)
self._mixer.master_strip().set_select_button(master_select_button)
def _setup_custom_components(self):
self._setup_device_and_transport_control()
self._setup_global_control()
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 = MonoRingedEncoderElement(
MIDI_CC_TYPE, 0, 16 + index, Live.MidiMap.MapMode.absolute,
index, self)
ringed_encoder.set_ring_mode_button(ring_mode_button)
ringed_encoder.name = 'Device_Control_' + str(index)
ring_mode_button.name = ringed_encoder.name + '_Ring_Mode_Button'
device_param_controls.append(ringed_encoder)
device = ShiftableDeviceComponent()
device.name = 'Device_Component'
device.set_bank_buttons(tuple(device_bank_buttons))
device.set_shift_button(self._shift_button)
device.set_parameter_controls(tuple(device_param_controls))
device.set_on_off_button(device_bank_buttons[1])
self.set_device_component(device)
self._device = 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'
self._transport = 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 = AumPCMonoButtonElement(is_momentary, MIDI_NOTE_TYPE,
0, 100, 'Nudge_Up_Button',
self)
self._nudge_up_button = nudge_up_button
nudge_down_button = AumPCMonoButtonElement(is_momentary,
MIDI_NOTE_TYPE, 0, 101,
'Nudge_Down_Button', self)
self._nudge_down_button = nudge_down_button
tap_tempo_button = ButtonElement(is_momentary, MIDI_NOTE_TYPE, 0, 99)
play_button.name = 'Play_Button'
stop_button.name = 'Stop_Button'
record_button.name = 'Record_Button'
#nudge_up_button.name = 'Nudge_Up_Button'
#nudge_down_button.name = 'Nudge_Down_Button'
tap_tempo_button.name = 'Tap_Tempo_Button'
transport.set_shift_button(self._shift_button)
transport.set_play_button(play_button)
transport.set_stop_button(stop_button)
transport.set_record_button(record_button)
transport.set_nudge_buttons(nudge_up_button, nudge_down_button)
transport.set_tap_tempo_button(tap_tempo_button)
transport.set_quant_toggle_button(device_bank_buttons[5])
transport.set_overdub_button(device_bank_buttons[6])
transport.set_metronome_button(device_bank_buttons[7])
bank_button_translator = ShiftTranslatorComponent()
bank_button_translator.set_controls_to_translate(
tuple(device_bank_buttons))
bank_button_translator.set_shift_button(self._shift_button)
def _setup_global_control(self):
is_momentary = True
global_bank_buttons = []
global_param_controls = []
for index in range(8):
ring_button = ButtonElement(not is_momentary, MIDI_CC_TYPE, 0,
56 + index)
ringed_encoder = MonoRingedEncoderElement(
MIDI_CC_TYPE, 0, 48 + index, Live.MidiMap.MapMode.absolute,
index + 8, self)
ringed_encoder.name = 'Track_Control_' + str(index)
ring_button.name = ringed_encoder.name + '_Ring_Mode_Button'
ringed_encoder.set_ring_mode_button(ring_button)
global_param_controls.append(ringed_encoder)
global_bank_buttons = []
global_bank_labels = ('Pan_Button', 'Send_A_Button', 'Send_B_Button',
'Send_C_Button')
for index in range(4):
global_bank_buttons.append(
ButtonElement(not is_momentary, MIDI_NOTE_TYPE, 0, 87 + index))
global_bank_buttons[-1].name = global_bank_labels[index]
encoder_modes = EncModeSelectorComponent(self._mixer)
encoder_modes.name = 'Track_Control_Modes'
encoder_modes.set_modes_buttons(global_bank_buttons)
encoder_modes.set_controls(tuple(global_param_controls))
global_translation_selector = ChannelTranslationSelector()
global_translation_selector.name = 'Global_Translations'
global_translation_selector.set_controls_to_translate(
tuple(global_param_controls))
global_translation_selector.set_mode_buttons(
tuple(global_bank_buttons))
def _product_model_id_byte(self):
return 115
def _setup_monobridge(self):
self._monobridge = MonoBridgeElement(self)
self._monobridge.name = 'MonoBridge'
def _setup_monomod(self):
self._host = MonomodComponent(self)
self._host.name = 'Monomod_Host'
self._host._navbox_selected = 16
self._host._navbox_unselected = 1
self.hosts = [self._host]
self._monomod = ButtonMatrixElement()
self._monomod.name = 'Monomod'
for row in range(5):
button_row = []
for column in range(8):
button_row.append(self._matrix.get_button(column, row))
self._monomod.add_row(tuple(button_row))
self._monomod.add_row(tuple(self._track_stop_buttons))
self._monomod.add_row(tuple(self._select_buttons))
self._monomod.add_row(tuple(self._solo_buttons))
self._monomod_mode = MonomodModeComponent(self._monomod_mode_update,
self)
self._monomod_mode.name = "Monomod_Mode_Component"
self._shift_button.add_value_listener(self._shift_value)
def _shift_value(self, value):
if value > 0:
self._mixer.master_strip().set_select_button(None)
self._monomod_mode.set_mode_toggle(self._master_select_button)
else:
self._mixer.master_strip().set_select_button(
self._master_select_button)
self._monomod_mode.set_mode_toggle(None)
def _monomod_mode_update(self):
#self.log_message('mode update: ' + str(self._monomod_mode._mode_index))
if (self._monomod_mode._mode_index == 0) or (self._host._active_client
== None):
self.flash_status = 0
self._host.set_enabled(False)
self._host._set_button_matrix(None)
self._host._set_nav_buttons(None)
self._host._set_lock_button(None)
self._host._set_alt_button(None)
self._host._set_shift_button(None)
self._monomod.reset()
self._session.set_track_bank_buttons(self._right_button,
self._left_button)
self._session.set_scene_bank_buttons(self._down_button,
self._up_button)
for track in range(8):
self._mixer.channel_strip(track).set_select_button(
self._select_buttons[track])
self._mixer.channel_strip(track).set_solo_button(
self._solo_buttons[track])
self._transport.set_nudge_buttons(self._nudge_up_button,
self._nudge_down_button)
self._session.set_enabled(True)
self._session_zoom._is_zoomed_out = False
self._session_zoom.set_enabled(True)
self.request_rebuild_midi_map()
self._master_select_button.turn_off()
elif (self._monomod_mode._mode_index == 1):
self._transport.set_nudge_buttons(None, None)
for track in range(8):
self._mixer.channel_strip(track).set_select_button(None)
self._mixer.channel_strip(track).set_solo_button(None)
self._session.set_enabled(False)
self._session_zoom.set_enabled(False)
self._session.set_track_bank_buttons(None, None)
self._session.set_scene_bank_buttons(None, None)
self.flash_status = 1
self._monomod.reset()
self._host._set_button_matrix(self._monomod)
self._host._set_nav_buttons([
self._up_button, self._down_button, self._left_button,
self._right_button
])
self._host._set_shift_button(self._shift_button)
self._host._set_lock_button(self._nudge_up_button)
self._host._set_alt_button(self._nudge_down_button)
self._host.set_enabled(True)
self.request_rebuild_midi_map()
self._master_select_button.turn_on()
#self.log_message('mod mode')
"""m4l bridge"""
def generate_strip_string(self, display_string):
#self.log_message(display_string)
NUM_CHARS_PER_DISPLAY_STRIP = 12
if (not display_string):
return (' ' * NUM_CHARS_PER_DISPLAY_STRIP)
if ((len(display_string.strip()) > (NUM_CHARS_PER_DISPLAY_STRIP - 1))
and (display_string.endswith('dB') and
(display_string.find('.') != -1))):
display_string = display_string[:-2]
if (len(display_string) > (NUM_CHARS_PER_DISPLAY_STRIP - 1)):
for um in [' ', 'i', 'o', 'u', 'e', 'a']:
while ((len(display_string) >
(NUM_CHARS_PER_DISPLAY_STRIP - 1))
and (display_string.rfind(um, 1) != -1)):
um_pos = display_string.rfind(um, 1)
display_string = (display_string[:um_pos] +
display_string[(um_pos + 1):])
else:
display_string = display_string.center(
(NUM_CHARS_PER_DISPLAY_STRIP - 1))
ret = u''
for i in range((NUM_CHARS_PER_DISPLAY_STRIP - 1)):
if ((ord(display_string[i]) > 127)
or (ord(display_string[i]) < 0)):
ret += ' '
else:
ret += display_string[i]
ret += ' '
assert (len(ret) == NUM_CHARS_PER_DISPLAY_STRIP)
return ret
def notification_to_bridge(self, name, value, sender):
if isinstance(sender, (MonoRingedEncoderElement, MonoEncoderElement)):
self._monobridge._send(sender.name, 'lcd_name',
str(self.generate_strip_string(name)))
self._monobridge._send(sender.name, 'lcd_value',
str(self.generate_strip_string(value)))
def touched(self):
if self._touched is 0:
self._monobridge._send('touch', 'on')
self.schedule_message(2, self.check_touch)
self._touched += 1
def check_touch(self):
if self._touched > 5:
self._touched = 5
elif self._touched > 0:
self._touched -= 1
if self._touched is 0:
self._monobridge._send('touch', 'off')
else:
self.schedule_message(2, self.check_touch)
def get_clip_names(self):
clip_names = []
for scene in self._session._scenes:
for clip_slot in scene._clip_slots:
if clip_slot.has_clip() is True:
clip_names.append(clip_slot._clip_slot) ##.clip.name)
return clip_slot._clip_slot
##self.log_message(str(clip_slot._clip_slot.clip.name))
return clip_names
def update_display(self):
ControlSurface.update_display(self)
self._timer = (self._timer + 1) % 256
self.flash()
def flash(self):
if self.flash_status:
for control in self.controls:
if isinstance(control, MonoButtonElement):
control.flash(self._timer)
