def __init__(self, identifier):
EncoderElement.__init__(
self,
msg_type=MIDI_CC_TYPE,
channel=self.channel,
identifier=identifier,
map_mode=self.map_mode)
def _setup_mixer_control(self): is_momentary = True # We use non-latching buttons (keys) throughout, so we'll set this as a constant num_tracks = 7 # Here we define the mixer width in tracks (a mixer has only one dimension) global mixer # We want to instantiate the global mixer as a MixerComponent object (it was a global "None" type up until now...) mixer = MixerComponent(num_tracks, 0) #(num_tracks, num_returns, with_eqs, with_filters) mixer.set_track_offset(0) #Sets start point for mixer strip (offset from left) """set up the mixer buttons""" self.song().view.selected_track = mixer.channel_strip(0)._track mixer.selected_strip().set_mute_button(ButtonElement(is_momentary, MIDI_NOTE_TYPE, CHANNEL, 64)) #mixer.selected_strip().set_solo_button(ButtonElement(is_momentary, MIDI_NOTE_TYPE, CHANNEL, 44)) mixer.selected_strip().set_arm_button(ButtonElement(is_momentary, MIDI_NOTE_TYPE, CHANNEL, 72)) track_select_notes = [65, 73, 66, 74, 67, 75, 68, 76] #more note numbers need to be added if num_scenes is increased slider_select_notes = [23, 22, 15, 14, 5, 7, 6, 4] pan_select_notes = [21, 20, 13, 12, 3, 1, 0, 2] master_volume_control = SliderElement(MIDI_CC_TYPE, 0, 4) master_select_button = ButtonElement(is_momentary, MIDI_NOTE_TYPE, 0, 76) prehear_control = EncoderElement(MIDI_CC_TYPE, 0, 26, Live.MidiMap.MapMode.absolute) crossfader = SliderElement(MIDI_CC_TYPE, 0, 24) for index in range(num_tracks): mixer.channel_strip(index).set_select_button(ButtonElement(is_momentary, MIDI_NOTE_TYPE, CHANNEL, track_select_notes[index])) mixer.channel_strip(index).set_volume_control(SliderElement(MIDI_CC_TYPE, CHANNEL, slider_select_notes[index])) mixer.channel_strip(index).set_pan_control(EncoderElement(MIDI_CC_TYPE, CHANNEL, pan_select_notes[index], Live.MidiMap.MapMode.absolute)) crossfader.name = 'Crossfader' master_volume_control.name = 'Master_Volume_Control' master_select_button.name = 'Master_Select_Button' prehear_control.name = 'Prehear_Volume_Control' mixer.set_crossfader_control(crossfader) mixer.set_prehear_volume_control(prehear_control) mixer.master_strip().set_volume_control(master_volume_control) mixer.master_strip().set_select_button(master_select_button)
def install_connections(self, install_translation_callback, install_mapping_callback, install_forwarding_callback):
EncoderElement.install_connections(
self, install_translation_callback, install_mapping_callback, install_forwarding_callback
)
if not self._is_mapped and self.value_listener_count() == 0:
self._is_being_forwarded = install_forwarding_callback(self)
self._update_ring_mode()
def _setup_mixer_control(self): is_momentary = True self._mixer = SpecialMixerComponent(8) self._mixer.name = 'Mixer' self._mixer.master_strip().name = 'Master_Channel_Strip' self._mixer.selected_strip().name = 'Selected_Channel_Strip' self._solo_buttons = [] for track in range(8): strip = self._mixer.channel_strip(track) strip.name = 'Channel_Strip_' + str(track) solo_button = FlashingButtonElement(is_momentary, MIDI_NOTE_TYPE, track, 50, self) self._solo_buttons.append(solo_button) mute_button = ButtonElement(is_momentary, MIDI_NOTE_TYPE, track, 49) solo_button.name = str(track) + '_Solo_Button' mute_button.name = str(track) + '_Mute_Button' strip.set_solo_button(solo_button) strip.set_mute_button(mute_button) strip.set_shift_button(self._shift_button) strip.set_invert_mute_feedback(True) master_volume_control = SliderElement(MIDI_CC_TYPE, 0, 14) prehear_control = EncoderElement(MIDI_CC_TYPE, 0, 47, Live.MidiMap.MapMode.relative_two_compliment) master_volume_control.name = 'Master_Volume_Control' prehear_control.name = 'Prehear_Volume_Control' self._mixer.set_prehear_volume_control(prehear_control) self._mixer.master_strip().set_volume_control(master_volume_control)
def __init__(self, msg_type, channel, identifier, map_mode, send_channel = None, identifier_send_offset = 0):
EncoderElement.__init__(self, msg_type, channel, identifier, map_mode)
self._identify_mode = False
self._send_channel = send_channel
self._identifier_send_offset = identifier_send_offset
self._on_value = 127
self._off_value = 0
self._force_next_value = False
def connect_to(self, parameter):
if ((parameter != self._parameter_to_map_to) and (not self.is_mapped_manually())):
force_send = True
#self._ring_mode_button.send_value(RING_OFF_VALUE, force_send)
EncoderElement.connect_to(self, parameter)
if (self._parameter_to_map_to.value_has_listener(self.update_ring)):
self._parameter_to_map_to.remove_value_listener(self.update_ring)
self._parameter_to_map_to.add_value_listener(self.update_ring)
def install_connections(self): #this override has to be here so that translation will happen when buttons are disabled if self._is_enabled: EncoderElement.install_connections(self) elif ((self._msg_channel != self._original_channel) or (self._msg_identifier != self._original_identifier)): self._install_translation(self._msg_type, self._original_identifier, self._original_channel, self._msg_identifier, self._msg_channel) #if ((not self._is_mapped) and (len(self._value_notifications) == 0)): # self._is_being_forwarded = self._install_forwarding(self) self._update_ring_mode()
def __init__(self, msg_type, channel, identifier, map_mode, send_channel=None, identifier_send_offset=0):
EncoderElement.__init__(self, msg_type, channel, identifier, map_mode)
self._identify_mode = False
self._send_channel = send_channel
self._identifier_send_offset = identifier_send_offset
self._on_value = 127
self._off_value = 0
self._force_next_value = False
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 _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)
def install_connections(self, install_translation_callback,
install_mapping_callback,
install_forwarding_callback):
EncoderElement.install_connections(self, install_translation_callback,
install_mapping_callback,
install_forwarding_callback)
if not self._is_mapped and self.value_listener_count() == 0:
self._is_being_forwarded = install_forwarding_callback(self)
self._update_ring_mode()
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_mixer_control(self):
is_momentary = True
self._mixer = SpecialMixerComponent(8)
self._mixer.name = 'Mixer'
self._mixer.master_strip().name = 'Master_Channel_Strip'
self._mixer.selected_strip().name = 'Selected_Channel_Strip'
self._solo_buttons = [] # added a
self._select_buttons = [] # added a
for track in range(8):
strip = self._mixer.channel_strip(track)
strip.name = 'Channel_Strip_' + str(track)
volume_control = EncoderElement(
MIDI_CC_TYPE, track, 7, Live.MidiMap.MapMode.absolute
) # 'Slider_' + str(track), track, self)
arm_button = ButtonElement(is_momentary, MIDI_NOTE_TYPE, track, 48)
solo_button = AumPCMonoButtonElement(is_momentary, MIDI_NOTE_TYPE,
track, 50,
str(track) + '_Solo_Button',
self)
self._solo_buttons.append(solo_button) # added a
mute_button = ButtonElement(is_momentary, MIDI_NOTE_TYPE, track,
49)
select_button = AumPCMonoButtonElement(
is_momentary, MIDI_NOTE_TYPE, track, 51,
str(track) + '_Select_Button', self)
self._select_buttons.append(select_button) # added a
#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'
strip.set_volume_control(volume_control)
strip.set_arm_button(arm_button)
strip.set_solo_button(solo_button)
strip.set_mute_button(mute_button)
strip.set_select_button(select_button)
strip.set_shift_button(self._shift_button)
strip.set_invert_mute_feedback(True)
crossfader = SliderElement(MIDI_CC_TYPE, 0, 15)
self._crossfader = crossfader
self._crossfader.name = 'Crossfader'
master_volume_control = SliderElement(MIDI_CC_TYPE, 0, 14)
master_select_button = ButtonElement(is_momentary, MIDI_NOTE_TYPE, 0,
80)
self._master_select_button = master_select_button
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'
prehear_control.name = 'Prehear_Volume_Control'
self._mixer.set_crossfader_control(crossfader)
self._mixer.set_prehear_volume_control(prehear_control)
self._mixer.master_strip().set_volume_control(master_volume_control)
self._mixer.master_strip().set_select_button(master_select_button)
def install_connections(
self
): #this override has to be here so that translation will happen when buttons are disabled
if self._is_enabled:
EncoderElement.install_connections(self)
elif ((self._msg_channel != self._original_channel)
or (self._msg_identifier != self._original_identifier)):
self._install_translation(self._msg_type,
self._original_identifier,
self._original_channel,
self._msg_identifier, self._msg_channel)
class Alias8(ControlSurface):
num_tracks = 8
knobs_top = [1, 2, 3, 4, 5, 6, 7, 8]
knobs_bottom = [9, 10, 11, 12, 13, 14, 15, 16]
faders = [17, 18, 19, 20, 21, 22, 23, 24]
master_fader = 25
encoder = 42
buttons_top = [0, 1, 2, 3, 4, 5, 6, 7]
buttons_bottom = [8, 9, 10, 11, 12, 13, 14, 15]
def __init__(self, instance):
super(Alias8, self).__init__(instance, False)
with self.component_guard():
self._set_suppress_rebuild_requests(True)
self.init_session()
self.init_mixer()
# Connect mixer to session.
self.session.set_mixer(self.mixer)
self.session.update()
# New in Live 9: must explicitly activate session component.
self.set_highlighting_session_component(self.session)
self._set_suppress_rebuild_requests(False)
def init_session(self):
self.session = SessionComponent(self.num_tracks, 1)
self.session.name = 'Alias 8 Session'
self.session.update()
# Connect the encoder to track scroller.
def scroll_cb(value):
if value == 1:
self.session._horizontal_banking.scroll_down()
elif value == 127:
self.session._horizontal_banking.scroll_up()
self.track_encoder = EncoderElement(MIDI_CC_TYPE, 0, self.encoder,
Live.MidiMap.MapMode.absolute)
self.track_encoder.add_value_listener(scroll_cb)
def init_mixer(self):
self.mixer = MixerComponent(self.num_tracks, 0)
self.mixer.id = 'Mixer'
self.song().view.selected_track = self.mixer.channel_strip(0)._track
for i in range(self.num_tracks):
self.mixer.channel_strip(i).set_volume_control(
fader(self.faders[i]))
self.mixer.channel_strip(i).set_solo_button(
button(self.buttons_top[i], color=CYAN))
self.mixer.channel_strip(i).set_arm_button(
button(self.buttons_bottom[i], color=RED))
self.mixer.channel_strip(i).set_pan_control(
knob(self.knobs_bottom[i]))
self.mixer.master_strip().set_volume_control(fader(self.master_fader))
self.mixer.update()
def __init__(self, msg_type, channel, identifier, map_mode, name, num, script): EncoderElement.__init__(self, msg_type, channel, identifier, map_mode=Live.MidiMap.MapMode.absolute) self.name = name self.num = num self._parameter = None self._script = script self._is_enabled = True self._paramter_lcd_name = ' ' self._parameter_last_value = None self._mapped_to_midi_velocity = False self._report = True self.set_report_values(True, False)
def _setup_controls(self):
is_momentary = True
self._tfader = [None for index in range(9)]
self._tfader_touch = [None for index in range(9)]
self._pad = [None for index in range(32)]
self._pad_cc = [None for index in range(32)]
self._button = [None for index in range(8)]
self._tbutton = [None for index in range(8)]
self._runnerled = [None for index in range(8)]
self._sideled = [None for index in range(8)]
self._lcd = [None for index in range(2)]
for index in range(3):
self._tfader[index] = EncoderElement(MIDI_CC_TYPE, CHANNEL,
GW_TOUCHSTRIPS[index],
Live.MidiMap.MapMode.absolute)
self._tfader[index].name = 'fader[' + str(index) + ']'
for index in range(3):
self._tfader_touch[index] = ButtonElement(is_momentary,
MIDI_NOTE_TYPE, CHANNEL,
GW_TOUCHSTRIPS[index])
self._tfader_touch[index].name = 'fadertouch[' + str(index) + ']'
for index in range(4):
self._pad[index] = ButtonElement(is_momentary, MIDI_NOTE_TYPE,
CHANNEL, GW_PADS[index])
self._pad[index].name = 'pad[' + str(index) + ']'
for index in range(4):
self._pad_cc[index] = EncoderElement(MIDI_CC_TYPE, CHANNEL,
GW_PADS[index],
Live.MidiMap.MapMode.absolute)
self._pad_cc[index].name = 'padcc[' + str(index) + ']'
for index in range(4):
self._button[index] = ButtonElement(is_momentary, MIDI_NOTE_TYPE,
CHANNEL, GW_BUTTONS[index])
self._button[index].name = 'btn[' + str(index) + ']'
for index in range(2):
self._tbutton[index] = ButtonElement(is_momentary, MIDI_NOTE_TYPE,
CHANNEL, GW_ARROWS[index])
self._tbutton[index].name = 'arrow[' + str(index) + ']'
for index in range(4):
self._sideled[index] = ButtonElement(is_momentary, MIDI_NOTE_TYPE,
CHANNEL, GW_SIDES[index])
self._sideled[index].name = 'sidebtn[' + str(index) + ']'
for index in range(1):
self._sideled[index] = ButtonElement(is_momentary, MIDI_NOTE_TYPE,
CHANNEL,
GW_MOTIONBUTTON[index])
self._sideled[index].name = 'motionbtn[' + str(index) + ']'
for index in range(3):
self._sideled[index] = EncoderElement(
MIDI_CC_TYPE, CHANNEL, GW_MOTION[index],
Live.MidiMap.MapMode.absolute)
self._sideled[index].name = 'motion[' + str(index) + ']'
def _setup_controls(self):
is_momentary = True
self._tfader = [None for index in range(9)]
self._tfader_touch = [None for index in range(9)]
self._pad = [None for index in range(32)]
self._pad_cc = [None for index in range(32)]
self._button = [None for index in range(8)]
self._tbutton = [None for index in range(8)]
self._runnerled = [None for index in range(8)]
self._sideled = [None for index in range(8)]
self._lcd = [None for index in range(2)]
for index in range(9):
self._tfader[index] = EncoderElement(MIDI_CC_TYPE, CHANNEL,
BASE_TOUCHSTRIPS[index],
Live.MidiMap.MapMode.absolute)
self._tfader[index].name = 'fader[' + str(index) + ']'
for index in range(9):
self._tfader_touch[index] = ButtonElement(is_momentary,
MIDI_NOTE_TYPE, CHANNEL,
BASE_TOUCHSTRIPS[index])
self._tfader_touch[index].name = 'fadertouch[' + str(index) + ']'
for index in range(32):
self._pad[index] = ButtonElement(is_momentary, MIDI_NOTE_TYPE,
CHANNEL, BASE_PADS[index])
self._pad[index].name = 'pad[' + str(index) + ']'
for index in range(32):
self._pad_cc[index] = EncoderElement(MIDI_CC_TYPE, CHANNEL,
BASE_PADS[index],
Live.MidiMap.MapMode.absolute)
self._pad_cc[index].name = 'padcc[' + str(index) + ']'
for index in range(8):
self._button[index] = ButtonElement(is_momentary, MIDI_NOTE_TYPE,
CHANNEL, BASE_BUTTONS[index])
self._button[index].name = 'btn[' + str(index) + ']'
for index in range(8):
self._tbutton[index] = ButtonElement(is_momentary, MIDI_NOTE_TYPE,
CHANNEL,
BASE_TOUCHPADS[index])
self._tbutton[index].name = 'topbtn[' + str(index) + ']'
for index in range(8):
self._runnerled[index] = ButtonElement(is_momentary,
MIDI_NOTE_TYPE, CHANNEL,
BASE_RUNNERS[index])
self._runnerled[index].name = 'runnerled[' + str(index) + ']'
for index in range(8):
self._sideled[index] = ButtonElement(is_momentary, MIDI_NOTE_TYPE,
CHANNEL, BASE_SIDES[index])
self._sideled[index].name = 'sideled[' + str(index) + ']'
for index in range(2):
self._lcd[index] = ButtonElement(is_momentary, MIDI_CC_TYPE,
CHANNEL, BASE_LCDS[index])
self._lcd[index].name = 'lcd[' + str(index) + ']'
def install_connections(
self
): # this override has to be here so that translation will happen when buttons are disabled
if self._is_enabled:
EncoderElement.install_connections(self)
elif (self._msg_channel != self._original_channel) or (self._msg_identifier != self._original_identifier):
self._install_translation(
self._msg_type,
self._original_identifier,
self._original_channel,
self._msg_identifier,
self._msg_channel,
)
def _setup_controls(self):
is_momentary = True
self._fader = [None for index in range(8)]
self._dial = [None for index in range(16)]
self._button = [None for index in range(8)]
self._menu = [None for index in range(6)]
for index in range(8):
self._fader[index] = EncoderElement(MIDI_CC_TYPE, CHANNEL,
OHM_FADERS[index],
Live.MidiMap.MapMode.absolute)
self._fader[index].name = 'Fader_' + str(index), self
for index in range(8):
self._button[index] = MonoButtonElement(is_momentary,
MIDI_NOTE_TYPE, CHANNEL,
OHM_BUTTONS[index],
'Button_' + str(index),
self)
for index in range(16):
self._dial[index] = EncoderElement(MIDI_CC_TYPE, CHANNEL,
OHM_DIALS[index],
Live.MidiMap.MapMode.absolute)
self._dial[index].name = 'Dial_' + str(index)
for index in range(6):
self._menu[index] = MonoButtonElement(is_momentary, MIDI_NOTE_TYPE,
CHANNEL, OHM_MENU[index],
'Menu_' + str(index), self)
self._crossfader = EncoderElement(MIDI_CC_TYPE, CHANNEL, CROSSFADER,
Live.MidiMap.MapMode.absolute)
self._crossfader.name = "Crossfader"
self._livid = MonoButtonElement(is_momentary, MIDI_NOTE_TYPE, CHANNEL,
LIVID, 'Livid_Button', self)
self._shift_l = MonoButtonElement(is_momentary, MIDI_NOTE_TYPE,
CHANNEL, SHIFT_L, 'Page_Button_Left',
self)
self._shift_r = MonoButtonElement(is_momentary, MIDI_NOTE_TYPE,
CHANNEL, SHIFT_R,
'Page_Button_Right', self)
self._matrix = ButtonMatrixElement()
self._matrix.name = 'Matrix'
self._grid = [None for index in range(8)]
for column in range(8):
self._grid[column] = [None for index in range(8)]
for row in range(8):
self._grid[column][row] = MonoButtonElement(
is_momentary, MIDI_NOTE_TYPE, CHANNEL, (column * 8) + row,
'Grid_' + str(column) + '_' + str(row), self)
for row in range(6):
button_row = []
for column in range(7):
button_row.append(self._grid[column][row])
self._matrix.add_row(tuple(button_row))
def __init__(self, msg_type, channel, identifier, map_mode, name, num, script): EncoderElement.__init__(self, msg_type, channel, identifier, map_mode=Live.MidiMap.MapMode.absolute) self.name = name self.num = num self._parameter = None self._script = script self._is_enabled = True #self._report_input = True #self._report_output = True #self._last_sent_val = -1 self._paramter_lcd_name = ' ' self._parameter_last_value = None self._mapped_to_midi_velocity = False self.set_report_values(True, False)
def _create_encoders(self):
# hack, placeholder control so we can get to arbitrary parameters
# in a device
self._dummy_encoder = EncoderElement(MIDI_CC_TYPE, CHAN + 1, 0x7f,
Live.MidiMap.MapMode.absolute)
self._encoders = []
self._sliders = []
for row in (ROW1_ENCODERS_CCS, ROW2_ENCODERS_CCS, ROW3_ENCODERS_CCS,
ROW4_ENCODERS_CCS):
for n in row:
self._encoders.append(
EncoderElement(MIDI_CC_TYPE, CHAN, n,
Live.MidiMap.MapMode.absolute))
self._sliders.append(SliderElement(MIDI_CC_TYPE, CHAN, n))
def __init__(self, msg_type, channel, identifier, map_mode, name, num, script): EncoderElement.__init__(self, msg_type, channel, identifier, map_mode=Live.MidiMap.MapMode.absolute) self.name = name self.num = num self._parameter = None self._script = script self._is_enabled = True self._mapping_feedback_delay = -1 #self._report_input = True #self._report_output = True #self._last_sent_val = -1 self._paramter_lcd_name = ' ' self._parameter_last_value = None self._mapped_to_midi_velocity = False
def install_connections(
self
): #this override has to be here so that translation will happen when buttons are disabled
if self._is_enabled:
EncoderElement.install_connections(self)
elif ((self._msg_channel != self._original_channel)
or (self._msg_identifier != self._original_identifier)):
self._install_translation(self._msg_type,
self._original_identifier,
self._original_channel,
self._msg_identifier, self._msg_channel)
#if ((not self._is_mapped) and (len(self._value_notifications) == 0)):
# self._is_being_forwarded = self._install_forwarding(self)
self._update_ring_mode()
def _create_controls(self):
self._device_encoders = ButtonMatrixElement(rows=[[
EncoderElement(MIDI_CC_TYPE,
ENCODER_CHANNEL,
identifier,
Live.MidiMap.MapMode.relative_smooth_binary_offset,
name=b'Device_Encoder_%d_%d' %
(col_index, row_index))
for col_index, identifier in enumerate(row)
] for row_index, row in enumerate((ENCODER_MSG_IDS[:4],
ENCODER_MSG_IDS[4:8]))])
self._horizontal_scroll_encoder = EncoderElement(
MIDI_CC_TYPE,
ENCODER_CHANNEL,
ENCODER_MSG_IDS[(-2)],
Live.MidiMap.MapMode.relative_smooth_binary_offset,
name=b'Horizontal_Scroll_Encoder')
self._vertical_scroll_encoder = EncoderElement(
MIDI_CC_TYPE,
ENCODER_CHANNEL,
ENCODER_MSG_IDS[(-1)],
Live.MidiMap.MapMode.relative_smooth_binary_offset,
name=b'Vertical_Scroll_Encoder')
self._volume_sliders = ButtonMatrixElement(rows=[[
SliderElement(MIDI_CC_TYPE, ENCODER_CHANNEL, identifier)
for identifier in SLIDER_MSG_IDS[:-1]
]])
self._master_slider = SliderElement(MIDI_CC_TYPE, ENCODER_CHANNEL,
SLIDER_MSG_IDS[(-1)])
def make_keylab_button(name):
button = ButtonElement(True,
MIDI_CC_TYPE,
0,
get_button_identifier_by_name(name),
name=name.title())
return button
for button_name in BUTTON_HARDWARE_AND_MESSAGE_IDS.keys():
setattr(self, b'_' + button_name, make_keylab_button(button_name))
self._pads = ButtonMatrixElement(rows=[[
ButtonElement(True,
MIDI_CC_TYPE,
PAD_CHANNEL,
col_index + row_offset,
name=b'Pad_%d_%d' % (col_index, row_index))
for col_index in xrange(4)
] for row_index, row_offset in enumerate(xrange(48, 35, -4))])
def setup_mixer(self):
global mixer
mixer = MixerComponent(2, 2)
mixer.set_track_offset(0)
self.song().view.selected_track = mixer.channel_strip(
0
)._track # set the selected strip to the first track, so that we don't, for example, try to assign a button to arm the master track, which would cause an assertion error
send_a = EncoderElement(MIDI_CC_TYPE, CHANNEL, SEND_A, mode_absolute)
send_b = EncoderElement(MIDI_CC_TYPE, CHANNEL, SEND_B, mode_absolute)
send_c = EncoderElement(MIDI_CC_TYPE, CHANNEL, SEND_C, mode_absolute)
send_d = EncoderElement(MIDI_CC_TYPE, CHANNEL, SEND_D, mode_absolute)
pan = EncoderElement(MIDI_CC_TYPE, CHANNEL, PAN, mode_absolute)
mixer.selected_strip().set_send_controls(
[send_a, send_b, send_c, send_d])
mixer.selected_strip().set_pan_control(pan)
def _setup_controls(self): is_momentary = True self._dial = [None for index in range(DIALCOUNT)] self._trackbtns = [None for index in range(8)] self._modebtns = [None for index in range(5)] for index in range(DIALCOUNT): self._dial[index] = EncoderElement(MIDI_CC_TYPE, CH, matrix_nums[index], Live.MidiMap.MapMode.absolute) self._dial[index].name = 'Dial_' + str(index) self._dial[index].set_feedback_delay(-1) for index in range(8): self._trackbtns[index] = ButtonElement(is_momentary, MIDI_NOTE_TYPE, CH, track_select_notes[index]) self._trackbtns[index].name = 'Button_' + str(index) for index in range(5): self._modebtns[index] = ButtonElement(is_momentary, MIDI_NOTE_TYPE, CH, mode_select_notes[index]) self._modebtns[index].name = 'ModeButton_' + str(index) self._matrix = ButtonMatrixElement() self._matrix.name = 'Matrix' self._grid = [None for index in range(COLS)] for column in range(COLS): self._grid[column] = [None for index in range(COLS)] for row in range(ROWS): nn = 1+(column * ROWS) + row self._grid[column][row] = ButtonElement(is_momentary, MIDI_NOTE_TYPE, CH, nn) #comment out if you don't want clip launch self._grid[column][row].name = 'Grid_' + str(column) + '_' + str(row) for row in range(ROWS): button_row = [] for column in range(COLS): button_row.append(self._grid[column][row]) self._matrix.add_row(tuple(button_row))
def make_mixer_encoder(cc, channel, name):
if is_valid_midi_identifier(cc) and is_valid_midi_channel(channel):
return EncoderElement(MIDI_CC_TYPE,
channel,
cc,
volume_map_mode,
name=name)
def make_rel_encoder(identifier, name, ch=0, skin=None):
return EncoderElement(
MIDI_CC_TYPE,
ch,
identifier,
map_mode=Live.MidiMap.MapMode.relative_two_compliment,
name=name)
def sequencer_init_rotaries(self):
for rotary_encoder_cc in self.sequencer_page_cc:
self.rotary_encoder_potis[rotary_encoder_cc] = EncoderElement(
MIDI_CC_TYPE, 0, rotary_encoder_cc,
Live.MidiMap.MapMode.absolute)
self.rotary_encoder_potis[rotary_encoder_cc].add_value_listener(
self.sequencer_rotary_change, identify_sender=True)
def _create_controls(self): make_color_button = partial(make_button, skin=self._skin) self._shift_button = make_button(0, 81, name='Shift_Button', num = 0, cs = self) self._matrix = ButtonMatrixElement(name='Button_Matrix') self._scene_launch_buttons_raw = [ make_color_button(0, index + 82, name='Scene_%d_Launch_Button' % index, num = index, cs = self) for index in xrange(SESSION_HEIGHT) ] self._track_stop_buttons = [ make_color_button(index, 52, name='Track_%d_Stop_Button' % index, num = index, cs = self) for index in xrange(SESSION_WIDTH) ] self._matrix_rows_raw = [] for scene_index in xrange(SESSION_HEIGHT): row = [ make_color_button(track_index, scene_index + 53, name='%d_Clip_%d_Button' % (track_index, scene_index), num = index, cs = self) for track_index in xrange(SESSION_WIDTH) ] self._matrix_rows_raw.append(row) self._matrix.add_row(row) self._selected_scene_launch_button = make_pedal_button(64, name='Selected_Scene_Launch_Button') self._scene_launch_buttons = ButtonMatrixElement(rows=[self._scene_launch_buttons_raw]) self._solo_buttons = [ make_button(track_index, 49, name='%d_Solo_Button' % track_index, num = track_index, cs = self) for track_index in xrange(MIXER_SIZE) ] self._mute_buttons = [ make_button(track_index, 50, name='%d_Mute_Button' % track_index, num = track_index, cs = self) for track_index in xrange(MIXER_SIZE) ] self._master_volume_control = make_slider(0, 14, name='Master_Volume_Control', num = 0, script = self) self._prehear_control = EncoderElement(MIDI_CC_TYPE, 0, 47, MapMode.relative_two_compliment, name='Prehear_Volume_Control', num = 0, script = self) self._master_select_button = make_button(0, 80, name='Master_Select_Button', num = index, cs = self) self._select_buttons = [ make_button(track_index, 51, name='%d_Select_Button' % track_index, num = track_index, cs = self ) for track_index in xrange(8) ] self._arm_buttons = [ make_button(track_index, 48, name='%d_Arm_Button' % track_index, num = track_index, cs = self) for track_index in xrange(8) ] self._sliders = [ make_slider(track_index, 7, name='%d_Volume_Control' % track_index, num = track_index, script = self) for track_index in xrange(8) ] self._monomod = ButtonMatrixElement(name = 'Monomod') for row in self._matrix_rows_raw: self._monomod.add_row(row) self._monomod.add_row(self._track_stop_buttons) self._monomod.add_row(self._select_buttons) self._monomod.add_row(self._mute_buttons) self._setup_monobridge() #had to put this here b/c the original author foolishly placed assignment methods inside of creation methods...argh.
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)
def __init__(self, c_instance):
ControlSurface.__init__(self, c_instance)
#self.log_message(time.strftime("%d.%m.%Y %H:%M:%S", time.localtime()) + "--------------= PocketDial log opened =--------------")
# turn off rebuild MIDI map until after setup
#self._set_suppress_rebuild_requests(True)
with self.component_guard():
self._controls = [
EncoderElement(MIDI_CC_TYPE, settings.CHANNEL, cc,
settings.MAP_MODE) for cc in settings.CCS
]
mixer = MixerControl(self)
session = SessionControl(self)
device = DeviceControl(self)
track = TrackControl(self)
# bind mixer to session
session.component.set_mixer(mixer.component)
self.set_highlighting_session_component(session.component)
# "magic" internal self._device_component, which enables lock to device, etc.
self.set_device_component(device.component)
# register components (Live 8 only?)
#self._register_component(session.component)
#self._register_component(mixer.component)
#self._register_component(device.component)
self._device = device
self._track = track
def _setup_mixer_control(self):
is_momentary = True
mixer = MixerComponent(1)
mixer.selected_strip().set_mute_button(
SysexButtonElement(is_momentary, MIDI_NOTE_TYPE, CHANNEL,
KMK_PAD[9]))
mixer.selected_strip().set_solo_button(
SysexButtonElement(is_momentary, MIDI_NOTE_TYPE, CHANNEL,
KMK_PAD[13]))
mixer.set_select_buttons(
SysexButtonElement(is_momentary, MIDI_NOTE_TYPE, CHANNEL,
KMK_PAD[15]),
SysexButtonElement(is_momentary, MIDI_NOTE_TYPE, CHANNEL,
KMK_PAD[14]))
send_faders = []
NUM_CONTROLLABLE_SENDS = 4
for index in range(NUM_CONTROLLABLE_SENDS):
send_faders.append(
SliderElement(MIDI_CC_TYPE, CHANNEL, KMK_FADER[index + 2]))
mixer.selected_strip().set_volume_control(
SliderElement(MIDI_CC_TYPE, CHANNEL, KMK_FADER[0]))
mixer.selected_strip().set_pan_control(
SliderElement(MIDI_CC_TYPE, CHANNEL, KMK_FADER[1]))
mixer.selected_strip().set_send_controls(tuple(send_faders))
mixer.set_prehear_volume_control(
EncoderElement(MIDI_CC_TYPE, CHANNEL, KMK_FADER[6],
Live.MidiMap.MapMode.absolute))
mixer.master_strip().set_volume_control(
SliderElement(MIDI_CC_TYPE, CHANNEL, KMK_FADER[7]))
return mixer
def _setup_device_and_transport_control(self):
is_momentary = True
device_param_controls = []
for index in range(8):
device_param_controls.append(
EncoderElement(MIDI_CC_TYPE, 15, 62 - index,
Live.MidiMap.MapMode.absolute))
device = SpecialDeviceComponent()
device.set_bank_nav_buttons(
ButtonElement(is_momentary, MIDI_CC_TYPE, 15, 107),
ButtonElement(is_momentary, MIDI_CC_TYPE, 15, 106))
device.set_parameter_controls(tuple(device_param_controls))
self.set_device_component(device)
transport = SpecialTransportComponent()
transport.set_play_button(
ButtonElement(is_momentary, MIDI_CC_TYPE, 15, 20))
transport.set_stop_button(
ButtonElement(is_momentary, MIDI_CC_TYPE, 15, 21))
transport.set_record_button(
ButtonElement(is_momentary, MIDI_CC_TYPE, 15, 22))
transport.set_seek_buttons(
ButtonElement(is_momentary, MIDI_CC_TYPE, 15, 24),
ButtonElement(is_momentary, MIDI_CC_TYPE, 15, 25))
transport.set_tap_tempo_button(
ButtonElement(is_momentary, MIDI_CC_TYPE, 15, 94))
transport.set_undo_button(
ButtonElement(is_momentary, MIDI_CC_TYPE, 15, 23))
transport.set_redo_button(
ButtonElement(is_momentary, MIDI_CC_TYPE, 15, 27))
transport.set_bts_button(
ButtonElement(is_momentary, MIDI_CC_TYPE, 15, 26))
def _setup_controls( self ): self._log( "_setup_controls", True ) self._track_offset = EncoderElement( MIDI_CC_TYPE, 15, 118, Live.MidiMap.MapMode.absolute ) self._track_offset.value = 0 self._track_offset.name = "Track_Offset" self._scene_offset = EncoderElement( MIDI_CC_TYPE, 15, 119, Live.MidiMap.MapMode.absolute ) self._scene_offset.value = 0 self._scene_offset.name = "Scene_Offset" self._session_width = EncoderElement( MIDI_CC_TYPE, 15, 120, Live.MidiMap.MapMode.absolute ) self._session_width.value = 0 self._session_width.name = "Session_Height" self._session_height = EncoderElement( MIDI_CC_TYPE, 15, 121, Live.MidiMap.MapMode.absolute ) self._session_height.value = 0 self._session_height.name = "Session_Width" self.touchAble.request_rebuild_midi_map() self._log( "_setup_controls complete", True )
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 _create_controls(self):
make_color_button = partial(make_button, skin=self._skin)
self._shift_button = make_button(0, 81, name='Shift_Button')
self._matrix = ButtonMatrixElement(name='Button_Matrix')
self._scene_launch_buttons = [ make_color_button(0, index + 82, name='Scene_%d_Launch_Button' % index) for index in xrange(SESSION_HEIGHT) ]
self._track_stop_buttons = [ make_color_button(index, 52, name='Track_%d_Stop_Button' % index) for index in xrange(SESSION_WIDTH) ]
for scene_index in xrange(SESSION_HEIGHT):
row = [ make_color_button(track_index, scene_index + 53, name='%d_Clip_%d_Button' % (track_index, scene_index)) for track_index in xrange(SESSION_WIDTH) ]
self._matrix.add_row(row)
self._selected_scene_launch_button = make_pedal_button(64, name='Selected_Scene_Launch_Button')
self._scene_launch_buttons = ButtonMatrixElement(name='Scene_Launch_Buttons', rows=[self._scene_launch_buttons])
self._solo_buttons = [ make_button(track_index, 49, name='%d_Solo_Button' % track_index) for track_index in xrange(MIXER_SIZE) ]
self._mute_buttons = [ make_button(track_index, 50, name='%d_Mute_Button' % track_index) for track_index in xrange(MIXER_SIZE) ]
self._master_volume_control = make_slider(0, 14, name='Master_Volume_Control')
self._prehear_control = EncoderElement(MIDI_CC_TYPE, 0, 47, MapMode.relative_two_compliment, name='Prehear_Volume_Control')
self._master_select_button = make_button(0, 80, name='Master_Select_Button')
self._select_buttons = [ make_button(track_index, 51, name='%d_Select_Button' % track_index) for track_index in xrange(8) ]
self._arm_buttons = [ make_button(track_index, 48, name='%d_Arm_Button' % track_index) for track_index in xrange(8) ]
self._sliders = [ make_slider(track_index, 7, name='%d_Volume_Control' % track_index) for track_index in xrange(8) ]
self._note_matrix = ButtonMatrixElement(name='Note_Button_Matrix')
self._note_buttons = [ [ make_button(9, note + i, name='Note_%d_Button' % (note + i)) for i in xrange(4) ] for note in xrange(36, 75, 4) ]
for row in self._note_buttons:
for button in row:
button.send_depends_on_forwarding = False
self._note_matrix.add_row(row)
def make_encoder(channel, cc, name):
map_mode = Live.MidiMap.MapMode.absolute
return EncoderElement(MIDI_CC_TYPE,
channel,
cc,
map_mode=map_mode,
name=name)
def _setup_mixer_control(self): is_momentary = True # We use non-latching buttons (keys) throughout, so we'll set this as a constant num_tracks = 4 # Here we define the mixer width in tracks (a mixer has only one dimension) global mixer # We want to instantiate the global mixer as a MixerComponent object (it was a global "None" type up until now...) mixer = MixerComponent(num_tracks, 2, with_eqs=True, with_filters=False) #(num_tracks, num_returns, with_eqs, with_filters) mixer.set_track_offset(0) #Sets start point for mixer strip (offset from left) """set up the mixer buttons""" self.song().view.selected_track = mixer.channel_strip(0)._track #mute_notes = [1,5,9,13] #solo_notes = [2,6,10,14] #arm_notes = [3,7,11,15] track_select_notes = [38,39,40,41]#more note numbers need to be added if num_scenes is increased send_ccs = [2,6,10,14,1,5,9,13] pan_ccs = [3,7,11,15] slider_ccs = [4,8,12,16] for index in range(num_tracks): mixer.channel_strip(index).set_select_button(ButtonElement(is_momentary, MIDI_NOTE_TYPE, CHAN, track_select_notes[index])) mixer.channel_strip(index).set_volume_control(SliderElement(MIDI_CC_TYPE, CHAN, slider_ccs[index])) mixer.channel_strip(index).set_pan_control(EncoderElement(MIDI_CC_TYPE, CHAN, pan_ccs[index], Live.MidiMap.MapMode.absolute)) #put send A and send B controllers into an array, which is then "tupled" for set_send_controls: send_controlers = [EncoderElement(MIDI_CC_TYPE, CHAN, send_ccs[index], Live.MidiMap.MapMode.absolute), EncoderElement(MIDI_CC_TYPE, CHAN, send_ccs[index+num_tracks], Live.MidiMap.MapMode.absolute)] mixer.channel_strip(index).set_send_controls(tuple(send_controlers)) crossfader = SliderElement(MIDI_CC_TYPE, CHAN, 28) master_volume_control = SliderElement(MIDI_CC_TYPE, CHAN, 32) returna_pan_control = SliderElement(MIDI_CC_TYPE, CHAN, 19) returna_volume_control = SliderElement(MIDI_CC_TYPE, CHAN, 20) returnb_pan_control = SliderElement(MIDI_CC_TYPE, CHAN, 23) returnb_volume_control = SliderElement(MIDI_CC_TYPE, CHAN, 24) master_select_button = ButtonElement(is_momentary, MIDI_NOTE_TYPE, CHAN, 31) prehear_control = EncoderElement(MIDI_CC_TYPE, CHAN, 30, Live.MidiMap.MapMode.absolute) crossfader.name = 'Crossfader' master_volume_control.name = 'Master_Volume_Control' returna_pan_control.name = 'ReturnA_Pan_Control' returna_volume_control.name = 'ReturnA_Volume_Control' returnb_pan_control.name = 'ReturnB_Pan_Control' returnb_volume_control.name = 'ReturnB_Volume_Control' master_select_button.name = 'Master_Select_Button' prehear_control.name = 'Prehear_Volume_Control' mixer.set_crossfader_control(crossfader) mixer.master_strip().set_volume_control(master_volume_control) mixer.master_strip().set_select_button(master_select_button) mixer.set_prehear_volume_control(prehear_control) mixer.return_strip(0).set_pan_control(returna_pan_control) mixer.return_strip(0).set_volume_control(returna_volume_control) mixer.return_strip(1).set_pan_control(returnb_pan_control) mixer.return_strip(1).set_volume_control(returnb_volume_control)
def _create_controls(self):
self._device_controls = 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, col + 36 + 8 * row, name='Pad_%d_%d' % (col, row)) for col in xrange(8) ] for row in xrange(2) ])
def _setup_controls(self): is_momentary = True self._encoder = [None for index in range(32)] self._encoder_button = [None for index in range(32)] self._button = [None for index in range(13)] for index in range(32): self._encoder[index] = EncoderElement(MIDI_CC_TYPE, CHANNEL, CODE_ENC[index], Live.MidiMap.MapMode.absolute) self._encoder[index].name = 'enc[' + str(index) + ']' for index in range(32): self._encoder_button[index] = ButtonElement(is_momentary, MIDI_NOTE_TYPE, CHANNEL, CODE_ENCBTN[index]) self._encoder_button[index].name = 'encbtn[' + str(index) + ']' for index in range(13): self._button[index] = ButtonElement(is_momentary, MIDI_NOTE_TYPE, CHANNEL, CODE_BTN[index]) self._button[index].name = 'btn[' + str(index) + ']' for index in range(32): self._encoder[index] = EncoderElement(MIDI_CC_TYPE, CHANNEL, CODE_ENCRING[index], Live.MidiMap.MapMode.absolute) self._encoder[index].name = 'encring[' + str(index) + ']'
def _setup_mixer_control(self): is_momentary = True self._mixer = SpecialMixerComponent(8) self._mixer.name = 'Mixer' self._mixer.master_strip().name = 'Master_Channel_Strip' self._mixer.selected_strip().name = 'Selected_Channel_Strip' self._solo_buttons = [] # added a self._select_buttons = [] # added a for track in range(8): strip = self._mixer.channel_strip(track) strip.name = 'Channel_Strip_' + str(track) volume_control = EncoderElement(MIDI_CC_TYPE, track, 7, Live.MidiMap.MapMode.absolute) # 'Slider_' + str(track), track, self) arm_button = ButtonElement(is_momentary, MIDI_NOTE_TYPE, track, 48) solo_button = AumPCMonoButtonElement(is_momentary, MIDI_NOTE_TYPE, track, 50, str(track) + '_Solo_Button', self) self._solo_buttons.append(solo_button) # added a mute_button = ButtonElement(is_momentary, MIDI_NOTE_TYPE, track, 49) select_button = AumPCMonoButtonElement(is_momentary, MIDI_NOTE_TYPE, track, 51, str(track) + '_Select_Button', self) self._select_buttons.append(select_button) # added a #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' strip.set_volume_control(volume_control) strip.set_arm_button(arm_button) strip.set_solo_button(solo_button) strip.set_mute_button(mute_button) strip.set_select_button(select_button) strip.set_shift_button(self._shift_button) strip.set_invert_mute_feedback(True) crossfader = SliderElement(MIDI_CC_TYPE, 0, 15) self._crossfader = crossfader self._crossfader.name = 'Crossfader' master_volume_control = SliderElement(MIDI_CC_TYPE, 0, 14) master_select_button = ButtonElement(is_momentary, MIDI_NOTE_TYPE, 0, 80) self._master_select_button = master_select_button 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' prehear_control.name = 'Prehear_Volume_Control' self._mixer.set_crossfader_control(crossfader) self._mixer.set_prehear_volume_control(prehear_control) self._mixer.master_strip().set_volume_control(master_volume_control) self._mixer.master_strip().set_select_button(master_select_button)
def __init__(self, msg_type, channel, identifier, map_mode, name, num, script): EncoderElement.__init__(self, msg_type, channel, identifier, map_mode) self._script = script self.name = name self.num = num self._parameter = None self._ring_mode = 0 self._ring_value = 0 self._raw_custom = None self._ring_custom = [[0, 0]] self._ring_green = 0 self._is_enabled = True #self._report_input = True #self._report_output = True self._paramter_lcd_name = ' ' self._parameter_last_value = None self._mapped_to_midi_velocity = False self.set_report_values(True, False)
def __init__(self, msg_type, channel, identifier, map_mode, session, transport, mixer, looper): EncoderElement.__init__(self, msg_type, channel, identifier, map_mode) self.set_report_values(True, True) self.session = session self.transport = transport self.mixer = mixer self.looper = looper self.mode = 0 self.nav_button = None self.scene_button = None self.library_button = None self.transport_button = None self.button1 = None self.button2 = None self.button3 = None self.button4 = None self.encoder_button = None self.null_button = ButtonElement(True, 0, channel,127)
def _update_send_index(self, sends_index):
for index in range(8):
self.send_controls = []
strip = self.channel_strip(index)
for i in range(12):
self.send_controls.append(None)
self.send_controls[sends_index] = EncoderElement(MIDI_CC_TYPE, CHANNEL, mixer_sendknob_cc[index],
Live.MidiMap.MapMode.absolute)
strip.set_send_controls(tuple(self.send_controls))
def __init__(self, msg_type, channel, identifier, map_mode, name, num, osc, osc_parameter, osc_name, script): EncoderElement.__init__(self, msg_type, channel, identifier, map_mode=Live.MidiMap.MapMode.absolute) self.name = name self.num = num self._parameter = None self._script = script self.osc = osc self.osc_parameter = osc_parameter self.osc_name = osc_name self._timer = 0 self._is_enabled = True self._report_input = True self._report_output = True self._paramter_lcd_name = ' ' self._parameter_last_value = None self._mapped_to_midi_velocity = False self._mapping_feedback_delay = 0 self._threshold = 10 self._script._monobridge._send_osc(self.osc, 0, True)
def _init_transport_component(self, transport_controls, global_channel, macro_map_mode):
is_momentary = True
if transport_controls:
transport = TransportComponent()
transport.name = 'Transport'
#THIS IS NEW STUFF
#if 'TEMPO' in transport_control.keys() and transport_controls['TEMPO'] in range(128):
tempo_slider = EncoderElement(MIDI_CC_TYPE, global_channel, 1, macro_map_mode)
tempo_slider.name = 'Tempo_Slider'
transport.set_tempo_control(tempo_slider)
#END NEW STUFF
if 'STOP' in transport_controls.keys() and transport_controls['STOP'] in range(128):
stop_button = ButtonElement(is_momentary, MIDI_CC_TYPE, global_channel, transport_controls['STOP'])
stop_button.name = 'Stop_Button'
transport.set_stop_button(stop_button)
if 'PLAY' in transport_controls.keys() and transport_controls['PLAY'] in range(128):
play_button = ButtonElement(is_momentary, MIDI_CC_TYPE, global_channel, transport_controls['PLAY'])
play_button.name = 'Play_Button'
transport.set_play_button(play_button)
if 'REC' in transport_controls.keys() and transport_controls['REC'] in range(128):
rec_button = ButtonElement(is_momentary, MIDI_CC_TYPE, global_channel, transport_controls['REC'])
rec_button.name = 'Record_Button'
transport.set_record_button(rec_button)
if 'LOOP' in transport_controls.keys() and transport_controls['LOOP'] in range(128):
loop_button = ButtonElement(is_momentary, MIDI_CC_TYPE, global_channel, transport_controls['LOOP'])
loop_button.name = 'Loop_Button'
transport.set_loop_button(loop_button)
ffwd_button = None
rwd_button = None
momentary_seek = 'NORELEASE' not in transport_controls.keys()
if 'FFWD' in transport_controls.keys() and transport_controls['FFWD'] in range(128):
ffwd_button = ButtonElement(momentary_seek, MIDI_CC_TYPE, global_channel, transport_controls['FFWD'])
ffwd_button.name = 'FFwd_Button'
if 'RWD' in transport_controls.keys() and transport_controls['RWD'] in range(128):
rwd_button = ButtonElement(momentary_seek, MIDI_CC_TYPE, global_channel, transport_controls['RWD'])
rwd_button.name = 'Rwd_Button'
transport.set_seek_buttons(ffwd_button, rwd_button)
def _setup_mixer_control(self):
is_momentary = True
self._mixer = SpecialMixerComponent(8)
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):
strip = self._mixer.channel_strip(track)
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"
strip.set_volume_control(volume_control)
strip.set_arm_button(arm_button)
strip.set_solo_button(solo_button)
strip.set_mute_button(mute_button)
strip.set_select_button(select_button)
strip.set_shift_button(self._shift_button)
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)
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"
prehear_control.name = "Prehear_Volume_Control"
self._mixer.set_crossfader_control(crossfader)
self._mixer.set_prehear_volume_control(prehear_control)
self._mixer.master_strip().set_volume_control(master_volume_control)
self._mixer.master_strip().set_select_button(master_select_button)
def init_session(self):
self.session = SessionComponent(self.num_tracks, 1)
self.session.name = 'Alias 8 Session'
self.session.update()
# Connect the encoder to track scroller.
def scroll_cb(value):
if value == 1:
self.session._horizontal_banking.scroll_down()
elif value == 127:
self.session._horizontal_banking.scroll_up()
self.track_encoder = EncoderElement(MIDI_CC_TYPE, 0, self.encoder,
Live.MidiMap.MapMode.absolute)
self.track_encoder.add_value_listener(scroll_cb)
def _load_MIDI_map(self):
is_momentary = True
rgb_skin = make_rgb_skin()
for note in range(128):
button = ButtonElement(is_momentary, MESSAGETYPE, BUTTONCHANNEL, note,)
button.name = 'Button Note_' + str(note)
button.is_rgb = True
self._note_map.append(button)
self._note_map.append(None) #add None to the end of the list, selectable with [-1]
for note in range(128):
clip_button = ColorButtonElement(self.log_message,is_momentary, MESSAGETYPE, BUTTONCHANNEL, note, skin = rgb_skin)
clip_button.name = 'Clip Note_' + str(note)
button.num_delayed_messages = 3
self._clip_map.append(clip_button)
self._clip_map.append(None) #add None
if MESSAGETYPE == MIDI_CC_TYPE and BUTTONCHANNEL == SLIDERCHANNEL:
for i in range(128):
self._ctrl_map.append(None)
self._enc_map.append(None)
else:
for ctrl in range(128):
control = SliderElement(MIDI_CC_TYPE, SLIDERCHANNEL, ctrl)
control.name = 'Ctrl_' + str(ctrl)
self._ctrl_map.append(control)
self._ctrl_map.append(None)
for enc in range(128):
encoder = EncoderElement(MIDI_CC_TYPE, SLIDERCHANNEL, enc, Live.MidiMap.MapMode.absolute)
encoder.name = "Encoder_" + str(enc)
self._enc_map.append(encoder)
self._enc_map.append(None)
self.log_message('Note Map: %s' % self._note_map)
self.log_message('Ctrl Map: %s' % self._ctrl_map)
self.log_message('Enc Map: %s' % self._enc_map)
def __init__(self, control_surface):
self.control_surface = control_surface
self.song = control_surface.song
self.view = control_surface.application().view # Live.Application.get_application().view
self.is_paused = False
for cc in (70, 86, 102):
encoder = EncoderElement(MIDI_CC_TYPE, settings.CHANNEL, cc, Live.MidiMap.MapMode.relative_two_compliment)
encoder.add_value_listener(self._undo_redo)
for cc in (71, 87, 103):
encoder = EncoderElement(MIDI_CC_TYPE, settings.CHANNEL, cc, Live.MidiMap.MapMode.relative_two_compliment)
encoder.add_value_listener(self._play_pause_stop)
def __init__(self, c_instance):
ControlSurface.__init__(self, c_instance)
with self.component_guard():
# Turn off rebuild MIDI map until after we're done setting up
self._set_suppress_rebuild_requests(True)
""" Call our setup functions """
# Setup the transport part
self._setup_transport_control()
# Setup the mixer part
self._setup_mixer_control()
# Setup the session part
self._setup_session_control()
# Track navigation
#self._setup_track_navigation_control()
#link the session model to the Live object-> shows your ring
self.set_highlighting_session_component(session)
# Device component control (effect rack)
self._setup_device_control()
""" Here is some Live API stuff just for fun """
app = Live.Application.get_application() # get a handle to the App
maj = app.get_major_version() # get the major version from the App
min = app.get_minor_version() # get the minor version from the App
bug = app.get_bugfix_version() # get the bugfix version from the App
self.show_message("Loading nanoKONTROL for Live " + str(maj) + "." + str(min) + "." + str(
bug)) # put them together and use the ControlSurface show_message method to output version info to console on the status bar of Live
""" Listener for midi input """
self.encoder_test_input=EncoderElement(MIDI_CC_TYPE, midi_channel, 94, Live.MidiMap.MapMode.relative_smooth_two_compliment) # identifies P&d1 as a ButtonElement. IS_MOMENTARY is true if the button send a message on being released
self.encoder_test_input.add_value_listener(self._encoder_test_input, identify_sender= False) #adda value listener that will lauch the method self.helloworld when Pad1 is pressed
# Turn rebuild back on, now that we're done setting up
self._set_suppress_rebuild_requests(False)
def connect_to(self, parameter):
if parameter != self._parameter_to_map_to and not self.is_mapped_manually():
force_send = True
self._ring_mode_button.send_value(RING_OFF_VALUE, force_send)
EncoderElement.connect_to(self, parameter)
def disconnect(self): self.remove_parameter_listener(self._parameter) EncoderElement.disconnect(self)
def release_parameter(self):
EncoderElement.release_parameter(self)
self._update_ring_mode()
def __init__(self, c_instance):
ControlSurface.__init__(self, c_instance)
with self.component_guard(): # this line allows you to instanciate framework classes
is_momentary = True # all our controlls will be momentary
self._suggested_input_port = 'px700'
self._suggested_output_port = 'px700'
"definition of buttons represented by the keyboard notes"
launch_buttons = [] # row of buttons launching the clips of a track
for index in range(16):
button = ConfigurableButtonElement(is_momentary, MIDI_NOTE_TYPE, 0, index)
button.name = '_Clip_' + str(index) + '_Button'
launch_buttons.append(button)
"buttons A, B, C, D are the buttons choosing he mode"
mode_buttons = [ ConfigurableButtonElement(is_momentary, MIDI_NOTE_TYPE, 0, 16+index) for index in range(4) ]
mode_buttons[0].name = 'A_mode'
mode_buttons[1].name = 'B_mode'
mode_buttons[2].name = 'C_mode'
mode_buttons[3].name = 'D_mode'
"pad controls definition"
select_button = ConfigurableButtonElement(is_momentary, MIDI_NOTE_TYPE, 0, 20)
select_button.name = '_Select_Button'
translate_button = ConfigurableButtonElement(is_momentary, MIDI_NOTE_TYPE, 0, 21)
translate_button.name = '_Translate_Button'
mute_button = ConfigurableButtonElement(is_momentary, MIDI_NOTE_TYPE, 0, 22)
mute_button.name = '_Mute_Button'
solo_button = ConfigurableButtonElement(is_momentary, MIDI_NOTE_TYPE, 0, 23)
solo_button.name = '_Solo_Button'
copy_button = ConfigurableButtonElement(is_momentary, MIDI_NOTE_TYPE, 0, 28)
copy_button.name = '_Copy_Button'
erase_button = ConfigurableButtonElement(is_momentary, MIDI_NOTE_TYPE, 0, 29)
erase_button.name = '_Erase_Button'
rewind_button = ConfigurableButtonElement(is_momentary, MIDI_NOTE_TYPE, 0, 36)
rewind_button.name = '_Rewind_Button'
forward_button = ConfigurableButtonElement(is_momentary, MIDI_NOTE_TYPE, 0, 37)
forward_button.name = '_Forward_Button'
"pads definition"
pads = []
for index in range(8):
pad = ConfigurableButtonElement(is_momentary, MIDI_NOTE_TYPE, 0, 60+index)
pad.name = '_Clip_' + str(index) + '_Button'
pads.append(pad)
"transport buttons"
transport_buttons = []
for index in range(4):
button = ConfigurableButtonElement(is_momentary, MIDI_NOTE_TYPE, 0, 24+index)
button.name = '_Transport_Button_'+str(index)
transport_buttons.append(button)
"knobs definition"
tempo_control = EncoderElement(MIDI_CC_TYPE, 0, 48, Live.MidiMap.MapMode.relative_binary_offset)
tempo_control.name = "_Tempo_controller_"
volume_control = EncoderElement(MIDI_CC_TYPE, 0, 47, Live.MidiMap.MapMode.relative_binary_offset)
tempo_control.name = "_Volume_controller_"
param_controls = []
for index in range(3):
control = EncoderElement(MIDI_CC_TYPE, 0, 49+index, Live.MidiMap.MapMode.relative_binary_offset)
control.name = "_Param_"+str(index)+"_control"
param_controls.append(control)
"browser knob definition"
browser_control = EncoderElement(MIDI_CC_TYPE, 0, 54, Live.MidiMap.MapMode.relative_binary_offset)
browser_control.name = "_Browser_controller_"
"browser button definition"
browser_button = ConfigurableButtonElement(is_momentary, MIDI_NOTE_TYPE, 0, 56)
browser_button.name = "_Browser_button_"
"pattern leds definition"
pattern_leds = []
for index in range(4):
led = ConfigurableButtonElement(is_momentary, MIDI_NOTE_TYPE, 0, 41+index)
led.name = str(index) + 'Pattern_Led'
pattern_leds.append(led)
"divide knob definition"
divide_control = EncoderElement(MIDI_CC_TYPE, 0, 52, Live.MidiMap.MapMode.relative_binary_offset)
divide_control.name = "_divide_controller_"
"move knob definition"
move_control = EncoderElement(MIDI_CC_TYPE, 0, 53, Live.MidiMap.MapMode.relative_binary_offset)
move_control.name = "_move_controller_"
"track leds definition"
track_leds = []
for index in range(8):
led = ConfigurableButtonElement(is_momentary, MIDI_NOTE_TYPE, 0, 68+index)
led.name = str(index) + 'Track_Led'
track_leds.append(led)
self._selector = MainSelectorComponent(tuple(launch_buttons), tuple(mode_buttons), tuple(pads), tuple(transport_buttons), select_button, translate_button, mute_button, solo_button, tempo_control, volume_control, tuple(param_controls), copy_button, erase_button, rewind_button, forward_button, browser_control, browser_button, tuple(pattern_leds), tuple(track_leds), divide_control, move_control, self)
self._selector.name = 'Main_Modes'
self.set_highlighting_session_component(self._selector._session)
self.log_message("SparkLE Loaded !")
def _init_mixer_component(self, volume_controls, trackarm_controls, mixer_options, global_channel, volume_map_mode):
if volume_controls != None and trackarm_controls != None:
num_strips = max(len(volume_controls), len(trackarm_controls))
send_info = []
momentary_buttons = False
mixer = SpecialMixerComponent(num_strips)
mixer.name = 'Mixer'
mixer.master_strip().name = 'Master_Channel_Strip'
mixer.selected_strip().name = 'Selected_Channel_Strip'
if mixer_options != None:
if 'MASTERVOLUME' in mixer_options.keys() and mixer_options['MASTERVOLUME'] in range(128):
encoder = EncoderElement(MIDI_CC_TYPE, global_channel, mixer_options['MASTERVOLUME'], volume_map_mode)
encoder.name = 'Master_Volume_Control'
mixer.master_strip().set_volume_control(encoder)
if 'NUMSENDS' in mixer_options.keys() and mixer_options['NUMSENDS'] > 0:
for send in range(mixer_options['NUMSENDS']):
key = 'SEND' + str(send + 1)
raise key in mixer_options.keys() or AssertionError
send_info.append(mixer_options[key])
momentary_buttons = 'NOTOGGLE' in mixer_options.keys()
next_bank_button = None
prev_bank_button = None
if 'NEXTBANK' in mixer_options.keys() and mixer_options['NEXTBANK'] in range(128):
next_bank_button = ButtonElement(momentary_buttons, MIDI_CC_TYPE, global_channel, mixer_options['NEXTBANK'])
next_bank_button.name = 'Mixer_Next_Bank_Button'
if 'PREVBANK' in mixer_options.keys() and mixer_options['PREVBANK'] in range(128):
prev_bank_button = ButtonElement(momentary_buttons, MIDI_CC_TYPE, global_channel, mixer_options['PREVBANK'])
prev_bank_button.name = 'Mixer_Previous_Bank_Button'
mixer.set_bank_buttons(next_bank_button, prev_bank_button)
for track in range(num_strips):
strip = mixer.channel_strip(track)
strip.name = 'Channel_Strip_' + str(track)
if track in range(len(volume_controls)):
channel = global_channel
cc = volume_controls[track]
if isinstance(volume_controls[track], (tuple, list)):
cc = volume_controls[track][0]
if volume_controls[track][1] in range(16):
channel = volume_controls[track][1]
if cc in range(128) and channel in range(16):
encoder = EncoderElement(MIDI_CC_TYPE, channel, cc, volume_map_mode)
encoder.name = str(track) + '_Volume_Control'
strip.set_volume_control(encoder)
if track in range(len(trackarm_controls)) and trackarm_controls[track] in range(128):
button = ButtonElement(momentary_buttons, MIDI_CC_TYPE, global_channel, trackarm_controls[track])
button.name = str(track) + '_Arm_Button'
strip.set_arm_button(button)
send_controls = []
for send in send_info:
encoder = None
if track in range(len(send)):
channel = global_channel
cc = send[track]
if isinstance(send[track], (tuple, list)):
cc = send[track][0]
if send[track][1] in range(16):
channel = send[track][1]
if cc in range(128) and channel in range(16):
encoder = EncoderElement(MIDI_CC_TYPE, channel, cc, volume_map_mode)
encoder.name = str(track) + '_Send_' + str(list(send_info).index(send)) + '_Control'
send_controls.append(encoder)
strip.set_send_controls(tuple(send_controls))
def make_encoder(cc_no, name):
encoder = EncoderElement(MIDI_CC_TYPE, 0, cc_no, Live.MidiMap.MapMode.absolute)
encoder.set_feedback_delay(-1)
encoder.name = name
return encoder
def __init__(self, msg_type, channel, identifier, map_mode):
EncoderElement.__init__(self, msg_type, channel, identifier, map_mode)
self._peek_mode = False
