def _setup_global_control(self): is_momentary = True self._global_bank_buttons = [] self._global_param_controls = [] for index in range(8): ring_button = ButtonElement(not is_momentary, MIDI_CC_TYPE, 0, 56 + index) ringed_encoder = RingedEncoderElement(MIDI_CC_TYPE, 0, 48 + index, Live.MidiMap.MapMode.absolute) ringed_encoder.name = 'Track_Control_' + str(index) ringed_encoder.set_feedback_delay(-1) ring_button.name = ringed_encoder.name + '_Ring_Mode_Button' ringed_encoder.set_ring_mode_button(ring_button) self._global_param_controls.append(ringed_encoder) self._global_bank_buttons = [] global_bank_labels = ('Pan_Button', 'Send_A_Button', 'Send_B_Button', 'Send_C_Button') for index in range(4): self._global_bank_buttons.append(ConfigurableButtonElement(is_momentary, MIDI_NOTE_TYPE, 0, 87 + index)) self._global_bank_buttons[-1].name = global_bank_labels[index] self._encoder_modes = EncModeSelectorComponent(self._mixer) self._encoder_modes.name = 'Track_Control_Modes' self._encoder_modes.set_controls(tuple(self._global_param_controls)) self._encoder_device_modes = EncoderDeviceComponent(self._mixer, self._device, self) self._encoder_device_modes.name = 'Alt_Device_Control_Modes' self._encoder_eq_modes = EncoderEQComponent(self._mixer, self) self._encoder_eq_modes.name = 'EQ_Control_Modes' global_translation_selector = ChannelTranslationSelector() global_translation_selector.name = 'Global_Translations' global_translation_selector.set_controls_to_translate(tuple(self._global_param_controls)) global_translation_selector.set_mode_buttons(tuple(self._global_bank_buttons)) encoder_user_modes = EncoderUserModesComponent(self, self._encoder_modes, tuple(self._global_param_controls), tuple(self._global_bank_buttons), self._mixer, self._device, self._encoder_device_modes, self._encoder_eq_modes) encoder_user_modes.name = 'Encoder_User_Modes' self._encoder_shift_modes = ShiftableEncoderSelectorComponent(self, tuple(self._global_bank_buttons), encoder_user_modes, self._encoder_modes, self._encoder_eq_modes, self._encoder_device_modes) self._encoder_shift_modes.name = 'Encoder_Shift_Modes' self._encoder_shift_modes.set_mode_toggle(self._shift_button)
def _setup_global_control(self): is_momentary = True global_bank_buttons = [] global_param_controls = [] for index in range(8): ring_button = ButtonElement(not is_momentary, MIDI_CC_TYPE, 0, 56 + index) ringed_encoder = RingedEncoderElement( MIDI_CC_TYPE, 0, 48 + index, Live.MidiMap.MapMode.absolute) ringed_encoder.name = 'Track_Control_' + str(index) ring_button.name = ringed_encoder.name + '_Ring_Mode_Button' ringed_encoder.set_ring_mode_button(ring_button) global_param_controls.append(ringed_encoder) global_bank_buttons = [] global_bank_labels = ('Pan_Button', 'Send_A_Button', 'Send_B_Button', 'Send_C_Button') for index in range(4): global_bank_buttons.append( ButtonElement(is_momentary, MIDI_NOTE_TYPE, 0, 87 + index)) global_bank_buttons[-1].name = global_bank_labels[index] encoder_modes = EncModeSelectorComponent(self._mixer) encoder_modes.name = 'Track_Control_Modes' encoder_modes.set_modes_buttons(global_bank_buttons) encoder_modes.set_controls(tuple(global_param_controls)) global_translation_selector = ChannelTranslationSelector() global_translation_selector.name = 'Global_Translations' global_translation_selector.set_controls_to_translate( tuple(global_param_controls)) global_translation_selector.set_mode_buttons( tuple(global_bank_buttons))
def _setup_global_control(self): is_momentary = True self._global_bank_buttons = [] self._global_param_controls = [] for index in range(8): ring_button = ButtonElement(not is_momentary, MIDI_CC_TYPE, 0, 56 + index) ringed_encoder = RingedEncoderElement(MIDI_CC_TYPE, 0, 48 + index, Live.MidiMap.MapMode.absolute) ringed_encoder.name = 'Track_Control_' + str(index) ringed_encoder.set_feedback_delay(-1) ring_button.name = ringed_encoder.name + '_Ring_Mode_Button' ringed_encoder.set_ring_mode_button(ring_button) self._global_param_controls.append(ringed_encoder) self._global_bank_buttons = [] global_bank_labels = ('Pan_Button', 'Send_A_Button', 'Send_B_Button', 'Send_C_Button') for index in range(4): self._global_bank_buttons.append(ConfigurableButtonElement(is_momentary, MIDI_NOTE_TYPE, 0, 87 + index))#(not is_momentary, MIDI_NOTE_TYPE, 0, 87 + index)) self._global_bank_buttons[-1].name = global_bank_labels[index] self._encoder_modes = EncoderMixerModeSelectorComponent(self._mixer) self._encoder_modes.name = 'Track_Control_Modes' #self._encoder_modes.set_modes_buttons(self._global_bank_buttons) # set in ShiftableEncoderSelectorComponent self._encoder_modes.set_controls(tuple(self._global_param_controls)) #self._encoder_device_modes = EncoderDeviceModeSelectorComponent(self._mixer, self._device) #new self._encoder_device_modes = EncoderDeviceComponent(self._mixer, self._device, self) self._encoder_device_modes.name = 'Alt_Device_Control_Modes' #new self._encoder_eq_modes = EncoderEQComponent(self._mixer, self)#EncoderEQModeSelectorComponent(self._mixer) #new self._encoder_eq_modes.name = 'EQ_Control_Modes' #new global_translation_selector = ChannelTranslationSelector() #translate track encoders to channels 1 through 4, based on button selection (pan = 1, send A = 2, send B = 3, send C = 4) global_translation_selector.name = 'Global_Translations' global_translation_selector.set_controls_to_translate(tuple(self._global_param_controls)) global_translation_selector.set_mode_buttons(tuple(self._global_bank_buttons)) encoder_user_modes = EncoderUserModesComponent(self, self._encoder_modes, tuple(self._global_param_controls), tuple(self._global_bank_buttons), self._mixer, self._device, self._encoder_device_modes, self._encoder_eq_modes) #self._mixer, tuple(sliders)) #added encoder_user_modes.name = 'Encoder_User_Modes' #added self._encoder_shift_modes = ShiftableEncoderSelectorComponent(self, tuple(self._global_bank_buttons), encoder_user_modes, self._encoder_modes, self._encoder_eq_modes, self._encoder_device_modes) #tuple(select_buttons), master_select_button, tuple(arm_buttons), self._matrix, self._session, self._session_zoom, self._mixer, slider_modes, matrix_modes) #, self._send_introduction_message) #also added self for _parent self._encoder_shift_modes.name = 'Encoder_Shift_Modes' self._encoder_shift_modes.set_mode_toggle(self._shift_button)
def _setup_global_control(self): is_momentary = True global_bank_buttons = [] global_param_controls = [] for index in range(8): ring_button = ButtonElement(not is_momentary, MIDI_CC_TYPE, 0, 56 + index) ringed_encoder = RingedEncoderElement(MIDI_CC_TYPE, 0, 48 + index, Live.MidiMap.MapMode.absolute) ringed_encoder.name = "Track_Control_" + str(index) ring_button.name = ringed_encoder.name + "_Ring_Mode_Button" ringed_encoder.set_ring_mode_button(ring_button) global_param_controls.append(ringed_encoder) global_bank_buttons = [] global_bank_labels = ("Pan_Button", "Send_A_Button", "Send_B_Button", "Send_C_Button") for index in range(4): global_bank_buttons.append(ButtonElement(is_momentary, MIDI_NOTE_TYPE, 0, 87 + index)) global_bank_buttons[-1].name = global_bank_labels[index] encoder_modes = EncModeSelectorComponent(self._mixer) encoder_modes.name = "Track_Control_Modes" encoder_modes.set_modes_buttons(global_bank_buttons) encoder_modes.set_controls(tuple(global_param_controls)) global_translation_selector = ChannelTranslationSelector() global_translation_selector.name = "Global_Translations" global_translation_selector.set_controls_to_translate(tuple(global_param_controls)) global_translation_selector.set_mode_buttons(tuple(global_bank_buttons))
def _setup_device_control(self): is_momentary = True device_bank_buttons = [] device_param_controls = [] for index in range(8): device_bank_buttons.append(ButtonElement(is_momentary, MIDI_NOTE_TYPE, 12, (70 + index))) device_param_controls.append(EncoderElement(MIDI_CC_TYPE, 12, (12 + index), Live.MidiMap.MapMode.absolute)) device = DeviceComponent() device.set_bank_buttons(tuple(device_bank_buttons)) device.set_parameter_controls(tuple(device_param_controls)) device_translation_selector = ChannelTranslationSelector() device_translation_selector.set_controls_to_translate(tuple(device_param_controls)) device_translation_selector.set_mode_buttons(tuple(device_bank_buttons)) self.set_device_component(device)
def _setup_device_control(self): is_momentary = True device_bank_buttons = [] device_param_controls = [] for index in range(8): device_bank_buttons.append(ButtonElement(is_momentary, MIDI_NOTE_TYPE, 12, 70 + index)) device_param_controls.append(EncoderElement(MIDI_CC_TYPE, 12, 12 + index, Live.MidiMap.MapMode.absolute)) device = DeviceComponent() device.set_bank_buttons(tuple(device_bank_buttons)) device.set_parameter_controls(tuple(device_param_controls)) device_translation_selector = ChannelTranslationSelector() device_translation_selector.set_controls_to_translate(tuple(device_param_controls)) device_translation_selector.set_mode_buttons(tuple(device_bank_buttons)) self.set_device_component(device)
def _setup_global_control(self): is_momentary = True self._global_bank_buttons = [] self._global_param_controls = [] for index in range(8): ring_button = ButtonElement(not is_momentary, MIDI_CC_TYPE, 0, 56 + index) ringed_encoder = RingedEncoderElement( MIDI_CC_TYPE, 0, 48 + index, Live.MidiMap.MapMode.absolute) ringed_encoder.name = 'Track_Control_' + str(index) ringed_encoder.set_feedback_delay(-1) ring_button.name = ringed_encoder.name + '_Ring_Mode_Button' ringed_encoder.set_ring_mode_button(ring_button) self._global_param_controls.append(ringed_encoder) self._global_bank_buttons = [] global_bank_labels = ('Pan_Button', 'Send_A_Button', 'Send_B_Button', 'Send_C_Button') for index in range(4): self._global_bank_buttons.append( ConfigurableButtonElement(is_momentary, MIDI_NOTE_TYPE, 0, 87 + index)) self._global_bank_buttons[-1].name = global_bank_labels[index] self._encoder_modes = EncModeSelectorComponent(self._mixer) self._encoder_modes.name = 'Track_Control_Modes' self._encoder_modes.set_controls(tuple(self._global_param_controls)) self._encoder_device_modes = EncoderDeviceComponent( self._mixer, self._device, self) self._encoder_device_modes.name = 'Alt_Device_Control_Modes' self._encoder_eq_modes = EncoderEQComponent(self._mixer, self) self._encoder_eq_modes.name = 'EQ_Control_Modes' global_translation_selector = ChannelTranslationSelector() global_translation_selector.name = 'Global_Translations' global_translation_selector.set_controls_to_translate( tuple(self._global_param_controls)) global_translation_selector.set_mode_buttons( tuple(self._global_bank_buttons)) encoder_user_modes = EncoderUserModesComponent( self, self._encoder_modes, tuple(self._global_param_controls), tuple(self._global_bank_buttons), self._mixer, self._device, self._encoder_device_modes, self._encoder_eq_modes) encoder_user_modes.name = 'Encoder_User_Modes' self._encoder_shift_modes = ShiftableEncoderSelectorComponent( self, tuple(self._global_bank_buttons), encoder_user_modes, self._encoder_modes, self._encoder_eq_modes, self._encoder_device_modes) self._encoder_shift_modes.name = 'Encoder_Shift_Modes' self._encoder_shift_modes.set_mode_toggle(self._shift_button)
class MaschineDeviceComponent(DeviceComponent): """ Class representing a device in Live """ def __init__(self, surface): DeviceComponent.__init__(self) self.surface = surface self.device_listener = None self.device_parm_listener = None self._control_translation_selector = ChannelTranslationSelector(8) def set_device(self, device): DeviceComponent.set_device(self, device) if self.device_listener != None: self.device_listener(device) def set_parameter_controls(self, controls): DeviceComponent.set_parameter_controls(self, controls) self._control_translation_selector.set_controls_to_translate(controls) self._control_translation_selector.set_mode(self._bank_index) def _on_parameters_changed(self): DeviceComponent._on_parameters_changed(self) if self.device_parm_listener != None: self.device_parm_listener() def set_device_changed_listener(self, listener): self.device_listener = listener def set_device_parm_listener(self, listener): self.device_parm_listener = listener def show_message(self, message): self.surface.show_message(message) def disconnect(self): DeviceComponent.disconnect(self) self._control_translation_selector.disconnect() self.surface = None self.device_listener = None self.device_parm_listener = None
class MaschineDeviceComponent(DeviceComponent): """ Class representing a device in Live """ 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 = [] return def _on_device_name_changed(self): if self._device != None: self.canonical_parent.send_to_display( 'Device: ' + self._device.name, 1) else: self.canonical_parent.send_to_display('<No Device>', 1) return def update(self): if self.is_enabled() and self._device != None: self._device_bank_registry.set_device_bank(self._device, self._bank_index) if self._parameter_controls != None: old_bank_name = self._bank_name self._assign_parameters() if self._bank_name != old_bank_name: self._show_msg_callback(self._device.name + ' Bank: ' + self._bank_name) self.canonical_parent.update_bank_display() if self._bank_up_button != None and self._bank_down_button != None: can_bank_up = self._bank_index == None or self._number_of_parameter_banks( ) > self._bank_index + 1 can_bank_down = self._bank_index == None or self._bank_index > 0 self._bank_up_button.set_light(can_bank_up) self._bank_down_button.set_light(can_bank_down) if self._bank_buttons != None: for index, button in enumerate(self._bank_buttons): button.set_light(index == self._bank_index) else: if self._lock_button != None: self._lock_button.turn_off() if self._bank_up_button != None: self._bank_up_button.turn_off() if self._bank_down_button != None: self._bank_down_button.turn_off() if self._bank_buttons != None: for button in self._bank_buttons: button.turn_off() if self._parameter_controls != None: self._release_parameters(self._parameter_controls) return def set_touch_mode(self, touchchannel): self.touch_mode = True nr_dev_ctrl = len(self._parameter_controls) for ctrl in self._parameter_controls: touch_button = ButtonElement(False, MIDI_CC_TYPE, touchchannel, ctrl.message_identifier()) self.del_touch_buttons.append(touch_button) touch_button.add_value_listener(self._clear_param, True) def enter_clear_mode(self): self.clear_mode = True self.del_parm_map = {} self.del_clip_map = {} for control in self._parameter_controls: key = control.message_identifier() self.del_parm_map[key] = control.mapped_parameter() self.touch_mode or control.add_value_listener( self._clear_param, True) self.touch_mode or self.set_enabled(False) def exit_clear_mode(self): self.clear_mode = False self.touch_mode or self.set_enabled(True) for control in self._parameter_controls: self.touch_mode or control.remove_value_listener(self._clear_param) def _get_track_of_device(self, obj): if obj != None: parent = obj.canonical_parent if isinstance(parent, Live.Track.Track): return parent return self._get_track_of_device(parent) return def _get_clip_of_device(self): track = self._get_track_of_device(self._device) if track: if track.can_be_armed: for clip_slot in track.clip_slots: if clip_slot.has_clip and clip_slot.is_playing: return clip_slot.clip return def _clear_param(self, value, control): key = control.message_identifier() if self._device and key in self.del_parm_map: prev_clip = key in self.del_clip_map and self.del_clip_map[ key] or None clip = self._get_clip_of_device() if clip and clip != prev_clip: clip.clear_envelope(self.del_parm_map[key]) self.del_clip_map[key] = clip return def set_device(self, device): DeviceComponent.set_device(self, device) if self.device_listener != None: self.device_listener(device) return def set_parameter_controls(self, controls): DeviceComponent.set_parameter_controls(self, controls) self._control_translation_selector.set_controls_to_translate(controls) self._control_translation_selector.set_mode(self._bank_index) def _on_parameters_changed(self): DeviceComponent._on_parameters_changed(self) if self.device_parm_listener != None: self.device_parm_listener() return def set_device_changed_listener(self, listener): self.device_listener = listener def set_device_parm_listener(self, listener): self.device_parm_listener = listener def show_message(self, message): self.canonical_parent.show_message(message) 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) return
class ShiftableDeviceComponent(DeviceComponent): ' DeviceComponent that only uses bank buttons if a shift button is pressed ' def __init__(self): DeviceComponent.__init__(self) self._shift_button = None self._shift_pressed = False self._control_translation_selector = ChannelTranslationSelector(8) def disconnect(self): DeviceComponent.disconnect(self) self._control_translation_selector.disconnect() if (self._shift_button != None): self._shift_button.remove_value_listener(self._shift_value) self._shift_button = None def set_parameter_controls(self, controls): DeviceComponent.set_parameter_controls(self, controls) self._control_translation_selector.set_controls_to_translate(controls) self._control_translation_selector.set_mode(self._bank_index) def set_device(self, device): DeviceComponent.set_device(self, device) self._control_translation_selector.set_mode(self._bank_index) def set_shift_button(self, button): assert ((button == None) or (isinstance(button, ButtonElement) and button.is_momentary())) if (self._shift_button != button): if (self._shift_button != None): self._shift_button.remove_value_listener(self._shift_value) self._shift_button = button if (self._shift_button != None): self._shift_button.add_value_listener(self._shift_value) self.update() def update(self): if (self._parameter_controls != None): for control in self._parameter_controls: control.release_parameter() if (self.is_enabled() and (self._device != None)): self._device_bank_registry[self._device] = self._bank_index if ((self._parameter_controls != None) and (self._bank_index < number_of_parameter_banks(self._device))): old_bank_name = self._bank_name self._assign_parameters() if (self._bank_name != old_bank_name): self._show_msg_callback( ((self._device.name + ' Bank: ') + self._bank_name)) if (not self._shift_pressed): self._on_on_off_changed() elif (self._bank_buttons != None): for index in range(len(self._bank_buttons)): if (index == self._bank_index): self._bank_buttons[index].turn_on() else: self._bank_buttons[index].turn_off() def _shift_value(self, value): assert (self._shift_button != None) assert (value in range(128)) self._shift_pressed = (value != 0) self.update() def _bank_value(self, value, sender): assert ((sender != None) and (sender in self._bank_buttons)) if (self._shift_pressed and self.is_enabled()): if ((value != 0) or (not sender.is_momentary())): self._bank_name = '' self._bank_index = list(self._bank_buttons).index(sender) self._control_translation_selector.set_mode(self._bank_index) self.update() def _on_off_value(self, value): if (not self._shift_pressed): DeviceComponent._on_off_value(self, value) def _on_on_off_changed(self): if (not self._shift_pressed): DeviceComponent._on_on_off_changed(self)
class ShiftableDeviceComponent(DeviceComponent): """ DeviceComponent that only uses bank buttons if a shift button is pressed """ def __init__(self): DeviceComponent.__init__(self) self._shift_button = None self._shift_pressed = False self._control_translation_selector = ChannelTranslationSelector(8) def disconnect(self): DeviceComponent.disconnect(self) self._control_translation_selector.disconnect() if self._shift_button != None: self._shift_button.remove_value_listener(self._shift_value) self._shift_button = None def set_parameter_controls(self, controls): DeviceComponent.set_parameter_controls(self, controls) self._control_translation_selector.set_controls_to_translate(controls) self._control_translation_selector.set_mode(self._bank_index) def set_device(self, device): DeviceComponent.set_device(self, device) self._control_translation_selector.set_mode(self._bank_index) def set_shift_button(self, button): if not (button == None or isinstance(button, ButtonElement) and button.is_momentary()): raise AssertionError if self._shift_button != button: if self._shift_button != None: self._shift_button.remove_value_listener(self._shift_value) self._shift_button = button self._shift_button != None and self._shift_button.add_value_listener(self._shift_value) self.update() def update(self): if self._parameter_controls != None: for control in self._parameter_controls: control.release_parameter() if self.is_enabled() and self._device != None: self._device_bank_registry.set_device_bank(self._device, self._bank_index) if self._parameter_controls != None: if self._bank_index < number_of_parameter_banks(self._device): old_bank_name = self._bank_name self._assign_parameters() if self._bank_name != old_bank_name: self._show_msg_callback(self._device.name + ' Bank: ' + self._bank_name) self._shift_pressed or self._on_on_off_changed() elif self._bank_buttons != None: for index in range(len(self._bank_buttons)): if index == self._bank_index: self._bank_buttons[index].turn_on() else: self._bank_buttons[index].turn_off() def _shift_value(self, value): raise self._shift_button != None or AssertionError raise value in range(128) or AssertionError self._shift_pressed = value != 0 self.update() def _bank_value(self, value, sender): if not (sender != None and sender in self._bank_buttons): raise AssertionError if self._shift_pressed and self.is_enabled(): self._bank_name = (value != 0 or not sender.is_momentary()) and '' self._bank_index = list(self._bank_buttons).index(sender) self._control_translation_selector.set_mode(self._bank_index) self.update() def _on_off_value(self, value): if not self._shift_pressed: DeviceComponent._on_off_value(self, value) def _on_on_off_changed(self): if not self._shift_pressed: DeviceComponent._on_device_on_off_changed(self)
class ShiftableDeviceComponent(DeviceComponent): ' DeviceComponent that only uses bank buttons if a shift button is pressed ' __module__ = __name__ def __init__(self): DeviceComponent.__init__(self) self._shift_button = None self._shift_pressed = False self._control_translation_selector = ChannelTranslationSelector(8) def disconnect(self): DeviceComponent.disconnect(self) self._control_translation_selector.disconnect() if (self._shift_button != None): self._shift_button.remove_value_listener(self._shift_value) self._shift_button = None def set_parameter_controls(self, controls): DeviceComponent.set_parameter_controls(self, controls) self._control_translation_selector.set_controls_to_translate(controls) self._control_translation_selector.set_mode(self._bank_index) def set_device(self, device): DeviceComponent.set_device(self, device) self._control_translation_selector.set_mode(self._bank_index) def set_shift_button(self, button): assert ((button == None) or (isinstance(button, ButtonElement) and button.is_momentary())) if (self._shift_button != button): if (self._shift_button != None): self._shift_button.remove_value_listener(self._shift_value) self._shift_button = button if (self._shift_button != None): self._shift_button.add_value_listener(self._shift_value) self.update() def update(self): if (self._parameter_controls != None): for control in self._parameter_controls: control.release_parameter() if (self.is_enabled() and (self._device != None)): self._device_bank_registry[self._device] = self._bank_index if ((self._parameter_controls != None) and (self._bank_index < number_of_parameter_banks(self._device))): old_bank_name = self._bank_name self._assign_parameters() if (self._bank_name != old_bank_name): self._show_msg_callback(((self._device.name + ' Bank: ') + self._bank_name)) if (not self._shift_pressed): self._on_on_off_changed() elif (self._bank_buttons != None): for index in range(len(self._bank_buttons)): if (index == self._bank_index): self._bank_buttons[index].turn_on() else: self._bank_buttons[index].turn_off() #self._rebuild_callback() def _shift_value(self, value): assert (self._shift_button != None) assert (value in range(128)) self._shift_pressed = (value != 0) self.update() def _bank_value(self, value, sender): assert ((sender != None) and (sender in self._bank_buttons)) if (self._shift_pressed and self.is_enabled()): if ((value != 0) or (not sender.is_momentary())): self._bank_name = '' self._bank_index = list(self._bank_buttons).index(sender) self._control_translation_selector.set_mode(self._bank_index) self.update() def _on_off_value(self, value): if not self._shift_pressed: DeviceComponent._on_off_value(self, value) def _on_on_off_changed(self): if not self._shift_pressed: DeviceComponent._on_on_off_changed(self) def _lock_value(self, value): #added if self._shift_pressed: DeviceComponent._lock_value(self, value)
class APC40(APC): __doc__ = " Script for Akai's APC40 Controller " def __init__(self, c_instance): APC.__init__(self, c_instance) self._device_selection_follows_track_selection = True 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' self.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(self.scene_launch_buttons)): self.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' self.stop_all_button = ButtonElement(is_momentary, MIDI_NOTE_TYPE, 0, 81) self.stop_all_button.name = 'Stop_All_Clips_Button' self._session.set_stop_all_clips_button(self.stop_all_button) self._session.set_stop_track_clip_buttons(tuple(track_stop_buttons)) self._session.set_stop_track_clip_value(2) ## Quirksmode self.newZoom_buttons = [] for scene_index in range(5): scene = self._session.scene(scene_index) scene.name = 'Scene_' + str(scene_index) button_row = [] scene.set_launch_button(self.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)) ## Quirksmode - This moves the zoomer to allow for scene launch customisation (Currently not working 100%) if(track_index == 4): self.newZoom_buttons.append(button) 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(3) 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(self.newZoom_buttons)) self._session_zoom.set_stopped_value(3) self._session_zoom.set_selected_value(5) return None #return session def _setup_mixer_control(self): is_momentary = True ## Quirksmode self.arm_buttons = [] self._mixer = SpecialMixerComponent(self, 8) #added self for parent self._mixer.name = 'Mixer' self._mixer.master_strip().name = 'Master_Channel_Strip' self._mixer.selected_strip().name = 'Selected_Channel_Strip' for track in range(8): self.strip = self._mixer.channel_strip(track) self.strip.name = 'Channel_Strip_' + str(track) volume_control = SliderElement(MIDI_CC_TYPE, track, 7) arm_button = ButtonElement(is_momentary, MIDI_NOTE_TYPE, track, 48) solo_button = ButtonElement(is_momentary, MIDI_NOTE_TYPE, track, 49) mute_button = ButtonElement(is_momentary, MIDI_NOTE_TYPE, track, 50) select_button = ButtonElement(is_momentary, MIDI_NOTE_TYPE, track, 51) volume_control.name = str(track) + '_Volume_Control' arm_button.name = str(track) + '_Arm_Button' solo_button.name = str(track) + '_Solo_Button' mute_button.name = str(track) + '_Mute_Button' select_button.name = str(track) + '_Select_Button' self.strip.set_volume_control(volume_control) ##Quirksmode self.arm_buttons.append(arm_button) self.strip.set_arm_button(arm_button) self.strip.set_solo_button(solo_button) self.strip.set_mute_button(mute_button) self.strip.set_select_button(select_button) self.strip.set_shift_button(self._shift_button) self.strip.set_invert_mute_feedback(True) crossfader = SliderElement(MIDI_CC_TYPE, 0, 15) master_volume_control = SliderElement(MIDI_CC_TYPE, 0, 14) master_select_button = ButtonElement(is_momentary, MIDI_NOTE_TYPE, 0, 80) ##self._prehear_control = EncoderElement(MIDI_CC_TYPE, 0, 47, Live.MidiMap.MapMode.relative_two_compliment) crossfader.name = 'Crossfader' master_volume_control.name = 'Master_Volume_Control' master_select_button.name = 'Master_Select_Button' ##self._prehear_control.name = 'Prehear_Volume_Control' self._mixer.set_crossfader_control(crossfader) ##self._mixer.set_prehear_volume_control(self._prehear_control) self._mixer.master_strip().set_volume_control(master_volume_control) self._mixer.master_strip().set_select_button(master_select_button) def _setup_custom_components(self): self._setup_device_and_transport_control() self._setup_global_control() self._setup_djModeToggle() def _setup_djModeToggle(self): self._newDjModeToggle_state = False ## How many tracks? self._trackTotal = len(self.song().tracks) ## Re-Assign Metronome to Dj Mode toggle self._newDjModeToggle_button = self.transport._metronome_button self.transport.set_metronome_button(None) self._newDjModeToggle_button.add_value_listener(self._toggleDjMode) ## Assign Cue Volume (Temporary hack until I get the correct Api Values) self.transport._tempo_encoder_control.connect_to(self.song().master_track.mixer_device.cue_volume) def _toggleDjMode(self, value): if value == 1: if(self._newDjModeToggle_state): self._newDjModeToggle_button.turn_off() self._newDjModeToggle_state = False self.show_message("########################################################################################## DJ MODE: OFF ##############################") self._disconnect_djMode() self.transport._cueLevelMode = 1 self.device_bank_buttons[4].turn_on() self.transport._tempo_encoder_control.connect_to(self.song().master_track.mixer_device.cue_volume) else: self._newDjModeToggle_button.turn_on() self._newDjModeToggle_state = True self.show_message("########################################################################################## DJ MODE: ON ##############################") self._setup_djMode() self.transport._cueLevelMode = 2 self.device_bank_buttons[4].turn_off() self.transport._tempo_encoder_control.release_parameter() def _setup_djMode(self): ## Assign imports self.sceneEffect = SceneEffectComponent(self) self.reset = ResetComponent(self) self.armmode = ArmToggleComponent(self) self.trackControl = TrackControlComponent(self) is_momentary = True ##### Scene Effect Component self.sceneEffect.set_shift_button(self._shift_button) for scene_index in range(5): self.sceneEffect.newScene_button = self._session.scene(scene_index)._launch_button self._session.scene(scene_index).set_launch_button(None) self.sceneEffect.newScene_button.add_value_listener(self.sceneEffect._device_toggle, True) self.sceneEffect._device_buttons.append(self.sceneEffect.newScene_button) # Re-assign the stop all clips button self.sceneEffect._newStopAll_button = self._session._stop_all_button self._session.set_stop_all_clips_button(None) self.sceneEffect._newStopAll_button.add_value_listener(self.sceneEffect._masterRepeat) ##### Reset Component self.reset.set_shift_button(self._shift_button) #Re-assign Play and Stop buttons to Reset Track and All self.reset.reset_button = self.transport._play_button self.transport.set_play_button(None) self.reset.reset_button.add_value_listener(self.reset.reset_track) self.reset.resetAll_button = self.transport._stop_button self.transport.set_stop_button(None) self.reset.resetAll_button.add_value_listener(self.reset.reset_all) ##### Arm Toggle Component self.armmode.set_shift_button(self._shift_button) # Re-Assign Clip/Track Button to Loop/Utility toggle self.armmode._newDetailView_button = self.detail_view_toggler._detail_toggle_button self.detail_view_toggler.set_detail_toggle_button(None) self.armmode._newDetailView_button.add_value_listener(self.armmode._toggleArmMode) # Re-assign Arm button functionality for track in range(8): self.armmode.newArm_button = self._mixer.channel_strip(track)._arm_button self._mixer.channel_strip(track).set_arm_button(None) self.armmode.newArm_button.add_value_listener(self.armmode._device_toggle, True) self.armmode._arm_buttons.append(self.armmode.newArm_button) ##### Re-assign Track Control Ringed Encoders self.trackControl._trackEncoders = [] for encoder_index in range(8): self.newTrackEncoder_encoder = self.global_param_controls[encoder_index] self.encoder_modes.set_controls(None) self.trackControl._trackEncoders.append(self.newTrackEncoder_encoder) self.get_current_track() if(self.song().view.selected_track != self.song().master_track): for device in self.song().tracks[self.current_track].devices: if device.name == "DJ EQ and FX": for parameter in range(8): self.trackControl._trackEncoders[parameter].connect_to(device.parameters[parameter+1]) def _disconnect_djMode(self): ##### Disconnect Scene Effect Component # Re-assign the Scene Start Buttons for scene_index in range(5): self.sceneEffect._device_buttons[scene_index].remove_value_listener(self.sceneEffect._device_toggle) self._session.scene(scene_index).set_launch_button(self.scene_launch_buttons[scene_index]) self.sceneEffect._device_buttons = [] # Re-assign the stop all clips button self.sceneEffect._newStopAll_button.remove_value_listener(self.sceneEffect._masterRepeat) self.sceneEffect._newStopAll_button = None self._session.set_stop_all_clips_button(self.stop_all_button) self.song().view.remove_selected_track_listener(self.sceneEffect.sceneLight) ##### Disconnect Reset Component # Re-assign the Play Button self.reset.reset_button.remove_value_listener(self.reset.reset_track) self.reset.reset_button = None self.transport.set_play_button(self.play_button) # Re-assign the Stop Button self.reset.resetAll_button.remove_value_listener(self.reset.reset_all) self.reset.resetAll_button = None self.transport.set_stop_button(self.stop_button) ##### Disconnect Arm Toggle Component for track in range(8): self.armmode._arm_buttons[track].remove_value_listener(self.armmode._device_toggle) self._mixer.channel_strip(track).set_arm_button(self.arm_buttons[track]) self.armmode._arm_buttons = [] self.armmode._newDetailView_button.remove_value_listener(self.armmode._toggleArmMode) self.armmode._newDetailView_button = None self.detail_view_toggler.set_detail_toggle_button(self.device_bank_buttons[4]) self.song().view.remove_selected_track_listener(self.armmode._armLightMode) ##### Disconnect Track Control Ringed Encoders self.trackControl._trackEncoders = [] self.song().view.remove_selected_track_listener(self.trackControl.get_current_track) ##### Link the cutoffs for the Scene Effect Parameters def _linkCutoff(self, value): for device in self.song().tracks[self.current_track].devices: if device.name == "Scene Launch Effects": device.parameters[1].value = value def _setup_device_and_transport_control(self): is_momentary = True self.device_bank_buttons = [] self.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): self.device_bank_buttons.append(ButtonElement(is_momentary, MIDI_NOTE_TYPE, 0, 58 + index)) self.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' ## Quirksmode ##### Link the cutoffs for the Scene Effect Parameters if (index == 0): ringed_encoder.add_value_listener(self._linkCutoff) self.device_param_controls.append(ringed_encoder) self.device = ShiftableDeviceComponent() self.device.name = 'Device_Component' self.device.set_bank_buttons(tuple(self.device_bank_buttons)) self.device.set_shift_button(self._shift_button) self.device.set_parameter_controls(tuple(self.device_param_controls)) self.device.set_on_off_button(self.device_bank_buttons[1]) self.set_device_component(self.device) self.detail_view_toggler = DetailViewCntrlComponent() self.detail_view_toggler.name = 'Detail_View_Control' self.detail_view_toggler.set_shift_button(self._shift_button) self.detail_view_toggler.set_device_clip_toggle_button(self.device_bank_buttons[0]) self.detail_view_toggler.set_detail_toggle_button(self.device_bank_buttons[4]) self.detail_view_toggler.set_device_nav_buttons(self.device_bank_buttons[2], self.device_bank_buttons[3]) self.transport = ShiftableTransportComponent(self) ## Quirksmode added self self.transport.name = 'Transport' self.play_button = ButtonElement(is_momentary, MIDI_NOTE_TYPE, 0, 91) self.play_button.name = 'Play_Button' self.stop_button = ButtonElement(is_momentary, MIDI_NOTE_TYPE, 0, 92) self.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) self.stop_button.name = 'Stop_Button' self.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' self.transport.set_shift_button(self._shift_button) self.transport.set_play_button(self.play_button) self.transport.set_stop_button(self.stop_button) self.transport.set_record_button(self.record_button) self.transport.set_nudge_buttons(nudge_up_button, nudge_down_button) self.transport.set_undo_button(nudge_down_button) #shifted nudge self.transport.set_redo_button(nudge_up_button) #shifted nudge self.transport.set_tap_tempo_button(tap_tempo_button) self.transport.set_quant_toggle_button(self.device_bank_buttons[5]) self.transport.set_overdub_button(self.device_bank_buttons[6]) self.transport.set_metronome_button(self.device_bank_buttons[7]) self._prehear_control = EncoderElement(MIDI_CC_TYPE, 0, 47, Live.MidiMap.MapMode.relative_two_compliment) self.transport.set_tempo_encoder(self._prehear_control) #shifted prehear bank_button_translator = ShiftTranslatorComponent() bank_button_translator.set_controls_to_translate(tuple(self.device_bank_buttons)) bank_button_translator.set_shift_button(self._shift_button) def _setup_global_control(self): is_momentary = True global_bank_buttons = [] self.global_param_controls = [] for index in range(8): ring_button = ButtonElement(not is_momentary, MIDI_CC_TYPE, 0, 56 + index) ringed_encoder = RingedEncoderElement(MIDI_CC_TYPE, 0, 48 + index, Live.MidiMap.MapMode.absolute) ringed_encoder.name = 'Track_Control_' + str(index) ring_button.name = ringed_encoder.name + '_Ring_Mode_Button' ringed_encoder.set_ring_mode_button(ring_button) self.global_param_controls.append(ringed_encoder) global_bank_buttons = [] global_bank_labels = ('Pan_Button', 'Send_A_Button', 'Send_B_Button', 'Send_C_Button') for index in range(4): global_bank_buttons.append(ButtonElement(not is_momentary, MIDI_NOTE_TYPE, 0, 87 + index)) global_bank_buttons[-1].name = global_bank_labels[index] self.encoder_modes = EncModeSelectorComponent(self._mixer) self.encoder_modes.name = 'Track_Control_Modes' self.encoder_modes.set_modes_buttons(global_bank_buttons) self.encoder_modes.set_controls(tuple(self.global_param_controls)) self.global_translation_selector = ChannelTranslationSelector() self.global_translation_selector.name = 'Global_Translations' self.global_translation_selector.set_controls_to_translate(tuple(self.global_param_controls)) self.global_translation_selector.set_mode_buttons(tuple(global_bank_buttons)) def _on_selected_track_changed(self): ControlSurface._on_selected_track_changed(self) ## Quirksmode if(self._newDjModeToggle_state): if self.application().view.is_view_visible('Detail/Clip'): self.application().view.show_view('Detail/DeviceChain') self.application().view.is_view_visible('Detail/DeviceChain') else: self.application().view.show_view('Detail/Clip') self.application().view.is_view_visible('Detail/Clip') if(self.song().view.selected_track != self.song().master_track): if (self.song().view.selected_track.playing_slot_index > -1): self.song().view.selected_scene = self.song().scenes[self.song().view.selected_track.playing_slot_index] track_index = 0 for track in self.song().tracks: if track == self.song().view.selected_track: break track_index += 1 self.current_track = track_index track = self.song().view.selected_track device_to_select = track.view.selected_device if device_to_select == None and len(track.devices) > 0: device_to_select = track.devices[0] if device_to_select != None: self.song().view.select_device(device_to_select) self._device_component.set_device(device_to_select) return None ######################### Utils # Get the current track def get_current_track(self): track_index = 0 for track in self.song().tracks: if track == self.song().view.selected_track: break track_index += 1 self.current_track = track_index # Get the device on the given track by the given name. def GetDeviceByName(self, trackIndex, deviceName): for device in self.song().tracks[trackIndex].devices: if (device.name == deviceName): return device return None # Get the value of the given device in the given track by the given parameter name. def GetDeviceParameter(self, device, paramName): for deviceParam in device.parameters: if (deviceParam.name == paramName): return deviceParam.value return None # Set the given parameter name of the given device to the given value. def SetDeviceParameter(self, device, paramName, value): for deviceParam in device.parameters: if (deviceParam.name == paramName): deviceParam.value = value pass # Toggles the given param of the given device. Usefull for on/off effects, etc. def ToggleDeviceParameter(self, device, paramName): for deviceParam in device.parameters: if (deviceParam.name == paramName): if (deviceParam.value == 1): deviceParam.value = 0 else: deviceParam.value = 1 pass # Returns if the given track has a triggered clip. def TrackHasTriggeredClip(self, track): for clipSlot in track.clip_slots: if (clipSlot.has_clip): if (clipSlot.clip.is_triggered): return True return False # Returns if the given track has a playing clip. def TrackHasPlayingClip(self, track): for clipSlot in track.clip_slots: if (clipSlot.has_clip): if (clipSlot.clip.is_playing): return True return False def _product_model_id_byte(self): return 115
class MaschineDeviceComponent(DeviceComponent): """ Class representing a device in Live """ 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 _on_device_name_changed(self): if self._device != None: self.canonical_parent.send_to_display('Device: ' + self._device.name, 1) else: self.canonical_parent.send_to_display('<No Device>', 1) def update(self): if self.is_enabled() and self._device != None: self._device_bank_registry.set_device_bank(self._device, self._bank_index) if self._parameter_controls != None: old_bank_name = self._bank_name self._assign_parameters() if self._bank_name != old_bank_name: self._show_msg_callback(self._device.name + ' Bank: ' + self._bank_name) self.canonical_parent.update_bank_display() if self._bank_up_button != None and self._bank_down_button != None: can_bank_up = self._bank_index == None or self._number_of_parameter_banks() > self._bank_index + 1 can_bank_down = self._bank_index == None or self._bank_index > 0 self._bank_up_button.set_light(can_bank_up) self._bank_down_button.set_light(can_bank_down) if self._bank_buttons != None: for index, button in enumerate(self._bank_buttons): button.set_light(index == self._bank_index) else: if self._lock_button != None: self._lock_button.turn_off() if self._bank_up_button != None: self._bank_up_button.turn_off() if self._bank_down_button != None: self._bank_down_button.turn_off() if self._bank_buttons != None: for button in self._bank_buttons: button.turn_off() if self._parameter_controls != None: self._release_parameters(self._parameter_controls) def set_touch_mode(self, touchchannel): self.touch_mode = True nr_dev_ctrl = len(self._parameter_controls) for ctrl in self._parameter_controls: touch_button = ButtonElement(False, MIDI_CC_TYPE, touchchannel, ctrl.message_identifier()) self.del_touch_buttons.append(touch_button) touch_button.add_value_listener(self._clear_param, True) def enter_clear_mode(self): self.clear_mode = True self.del_parm_map = {} self.del_clip_map = {} for control in self._parameter_controls: key = control.message_identifier() self.del_parm_map[key] = control.mapped_parameter() self.touch_mode or control.add_value_listener(self._clear_param, True) self.touch_mode or self.set_enabled(False) def exit_clear_mode(self): self.clear_mode = False self.touch_mode or self.set_enabled(True) for control in self._parameter_controls: self.touch_mode or control.remove_value_listener(self._clear_param) def _get_track_of_device(self, obj): if obj != None: parent = obj.canonical_parent if isinstance(parent, Live.Track.Track): return parent else: return self._get_track_of_device(parent) def _get_clip_of_device(self): track = self._get_track_of_device(self._device) if track: if track.can_be_armed: for clip_slot in track.clip_slots: if clip_slot.has_clip and clip_slot.is_playing: return clip_slot.clip def _clear_param(self, value, control): key = control.message_identifier() if self._device and key in self.del_parm_map: if not (key in self.del_clip_map and self.del_clip_map[key]): prev_clip = None clip = self._get_clip_of_device() clip and clip != prev_clip and clip.clear_envelope(self.del_parm_map[key]) self.del_clip_map[key] = clip def set_device(self, device): DeviceComponent.set_device(self, device) if self.device_listener != None: self.device_listener(device) def set_parameter_controls(self, controls): DeviceComponent.set_parameter_controls(self, controls) self._control_translation_selector.set_controls_to_translate(controls) self._control_translation_selector.set_mode(self._bank_index) def _on_parameters_changed(self): DeviceComponent._on_parameters_changed(self) if self.device_parm_listener != None: self.device_parm_listener() def set_device_changed_listener(self, listener): self.device_listener = listener def set_device_parm_listener(self, listener): self.device_parm_listener = listener def show_message(self, message): self.canonical_parent.show_message(message) 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)