def add_matrix(self, name, element_factory, channel, numbers,
midi_message_type):
assert (name not in self.keys())
def one_dimensional_name(base_name, x, _y):
return '%s_%d' % (base_name, x)
def two_dimensional_name(base_name, x, y):
return '%s_%d_%d' % (base_name, x, y)
name_factory = two_dimensional_name if len(
numbers) > 1 else one_dimensional_name
elements = []
id_dict = {}
for row, identifiers in enumerate(numbers):
element_row = []
for column, identifier in enumerate(identifiers):
element_row.append(
element_factory(name_factory(name, column, row), channel,
identifier, midi_message_type))
id_dict[identifier] = (column, row)
elements.append(element_row)
self['%s_Raw' % name] = elements
self['%s_Ids' % name] = id_dict
self[name] = ButtonMatrixElement(rows=elements, name=name)
def _create_controls(self):
make_on_off_button = partial(make_button, skin=self._default_skin)
make_color_button = partial(make_button, skin=self._color_skin)
make_stop_button = partial(make_button, skin=self._stop_button_skin)
self._shift_button = make_button(0,
98,
resource_type=SharedResource,
name=u'Shift_Button')
self._parameter_knobs = [
make_knob(0, index + 48, name=u'Parameter_Knob_%d' % (index + 1))
for index in xrange(self.SESSION_WIDTH)
]
self._select_buttons = [
make_stop_button(0,
64 + index,
name=u'Track_Select_%d' % (index + 1))
for index in xrange(self.SESSION_WIDTH)
]
self._up_button = self.make_shifted_button(self._select_buttons[0])
self._down_button = self.make_shifted_button(self._select_buttons[1])
self._left_button = self.make_shifted_button(self._select_buttons[2])
self._right_button = self.make_shifted_button(self._select_buttons[3])
self._volume_button = self.make_shifted_button(self._select_buttons[4])
self._pan_button = self.make_shifted_button(self._select_buttons[5])
self._send_button = self.make_shifted_button(self._select_buttons[6])
self._device_button = self.make_shifted_button(self._select_buttons[7])
if self.HAS_TRANSPORT:
self._play_button = make_on_off_button(0, 91, name=u'Play_Button')
self._record_button = make_on_off_button(0,
93,
name=u'Record_Button')
def matrix_note(x, y):
return x + self.SESSION_WIDTH * (self.SESSION_HEIGHT - y - 1)
self._matrix_buttons = [[
make_color_button(0,
matrix_note(track, scene),
name=u'%d_Clip_%d_Button' % (track, scene))
for track in xrange(self.SESSION_WIDTH)
] for scene in xrange(self.SESSION_HEIGHT)]
self._session_matrix = ButtonMatrixElement(name=u'Button_Matrix',
rows=self._matrix_buttons)
self._scene_launch_buttons = [
make_color_button(0,
index + 82,
name=u'Scene_Launch_%d' % (index + 1))
for index in xrange(self.SESSION_HEIGHT)
]
self._stop_button = self.make_shifted_button(
self._scene_launch_buttons[0])
self._solo_button = self.make_shifted_button(
self._scene_launch_buttons[1])
self._arm_button = self.make_shifted_button(
self._scene_launch_buttons[2])
self._mute_button = self.make_shifted_button(
self._scene_launch_buttons[3])
self._select_button = self.make_shifted_button(
self._scene_launch_buttons[4])
self._stop_all_button = self._make_stop_all_button()
def _setup_device(self):
"""Create a DeviceComponent to control macro knobs"""
self._device = DeviceComponent()
self.set_device_component(self._device)
param_knobs = ButtonMatrixElement(rows=[self._knobs[0:8]])
self._device.layer = Layer(parameter_controls=param_knobs)
def _setup_session_control(self):
is_momentary = True
self._session = SpecialSessionComponent(NUM_TRACKS, NUM_SCENES)
self._session.set_serato_interface(self._serato_interface)
self._matrix = ButtonMatrixElement()
self._scene_launch_buttons = [
ButtonElement(is_momentary, MIDI_NOTE_TYPE, 0, 0)
for index in range(NUM_SCENES)
]
self._track_stop_buttons = [
ButtonElement(not is_momentary, MIDI_NOTE_TYPE, 0, 0)
for index in range(NUM_TRACKS)
]
stop_all_button = ButtonElement(is_momentary, MIDI_NOTE_TYPE, 0, 0)
self._session.set_stop_all_clips_button(stop_all_button)
self._session.set_stop_track_clip_buttons(
tuple(self._track_stop_buttons))
for scene_index in range(NUM_SCENES):
scene = self._session.scene(scene_index)
button_row = []
scene.set_launch_button(self._scene_launch_buttons[scene_index])
scene.set_index(scene_index)
scene.set_serato_interface(self._serato_interface)
for track_index in range(NUM_TRACKS):
button = ButtonElement(is_momentary, MIDI_NOTE_TYPE, 0, 0)
button_row.append(button)
clip_slot = scene.clip_slot(track_index)
clip_slot.set_launch_button(button)
clip_slot.set_serato_interface(self._serato_interface)
self._matrix.add_row(tuple(button_row))
def __init__(self, *a, **k):
super(Advance, self).__init__(*a, **k)
with self.component_guard():
encoders = ButtonMatrixElement(rows=[[ make_encoder(index + 22, 'Encoder_%d' % index) for index in xrange(8) ]])
pads = ButtonMatrixElement(rows=[ [ make_button(identifier, 'Pad_%d_%d' % (col, row)) for col, identifier in enumerate(row_ids) ] for row, row_ids in enumerate(PAD_IDS) ])
device = DeviceComponent(is_enabled=False, layer=Layer(parameter_controls=encoders))
device.set_enabled(True)
self.set_device_component(device)
self._device_selection_follows_track_selection = True
drums = DrumRackComponent(is_enabled=False, layer=Layer(pads=pads))
drums.set_enabled(True)
play_button = make_button(118, 'Play_Button', MIDI_CC_TYPE, 0)
stop_button = make_button(117, 'Stop_Button', MIDI_CC_TYPE, 0)
record_button = make_button(119, 'Record_Button', MIDI_CC_TYPE, 0)
loop_button = make_button(114, 'Loop_Button', MIDI_CC_TYPE, 0)
transport = TransportComponent(is_enabled=False, layer=Layer(play_button=play_button, stop_button=stop_button, record_button=record_button, loop_button=loop_button))
transport.set_enabled(True)
def _create_controls(self):
self._encoders = ButtonMatrixElement(rows=[
[ make_encoder(identifier, name='Encoder_%d' % (index,)) for index, identifier in enumerate(xrange(21, 29))
]])
self._top_pad_row = ButtonMatrixElement(rows=[
[ make_button(identifier, name='Pad_0_%d' % (index,)) for index, identifier in enumerate(xrange(96, 104))
]])
self._bottom_pad_row_raw = [ make_button(identifier, name='Pad_1_%d' % (index,)) for index, identifier in enumerate(xrange(112, 120))
]
self._bottom_pad_row = ButtonMatrixElement(rows=[self._bottom_pad_row_raw])
self._top_launch_button = make_button(104, name='Scene_Launch_Button')
self._bottom_launch_button = make_button(120, name='Stop_All_Clips_Button')
self._scene_up_button = make_button(112, MIDI_CC_TYPE, name='Scene_Up_Button')
self._scene_down_button = make_button(113, MIDI_CC_TYPE, name='Scene_Down_Button')
self._stop_button = make_button(114, MIDI_CC_TYPE, name='Stop_Button')
self._play_button = make_button(115, MIDI_CC_TYPE, name='Play_Button')
self._loop_button = make_button(116, MIDI_CC_TYPE, name='Loop_Button')
self._record_button = make_button(117, MIDI_CC_TYPE, name='Record_Button')
self._sliders = ButtonMatrixElement(rows=[
[ make_slider(identifier, name='Slider_%d' % (index,)) for index, identifier in enumerate(xrange(41, 49))
]])
self._master_slider = make_slider(7, name='Master_Slider')
self._25_key_slider = make_slider(7, name='Slider', channel=0)
self._mute_buttons_raw = [ make_button(identifier, MIDI_CC_TYPE, name='Mute_Button_%d' % (index,)) for index, identifier in enumerate(xrange(51, 59))
]
self._mute_buttons = ButtonMatrixElement(rows=[self._mute_buttons_raw])
self._master_button = make_button(59, MIDI_CC_TYPE, name='Master_Button')
self._track_left_button = make_button(102, MIDI_CC_TYPE, name='Track_Left_Button')
self._track_right_button = make_button(103, MIDI_CC_TYPE, name='Track_Right_Button')
self._device_mode_button = self._bottom_pad_row_raw[0]
self._pan_mode_button = self._bottom_pad_row_raw[1]
self._send_mode_buttons = dict()
for index in xrange(consts.MAX_SENDS):
setattr(self, '_send_%d_button' % (index,), self._bottom_pad_row_raw[(index + 2)])
self._send_mode_buttons['send_%d_mode_button' % (index,)] = getattr(self, '_send_%d_button' % (index,))
self._extended_mode_button = make_button(12, name='Dummy_Extended_Mode_Button')
self._extended_mode_button.add_value_listener(nop)
self._encoder_incontrol_button = make_button(13, is_momentary=False, name='Encoder_InControl_Button')
self._encoder_incontrol_button.add_value_listener(nop)
self._slider_incontrol_button = make_button(14, is_momentary=False, name='Fader_InControl_Button')
self._slider_incontrol_button.add_value_listener(nop)
self._pad_incontrol_button = make_button(15, is_momentary=False, name='Pad_InControl_Button')
self._pad_incontrol_button.add_value_listener(self._update_pads)
self._encoder_incontrol_button2 = make_button(16, name='Encoder_InControl_Button')
self._pad_in_control_status_button = make_button(11, name='Dummy_InControl_Button')
def _create_controls(self):
self._create_pads()
self._encoders = ButtonMatrixElement(rows=[[
make_encoder(identifier, 0, 'Encoder_%d' % index)
for index, identifier in enumerate(xrange(22, 30))
]])
self._sliders = ButtonMatrixElement(rows=[[
make_slider(identifier, 0, 'Slider_%d' % index)
for index, identifier in enumerate(xrange(12, 20))
]])
self._control_buttons = ButtonMatrixElement(rows=[[
make_button(identifier, 0, 'Control_Button_%d' % index)
for index, identifier in enumerate(xrange(32, 40))
]])
self._play_button = make_button(118, 0, 'Play_Button')
self._stop_button = make_button(117, 0, 'Stop_Button')
self._record_button = make_button(119, 0, 'Record_Button')
def _create_controls(self):
super(MiniLabMk2, self)._create_controls()
self._pad_leds = ButtonMatrixElement(rows=[ [ SysexValueControl(message_prefix=SETUP_MSG_PREFIX + (WRITE_COMMAND,
WORKING_MEMORY_ID,
COLOR_PROPERTY,
column + 112 + row * 8), default_value=(0,), name=u'Pad_LED_%d' % (column,)) for column in range(8) ] for row in range(2) ], name=u'Pad_LED_Matrix')
self._memory_slot_selection = SysexValueControl(message_prefix=SETUP_MSG_PREFIX + (MEMORY_SLOT_PROPERTY,), name=u'Memory_Slot_Selection')
self._hardware_live_mode_switch = SysexValueControl(message_prefix=LIVE_MODE_MSG_HEAD, default_value=(OFF_VALUE,), name=u'Hardware_Live_Mode_Switch')
def _create_instrument_layer(self):
return Layer(
playhead=self._playhead,
#mute_button=self._global_mute_button,
quantization_buttons=self._stop_buttons,
loop_selector_matrix=self._double_press_matrix.submatrix[:8, :1],# [:, 0]
short_loop_selector_matrix=self._double_press_event_matrix.submatrix[:, 0],# [:, 0]
note_editor_matrices=ButtonMatrixElement([[ self._session_matrix.submatrix[:, 4 - row] for row in xrange(7) ]]))
def _create_controls(self):
""" Add some additional stuff baby """
super(PHAZE, self)._create_controls()
self._grid_resolution = GridResolution()
self._velocity_slider = ButtonSliderElement(tuple(self._scene_launch_buttons_raw[::-1]))
double_press_rows = recursive_map(DoublePressElement, self._matrix_rows_raw)
self._double_press_matrix = ButtonMatrixElement(name='Double_Press_Matrix', rows=double_press_rows)
self._double_press_event_matrix = ButtonMatrixElement(name='Double_Press_Event_Matrix', rows=recursive_map(lambda x: x.double_press, double_press_rows))
self._playhead = PlayheadElement(self._c_instance.playhead)
# Make these prioritized resources, which share between Layers() equally
# Rather than building a stack
"""not sure but we greened out below on 05/11/17.. maybe work on order of definitions so as to tidy up some"""
self._pan_button._resource_type = PrioritizedResource
self._user_button._resource_type = PrioritizedResource
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_controls(self): is_momentary = True self._fader = [None for index in range(8)] self._dial = [None for index in range(8)] self._button = [None for index in range(8)] self._menu = [None for index in range(6)] for index in range(2): self._fader[index] = MonoEncoderElement(MIDI_CC_TYPE, CHANNEL, SLIDER_CC[index], Live.MidiMap.MapMode.absolute, 'Fader_' + str(index), 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(8): self._dial[index] = MonoEncoderElement(MIDI_CC_TYPE, CHANNEL, KNOB_CC[index], Live.MidiMap.MapMode.absolute, 'Dial_' + str(index), index + 8, self) for index in range(4): self._menu[index] = MonoButtonElement(is_momentary, MIDI_NOTE_TYPE, CHANNEL, FUNCTION_NOTES[index], 'Menu_' + str(index), self) #self._livid = MonoButtonElement(is_momentary, MIDI_NOTE_TYPE, CHANNEL, LIVID, 'Livid_Button', self) self._livid = DoublePressElement(MonoButtonElement(is_momentary, MIDI_NOTE_TYPE, CHANNEL, LIVID, 'Livid_Button', self)) self._shift_l = MonoButtonElement(is_momentary, MIDI_NOTE_TYPE, CHANNEL, SHIFT_L, 'Shift_Button_Left', self) self._shift_r = MonoButtonElement(is_momentary, MIDI_NOTE_TYPE, CHANNEL, SHIFT_R, 'Shift_Button_Right', 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] = MonoButtonElement(is_momentary, MIDI_NOTE_TYPE, CHANNEL, (column * 8) + row, 'Grid_' + 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._dial_matrix = ButtonMatrixElement() self._dial_matrix.add_row(self._dial)
def __init__(self, *a, **k):
super(Alesis_V, self).__init__(*a, **k)
with self.component_guard():
encoders = ButtonMatrixElement(rows=[
[ EncoderElement(MIDI_CC_TYPE, 0, identifier + 20, Live.MidiMap.MapMode.absolute, name='Encoder_%d' % identifier) for identifier in xrange(4)
]])
device = DeviceComponent(name='Device', is_enabled=False, layer=Layer(parameter_controls=encoders), device_selection_follows_track_selection=True)
device.set_enabled(True)
self.set_device_component(device)
def _setup_mixer(self):
self._mixer = MixerComponent(NUM_CHANNEL_STRIPS)
self._mixer.name = 'Mixer'
self._mixer.set_enabled(False)
for index in xrange(NUM_CHANNEL_STRIPS):
strip = self._mixer.channel_strip(index)
strip.set_invert_mute_feedback(True)
sends = ButtonMatrixElement(name='%d_Send_Controls' % (index + 1), rows=[(self._rotaries_a[index], self._rotaries_b[index])])
strip.layer = Layer(volume_control=self._faders[index], pan_control=self._encoders[index], send_controls=sends, mute_button=self._mute_buttons[index], solo_button=self._solo_buttons[index], arm_button=self._arm_buttons[index], select_button=self._encoder_pushes[index])
def _create_pads(self):
self._pads = ButtonMatrixElement(rows=[[
ButtonElement(True,
MIDI_NOTE_TYPE,
self._pad_channel,
pad_id,
name=u'Pad_%d_%d' % (col_index, row_index))
for col_index, pad_id in enumerate(row)
] for row_index, row in enumerate(self._pad_ids)])
def __init__(self, w, h,hold,mode):
#ButtonMatrixElement.__init__(self)
self._matrix = ButtonMatrixElement()
self._matrix.name = 'Launchpad_Main_Grid'
self._width = w
self._height = h
self._hold = hold
self.setup_button_arrays()
self.set_grid_mapping_mode(mode)
def __init__(self, c_instance):
ControlSurface.__init__(self, c_instance)
self._monomod_version = 'b994'
self._host_name = 'LaunchMod'
self._color_type = 'Launchpad'
self.hosts = []
self._timer = 0
self.set_suppress_rebuild_requests(True)
self._suppress_send_midi = True
self._suppress_session_highlight = True
is_momentary = True
self._suggested_input_port = 'Launchpad'
self._suggested_output_port = 'Launchpad'
self._wrote_user_byte = False
self._control_is_with_automap = False
self._challenge = (Live.Application.get_random_int(0, 400000000)
& 2139062143)
matrix = ButtonMatrixElement()
matrix.name = 'ButtonMatrix'
for row in range(8):
#button_row = [ ConfigurableButtonElement(is_momentary, MIDI_NOTE_TYPE, 0, ((row * 16) + column)) for column in range(8) ]
button_row = [
FlashingButtonElement(is_momentary, MIDI_NOTE_TYPE, 0,
((row * 16) + column),
'Button_' + str(row) + '_' + str(column),
self) for column in range(8)
]
matrix.add_row(tuple(button_row))
self._config_button = ButtonElement(is_momentary, MIDI_CC_TYPE, 0, 0)
self._config_button.add_value_listener(self._config_value)
top_buttons = [
FlashingButtonElement(is_momentary, MIDI_CC_TYPE, 0, (104 + index),
'Top_Button' + str(index), self)
for index in range(8)
]
side_buttons = [
FlashingButtonElement(is_momentary, MIDI_NOTE_TYPE, 0,
SIDE_NOTES[index],
'Side_Button' + str(index), self)
for index in range(8)
]
self._setup_monobridge()
self._setup_monomod()
self._selector = MainSelectorComponent(matrix, tuple(top_buttons),
tuple(side_buttons),
self._config_button, self)
self._suppress_session_highlight = False
self._suppress_send_midi = False
self._user_byte_write_button = ButtonElement(is_momentary,
MIDI_CC_TYPE, 0, 16)
self._user_byte_write_button.send_value(1)
self._user_byte_write_button.add_value_listener(self._user_byte_value)
self._suppress_send_midi = True
self.set_suppress_rebuild_requests(False)
self.log_message("--------------= LaunchMod log opened =--------------"
) #Create entry in log file
self.refresh_state()
def __init__(self, c_instance):
ControlSurface.__init__(self, c_instance)
with self.component_guard():
self._suppress_send_midi = True
self._suppress_session_highlight = True
is_momentary = True
self._suggested_input_port = 'Launchpad'
self._suggested_output_port = 'Launchpad'
self._control_is_with_automap = False
self._user_byte_write_button = ButtonElement(is_momentary, MIDI_CC_TYPE, 0, 16)
self._user_byte_write_button.name = 'User_Byte_Button'
self._user_byte_write_button.send_value(1)
self._user_byte_write_button.add_value_listener(self._user_byte_value)
self._wrote_user_byte = False
self._challenge = Live.Application.get_random_int(0, 400000000) & 2139062143
matrix = ButtonMatrixElement()
matrix.name = 'Button_Matrix'
for row in range(8):
button_row = []
for column in range(8):
button = ConfigurableButtonElement(is_momentary, MIDI_NOTE_TYPE, 0, row * 16 + column)
button.name = str(column) + '_Clip_' + str(row) + '_Button'
button_row.append(button)
matrix.add_row(tuple(button_row))
self._config_button = ButtonElement(is_momentary, MIDI_CC_TYPE, 0, 0, optimized_send_midi=False)
self._config_button.add_value_listener(self._config_value)
top_buttons = [ ConfigurableButtonElement(is_momentary, MIDI_CC_TYPE, 0, 104 + index) for index in range(8)
]
side_buttons = [ ConfigurableButtonElement(is_momentary, MIDI_NOTE_TYPE, 0, SIDE_NOTES[index]) for index in range(8)
]
top_buttons[0].name = 'Bank_Select_Up_Button'
top_buttons[1].name = 'Bank_Select_Down_Button'
top_buttons[2].name = 'Bank_Select_Left_Button'
top_buttons[3].name = 'Bank_Select_Right_Button'
top_buttons[4].name = 'Session_Button'
top_buttons[5].name = 'User1_Button'
top_buttons[6].name = 'User2_Button'
top_buttons[7].name = 'Mixer_Button'
side_buttons[0].name = 'Vol_Button'
side_buttons[1].name = 'Pan_Button'
side_buttons[2].name = 'SndA_Button'
side_buttons[3].name = 'SndB_Button'
side_buttons[4].name = 'Stop_Button'
side_buttons[5].name = 'Trk_On_Button'
side_buttons[6].name = 'Solo_Button'
side_buttons[7].name = 'Arm_Button'
self._selector = MainSelectorComponent(matrix, tuple(top_buttons), tuple(side_buttons), self._config_button)
self._selector.name = 'Main_Modes'
for control in self.controls:
if isinstance(control, ConfigurableButtonElement):
control.add_value_listener(self._button_value)
self.set_highlighting_session_component(self._selector.session_component())
self._suppress_session_highlight = False
def _setup_session(self):
self._session = SessionComponent(NUM_CHANNEL_STRIPS, name='Session_Control')
self._session.set_enabled(False)
stop_buttons = ButtonMatrixElement(name='Track_Stop_Buttons', rows=[self._shifted_solo_buttons])
self._session.layer = Layer(stop_all_clips_button=self._shifted_stop_button, stop_track_clip_buttons=stop_buttons, select_prev_button=self._shifted_octave_down_button, select_next_button=self._shifted_octave_up_button)
self._session.selected_scene().name = 'Selected_Scene_Control'
self._session.selected_scene().layer = Layer(launch_button=self._shifted_play_button)
for index in xrange(NUM_CHANNEL_STRIPS):
slot = self._session.selected_scene().clip_slot(index)
slot.layer = Layer(launch_button=self._shifted_mute_buttons[index])
def _create_controls(self):
super(MPD226, self)._create_controls()
self._encoders = ButtonMatrixElement(rows=[[
make_encoder(identifier, 0 if index < 4 else 1, 'Encoder_%d' %
index)
for index, identifier in izip(xrange(8), cycle(xrange(22, 26)))
]])
self._sliders = ButtonMatrixElement(rows=[[
make_slider(identifier, 0 if index < 4 else 1, 'Slider_%d' % index)
for index, identifier in izip(xrange(8), cycle(xrange(12, 16)))
]])
self._control_buttons = ButtonMatrixElement(rows=[[
make_button(identifier, 0 if index < 4 else 1,
'Control_Button_%d' % index)
for index, identifier in izip(xrange(8), cycle(xrange(32, 36)))
]])
self._play_button = make_button(118, 0, 'Play_Button')
self._stop_button = make_button(117, 0, 'Stop_Button')
self._record_button = make_button(119, 0, 'Record_Button')
def _init_session(self):
make_button = partial(make_launch_control_button, channel=9)
make_encoder = partial(make_launch_control_encoder, channel=9)
bottom_encoders, top_encoders = make_all_encoders(
'Session_Mixer', make_encoder)
pan_volume_layer = Layer(
volume_controls=ButtonMatrixElement(rows=[bottom_encoders]),
pan_controls=ButtonMatrixElement(rows=[top_encoders]))
self._session_mixer = SpecialMixerComponent(8, Layer(),
pan_volume_layer, Layer())
self._session_mixer.set_enabled(False)
self._session_mixer.name = 'Session_Mixer'
clip_launch_buttons = [
make_button(identifier,
'Clip_Launch_Button_' + str(i),
is_pad=True)
for i, identifier in enumerate(pad_identifiers)
]
self._session = SpecialSessionComponent(num_tracks=8,
num_scenes=0,
name='Session')
self._session.set_enabled(False)
self._session.set_mixer(self._session_mixer)
self._session_layer = Layer(
track_bank_left_button=make_button(116, 'Track_Bank_Left_Button'),
track_bank_right_button=make_button(117,
'Track_Bank_Right_Button'),
select_prev_button=make_button(114, 'Scene_Bank_Up_Button'),
select_next_button=make_button(115, 'Scene_Bank_Down_Button'),
clip_launch_buttons=ButtonMatrixElement(
rows=[clip_launch_buttons]))
scene = self._session.selected_scene()
for index in range(8):
clip_slot = scene.clip_slot(index)
clip_slot.set_triggered_to_play_value(Colors.GREEN_BLINK)
clip_slot.set_triggered_to_record_value(Colors.RED_BLINK)
clip_slot.set_stopped_value(Colors.AMBER_FULL)
clip_slot.set_started_value(Colors.GREEN_FULL)
clip_slot.set_recording_value(Colors.RED_FULL)
clip_slot.name = 'Selected_Clip_Slot_' + str(index)
self._on_track_offset.subject = self._session
def _create_user(self):
def make_control_button(identifier, name, channel=0, is_pad=False):
button = ButtonElement(True,
MIDI_NOTE_TYPE if is_pad else MIDI_CC_TYPE,
channel, identifier)
button.name = name
button.set_on_off_values(127, 0)
return button
def make_control_encoder(identifier, name, channel=0):
encoder = EncoderElement(
MIDI_CC_TYPE, channel, identifier,
Live.MidiMap.MapMode.absolute if not self._relative else
Live.MidiMap.MapMode.relative_two_compliment)
encoder.reset = nop
encoder.set_feedback_delay(-1)
encoder.name = name
return encoder
def make_all_encoders(name_prefix='',
make_encoder=make_control_encoder):
return ([
make_encoder(13 + index, name_prefix + '_' + str(index) + '_0')
for index in xrange(8)
], [
make_encoder(80 + index, name_prefix + '_' + str(index) + '_1')
for index in xrange(8)
], [
make_encoder(88 + index, name_prefix + '_' + str(index) + '_2')
for index in xrange(8)
], [
make_encoder(96 + index, name_prefix + '_' + str(index) + '_3')
for index in xrange(8)
])
make_button = partial(make_control_button, channel=USER_MODE)
make_encoder = partial(make_control_encoder, channel=USER_MODE)
encoders_row_1, encoders_row_2, encoders_row_3, encoders_row_4 = make_all_encoders(
'User_Encoder', make_encoder)
buttons_0 = [
make_button(pad_identifiers[i],
'User_Button_Matrix_' + str(i) + '_0',
is_pad=True) for i in xrange(8)
]
buttons_1 = [
make_button(pad_identifiers[i + 8],
'User_Button_Matrix_' + str(i) + '_1',
is_pad=True) for i in xrange(8)
]
self._matrix = ButtonMatrixElement()
self._matrix.name = 'User_Button_Matrix'
self._matrix.add_row(tuple(buttons_0))
self._matrix.add_row(tuple(buttons_1))
self.request_rebuild_midi_map()
def _create_controls(self):
self._sliders = make_button_row(chain(xrange(19, 32, 4), xrange(49, 62, 4)), make_slider, 'Volume_Slider')
self._rec_arm_buttons = make_button_row(xrange(3, 25, 3), make_button, 'Record_Arm_Button')
self._mute_buttons = make_button_row(xrange(1, 23, 3), make_button, 'Mute_Button')
self._solo_buttons = make_button_row(xrange(2, 24, 3), make_button, 'Solo_Button')
self._send_encoders = ButtonMatrixElement(rows=[ [ make_encoder(id, 'Send_Encoder_%d' % (id_index + row_index * NUM_TRACKS)) for id_index, id in enumerate(row) ] for row_index, row in enumerate(SEND_IDS) ])
self._pan_encoders = make_button_row(chain(xrange(18, 31, 4), xrange(48, 61, 4)), make_encoder, 'Pan_Encoder')
self._bank_left_button = make_button(25, 'Bank_Left_Button')
self._bank_right_button = make_button(26, 'Bank_Right_Button')
self._solo_mode_button = make_button(27, 'Solo_Mode_Button')
self._master_slider = make_slider(62, 'Master_Slider')
def _setup_controls(self):
""" Create all the instances of the physical controls on the MPK """
self.play_button = ButtonElement(True, MIDI_CC_TYPE,
TRANSPORT_MIDI_CHANNEL, PLAY_BUTTON)
self.stop_button = ButtonElement(True, MIDI_CC_TYPE,
TRANSPORT_MIDI_CHANNEL, STOP_BUTTON)
self.loop_button = ButtonElement(True, MIDI_CC_TYPE,
TRANSPORT_MIDI_CHANNEL, LOOP_BUTTON)
self.forward_button = ButtonElement(True, MIDI_CC_TYPE,
TRANSPORT_MIDI_CHANNEL,
FORWARD_BUTTON)
self.backward_button = ButtonElement(True, MIDI_CC_TYPE,
TRANSPORT_MIDI_CHANNEL,
BACKWARD_BUTTON)
self.record_button = ButtonElement(True, MIDI_CC_TYPE,
TRANSPORT_MIDI_CHANNEL, REC_BUTTON)
self.buttons = []
self.encoders = []
self.sliders = []
for cc_start in BUTTON_STARTS:
buttons = [
ButtonElement(False, MIDI_CC_TYPE, MIDI_CHANNEL, cc_start + n)
for n in range(8)
]
self.buttons.append(ButtonMatrixElement(rows=[buttons]))
for cc_start in ENCORDER_STARTS:
encoders = [
EncoderElement(MIDI_CC_TYPE, MIDI_CHANNEL, cc_start + n,
Live.MidiMap.MapMode.relative_two_compliment)
for n in range(8)
]
self.encoders.append(ButtonMatrixElement(rows=[encoders]))
for cc_start in SLIDER_STARTS:
sliders = [
SliderElement(MIDI_CC_TYPE, MIDI_CHANNEL, cc_start + n)
for n in range(8)
]
self.sliders.append(ButtonMatrixElement(rows=[sliders]))
self.shift_button = self.record_button
def _setup_controls(self):
is_momentary = True
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] = OSCFlashingButtonElement(
is_momentary, MIDI_NOTE_TYPE,
int(column / 8) + 1, row + ((column % 8) * 16),
'256Grid_' + str(column) + '_' + str(row),
'/1/p_grid/' + str(column) + '/' + str(row),
'/1/c_grid/' + str(column) + '/' + str(row), None, 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] = OSCFlashingButtonElement(
is_momentary, MIDI_NOTE_TYPE, 15, index,
'256Grid_Bank_' + str(index), '/1/p_a/' + str(index),
'/1/c_a/' + 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] = OSCFlashingButtonElement(
is_momentary, MIDI_NOTE_TYPE, 15, index + 8,
'256Grid_Key_' + str(index), '/1/p_s/' + str(index),
'/1/c_s/' + str(index), None, self)
for index in range(8):
button_row.append(self._key_button[index])
self._key_buttons.add_row(tuple(button_row))
def _setup_session_control(self):
num_tracks = 7
num_scenes = 4
session_nav_button = [
ButtonElement(is_momentary, MIDI_NOTE_TYPE, CHANNEL,
SESSION_NAV_BUTTONS[index]) for index in range(2)
]
session_stop_button = []
matrix = ButtonMatrixElement()
matrix.name = 'Button_Matrix'
global session
session = SessionComponent(num_tracks, num_scenes)
session.name = 'Session_Control'
session.set_offsets(0, 0)
session.set_scene_bank_buttons(session_nav_button[1],
session_nav_button[0])
#session.set_track_bank_buttons(session_nav_button[3], session_nav_button[2])
for row in xrange(num_scenes):
scene_launch_button = ButtonElement(True, MIDI_NOTE_TYPE, CHANNEL,
SCENE_LAUNCH_BUTTONS[row])
session_row = []
scene = session.scene(row)
scene.name = 'Scene' + str(row)
scene.set_launch_button(scene_launch_button)
scene.set_triggered_value(2)
#scene_launch_button._set_skin_light(68)
for column in xrange(num_tracks):
clip_launch_button = ButtonElement(
is_momentary, MIDI_NOTE_TYPE, CHANNEL,
CLIP_LAUNCH_BUTTONS[row][column])
clip_launch_button.name = str(column) + '_Clip_' + str(
row) + '_Button'
session_row.append(clip_launch_button)
clip_slot = scene.clip_slot(column)
clip_slot.name = str(column) + '_ClipSlot_' + str(row)
clip_slot.set_launch_button(clip_launch_button)
#clip_launch_button._set_skin_light(76)
matrix.add_row(tuple(session_row))
for column in xrange(num_tracks):
session_stop_button.append(
ButtonElement(True, MIDI_NOTE_TYPE, CHANNEL,
SESSION_STOP_BUTTONS[column]))
self._supress_session_highlight = False
self._supress_send_midi = False
self.set_highlighting_session_component(session)
session.set_stop_track_clip_buttons(tuple(session_stop_button))
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 _create_controls(self):
multi_button_channels = consts.USER_MODE_CHANNELS
self._session_button_single = make_button(108, 0, u'Session_Mode_Button', msg_type=MIDI_CC_TYPE, is_modifier=True)
self._session_button = FilteringMultiElement([self._session_button_single] + [ make_button(108, channel, msg_type=MIDI_CC_TYPE, name=u'Session_Mode_Button_ch_%d' % (channel,)) for channel in multi_button_channels ], feedback_channels=[0])
self._user_1_button = FilteringMultiElement([ make_button(109, channel, msg_type=MIDI_CC_TYPE, name=u'User_1_Mode_Button_ch_%d' % (channel,)) for channel in (0,) + multi_button_channels ], feedback_channels=[0,
5,
6,
7])
self._user_2_button = FilteringMultiElement([ make_button(110, channel, msg_type=MIDI_CC_TYPE, name=u'User_2_Mode_Button_ch_%d' % (channel,)) for channel in (0,) + multi_button_channels ], feedback_channels=[0,
13,
14,
15])
self._mixer_button = FilteringMultiElement([ make_button(111, channel, msg_type=MIDI_CC_TYPE, name=u'Mixer_Mode_Button_ch_%d' % (channel,)) for channel in (0,) + multi_button_channels ], feedback_channels=[0])
self._up_button = make_button(104, 0, msg_type=MIDI_CC_TYPE, name=u'Up_Button')
self._down_button = make_button(105, 0, msg_type=MIDI_CC_TYPE, name=u'Down_Button')
self._left_button = make_button(106, 0, msg_type=MIDI_CC_TYPE, name=u'Left_Button')
self._right_button = make_button(107, 0, msg_type=MIDI_CC_TYPE, name=u'Right_Button')
self._session_matrix_raw = [ [ make_button(col + offset, 0, name=u'Session_Matrix_Button_%d_%d' % (col, row)) for col in range(consts.SESSION_WIDTH) ] for row, offset in enumerate(range(81, 10, -10)) ]
self._session_matrix = ButtonMatrixElement(rows=self._session_matrix_raw, name=u'Session_Matrix')
self._scene_launch_matrix_raw = [ make_button(identifier, 0, name=u'Scene_Launch_Button_%d' % (index,)) for index, identifier in enumerate(range(89, 18, -10)) ]
self._scene_launch_matrix = ButtonMatrixElement(rows=[self._scene_launch_matrix_raw], name=u'Scene_Launch_Buttons')
self._session_zoom_matrix = ButtonMatrixElement(rows=recursive_map(partial(with_modifier, self._session_button_single), self._session_matrix_raw))
self._volume_reset_buttons = self._session_matrix.submatrix[:, :1]
self._pan_reset_buttons = self._session_matrix.submatrix[:, 1:2]
self._send_a_reset_buttons = self._session_matrix.submatrix[:, 2:3]
self._send_b_reset_buttons = self._session_matrix.submatrix[:, 3:4]
self._stop_clip_buttons = self._session_matrix.submatrix[:, 4:5]
self._mute_buttons = self._session_matrix.submatrix[:, 5:6]
self._solo_buttons = self._session_matrix.submatrix[:, 6:7]
self._arm_buttons = self._session_matrix.submatrix[:, 7:]
self._volume_button = self._scene_launch_matrix_raw[0]
self._pan_button = self._scene_launch_matrix_raw[1]
self._send_a_button = self._scene_launch_matrix_raw[2]
self._send_b_button = self._scene_launch_matrix_raw[3]
self._stop_button = self._scene_launch_matrix_raw[4]
self._mute_button = self._scene_launch_matrix_raw[5]
self._solo_button = self._scene_launch_matrix_raw[6]
self._record_arm_button = self._scene_launch_matrix_raw[7]
self._sliders = ButtonMatrixElement(rows=[[ SliderElement(MIDI_CC_TYPE, 0, identifier) for identifier in range(21, 29) ]])
self._create_user_controls()
def _create_controls(self):
self._aux_button = make_button(b'Aux_Button', 32, is_modifier=True)
self._cursor_up_button = make_button(b'Cursor_Up_Button', 12)
self._cursor_down_button = make_button(b'Cursor_Down_Button', 13)
self._modified_cursor_up_button = with_modifier(self._cursor_up_button, self._aux_button)
self._modified_cursor_down_button = with_modifier(self._cursor_down_button, self._aux_button)
self._start_stop_button = make_button(b'Start_Stop_Button', 16)
self._modified_start_stop_button = with_modifier(self._start_stop_button, self._aux_button)
self._recall_button = make_button(b'Recall_Button', 17)
self._store_button = make_button(b'Store_Button', 18)
self._tone_filter_knobs = ButtonMatrixElement(rows=[
[ make_encoder(b'Tone_Filter_Encoder_%d' % (col,), identifier) for col, identifier in enumerate(xrange(102, 113))
]], name=b'Tone_Filter_Knobs')
step_buttons_raw = [
[ make_button(b'Step_Button_%d' % (col,), identifier) for col, identifier in enumerate(xrange(20, 31))
]]
self._step_buttons = ButtonMatrixElement(rows=step_buttons_raw, name=b'Step_Buttons')
self._modified_step_buttons = ButtonMatrixElement(rows=recursive_map(partial(with_modifier, modifier=self._aux_button), step_buttons_raw), name=b'Step_Buttons_With_Modifier')
self._select_buttons = ButtonMatrixElement(rows=[
[ make_button(b'Select_Button_%d' % (col,), identifier) for col, identifier in enumerate(xrange(60, 71))
]], name=b'Select_Buttons')
self._bfx_buttons = ButtonMatrixElement(rows=[
[ make_button(b'BFX_Button_%d' % (col,), identifier) for col, identifier in enumerate(xrange(80, 91))
]], name=b'BFX_Buttons')
self._mfx_buttons = ButtonMatrixElement(rows=[
[ make_button(b'MFX_Button_%d' % (col,), identifier) for col, identifier in enumerate(xrange(100, 111))
]], name=b'MFX_Buttons')
def _create_controls(self):
self._device_encoders = ButtonMatrixElement(rows=[ [ EncoderElement(MIDI_CC_TYPE, 0, identifier, Live.MidiMap.MapMode.relative_smooth_two_compliment, name='Encoder_%d_%d' % (column_index, row_index)) for column_index, identifier in enumerate(row) ] for row_index, row in enumerate((
ENCODER_MSG_IDS[:4], ENCODER_MSG_IDS[8:12]))
])
self._horizontal_scroll_encoder = EncoderElement(MIDI_CC_TYPE, 0, 75, Live.MidiMap.MapMode.relative_smooth_two_compliment, name='Horizontal_Scroll_Encoder')
self._vertical_scroll_encoder = EncoderElement(MIDI_CC_TYPE, 0, 72, Live.MidiMap.MapMode.relative_smooth_two_compliment, name='Vertical_Scroll_Encoder')
self._volume_encoder = EncoderElement(MIDI_CC_TYPE, 0, 91, Live.MidiMap.MapMode.relative_smooth_two_compliment, name='Volume_Encoder')
self._pan_encoder = EncoderElement(MIDI_CC_TYPE, 0, 17, Live.MidiMap.MapMode.relative_smooth_two_compliment, name='Pan_Encoder')
self._send_a_encoder = EncoderElement(MIDI_CC_TYPE, 0, 77, Live.MidiMap.MapMode.relative_smooth_two_compliment, name='Send_A_Encoder')
self._send_b_encoder = EncoderElement(MIDI_CC_TYPE, 0, 93, Live.MidiMap.MapMode.relative_smooth_two_compliment, name='Send_B_Encoder')
self._send_encoders = ButtonMatrixElement(rows=[
[
self._send_a_encoder, self._send_b_encoder]])
self._return_a_encoder = EncoderElement(MIDI_CC_TYPE, 0, 73, Live.MidiMap.MapMode.relative_smooth_two_compliment, name='Return_A_Encoder')
self._return_b_encoder = EncoderElement(MIDI_CC_TYPE, 0, 79, Live.MidiMap.MapMode.relative_smooth_two_compliment, name='Return_B_Encoder')
self._return_encoders = ButtonMatrixElement(rows=[
[
self._return_a_encoder, self._return_b_encoder]])
self._pads = ButtonMatrixElement(rows=[ [ ButtonElement(True, MIDI_NOTE_TYPE, PAD_CHANNEL, identifier, name='Pad_%d_%d' % (col_index, row_index), skin=self._skin) for col_index, identifier in enumerate(row) ] for row_index, row in enumerate(PAD_MSG_IDS)
])
self._stop_button = ButtonElement(True, MIDI_CC_TYPE, 0, 1, name='Stop_Button')
self._play_button = ButtonElement(True, MIDI_CC_TYPE, 0, 2, name='Play_Button')
