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 _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):
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 __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 _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 __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 _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
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
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 __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 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)
