def _create_controls(self):
super(KeyLabMkII, self)._create_controls()
def make_button_row(index_offset, name):
return ButtonMatrixElement(rows=[
[ create_button(index + index_offset, name=('{}_{}').format(name, index)) for index in xrange(8)
]], name=('{}s').format(name))
self._select_buttons = make_button_row(24, 'Select_Button')
self._solo_buttons = make_button_row(8, 'Solo_Button')
self._mute_buttons = make_button_row(16, 'Mute_Button')
self._record_arm_buttons = make_button_row(0, 'Record_Arm_Buttons')
self._automation_button = create_button(56, name='Automation_Button')
self._re_enable_automation_button = create_button(57, name='Re_Enable_Automation_Button')
self._view_button = create_button(74, name='View_Button')
self._pads = ButtonMatrixElement(rows=[ [ create_button(identifier, channel=9, name=('Pad_{}_{}').format(col_index, row_index)) for col_index, identifier in enumerate(row) ] for row_index, row in enumerate(PAD_IDS)
])
self._pad_leds = ButtonMatrixElement(rows=[ [ create_pad_led(identifier, ('Pad_LED_{}_{}').format(col_index, row_index)) for col_index, identifier in enumerate(row) ] for row_index, row in enumerate(PAD_LED_IDS)
], name='Pad_LED_Matrix')
self._display = PhysicalDisplayElement(DISPLAY_LINE_WIDTH, name='Display')
self._display.set_message_parts(sysex.LCD_SET_STRING_MESSAGE_HEADER + (sysex.LCD_LINE_1_ITEM_ID,), (
sysex.NULL, sysex.LCD_LINE_2_ITEM_ID) + (ord(' '),) * DISPLAY_LINE_WIDTH + (sysex.NULL, sysex.END_BYTE))
self._mixer_mode_cycle_button = create_button(51, name='Mixer_Mode_Cycle_Button')
self._vegas_mode_switch = SysexElement(send_message_generator=lambda b: sysex.VEGAS_MODE_MESSAGE_HEADER + (
b, sysex.END_BYTE), name='Vegas_Mode_Switch')
def _create_controls(self):
self._play_button = MultiElement(create_button(16, u'Play_Button'), create_button(17, u'Play_Button_With_Shift'))
self._record_button = create_button(18, u'Record_Button')
self._count_in_button = create_button(19, u'Count_In_Button')
self._stop_button = create_button(20, u'Stop_Button')
self._clear_button = create_button(21, u'Clear_Button')
self._loop_button = create_button(22, u'Loop_Button')
self._metronome_button = create_button(23, u'Metronome_Button')
self._tap_tempo_button = create_button(24, u'Tap_Tempo_Button')
self._undo_button = create_button(32, u'Undo_Button')
self._redo_button = create_button(33, u'Redo_Button')
self._quantize_button = create_button(34, u'Quantize_Button')
self._automation_button = create_button(35, u'Automation_Button')
self._clip_launch_button = create_button(96, u'Clip_Launch_Button')
self._track_stop_button = create_button(97, u'Track_Stop_Button')
self._jump_encoder = create_encoder(52, u'Jump_Encoder')
self._loop_encoder = create_encoder(53, u'Loop_Encoder')
self._volume_encoders = ButtonMatrixElement(rows=[[ create_encoder(index + 80, u'Volume_Encoder_{}'.format(index), is_s_mk2=self.is_s_mk2) for index in xrange(NUM_TRACKS) ]], name=u'Volume_Encoders')
self._pan_encoders = ButtonMatrixElement(rows=[[ create_encoder(index + 88, u'Pan_Encoder_{}'.format(index), is_s_mk2=self.is_s_mk2) for index in xrange(NUM_TRACKS) ]], name=u'Pan_Encoders')
self._track_name_displays = ButtonMatrixElement(rows=[[ create_display_line(sysex.TRACK_NAME_DISPLAY_HEADER, index, u'Track_Name_Display_{}'.format(index), width=33 if self.is_s_mk2 else 11) for index in xrange(NUM_TRACKS) ]], name=u'Track_Name_Displays')
self._track_volume_displays = ButtonMatrixElement(rows=[[ create_display_line(sysex.TRACK_VOLUME_DISPLAY_HEADER, index, u'Track_Volume_Display_{}'.format(index), width=12) for index in xrange(NUM_TRACKS) ]], name=u'Track_Volume_Displays')
self._track_panning_displays = ButtonMatrixElement(rows=[[ create_display_line(sysex.TRACK_PANNING_DISPLAY_HEADER, index, u'Track_Panning_Display_{}'.format(index), width=12) for index in xrange(NUM_TRACKS) ]], name=u'Track_Panning_Displays')
self._track_type_displays = ButtonMatrixElement(rows=[[ create_sysex_element(sysex.TRACK_TYPE_DISPLAY_HEADER, index, u'Track_Type_Display_{}'.format(index)) for index in xrange(NUM_TRACKS) ]], name=u'Track_Type_Displays')
self._track_mute_displays = ButtonMatrixElement(rows=[[ create_sysex_element(sysex.TRACK_MUTE_DISPLAY_HEADER, index, u'Track_Mute_Display_{}'.format(index)) for index in xrange(NUM_TRACKS) ]], name=u'Track_Mute_Displays')
self._track_solo_displays = ButtonMatrixElement(rows=[[ create_sysex_element(sysex.TRACK_SOLO_DISPLAY_HEADER, index, u'Track_Solo_Display_{}'.format(index)) for index in xrange(NUM_TRACKS) ]], name=u'Track_Solo_Displays')
self._track_muted_via_solo_displays = ButtonMatrixElement(rows=[[ create_sysex_element(sysex.TRACK_MUTED_VIA_SOLO_DISPLAY_HEADER, index, u'Track_Muted_via_Solo_Display_{}'.format(index)) for index in xrange(NUM_TRACKS) ]], name=u'Track_Muted_via_Solo_Displays')
self._track_selection_displays = ButtonMatrixElement(rows=[[ create_sysex_element(sysex.TRACK_SELECT_DISPLAY_HEADER, index, u'Track_Selection_Display_{}'.format(index)) for index in xrange(NUM_TRACKS) ]], name=u'Track_Selection_Displays')
self._focus_follow_control = SysexElement(lambda value: sysex.TRACK_CHANGED_DISPLAY_HEADER + value + (midi.SYSEX_END,), name=u'Focus_Follow_Control')
self._handshake_control = create_button(1, u'Handshake_Control')
self._handshake_control.reset = nop
self._on_handshake_response.subject = self._handshake_control
def __init__(self, *a, **k):
(super(Elements, self).__init__)(*a, **k)
self.shift_button = create_button(32,
'Shift_Button',
resource_type=PrioritizedResource)
self.zoom_button = create_button(104,
'Zoom_Button',
resource_type=PrioritizedResource)
self.note_repeat_button = create_button(24, 'Note_Repeat_Button')
self.full_level_button = create_button(25, 'Full_Level_Button')
self.bank_button = create_button(26, 'Bank_Button')
self.preset_button = create_button(27, 'Preset_Button')
self.show_hide_button = create_button(29, 'Show_Hide_Button')
self.nudge_button = create_button(30, 'Nudge_Button')
self.editor_button = create_button(31, 'Editor_Button')
self.set_loop_button = create_button(85, 'Set_Loop_Button')
self.setup_button = create_button(86, 'Setup_Button')
self.up_button = create_button(87, 'Up_Button')
self.down_button = create_button(89, 'Down_Button')
self.left_button = create_button(90, 'Left_Button')
self.right_button = create_button(102, 'Right_Button')
self.select_button = create_button(103, 'Select_Button')
self.click_button = create_button(105, 'Click_Button')
self.record_button = create_button(107, 'Record_Button')
self.play_button = create_button(109, 'Play_Button')
self.stop_button = create_button(111, 'Stop_Button')
self.pads_raw = [[
create_button((offset + col_index),
('{}_Pad_{}'.format(col_index, row_index)),
msg_type=MIDI_NOTE_TYPE)
for col_index in range(SESSION_WIDTH)
] for row_index, offset in enumerate(range(48, 32, -4))]
self.pads = ButtonMatrixElement(rows=(self.pads_raw), name='Pads')
def with_modifier(modifier_button, button):
return ComboElement(control=button,
modifier=modifier_button,
name=('{}_With_{}'.format(
button.name,
modifier_button.name.split('_')[0])))
self.play_button_with_shift = with_modifier(self.shift_button,
self.play_button)
self.stop_button_with_shift = with_modifier(self.shift_button,
self.stop_button)
self.pads_with_shift = ButtonMatrixElement(
name='Pads_With_Shift',
rows=(recursive_map(partial(with_modifier, self.shift_button),
self.pads_raw)))
self.pads_with_zoom = ButtonMatrixElement(
name='Pads_With_Zoom',
rows=(recursive_map(partial(with_modifier, self.zoom_button),
self.pads_raw)))
self.encoders = ButtonMatrixElement(rows=[[
create_encoder(index + 14, 'Encoder_{}'.format(index))
for index in range(4)
]],
name='Encoders')
self.native_mode_reply_element = InputControlElement(
MIDI_CC_TYPE, 15, 127, name='Native_Mode_Reply_Element')
def __init__(self, skin=None, *a, **k):
(super(Elements, self).__init__)(*a, **k)
self._create_drum_pads()
self._create_scale_pads()
self._create_scale_feedback_switch()
self.note_mode_button = create_button(96, 'Note_Mode_Button')
self.custom_mode_button = create_button(97, 'Custom_Mode_Button')
self.record_button = create_button(98, 'Record_Button')
self.button_faders = ButtonMatrixElement(rows=[
[create_slider(index + self.button_fader_cc_offset, 'Button_Fader_{}'.format(index)) for index in range(SESSION_WIDTH)]],
name='Button_Faders')
self.button_fader_color_elements_raw = [create_button((index + self.button_fader_cc_offset), ('Button_Fader_Color_Element_{}'.format(index)), channel=BUTTON_FADER_COLOR_CHANNEL) for index in range(SESSION_WIDTH)]
self.button_fader_color_elements = ButtonMatrixElement(rows=[
self.button_fader_color_elements_raw],
name='Button_Fader_Color_Elements')
self.note_layout_switch = SysexElement(name='Note_Layout_Switch',
send_message_generator=(lambda v: sysex.STD_MSG_HEADER + (
ids.LP_X_ID, sysex.NOTE_LAYOUT_COMMAND_BYTE, v, sysex.SYSEX_END_BYTE)),
default_value=(sysex.SCALE_LAYOUT_BYTE))
session_button_color_identifier = sysex.STD_MSG_HEADER + (ids.LP_X_ID, 20)
self.session_button_color_element = ColorSysexElement(name='Session_Button_Color_Element',
sysex_identifier=session_button_color_identifier,
send_message_generator=(lambda v: session_button_color_identifier + v + (sysex.SYSEX_END_BYTE,)),
skin=skin)
self.button_fader_setup_element = SysexElement(name='Button_Fader_Setup_Element',
send_message_generator=(partial(self._fader_setup_message_generator, 0)))
def _create_controls(self):
self._encoders = ButtonMatrixElement(rows=[[
EncoderElement(MIDI_CC_TYPE,
0,
identifier,
map_mode=(Live.MidiMap.MapMode.absolute),
name=('Volume_Encoder_{}'.format(index)))
for index, identifier in enumerate(range(12, 20))
]],
name='Volume_Encoders')
self._data_encoder = EncoderElement(
MIDI_CC_TYPE,
0,
22,
map_mode=(Live.MidiMap.MapMode.relative_smooth_two_compliment),
name='Data_Encoder')
self._data_encoder_button = ButtonElement(True,
MIDI_CC_TYPE,
0,
23,
name='Data_Encoder_Button',
skin=skin)
self._play_button = ButtonElement(False,
MIDI_CC_TYPE,
0,
118,
name='Play_Button',
skin=skin)
self._record_button = ButtonElement(False,
MIDI_CC_TYPE,
0,
119,
name='Record_Button',
skin=skin)
self._record_stop_button = ButtonElement(False,
MIDI_CC_TYPE,
0,
116,
name='Record_Stop_Button',
skin=skin)
self._stop_button = ButtonElement(False,
MIDI_CC_TYPE,
0,
117,
name='Stop_Button',
skin=skin)
self._pads = ButtonMatrixElement(rows=[[
ButtonElement(True,
MIDI_NOTE_TYPE,
PAD_CHANNEL,
identifier,
name=('Pad_{}'.format(index)),
skin=skin)
for index, identifier in enumerate(PAD_IDS)
]])
def _create_controls(self):
self._pads_raw = [
ButtonElement(True,
MIDI_NOTE_TYPE,
0,
identifier,
name=u'Pad_{}'.format(identifier),
skin=skin) for identifier in range(100)
]
self._session_matrix = ButtonMatrixElement(
rows=[[self._pads_raw[offset + col] for col in range(NUM_TRACKS)]
for offset in range(80, 49, -10)],
name=u'Session_Matrix')
self._scene_launch_button_matrix = ButtonMatrixElement(
rows=[[
self._pads_raw[identifier]
for identifier in range(89, 58, -10)
]],
name=u'Scene_Launch_Button_Matrix')
self._stop_all_clips_button = ButtonElement(
True,
MIDI_NOTE_TYPE,
0,
127,
skin=skin,
name=u'Stop_All_Clips_Button')
self._nav_down_button = self._pads_raw[90]
self._nav_up_button = self._pads_raw[91]
self._nav_left_button = self._pads_raw[92]
self._nav_right_button = self._pads_raw[93]
self._mode_cycle_button = ButtonElement(True,
MIDI_CC_TYPE,
0,
127,
skin=skin,
name=u'Mode_Button')
self._drum_pads = ButtonMatrixElement(
rows=[[self._pads_raw[offset + col] for col in range(4)]
for offset in range(48, 35, -4)],
name=u'Drum_Pads')
self._tempo_encoder = EncoderElement(
MIDI_PB_TYPE,
0,
0,
Live.MidiMap.MapMode.absolute,
send_should_depend_on_forwarding=False,
name=u'Tempo_Encoder')
self._tempo_encoder.reset = nop
self._sysex_element = SysexElement(sysex_identifier=SYSEX_HEADER,
name=u'Sysex_Element')
self._sysex_element.add_value_listener(nop)
self._surface_update_message_element = ButtonElement(
True, MIDI_CC_TYPE, 0, 64, name=u'Surface_Update_Message_Element')
self.__on_surface_update_message_received.subject = self._surface_update_message_element
def _setup_controls(self): is_momentary = True optimized = False resource = PrioritizedResource self._livid = DoublePressElement(MonoButtonElement(is_momentary = is_momentary, msg_type = MIDI_NOTE_TYPE, channel = CHANNEL, identifier = LIVID, name = 'Livid_Button', script = self, skin = self._skin, color_map = COLOR_MAP, optimized_send_midi = optimized, resource_type = resource, monobridge = self._monobridge)) self._dial = [[CodecEncoderElement(msg_type = MIDI_CC_TYPE, channel = CHANNEL, identifier = CODE_DIALS[row][column], name = 'Dial_' + str(column) + '_' + str(row), num = (column + (row*8)), script = self, optimized_send_midi = optimized, resource_type = resource, monobridge = self._monobridge) for row in range(4)] for column in range(8)] self._button = [[MonoButtonElement(is_momentary = is_momentary, msg_type = MIDI_NOTE_TYPE, channel = CHANNEL, identifier = CODE_BUTTONS[row][column], name = 'Button_' + str(column) + '_' + str(row), script = self, skin = self._skin, color_map = COLOR_MAP, optimized_send_midi = optimized, resource_type = resource, monobridge = self._monobridge) for row in range(4)] for column in range(8)] self._column_button = [MonoButtonElement(is_momentary = is_momentary, msg_type = MIDI_NOTE_TYPE, channel = CHANNEL, identifier = CODE_COLUMN_BUTTONS[index], name = 'Column_Button_' + str(index), script = self, skin = self._skin, color_map = COLOR_MAP, optimized_send_midi = optimized, resource_type = resource, monobridge = self._monobridge) for index in range(8)] self._row_button = [MonoButtonElement(is_momentary = is_momentary, msg_type = MIDI_NOTE_TYPE, channel = CHANNEL, identifier = CODE_ROW_BUTTONS[index], name = 'Row_Button_' + str(index), script = self, skin = self._skin, color_map = COLOR_MAP, optimized_send_midi = optimized, resource_type = resource, monobridge = self._monobridge) for index in range(4)] self._code_keys = ButtonMatrixElement(name = 'Code_Keys', rows = [self._column_button]) self._code_buttons = ButtonMatrixElement(name = 'Code_Buttons', rows = [self._row_button]) self._encoder_matrix = ButtonMatrixElement(name = 'Encoder_Matrix', rows = [[self._dial[column][row] for column in range(8)] for row in range(4)]) self._button_matrix = ButtonMatrixElement(name = 'Button_Matrix', rows = [[self._button[column][row] for column in range(8)] for row in range(4)])
def __init__(self,
arrow_button_identifiers=(91, 92, 93, 94),
session_mode_button_identifier=95,
*a,
**k):
(super(LaunchpadElements, self).__init__)(*a, **k)
self.up_button = create_button(arrow_button_identifiers[0],
'Up_Button')
self.down_button = create_button(arrow_button_identifiers[1],
'Down_Button')
self.left_button = create_button(arrow_button_identifiers[2],
'Left_Button')
self.right_button = create_button(arrow_button_identifiers[3],
'Right_Button')
self.session_mode_button = create_button(
session_mode_button_identifier, 'Session_Mode_Button')
self.scene_launch_buttons_raw = [
create_button(identifier,
'Scene_Launch_Button_{}'.format(row_index))
for row_index, identifier in enumerate(range(89, 18, -10))
]
self.scene_launch_buttons = ButtonMatrixElement(
rows=[self.scene_launch_buttons_raw], name='Scene_Launch_Buttons')
self.clip_launch_matrix = ButtonMatrixElement(
rows=[[
create_button(
(offset + col_index),
('{}_Clip_Launch_Button_{}'.format(col_index, row_index)),
msg_type=MIDI_NOTE_TYPE)
for col_index in range(SESSION_WIDTH)
] for row_index, offset in enumerate(range(81, 10, -10))],
name='Clip_Launch_Matrix')
self.firmware_mode_switch = SysexElement(
name='Firmware_Mode_Switch',
send_message_generator=(
lambda v: sysex.STD_MSG_HEADER +
(self.model_id, sysex.FIRMWARE_MODE_COMMAND_BYTE, v, sysex.
SYSEX_END_BYTE)),
default_value=(sysex.STANDALONE_MODE_BYTE),
optimized=True)
layout_switch_identifier = sysex.STD_MSG_HEADER + (
self.model_id, sysex.LAYOUT_COMMAND_BYTE)
self.layout_switch = SysexElement(
name='Layout_Switch',
sysex_identifier=layout_switch_identifier,
send_message_generator=(lambda v: layout_switch_identifier +
(v if type(v) is tuple else
(v, )) + (sysex.SYSEX_END_BYTE, )),
default_value=(self.default_layout),
enquire_message=(layout_switch_identifier +
(sysex.SYSEX_END_BYTE, )))
def _setup_controls(self):
is_momentary = True
optimized = True
resource = PrioritizedResource
self._fader = [
MonoEncoderElement(msg_type=MIDI_CC_TYPE,
channel=CHANNEL,
identifier=ALIAS_FADERS[index],
name='Fader_' + str(index),
num=index,
script=self,
optimized_send_midi=optimized,
resource_type=resource,
monobridge=self._monobridge)
for index in range(9)
]
self._button = [
MonoButtonElement(is_momentary=is_momentary,
msg_type=MIDI_NOTE_TYPE,
channel=CHANNEL,
identifier=ALIAS_BUTTONS[index],
name='Button_' + str(index),
script=self,
skin=self._skin,
optimized_send_midi=optimized,
resource_type=resource,
monobridge=self._monobridge)
for index in range(16)
]
self._dial = [
MonoEncoderElement(msg_type=MIDI_CC_TYPE,
channel=CHANNEL,
identifier=ALIAS_DIALS[index],
name='Dial_' + str(index),
num=index + 8,
script=self) for index in range(16)
]
self._encoder = MonoEncoderElement(msg_type=MIDI_CC_TYPE,
channel=CHANNEL,
identifier=ALIAS_ENCODER,
name='Encoder',
script=self,
optimized_send_midi=optimized,
resource_type=resource,
monobridge=self._monobridge)
self._fader_matrix = ButtonMatrixElement(name='FaderMatrix',
rows=[self._fader[:8]])
self._button_matrix = ButtonMatrixElement(
name='ButtonMatrix', rows=[self._button[:8], self._button[8:]])
self._dial_matrix = ButtonMatrixElement(
name='DialMatrix', rows=[self._dial[:8], self._dial[8:]])
def _setup_controls(self):
self._pedal = [None for index in range(14)]
for index in range(5):
self._pedal[index] = DoublePressElement(
MonoButtonElement(is_momentary=True,
msg_type=MIDI_NOTE_TYPE,
channel=0,
identifier=PEDAL_DEFS[index],
name='Pedal_' + str(index),
script=self,
skin=self._skin))
self._pedal[index]._report = False
for index in range(7):
self._pedal[index + 5] = MonoButtonElement(
is_momentary=True,
msg_type=MIDI_NOTE_TYPE,
channel=0,
identifier=PEDAL_DEFS[index + 5],
name='Pedal_' + str(index + 5),
script=self,
skin=self._skin)
self._pedal[index + 5]._report = False
self._pedal[12] = LoopPedalExpressionElement(
script=self,
msg_type=MIDI_CC_TYPE,
channel=0,
identifier=102,
map_mode=Live.MidiMap.MapMode.absolute)
self._pedal[12].name = 'Pedal_' + str(12)
self._pedal[12]._report = False
self._pedal[13] = LoopPedalExpressionElement(
script=self,
msg_type=MIDI_CC_TYPE,
channel=0,
identifier=103,
map_mode=Live.MidiMap.MapMode.absolute)
self._pedal[13].name = 'Pedal_' + str(13)
self._pedal[13]._report = False
self._leds = self._pedal[5:9]
self._select_buttons = ButtonMatrixElement()
self._select_buttons.name = 'SelectMatrix'
self._select_buttons.add_row(
[self._pedal[5], self._pedal[6], self._pedal[7], self._pedal[8]])
#self._doublepress_select_buttons = ButtonMatrixElement()
#self._doublepress_select_buttons.name = 'DoublepressSelectMatrix'
#self._doublepress_select_buttons.add_row([self._pedal[9].double_press, self._pedal[8].double_press, self._pedal[7].double_press, self._pedal[6].double_press])
self._overdub_button = self._pedal[0]
self._record_button = self._pedal[1]
self._mute_button = self._pedal[2]
self._reverse_button = self._pedal[3]
def _setup_controls(self): is_momentary = True optimized = True resource = PrioritizedResource self._button = [MonoButtonElement(is_momentary = is_momentary, msg_type = MIDI_NOTE_TYPE, channel = CHANNEL, identifier = BUTTONS[index], name = 'Button_' + str(index), script = self, skin = self._skin, optimized_send_midi = optimized, resource_type = resource, monobridge = self._monobridge) for index in range(10)] self._fader = [MonoEncoderElement(msg_type = MIDI_CC_TYPE, channel = CHANNEL, identifier = SLIDERS[index], name = 'Fader_' + str(index), num = index, script = self, optimized_send_midi = optimized, resource_type = resource, monobridge = self._monobridge) for index in range(3)] self._fader_button = [MonoEncoderElement(msg_type = MIDI_NOTE_TYPE, channel = CHANNEL, identifier = SLIDERS[index], name = 'Fader_Button_' + str(index), num = index, script = self, optimized_send_midi = optimized, resource_type = resource, monobridge = self._monobridge) for index in range(3)] self._ccs = [MonoEncoderElement(msg_type = MIDI_CC_TYPE, channel = CHANNEL, identifier = CCS[index], name = 'CCs_' + str(index), num = index, script = self, optimized_send_midi = optimized, resource_type = resource, monobridge = self._monobridge) for index in range(4)] self._pad = [MonoButtonElement(is_momentary = is_momentary, msg_type = MIDI_NOTE_TYPE, channel = CHANNEL, identifier = PADS[index], name = 'Pad_' + str(index), script = self, skin = self._skin, optimized_send_midi = optimized, resource_type = resource, monobridge = self._monobridge) for index in range(5)] self._padCC = [MonoEncoderElement(msg_type = MIDI_CC_TYPE, channel = CHANNEL, identifier = PADS[index], name = 'PadCC_' + str(index), num = index, script = self, optimized_send_midi = optimized, resource_type = resource, monobridge = self._monobridge) for index in range(5)] self._accel = [MonoEncoderElement(msg_type = MIDI_CC_TYPE, channel = CHANNEL, identifier = ACCELS[index], name = 'Accel_' + str(index), num = index, script = self, optimized_send_midi = optimized, resource_type = resource, monobridge = self._monobridge) for index in range(3)] self._parameter_control_matrix = ButtonMatrixElement(rows = [ [ self._fader[0], self._fader[1], self._fader[2], self._accel[2], self._ccs[0], self._ccs[1], self._ccs[2], self._ccs[3] ]]) self._scene_launch_matrix = ButtonMatrixElement(rows = [self._pad[:4]])
def _setup_controls(self):
self._pedal = [None for index in range(8)]
for index in range(7):
self._pedal[index] = DoublePressElement(
MonoButtonElement(is_momentary=True,
msg_type=MIDI_CC_TYPE,
channel=0,
identifier=PEDAL_DEFS[index],
name='Pedal_' + str(index),
script=self))
self._pedal[index]._report = False
self._pedal[7] = LoopPedalExpressionElement(
script=self,
msg_type=MIDI_CC_TYPE,
channel=0,
identifier=1,
map_mode=Live.MidiMap.MapMode.absolute)
self._pedal[7].name = 'Pedal_' + str(7)
self._pedal[7]._report = False
self._leds = [None for index in range(4)]
for index in range(4):
red_led = ButtonElement(True, MIDI_NOTE_TYPE, 0, LED_DEFS[index])
green_led = ButtonElement(True, MIDI_NOTE_TYPE, 0,
LED_DEFS[index] + 4)
blue_led = ButtonElement(True, MIDI_NOTE_TYPE, 0,
LED_DEFS[index] + 8)
self._leds[index] = RGB_LED(red_led,
green_led,
blue_led,
is_momentary=True,
msg_type=MIDI_NOTE_TYPE,
channel=0,
identifier=index + 13,
name='LED_' + str(index),
script=self)
self._select_buttons = ButtonMatrixElement()
self._select_buttons.name = 'SelectMatrix'
self._select_buttons.add_row(
[self._pedal[6], self._pedal[5], self._pedal[4], self._pedal[3]])
self._doublepress_select_buttons = ButtonMatrixElement()
self._doublepress_select_buttons.name = 'DoublepressSelectMatrix'
self._doublepress_select_buttons.add_row([
self._pedal[6].double_press, self._pedal[5].double_press,
self._pedal[4].double_press, self._pedal[3].double_press
])
self._record_button = self._pedal[1]
self._mute_button = self._pedal[2]
self._overdub_button = self._pedal[0]
def __init__(self, *a, **k):
super(Elements, self).__init__(*a, **k)
self.encoder_push_button = create_button(102, u'Encoder_Push_Button')
self.back_button = create_button(104, u'Back_Button')
self.bank_left_button = create_button(110, u'Bank_Left_Button')
self.bank_right_button = create_button(111, u'Bank_Right_Button')
self.loop_button = create_button(114, u'Loop_Button')
self.rewind_button = create_button(115, u'Rewind_Button')
self.fastforward_button = create_button(116, u'Fastforward_Button')
self.stop_button = create_button(117, u'Stop_Button')
self.play_button = create_button(118, u'Play_Button')
self.record_button = create_button(119, u'Record_Button')
self.fader_buttons = ButtonMatrixElement(rows=[[
create_button(index + 32,
u'Fader_Button_{}'.format(index),
is_momentary=False) for index in range(SESSION_WIDTH)
]],
name=u'Fader_Buttons')
self.scene_launch_buttons = ButtonMatrixElement(
rows=[[
create_button(index + 107,
u'Scene_Launch_Button_{}'.format(index))
for index in range(SESSION_HEIGHT)
]],
name=u'Scene_Launch_Buttons')
pad_ids = ((40, 41, 42, 43, 48, 49, 50, 51), (36, 37, 38, 39, 44, 45,
46, 47))
self.pads = ButtonMatrixElement(rows=[[
create_button(ident,
u'{}_Pad_{}'.format(row_index,
ident % SESSION_WIDTH),
msg_type=MIDI_NOTE_TYPE)
for ident in pad_ids[row_index]
] for row_index in range(SESSION_HEIGHT)],
name=u'Pads')
self.encoder = create_encoder(
103, u'Encoder', map_mode=Live.MidiMap.MapMode.relative_signed_bit)
self.master_fader = create_encoder(41, u'Master_Fader')
self.faders = ButtonMatrixElement(rows=[[
create_encoder(index + 12, u'Fader_{}'.format(index))
for index in range(SESSION_WIDTH)
]],
name=u'Faders')
self.knobs = ButtonMatrixElement(rows=[[
create_encoder(index + 22, u'Knob_{}'.format(index))
for index in range(8)
]],
name=u'Knobs')
def create_selection_field_line(v_position):
lines_raw = [ create_selection_field(index, v_position) for index in xrange(SESSION_WIDTH)
]
return (
lines_raw,
ButtonMatrixElement(rows=[
lines_raw], name=('Selection_Field_Line_{}').format(v_position)))
def __init__(self, *a, **k):
super(Elements, self).__init__(continuous_mapping_sensitivity=CONTINUOUS_MAPPING_SENSITIVITY, fine_grained_continuous_mapping_sensitivity=FINE_GRAINED_CONTINUOUS_MAPPING_SENSITIVITY, *a, **k)
self.display_line1 = self._create_display_line(sysex.CLEAR_LINE1, sysex.WRITE_LINE1, 0)
self.display_line2 = self._create_display_line(sysex.CLEAR_LINE2, sysex.WRITE_LINE2, 1)
self.display_line3 = self._create_display_line(sysex.CLEAR_LINE3, sysex.WRITE_LINE3, 2)
self.display_line4 = self._create_display_line(sysex.CLEAR_LINE4, sysex.WRITE_LINE4, 3)
self.display_lines = [self.display_line1,
self.display_line2,
self.display_line3,
self.display_line4]
with_shift = partial(ComboElement, modifier=self.shift_button)
self.shifted_matrix = ButtonMatrixElement(name=u'Shifted_Button_Matrix', rows=recursive_map(with_shift, self.matrix_rows_raw))
touch_strip_mode_element = SysexElement(send_message_generator=sysex.make_touch_strip_mode_message)
touch_strip_light_element = SysexElement(send_message_generator=sysex.make_touch_strip_light_message)
self.touch_strip_tap = create_note_button(12, u'Touch_Strip_Tap')
self.touch_strip_control = TouchStripElement(name=u'Touch_Strip_Control', touch_button=self.touch_strip_tap, mode_element=touch_strip_mode_element, light_element=touch_strip_light_element)
self.touch_strip_control.set_feedback_delay(-1)
self.touch_strip_control.set_needs_takeover(False)
base_message_generator = make_send_message_generator(sysex.SET_AFTERTOUCH_MODE)
def make_aftertouch_mode_message(mode_id):
assert mode_id in (u'polyphonic', u'mono')
mode_message = sysex.POLY_AFTERTOUCH if mode_id == u'polyphonic' else sysex.MONO_AFTERTOUCH
return base_message_generator(mode_message)
self.aftertouch_control = SysexElement(sysex_identifier=sysex.SET_AFTERTOUCH_MODE, send_message_generator=make_aftertouch_mode_message, default_value=u'polyphonic')
def create_display_color_element_line(v_position, **k):
raw_line = [ create_display_color_element(index, v_position, ('Color_Field_{}_{}').format(index, v_position), **k) for index in xrange(SESSION_WIDTH)
]
return (
raw_line,
ButtonMatrixElement(rows=[
raw_line], name=('Color_Field_Line_{}').format(v_position)))
def _create_scale_pads(self):
self.scale_pads = ButtonMatrixElement(rows=[[
create_button(identifier, ('Scale_Pad_{}'.format(identifier)),
msg_type=MIDI_NOTE_TYPE,
channel=15) for identifier in range(128)
]],
name='Scale_Pads')
def make_button_row(index_offset, name):
return ButtonMatrixElement(rows=[[
create_button(index + index_offset,
name=('{}_{}').format(name, index))
for index in xrange(8)
]],
name=('{}s').format(name))
def create_parameter_display_matrix(command_byte, start_index, name):
return ButtonMatrixElement(rows=[[
create_display_element((command_byte, start_index + index),
u'_Display_{}'.format(name, index))
for index in range(8)
]],
name=u'{}_Displays'.format(name))
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 u'%s_%d' % (base_name, x)
def two_dimensional_name(base_name, x, y):
return u'%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[u'%s_Raw' % name] = elements
self[u'%s_Ids' % name] = id_dict
self[name] = ButtonMatrixElement(rows=elements, name=name)
def _setup_controls(self):
is_momentary = True
optimized = True
resource = PrioritizedResource
#self._pads_raw = [ ButtonElement(True, MIDI_NOTE_TYPE, 0, identifier, name=u'Pad_{}'.format(identifier), skin=skin) for identifier in xrange(100) ]
self._pad = [
MonoButtonElement(is_momentary=is_momentary,
msg_type=MIDI_NOTE_TYPE,
channel=CHANNEL,
identifier=BLOCKS_PADS[index],
name='Pad_' + str(index),
script=self,
monobridge=self._monobridge,
skin=self._skin,
color_map=COLOR_MAP,
optimized_send_midi=optimized,
resource_type=resource) for index in range(64)
]
for button in self._pad:
button.set_color_map(tuple(range(128)))
self._matrix = ButtonMatrixElement(
name='Matrix',
rows=[
self._pad[(index * 8):(index * 8) + 8] for index in range(8)
])
def _create_controls(self):
self._jump_to_start_button = make_button(21, 'Jump_To_Start_Button')
self._rwd_button = make_button(22, 'RWD_Button')
self._ff_button = make_button(23, 'FF_Button')
self._stop_button = make_button(25, 'Stop_Button')
self._play_button = make_button(26, 'Play_Button')
self._record_button = make_button(28, 'Record_Button')
self._encoders = ButtonMatrixElement(rows=[[ make_encoder(index + 70, 'Encoder_%d' % (index,)) for index in xrange(6) ]], name='Encoders')
self._volume_mode_button = make_button(16, 'Volume_Mode_Button')
self._pan_mode_button = make_button(17, 'Pan_Mode_Button')
self._send_a_mode_button = make_button(18, 'Send_A_Mode_Button')
self._send_b_mode_button = make_button(19, 'Send_B_Mode_Button')
self._s1_button = make_button(14, 'S1_Button')
self._s2_button = make_button(15, 'S2_Button')
self._pads = ButtonMatrixElement(rows=[ [ make_button(col_index + offset, 'Pad_%d_%d' % (col_index, row_index), msg_type=MIDI_NOTE_TYPE) for col_index in xrange(4) ] for row_index, offset in enumerate(xrange(72, 59, -4))
], name='Pads')
def __init__(self, *a, **k):
(super(Elements, self).__init__)(*a, **k)
self.foot_switches = ButtonMatrixElement(rows=[
[create_button(i, 'Foot_Switch_{}'.format(i)) for i in range(NUM_LOOPER_SWITCHES)]],
name='Foot_Switches')
self.time_display = TimeDisplayElement(SYSEX_HEADER + NUMERIC_DISPLAY_COMMAND, (SYSEX_END,))
self.live_integration_mode_switch = SysexElement(name='Live_Integration_Mode_Switch',
send_message_generator=(lambda v: LIVE_INTEGRATION_MODE_ID + (v, SYSEX_END)))
def __init__(self, *a, **k):
super(Elements, self).__init__(*a, **k)
self.display_encoder = create_encoder(29, u'Display_Encoder')
self.shift_button = create_button(31, u'Shift_Button', resource_type=PrioritizedResource)
self.plus_button = create_button(0, u'Plus_Button', msg_type=MIDI_NOTE_TYPE, skin=rgb_skin)
self.minus_button = create_button(1, u'Minus_Button', msg_type=MIDI_NOTE_TYPE, skin=rgb_skin)
self.song_mode_button = create_button(32, u'Song_Mode_Button')
self.instrument_mode_button = create_button(33, u'Instrument_Mode_Button')
self.editor_mode_button = create_button(34, u'Editor_Mode_Button')
self.user_mode_button = create_button(35, u'User_Mode_Button')
self.display_left_button = create_button(42, u'Display_Left_Button')
self.display_right_button = create_button(43, u'Display_Right_Button')
self.up_button = create_button(87, u'Up_Button')
self.down_button = create_button(89, u'Down_Button')
self.left_button = create_button(90, u'Left_Button')
self.right_button = create_button(102, u'Right_Button')
self.click_button = create_button(105, u'Click_Button')
self.record_button = create_button(107, u'Record_Button')
self.play_button = create_button(109, u'Play_Button', skin=rgb_skin)
self.stop_button = create_button(111, u'Stop_Button')
for i, name in enumerate(BANK_BUTTON_NAMES):
setattr(self, name, create_button(i, name.title(), skin=rgb_skin))
def with_shift(button):
return ComboElement(control=button, modifier=self.shift_button, name=u'{}_With_Shift'.format(button.name))
self.play_button_with_shift = with_shift(self.play_button)
self.stop_button_with_shift = with_shift(self.stop_button)
self.record_button_with_shift = with_shift(self.record_button)
self.up_button_with_shift = with_shift(self.up_button)
self.down_button_with_shift = with_shift(self.down_button)
self.display_buttons_raw = [ create_button(index + 36, u'Display_Button_{}'.format(index)) for index in range(6) ]
self.display_buttons = ButtonMatrixElement(rows=[self.display_buttons_raw], name=u'Display_Buttons')
self.lower_pads = ButtonMatrixElement(rows=[[ create_button(36 + index, u'Lower_Pad_{}'.format(index), msg_type=MIDI_NOTE_TYPE, skin=rgb_skin) for index in range(SESSION_WIDTH) ]], name=u'Lower_Pads')
self.upper_pads = ButtonMatrixElement(rows=[[ create_button(52 + index, u'Upper_Pad_{}'.format(index), msg_type=MIDI_NOTE_TYPE, skin=rgb_skin) for index in range(SESSION_WIDTH) ]], name=u'Upper_Pads')
self.encoders_raw = [ create_encoder(index + 14, u'Encoder_{}'.format(index)) for index in range(8) ]
self.encoders = ButtonMatrixElement(rows=[self.encoders_raw], name=u'Encoders')
self.button_label_display_matrix = ButtonMatrixElement(rows=[[ create_display_element(strip_id, u'Button_Label_Display_{}'.format(index), **DISPLAY_RGB_VALUES) for index, strip_id in enumerate((0, 1, 2, 11, 12, 13)) ]], name=u'Button_Label_Displays')
self.track_name_display = create_display_element(6, u'Track_Name_Display', **DISPLAY_RGB_VALUES)
self.device_name_display = create_display_element(7, u'Device_Name_Display', **DISPLAY_RGB_VALUES)
self.lower_firmware_toggle_switch = SysexElement(name=u'Lower_Firmware_Toggle_Switch', send_message_generator=lambda v: midi.LOWER_FIRMWARE_TOGGLE_HEADER + (v, midi.SYSEX_END_BYTE))
self.upper_firmware_toggle_switch = SysexElement(name=u'Upper_Firmware_Toggle_Switch', send_message_generator=lambda v: midi.UPPER_FIRMWARE_TOGGLE_HEADER + (v, midi.SYSEX_END_BYTE))
self.touch_strip_tap = create_button(64, u'Touch_Strip_Tap')
self.touch_strip_leds = [ create_button(led_id, u'Touch_Strip_LED_{}'.format(index)) for index, led_id in enumerate(TOUCH_STRIP_LED_CC_RANGE) ]
self.touch_strip = TouchStripElement(name=u'Touch_Strip', msg_type=MIDI_PB_TYPE, channel=15, touch_element=self.touch_strip_tap, leds=self.touch_strip_leds)
self.touch_strip.set_needs_takeover(False)
def __init__(self, *a, **k):
(super(LaunchkeyElements, self).__init__)(*a, **k)
self.right_button = create_button(102, 'Right_Button')
self.left_button = create_button(103, 'Left_Button')
self.shift_button = create_button(108,
'Shift_Button',
resource_type=PrioritizedResource,
channel=0)
self.play_button = create_button(115, 'Play_Button')
self.record_button = create_button(117, 'Record_Button')
self.play_button_with_shift = self.with_shift(self.play_button)
self.scene_launch_buttons_raw = [
create_button(104, 'Scene_Launch_Button', channel=0),
create_button(105, 'Stop_Solo_Mute_Button', channel=0)
]
self.scene_launch_buttons = ButtonMatrixElement(
rows=[self.scene_launch_buttons_raw], name='Scene_Launch_Buttons')
self.clip_launch_matrix = ButtonMatrixElement(
rows=[[
create_button(
(offset + col_index),
('{}_Clip_Launch_Button_{}'.format(col_index, row_index)),
msg_type=MIDI_NOTE_TYPE,
channel=0) for col_index in range(SESSION_WIDTH)
] for row_index, offset in enumerate(range(96, 119, 16))],
name='Clip_Launch_Matrix')
drum_pad_rows = ((48, 49, 50, 51), (44, 45, 46, 47), (40, 41, 42, 43),
(36, 37, 38, 39))
self.drum_pads = ButtonMatrixElement(rows=[[
create_button((row_identifiers[col_index]),
('Drum_Pad_{}_{}'.format(col_index, row_index)),
msg_type=MIDI_NOTE_TYPE,
channel=DRUM_CHANNEL) for col_index in range(4)
] for row_index, row_identifiers in enumerate(drum_pad_rows)],
name='Drum_Pads')
self.pots = ButtonMatrixElement(rows=[[
create_encoder(index + 21, 'Pot_{}'.format(index))
for index in range(SESSION_WIDTH)
]],
name='Pots')
self.incontrol_mode_switch = create_button(12,
'InControl_Mode_Switch',
msg_type=MIDI_NOTE_TYPE)
self.pad_layout_switch = create_button(3, 'Pad_Layout_Switch')
self.pot_layout_switch = create_button(9, 'Pot_Layout_Switch')
def _setup_controls(self):
is_momentary = True
optimized = True
resource = PrioritizedResource
self._encoder = [
CodecEncoderElement(msg_type=MIDI_CC_TYPE,
channel=CHANNEL,
identifier=TWISTER_DIALS[index],
name='Encoder_' + str(index),
num=TWISTER_DIALS[index],
script=self,
optimized_send_midi=optimized,
resource_type=resource,
monobridge=self._monobridge)
for index in range(16)
]
self._encoder_button = [
TwisterButtonElement(is_momentary=is_momentary,
msg_type=MIDI_CC_TYPE,
channel=1,
identifier=TWISTER_DIAL_BUTTONS[index],
name='Encoder_Button_' + str(index),
script=self,
skin=self._skin,
color_map=COLOR_MAP,
optimized_send_midi=optimized,
resource_type=resource,
monobridge=self._monobridge)
for index in range(16)
]
self._dial_matrix = ButtonMatrixElement(
name='Dial_Matrix',
rows=[
self._encoder[index * 4:(index * 4) + 4] for index in range(4)
])
self._dial_button_matrix = ButtonMatrixElement(
name='Dial_Button_Matrix',
rows=[
self._encoder_button[index * 4:(index * 4) + 4]
for index in range(4)
])
def _create_device_component(self):
device_component_layer = Layer(
parameter_touch_buttons=ButtonMatrixElement(
rows=[self.elements.global_param_touch_buttons_raw]),
shift_button=u'shift_button')
return DeviceComponentProvider(
device_component_layer=device_component_layer,
device_decorator_factory=self._device_decorator_factory,
device_bank_registry=self._device_bank_registry,
banking_info=self._banking_info,
name=u'DeviceComponent',
is_enabled=False,
delete_button=self.elements.delete_button)
def __init__(self, *a, **k):
(super(Elements, self).__init__)(*a, **k)
self.fader_button_modes_button = create_button(45, 'Fader_Button_Modes_Button')
self.device_select_button = create_button(51, 'Device_Select_Button')
self.device_lock_button = create_button(52, 'Device_Lock_Button')
self.capture_midi_button = create_button(74, 'Capture_MIDI_Button')
self.quantize_button = create_button(75, 'Quantize_Button')
self.click_button = create_button(76, 'Click_Button')
self.undo_button = create_button(77, 'Undo_Button')
self.up_button = create_rgb_button(106, 'Up_Button')
self.down_button = create_rgb_button(107, 'Down_Button')
self.stop_button = create_button(116, 'Stop_Button')
self.loop_button = create_button(118, 'Loop_Button')
self.secondary_up_button = create_button(104, '')
self.secondary_down_button = create_button(105, '')
self.device_select_matrix = ButtonMatrixElement(rows=[[create_button((offset + col_index), ('{}_Device_Select_Button_{}'.format(col_index, row_index)), msg_type=MIDI_NOTE_TYPE, channel=0) for col_index in range(SESSION_WIDTH)] for row_index, offset in enumerate(range(64, 87, 16))],
name='Device_Select_Matrix')
self.fader_layout_switch = create_button(10, 'Fader_Layout_Switch')
self.fader_buttons = ButtonMatrixElement(rows=[
[create_rgb_button(index + 37, 'Fader_Button_{}'.format(index)) for index in range(SESSION_WIDTH)]],
name='Fader_Button')
self.faders = ButtonMatrixElement(rows=[
[create_encoder(index + 53, 'Fader_{}'.format(index)) for index in range(SESSION_WIDTH)]],
name='Faders')
self.master_fader = create_encoder(61, 'Master_Fader')
self.notification_display = ButtonMatrixElement(rows=[
[create_display_element(midi.NOTIFICATION_DISPLAY_COMMAND_BYTES[index], 'Notification_Display_Line_{}'.format(index)) for index in range(2)]],
name='Notification_Display')
self.pot_parameter_name_displays = create_parameter_display_matrix(midi.PARAMETER_NAME_DISPLAY_COMMAND_BYTE, midi.POT_PARAMETER_DISPLAY_START_INDEX, 'Pot_Parameter_Name')
self.pot_parameter_value_displays = create_parameter_display_matrix(midi.PARAMETER_VALUE_DISPLAY_COMMAND_BYTE, midi.POT_PARAMETER_DISPLAY_START_INDEX, 'Pot_Parameter_Value')
self.fader_parameter_name_displays = create_parameter_display_matrix(midi.PARAMETER_NAME_DISPLAY_COMMAND_BYTE, midi.FADER_PARAMETER_DISPLAY_START_INDEX, 'Fader_Parameter_Name')
self.fader_parameter_value_displays = create_parameter_display_matrix(midi.PARAMETER_VALUE_DISPLAY_COMMAND_BYTE, midi.FADER_PARAMETER_DISPLAY_START_INDEX, 'Fader_Parameter_Value')
self.master_fader_parameter_name_display = create_display_element((
midi.PARAMETER_NAME_DISPLAY_COMMAND_BYTE,
midi.MASTER_PARAMETER_DISPLAY_INDEX), 'Master_Fader_Parameter_Name_Display')
self.master_fader_parameter_value_display = create_display_element((
midi.PARAMETER_VALUE_DISPLAY_COMMAND_BYTE,
midi.MASTER_PARAMETER_DISPLAY_INDEX), 'Master_Fader_Parameter_Value_Display')
def _create_controls(self):
self._hardware_live_mode_switch = SysexElement(send_message_generator=lambda b: sysex.LIVE_MODE_MESSAGE_HEADER + (
b, sysex.END_BYTE), default_value=sysex.OFF_VALUE, name=b'Hardware_Live_Mode_Switch')
self._memory_preset_switch = SysexElement(send_message_generator=lambda b: sysex.MEMORY_PRESET_SWITCH_MESSAGE_HEADER + (
b, sysex.END_BYTE), sysex_identifier=sysex.MEMORY_PRESET_SWITCH_MESSAGE_HEADER, name=b'Memory_Preset_Switch')
self._memory_preset_select_mode_switch = SysexElement(sysex_identifier=sysex.MEMORY_PRESET_SELECT_MODE_MESSAGE_HEADER, name=b'Memory_Preset_Select_Mode')
self._play_button = create_button(94, b'Play_Button')
self._stop_button = create_button(93, b'Stop_Button')
self._punch_in_button = create_button(87, b'Punch_In_Button')
self._punch_out_button = create_button(88, b'Punch_Out_Button')
self._metronome_button = create_button(89, b'Metronome_Button')
self._loop_button = create_button(86, b'Loop_Button')
self._rwd_button = create_button(91, b'Rewind_Button')
self._ff_button = create_button(92, b'Fast_Forward_Button')
self._record_button = create_button(95, b'Record_Button')
self._undo_button = create_button(81, b'Undo_Button')
self._bank_left_button = create_button(46, b'Bank_Left_Button')
self._bank_right_button = create_button(47, b'Bank_Right_Button')
self._left_button = create_button(48, b'Left_Button')
self._right_button = create_button(49, b'Right_Button')
self._left_arrow_button = create_button(98, b'Left_Arrow_Button')
self._right_arrow_button = create_button(99, b'Right_Arrow_Button')
self._marker_button = create_button(84, b'Marker_Button')
self._pads = ButtonMatrixElement(rows=[
[ create_button(col + 36, b'Pad_%d' % (col,), channel=10) for col in xrange(8)
]], name=b'Pad_Matrix')
self._pad_leds = ButtonMatrixElement(rows=[
[ create_pad_led(column + 112, b'Pad_LED_%d' % (column,)) for column in xrange(8)
]], name=b'Pad_LED_Matrix')
self._faders = ButtonMatrixElement(rows=[
[ SliderElement(msg_type=MIDI_PB_TYPE, channel=index, identifier=None, name=b'Fader_%d' % (index,)) for index in xrange(8)
]], name=b'Faders')
self._master_fader = SliderElement(MIDI_PB_TYPE, 8, identifier=None, name=b'Master_Fader')
self._encoders = ButtonMatrixElement(rows=[
[ create_ringed_encoder(index + 16, index + 48, b'Encoder_%d' % (index,)) for index in xrange(8)
]])
self._jogwheel = EncoderElement(MIDI_CC_TYPE, 0, 60, Live.MidiMap.MapMode.relative_smooth_signed_bit, name=b'Jogwheel')
return
def _setup_controls(self): self._pedal = [None for index in range(8)] for index in range(7): self._pedal[index] = DoublePressElement(MonoButtonElement(is_momentary = True, msg_type = MIDI_CC_TYPE, channel = 0, identifier = PEDAL_DEFS[index], name = 'Pedal_'+str(index), script = self)) self._pedal[index]._report = False self._pedal[7] = LoopPedalExpressionElement(script = self, msg_type = MIDI_CC_TYPE, channel = 0, identifier = 1, map_mode = Live.MidiMap.MapMode.absolute) self._pedal[7].name = 'Pedal_'+str(7) self._pedal[7]._report = False self._leds = [None for index in range(4)] for index in range(4): red_led = ButtonElement(True, MIDI_NOTE_TYPE, 0, LED_DEFS[index]) green_led = ButtonElement(True, MIDI_NOTE_TYPE, 0, LED_DEFS[index]+4) blue_led = ButtonElement(True, MIDI_NOTE_TYPE, 0, LED_DEFS[index]+8) self._leds[index] = RGB_LED(red_led, green_led, blue_led, is_momentary = True, msg_type = MIDI_NOTE_TYPE, channel = 0, identifier = index+13, name = 'LED_' + str(index), script = self) self._select_buttons = ButtonMatrixElement() self._select_buttons.name = 'SelectMatrix' self._select_buttons.add_row([self._pedal[6], self._pedal[5], self._pedal[4], self._pedal[3]]) self._doublepress_select_buttons = ButtonMatrixElement() self._doublepress_select_buttons.name = 'DoublepressSelectMatrix' self._doublepress_select_buttons.add_row([self._pedal[6].double_press, self._pedal[5].double_press, self._pedal[4].double_press, self._pedal[3].double_press]) self._record_button = self._pedal[1] self._mute_button = self._pedal[2] self._overdub_button = self._pedal[0]
def _setup_device_selector(self):
self._device_selector = DeviceSelectorComponent(self)
self._device_selector.name = 'Device_Selector'
#self._device_selector.select_layer = AddLayerMode(self._device_selector, Layer(priority = 6 , matrix = self._matrix.submatrix[:, :]))
self._device_selector.select_layer = AddLayerMode(
self._device_selector,
Layer(priority=6,
matrix=ButtonMatrixElement(rows=[
self._grid[:4], self._grid[4:8], self._grid[8:12],
self._grid[12:14]
])))
self._device_selector.assign_layer = AddLayerMode(
self._device_selector,
Layer(priority=7, assign_button=self._grid[14]))
self._device_selector.set_enabled(False)
class MonoPedal(ControlSurface):
def __init__(self, *a, **k):
self.log_message = logger.warning
super(MonoPedal, self).__init__(*a, **k)
self._monomod_version = 'b996'
self._codec_version = 'b996'
self._cntrlr_version = 'b996'
self._cntrlr = None
self._host_name = 'MonoPedal'
self._color_type = 'OhmRGB'
self.hosts = []
self._timer = 0
self.flash_status = 1
self._touched = 0
self._last_main_mode = 'looper'
with self.component_guard():
self._setup_monobridge()
self._setup_controls()
self._setup_looper()
self._setup_launcher()
self._setup_device_control()
self._setup_modes()
self.schedule_message(1, self._open_log)
#self._loop_selector.set_enabled(True)
"""script initialization methods"""
def _open_log(self):
self.log_message("<<<<<<<<<<<<<<<<<<<<= " + str(self._host_name) + " " + str(self._monomod_version) + " log opened =>>>>>>>>>>>>>>>>>>>")
self.show_message(str(self._host_name) + ' Control Surface Loaded')
def _setup_monobridge(self):
self._monobridge = MonoBridgeElement(self)
self._monobridge.name = 'MonoBridge'
def _setup_controls(self):
self._pedal = [None for index in range(8)]
for index in range(7):
self._pedal[index] = DoublePressElement(MonoButtonElement(is_momentary = True, msg_type = MIDI_CC_TYPE, channel = 0, identifier = PEDAL_DEFS[index], name = 'Pedal_'+str(index), script = self))
self._pedal[index]._report = False
self._pedal[7] = LoopPedalExpressionElement(script = self, msg_type = MIDI_CC_TYPE, channel = 0, identifier = 1, map_mode = Live.MidiMap.MapMode.absolute)
self._pedal[7].name = 'Pedal_'+str(7)
self._pedal[7]._report = False
self._leds = [None for index in range(4)]
for index in range(4):
red_led = ButtonElement(True, MIDI_NOTE_TYPE, 0, LED_DEFS[index])
green_led = ButtonElement(True, MIDI_NOTE_TYPE, 0, LED_DEFS[index]+4)
blue_led = ButtonElement(True, MIDI_NOTE_TYPE, 0, LED_DEFS[index]+8)
self._leds[index] = RGB_LED(red_led, green_led, blue_led, is_momentary = True, msg_type = MIDI_NOTE_TYPE, channel = 0, identifier = index+13, name = 'LED_' + str(index), script = self)
self._select_buttons = ButtonMatrixElement()
self._select_buttons.name = 'SelectMatrix'
self._select_buttons.add_row([self._pedal[6], self._pedal[5], self._pedal[4], self._pedal[3]])
self._doublepress_select_buttons = ButtonMatrixElement()
self._doublepress_select_buttons.name = 'DoublepressSelectMatrix'
self._doublepress_select_buttons.add_row([self._pedal[6].double_press, self._pedal[5].double_press, self._pedal[4].double_press, self._pedal[3].double_press])
self._record_button = self._pedal[1]
self._mute_button = self._pedal[2]
self._overdub_button = self._pedal[0]
def _setup_looper(self):
self._looper = MonolooperComponent(self._leds, self)
self._looper.layer = Layer(select_buttons = self._select_buttons,
doublepress_select_buttons = self._doublepress_select_buttons,
overdub_button = self._pedal[2],
record_button = self._pedal[1],
mute_button = self._pedal[0],
expression_pedal = self._pedal[7],)
def _setup_launcher(self):
self._launcher = LauncherComponent(self._leds, self)
self._launcher.set_enabled(False)
self._launcher.layer = Layer(select_buttons = self._select_buttons,
doublepress_select_buttons = self._doublepress_select_buttons,
fire1_button = self._pedal[2],
fire2_button = self._pedal[1],
fire3_button = self._pedal[0],
expression_pedal = self._pedal[7])
def _setup_device_control(self):
self._device_control = DeviceControlComponent(self._leds, self)
self._device_control.set_enabled(False)
self._device_control.layer = Layer(select_buttons = self._select_buttons,
doublepress_select_buttons = self._doublepress_select_buttons,
toggle1_button = self._pedal[2],
toggle2_button = self._pedal[1],
toggle3_button = self._pedal[0],
expression_pedal = self._pedal[7])
def _setup_modes(self):
self._button_modes = ModesComponent(name='Button_Modes')
self._button_modes.add_mode('launcher', self._launcher)
self._button_modes.add_mode('looper', self._looper)
self._button_modes.add_mode('device', self._device_control)
self._button_modes.selected_mode = 'looper'
self._button_modes.set_enabled(True)
def receive_led(self, button, value):
#self.log_message('receive led: ' + str(index) + ' ' + str(value))
pass
def toggle_mode(self):
self._button_modes.selected_mode = 'launcher' if self._button_modes.selected_mode is 'looper' else 'looper'
self._last_main_mode = self._button_modes.selected_mode
#self.log_message('toggle mode to: ' + str(self._button_modes.selected_mode))
def toggle_device_control(self, x):
self._button_modes.selected_mode = 'device' if not self._button_modes.selected_mode is 'device' else self._last_main_mode
if self._button_modes.selected_mode is 'device':
self._device_control.set_bank(x)
"""called on timer"""
def update_display(self):
super(MonoPedal, self).update_display()
self._timer = (self._timer + 1) % 256
self.flash()
def flash(self):
if(self.flash_status > 0):
for control in self.controls:
if isinstance(control, MonoButtonElement):
control.flash(self._timer)
def __init__(self, deleter = None, undo_handler = None, pad_sensitivity_update = None, playhead = None, *a, **k):
raise deleter is not None or AssertionError
raise undo_handler is not None or AssertionError
raise playhead is not None or AssertionError
super(Elements, self).__init__(*a, **k)
self.foot_pedal_button = DoublePressElement(create_button(69, 'Foot_Pedal', is_rgb=True))
self.nav_up_button = create_button(46, 'Up_Arrow')
self.nav_down_button = create_button(47, 'Down_Arrow')
self.nav_left_button = create_button(44, 'Left_Arrow')
self.nav_right_button = create_button(45, 'Right_Arrow')
self.shift_button = create_modifier_button(49, 'Shift_Button')
self.select_button = create_modifier_button(48, 'Select_Button')
self.delete_button = create_modifier_button(118, 'Delete_Button', undo_step_handler=undo_handler)
self.duplicate_button = create_modifier_button(88, 'Duplicate_Button', undo_step_handler=undo_handler)
self.quantize_button = create_modifier_button(116, 'Quantization_Button', undo_step_handler=undo_handler)
self.accent_button = create_modifier_button(57, 'Accent_Button')
self.in_button = create_button(62, 'In_Button')
self.out_button = create_button(63, 'Out_Button')
self.master_select_button = create_button(28, 'Master_Select_Button')
self.octave_down_button = create_button(54, 'Octave_Down_Button')
self.octave_up_button = create_button(55, 'Octave_Up_Button')
self.repeat_button = create_button(56, 'Repeat_Button')
self.global_mute_button = create_modifier_button(60, 'Global_Mute_Button')
self.global_solo_button = create_modifier_button(61, 'Global_Solo_Button')
self.global_track_stop_button = create_modifier_button(29, 'Track_Stop_Button')
self.scale_presets_button = create_button(58, 'Scale_Presets_Button')
self.vol_mix_mode_button = create_button(114, 'Vol_Mix_Mode_Button')
self.device_mode_button = create_button(110, 'Device_Mode_Button')
self.clip_mode_button = create_button(113, 'Clip_Mode_Button')
self.browse_mode_button = create_button(111, 'Browse_Mode_Button')
self.single_track_mix_mode_button = create_button(112, 'Single_Track_Mode_Button')
self.pan_send_mix_mode_button = create_button(115, 'Pan_Send_Mode_Button', resource_type=PrioritizedResource)
self.note_mode_button = create_button(50, 'Note_Mode_Button')
self.session_mode_button = create_button(51, 'Session_Mode_Button')
self.play_button = create_button(85, 'Play_Button')
self.new_button = create_button(87, 'New_Button')
self.automation_button = create_button(89, 'Automation_Button')
self.tap_tempo_button = create_button(3, 'Tap_Tempo_Button')
self.metronome_button = create_button(9, 'Metronome_Button')
self.fixed_length_button = create_button(90, 'Fixed_Length_Button')
self.record_button = create_modifier_button(86, 'Record_Button')
self.undo_button = create_button(119, 'Undo_Button')
self.create_device_button = create_button(52, 'Create_Device_Button', undo_step_handler=undo_handler)
self.create_track_button = create_button(53, 'Create_Track_Button', undo_step_handler=undo_handler)
self.double_button = create_button(117, 'Double_Button', undo_step_handler=undo_handler)
self.user_button = create_button(59, 'User_Button', undo_step_handler=undo_handler)
self.select_buttons_raw = [ create_button(20 + idx, 'Track_Select_Button' + str(idx)) for idx in xrange(8) ]
self.select_buttons = ButtonMatrixElement(name='Track_Select_Buttons', rows=[self.select_buttons_raw])
self.track_state_buttons_raw = [ create_button(102 + idx, 'Track_State_Button' + str(idx), is_rgb=True) for idx in xrange(8) ]
self.track_state_buttons = ButtonMatrixElement(name='Track_State_Buttons', rows=[self.track_state_buttons_raw])
self.side_buttons_raw = [ create_button(36 + idx, 'Scene_Launch_Button' + str(idx)) for idx in reversed(xrange(8)) ]
self.side_buttons = ButtonMatrixElement(name='Scene_Launch_Buttons', rows=[self.side_buttons_raw])
@depends(skin=None)
def create_pad_button(pad_id, name, skin = None, **k):
return PadButtonElement(pad_id, pad_sensitivity_update, True, MIDI_NOTE_TYPE, 0, (36 + pad_id), skin=skin, name=name, **k)
self.matrix_rows_raw = [ [ create_pad_button((7 - row) * 8 + column, str(column) + '_Clip_' + str(row) + '_Button', is_rgb=True, default_states={True: 'DefaultMatrix.On',
False: 'DefaultMatrix.Off'}) for column in xrange(8) ] for row in xrange(8) ]
double_press_rows = recursive_map(DoublePressElement, self.matrix_rows_raw)
self.matrix = ButtonMatrixElement(name='Button_Matrix', rows=self.matrix_rows_raw)
self.double_press_matrix = ButtonMatrixElement(name='Double_Press_Matrix', rows=double_press_rows)
self.single_press_event_matrix = ButtonMatrixElement(name='Single_Press_Event_Matrix', rows=recursive_map(lambda x: x.single_press, 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.tempo_control_tap = create_note_button(10, 'Tempo_Control_Tap')
self.tempo_control = TouchEncoderElement(channel=0, identifier=14, map_mode=consts.GLOBAL_MAP_MODE, name='Tempo_Control', undo_step_handler=undo_handler, delete_handler=deleter, encoder_sensitivity=consts.ENCODER_SENSITIVITY, touch_element=self.tempo_control_tap)
self.swing_control_tap = create_note_button(9, 'Swing_Control_Tap')
self.swing_control = TouchEncoderElement(channel=0, identifier=15, map_mode=consts.GLOBAL_MAP_MODE, name='Swing_Control', undo_step_handler=undo_handler, delete_handler=deleter, encoder_sensitivity=consts.ENCODER_SENSITIVITY, touch_element=self.swing_control_tap)
self.master_volume_control_tap = create_note_button(8, 'Master_Volume_Tap')
self.master_volume_control = TouchEncoderElement(channel=0, identifier=79, map_mode=consts.GLOBAL_MAP_MODE, undo_step_handler=undo_handler, delete_handler=deleter, name='Master_Volume_Control', encoder_sensitivity=consts.ENCODER_SENSITIVITY, touch_element=self.master_volume_control_tap)
self.master_volume_control.mapping_sensitivity = consts.CONTINUOUS_MAPPING_SENSITIVITY
self.global_param_touch_buttons_raw = [ create_note_button(index, 'Track_Control_Touch_' + str(index), resource_type=PrioritizedResource) for index in range(8) ]
self.global_param_touch_buttons = ButtonMatrixElement(name='Track_Control_Touches', rows=[self.global_param_touch_buttons_raw])
self.parameter_controls_raw = [ TouchEncoderElement(channel=0, identifier=71 + index, map_mode=consts.GLOBAL_MAP_MODE, undo_step_handler=undo_handler, delete_handler=deleter, encoder_sensitivity=consts.ENCODER_SENSITIVITY, name='Track_Control_' + str(index), touch_element=self.global_param_touch_buttons_raw[index]) for index in xrange(8) ]
self.global_param_controls = ButtonMatrixElement(name='Track_Controls', rows=[self.parameter_controls_raw])
self.fine_grain_param_controls_raw = [ FineGrainWithModifierEncoderElement(encoder, self.shift_button, consts.FINE_GRAINED_CONTINUOUS_MAPPING_SENSITIVITY, consts.CONTINUOUS_MAPPING_SENSITIVITY) for encoder in self.parameter_controls_raw ]
self.fine_grain_param_controls = ButtonMatrixElement(rows=[self.fine_grain_param_controls_raw])
self.any_touch_button = MultiElement(*self.global_param_touch_buttons.nested_control_elements())
self.playhead_element = PlayheadElement(playhead)
