def __init__(self, *a, **k): super(MPK225, self).__init__(*a, **k) with self.component_guard(): midimap = MidiMap() drum_rack = DrumRackComponent(name="Drum_Rack", is_enabled=False, layer=Layer(pads=midimap["Drum_Pads"])) drum_rack.set_enabled(True) transport = TransportComponent( name="Transport", is_enabled=False, layer=Layer( play_button=midimap["Play"], record_button=midimap["Record"], stop_button=midimap["Stop"], seek_forward_button=midimap["Forward"], seek_backward_button=midimap["Backward"], loop_button=midimap["Loop"], ), ) transport.set_enabled(True) device = DeviceComponent( name="Device", is_enabled=False, layer=Layer(parameter_controls=midimap["Encoders"]) ) device.set_enabled(True) self.set_device_component(device) self._device_selection_follows_track_selection = True
def _setup_device(self): encoders = [make_encoder(21 + index, "Device_Control_%d" % index) for index in xrange(8)] self._encoders = tuple(encoders) device = DeviceComponent() device.name = "Device_Component" self.set_device_component(device) device.set_parameter_controls(self._encoders)
def update(self): if self.is_enabled(): if(not self._locked_to_device): if ((not self.application().view.is_view_visible('Detail')) or (not self.application().view.is_view_visible('Detail/DeviceChain'))): self.application().view.show_view('Detail') self.application().view.show_view('Detail/DeviceChain') #update bank buttons colors if self._device != None : if(self._prev_bank_button != None): self._prev_bank_button.set_on_off_values(AMBER_FULL,AMBER_THIRD) if(self._next_bank_button != None): self._next_bank_button.set_on_off_values(AMBER_FULL,AMBER_THIRD) else : self._prev_bank_button.set_on_off_values(LED_OFF,LED_OFF) self._next_bank_button.set_on_off_values(LED_OFF,LED_OFF) #update parent DeviceComponent.update(self) #reset sliders if no device if(self._device==None): for slider in self._sliders: slider.reset() #additional updates : self.update_track_buttons() self.update_device_buttons() self.update_lock_button() self.update_on_off_button() self.update_precision_button() self.update_remaining_buttons()
def set_device(self, device): if(device != self._device): if self._number_of_parameter_banks() <= self._bank_index: self._bank_index = 0 self._device = device self.set_device_view() LiveDeviceComponent.set_device(self, device)
def __init__(self, c_instance): ControlSurface.__init__(self, c_instance) with self.component_guard(): is_momentary = True self._suggested_input_port = 'Oxygen' self._suggested_output_port = 'Oxygen' self._has_slider_section = True self._device_selection_follows_track_selection = True self._shift_button = ButtonElement(is_momentary, MIDI_CC_TYPE, GLOBAL_CHANNEL, 57) self._shift_button.add_value_listener(self._shift_value) self._mixer = SpecialMixerComponent(NUM_TRACKS) self._mute_solo_buttons = [] self._track_up_button = ButtonElement(is_momentary, MIDI_CC_TYPE, GLOBAL_CHANNEL, 111) self._track_down_button = ButtonElement(is_momentary, MIDI_CC_TYPE, GLOBAL_CHANNEL, 110) self._master_slider = SliderElement(MIDI_CC_TYPE, GLOBAL_CHANNEL, 41) for index in range(NUM_TRACKS): self._mute_solo_buttons.append(ButtonElement(is_momentary, MIDI_CC_TYPE, GLOBAL_CHANNEL, 49 + index)) self._mixer.channel_strip(index).set_volume_control(SliderElement(MIDI_CC_TYPE, GLOBAL_CHANNEL, 33 + index)) self._shift_value(0) self._mixer.master_strip().set_volume_control(self._master_slider) self._mixer.selected_strip().set_volume_control(None) device = DeviceComponent() device.set_parameter_controls(tuple([ EncoderElement(MIDI_CC_TYPE, GLOBAL_CHANNEL, 17 + index, Live.MidiMap.MapMode.absolute) for index in range(8) ])) self.set_device_component(device) ffwd_button = ButtonElement(is_momentary, MIDI_CC_TYPE, GLOBAL_CHANNEL, 115) rwd_button = ButtonElement(is_momentary, MIDI_CC_TYPE, GLOBAL_CHANNEL, 114) loop_button = ButtonElement(is_momentary, MIDI_CC_TYPE, GLOBAL_CHANNEL, 113) transport = TransportComponent() transport.set_stop_button(ButtonElement(is_momentary, MIDI_CC_TYPE, GLOBAL_CHANNEL, 116)) transport.set_play_button(ButtonElement(is_momentary, MIDI_CC_TYPE, GLOBAL_CHANNEL, 117)) transport.set_record_button(ButtonElement(is_momentary, MIDI_CC_TYPE, GLOBAL_CHANNEL, 118)) session = SessionComponent(0, 0) transport_view_modes = TransportViewModeSelector(transport, session, ffwd_button, rwd_button, loop_button) return
def update(self): #self._cs.log_message('update, enabled: ' + str(self.is_enabled())) DeviceComponent.update(self) if (self._parameter_controls != None): self._assign_params() if self.is_enabled(): self._cs.request_rebuild_midi_map()
def set_device(self, device): DeviceComponent.set_device(self, device) if self.is_enabled() and SLExtraDevice._main_device != None and not self._locked_to_device: if (not SLExtraDevice._main_device._is_enabled) or (SLExtraDevice._main_device._locked_to_device): if self._update_callback != None: self._update_callback()
def disconnect(self): self._save_favorites() self._save_recent() self._autosave_mappings() #self._unregister_timer_callback(self._on_custom_timer) DeviceComponent.disconnect(self)
def disconnect(self): self._remove_parameter_listeners() self._on_device_name_changed() DeviceComponent.disconnect(self) self._serato_interface = None self._parameter_listeners = None return
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_transport_control(self): is_momentary = True # We'll only be using momentary buttons here transport = TransportComponent() #Instantiate a Transport Component """set up the buttons""" transport.set_play_button(ButtonElement(is_momentary, MIDI_NOTE_TYPE, CHANNEL, 69)) #ButtonElement(is_momentary, msg_type, channel, identifier) Note that the MIDI_NOTE_TYPE constant is defined in the InputControlElement module transport.set_stop_button(ButtonElement(is_momentary, MIDI_NOTE_TYPE, CHANNEL, 70)) #transport.set_record_button(ButtonElement(is_momentary, MIDI_NOTE_TYPE, CHANNEL, 66)) #transport.set_overdub_button(ButtonElement(is_momentary, MIDI_NOTE_TYPE, CHANNEL, 68)) #transport.set_nudge_buttons(ButtonElement(is_momentary, MIDI_NOTE_TYPE, CHANNEL, 80), ButtonElement(is_momentary, MIDI_NOTE_TYPE, CHANNEL, 73)) #(up_button, down_button) #transport.set_tap_tempo_button(ButtonElement(is_momentary, MIDI_NOTE_TYPE, CHANNEL, 80)) #transport.set_metronome_button(ButtonElement(is_momentary, MIDI_NOTE_TYPE, CHANNEL, 80)) #For some reason, in Ver 7.x.x this method's name has no trailing "e" , and must be called as "set_metronom_button()"... #transport.set_loop_button(ButtonElement(is_momentary, MIDI_NOTE_TYPE, CHANNEL, 82)) #transport.set_punch_buttons(ButtonElement(is_momentary, MIDI_NOTE_TYPE, CHANNEL, 85), ButtonElement(is_momentary, MIDI_NOTE_TYPE, CHANNEL, 87)) #(in_button, out_button) #transport.set_seek_buttons(ButtonElement(is_momentary, MIDI_NOTE_TYPE, CHANNEL, 90), ButtonElement(is_momentary, MIDI_NOTE_TYPE, CHANNEL, 92)) # (ffwd_button, rwd_button) #"""set up the sliders""" #transport.set_tempo_control(SliderElement(MIDI_CC_TYPE, CHANNEL, 26), SliderElement(MIDI_CC_TYPE, CHANNEL, 25)) #(control, fine_control) #transport.set_song_position_control(SliderElement(MIDI_CC_TYPE, CHANNEL, 24)) device_param_controls = [] effects_knob_cc = [17,16,9,8,19,18,11,10] device = DeviceComponent() for index in range(8): device_param_controls.append(EncoderElement(MIDI_CC_TYPE, 0, effects_knob_cc[index], Live.MidiMap.MapMode.absolute)) device.set_parameter_controls(tuple(device_param_controls)) self.set_device_component(device)
def set_device(self, device): DeviceComponent.set_device(self, device) if device is not None: if hasattr(device, 'chains'): LC2Sysex.log_message(str(len(device.chains))) if hasattr(device, 'drum_pads'): LC2Sysex.log_message(str(len(device.drum_pads))) LC2Sysex.log_message(str(len(device.drum_pads[0].chains))) cl = 0 par = False if self._device is not None: if hasattr(self._device, 'canonical_parent'): par = isinstance(self._device.canonical_parent, Live.Device.Device) or isinstance(self._device.canonical_parent, Live.Chain.Chain) else: par = False if hasattr(self._device, 'chains'): if len(self._device.chains) > 0: chains = [ i < len(self._device.chains) and (self._device.chains[i].name == '' and 'Chain ' + str(i + 1) or self._device.chains[i].name) or '' for i in range(8) ] cl = min(8, len(self._device.chains)) else: chains = [ '' for i in range(8) ] else: chains = [ '' for i in range(8) ] else: chains = [ '' for i in range(8) ] sysex = LC2Sysex('CHAIN_NAMES') sysex.byte(cl) sysex.byte(int(par)) for i in range(8): sysex.ascii(chains[i]) sysex.send() self._selected_chain_id = 0 self._send_chain_devices()
def _setup_device(self): encoders = [ make_encoder(21 + index, 'Device_Control_%d' % index) for index in xrange(8) ] self._encoders = tuple(encoders) device = DeviceComponent(device_selection_follows_track_selection=True) device.name = 'Device_Component' self.set_device_component(device) device.set_parameter_controls(self._encoders)
def __init__(self, *a, **k): DeviceComponent.__init__(self, *a, **k) self._chain_sliders = [] self._chain_buttons = [] self._sibling_devices = [] self._parent_component = None
def update(self): DeviceComponent.update(self) if self.is_enabled(): if self._on_off_parameter() != None and self._on_off_button != None: self._on_off_button.send_value(self._on_off_parameter().value > 0) if self._lock_button != None: self._lock_button.send_value(self.is_locked()) self._script.request_rebuild_midi_map()
def set_enabled(self,active): if active: self.force=True #disable matrix. for slider in self._sliders: slider.set_disabled(not active) #ping parent DeviceComponent.set_enabled(self,active)
def set_enabled(self, active): if active: self.force = True self.on_selected_track_changed() # disable matrix. for slider in self._sliders: slider.set_enabled(active) DeviceComponent.set_enabled(self, active)
def set_device(self, device): DeviceComponent.set_device(self, device) if self._device == None: for source in self._parameter_name_data_sources: source.set_display_string(' - ') for source in self._page_name_data_sources: source.set_display_string(' - ')
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) 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) if len(parameter_encoders) > 0: device.set_parameter_controls(tuple(parameter_encoders)) self.set_device_component(device) return
def update(self): DeviceComponent.update(self) if self.is_enabled(): if self._lock_button != None: if self._locked_to_device: self._lock_button.turn_on() else: self._lock_button.turn_off() self._on_on_off_changed()
def __init__(self): self._parameter_offset = 0 self._selected_param = 0 self._selected_parameter = None DeviceComponent.__init__(self) LC2ParameterElement.set_select_param(self.select_parameter) self._xys = [ LC2ParameterElement(MIDI_PB_TYPE, i, 0) for i in range(8) ] self._device_banks = {} self.song().view.add_selected_parameter_listener(self._on_selected_parameter_changed)
def __init__(self, matrix, side_buttons, top_buttons, control_surface): self._control_surface = control_surface self._skin = self._control_surface._skin self._matrix = matrix self._prev_track_button = None self._next_track_button = None self._prev_device_button = None self._next_device_button = None self._prev_bank_button = None self._next_bank_button = None self._precision_button = None self._precision_mode = False self._remaining_buttons = None self._device = None self._lock_button_slots = [None,None,None,None] self._lock_buttons = [None,None,None,None] self._locked_devices = [None,None,None,None] self._locked_device_index = None self._is_active = False self._force = True self._osd = None DeviceComponent.__init__(self) # Sliders self._sliders = [] self.set_enabled(False) for column in range(self._matrix.width()): slider = DeviceControllerStrip(tuple([self._matrix.get_button(column, (self._matrix.height() - 1 - row)) for row in range(self._matrix.height())]),self._control_surface, self) self._sliders.append(slider) self._sliders = tuple(self._sliders) self.set_parameter_controls(self._sliders) self._selected_track = None # device selection buttons self.set_prev_device_button(top_buttons[0]) self.set_next_device_button(top_buttons[1]) # track selection buttons self.set_prev_track_button(top_buttons[2]) self.set_next_track_button(top_buttons[3]) # on/off button self.set_on_off_button(side_buttons[0]) # bank nav buttons self.set_bank_nav_buttons(side_buttons[1], side_buttons[2]) self._prev_bank_button = side_buttons[1] self._next_bank_button = side_buttons[2] # precision self.set_precision_button(side_buttons[3]) # lock buttons self.set_lock_buttons([side_buttons[4],side_buttons[5],side_buttons[6],side_buttons[7]]) # selected device listener self.song().add_appointed_device_listener(self._on_device_changed)
def set_device(self, device): DeviceComponent.set_device(self, device) # Zero out controls whenever a device is disconnected if device is None: for c in (self._parameter_controls or []): if not c: continue c.force_next_send() c.send_value(0)
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 __init__(self): self._lock_button_pressed = False self._lock_button_pressed_time = 0 self._lock_button_blink = False self._was_locked = False self._update_callback = None self._device_string = '' DeviceComponent.__init__(self)
def __init__(self): DeviceComponent.__init__(self) self.device_listener = None self.device_parm_listener = None self._control_translation_selector = ChannelTranslationSelector(8) self.clear_mode = True self.touch_mode = False self.del_parm_map = {} self.del_clip_map = {} self.del_touch_buttons = []
def __init__(self): self._parameter_offset = 0 self._selected_param = 0 self._selected_parameter = None DeviceComponent.__init__(self) LC2ParameterElement.set_select_param(self.select_parameter) self._xys = [LC2ParameterElement(MIDI_PB_TYPE, i, 0) for i in range(8)] self._device_banks = {} self.song().view.add_selected_parameter_listener( self._on_selected_parameter_changed)
def update(self): DeviceComponent.update(self) if self.is_enabled(): if self._on_off_parameter( ) != None and self._on_off_button != None: self._on_off_button.send_value( self._on_off_parameter().value > 0) if self._lock_button != None: self._lock_button.send_value(self.is_locked()) self._script.request_rebuild_midi_map()
def _setup_device_control(self): self._device = DeviceComponent() self._device.name = 'Device_Component' self.set_device_component(self._device) self._device_navigator = DeviceNavigator(self._device, self._mixer, self) self._device_navigator.name = 'Device_Navigator' #self._device_selection_follows_track_selection = FOLLOW self._device.device_name_data_source().set_update_callback( self._on_device_name_changed)
def set_device(self, device): DeviceComponent.set_device(self, device) if self._device == None: for source in self._parameter_name_data_sources: source.set_display_string(' - ') for source in self._page_name_data_sources: source.set_display_string(' - ') return
def __init__(self,matrix,side_buttons,top_buttons,parent): self._parent=parent self._matrix=matrix self._prev_track_button=None self._next_track_button=None self._prev_device_button=None self._next_device_button=None self._prev_bank_button=None self._next_bank_button=None self._precision_button=None self._precision_mode=False self._remaining_buttons=None self._device= None self._is_active = False self._force=True self._osd = None DeviceComponent.__init__(self) #Sliders self._sliders = [] self.set_enabled(False) for column in range(self._matrix.width()): slider = PreciseButtonSliderElement(tuple([self._matrix.get_button(column, (self._matrix.height() - 1 - row)) for row in range(self._matrix.height()) ])) slider.set_parent(self) slider.set_mode(3) self._sliders.append(slider) self._sliders=tuple(self._sliders) self.set_parameter_controls(self._sliders) self._selected_track = None #device selection buttons self.set_prev_device_button(top_buttons[0]) self.set_next_device_button(top_buttons[1]) #track selection buttons self.set_prev_track_button(top_buttons[2]) self.set_next_track_button(top_buttons[3]) #on/off button self.set_on_off_button(side_buttons[0]) #lock button self.set_lock_button(side_buttons[1]) self.set_lock_callback(self._lock_callback_function) #bank nav buttons self.set_bank_nav_buttons(side_buttons[2],side_buttons[3]) self._prev_bank_button=side_buttons[2] self._next_bank_button=side_buttons[3] #precision self.set_precision_button(side_buttons[4]) #remaining buttons that need to be turned off ! self.set_remaining_buttons([side_buttons[5],side_buttons[6],side_buttons[7]]) #selected device listener self.song().add_appointed_device_listener(self._on_device_changed)
def __init__(self): DeviceComponent.__init__(self) self._parameter_value_data_source = DisplayDataSource() self._parameter_name_data_sources = [] self._page_name_data_sources = [] self._page_index = [0, 0, 0, 0] for new_index in range(8): self._parameter_name_data_sources.append(DisplayDataSource()) self._page_name_data_sources.append(DisplayDataSource()) self._parameter_name_data_sources[-1].set_display_string(' - ') self._page_name_data_sources[-1].set_display_string(' - ')
def __init__(self, parent, host, cs): DeviceComponent.__init__(self) self._type = None self._device_parent = None self._host = host self._parent = parent self._chain = 0 self._cs = cs self._device_chain = 0 self._params = [] self._cntrl_offset = 0
def __init__(self, *a, **k): super(MPK225, self).__init__(*a, **k) with self.component_guard(): midimap = MidiMap() drum_rack = DrumRackComponent(name='Drum_Rack', is_enabled=False, layer=Layer(pads=midimap['Drum_Pads'])) drum_rack.set_enabled(True) transport = TransportComponent(name='Transport', is_enabled=False, layer=Layer(play_button=midimap['Play'], record_button=midimap['Record'], stop_button=midimap['Stop'], seek_forward_button=midimap['Forward'], seek_backward_button=midimap['Backward'], loop_button=midimap['Loop'])) transport.set_enabled(True) device = DeviceComponent(name='Device', is_enabled=False, layer=Layer(parameter_controls=midimap['Encoders']), device_selection_follows_track_selection=True) device.set_enabled(True) self.set_device_component(device)
def __init__(self, parent): DeviceComponent.__init__(self) self._type = None self._device_parent = None self._parent = parent self._chain = 0 self._device_chain = 0 self._number_params = 0 self._params = [] self._custom_parameter = [] self._nodevice = NoDevice()
def _create_return_devices(self): self._device_returns = [] for track in self.song().return_tracks: device = DeviceComponent() try: device.set_device(track.devices[0]) except: self.log_message("no devices on return track") self._device_returns.append(device) if len(self._device_returns) == 2: break
def update(self): if self.is_enabled(): if self._number_of_parameter_banks() <= self._bank_index: self._bank_index = 0 if (not self._locked_to_device2): if (self._device != None): if ((not self.application().view.is_view_visible('Detail')) or (not self.application().view.is_view_visible( 'Detail/DeviceChain'))): self.application().view.show_view('Detail') self.application().view.show_view('Detail/DeviceChain') # update bank buttons colors if self._device != None: if self._prev_bank_button != None: self._prev_bank_button.set_on_off_values( "Device.Bank.On", "Device.Bank.Off") if self._next_bank_button != None: self._next_bank_button.set_on_off_values( "Device.Bank.On", "Device.Bank.Off") else: if self._prev_bank_button != None: self._prev_bank_button.set_on_off_values( "DefaultButton.Disabled", "DefaultButton.Disabled") if self._next_bank_button != None: self._next_bank_button.set_on_off_values( "DefaultButton.Disabled", "DefaultButton.Disabled") if self._matrix != None: for x in range(self._matrix.width()): for y in range(self._matrix.height()): self._matrix.get_button(x, y).set_enabled(True) if self._device == None and self._matrix != None: for x in range(self._matrix.width()): for y in range(self._matrix.height()): if self._force: self._matrix.get_button(x, y).set_on_off_values( "DefaulyButton.Disabled", "DefaultButton.Disabled") self._matrix.get_button(x, y).turn_off() # update parent LiveDeviceComponent.update(self) if self._sliders != None: for slider in self._sliders: slider.reset_if_no_parameter() # additional updates : self.update_track_buttons() self.update_device_buttons() self.update_lock_buttons() self.update_on_off_button() self.update_precision_button() self._update_OSD() self._force = False
class BeatStep(ArturiaControlSurface): def __init__(self, *a, **k): super(BeatStep, self).__init__(*a, **k) self._skin = Skin(Colors) with self.component_guard(): self._create_controls() self._create_device() self._create_session() self._create_mixer() self._create_transport() 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') def _create_device(self): self._device = DeviceComponent(name='Device', is_enabled=False, layer=Layer(parameter_controls=self._device_encoders)) self._device.set_enabled(True) self.set_device_component(self._device) self._device_selection_follows_track_selection = True def _create_session(self): self._session = SessionComponent(name='Session', is_enabled=False, num_tracks=self._pads.width(), num_scenes=self._pads.height(), enable_skinning=True, layer=Layer(clip_launch_buttons=self._pads, scene_select_control=self._vertical_scroll_encoder)) self._session.set_enabled(True) def _create_mixer(self): self._mixer = MixerComponent(name='Mixer', is_enabled=False, num_returns=2, layer=Layer(track_select_encoder=self._horizontal_scroll_encoder, selected_track_volume_control=self._volume_encoder, selected_track_pan_control=self._pan_encoder, selected_track_send_controls=self._send_encoders, return_volume_controls=self._return_encoders)) self._mixer.set_enabled(True) def _create_transport(self): self._transport = TransportComponent(name='Transport', is_enabled=False, layer=Layer(stop_button=self._stop_button, play_button=self._play_button)) self._transport.set_enabled(True) def _collect_setup_messages(self): for identifier, hardware_id in izip(ENCODER_MSG_IDS, HARDWARE_ENCODER_IDS): self._setup_hardware_encoder(hardware_id, identifier) self._setup_hardware_button(HARDWARE_STOP_BUTTON_ID, 1, msg_type='cc') self._setup_hardware_button(HARDWARE_PLAY_BUTTON_ID, 2, msg_type='cc') for hardware_id, identifier in izip(HARDWARE_PAD_IDS, chain(*PAD_MSG_IDS)): self._setup_hardware_button(hardware_id, identifier, PAD_CHANNEL, msg_type='note')
def __init__(self, c_instance): ControlSurface.__init__(self, c_instance) with self.component_guard(): is_momentary = True self._suggested_input_port = 'Oxygen' self._suggested_output_port = 'Oxygen' self._has_slider_section = True self._shift_button = ButtonElement(is_momentary, MIDI_CC_TYPE, GLOBAL_CHANNEL, 57) self._shift_button.add_value_listener(self._shift_value) self._mixer = SpecialMixerComponent(NUM_TRACKS) self._mute_solo_buttons = [] self._track_up_button = ButtonElement(is_momentary, MIDI_CC_TYPE, GLOBAL_CHANNEL, 111) self._track_down_button = ButtonElement(is_momentary, MIDI_CC_TYPE, GLOBAL_CHANNEL, 110) self._master_slider = SliderElement(MIDI_CC_TYPE, GLOBAL_CHANNEL, 41) for index in range(NUM_TRACKS): self._mute_solo_buttons.append( ButtonElement(is_momentary, MIDI_CC_TYPE, GLOBAL_CHANNEL, 49 + index)) self._mixer.channel_strip(index).set_volume_control( SliderElement(MIDI_CC_TYPE, GLOBAL_CHANNEL, 33 + index)) self._shift_value(0) self._mixer.master_strip().set_volume_control(self._master_slider) self._mixer.selected_strip().set_volume_control(None) device = DeviceComponent( device_selection_follows_track_selection=True) device.set_parameter_controls( tuple([ EncoderElement(MIDI_CC_TYPE, GLOBAL_CHANNEL, 17 + index, Live.MidiMap.MapMode.absolute) for index in range(8) ])) self.set_device_component(device) ffwd_button = ButtonElement(is_momentary, MIDI_CC_TYPE, GLOBAL_CHANNEL, 115) rwd_button = ButtonElement(is_momentary, MIDI_CC_TYPE, GLOBAL_CHANNEL, 114) loop_button = ButtonElement(is_momentary, MIDI_CC_TYPE, GLOBAL_CHANNEL, 113) transport = TransportComponent() transport.set_stop_button( ButtonElement(is_momentary, MIDI_CC_TYPE, GLOBAL_CHANNEL, 116)) transport.set_play_button( ButtonElement(is_momentary, MIDI_CC_TYPE, GLOBAL_CHANNEL, 117)) transport.set_record_button( ButtonElement(is_momentary, MIDI_CC_TYPE, GLOBAL_CHANNEL, 118)) session = SessionComponent(0, 0) transport_view_modes = TransportViewModeSelector( transport, session, ffwd_button, rwd_button, loop_button) return
def _setup_device_control(self): sliders = [] pressures = [92, 94, 98, 102, 106, 108] for index in range(6): sliders.append( SliderElement(MIDI_CC_TYPE, CHANNEL, pressures[index])) self._sliders = tuple(sliders) device = DeviceComponent() self.set_device_component(device) device.set_parameter_controls(self._sliders)
def update(self): DeviceComponent.update(self) if self.is_enabled(): if self._lock_button != None: if self._locked_to_device: self._lock_button.turn_on() else: self._lock_button.turn_off() if LC2Sysex.l9(): self._update_on_off_button() else: self._on_on_off_changed()
class BeatStep(ArturiaControlSurface): def __init__(self, *a, **k): super(BeatStep, self).__init__(*a, **k) self._skin = Skin(Colors) with self.component_guard(): self._create_controls() self._create_device() self._create_session() self._create_mixer() self._create_transport() 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') def _create_device(self): self._device = DeviceComponent(name='Device', is_enabled=False, layer=Layer(parameter_controls=self._device_encoders), device_selection_follows_track_selection=True) self._device.set_enabled(True) self.set_device_component(self._device) def _create_session(self): self._session = SessionComponent(name='Session', is_enabled=False, num_tracks=self._pads.width(), num_scenes=self._pads.height(), enable_skinning=True, layer=Layer(clip_launch_buttons=self._pads, scene_select_control=self._vertical_scroll_encoder)) self._session.set_enabled(True) def _create_mixer(self): self._mixer = MixerComponent(name='Mixer', is_enabled=False, num_returns=2, layer=Layer(track_select_encoder=self._horizontal_scroll_encoder, selected_track_volume_control=self._volume_encoder, selected_track_pan_control=self._pan_encoder, selected_track_send_controls=self._send_encoders, return_volume_controls=self._return_encoders)) self._mixer.set_enabled(True) def _create_transport(self): self._transport = TransportComponent(name='Transport', is_enabled=False, layer=Layer(stop_button=self._stop_button, play_button=self._play_button)) self._transport.set_enabled(True) def _collect_setup_messages(self): for identifier, hardware_id in izip(ENCODER_MSG_IDS, HARDWARE_ENCODER_IDS): self._setup_hardware_encoder(hardware_id, identifier) self._setup_hardware_button(HARDWARE_STOP_BUTTON_ID, 1, msg_type='cc') self._setup_hardware_button(HARDWARE_PLAY_BUTTON_ID, 2, msg_type='cc') for hardware_id, identifier in izip(HARDWARE_PAD_IDS, chain(*PAD_MSG_IDS)): self._setup_hardware_button(hardware_id, identifier, PAD_CHANNEL, msg_type='note')
def _on_device_name_changed(self): DeviceComponent._on_device_name_changed(self) name = 'Please select a device in Live' if self._device is not None: if self._device.canonical_parent.name: pre = self._device.canonical_parent.name else: pre = 'Chain' name = pre + ': ' + unicode(self._device.name) sysex = LC2Sysex('DEVICE_NAME') sysex.ascii(name) sysex.send()
def _init_device_component(self, device_controls, bank_controls, global_channel, macro_map_mode): is_momentary = True DeviceButton = partial(ButtonElement, is_momentary, MIDI_CC_TYPE) def make_bank_button(control, name, is_momentary=True): return DeviceButton(global_channel, bank_controls[control], name=name) if device_controls: device = DeviceComponent(device_selection_follows_track_selection=True, name='Device_Component') layer_specs = {} if bank_controls: if has_specification_for('NEXTBANK', bank_controls): layer_specs['bank_next_button'] = make_bank_button('NEXTBANK', 'Device_Next_Bank_Button') if has_specification_for('PREVBANK', bank_controls): layer_specs['bank_prev_button'] = make_bank_button('PREVBANK', 'Device_Previous_Bank_Button') if has_specification_for('TOGGLELOCK', bank_controls): layer_specs['lock_button'] = make_bank_button('TOGGLELOCK', 'Device_Lock_Button') bank_buttons_raw = [] for index in xrange(8): key = 'BANK' + str(index + 1) if key in bank_controls.keys(): control_info = bank_controls[key] channel = global_channel cc = control_info if isinstance(control_info, (tuple, list)): cc = control_info[0] if is_valid_midi_channel(control_info[1]): channel = control_info[1] if is_valid_midi_identifier(cc) and is_valid_midi_channel(channel): name = 'Device_Bank_' + str(index) + '_Button' bank_buttons_raw.append(DeviceButton(channel, cc, name=name)) if len(bank_buttons_raw) > 0: layer_specs['bank_buttons'] = ButtonMatrixElement(rows=[ bank_buttons_raw]) parameter_encoders_raw = [] for index, control_info in enumerate(device_controls): channel = global_channel cc = control_info if isinstance(control_info, (tuple, list)): cc = control_info[0] if is_valid_midi_channel(control_info[1]): channel = control_info[1] if is_valid_midi_identifier(cc) and is_valid_midi_channel(channel): name = 'Device_Parameter_%d_Control' % index parameter_encoders_raw.append(EncoderElement(MIDI_CC_TYPE, channel, cc, macro_map_mode, name=name)) if len(parameter_encoders_raw) > 0: layer_specs['parameter_controls'] = ButtonMatrixElement(rows=[ parameter_encoders_raw]) device.layer = Layer(**layer_specs) self.set_device_component(device)
def disconnect(self): if self._device_parent != None: if self._device_parent != None: if self._device_parent.canonical_parent.devices_has_listener(self._parent_device_changed): self._device_parent.canonical_parent.remove_devices_listener(self._parent_device_changed) if self._device != None: if self._device.canonical_parent != None: if self._device.canonical_parent.devices_has_listener(self._device_changed): self._device.canonical_parent.remove_devices_listener(self._device_changed) self._type = None self._device_parent = None self._device_chain = None DeviceComponent.disconnect(self)
def __init__(self, *a, **k): super(ChannelStripComponent, self).__init__(*a, **k) self._device_component = DeviceComponent() self._device_component._show_msg_callback = lambda message: None self._on_selected_track_changed.subject = self.song().view self._fold_task = self._tasks.add(Task.sequence(Task.wait(TRACK_FOLD_DELAY), Task.run(self._do_fold_track))).kill() #self._cue_volume_slot = self.register_disconnectable(ParameterSlot()) self._track_state = self.register_disconnectable(TrackArmState()) self._on_arm_state_changed.subject = self._track_state self._eq_gain_controls = None self._eq_device = None self._record_button_value = 0 self._arming_select_button = None
def _current_bank_details(): if not self.modhandler.active_mod() is None: if self.modhandler.active_mod() and self.modhandler.active_mod()._param_component._device_parent != None: bank_name = self.modhandler.active_mod()._param_component._bank_name bank = [param._parameter for param in self.modhandler.active_mod()._param_component._params] if self.modhandler._alt_value.subject and self.modhandler._alt_value.subject.is_pressed(): bank = bank[8:] #self.log_message('current mod bank details: ' + str(bank_name) + ' ' + str(bank)) return (bank_name, bank) else: return DeviceComponent._current_bank_details(device_component) else: return DeviceComponent._current_bank_details(device_component)
def disconnect(self): if self._display_device_button != None: if self._display_device_button.value_has_listener( self._display_device_value): self._display_device_button.remove_value_listener( self._display_device_value) if self._prev_button != None: if self._prev_button.value_has_listener(self._nav_value): self._prev_button.remove_value_listener(self._nav_value) if self._next_button != None: if self._next_button.value_has_listener(self._nav_value): self._next_button.remove_value_listener(self._nav_value) DeviceComponent.disconnect(self)
def __init__(self, *a, **k): super(MPK261Custom, self).__init__(*a, **k) with self.component_guard(): midimap = MidiMap() drum_rack = DrumRackComponent(name=u'Drum_Rack', is_enabled=False, layer=Layer(pads=midimap[u'Drum_Pads'])) drum_rack.set_enabled(True) transport = TransportComponent(name=u'Transport', is_enabled=False, layer=Layer( play_button=midimap[u'Play'], record_button=midimap[u'Record'], stop_button=midimap[u'Stop'], seek_forward_button=midimap[u'Forward'], seek_backward_button=midimap[u'Backward'], loop_button=midimap[u'Loop'], metronome_button=midimap[u'Metronome'], tap_tempo_button=midimap[u'TapTempoButton'], quant_toggle_button=midimap[u'RecQuantButton'], overdub_button=midimap[u'OverdubButton'] )) transport.set_enabled(True) mixer_size = len(midimap[u'Sliders']) # Custom changes: Adds the "mute" buttons. By default, mute = turns light on. # invert_mute_feedback flips it around so muting = turns light off. mixer = MixerComponent(mixer_size, name=u'Mixer', is_enabled=False, invert_mute_feedback=True, layer=Layer( volume_controls=midimap[u'Sliders'], pan_controls=midimap[u'Encoders'], arm_buttons=midimap[u'Arm_Buttons'], mute_buttons=midimap[u'Mute_Buttons'], )) mixer.set_enabled(True) # Adds the blue hand controls. device = DeviceComponent( name=u'Device', is_enabled=False, layer=Layer(parameter_controls=midimap[u'EncodersB1']), device_selection_follows_track_selection=True) device.set_enabled(True) self.set_device_component(device) session = SessionComponent( SESSION_WIDTH, SESSION_HEIGHT, auto_name=True, enable_skinning=True, is_enabled=False, layer=Layer( clip_launch_buttons=midimap[u'Drum_Pads_BankB'], stop_track_clip_buttons=midimap[u'Drum_Pads_BankC_BottomRow'], scene_launch_buttons=midimap[u'Drum_Pads_BankD_RightColumn'])) session.set_enabled(True) self.log_message(u' ***** MPK261 Custom script loaded ****')
def _create_device(self): self._device = DeviceComponent( name=b'Device', is_enabled=False, layer=Layer(parameter_controls=self._device_encoders), device_selection_follows_track_selection=True) self._device.set_enabled(True) self.set_device_component(self._device) self._device_navigation = DeviceNavigationComponent( name=b'Device_Navigation', is_enabled=False, layer=Layer(device_nav_left_button=self._device_left_button, device_nav_right_button=self._device_right_button)) self._device_navigation.set_enabled(True)
def pad_device_params(self): device_param_controls = [] for param in self.note_page_cc[:8]: self.rotary_encoder_potis[param] = EncoderElement( MIDI_CC_TYPE, 0, param, Live.MidiMap.MapMode.absolute) self.rotary_encoder_potis[param].release_parameter() self.rotary_encoder_potis[param].send_value(0, True) self.rotary_encoder_potis[param].clear_send_cache() device_param_controls.append(self.rotary_encoder_potis[param]) device = DeviceComponent() device.name = 'Device_Component pad' device.set_parameter_controls(tuple(device_param_controls)) self.set_device_component(device)
def __init__(self, parent): self._update_callback = None self._device_string = ' Browser ' self.__parent = parent self._mode_selector = None self._action_controls = None self._is_last_nav = False self._active_browser = None self._mapping = SLPadMapping(self) DeviceComponent.__init__(self) self._init_browser() #self._register_timer_callback(self._on_custom_timer) self._init_task = None self._init_done = False
def set_device(device): is_monodevice = False for client in self._client: if (device != None) and (client.device == device): is_monodevice = client if is_monodevice != False: #device = client._device_component._device #self.log_message('is monodevice' + str(device.name)) assert ((device == None) or isinstance(device, Live.Device.Device)) if ((not device_component._locked_to_device) and (device != device_component._device)): if (device_component._device != None): device_component._device.remove_name_listener( device_component._on_device_name_changed) device_component._device.remove_parameters_listener( device_component._on_parameters_changed) parameter = device_component._on_off_parameter() if (parameter != None): parameter.remove_value_listener( device_component._on_on_off_changed) if (device_component._parameter_controls != None): for control in device_component._parameter_controls: control.release_parameter() device_component._device = device if (device_component._device != None): device_component._bank_index = 0 device_component._device.add_name_listener( self._on_device_name_changed) device_component._device.add_parameters_listener( self._on_parameters_changed) parameter = device_component._on_off_parameter() if (parameter != None): parameter.add_value_listener( device_component._on_on_off_changed) for key in device_component._device_bank_registry.keys(): if (key == device_component._device): device_component._bank_index = device_component._device_bank_registry.get( key, 0) del device_component._device_bank_registry[key] break device_component._bank_name = '<No Bank>' #added device_component._bank_index = max( is_monodevice._cntrl_offset, device_component._bank_index) device_component._on_device_name_changed() device_component.update() else: DeviceComponent.set_device(device_component, device)
def disconnect(self): self._control_translation_selector.disconnect() self.device_listener = None self.device_parm_listener = None self.del_parm_map = None self.del_clip_map = None for touch_button in self.del_touch_buttons: touch_button.remove_value_listener(self._clear_param) if self.clear_mode and not self.touch_mode: for control in self._parameter_controls: self.touch_mode and control.remove_value_listener( self._clear_param) DeviceComponent.disconnect(self)