def _setup_session_control(self): self.session = CustomSessionComponent(self.box_width, self.box_height, self) # subclass from _Framework is_momentary = True # what exactly does this do in the _Framework? if up_button_note_number >= 0 and down_button_note_number >= 0: # opt in enable UP/DOWN nav up_button = ButtonElement(is_momentary, MIDI_NOTE_TYPE, midi_channel, up_button_note_number) up_button.name = 'Bank_Select_Up_Button' # sure, why not down_button = ButtonElement(is_momentary, MIDI_NOTE_TYPE, midi_channel, down_button_note_number) down_button.name = 'Bank_Select_Down_Button' #sure, why not self.session.set_scene_bank_buttons(down_button, up_button) if right_button_note_number >= 0 and left_button_note_number >= 0: # opt in enable LEFT/RIGHT nav right_button = ButtonElement(is_momentary, MIDI_NOTE_TYPE, midi_channel, right_button_note_number) right_button.name = 'Bank_Select_Right_Button' #sure, why not left_button = ButtonElement(is_momentary, MIDI_NOTE_TYPE, midi_channel, left_button_note_number) left_button.name = 'Bank_Select_Left_Button' #sure, why not self.session.set_track_bank_buttons(right_button, left_button) self.session.name = 'Session_Control' #sure, why not matrix = ButtonMatrixElement() # @todo subclass this via established new patterns matrix.name = 'Button_Matrix' #sure, why not # I loop a little different. The goal is readbility, flexibility, and the web app...incase you did not notice yet if len(scene_launch_notes) > 0 and len(scene_launch_notes) == self.box_height: # logic check have launch notes and scene = box height for index in range(self.box_height): self.session.scene(index).set_launch_button(ButtonElement(is_momentary, MIDI_NOTE_TYPE, midi_channel, scene_launch_notes[index])) else : self.log_message("..::|| Scene launch not in use or error on case of use. Modern.DJ ||::..") if len(stop_track_buttons) >0 and len(stop_track_buttons) == self.box_width: #logic check have track stop assignments and track_stop_buttons = [ ButtonElement(is_momentary, MIDI_NOTE_TYPE, midi_channel, stop_track_buttons[index]) for index in range(len(stop_track_buttons))] for index in range(len(track_stop_buttons)): track_stop_buttons[index].name = 'Track_' + str(index) + '_Stop_Button' # sure, why not self.session.set_stop_track_clip_buttons(tuple(track_stop_buttons)) else : self.log_message("..::|| Stop notes not in use or error found Modern.DJ ||::..") # Check for stop all clips option if stop_all_clips >=0 : self.session.set_stop_all_clips_button(ButtonElement(is_momentary, MIDI_NOTE_TYPE, midi_channel, stop_all_clips)) # creating the matrix of buttons from the launch_button_list (tuple) launch_button_list_len = len(launch_button_list) # var used multiple times. This is a performance modification if (self.box_height*self.box_width) == launch_button_list_len : # check box size against number of button vars sent launch_ctr = launch_button_list_len -1 # decrement for zero offset in list/tuple launch_button_list.reverse() #reverse list from human readable for decrement use (performance tweak) ## check for use of RGB if use_velocity_for_RGB != 1: # if not enabled use these defaults self.log_message("..::|| RGB not in effect assigning defaults ||::..") self.clip_loaded_stopped = 1 self.clip_currently_playing = 127 self.clip_triggered_to_play = 64 else: # yes RGB in effect...assign per the parameters script self.clip_loaded_stopped = clip_loaded_stopped self.clip_currently_playing = clip_currently_playing self.clip_triggered_to_play = clip_triggered_to_play for scene_index in range(self.box_height): # loop on the notes matrix scene = self.session.scene(scene_index) # part of the martix built, think rows scene.name = 'Scene_' + str(scene_index) # sure, why not button_row = [] # create recepticle # loop across the tracks for track_index in range(self.box_width): button = ButtonElement(is_momentary, MIDI_NOTE_TYPE, midi_channel, launch_button_list[launch_ctr]) # button instance for _Framework launch_ctr = launch_ctr -1# decrement is faster than increment button.name = str(track_index) + '_Clip_' + str(scene_index) + '_Button' # sure, why not button_row.append(button) # add to our growing list clip_slot = scene.clip_slot(track_index) # clips slot and buttons are not the same thing, this aligns these ideas in the red box clip_slot.name = str(track_index) + '_Clip_Slot_' + str(scene_index) # sure, why not # assign the button and and status in th refrech update clip_slot.set_stopped_value(self.clip_loaded_stopped ) # this number is sent back to the machine allowing diff colors for stopped clip_slot.set_started_value(self.clip_currently_playing) # this number is sent back to the machine allowing diff colors for started/is-playing clip_slot.set_triggered_to_play_value(self.clip_triggered_to_play) # this number is sent back to the machine allowing diff colors for cued, will play next clip_slot.set_launch_button(button) # part of the slit+button = go time paradigm matrix.add_row(tuple(button_row)) # close out the matrix build. @todo - possible subclass here? else : # log message self.log_message("..::|| Number of notes defined does not match box height and width Modern.DJ ||::..") ''' live 9 only self.set_highlighting_session_component(self.session) # new for live9 -- this is for the box. via aumhaa/bitnomad ''' return None
def _setup_session_control(self): is_momentary = True self._shift_button = ButtonElement(is_momentary, MIDI_NOTE_TYPE, 0, 98) right_button = ButtonElement(is_momentary, MIDI_NOTE_TYPE, 0, 96) left_button = ButtonElement(is_momentary, MIDI_NOTE_TYPE, 0, 97) up_button = ButtonElement(is_momentary, MIDI_NOTE_TYPE, 0, 94) down_button = ButtonElement(is_momentary, MIDI_NOTE_TYPE, 0, 95) right_button.name = 'Bank_Select_Right_Button' left_button.name = 'Bank_Select_Left_Button' up_button.name = 'Bank_Select_Up_Button' down_button.name = 'Bank_Select_Down_Button' self._session = PedaledSessionComponent(8, 5) self._session.name = 'Session_Control' self._session.set_track_bank_buttons(right_button, left_button) self._session.set_scene_bank_buttons(down_button, up_button) matrix = ButtonMatrixElement() matrix.name = 'Button_Matrix' scene_launch_buttons = [ ButtonElement(is_momentary, MIDI_NOTE_TYPE, 0, index + 82) for index in range(5) ] track_stop_buttons = [ ButtonElement(is_momentary, MIDI_NOTE_TYPE, index, 52) for index in range(8) ] for index in range(len(scene_launch_buttons)): scene_launch_buttons[index].name = 'Scene_' + str( index) + '_Launch_Button' for index in range(len(track_stop_buttons)): track_stop_buttons[index].name = 'Track_' + str( index) + '_Stop_Button' stop_all_button = ButtonElement(is_momentary, MIDI_NOTE_TYPE, 0, 81) stop_all_button.name = 'Stop_All_Clips_Button' self._session.set_stop_all_clips_button(stop_all_button) self._session.set_stop_track_clip_buttons(tuple(track_stop_buttons)) self._session.set_stop_track_clip_value(2) for scene_index in range(5): scene = self._session.scene(scene_index) scene.name = 'Scene_' + str(scene_index) button_row = [] scene.set_launch_button(scene_launch_buttons[scene_index]) scene.set_triggered_value(2) for track_index in range(8): button = ButtonElement(is_momentary, MIDI_NOTE_TYPE, track_index, scene_index + 53) button.name = str(track_index) + '_Clip_' + str( scene_index) + '_Button' button_row.append(button) clip_slot = scene.clip_slot(track_index) clip_slot.name = str(track_index) + '_Clip_Slot_' + str( scene_index) clip_slot.set_triggered_to_play_value(2) clip_slot.set_triggered_to_record_value(4) clip_slot.set_stopped_value(5) clip_slot.set_started_value(1) clip_slot.set_recording_value(3) clip_slot.set_launch_button(button) matrix.add_row(tuple(button_row)) self._session.set_slot_launch_button( ButtonElement(is_momentary, MIDI_CC_TYPE, 0, 67)) self._session.selected_scene().name = 'Selected_Scene' self._session.selected_scene().set_launch_button( ButtonElement(is_momentary, MIDI_CC_TYPE, 0, 64)) self._session_zoom = SessionZoomingComponent(self._session) self._session_zoom.name = 'Session_Overview' self._session_zoom.set_button_matrix(matrix) self._session_zoom.set_zoom_button(self._shift_button) self._session_zoom.set_nav_buttons(up_button, down_button, left_button, right_button) self._session_zoom.set_scene_bank_buttons(tuple(scene_launch_buttons)) self._session_zoom.set_stopped_value(3) self._session_zoom.set_selected_value(5)
def __init__(self, c_instance): ControlSurface.__init__(self, c_instance) with self.component_guard(): is_momentary = True self._device_selection_follows_track_selection = True self.set_pad_translations(PAD_TRANSLATIONS) self._suggested_input_port = 'HyperControl' self._suggested_output_port = 'HyperControl' self._display_on_button = ButtonElement(not is_momentary, MIDI_CC_TYPE, 15, 79) self._waiting_for_first_response = True mixer1 = DisplayingMixerComponent(0) mixer1.set_select_buttons( ButtonElement(is_momentary, MIDI_CC_TYPE, 15, 111), ButtonElement(is_momentary, MIDI_CC_TYPE, 15, 110)) mixer1.set_mute_button( ButtonElement(is_momentary, MIDI_CC_TYPE, 15, 12)) mixer1.set_solo_button( ButtonElement(is_momentary, MIDI_CC_TYPE, 15, 13)) mixer2 = NotifyingMixerComponent(8) mixer2.set_bank_buttons( ButtonElement(is_momentary, MIDI_CC_TYPE, 15, 15), ButtonElement(is_momentary, MIDI_CC_TYPE, 15, 14)) mixer2.master_strip().set_volume_control( SliderElement(MIDI_CC_TYPE, 15, 41)) for index in range(8): mixer2.channel_strip(index).set_volume_control( SliderElement(MIDI_CC_TYPE, 15, 33 + index)) device = PageableDeviceComponent() self.set_device_component(device) ffwd_button = ButtonElement(is_momentary, MIDI_CC_TYPE, 15, 115) rwd_button = ButtonElement(is_momentary, MIDI_CC_TYPE, 15, 114) loop_button = ButtonElement(is_momentary, MIDI_CC_TYPE, 15, 113) transport = TransportComponent() transport.set_stop_button( ButtonElement(is_momentary, MIDI_CC_TYPE, 15, 116)) transport.set_play_button( ButtonElement(is_momentary, MIDI_CC_TYPE, 15, 117)) transport.set_record_button( ButtonElement(is_momentary, MIDI_CC_TYPE, 15, 118)) session = SessionComponent(0, 0) transport_view_modes = TransportViewModeSelector( transport, session, ffwd_button, rwd_button, loop_button) select_button_modes = SelectButtonModeSelector( mixer2, tuple([ ButtonElement(is_momentary, MIDI_CC_TYPE, 15, 49 + offset) for offset in range(8) ])) select_button_modes.set_mode_toggle( ButtonElement(is_momentary, MIDI_CC_TYPE, 15, 57)) self._mixer_encoder_modes = EncoderMixerModeSelector(mixer2) encoders = [] for offset in range(8): encoders.append( PeekableEncoderElement( MIDI_CC_TYPE, 15, 17 + offset, Live.MidiMap.MapMode.relative_smooth_two_compliment)) encoders[-1].set_feedback_delay(-1) mixer_or_device = MixerOrDeviceModeSelector( self._mixer_encoder_modes, device, tuple(encoders), tuple([ ButtonElement(is_momentary, MIDI_CC_TYPE, 15, 74 + offset) for offset in range(4) ])) mixer_or_device.set_mode_toggle( ButtonElement(is_momentary, MIDI_CC_TYPE, 15, 109)) mixer_or_device.set_peek_button( ButtonElement(is_momentary, MIDI_CC_TYPE, 15, 78)) self._track_display = PhysicalDisplayElement(8, 1) self._track_display.set_clear_all_message(SYSEX_START + (16, 247)) self._track_display.set_message_parts(SYSEX_START + (17, 1, 0, 0), (247, )) self._track_display.segment(0).set_data_source( mixer1.selected_strip().track_name_data_source()) device_display = PhysicalDisplayElement(8, 1) device_display.set_message_parts(SYSEX_START + (17, 1, 0, 10), (247, )) parameter_display = PhysicalDisplayElement(16, 1) parameter_display.set_message_parts(SYSEX_START + (17, 2, 0, 0), (247, )) select_button_modes.set_mode_display(parameter_display) mixer1.set_display(parameter_display) mixer2.set_bank_display(parameter_display) page_displays = [] for index in range(4): page_displays.append(PhysicalDisplayElement(5, 1)) page_displays[-1].set_message_parts( SYSEX_START + (17, 4, index, 0), (247, )) encoder_display = PhysicalDisplayElement(80, 8) encoder_display.set_message_parts(SYSEX_START + (17, 3), (247, )) for index in range(8): pos_id = tuple() if index != 0: pos_id += (0, ) if index > 3: pos_id += (index % 4, 13) else: pos_id += (index % 4, 0) encoder_display.segment(index).set_position_identifier(pos_id) mixer_or_device.set_displays(encoder_display, parameter_display, device_display, tuple(page_displays)) for component in self.components: component.set_enabled(False)
def make_transport_button(control, name, is_momentary=True): return ButtonElement(is_momentary, MIDI_CC_TYPE, global_channel, transport_controls[control], name=name)
def make_button(identifier, name, msg_type=MIDI_NOTE_TYPE, channel=PAD_CHANNEL): return ButtonElement(True, msg_type, channel, identifier, name=name)
def __init__(self, parent): self._parent = parent self.master_track = parent.song().master_track self.the_slider = SliderElement(MIDI_CC_TYPE, 1, 86) self.the_slider.add_value_listener(self._do_main_slider, True) self.volume_button = None self._set_volume_button(ButtonElement(True, MIDI_CC_TYPE, 1, 80)) self.xfade_button = None self._set_xfade_button(ButtonElement(True, MIDI_CC_TYPE, 1, 99)) self.swing_button = None self._set_swing_button(ButtonElement(True, MIDI_CC_TYPE, 1, 81)) self.mode = KN2_MODE_VOLUME self.previous_mode = -1 self.tempo_button = None self._set_tempo_button(ButtonElement(True, MIDI_CC_TYPE, 1, 82)) self.push_button = None self._set_push_button(ButtonElement(True, MIDI_CC_TYPE, 1, 87)) self.clipn_v_button = None self.clipn_h_button = None self._set_clipn_h_button(ButtonElement(True, MIDI_CC_TYPE, 1, 90)) self._set_clipn_v_button(ButtonElement(True, MIDI_CC_TYPE, 1, 91)) self.toggle_buttons = [self.volume_button, self.xfade_button, self.swing_button, self.tempo_button, self.clipn_h_button, self.clipn_v_button] self.shift_button = None self._set_shift_button(ButtonElement(True, MIDI_CC_TYPE, 1, 85)) self.shift_on = False self.scroll_mod_left_button = None self.scroll_mod_right_button = None self._set_scroll_mod_left_button(ButtonElement(True, MIDI_CC_TYPE, 0, 105)) self._set_scroll_mod_right_button(ButtonElement(True, MIDI_CC_TYPE, 0, 106)) self._prev_mode = KN2_MODE_VOLUME self.lrmode = LR_CONTROL_CLIP self.loop_div_index = 0 self.loop_incdex = 4.0 self.arrow_mode_button = ColorButton(True, MIDI_CC_TYPE, 30) self.arrow_mode_button.add_value_listener(self.toggle_arrow_mode) self.arrow_mode_button.send_color(LR_MODE_HUES[self.lrmode]) self.arrow_mode_button.send_value(1) self.navflags = 0 self.octave_mod_button = ButtonElement(True, MIDI_CC_TYPE, 1, 70) self.octave_mod_button.add_value_listener(self._action_octave) self.scale_mod_button = ButtonElement(True, MIDI_CC_TYPE, 1, 71) self.scale_mod_button.add_value_listener(self._action_scale) self.basenote_mod_button = ButtonElement(True, MIDI_CC_TYPE, 1, 72) self.basenote_mod_button.add_value_listener(self._action_base_note) self.pad_to_mainknob_mode = 0 self.octave_dwn_button = ButtonElement(True, MIDI_CC_TYPE, 3, 120) self.octave_upp_button = ButtonElement(True, MIDI_CC_TYPE, 3, 121) self.scale_dwn_button = ButtonElement(True, MIDI_CC_TYPE, 3, 118) self.scale_upp_button = ButtonElement(True, MIDI_CC_TYPE, 3, 119) self.basent_dwn_button = ButtonElement(True, MIDI_CC_TYPE, 3, 124) self.basent_upp_button = ButtonElement(True, MIDI_CC_TYPE, 3, 125) self.octave_dwn_button.add_value_listener(self._action_oct_down) self.octave_upp_button.add_value_listener(self._action_oct_up) self.scale_dwn_button.add_value_listener(self._action_scale_down) self.scale_upp_button.add_value_listener(self._action_scale_up) self.basent_dwn_button.add_value_listener(self._action_base_down) self.basent_upp_button.add_value_listener(self._action_base_up) self._measure_left_click = 0 self._measure_right_click = 0 self.mode_assign_map = {KN2_MODE_VOLUME: (self.chg_volume, 0, 'Master Knob controls MASTER Volume', KN2_MODE_CUE), KN2_MODE_CUE: (self.chg_cue, 0, 'Master Knob controls Cue Level', KN2_MODE_VOLUME), KN2_MODE_TEMPO_COARSE: (self.chg_tempo, 3, 'Master Knob controls TEMPO Coarse', KN2_MODE_TEMPO_FINE), KN2_MODE_TEMPO_FINE: (self.chg_tempo_fine, 3, 'Master Knob controls TEMPO Fine', KN2_MODE_TEMPO_COARSE), KN2_MODE_XFADE: (self.chg_xfade, 1, 'Master Knob controls Crossfader', -1), KN2_MODE_QUANT: (self.chg_quant, 2, 'Master Knob controls Recording Quantize', KN2_MODE_CLIP_QUANT), KN2_MODE_CLIP_QUANT: (self.chg_clip_q, 2, 'Master Knob controls Clip Start Quantize', KN2_MODE_QUANT), KN2_MODE_CLIPN_HOR: (self.nav_c_hor, 4, 'Master Knob Clip View horizontally', -1), KN2_MODE_CLIPN_VER: (self.nav_c_ver, 5, 'Master Knob Clip View vertically', -1), KN2_MODE_GENERAL: (self.chg_general, -1, None, -1), KN2_P_SCALES: (self.modify_pad_scaling, -1, None, -1)}
def init(self): #skip init if already done. if self._init_done: return self._init_done = True # second part of the __init__ after model has been identified using its challenge response if self._mk3_rgb or self._lpx: from SkinMK2 import make_skin self._skin = make_skin() self._side_notes = (89, 79, 69, 59, 49, 39, 29, 19) self._drum_notes = (20, 30, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126) elif self._mk2_rgb: from SkinMK2 import make_skin self._skin = make_skin() self._side_notes = (89, 79, 69, 59, 49, 39, 29, 19) #self._drum_notes = (20, 30, 31, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126) self._drum_notes = (20, 30, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126) else: from SkinMK1 import make_skin # @Reimport self._skin = make_skin() self._side_notes = (8, 24, 40, 56, 72, 88, 104, 120) self._drum_notes = (41, 42, 43, 44, 45, 46, 47, 57, 58, 59, 60, 61, 62, 63, 73, 74, 75, 76, 77, 78, 79, 89, 90, 91, 92, 93, 94, 95, 105, 106, 107) with self.component_guard(): is_momentary = True self._config_button = ButtonElement(is_momentary, MIDI_CC_TYPE, 0, 0, optimized_send_midi=False) self._config_button.add_value_listener(self._config_value) 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) matrix = ButtonMatrixElement() matrix.name = 'Button_Matrix' for row in range(8): button_row = [] for column in range(8): if self._mk2_rgb or self._mk3_rgb or self._lpx: # for mk2 buttons are assigned "top to bottom" midi_note = (81 - (10 * row)) + column else: midi_note = row * 16 + column button = ConfigurableButtonElement(is_momentary, MIDI_NOTE_TYPE, 0, midi_note, skin=self._skin, control_surface=self) button.name = str(column) + '_Clip_' + str(row) + '_Button' button_row.append(button) matrix.add_row(tuple(button_row)) if self._mk3_rgb or self._lpx: top_buttons = [ ConfigurableButtonElement(is_momentary, MIDI_CC_TYPE, 0, 91 + index, skin=self._skin) for index in range(8) ] side_buttons = [ ConfigurableButtonElement(is_momentary, MIDI_CC_TYPE, 0, self._side_notes[index], skin=self._skin) for index in range(8) ] else: top_buttons = [ ConfigurableButtonElement(is_momentary, MIDI_CC_TYPE, 0, 104 + index, skin=self._skin) for index in range(8) ] side_buttons = [ ConfigurableButtonElement(is_momentary, MIDI_NOTE_TYPE, 0, self._side_notes[index], skin=self._skin) 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._osd = M4LInterface() self._osd.name = "OSD" self._init_note_repeat() self._selector = MainSelectorComponent(matrix, tuple(top_buttons), tuple(side_buttons), self._config_button, self._osd, self, self._note_repeat) self._selector.name = 'Main_Modes' self._do_combine() for control in self.controls: if isinstance(control, ConfigurableButtonElement): control.add_value_listener(self._button_value) self._suppress_session_highlight = False self.set_highlighting_session_component( self._selector.session_component()) # due to our 2 stage init, we need to rebuild midi map self.request_rebuild_midi_map() # and request update self._selector.update() if self._lpx: self.log_message("LaunchPad95 (LPX) Loaded !") elif self._mk3_rgb: self.log_message("LaunchPad95 (mk3) Loaded !") elif self._mk2_rgb: self.log_message("LaunchPad95 (mk2) Loaded !") else: self.log_message("LaunchPad95 (classic) Loaded !")
def _init_mixer_component(self, volume_controls, trackarm_controls, mixer_options, global_channel, volume_map_mode): if volume_controls != None and trackarm_controls != None: num_strips = max(len(volume_controls), len(trackarm_controls)) send_info = [] momentary_buttons = False mixer = SpecialMixerComponent(num_strips) mixer.name = 'Mixer' mixer.master_strip().name = 'Master_Channel_Strip' mixer.selected_strip().name = 'Selected_Channel_Strip' if mixer_options != None: if 'MASTERVOLUME' in mixer_options.keys() and mixer_options['MASTERVOLUME'] in range(128): encoder = EncoderElement(MIDI_CC_TYPE, global_channel, mixer_options['MASTERVOLUME'], volume_map_mode) encoder.name = 'Master_Volume_Control' mixer.master_strip().set_volume_control(encoder) if 'NUMSENDS' in mixer_options.keys() and mixer_options['NUMSENDS'] > 0: for send in range(mixer_options['NUMSENDS']): key = 'SEND' + str(send + 1) if not key in mixer_options.keys(): raise AssertionError send_info.append(mixer_options[key]) momentary_buttons = 'NOTOGGLE' in mixer_options.keys() next_bank_button = None prev_bank_button = None if 'NEXTBANK' in mixer_options.keys() and mixer_options['NEXTBANK'] in range(128): next_bank_button = ButtonElement(momentary_buttons, MIDI_CC_TYPE, global_channel, mixer_options['NEXTBANK']) next_bank_button.name = 'Mixer_Next_Bank_Button' if 'PREVBANK' in mixer_options.keys() and mixer_options['PREVBANK'] in range(128): prev_bank_button = ButtonElement(momentary_buttons, MIDI_CC_TYPE, global_channel, mixer_options['PREVBANK']) prev_bank_button.name = 'Mixer_Previous_Bank_Button' mixer.set_bank_buttons(next_bank_button, prev_bank_button) for track in range(num_strips): strip = mixer.channel_strip(track) strip.name = 'Channel_Strip_' + str(track) if track in range(len(volume_controls)): channel = global_channel cc = volume_controls[track] if isinstance(volume_controls[track], (tuple, list)): cc = volume_controls[track][0] if volume_controls[track][1] in range(16): channel = volume_controls[track][1] if cc in range(128) and channel in range(16): encoder = EncoderElement(MIDI_CC_TYPE, channel, cc, volume_map_mode) encoder.name = str(track) + '_Volume_Control' strip.set_volume_control(encoder) if track in range(len(trackarm_controls)) and trackarm_controls[track] in range(128): button = ButtonElement(momentary_buttons, MIDI_CC_TYPE, global_channel, trackarm_controls[track]) button.name = str(track) + '_Arm_Button' strip.set_arm_button(button) send_controls = [] for send in send_info: encoder = None if track in range(len(send)): channel = global_channel cc = send[track] if isinstance(send[track], (tuple, list)): cc = send[track][0] if send[track][1] in range(16): channel = send[track][1] if cc in range(128) and channel in range(16): encoder = EncoderElement(MIDI_CC_TYPE, channel, cc, volume_map_mode) encoder.name = str(track) + '_Send_' + str(list(send_info).index(send)) + '_Control' send_controls.append(encoder) strip.set_send_controls(tuple(send_controls))
def make_button(cc_no, name): button = ButtonElement(IS_MOMENTARY, MIDI_CC_TYPE, 0, cc_no) button.name = name return button
def setup_mixer(self): # elements self.mute_button = ButtonElement(True, MIDI_NOTE_TYPE, 0, 92) # tracks, return_tracks self.solo_button = ButtonElement(True, MIDI_NOTE_TYPE, 0, 84) # tracks, return_tracks self.arm_button = ButtonElement(True, MIDI_NOTE_TYPE, 0, 85) # tracks self.senda_up_button = ButtonElement(True, MIDI_NOTE_TYPE, 0, 96) # tracks, return_tracks self.senda_down_button = ButtonElement(True, MIDI_NOTE_TYPE, 0, 88) # tracks, return_tracks self.sendb_up_button = ButtonElement(True, MIDI_NOTE_TYPE, 0, 97) # tracks, return_tracks self.sendb_down_button = ButtonElement(True, MIDI_NOTE_TYPE, 0, 89) # tracks, return_tracks self.pan_up_button = ButtonElement( True, MIDI_NOTE_TYPE, 0, 98) # tracks, return_tracks, master_track self.pan_down_button = ButtonElement( True, MIDI_NOTE_TYPE, 0, 90) # tracks, return_tracks, master_track self.volume_up_button = ButtonElement( True, MIDI_NOTE_TYPE, 0, 99) # tracks, return_tracks, master_track self.volume_down_button = ButtonElement( True, MIDI_NOTE_TYPE, 0, 91) # tracks, return_tracks, master_track self.track_nav_encoder = EncoderElement( MIDI_CC_TYPE, 0, 14, Live.MidiMap.MapMode.relative_binary_offset) # mixer self.mixer = MixerComponent(7, 2) self.mixer.selected_strip().set_mute_button(self.mute_button) self.mixer.selected_strip().set_solo_button(self.solo_button) self.mixer.selected_strip().set_arm_button(self.arm_button) # send A/B, pan, volume self.senda_up_button.add_value_listener(self.on_senda_up_changed) self.senda_down_button.add_value_listener(self.on_senda_down_changed) self.sendb_up_button.add_value_listener(self.on_sendb_up_changed) self.sendb_down_button.add_value_listener(self.on_sendb_down_changed) self.pan_up_button.add_value_listener(self.on_pan_up_changed) self.pan_down_button.add_value_listener(self.on_pan_down_changed) self.volume_up_button.add_value_listener(self.on_volume_up_changed) self.volume_down_button.add_value_listener(self.on_volume_down_changed) # nav self.track_nav_encoder.add_value_listener(self.on_mixer_track_nav)
def _init_device_component(self, device_controls, bank_controls, global_channel, macro_map_mode): is_momentary = True if device_controls: device = DeviceComponent() device.name = 'Device_Component' if bank_controls: next_button = None prev_button = None if 'NEXTBANK' in bank_controls.keys() and bank_controls['NEXTBANK'] in range(128): next_button = ButtonElement(is_momentary, MIDI_CC_TYPE, global_channel, bank_controls['NEXTBANK']) next_button.name = 'Device_Next_Bank_Button' if 'PREVBANK' in bank_controls.keys() and bank_controls['PREVBANK'] in range(128): prev_button = ButtonElement(is_momentary, MIDI_CC_TYPE, global_channel, bank_controls['PREVBANK']) prev_button.name = 'Device_Previous_Bank_Button' device.set_bank_nav_buttons(prev_button, next_button) if 'TOGGLELOCK' in bank_controls.keys() and bank_controls['TOGGLELOCK'] in range(128): lock_button = ButtonElement(is_momentary, MIDI_CC_TYPE, global_channel, bank_controls['TOGGLELOCK']) lock_button.name = 'Device_Lock_Button' device.set_lock_button(lock_button) bank_buttons = [] for index in range(8): key = 'BANK' + str(index + 1) if key in bank_controls.keys(): control_info = bank_controls[key] channel = global_channel cc = -1 if isinstance(control_info, (tuple, list)): cc = control_info[0] if control_info[1] in range(16): channel = control_info[1] else: cc = control_info if cc in range(128) and channel in range(16): button = ButtonElement(is_momentary, MIDI_CC_TYPE, channel, cc) button.name = 'Device_Bank_' + str(index) + '_Button' bank_buttons.append(button) channel in range(16) if len(bank_buttons) > 0: device.set_bank_buttons(tuple(bank_buttons)) parameter_encoders = [] for control_info in device_controls: channel = global_channel cc = -1 if isinstance(control_info, (tuple, list)): cc = control_info[0] if control_info[1] in range(16): channel = control_info[1] else: cc = control_info if cc in range(128) and channel in range(16): encoder = EncoderElement(MIDI_CC_TYPE, channel, cc, macro_map_mode) encoder.name = 'Device_Parameter_' + str(list(device_controls).index(control_info)) + '_Control' parameter_encoders.append(encoder) continue if len(parameter_encoders) > 0: device.set_parameter_controls(tuple(parameter_encoders)) self.set_device_component(device)
def make_button(channel, cc, name, is_momentary=True): return ButtonElement(is_momentary, MIDI_CC_TYPE, channel, cc, name=name)
def _mainCtrl(self): self.show_message("Loading Korg nanoKontrol Studio mappings") # Main transport controls transport.set_record_button(ButtonElement(1, MIDI_CC_TYPE, 0, 81)) transport.set_loop_button(ButtonElement(1, MIDI_CC_TYPE, 0, 54)) transport.set_play_button(ButtonElement(1, MIDI_CC_TYPE, 0, 80)) transport.set_stop_button(ButtonElement(1, MIDI_CC_TYPE, 0, 63)) transport.set_tap_tempo_button(ButtonElement(1, MIDI_CC_TYPE, 0, 62)) # Seek/scrub controls: (is_momentary, MIDI_CC_TYPE, channel, CCnum). For this to work, nanoKontrol Studio's jog wheel should be set to: Inc/Dec 2, Acceleration 2. transport.set_seek_forward_button(ButtonElement( 0, MIDI_CC_TYPE, 0, 83)) transport.set_seek_backward_button( ButtonElement(0, MIDI_CC_TYPE, 0, 85)) transport.set_metronome_button(ButtonElement(1, MIDI_CC_TYPE, 0, 58)) transport.set_arrangement_overdub_button( ButtonElement(1, MIDI_CC_TYPE, 0, 59)) # nKS' 1st strip is always the current track, set with the Track < and > buttons. mixer.set_select_buttons(ButtonElement(1, MIDI_CC_TYPE, 0, 61), ButtonElement(1, MIDI_CC_TYPE, 0, 60)) mixer.selected_strip().set_mute_button( ButtonElement(1, MIDI_CC_TYPE, 0, 21)) mixer.selected_strip().set_solo_button( ButtonElement(1, MIDI_CC_TYPE, 0, 29)) mixer.selected_strip().set_arm_button( ButtonElement(1, MIDI_CC_TYPE, 0, 38)) mixer.selected_strip().set_shift_button( ButtonElement(1, MIDI_CC_TYPE, 0, 46)) mixer.selected_strip().set_pan_control( EncoderElement(MIDI_CC_TYPE, 0, 13, Live.MidiMap.MapMode.absolute)) mixer.selected_strip().set_volume_control( SliderElement(MIDI_CC_TYPE, 0, 2)) # nKS' 8th strip is always Master. Fader is volume and pot is cue level. mixer.master_strip().set_volume_control( SliderElement(MIDI_CC_TYPE, 0, 12)) mixer.set_prehear_volume_control( EncoderElement(MIDI_CC_TYPE, 0, 20, Live.MidiMap.MapMode.absolute) ) # Known as cue/preview in current versions of Live; controls e.g. metronome level in headphones # Scene 2 on the nKS should be factory defaults - ie same CCs as Scene 1 but on MIDI Channel 2 (1). This is set up like a conventional 8-track mix control surface. mixer.channel_strip(0).set_mute_button( ButtonElement(1, MIDI_CC_TYPE, 1, 21)) mixer.channel_strip(1).set_mute_button( ButtonElement(1, MIDI_CC_TYPE, 1, 22)) mixer.channel_strip(2).set_mute_button( ButtonElement(1, MIDI_CC_TYPE, 1, 23)) mixer.channel_strip(3).set_mute_button( ButtonElement(1, MIDI_CC_TYPE, 1, 24)) mixer.channel_strip(4).set_mute_button( ButtonElement(1, MIDI_CC_TYPE, 1, 25)) mixer.channel_strip(5).set_mute_button( ButtonElement(1, MIDI_CC_TYPE, 1, 26)) mixer.channel_strip(6).set_mute_button( ButtonElement(1, MIDI_CC_TYPE, 1, 27)) mixer.channel_strip(7).set_mute_button( ButtonElement(1, MIDI_CC_TYPE, 1, 28)) mixer.channel_strip(0).set_solo_button( ButtonElement(1, MIDI_CC_TYPE, 1, 29)) mixer.channel_strip(1).set_solo_button( ButtonElement(1, MIDI_CC_TYPE, 1, 30)) mixer.channel_strip(2).set_solo_button( ButtonElement(1, MIDI_CC_TYPE, 1, 31)) mixer.channel_strip(3).set_solo_button( ButtonElement(1, MIDI_CC_TYPE, 1, 33)) mixer.channel_strip(4).set_solo_button( ButtonElement(1, MIDI_CC_TYPE, 1, 34)) mixer.channel_strip(5).set_solo_button( ButtonElement(1, MIDI_CC_TYPE, 1, 35)) mixer.channel_strip(6).set_solo_button( ButtonElement(1, MIDI_CC_TYPE, 1, 36)) mixer.channel_strip(7).set_solo_button( ButtonElement(1, MIDI_CC_TYPE, 1, 37)) mixer.channel_strip(0).set_arm_button( ButtonElement(1, MIDI_CC_TYPE, 1, 38)) mixer.channel_strip(1).set_arm_button( ButtonElement(1, MIDI_CC_TYPE, 1, 39)) mixer.channel_strip(2).set_arm_button( ButtonElement(1, MIDI_CC_TYPE, 1, 40)) mixer.channel_strip(3).set_arm_button( ButtonElement(1, MIDI_CC_TYPE, 1, 41)) mixer.channel_strip(4).set_arm_button( ButtonElement(1, MIDI_CC_TYPE, 1, 42)) mixer.channel_strip(5).set_arm_button( ButtonElement(1, MIDI_CC_TYPE, 1, 43)) mixer.channel_strip(6).set_arm_button( ButtonElement(1, MIDI_CC_TYPE, 1, 44)) mixer.channel_strip(7).set_arm_button( ButtonElement(1, MIDI_CC_TYPE, 1, 45)) mixer.channel_strip(0).set_shift_button( ButtonElement(1, MIDI_CC_TYPE, 1, 46)) mixer.channel_strip(1).set_shift_button( ButtonElement(1, MIDI_CC_TYPE, 1, 47)) mixer.channel_strip(2).set_shift_button( ButtonElement(1, MIDI_CC_TYPE, 1, 48)) mixer.channel_strip(3).set_shift_button( ButtonElement(1, MIDI_CC_TYPE, 1, 49)) mixer.channel_strip(4).set_shift_button( ButtonElement(1, MIDI_CC_TYPE, 1, 50)) mixer.channel_strip(5).set_shift_button( ButtonElement(1, MIDI_CC_TYPE, 1, 51)) mixer.channel_strip(6).set_shift_button( ButtonElement(1, MIDI_CC_TYPE, 1, 52)) mixer.channel_strip(7).set_shift_button( ButtonElement(1, MIDI_CC_TYPE, 1, 53)) mixer.channel_strip(0).set_pan_control( EncoderElement(MIDI_CC_TYPE, 1, 13, Live.MidiMap.MapMode.absolute)) mixer.channel_strip(1).set_pan_control( EncoderElement(MIDI_CC_TYPE, 1, 14, Live.MidiMap.MapMode.absolute)) mixer.channel_strip(2).set_pan_control( EncoderElement(MIDI_CC_TYPE, 1, 15, Live.MidiMap.MapMode.absolute)) mixer.channel_strip(3).set_pan_control( EncoderElement(MIDI_CC_TYPE, 1, 16, Live.MidiMap.MapMode.absolute)) mixer.channel_strip(4).set_pan_control( EncoderElement(MIDI_CC_TYPE, 1, 17, Live.MidiMap.MapMode.absolute)) mixer.channel_strip(5).set_pan_control( EncoderElement(MIDI_CC_TYPE, 1, 18, Live.MidiMap.MapMode.absolute)) mixer.channel_strip(6).set_pan_control( EncoderElement(MIDI_CC_TYPE, 1, 19, Live.MidiMap.MapMode.absolute)) mixer.channel_strip(7).set_pan_control( EncoderElement(MIDI_CC_TYPE, 1, 20, Live.MidiMap.MapMode.absolute)) mixer.channel_strip(0).set_volume_control( SliderElement(MIDI_CC_TYPE, 1, 2)) mixer.channel_strip(1).set_volume_control( SliderElement(MIDI_CC_TYPE, 1, 3)) mixer.channel_strip(2).set_volume_control( SliderElement(MIDI_CC_TYPE, 1, 4)) mixer.channel_strip(3).set_volume_control( SliderElement(MIDI_CC_TYPE, 1, 5)) mixer.channel_strip(4).set_volume_control( SliderElement(MIDI_CC_TYPE, 1, 6)) mixer.channel_strip(5).set_volume_control( SliderElement(MIDI_CC_TYPE, 1, 8)) mixer.channel_strip(6).set_volume_control( SliderElement(MIDI_CC_TYPE, 1, 9)) mixer.channel_strip(7).set_volume_control( SliderElement(MIDI_CC_TYPE, 1, 12))
def _setup_controls(self): is_momentary = True self._fader = [None for index in range(8)] self._dial = [None for index in range(16)] self._button = [None for index in range(8)] self._menu = [None for index in range(6)] for index in range(8): self._fader[index] = OSCMonoEncoderElement( MIDI_CC_TYPE, CHANNEL, OHM_FADERS[index], Live.MidiMap.MapMode.absolute, 'Fader_' + str(index), index, self, osc='/Fader_' + str(index) + '/x', osc_parameter='/Strip' + str(index + 8) + '/set', osc_name='/Strip' + str(index) + '/set') for index in range(8): self._button[index] = OSCMonoButtonElement( is_momentary, MIDI_NOTE_TYPE, CHANNEL, OHM_BUTTONS[index], 'Button_' + str(index), self, osc='/Select_' + str(index) + '/value', osc_alt='/Select/set ' + str(index), osc_name='/Select/text ' + str(index)) for index in range(16): self._dial[index] = OSCMonoEncoderElement( MIDI_CC_TYPE, CHANNEL, OHM_DIALS[index], Live.MidiMap.MapMode.absolute, 'Dial_' + str(index), index + 8, self, osc='/Dial_' + str(index) + '/x', osc_parameter='/Dial' + str(index) + 'val/set', osc_name='/Dial' + str(index) + 'name/set') for index in range(6): self._menu[index] = OSCMonoButtonElement( is_momentary, MIDI_NOTE_TYPE, CHANNEL, OHM_MENU[index], 'Menu_' + str(index), self, osc='/Function_' + str(index) + '/value', osc_alt='/Function/set ' + str(index), osc_name='/Function/text ' + str(index)) self._crossfader = OSCMonoEncoderElement(MIDI_CC_TYPE, CHANNEL, CROSSFADER, Live.MidiMap.MapMode.absolute, "Crossfader", 24, self, osc='/XFader/x', osc_parameter='/XFader/none', osc_name=None) self._livid = OSCMonoButtonElement(is_momentary, MIDI_NOTE_TYPE, CHANNEL, LIVID, 'Livid_Button', self, osc='/Livid/x', osc_alt='/Livid/x', osc_name=None) self._shift_l = OSCMonoButtonElement(is_momentary, MIDI_NOTE_TYPE, CHANNEL, SHIFT_L, 'Shift_Button_Left', self, osc='/ShiftL/x', osc_alt='/ShiftL/x', osc_name=None) self._shift_r = OSCMonoButtonElement(is_momentary, MIDI_NOTE_TYPE, CHANNEL, SHIFT_R, 'Shift_Button_Right', self, osc='/ShiftR/x', osc_alt='/ShiftR/x', osc_name=None) self._matrix = ButtonMatrixElement() self._matrix.name = 'Matrix' self._monomod = ButtonMatrixElement() self._monomod.name = 'Monomod' self._grid = [None for index in range(8)] for column in range(8): self._grid[column] = [None for index in range(8)] for row in range(8): self._grid[column][row] = OSCMonoButtonElement( is_momentary, MIDI_NOTE_TYPE, CHANNEL, (column * 8) + row, 'Grid_' + str(column) + '_' + str(row), self, osc='/ClipGrid_' + str(column) + '_' + str(row) + '/value', osc_alt='/ClipGrid/set ' + str(column) + ' ' + str(row), osc_name='/ClipGrid/text ' + str(column) + ' ' + str(row)) for row in range(5): button_row = [] for column in range(7): button_row.append(self._grid[column][row]) self._matrix.add_row(tuple(button_row)) for row in range(8): button_row = [] for column in range(8): button_row.append(self._grid[column][row]) self._monomod.add_row(tuple(button_row)) self._dummy_button = ButtonElement(is_momentary, MIDI_NOTE_TYPE, 15, 125) self._dummy_button.name = 'Dummy1' self._dummy_button2 = ButtonElement(is_momentary, MIDI_NOTE_TYPE, 15, 126) self._dummy_button2.name = 'Dummy2' self._dummy_button3 = ButtonElement(is_momentary, MIDI_NOTE_TYPE, 15, 127) self._dummy_button2.name = 'Dummy3' self._monomod256 = ButtonMatrixElement() self._monomod256.name = 'Monomod256' self._square = [None for index in range(16)] for column in range(16): self._square[column] = [None for index in range(16)] for row in range(16): self._square[column][row] = OSCMonoButtonElement( is_momentary, MIDI_NOTE_TYPE, int(column / 8) + 1, row + ((column % 8) * 16), '256Grid_' + str(column) + '_' + str(row), self, osc='/Grid_' + str(column) + '_' + str(row) + '/value', osc_alt='/Grid/set ' + str(column) + ' ' + str(row), osc_name=None) #self._square[column][row] = FlashingButtonElement(is_momentary, 0, 15, -1, '256Grid_' + str(column) + '_' + str(row), '/1/p_grid/'+str(column)+'/'+str(row), '/1/c_grid/'+str(column)+'/'+str(row), self) for row in range(16): button_row = [] for column in range(16): button_row.append(self._square[column][row]) self._monomod256.add_row(tuple(button_row)) self._bank_buttons = ButtonMatrixElement() self._key_buttons = ButtonMatrixElement() self._bank_button = [None for index in range(2)] for index in range(2): self._bank_button[index] = OSCMonoButtonElement( is_momentary, MIDI_NOTE_TYPE, 15, index, '256Grid_Bank_' + str(index), self, osc='/Shift_' + str(index) + '/value', osc_alt='/Shift/set ' + str(index), osc_name=None) button_row = [] for index in range(2): button_row.append(self._bank_button[index]) self._bank_buttons.add_row(tuple(button_row)) button_row = [] self._key_button = [None for index in range(8)] for index in range(8): self._key_button[index] = OSCMonoButtonElement( is_momentary, MIDI_NOTE_TYPE, 15, index + 8, '256Grid_Key_' + str(index), self, osc='/Keys_' + str(index) + '/value', osc_alt='/Keys/set ' + str(index), osc_name=None) for index in range(8): button_row.append(self._key_button[index]) self._key_buttons.add_row(tuple(button_row))
def make_button(channel, identifier, *a, **k): return ButtonElement(True, MIDI_NOTE_TYPE, channel, identifier, *a, **k)
def _mode1(self): self.show_message("_mode1 is active") # mixer global mixer num_tracks = 32 num_returns = 7 self.mixer = MixerComponent(num_tracks, num_returns) self.mixer.set_track_offset(0) self.song().view.selected_track = self.mixer.channel_strip(0)._track # sends send0_controls = ( SliderElement(MIDI_CC_TYPE, 0, 32), SliderElement(MIDI_CC_TYPE, 0, 36), SliderElement(MIDI_CC_TYPE, 0, 40), None, None, None, None, None, ) self.mixer.channel_strip(0).set_send_controls(tuple(send0_controls)) self.mixer.channel_strip(0).set_volume_control( SliderElement(MIDI_CC_TYPE, 0, 44)) send1_controls = ( SliderElement(MIDI_CC_TYPE, 0, 33), SliderElement(MIDI_CC_TYPE, 0, 37), SliderElement(MIDI_CC_TYPE, 0, 41), None, None, None, None, None, ) self.mixer.channel_strip(1).set_send_controls(tuple(send1_controls)) self.mixer.channel_strip(1).set_volume_control( SliderElement(MIDI_CC_TYPE, 0, 45)) send2_controls = ( SliderElement(MIDI_CC_TYPE, 0, 34), SliderElement(MIDI_CC_TYPE, 0, 38), SliderElement(MIDI_CC_TYPE, 0, 42), None, None, None, None, None, ) self.mixer.channel_strip(2).set_send_controls(tuple(send2_controls)) self.mixer.channel_strip(2).set_volume_control( SliderElement(MIDI_CC_TYPE, 0, 46)) send3_controls = ( SliderElement(MIDI_CC_TYPE, 0, 35), SliderElement(MIDI_CC_TYPE, 0, 39), SliderElement(MIDI_CC_TYPE, 0, 43), None, None, None, None, None, ) self.mixer.channel_strip(3).set_send_controls(tuple(send3_controls)) self.mixer.channel_strip(3).set_volume_control( SliderElement(MIDI_CC_TYPE, 0, 47)) # session global _session num_tracks = 4 num_scenes = 3 session_buttons = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11] self._pads = [ ButtonElement(1, MIDI_CC_TYPE, 1, session_buttons[index]) for index in range(num_tracks * num_scenes) ] self._grid = ButtonMatrixElement(rows=[ self._pads[(index * num_tracks):(index * num_tracks) + num_tracks] for index in range(num_scenes) ]) self._session = SessionComponent(num_tracks, num_scenes) self._session.set_clip_launch_buttons(self._grid) self.set_highlighting_session_component(self._session) # session track stop stop_track_buttons = [12, 13, 14, 15] self._track_stop_buttons = [ ButtonElement(1, MIDI_CC_TYPE, 1, stop_track_buttons[index]) for index in range(num_tracks) ] self._session.set_stop_track_clip_buttons( tuple(self._track_stop_buttons)) # session navigation self.session_left = ButtonElement(1, MIDI_CC_TYPE, 3, 8) self._session.set_page_left_button(self.session_left) self.session_left.add_value_listener(self._reload_active_devices, identify_sender=False) self.session_right = ButtonElement(1, MIDI_CC_TYPE, 3, 11) self._session.set_page_right_button(self.session_right) self.session_right.add_value_listener(self._reload_active_devices, identify_sender=False) self.session_up = ButtonElement(1, MIDI_CC_TYPE, 3, 10) self._session.set_page_up_button(self.session_up) self.session_up.add_value_listener(self._reload_active_devices, identify_sender=False) self.session_down = ButtonElement(1, MIDI_CC_TYPE, 3, 13) self._session.set_page_down_button(self.session_down) self.session_down.add_value_listener(self._reload_active_devices, identify_sender=False) self._session._link() self._session.set_mixer(self.mixer) #self._session.set_mixer(self.mixer) self._mode1_devices() self.add_device_listeners() # button: next device self.next_device = ButtonElement(0, MIDI_CC_TYPE, 1, 25) self.next_device.add_value_listener(self._next_device_value, identify_sender=False) # button: prev device self.previous_device = ButtonElement(1, MIDI_CC_TYPE, 1, 24) self.previous_device.add_value_listener(self._prev_device_value, identify_sender=False) # transport global transport self.transport = TransportComponent() self.transport.name = 'Transport' loop_button = ButtonElement(1, MIDI_CC_TYPE, 1, 50) loop_button.name = 'loop_button' self.transport.set_loop_button(loop_button) stop_button = ButtonElement(1, MIDI_CC_TYPE, 1, 49) stop_button.name = 'stop_button' self.transport.set_stop_button(stop_button) play_button = ButtonElement(1, MIDI_CC_TYPE, 1, 48) play_button.name = 'play_button' self.transport.set_play_button(play_button) # button: track navigation right self.track_navigation_right = ButtonElement(1, MIDI_CC_TYPE, 3, 17) self.track_navigation_right.add_value_listener( self._track_navigation_right_track_nav, identify_sender=False) # button: track navigation left self.track_navigation_left = ButtonElement(1, MIDI_CC_TYPE, 3, 14) self.track_navigation_left.add_value_listener( self._track_navigation_left_track_nav, identify_sender=False)
def make_pedal_button(identifier, *a, **k): return ButtonElement(True, MIDI_CC_TYPE, 0, identifier, *a, **k)
def create_button(identifier, name): button = ButtonElement(IS_MOMENTARY, MIDI_CC_TYPE, GLOBAL_CHANNEL, identifier) button.name = name return button
def make_button(cc_no): is_momentary = True return ButtonElement(is_momentary, MIDI_CC_TYPE, GLOBAL_CHANNEL, cc_no)
def _setup_controls(self): self._track_left_button = ButtonElement(True, MIDI_CC_TYPE, CHANNEL, track_left_btn) self._track_right_button = ButtonElement(True, MIDI_CC_TYPE, CHANNEL, track_right_btn) self._cycle_button = ButtonElement(True, MIDI_CC_TYPE, CHANNEL, cycle_btn) self._cycle_button_active = False self._set_button = ButtonElement(True, MIDI_CC_TYPE, CHANNEL, set_btn) self._mrk_left_button = ButtonElement(True, MIDI_CC_TYPE, CHANNEL, mrk_left_btn) self._mrk_right_button = ButtonElement(True, MIDI_CC_TYPE, CHANNEL, mrk_right_btn) self._ff_button = ButtonElement(True, MIDI_CC_TYPE, CHANNEL, ff_btn) self._rwd_button = ButtonElement(True, MIDI_CC_TYPE, CHANNEL, rwd_btn) self._play_button = ButtonElement(True, MIDI_CC_TYPE, CHANNEL, play_btn) self._stop_button = ButtonElement(True, MIDI_CC_TYPE, CHANNEL, stop_btn) self._rec_button = ButtonElement(True, MIDI_CC_TYPE, CHANNEL, rec_btn) self._solo_buttons = [ButtonElement(True, MIDI_CC_TYPE, CHANNEL, track_solo_cc[index]) for index in range(num_tracks)] self._mute_buttons = [ButtonElement(True, MIDI_CC_TYPE, CHANNEL, track_mute_cc[index]) for index in range(num_tracks)] self._arm_buttons = [ButtonElement(True, MIDI_CC_TYPE, CHANNEL, track_arm_cc[index]) for index in range(num_tracks)] self._knobs = [SliderElement(MIDI_CC_TYPE, CHANNEL, mixer_knob_cc[index]) for index in range(num_tracks)] self._faders = [SliderElement(MIDI_CC_TYPE, CHANNEL, mixer_fader_cc[index]) for index in range(num_tracks)]
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 __init__(self, *a, **k): super(MPK261MX, self).__init__(*a, **k) self.show_message( "-----------------------= MPK261MX LOADING - maxcloutier13 says hi =----------------------------------------------------------" ) self.log_message( "-----------------------= MPK261MX LOADING - maxcloutier13 says hi =----------------------------------------------------------" ) with self.component_guard(): midimap = MidiMap() #Super crude manual init for the custom buttons and faders #Bank A - Channel 1 ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- self._Encoder0 = EncoderElement( MIDI_CC_TYPE, 1, 22, Live.MidiMap.MapMode.relative_two_compliment, name='Encoder0') self._Encoder1 = EncoderElement( MIDI_CC_TYPE, 1, 23, Live.MidiMap.MapMode.relative_two_compliment, name='Encoder1') self._Encoder2 = EncoderElement( MIDI_CC_TYPE, 1, 24, Live.MidiMap.MapMode.relative_two_compliment, name='Encoder2') self._Encoder3 = EncoderElement( MIDI_CC_TYPE, 1, 25, Live.MidiMap.MapMode.relative_two_compliment, name='Encoder3') self._Encoder4 = EncoderElement( MIDI_CC_TYPE, 1, 26, Live.MidiMap.MapMode.relative_two_compliment, name='Encoder4') self._Encoder5 = EncoderElement( MIDI_CC_TYPE, 1, 27, Live.MidiMap.MapMode.relative_two_compliment, name='Encoder5') self._Encoder6 = EncoderElement( MIDI_CC_TYPE, 1, 28, Live.MidiMap.MapMode.relative_two_compliment, name='Encoder6') self._Encoder7 = EncoderElement( MIDI_CC_TYPE, 1, 29, Live.MidiMap.MapMode.relative_two_compliment, name='Encoder7') self._ArmButton0 = ButtonElement(False, MIDI_CC_TYPE, 0, 32, name='ArmButton0') self._ArmButton1 = ButtonElement(False, MIDI_CC_TYPE, 0, 33, name='ArmButton1') self._ArmButton2 = ButtonElement(False, MIDI_CC_TYPE, 0, 34, name='ArmButton2') self._ArmButton3 = ButtonElement(False, MIDI_CC_TYPE, 0, 35, name='ArmButton3') self._ArmButton4 = ButtonElement(False, MIDI_CC_TYPE, 0, 36, name='ArmButton4') self._ArmButton5 = ButtonElement(False, MIDI_CC_TYPE, 0, 37, name='ArmButton5') self._ArmButton6 = ButtonElement(False, MIDI_CC_TYPE, 0, 38, name='ArmButton6') self._ArmButton7 = ButtonElement(False, MIDI_CC_TYPE, 0, 39, name='ArmButton7') self._VolumeSlider0 = SliderElement(MIDI_CC_TYPE, 0, 12, name='VolumeSlider0') self._VolumeSlider1 = SliderElement(MIDI_CC_TYPE, 0, 13, name='VolumeSlider1') self._VolumeSlider2 = SliderElement(MIDI_CC_TYPE, 0, 14, name='VolumeSlider2') self._VolumeSlider3 = SliderElement(MIDI_CC_TYPE, 0, 15, name='VolumeSlider3') self._VolumeSlider4 = SliderElement(MIDI_CC_TYPE, 0, 16, name='VolumeSlider4') self._VolumeSlider5 = SliderElement(MIDI_CC_TYPE, 0, 17, name='VolumeSlider5') self._VolumeSlider6 = SliderElement(MIDI_CC_TYPE, 0, 18, name='VolumeSlider6') self._VolumeSlider7 = SliderElement(MIDI_CC_TYPE, 0, 19, name='VolumeSlider7') #Bank B - Channel 2 ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- self._Encoder8 = EncoderElement( MIDI_CC_TYPE, 2, 22, Live.MidiMap.MapMode.relative_two_compliment, name='Encoder8') self._Encoder9 = EncoderElement( MIDI_CC_TYPE, 2, 23, Live.MidiMap.MapMode.relative_two_compliment, name='Encoder9') self._Encoder10 = EncoderElement( MIDI_CC_TYPE, 2, 24, Live.MidiMap.MapMode.relative_two_compliment, name='Encoder10') self._Encoder11 = EncoderElement( MIDI_CC_TYPE, 2, 25, Live.MidiMap.MapMode.relative_two_compliment, name='Encoder11') self._Encoder12 = EncoderElement( MIDI_CC_TYPE, 2, 26, Live.MidiMap.MapMode.relative_two_compliment, name='Encoder12') self._Encoder13 = EncoderElement( MIDI_CC_TYPE, 2, 27, Live.MidiMap.MapMode.relative_two_compliment, name='Encoder13') self._Encoder14 = EncoderElement( MIDI_CC_TYPE, 2, 28, Live.MidiMap.MapMode.relative_two_compliment, name='Encoder14') self._Encoder15 = EncoderElement( MIDI_CC_TYPE, 2, 29, Live.MidiMap.MapMode.relative_two_compliment, name='Encoder15') self._ArmButton8 = ButtonElement(False, MIDI_CC_TYPE, 1, 32, name='ArmButton8') self._ArmButton9 = ButtonElement(False, MIDI_CC_TYPE, 1, 33, name='ArmButton9') self._ArmButton10 = ButtonElement(False, MIDI_CC_TYPE, 1, 34, name='ArmButton10') self._ArmButton11 = ButtonElement(False, MIDI_CC_TYPE, 1, 35, name='ArmButton11') self._ArmButton12 = ButtonElement(False, MIDI_CC_TYPE, 1, 36, name='ArmButton12') self._ArmButton13 = ButtonElement(False, MIDI_CC_TYPE, 1, 37, name='ArmButton13') self._ArmButton14 = ButtonElement(False, MIDI_CC_TYPE, 1, 38, name='ArmButton14') self._ArmButton15 = ButtonElement(False, MIDI_CC_TYPE, 1, 39, name='ArmButton15') self._VolumeSlider8 = SliderElement(MIDI_CC_TYPE, 1, 12, name='VolumeSlider8') self._VolumeSlider9 = SliderElement(MIDI_CC_TYPE, 1, 13, name='VolumeSlider9') self._VolumeSlider10 = SliderElement(MIDI_CC_TYPE, 1, 14, name='VolumeSlider10') self._VolumeSlider11 = SliderElement(MIDI_CC_TYPE, 1, 15, name='VolumeSlider11') self._VolumeSlider12 = SliderElement(MIDI_CC_TYPE, 1, 16, name='VolumeSlider12') self._VolumeSlider13 = SliderElement(MIDI_CC_TYPE, 1, 17, name='VolumeSlider13') self._VolumeSlider14 = SliderElement(MIDI_CC_TYPE, 1, 18, name='VolumeSlider14') self._VolumeSlider15 = SliderElement(MIDI_CC_TYPE, 1, 19, name='VolumeSlider15') #Bank C - Channel 3 ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- self._Encoder16 = EncoderElement( MIDI_CC_TYPE, 3, 22, Live.MidiMap.MapMode.relative_two_compliment, name='Encoder16') self._Encoder17 = EncoderElement( MIDI_CC_TYPE, 3, 23, Live.MidiMap.MapMode.relative_two_compliment, name='Encoder17') self._Encoder18 = EncoderElement( MIDI_CC_TYPE, 3, 24, Live.MidiMap.MapMode.relative_two_compliment, name='Encoder18') self._Encoder19 = EncoderElement( MIDI_CC_TYPE, 3, 25, Live.MidiMap.MapMode.relative_two_compliment, name='Encoder19') self._Encoder20 = EncoderElement( MIDI_CC_TYPE, 3, 26, Live.MidiMap.MapMode.relative_two_compliment, name='Encoder20') self._Encoder21 = EncoderElement( MIDI_CC_TYPE, 3, 27, Live.MidiMap.MapMode.relative_two_compliment, name='Encoder21') self._Encoder22 = EncoderElement( MIDI_CC_TYPE, 3, 28, Live.MidiMap.MapMode.relative_two_compliment, name='Encoder22') self._Encoder23 = EncoderElement( MIDI_CC_TYPE, 3, 29, Live.MidiMap.MapMode.relative_two_compliment, name='Encoder23') self._ArmButton16 = ButtonElement(False, MIDI_CC_TYPE, 2, 32, name='ArmButton16') self._ArmButton17 = ButtonElement(False, MIDI_CC_TYPE, 2, 33, name='ArmButton17') self._ArmButton18 = ButtonElement(False, MIDI_CC_TYPE, 2, 34, name='ArmButton18') self._ArmButton19 = ButtonElement(False, MIDI_CC_TYPE, 2, 35, name='ArmButton19') self._ArmButton20 = ButtonElement(False, MIDI_CC_TYPE, 2, 36, name='ArmButton20') self._ArmButton21 = ButtonElement(False, MIDI_CC_TYPE, 2, 37, name='ArmButton21') self._ArmButton22 = ButtonElement(False, MIDI_CC_TYPE, 2, 38, name='ArmButton22') self._ArmButton23 = ButtonElement(False, MIDI_CC_TYPE, 2, 39, name='ArmButton23') self._VolumeSlider16 = SliderElement(MIDI_CC_TYPE, 2, 12, name='VolumeSlider16') self._VolumeSlider17 = SliderElement(MIDI_CC_TYPE, 2, 13, name='VolumeSlider17') self._VolumeSlider18 = SliderElement(MIDI_CC_TYPE, 2, 14, name='VolumeSlider18') self._VolumeSlider19 = SliderElement(MIDI_CC_TYPE, 2, 15, name='VolumeSlider19') self._VolumeSlider20 = SliderElement(MIDI_CC_TYPE, 2, 16, name='VolumeSlider20') self._VolumeSlider21 = SliderElement(MIDI_CC_TYPE, 2, 17, name='VolumeSlider21') self._VolumeSlider22 = SliderElement(MIDI_CC_TYPE, 2, 18, name='VolumeSlider22') self._VolumeSlider23 = SliderElement(MIDI_CC_TYPE, 2, 19, name='VolumeSlider23') #Drum rack ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- drum_rack = DrumRackComponent( name='Drum_Rack', is_enabled=False, layer=Layer(pads=midimap['Drum_Pads'])) drum_rack.set_enabled(True) #Transport ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- transport = TransportComponent(name='Transport', is_enabled=False, layer=Layer( play_button=midimap['Play'], record_button=midimap['Record'], stop_button=midimap['Stop'], loop_button=midimap['Loop'])) #, seek_forward_button=midimap['Forward'], seek_backward_button=midimap['Backward'] transport.set_enabled(True) #Make the Back/Fwd button just normal mapable CC senders self._BackButton = ButtonElement(False, MIDI_CC_TYPE, 0, 116, name='BackButton') self._FwdButton = ButtonElement(False, MIDI_CC_TYPE, 0, 115, name='FwdButton') #Device ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- self._device = DeviceComponent( name='Device', is_enabled=False, layer=Layer(parameter_controls=midimap['Encoders']), device_selection_follows_track_selection=True) self._device.set_enabled(True) self.set_device_component(self._device) #Mixer ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- mixer_size = 24 self._mixer = MixerComponent(mixer_size, name='Mixer', is_enabled=False) #Super crude and repetitive mapping because after all this shit I'm not spending time learning how to loop this crap hehe #Bank A self._mixer.channel_strip(0).layer = Layer( volume_control=self._VolumeSlider0, arm_button=self._ArmButton0, pan_control=self._Encoder0) self._mixer.channel_strip(1).layer = Layer( volume_control=self._VolumeSlider1, arm_button=self._ArmButton1, pan_control=self._Encoder1) self._mixer.channel_strip(2).layer = Layer( volume_control=self._VolumeSlider2, arm_button=self._ArmButton2, pan_control=self._Encoder2) self._mixer.channel_strip(3).layer = Layer( volume_control=self._VolumeSlider3, arm_button=self._ArmButton3, pan_control=self._Encoder3) self._mixer.channel_strip(4).layer = Layer( volume_control=self._VolumeSlider4, arm_button=self._ArmButton4, pan_control=self._Encoder4) self._mixer.channel_strip(5).layer = Layer( volume_control=self._VolumeSlider5, arm_button=self._ArmButton5, pan_control=self._Encoder5) self._mixer.channel_strip(6).layer = Layer( volume_control=self._VolumeSlider6, arm_button=self._ArmButton6, pan_control=self._Encoder6) self._mixer.channel_strip(7).layer = Layer( volume_control=self._VolumeSlider7, arm_button=self._ArmButton7, pan_control=self._Encoder7) #Bank B self._mixer.channel_strip(8).layer = Layer( volume_control=self._VolumeSlider8, arm_button=self._ArmButton8, pan_control=self._Encoder8) self._mixer.channel_strip(9).layer = Layer( volume_control=self._VolumeSlider9, arm_button=self._ArmButton9, pan_control=self._Encoder9) self._mixer.channel_strip(10).layer = Layer( volume_control=self._VolumeSlider10, arm_button=self._ArmButton10, pan_control=self._Encoder10) self._mixer.channel_strip(11).layer = Layer( volume_control=self._VolumeSlider11, arm_button=self._ArmButton11, pan_control=self._Encoder11) self._mixer.channel_strip(12).layer = Layer( volume_control=self._VolumeSlider12, arm_button=self._ArmButton12, pan_control=self._Encoder12) self._mixer.channel_strip(13).layer = Layer( volume_control=self._VolumeSlider13, arm_button=self._ArmButton13, pan_control=self._Encoder13) self._mixer.channel_strip(14).layer = Layer( volume_control=self._VolumeSlider14, arm_button=self._ArmButton14, pan_control=self._Encoder14) self._mixer.channel_strip(15).layer = Layer( volume_control=self._VolumeSlider15, arm_button=self._ArmButton15, pan_control=self._Encoder15) #Bank C self._mixer.channel_strip(16).layer = Layer( volume_control=self._VolumeSlider16, arm_button=self._ArmButton16, pan_control=self._Encoder16) self._mixer.channel_strip(17).layer = Layer( volume_control=self._VolumeSlider17, arm_button=self._ArmButton17, pan_control=self._Encoder17) self._mixer.channel_strip(18).layer = Layer( volume_control=self._VolumeSlider18, arm_button=self._ArmButton18, pan_control=self._Encoder18) self._mixer.channel_strip(19).layer = Layer( volume_control=self._VolumeSlider19, arm_button=self._ArmButton19, pan_control=self._Encoder19) self._mixer.channel_strip(20).layer = Layer( volume_control=self._VolumeSlider20, arm_button=self._ArmButton20, pan_control=self._Encoder20) self._mixer.channel_strip(21).layer = Layer( volume_control=self._VolumeSlider21, arm_button=self._ArmButton21, pan_control=self._Encoder21) self._mixer.channel_strip(22).layer = Layer( volume_control=self._VolumeSlider22, arm_button=self._ArmButton22, pan_control=self._Encoder22) self._mixer.channel_strip(23).layer = Layer( volume_control=self._VolumeSlider23, arm_button=self._ArmButton23, pan_control=self._Encoder23) self._mixer.set_enabled(True) #-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
def _create_controls(self): self._device_controls = ButtonMatrixElement(rows=[[ EncoderElement(MIDI_CC_TYPE, self.encoder_msg_channel, identifier, Live.MidiMap.MapMode.relative_smooth_two_compliment, name=u'Encoder_%d_%d' % (column_index, row_index)) for column_index, identifier in enumerate(row) ] for row_index, row in enumerate((self.encoder_msg_ids[:4], self.encoder_msg_ids[8:12]))]) self._horizontal_scroll_encoder = EncoderElement( MIDI_CC_TYPE, self.encoder_msg_channel, self.encoder_msg_ids[7], Live.MidiMap.MapMode.relative_smooth_two_compliment, name=u'Horizontal_Scroll_Encoder') self._vertical_scroll_encoder = EncoderElement( MIDI_CC_TYPE, self.encoder_msg_channel, self.encoder_msg_ids[15], Live.MidiMap.MapMode.relative_smooth_two_compliment, name=u'Vertical_Scroll_Encoder') self._volume_encoder = EncoderElement( MIDI_CC_TYPE, self.encoder_msg_channel, self.encoder_msg_ids[13], Live.MidiMap.MapMode.relative_smooth_two_compliment, name=u'Volume_Encoder') self._pan_encoder = EncoderElement( MIDI_CC_TYPE, self.encoder_msg_channel, self.encoder_msg_ids[12], Live.MidiMap.MapMode.relative_smooth_two_compliment, name=u'Pan_Encoder') self._send_a_encoder = EncoderElement( MIDI_CC_TYPE, self.encoder_msg_channel, self.encoder_msg_ids[4], Live.MidiMap.MapMode.relative_smooth_two_compliment, name=u'Send_A_Encoder') self._send_b_encoder = EncoderElement( MIDI_CC_TYPE, self.encoder_msg_channel, self.encoder_msg_ids[5], Live.MidiMap.MapMode.relative_smooth_two_compliment, name=u'Send_B_Encoder') self._send_encoders = ButtonMatrixElement( rows=[[self._send_a_encoder, self._send_b_encoder]]) self._return_a_encoder = EncoderElement( MIDI_CC_TYPE, self.encoder_msg_channel, self.encoder_msg_ids[6], Live.MidiMap.MapMode.relative_smooth_two_compliment, name=u'Return_A_Encoder') self._return_b_encoder = EncoderElement( MIDI_CC_TYPE, self.encoder_msg_channel, self.encoder_msg_ids[14], Live.MidiMap.MapMode.relative_smooth_two_compliment, name=u'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, self.pad_channel, col + 36 + 8 * row, name=u'Pad_%d_%d' % (col, row)) for col in range(8) ] for row in range(2)])
def _setup_mixer_control(self): is_momentary = True self._mixer = SpecialMixerComponent(self, 8) self._mixer.name = 'Mixer' self._mixer.master_strip().name = 'Master_Channel_Strip' master_select_button = ButtonElement(is_momentary, MIDI_NOTE_TYPE, 0, 80) master_select_button.name = 'Master_Select_Button' self._mixer.master_strip().set_select_button(master_select_button) self._mixer.selected_strip().name = 'Selected_Channel_Strip' select_buttons = [] arm_buttons = [] solo_buttons = [] mute_buttons = [] sliders = [] for track in range(8): strip = self._mixer.channel_strip(track) strip.name = 'Channel_Strip_' + str(track) solo_button = ButtonElement(is_momentary, MIDI_NOTE_TYPE, track, 49) solo_buttons.append(solo_button) mute_button = ButtonElement(is_momentary, MIDI_NOTE_TYPE, track, 50) mute_buttons.append(mute_button) solo_button.name = str(track) + '_Solo_Button' mute_button.name = str(track) + '_Mute_Button' strip.set_solo_button(solo_button) strip.set_mute_button(mute_button) strip.set_shift_button(self._shift_button) strip.set_invert_mute_feedback(True) select_buttons.append( ButtonElement(is_momentary, MIDI_NOTE_TYPE, track, 51)) select_buttons[-1].name = str(track) + '_Select_Button' arm_buttons.append( ButtonElement(is_momentary, MIDI_NOTE_TYPE, track, 48)) arm_buttons[-1].name = str(track) + '_Arm_Button' sliders.append(SliderElement(MIDI_CC_TYPE, track, 7)) sliders[-1].name = str(track) + '_Volume_Control' self._crossfader = SliderElement(MIDI_CC_TYPE, 0, 15) master_volume_control = SliderElement(MIDI_CC_TYPE, 0, 14) self._prehear_control = EncoderElement( MIDI_CC_TYPE, 0, 47, Live.MidiMap.MapMode.relative_two_compliment) self._crossfader.name = 'Crossfader' master_volume_control.name = 'Master_Volume_Control' self._prehear_control.name = 'Prehear_Volume_Control' self._mixer.set_shift_button(self._shift_button) self._mixer.set_crossfader_control(self._crossfader) self._mixer.set_prehear_volume_control(self._prehear_control) self._mixer.master_strip().set_volume_control(master_volume_control) self._slider_modes = SliderModesComponent(self._mixer, tuple(sliders)) self._slider_modes.name = 'Slider_Modes' matrix_modes = MatrixModesComponent(self._matrix, self._session, self._session_zoom, tuple(self._track_stop_buttons), self) matrix_modes.name = 'Matrix_Modes' self._sequencer = StepSequencerComponent( self, self._session, self._matrix, tuple(self._track_stop_buttons)) self._sequencer.set_bank_buttons(tuple(select_buttons)) self._sequencer.set_nav_buttons(self._up_button, self._down_button, self._left_button, self._right_button) self._sequencer.set_button_matrix(self._matrix) self._sequencer.set_follow_button(master_select_button) self._sequencer.set_velocity_buttons(tuple(arm_buttons)) self._sequencer.set_shift_button(self._shift_button) self._sequencer.set_lane_mute_buttons(tuple( self._scene_launch_buttons)) self._sequencer.set_loop_start_buttons(tuple(mute_buttons)) self._sequencer.set_loop_length_buttons(tuple(solo_buttons)) self._shift_modes = ShiftableSelectorComponent( self, tuple(select_buttons), master_select_button, tuple(self._track_stop_buttons), self._stop_all_button, tuple(mute_buttons), tuple(solo_buttons), tuple(arm_buttons), tuple(self._scene_launch_buttons), self._matrix, self._session, self._session_zoom, self._mixer, self._slider_modes, matrix_modes, self._sequencer) self._shift_modes.name = 'Shift_Modes' self._shift_modes.set_mode_toggle(self._shift_button)
def _setup_device_and_transport_control(self): is_momentary = True device_bank_buttons = [] device_param_controls = [] bank_button_labels = ('Clip_Track_Button', 'Device_On_Off_Button', 'Previous_Device_Button', 'Next_Device_Button', 'Detail_View_Button', 'Rec_Quantization_Button', 'Midi_Overdub_Button', 'Metronome_Button') for index in range(8): device_bank_buttons.append( ButtonElement(is_momentary, MIDI_NOTE_TYPE, 0, 58 + index)) device_bank_buttons[-1].name = bank_button_labels[index] ring_mode_button = ButtonElement(not is_momentary, MIDI_CC_TYPE, 0, 24 + index) ringed_encoder = RingedEncoderElement( MIDI_CC_TYPE, 0, 16 + index, Live.MidiMap.MapMode.absolute) ringed_encoder.set_ring_mode_button(ring_mode_button) ringed_encoder.name = 'Device_Control_' + str(index) ring_mode_button.name = ringed_encoder.name + '_Ring_Mode_Button' device_param_controls.append(ringed_encoder) device = ShiftableDeviceComponent() device.name = 'Device_Component' device.set_bank_buttons(tuple(device_bank_buttons)) device.set_shift_button(self._shift_button) device.set_parameter_controls(tuple(device_param_controls)) device.set_on_off_button(device_bank_buttons[1]) self.set_device_component(device) detail_view_toggler = DetailViewCntrlComponent() detail_view_toggler.name = 'Detail_View_Control' detail_view_toggler.set_shift_button(self._shift_button) detail_view_toggler.set_device_clip_toggle_button( device_bank_buttons[0]) detail_view_toggler.set_detail_toggle_button(device_bank_buttons[4]) detail_view_toggler.set_device_nav_buttons(device_bank_buttons[2], device_bank_buttons[3]) transport = ShiftableTransportComponent() transport.name = 'Transport' play_button = ButtonElement(is_momentary, MIDI_NOTE_TYPE, 0, 91) stop_button = ButtonElement(is_momentary, MIDI_NOTE_TYPE, 0, 92) record_button = ButtonElement(is_momentary, MIDI_NOTE_TYPE, 0, 93) nudge_up_button = ButtonElement(is_momentary, MIDI_NOTE_TYPE, 0, 100) nudge_down_button = ButtonElement(is_momentary, MIDI_NOTE_TYPE, 0, 101) tap_tempo_button = ButtonElement(is_momentary, MIDI_NOTE_TYPE, 0, 99) play_button.name = 'Play_Button' stop_button.name = 'Stop_Button' record_button.name = 'Record_Button' nudge_up_button.name = 'Nudge_Up_Button' nudge_down_button.name = 'Nudge_Down_Button' tap_tempo_button.name = 'Tap_Tempo_Button' transport.set_shift_button(self._shift_button) transport.set_play_button(play_button) transport.set_stop_button(stop_button) transport.set_record_button(record_button) transport.set_nudge_buttons(nudge_up_button, nudge_down_button) transport.set_tap_tempo_button(tap_tempo_button) transport.set_quant_toggle_button(device_bank_buttons[5]) transport.set_overdub_button(device_bank_buttons[6]) transport.set_metronome_button(device_bank_buttons[7]) bank_button_translator = ShiftTranslatorComponent() bank_button_translator.set_controls_to_translate( tuple(device_bank_buttons)) bank_button_translator.set_shift_button(self._shift_button)
def make_button(identifier, channel, name): return ButtonElement(True, MIDI_CC_TYPE, channel, identifier, name=name)
def make_button(identifier, msg_type=MIDI_NOTE_TYPE, is_momentary=True, skin=None, is_modifier=False, name=''): return ButtonElement(is_momentary, msg_type, STANDARD_CHANNEL, identifier, skin=skin, name=name, resource_type=PrioritizedResource if is_modifier else None)
def _create_controls(self): self._encoders = ButtonMatrixElement(rows=[[ EncoderElement(MIDI_CC_TYPE, 0, identifier, Live.MidiMap.MapMode.absolute, name=b'Encoder_%d' % index) for index, identifier in enumerate(ENCODER_IDS) ]]) self._master_encoder = EncoderElement(MIDI_CC_TYPE, 0, 10, Live.MidiMap.MapMode.absolute, name=b'Master_Encoder') self._sliders = ButtonMatrixElement(rows=[[ SliderElement( MIDI_CC_TYPE, 0, identifier, name=b'Slider_%d' % index) for index, identifier in enumerate(SLIDER_IDS) ]]) self._master_slider = SliderElement(MIDI_CC_TYPE, 0, 7, name=b'Master_Slider') self._play_button = ButtonElement(True, MIDI_CC_TYPE, 0, 26) self._stop_button = ButtonElement(True, MIDI_CC_TYPE, 0, 25) self._record_button = ButtonElement(True, MIDI_CC_TYPE, 0, 28) self._forward_button = ButtonElement(True, MIDI_CC_TYPE, 0, 24) self._backward_button = ButtonElement(True, MIDI_CC_TYPE, 0, 21) self._ff_button = ButtonElement(True, MIDI_CC_TYPE, 0, 23) self._rw_button = ButtonElement(True, MIDI_CC_TYPE, 0, 22) self._device_mode_button = ButtonElement(True, MIDI_CC_TYPE, 0, 80) self._pan_mode_button = ButtonElement(True, MIDI_CC_TYPE, 0, 81) self._send_a_mode_button = ButtonElement(True, MIDI_CC_TYPE, 0, 82) self._send_b_mode_button = ButtonElement(True, MIDI_CC_TYPE, 0, 83) self._pads = ButtonMatrixElement(rows=[[ ButtonElement(True, MIDI_NOTE_TYPE, 0, identifier) for identifier in row ] for row in PAD_ROWS])
def _create_controls(self): self._device_encoders = ButtonMatrixElement(rows=[[ EncoderElement(MIDI_CC_TYPE, 0, identifier, Live.MidiMap.MapMode.relative_smooth_two_compliment, name=b'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=b'Horizontal_Scroll_Encoder') self._vertical_scroll_encoder = EncoderElement( MIDI_CC_TYPE, 0, 72, Live.MidiMap.MapMode.relative_smooth_two_compliment, name=b'Vertical_Scroll_Encoder') self._volume_encoder = EncoderElement( MIDI_CC_TYPE, 0, 91, Live.MidiMap.MapMode.relative_smooth_two_compliment, name=b'Volume_Encoder') self._pan_encoder = EncoderElement( MIDI_CC_TYPE, 0, 17, Live.MidiMap.MapMode.relative_smooth_two_compliment, name=b'Pan_Encoder') self._send_a_encoder = EncoderElement( MIDI_CC_TYPE, 0, 77, Live.MidiMap.MapMode.relative_smooth_two_compliment, name=b'Send_A_Encoder') self._send_b_encoder = EncoderElement( MIDI_CC_TYPE, 0, 93, Live.MidiMap.MapMode.relative_smooth_two_compliment, name=b'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=b'Return_A_Encoder') self._return_b_encoder = EncoderElement( MIDI_CC_TYPE, 0, 79, Live.MidiMap.MapMode.relative_smooth_two_compliment, name=b'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=b'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=b'Stop_Button') self._play_button = ButtonElement(True, MIDI_CC_TYPE, 0, 2, name=b'Play_Button')
def make_ring_encoder(encoder_identifer, button_identifier, name=b'', *a, **k): button_name = b'%s_Ring_Mode_Button' % name button = ButtonElement(False, MIDI_CC_TYPE, 0, button_identifier, name=button_name) encoder = RingedEncoderElement(MIDI_CC_TYPE, 0, encoder_identifer, MapMode.absolute, name=name, *a, **k) encoder.set_ring_mode_button(button) return encoder