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')