def _setup_device(self):
encoders = []
for index in range(8):
encoders.append(
PeekableEncoderElement(
MIDI_CC_TYPE, 1, index,
Live.MidiMap.MapMode.relative_binary_offset))
encoders[(-1)].set_feedback_delay(-1)
encoders[(-1)].add_value_listener((self._encoder_value),
identify_sender=True)
encoders[(-1)].name = 'Device_Control_' + str(index)
self._encoders = tuple(encoders)
self._prev_bank_button = ButtonElement(IS_MOMENTARY, MIDI_CC_TYPE, 1,
12)
self._next_bank_button = ButtonElement(IS_MOMENTARY, MIDI_CC_TYPE, 1,
11)
self._prev_bank_button.name = 'Device_Bank_Down_Button'
self._next_bank_button.name = 'Device_Bank_Up_Button'
device = DeviceComponent(device_selection_follows_track_selection=True)
device.name = 'Device_Component'
self.set_device_component(device)
device.set_parameter_controls(self._encoders)
device.set_bank_nav_buttons(self._prev_bank_button,
self._next_bank_button)
def _setup_mixer_control(self):
is_momentary = True
mixer = MixerComponent(NUM_TRACKS, 2)
for track in range(NUM_TRACKS):
strip = mixer.channel_strip(track)
strip.set_volume_control(SliderElement(MIDI_CC_TYPE, track, 23))
strip.set_pan_control(
EncoderElement(MIDI_CC_TYPE, track, 10,
Live.MidiMap.MapMode.absolute))
strip.set_send_controls(
(EncoderElement(MIDI_CC_TYPE, track, 19,
Live.MidiMap.MapMode.absolute),
EncoderElement(MIDI_CC_TYPE, track, 20,
Live.MidiMap.MapMode.absolute)))
strip.set_solo_button(
ButtonElement(is_momentary, MIDI_NOTE_TYPE, track, 64))
strip.set_mute_button(
ButtonElement(is_momentary, MIDI_NOTE_TYPE, track, 63))
strip.set_crossfade_toggle(
ButtonElement(is_momentary, MIDI_NOTE_TYPE, track, 65))
eq = mixer.track_eq(track)
eq.set_gain_controls(
tuple([
EncoderElement(MIDI_CC_TYPE, track, 18 - index,
Live.MidiMap.MapMode.absolute)
for index in range(3)
]))
eq.set_cut_buttons(
tuple([
ButtonElement(is_momentary, MIDI_NOTE_TYPE, track,
62 - index) for index in range(3)
]))
filter = mixer.track_filter(track)
filter.set_filter_controls(
EncoderElement(MIDI_CC_TYPE, track, 22,
Live.MidiMap.MapMode.absolute),
EncoderElement(MIDI_CC_TYPE, track, 21,
Live.MidiMap.MapMode.absolute))
for ret_track in range(2):
strip = mixer.return_strip(ret_track)
strip.set_volume_control(
SliderElement(MIDI_CC_TYPE, 12, 22 + ret_track))
strip.set_pan_control(
EncoderElement(MIDI_CC_TYPE, 12, 20 + ret_track,
Live.MidiMap.MapMode.absolute))
strip.set_mute_button(
ButtonElement(is_momentary, MIDI_NOTE_TYPE, 12,
78 + ret_track))
mixer.set_crossfader_control(SliderElement(MIDI_CC_TYPE, 12, 8))
mixer.set_prehear_volume_control(
EncoderElement(MIDI_CC_TYPE, 12, 24,
Live.MidiMap.MapMode.absolute))
mixer.master_strip().set_volume_control(
SliderElement(MIDI_CC_TYPE, 12, 7))
mixer.master_strip().set_pan_control(
EncoderElement(MIDI_CC_TYPE, 12, 10,
Live.MidiMap.MapMode.absolute))
return mixer
def _setup_session(self):
num_pads = len(PAD_TRANSLATIONS)
self._track_left_button = ButtonElement(not IS_MOMENTARY, MIDI_CC_TYPE,
0, 36)
self._track_right_button = ButtonElement(not IS_MOMENTARY,
MIDI_CC_TYPE, 0, 35)
self._session = SessionComponent(8, 0)
self._session.name = 'Session_Control'
self._session.selected_scene().name = 'Selected_Scene'
self._session.set_mixer(self._mixer)
self._session.set_page_left_button(self._track_left_button)
self._session.set_page_right_button(self._track_right_button)
pads = []
for index in range(num_pads):
pads.append(
ButtonElement(IS_MOMENTARY, MIDI_CC_TYPE, 0, 60 + index))
pads[(-1)].name = 'Pad_' + str(index)
clip_slot = self._session.selected_scene().clip_slot(index)
clip_slot.set_triggered_to_play_value(GREEN_BLINK)
clip_slot.set_triggered_to_record_value(RED_BLINK)
clip_slot.set_stopped_value(AMBER_FULL)
clip_slot.set_started_value(GREEN_FULL)
clip_slot.set_recording_value(RED_FULL)
clip_slot.set_launch_button(pads[(-1)])
clip_slot.name = str(index) + '_Selected_Clip_Slot'
def _setup_device(self):
self._encoders = []
for offset in range(8):
self._encoders.append(
PeekableEncoderElement(
MIDI_CC_TYPE, 15, 17 + offset,
Live.MidiMap.MapMode.relative_smooth_two_compliment))
self._encoders[(-1)].set_feedback_delay(-1)
self._encoders[(-1)].add_value_listener((self._encoder_value),
identify_sender=True)
self._encoders[(-1)].name = 'Device_Control_' + str(offset)
prev_bank_button = ButtonElement(IS_MOMENTARY, MIDI_CC_TYPE, 15, 14)
next_bank_button = ButtonElement(IS_MOMENTARY, MIDI_CC_TYPE, 15, 15)
prev_bank_button.name = 'Device_Bank_Down_Button'
next_bank_button.name = 'Device_Bank_Up_Button'
device = BestBankDeviceComponent(
device_selection_follows_track_selection=True)
device.name = 'Device_Component'
self.set_device_component(device)
device.set_parameter_controls(tuple(self._encoders))
device.set_bank_nav_buttons(prev_bank_button, next_bank_button)
self._device_bank_buttons = (prev_bank_button, next_bank_button)
prev_bank_button.add_value_listener(self._device_bank_value)
next_bank_button.add_value_listener(self._device_bank_value)
self._inst_button = ButtonElement(IS_MOMENTARY, MIDI_CC_TYPE, 15, 109)
self._inst_button.name = 'Inst_Button'
self._inst_button.add_value_listener(self._inst_value)
self._device_navigation = DetailViewCntrlComponent()
self._device_navigation.name = 'Device_Navigation_Component'
def __init__(self, c_instance):
ControlSurface.__init__(self, c_instance)
with self.component_guard():
self.set_pad_translations(PAD_TRANSLATIONS)
self._suggested_input_port = 'DirectLink'
self._suggested_output_port = 'DirectLink'
self._waiting_for_first_response = True
self._has_sliders = True
self._current_midi_map = None
self._display_reset_delay = -1
self._shift_pressed = False
self._shift_button = ButtonElement(IS_MOMENTARY, MIDI_CC_TYPE, 15,
13)
self._master_slider = SliderElement(MIDI_CC_TYPE, 15, 41)
self._next_nav_button = ButtonElement(IS_MOMENTARY, MIDI_CC_TYPE,
15, 111)
self._prev_nav_button = ButtonElement(IS_MOMENTARY, MIDI_CC_TYPE,
15, 110)
self._device_bank_buttons = None
self._device_navigation = None
self._shift_button.name = 'Shift_Button'
self._master_slider.name = 'Master_Volume_Control'
self._next_nav_button.name = 'Next_Track_Button'
self._prev_nav_button.name = 'Prev_Track_Button'
self._master_slider.add_value_listener((self._slider_value),
identify_sender=True)
self._shift_button.add_value_listener(self._shift_value)
self._setup_mixer()
self._setup_transport_and_session()
self._setup_device()
self._setup_display()
for component in self.components:
component.set_enabled(False)
def __init__(self, *a, **k):
(super().__init__)(*a, **k)
is_momentary = True
self.split_knob = SliderElement(MIDI_CC_TYPE, 5, 70)
self.gate_knob = SliderElement(MIDI_CC_TYPE, 5, 71)
self.bend_knob = SliderElement(MIDI_CC_TYPE, 5, 72)
self.offset_knob = SliderElement(MIDI_CC_TYPE, 5, 73)
self.strech_knob = SliderElement(MIDI_CC_TYPE, 5, 74)
self.fade_knob = SliderElement(MIDI_CC_TYPE, 5, 75)
self.transpose_knob = SliderElement(MIDI_CC_TYPE, 5, 77)
self.edit_button = ButtonElement(is_momentary, MIDI_CC_TYPE, 5, 60)
self.split_button = ButtonElement(is_momentary, MIDI_CC_TYPE, 5, 61)
self.init_button = ButtonElement(is_momentary, MIDI_CC_TYPE, 5, 62)
self.delete_button = ButtonElement(is_momentary, MIDI_CC_TYPE, 5, 63)
self.select_button = ButtonElement(is_momentary, MIDI_CC_TYPE, 5, 64)
self._do_edit_button.subject = self.edit_button
self._do_split_button.subject = self.split_button
self._do_delete.subject = self.delete_button
self._do_init.subject = self.init_button
self._do_select.subject = self.select_button
self._do_split.subject = self.split_knob
self._do_gate.subject = self.gate_knob
self._do_bend.subject = self.bend_knob
self._do_offset.subject = self.offset_knob
self._do_strech.subject = self.strech_knob
self._do_fade.subject = self.fade_knob
self._do_transpose.subject = self.transpose_knob
def __init__(self, modeselector, editsection, *a, **k):
super(CompoundComponent, self).__init__(*a, **k)
self._modesel = modeselector
self._editsection = editsection
is_momentary = True
self._do_push_button.subject = ButtonElement(is_momentary,
MIDI_CC_TYPE, 0, 82)
self._do_edit_slider.subject = SliderElement(MIDI_CC_TYPE, 1, 81)
self._do_channel_slider.subject = SliderElement(MIDI_CC_TYPE, 1, 83)
self._do_channel_button.subject = ButtonElement(
is_momentary, MIDI_CC_TYPE, 1, 63)
self._do_req_quantize.subject = SliderElement(MIDI_CC_TYPE, 1, 100)
self._do_browse.subject = SliderElement(MIDI_CC_TYPE, 1, 84)
self._do_tempo.subject = SliderElement(MIDI_CC_TYPE, 1, 101)
self._do_volume.subject = SliderElement(MIDI_CC_TYPE, 1, 103)
self._do_dedicated_rec_quantize.subject = SliderElement(
MIDI_CC_TYPE, 2, 112)
self._do_dedicated_clip_quantize.subject = SliderElement(
MIDI_CC_TYPE, 2, 113)
self.set_up_function_buttons()
self._wheel_overide = None
self.scrub_mode = True
self.select_arm_mode = True
self._push_down = False
return
def __init__(self, *a, **k):
ControlSurface.__init__(self, *a, **k)
self._skin = Skin(LaunchModColors)
with self.component_guard():
self._monomod_version = 'b996'
self._host_name = 'LaunchMod'
self._color_type = 'Launchpad'
self._timer = 0
self._suppress_send_midi = True
self._suppress_session_highlight = True
self._suppress_highlight = False
is_momentary = True
self._suggested_input_port = 'Launchpad'
self._suggested_output_port = 'Launchpad'
self._control_is_with_automap = False
self._user_byte_write_button = ButtonElement(is_momentary, MIDI_CC_TYPE, 0, 16)
self._user_byte_write_button.name = 'User_Byte_Button'
self._user_byte_write_button.send_value(1)
self._user_byte_write_button.add_value_listener(self._user_byte_value)
self._wrote_user_byte = False
self._challenge = Live.Application.get_random_int(0, 400000000) & 2139062143
matrix = ButtonMatrixElement(name = 'Button_Matrix')
for row in range(8):
button_row = [ ConfigurableButtonElement(is_momentary, MIDI_NOTE_TYPE, 0, row * 16 + column, str(column) + '_Clip_' + str(row) + '_Button', self, skin = self._skin) for column in range(8) ]
matrix.add_row(tuple(button_row))
self._matrix = matrix
self._config_button = ButtonElement(is_momentary, MIDI_CC_TYPE, 0, 0, optimized_send_midi=False)
self._config_button.add_value_listener(self._config_value)
top_button_names = ['Bank_Select_Up_Button',
'Bank_Select_Down_Button',
'Bank_Select_Left_Button',
'Bank_Select_Right_Button',
'Session_Button',
'User1_Button',
'User2_Button',
'Mixer_Button']
side_button_names = ['Vol_Button',
'Pan_Button',
'SndA_Button',
'SndB_Button',
'Stop_Button',
'Trk_On_Button',
'Solo_Button',
'Arm_Button']
top_buttons = [ ConfigurableButtonElement(is_momentary, MIDI_CC_TYPE, 0, 104 + index, top_button_names[index], self, skin = self._skin) for index in range(8) ]
self._top_buttons = top_buttons
side_buttons = [ ConfigurableButtonElement(is_momentary, MIDI_NOTE_TYPE, 0, SIDE_NOTES[index], side_button_names[index], self, skin = self._skin) for index in range(8) ]
self._side_buttons = ButtonMatrixElement(name = 'SideButtons', rows = [side_buttons])
self._setup_monobridge()
self._setup_mod()
self._selector = MainSelectorComponent(self, matrix, tuple(top_buttons), tuple(side_buttons), self._config_button)
self._selector.name = 'Main_Modes'
for control in self.controls:
isinstance(control, MonoButtonElement) and control.add_value_listener(self._button_value)
self.set_highlighting_session_component(self._selector.session_component())
self._suppress_session_highlight = False
self.log_message('--------------= ' + str(self._monomod_version) + ' log opened =--------------')
def _setup_view_control(self):
is_momentary = True
view = ViewTogglerComponent(NUM_TRACKS)
view.set_buttons(
tuple([
ButtonElement(is_momentary, MIDI_NOTE_TYPE, track, 67)
for track in range(NUM_TRACKS)
]),
tuple([
ButtonElement(is_momentary, MIDI_NOTE_TYPE, track, 66)
for track in range(NUM_TRACKS)
]))
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)
def __init__(self):
SessionComponent.__init__(self, 4, 4)
self._mode_button = ButtonElement(False, MIDI_CC_TYPE, 2, 50)
self._do_matrix_adv_mode.subject = self._mode_button
self._mode_button.send_value(0, True)
self._track_banking_increment = 1
self._c_mode_button = ButtonElement(True, MIDI_CC_TYPE, 2, 90)
self._change_color_mode.subject = self._c_mode_button
self._c_mode_button.send_value(0, True)
self.notify = self.notify_standard
self.get_color = self.get_color_standard
self._nav_color_button = self.canonical_parent.create_gated_button(8, 110)
self._toggle_step_advance.subject = self._nav_color_button
self._nav_color_button.switch_off()
self._color_manager = self
def _setup_session_control(self):
is_momentary = True
down_button = ButtonElement(is_momentary, MIDI_NOTE_TYPE, 12, 89)
up_button = ButtonElement(is_momentary, MIDI_NOTE_TYPE, 12, 90)
session = SessionComponent(NUM_TRACKS, 0)
session.set_select_buttons(down_button, up_button)
session.selected_scene().set_launch_button(
ButtonElement(is_momentary, MIDI_NOTE_TYPE, 12, 87))
track_stop_buttons = [
ButtonElement(is_momentary, MIDI_NOTE_TYPE, index, 68)
for index in range(NUM_TRACKS)
]
session.set_stop_track_clip_buttons(tuple(track_stop_buttons))
for index in range(NUM_TRACKS):
session.selected_scene().clip_slot(index).set_launch_button(
ButtonElement(is_momentary, MIDI_NOTE_TYPE, index, 69))
def __init__(self):
SessionComponent.__init__(self, 4, 4)
self._matrix = None
self._advance = STEP4
self._mode_button = None
self._set_mode_button(ButtonElement(False, MIDI_CC_TYPE, 0, 80))
self.set_track_banking_increment(STEP4)
def __init__(self,
c_instance,
control_factory=LaunchkeyControlFactory(),
identity_response=SIZE_RESPONSE):
ControlSurface.__init__(self, c_instance)
self._control_factory = control_factory
self._identity_response = identity_response
with self.component_guard():
self.set_pad_translations(PAD_TRANSLATIONS)
self._suggested_input_port = 'Launchkey InControl'
self._suggested_output_port = 'Launchkey InControl'
self._has_sliders = True
self._current_midi_map = None
self._master_slider = make_slider(7, 'Master_Volume_Control')
self._modes_buttons = []
for index in range(3):
button = ButtonElement(IS_MOMENTARY, MIDI_NOTE_TYPE, 0,
13 + index)
self._modes_buttons.append(button)
self._modes_buttons[(-1)].add_value_listener(
self._dummy_listener)
self._setup_mixer()
self._setup_session()
self._setup_transport()
self._setup_device()
self._setup_navigation()
for component in self.components:
component.set_enabled(False)
def __init__(self, parent):
SessionComponent.__init__(self, 4, 4)
self._parent = parent
self._matrix = None
self._advance = STEP4
self._mode_button = None
self._set_mode_button(ButtonElement(False, MIDI_CC_TYPE, 0, 80))
self._linkoff = 0
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 __init__(self, modeselector, editsection, *a, **k):
(super().__init__)(*a, **k)
self._modesel = modeselector
self._editsection = editsection
self._modesel.connect_main_knob(self)
is_momentary = True
self.main_knob = SliderElement(MIDI_CC_TYPE, 1, 85)
self.push_button = ButtonElement(is_momentary, MIDI_CC_TYPE, 1, 87)
self.volume_button = ButtonElement(is_momentary, MIDI_CC_TYPE, 3, 110)
self.swing_button = ButtonElement(is_momentary, MIDI_CC_TYPE, 3, 111)
self.tempo_button = ButtonElement(is_momentary, MIDI_CC_TYPE, 3, 112)
self.xfade_button = ButtonElement(is_momentary, MIDI_CC_TYPE, 3, 116)
self._mode_button = self.canonical_parent.create_gated_button(
80, KSM_HUES[0])
self._color_edit_button = ButtonElement(is_momentary, MIDI_CC_TYPE, 3,
113)
self._set_inicliplen_button = ButtonElement(is_momentary, MIDI_CC_TYPE,
3, 122)
self._set_quantize_button = ButtonElement(is_momentary, MIDI_CC_TYPE,
3, 126)
self.do_main.subject = self.main_knob
self.do_main_push.subject = self.push_button
self._do_volume.subject = self.volume_button
self._do_swing.subject = self.swing_button
self._do_tempo.subject = self.tempo_button
self._do_xfade.subject = self.xfade_button
self._do_toggle_mode.subject = self._mode_button
self._do_color_button.subject = self._color_edit_button
self._do_mikr_cliplen.subject = self._set_inicliplen_button
self._do_mikr_quantize.subject = self._set_quantize_button
self._do_dedicated_rec_quantize.subject = SliderElement(
MIDI_CC_TYPE, 2, 112)
self._do_dedicated_clip_quantize.subject = SliderElement(
MIDI_CC_TYPE, 2, 113)
self._radio_buttons = (self.volume_button, self.swing_button,
self.tempo_button, self.xfade_button,
self._color_edit_button)
self._do_button_left.subject = ButtonElement(is_momentary,
MIDI_CC_TYPE, 2, 120)
self._do_button_right.subject = ButtonElement(is_momentary,
MIDI_CC_TYPE, 2, 121)
self.volume_button.send_value(0, True)
self._mode_button.set_color(KSM_HUES[0])
self.knob_action = self._scroll_action
self._prev_mode = None
self._prev_action = None
def _setup_transport_and_session(self):
ffwd_button = ButtonElement(IS_MOMENTARY, MIDI_CC_TYPE, 15, 115)
rwd_button = ButtonElement(IS_MOMENTARY, MIDI_CC_TYPE, 15, 114)
loop_button = ButtonElement(IS_MOMENTARY, MIDI_CC_TYPE, 15, 113)
play_button = ButtonElement(IS_MOMENTARY, MIDI_CC_TYPE, 15, 117)
stop_button = ButtonElement(IS_MOMENTARY, MIDI_CC_TYPE, 15, 116)
rec_button = ButtonElement(IS_MOMENTARY, MIDI_CC_TYPE, 15, 118)
ffwd_button.name = 'FFwd_Button'
rwd_button.name = 'Rwd_Button'
loop_button.name = 'Loop_Button'
play_button.name = 'Play_Button'
stop_button.name = 'Stop_Button'
rec_button.name = 'Record_Button'
transport = ShiftableTransportComponent()
transport.name = 'Transport'
transport.set_shift_button(self._shift_button)
transport.set_stop_button(stop_button)
transport.set_play_button(play_button)
transport.set_record_button(rec_button)
pads = []
for index in range(len(PAD_TRANSLATIONS)):
pads.append(
ButtonElement(IS_MOMENTARY, MIDI_NOTE_TYPE, 15,
PAD_TRANSLATIONS[index][2]))
pads[(-1)].name = 'Pad_' + str(index)
self._session = ShiftableSessionComponent(8, 0)
self._session.name = 'Session_Control'
self._session.selected_scene().name = 'Selected_Scene'
self._session.set_mixer(self._mixer)
self._session.set_shift_button(self._shift_button)
self._session.set_clip_slot_buttons(tuple(pads))
transport_view_modes = TransportViewModeSelector(
transport, self._session, ffwd_button, rwd_button, loop_button)
transport_view_modes.name = 'Transport_View_Modes'
def set_touch_mode(self, touchchannel):
self.touch_mode = True
id_vol = self._volume_control.message_identifier()
id_pan = self._pan_control.message_identifier()
id_send = None
for send in self._send_controls:
if send:
id_send = send.message_identifier()
self.clear_vol_button = ButtonElement(False, MIDI_CC_TYPE, touchchannel, id_vol)
self.clear_vol_button.add_value_listener(self._do_clear_vol)
self.clear_pan_button = ButtonElement(False, MIDI_CC_TYPE, touchchannel, id_pan)
self.clear_pan_button.add_value_listener(self._do_clear_pan)
self.clear_send_button = ButtonElement(False, MIDI_CC_TYPE, touchchannel, id_send)
self.clear_send_button.add_value_listener(self._do_clear_send)
for send in self._send_controls:
if send:
self.send_control = send
def __init__(self, button_index, monochrome=False, *a, **k):
(super().__init__)(button_index, *a, **k)
self._note_display_mode = ND_KEYBOARD1
self.current_scale_index = 0
self._scale = None
self._base_note = 0
self._octave = 0.55
self.current_scale_index = 0
self._in_edit_mode = False
self._editmode = None
self._is_monochrome = monochrome
self._color_edit_assign = monochrome and self.assign_edit_mono or self.assign_edit_color
self.assign_transpose(SCALES[self.current_scale_index])
is_momentary = True
self.octave_down_button = ButtonElement(is_momentary, MIDI_CC_TYPE, 3,
120)
self.octave_up_button = ButtonElement(is_momentary, MIDI_CC_TYPE, 3,
121)
self.base_down_button = ButtonElement(is_momentary, MIDI_CC_TYPE, 3,
124)
self.base_up_button = ButtonElement(is_momentary, MIDI_CC_TYPE, 3, 125)
self.scale_down_button = ButtonElement(is_momentary, MIDI_CC_TYPE, 3,
118)
self.scale_up_button = ButtonElement(is_momentary, MIDI_CC_TYPE, 3,
119)
self._adjust_scale.subject = SliderElement(MIDI_CC_TYPE, 2, 116)
self._adjust_octav.subject = SliderElement(MIDI_CC_TYPE, 2, 115)
self._adjust_basem.subject = SliderElement(MIDI_CC_TYPE, 2, 117)
self._do_oct_down.subject = self.octave_down_button
self._do_oct_up.subject = self.octave_up_button
self._do_base_down.subject = self.base_down_button
self._do_base_up.subject = self.base_up_button
self._do_scale_down.subject = self.scale_down_button
self._do_scale_up.subject = self.scale_up_button
self._seg_display = None
def __init__(self, *a, **k):
(super().__init__)(*a, **k)
is_momentary = True
self.mikro_shift_button = ButtonElement(is_momentary, MIDI_CC_TYPE, 2, 80)
self._do_shift_mikro.subject = self.mikro_shift_button
self.shift_button = ButtonElement(is_momentary, MIDI_CC_TYPE, 1, 80)
self._do_shift.subject = self.shift_button
self.alt_button = ButtonElement(is_momentary, MIDI_CC_TYPE, 1, 82)
self._do_alt.subject = self.alt_button
self.mikro_shift = False
self.shiftdown = False
self.altdown = False
self.edit_state = ES_NONE
self._down_button = None
self._action_set_quant.subject = SliderElement(MIDI_CC_TYPE, 2, 110)
self._action_init_loop.subject = SliderElement(MIDI_CC_TYPE, 2, 111)
self._nav_button = StateButton(is_momentary, MIDI_CC_TYPE, 0, 115)
self._action_navigate.subject = self._nav_button
self._copy_button = StateButton(is_momentary, MIDI_CC_TYPE, 0, 95)
self._action_duplicate.subject = self._copy_button
self._quantize_button = StateButton(is_momentary, MIDI_CC_TYPE, 0, 97)
self._action_quantize.subject = self._quantize_button
self._paste_button = StateButton(is_momentary, MIDI_CC_TYPE, 0, 96)
self._action_new.subject = self._paste_button
self._note_button = StateButton(is_momentary, MIDI_CC_TYPE, 0, 101)
self._action_note.subject = self._note_button
self._clear_button = StateButton(is_momentary, MIDI_CC_TYPE, 0, 103)
self._action_clear.subject = self._clear_button
self._nudge_button = StateButton(is_momentary, MIDI_CC_TYPE, 0, 100)
self._action_nudge_button.subject = self._nudge_button
self.action_time = False
self.pad_action = False
self.pad_wheel_action = False
self.quantize = 5
self.quantize_amount = 1.0
self.initial_clip_len = 4.0
self._focused_clip = None
self._focused_c_index = None
self._color_edit = False
self.nav_index = 0
def _setup_mixer_control(self):
is_momentary = True
num_tracks = 8
num_returns = 7
mixer = MixerComponent(num_tracks, num_returns)
for track in range(num_tracks):
strip = mixer.channel_strip(track)
strip.set_volume_control(
SliderElement(MIDI_CC_TYPE, 15, 54 - track))
strip.set_pan_control(SliderElement(MIDI_CC_TYPE, 15, 80 - track))
strip.set_mute_button(
ButtonElement(is_momentary, MIDI_CC_TYPE, 15, 117 - track))
strip.set_invert_mute_feedback(True)
for track in range(num_returns):
strip = mixer.return_strip(track)
strip.set_volume_control(
SliderElement(MIDI_CC_TYPE, 15, 10 + track))
mixer.set_bank_buttons(
ButtonElement(is_momentary, MIDI_CC_TYPE, 15, 108),
ButtonElement(is_momentary, MIDI_CC_TYPE, 15, 109))
mixer.set_crossfader_control(SliderElement(MIDI_CC_TYPE, 15, 9))
mixer.master_strip().set_volume_control(
SliderElement(MIDI_CC_TYPE, 15, 46))
session = SessionComponent(0, 0)
session.set_select_buttons(
ButtonElement(is_momentary, MIDI_CC_TYPE, 15, 95),
ButtonElement(is_momentary, MIDI_CC_TYPE, 15, 92))
session.selected_scene().set_launch_button(
ButtonElement(is_momentary, MIDI_CC_TYPE, 15, 91))
def _setup_mixer(self):
mute_solo_flip_button = ButtonElement(not IS_MOMENTARY, MIDI_CC_TYPE,
0, 34)
self._next_nav_button = ButtonElement(IS_MOMENTARY, MIDI_CC_TYPE, 0,
37)
self._prev_nav_button = ButtonElement(IS_MOMENTARY, MIDI_CC_TYPE, 0,
38)
self._strip_buttons = []
mute_solo_flip_button.name = 'Mute_Solo_Flip_Button'
self._next_nav_button.name = 'Next_Track_Button'
self._prev_nav_button.name = 'Prev_Track_Button'
self._mixer = SpecialMixerComponent(8)
self._mixer.name = 'Mixer'
self._mixer.set_select_buttons(self._next_nav_button,
self._prev_nav_button)
self._mixer.selected_strip().name = 'Selected_Channel_Strip'
self._mixer.master_strip().name = 'Master_Channel_Strip'
self._mixer.master_strip().set_volume_control(self._master_slider)
self._sliders = []
for index in range(8):
strip = self._mixer.channel_strip(index)
strip.name = 'Channel_Strip_' + str(index)
strip.set_invert_mute_feedback(True)
self._sliders.append(SliderElement(MIDI_CC_TYPE, 0, index))
self._sliders[(-1)].name = str(index) + '_Volume_Control'
self._sliders[(-1)].set_feedback_delay(-1)
self._sliders[(-1)].add_value_listener((self._slider_value),
identify_sender=True)
strip.set_volume_control(self._sliders[(-1)])
self._strip_buttons.append(
ButtonElement(IS_MOMENTARY, MIDI_CC_TYPE, 0, 9 + index))
self._strip_buttons[(-1)].name = str(index) + '_Mute_Button'
self._strip_buttons[(-1)].add_value_listener(
(self._mixer_button_value), identify_sender=True)
self._mixer.master_strip().set_mute_button(
ButtonElement(IS_MOMENTARY, MIDI_CC_TYPE, 1, 17))
self._mixer.set_strip_mute_solo_buttons(tuple(self._strip_buttons),
mute_solo_flip_button)
def __init__(self, c_instance):
ControlSurface.__init__(self, c_instance)
with self.component_guard():
self.set_pad_translations(PAD_TRANSLATIONS)
self._suggested_input_port = 'Impulse'
self._suggested_output_port = 'Impulse'
self._has_sliders = True
self._current_midi_map = None
self._display_reset_delay = -1
self._shift_button = ButtonElement(IS_MOMENTARY, MIDI_CC_TYPE, 0,
39)
self._preview_button = ButtonElement(IS_MOMENTARY, MIDI_CC_TYPE, 0,
41)
self._master_slider = SliderElement(MIDI_CC_TYPE, 0, 8)
self._shift_button.name = 'Shift_Button'
self._master_slider.name = 'Master_Volume_Control'
self._master_slider.add_value_listener((self._slider_value),
identify_sender=True)
self._preview_button.add_value_listener(self._preview_value)
self._setup_mixer()
self._setup_session()
self._setup_transport()
self._setup_device()
self._setup_name_display()
device_button = ButtonElement(not IS_MOMENTARY, MIDI_CC_TYPE, 1,
10)
mixer_button = ButtonElement(not IS_MOMENTARY, MIDI_CC_TYPE, 1, 9)
device_button.name = 'Encoder_Device_Mode'
mixer_button.name = 'Encoder_Mixer_Mode'
self._encoder_modes = EncoderModeSelector(self._device_component,
self._mixer,
self._next_bank_button,
self._prev_bank_button,
self._encoders)
self._encoder_modes.set_device_mixer_buttons(
device_button, mixer_button)
self._string_to_display = None
for component in self.components:
component.set_enabled(False)
def make_button(identifier,
msg_type=MIDI_NOTE_TYPE,
is_momentary=True,
skin=None,
is_modifier=False,
name=''):
return ButtonElement(
is_momentary,
msg_type,
STANDARD_CHANNEL,
identifier,
skin=skin,
name=name,
resource_type=(PrioritizedResource if is_modifier else None))
def __init__(self, *a, **k):
super(JogWheelSection, self).__init__(*a, **k)
self._do_encoder_button.subject = ButtonElement(
True, MIDI_CC_TYPE, 0, CC_JOGWHEEL_PUSH)
self._do_encoder_touch.subject = ButtonElement(True, MIDI_CC_TYPE, 0,
CC_JOGWHEEL_TOUCH)
self._do_encoder_slider.subject = SliderElement(
MIDI_CC_TYPE, 0, CC_JOGWHEEL)
self.__nav_left_button = IndexedButton(True, MIDI_CC_TYPE, CC_NAV_LEFT,
0, (0, 127))
self.__nav_right_button = IndexedButton(True, MIDI_CC_TYPE,
CC_NAV_RIGHT, 0, (0, 127))
self.__nav_up_button = IndexedButton(True, MIDI_CC_TYPE, CC_NAV_UP, 0,
(0, 127))
self.__nav_down_button = IndexedButton(True, MIDI_CC_TYPE, CC_NAV_DOWN,
0, (0, 127))
self._do_nav_left.subject = self.__nav_left_button
self._do_nav_right.subject = self.__nav_right_button
self._do_nav_up.subject = self.__nav_up_button
self._do_nav_down.subject = self.__nav_down_button
self._selected_track_change.subject = self.song().view
self._clip = None
return
def make_button(identifier,
channel,
name,
msg_type=MIDI_NOTE_TYPE,
skin=None,
is_modifier=False):
return ButtonElement(
True,
msg_type,
channel,
identifier,
skin=skin,
name=name,
resource_type=(PrioritizedResource if is_modifier else None))
def _create_controls(self):
self._device_controls = ButtonMatrixElement(rows=[[EncoderElement(MIDI_CC_TYPE, (self.encoder_msg_channel), identifier, (Live.MidiMap.MapMode.relative_smooth_two_compliment), name=('Encoder_%d_%d' % (column_index, row_index))) for column_index, identifier in enumerate(row)] for row_index, row in enumerate((
self.encoder_msg_ids[:4], self.encoder_msg_ids[8:12]))])
self._horizontal_scroll_encoder = EncoderElement(MIDI_CC_TYPE,
(self.encoder_msg_channel),
(self.encoder_msg_ids[7]),
(Live.MidiMap.MapMode.relative_smooth_two_compliment),
name='Horizontal_Scroll_Encoder')
self._vertical_scroll_encoder = EncoderElement(MIDI_CC_TYPE,
(self.encoder_msg_channel),
(self.encoder_msg_ids[15]),
(Live.MidiMap.MapMode.relative_smooth_two_compliment),
name='Vertical_Scroll_Encoder')
self._volume_encoder = EncoderElement(MIDI_CC_TYPE,
(self.encoder_msg_channel),
(self.encoder_msg_ids[13]),
(Live.MidiMap.MapMode.relative_smooth_two_compliment),
name='Volume_Encoder')
self._pan_encoder = EncoderElement(MIDI_CC_TYPE,
(self.encoder_msg_channel),
(self.encoder_msg_ids[12]),
(Live.MidiMap.MapMode.relative_smooth_two_compliment),
name='Pan_Encoder')
self._send_a_encoder = EncoderElement(MIDI_CC_TYPE,
(self.encoder_msg_channel),
(self.encoder_msg_ids[4]),
(Live.MidiMap.MapMode.relative_smooth_two_compliment),
name='Send_A_Encoder')
self._send_b_encoder = EncoderElement(MIDI_CC_TYPE,
(self.encoder_msg_channel),
(self.encoder_msg_ids[5]),
(Live.MidiMap.MapMode.relative_smooth_two_compliment),
name='Send_B_Encoder')
self._send_encoders = ButtonMatrixElement(rows=[
[
self._send_a_encoder, self._send_b_encoder]])
self._return_a_encoder = EncoderElement(MIDI_CC_TYPE,
(self.encoder_msg_channel),
(self.encoder_msg_ids[6]),
(Live.MidiMap.MapMode.relative_smooth_two_compliment),
name='Return_A_Encoder')
self._return_b_encoder = EncoderElement(MIDI_CC_TYPE,
(self.encoder_msg_channel),
(self.encoder_msg_ids[14]),
(Live.MidiMap.MapMode.relative_smooth_two_compliment),
name='Return_B_Encoder')
self._return_encoders = ButtonMatrixElement(rows=[
[
self._return_a_encoder, self._return_b_encoder]])
self._pads = ButtonMatrixElement(rows=[[ButtonElement(True, MIDI_NOTE_TYPE, (self.pad_channel), (col + 36 + 8 * row), name=('Pad_%d_%d' % (col, row))) for col in range(8)] for row in range(2)])
def make_ring_encoder(encoder_identifer, button_identifier, name='', *a, **k):
button_name = '%s_Ring_Mode_Button' % name
button = ButtonElement(False,
MIDI_CC_TYPE,
0,
button_identifier,
name=button_name)
encoder = RingedEncoderElement(MIDI_CC_TYPE,
0,
encoder_identifer, (MapMode.absolute),
*a,
name=name,
**k)
encoder.set_ring_mode_button(button)
return encoder
def __init__(self, *a, **k):
(super(AudioClipEditComponent, self).__init__)(*a, **k)
self._loop_start_slider = SliderElement(MIDI_CC_TYPE, 2, 60)
self._action_loop_start.subject = self._loop_start_slider
self._loop_end_slider = SliderElement(MIDI_CC_TYPE, 2, 61)
self._action_loop_end.subject = self._loop_end_slider
self._mark_start_slider = SliderElement(MIDI_CC_TYPE, 2, 62)
self._action_mark_start.subject = self._mark_start_slider
self._mark_end_slider = SliderElement(MIDI_CC_TYPE, 2, 63)
self._action_mark_end.subject = self._mark_end_slider
self._pitch_c_slider = SliderElement(MIDI_CC_TYPE, 2, 64)
self._pitch_f_slider = SliderElement(MIDI_CC_TYPE, 2, 65)
self._gain_slider = SliderElement(MIDI_CC_TYPE, 2, 66)
self._action_pitch_c.subject = self._pitch_c_slider
self._action_pitch_f.subject = self._pitch_f_slider
self._action_gain.subject = self._gain_slider
self._loop_inc_slider = SliderElement(MIDI_CC_TYPE, 2, 67)
self._action_loop_inc.subject = self._loop_inc_slider
self._loop_move_button = ButtonElement(False, MIDI_CC_TYPE, 2, 74)
self._action_mv_loop.subject = self._loop_move_button
self._loop_set_button = ButtonElement(False, MIDI_CC_TYPE, 2, 70)
self._action_loop_toggle.subject = self._loop_set_button
self._warp_set_button = ButtonElement(False, MIDI_CC_TYPE, 2, 71)
self._action_warp_toggle.subject = self._warp_set_button
self._zoom_scroll_button = ButtonElement(False, MIDI_CC_TYPE, 2, 73)
self._action_scroll_mode.subject = self._zoom_scroll_button
self.selected_clip_slot = None
self.inc_index = 4
self.loop_inc = INC_STEPS[self.inc_index]
self.start_inc = INC_STEPS[self.inc_index]
self.mv_loop = False
self._on_pitch_c_changed.subject = None
self._on_pitch_f_changed.subject = None
self._on_gain_changed.subject = None
self._scroll_mode = False
self.update_selected_clip()
