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, 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)
class HyperionChan(CompoundComponent):
def __init__(self, hyperion, mod_num, *a, **kw):
super(HyperionChan, self).__init__(*a, **kw)
self.hyperion = hyperion
self.mod_num = mod_num
self._track_selector_encoder = EncoderElement(MIDI_CC_TYPE, MIDI_MASTER_CH + 1 + mod_num, 0x15, Live.MidiMap.MapMode.relative_smooth_binary_offset) # Right encoder on Hyperion
self._track_selector_encoder.add_value_listener(self._on_track_selector_encoder)
self._fader = SliderElement(MIDI_CC_TYPE, MIDI_MASTER_CH + 1 + mod_num, 0x25)
self._pots = [
EncoderElement(MIDI_CC_TYPE, MIDI_MASTER_CH + 1 + mod_num, 0x1E + num, Live.MidiMap.MapMode.absolute, name='Pot{}'.format(num))
for num in range(8)
]
self._btns = [
ButtonElement(True, MIDI_CC_TYPE, MIDI_MASTER_CH + 1 + mod_num, 1 + num, name='Btn{}'.format(num))
for num in range(8)
]
self._enc_right_btn = ButtonElement(True, MIDI_CC_TYPE, MIDI_MASTER_CH + 1 + mod_num, 10, name='EncRightBtn')
self._enc_right_btn.add_value_listener(self._on_enc_right_btn)
#self._cs = ChannelStripComponent()
#self._cs.set_volume_control(self._fader)
self._vu_slider = SliderElement(MIDI_CC_TYPE, MIDI_MASTER_CH + 1 + mod_num, 60)
self._vu = VUMeter(self)
self._track = None
tracks = self._get_all_tracks(self.hyperion.song().tracks)
if len(tracks) > self.mod_num:
self._bind_to_track(tracks[self.mod_num])
else:
self._bind_to_track(None)
def log(self, msg, *args):
self.hyperion.log_message(('HyperionChan({}): ' + msg).format(self.mod_num, *args))
def disconnect(self):
super(HyperionChan, self).disconnect()
self._enc_right_btn.remove_value_listener(self._on_enc_right_btn)
def _get_parent_by_type(self, obj, parent_type):
if not obj.canonical_parent:
return
if isinstance(obj.canonical_parent, parent_type):
return obj.canonical_parent
return self._get_parent_by_type(obj.canonical_parent, parent_type)
def _on_enc_right_btn(self, value):
if value and self._track:
self.log('type {}',type(self._track))
song = self.hyperion.song()
if isinstance(self._track, Live.Track.Track):
song.view.selected_track = self._track
elif isinstance(self._track, Live.DrumChain.DrumChain):
parent_track = self._get_parent_by_type(self._track, Live.Track.Track)
song.view.selected_track = parent_track
try:
song.view.selected_chain = self._track
except:
try:
song.view.selected_track = parent_track
song.view.selected_chain = self._track.canonical_parent.canonical_parent
self._track.canonical_parent.view.selected_chain = self._track
except:
pass
def _get_track_mapper_device(self, track):
for device in track.devices:
if device.name == 'MultiMapper16 V2.0':
return device
def _get_all_tracks(self, all_tracks):
got_tracks = []
for cur_track in all_tracks:
if isinstance(cur_track, (Live.Track.Track, Live.DrumChain.DrumChain)):
got_tracks.append(cur_track)
devices = list(cur_track.devices)
if len(devices) and isinstance(devices[0], Live.RackDevice.RackDevice):
got_tracks.extend(self._get_all_tracks(devices[0].chains))
return [track for track in got_tracks if self._get_track_mapper_device(track)]
def _on_track_selector_encoder(self, value):
direction = 1 if value > 64 else -1
tracks = self._get_all_tracks(self.hyperion.song().tracks)
# for t in tracks:
# self.log('AAAAA {}', t.name)
try:
cur_track_idx = tracks.index(self._track)
except ValueError:
self.log('track disappeared :(')
self._bind_to_track(tracks[0])
else:
cur_track_idx += direction
if cur_track_idx == len(tracks):
cur_track_idx = 0
if cur_track_idx == -1:
cur_track_idx = len(tracks) - 1
self._bind_to_track(tracks[cur_track_idx])
def _bind_to_track(self, track):
if self._track:
#self._cs.set_track(None)
self._fader.release_parameter()
[pot.release_parameter() for pot in self._pots]
[btn.release_parameter() for btn in self._btns]
self._track.remove_name_listener(self._on_name_changed)
self._track = None
if not track:
return
self.log('binding to {}', track.name)
self._track = track
self._fader.connect_to(track.mixer_device.volume)
mapper_dev = self._get_track_mapper_device(track)
for num in range(8):
self._pots[num].connect_to(mapper_dev.parameters[3 + num]) # MacroA0 MacroA1 etc
self._btns[num].connect_to(mapper_dev.parameters[11 + num]) # MacroB0 MacroB1 etc
# self._cs.set_track(track)
if getattr(self._track, 'has_audio_output', False) and hasattr(self._track, 'add_output_meter_left_listener'):
self._vu.set_vu_meter(track, self._vu_slider)
else:
self._vu.set_vu_meter(None, None)
self._track.add_name_listener(self._on_name_changed)
self._on_name_changed()
def _on_name_changed(self):
self.hyperion.sysex.set_title(self.mod_num, self._track.name if self._track else '-')
class nanoKONTROL(ControlSurface):
__doc__ = " Initial script for Korg nanoKONTROL controller script "
__module__ = __name__
"""------------------------------------------------------------------------------------------"""
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)
""" Device control allow to control the audio effect rack for the selected track """
"""------------------------------------------------------------------------------------------"""
def _setup_device_control(self):
is_momentary = True
global device # We want to instantiate the global mixer as a MixerComponent object (it was a global "None" type up until now...)
device = DeviceComponent()
device.name = 'Audio Effect Rack'
# Button on/off
button_on_off = ButtonElement(is_momentary, MIDI_CC_TYPE, midi_channel, midi_device_on_off)
device.set_on_off_button(button_on_off)
# Audio Effect Rack - 8 modulation controls
device_parameter_controls = []
for index in range(8):
device_parameter_controls.append(EncoderElement(MIDI_CC_TYPE, midi_channel, midi_device_controls[index], Live.MidiMap.MapMode.absolute))
device.set_parameter_controls(device_parameter_controls)
self.set_device_component(device)
self._device_selection_follows_track_selection = True # select automatically the device of the selected track
""" Called on configured encoder input """
"""------------------------------------------------------------------------------------------"""
def _encoder_test_input(self, value):
self.show_message("Yeah ==> " + str(value) + " ! " + str(mixer.song().view.selected_track))
""" Initialisation of transport part """
"""------------------------------------------------------------------------------------------"""
def _setup_transport_control(self):
is_momentary = True
""" Instantiate a Transport Component """
transport = TransportComponent()
""" Buttons declaration """
button_play = ButtonElement(is_momentary, MIDI_CC_TYPE, midi_channel, midi_transport_play_button)
button_stop = ButtonElement(is_momentary, MIDI_CC_TYPE, midi_channel, midi_transport_stop_button)
button_record = ButtonElement(is_momentary, MIDI_CC_TYPE, midi_channel, midi_transport_record_button)
button_loop = ButtonElement(is_momentary, MIDI_CC_TYPE, midi_channel, midi_transport_loop_button)
button_seek_ffwd = ButtonElement(is_momentary, MIDI_CC_TYPE, midi_channel, midi_transport_seek_ffwd)
button_seek_rwd = ButtonElement(is_momentary, MIDI_CC_TYPE, midi_channel, midi_transport_seek_rwd)
""" Buttons association """
transport.set_play_button(button_play)
transport.set_stop_button(button_stop)
transport.set_record_button(button_record)
transport.set_loop_button(button_loop)
transport.set_seek_buttons(button_seek_ffwd, button_seek_rwd)
""" Initialisation of mixer part """
"""------------------------------------------------------------------------------------------"""
def _setup_mixer_control(self):
is_momentary = True
""" Instantiate a Mixer Component """
global mixer # We want to instantiate the global mixer as a MixerComponent object (it was a global "None" type up until now...)
mixer = MixerComponent(mixer_num_tracks, 2, with_eqs=True, with_filters=True) # (num_tracks, num_returns, with_eqs, with_filters)
mixer.set_track_offset(0) # Sets start point for mixer strip (offset from left)
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
""" Buttons and Sliders association """
# Master channel
mixer.master_strip().set_volume_control(SliderElement(MIDI_CC_TYPE, midi_channel, midi_mixer_volume_master)) # sets the continuous controller for volume
# Other channels, same size as mixer_num_tracks
# Set volume control, solo and mute buttons
for index in range(mixer_num_tracks): # launch_button assignment must match number of scenes
mixer.channel_strip(index).set_volume_control(SliderElement(MIDI_CC_TYPE, midi_channel, midi_mixer_volume_channels[index])) # sets the continuous controller for volume
mixer.channel_strip(index).set_solo_button(ButtonElement(is_momentary, MIDI_CC_TYPE, midi_channel, midi_mixer_solo_channels[index])) # sets the solo button
mixer.channel_strip(index).set_mute_button(ButtonElement(is_momentary, MIDI_CC_TYPE, midi_channel, midi_mixer_mute_channels[index])) # sets the mute ("activate") button
""" Buttons to select track """
button_next_track = ButtonElement(is_momentary, MIDI_CC_TYPE, midi_channel, midi_track_select_next)
button_previous_track = ButtonElement(is_momentary, MIDI_CC_TYPE, midi_channel, midi_track_select_previous)
mixer.set_select_buttons(button_next_track, button_previous_track)
""" Listeners """
# When selected track if changed
self.song().view.add_selected_track_listener(self.on_track_selected)
""" Called when a track is changed """
"""------------------------------------------------------------------------------------------"""
def on_track_selected(self):
self.show_message("Track changed!")
""" Encoder for Sends controls on selected track """
'''encoder_test = EncoderElement(MIDI_CC_TYPE, midi_channel, 57, Live.MidiMap.MapMode.absolute)
encoder_test2 = EncoderElement(MIDI_CC_TYPE, midi_channel, 58, Live.MidiMap.MapMode.absolute)
encoder_send_buttons = []
encoder_send_buttons.append(encoder_test)
encoder_send_buttons.append(encoder_test2)
mixer.selected_strip().set_send_controls(encoder_send_buttons)'''
""" Initialisation of session part """
"""------------------------------------------------------------------------------------------"""
def _setup_session_control(self):
is_momentary = True
# Size of session box
num_tracks = 8 # column
num_scenes = 1 # row
""" Buttons declaration """
# Navigation
button_navig_up = ButtonElement(is_momentary, MIDI_CC_TYPE, midi_channel, midi_session_up)
button_navig_down = ButtonElement(is_momentary, MIDI_CC_TYPE, midi_channel, midi_session_down)
""" Declare our session box """
global session #We want to instantiate the global session as a SessionComponent object (it was a global "None" type up until now...)
session = SessionComponent(num_tracks, num_scenes) #(num_tracks, num_scenes) A session highlight ("red box") will appear with any two non-zero values
session.set_offsets(0, 0) #(track_offset, scene_offset) Sets the initial offset of the "red box" from top left
session._do_show_highlight() #to ensure that this session will be highlighted
""" Buttons association """
# Navigation up, down, left, right
session.set_scene_bank_buttons(button_navig_down, button_navig_up)
# Launch selected clip
for index in range(num_tracks):
session.scene(0).clip_slot(index).set_launch_button(ButtonElement(is_momentary, MIDI_CC_TYPE, midi_channel, midi_session_launch_clip[index]))
# Stop selected track
stop_track_buttons = []
for index in range(num_tracks):
stop_track_buttons.append(ButtonElement(is_momentary, MIDI_CC_TYPE, midi_channel, midi_session_stop_track[index]))
session.set_stop_track_clip_buttons(tuple(stop_track_buttons)) #array size needs to match num_tracks
"""------------------------------------------------------------------------------------------"""
def disconnect(self):
"""clean things up on disconnect"""
self.log_message(time.strftime("%d.%m.%Y %H:%M:%S", time.localtime()) + "--------------= nanoKONTROL log closed =--------------") # Create entry in log file
ControlSurface.disconnect(self)
return None
class OP1(ControlSurface):
def __init__(self, c_instance):
ControlSurface.__init__(self, c_instance)
with self.component_guard():
self.c_instance = c_instance
self.retries_count = 0
self.device_connected = False
self.clip_color_callbacks = {}
self.slot_callbacks = {}
self.text_start_sequence = (0xf0, 0x0, 0x20, 0x76, 0x00, 0x03)
self.text_end_sequence = (0xf7, )
self.enable_sequence = (0xf0, 0x00, 0x20, 0x76, 0x00, 0x01, 0x02,
0xf7)
self.disable_sequence = (0xf0, 0x00, 0x20, 0x76, 0x00, 0x01, 0x00,
0xf7)
self.id_sequence = (0xf0, 0x7e, 0x7f, 0x06, 0x01, 0xf7)
self.text_color_start_sequence = (0xf0, 0x0, 0x20, 0x76, 0x00,
0x04)
# self.log('INITIALIZING')
self.app = Live.Application.get_application()
#maj = self.app.get_major_version()
#min = self.app.get_minor_version()
#bug = self.app.get_bugfix_version()
#self.show_message(str(maj) + "." + str(min) + "." + str(bug))
self.show_message("Version: " + VERSION)
# reseting text
self.write_text(' ')
# reset display clips
self.reset_display_clips()
# getting browser visible state
self.session_browser_visible = self.app.view.is_view_visible(
"Browser")
# getting browser visible state
self.arrange_browser_visible = self.app.view.is_view_visible(
"Browser")
# getting session view visible state
self.session_visible = self.app.view.is_view_visible("Session")
# getting arrange view visible state
self.arrange_visible = self.app.view.is_view_visible("Arranger")
# getting detail view visible state
self.detail_visible = self.app.view.is_view_visible("Detail")
# getting back to arranger state
self.back_to_arranger_state = self.song().back_to_arranger
# initializing channel strip to null
self._channel_strip = None
# initializing mixer component
self._mixer = MixerComponent(NUM_TRACKS, 2)
# initializing session component
self._session = SessionComponent(NUM_TRACKS, NUM_ROWS)
self._session.add_offset_listener(self.session_offset_changed)
self.set_highlighting_session_component(self._session)
self._suppress_session_highlight = False
# initializing transport component
self._transport = TransportComponent()
# configuring operation mode selector buttons
self._operation_mode_buttons = ButtonElement(
True, MIDI_CC_TYPE, CHANNEL, OP1_MODE_1_BUTTON), ButtonElement(
True, MIDI_CC_TYPE,
CHANNEL, OP1_MODE_2_BUTTON), ButtonElement(
True, MIDI_CC_TYPE, CHANNEL,
OP1_MODE_3_BUTTON), ButtonElement(
True, MIDI_CC_TYPE, CHANNEL, OP1_MODE_4_BUTTON),
# initializing operation mode selector
self._operation_mode_selector = OP1ModeSelectorComponent(
self, self._transport, self._mixer, self._session)
# setting operation mode selector buttons
self._operation_mode_selector.set_mode_buttons(
self._operation_mode_buttons)
# adding value listener for operation mode index
self._operation_mode_selector.add_mode_index_listener(
self.mode_index_changed)
# setting global transport assignments
self._transport.set_record_button(
ButtonElement(True, MIDI_CC_TYPE, CHANNEL, OP1_REC_BUTTON))
self._transport.set_stop_button(
ButtonElement(True, MIDI_CC_TYPE, CHANNEL, OP1_STOP_BUTTON))
self._transport.set_metronome_button(
ButtonElement(True, MIDI_CC_TYPE, CHANNEL,
OP1_METRONOME_BUTTON))
self._transport.set_tap_tempo_button(
ButtonElement(True, MIDI_CC_TYPE, CHANNEL, OP1_HELP_BUTTON))
# self._transport.set_punch_buttons(ButtonElement(True, MIDI_CC_TYPE, CHANNEL, OP1_SS1_BUTTON), ButtonElement(True,MIDI_CC_TYPE, CHANNEL, OP1_SS2_BUTTON))
self._transport.set_loop_button(
ButtonElement(True, MIDI_CC_TYPE, CHANNEL, OP1_SS3_BUTTON))
self._transport.set_overdub_button(
ButtonElement(True, MIDI_CC_TYPE, CHANNEL, OP1_SS4_BUTTON))
self._play_button = ButtonElement(True, MIDI_CC_TYPE, CHANNEL,
OP1_PLAY_BUTTON)
# self._transport.set_play_button(self._play_button)
self.shift_pressed = False
self._play_button.add_value_listener(self.play_button_callback)
# setting global session assignments
self._session.set_scene_bank_buttons(
ButtonElement(True, MIDI_CC_TYPE, CHANNEL, OP1_COM),
ButtonElement(True, MIDI_CC_TYPE, CHANNEL, OP1_MICRO))
# encoder for transport control - leave it empty for now
self._encoder_1 = EncoderElement(
MIDI_CC_TYPE, CHANNEL, OP1_ENCODER_1,
Live.MidiMap.MapMode.relative_two_compliment)
self._encoder_2 = EncoderElement(
MIDI_CC_TYPE, CHANNEL, OP1_ENCODER_2,
Live.MidiMap.MapMode.relative_two_compliment)
self._encoder_3 = EncoderElement(
MIDI_CC_TYPE, CHANNEL, OP1_ENCODER_3,
Live.MidiMap.MapMode.relative_two_compliment)
self._encoder_4 = EncoderElement(
MIDI_CC_TYPE, CHANNEL, OP1_ENCODER_4,
Live.MidiMap.MapMode.relative_two_compliment)
# setting misc listeners
self._encoder_1_push = ButtonElement(True, MIDI_CC_TYPE, CHANNEL,
OP1_ENCODER_1_PUSH)
self._encoder_2_push = ButtonElement(True, MIDI_CC_TYPE, CHANNEL,
OP1_ENCODER_2_PUSH)
self._encoder_3_push = ButtonElement(True, MIDI_CC_TYPE, CHANNEL,
OP1_ENCODER_3_PUSH)
self._encoder_4_push = ButtonElement(True, MIDI_CC_TYPE, CHANNEL,
OP1_ENCODER_4_PUSH)
self._encoder_3_push.add_value_listener(self.e3_push_callback)
self._e3_pressed = False
self.mainview_toggle_button = ButtonElement(
False, MIDI_CC_TYPE, CHANNEL, OP1_ARROW_DOWN_BUTTON)
self.mainview_toggle_button.add_value_listener(
self.mainview_toggle_button_callback)
self.detailview_toggle_button = ButtonElement(
False, MIDI_CC_TYPE, CHANNEL, OP1_SCISSOR_BUTTON)
self.detailview_toggle_button.add_value_listener(
self.detailview_toggle_button_callback)
self.clear_track_button = ButtonElement(True, MIDI_CC_TYPE,
CHANNEL, OP1_SS8_BUTTON)
self.clear_track_button.add_value_listener(
self.clear_track_button_callback)
self.back_to_arranger_button = ButtonElement(
True, MIDI_CC_TYPE, CHANNEL, OP1_SEQ_BUTTON)
self.back_to_arranger_button.add_value_listener(
self.back_to_arranger_button_callback)
# adding value listener for selected track change
self.song().view.add_selected_track_listener(
self.selected_track_changed)
# adding value listener for selected scene change
self.song().view.add_selected_scene_listener(
self.selected_scene_changed)
# setting assignments for currently selected track
self.selected_track_changed()
# setting assignments for currently selected scene
self.selected_scene_changed()
def handle_sysex(self, midi_bytes):
if ((midi_bytes[6] == 32) and (midi_bytes[7] == 118)):
self.device_connected = True
self.log("OP-1 CONNECTED. SENDING ABLETON LIVE MODE INIT SEQUENCE")
self._send_midi(self.enable_sequence)
def add_clip_slot_listeners(self):
#self.log('ADDING CLIP SLOT LISTENERS')
# creating an empty list for all clip slots
clip_slots = []
# getting a reference to all tracks
tracks = self.song().tracks
# appending all tracks clip slots to clip_slots
for track in tracks:
clip_slots.append(track.clip_slots)
# iterating over all clip slots
for t in range(len(clip_slots)):
for c in range(len(clip_slots[t])):
clip_slot = clip_slots[t][c]
# adding has clip listener to clip slot
self.add_slot_listener(clip_slot)
# if clip slot has clip
if clip_slot.has_clip:
# adding clip listeners
self.add_clip_listener(clip_slot.clip)
def rem_clip_slot_listeners(self):
#self.log('REMOVING CLIP SLOT LISTENERS')
# iterate over all clip color change callbacks
for c in self.clip_color_callbacks:
# if clip still exists
if c != None:
# and it has a has clip listener
if c.color_has_listener(self.clip_color_callbacks[c]) == 1:
# remove it
c.remove_color_listener(self.clip_color_callbacks[c])
# iterate over all clip slot callbacks
for cs in self.slot_callbacks:
# if clip slot still exists
if cs != None:
# and it has a has clip listener
if cs.has_clip_has_listener(self.slot_callbacks[cs]) == 1:
# remove it
cs.remove_has_clip_listener(self.slot_callbacks[cs])
def add_slot_listener(self, cs):
# setting has clip listener
callback = lambda: self.has_clip_listener(cs)
# if we don't have a clip slot has clip listener for this clip slot yet
if not (self.slot_callbacks.has_key(cs)):
# adding has clip callback to clip slot
cs.add_has_clip_listener(callback)
# saving callback for future release
self.slot_callbacks[cs] = callback
def add_clip_listener(self, clip):
# setting callback for clip color change
color_callback = lambda: self.update_display_clips()
# if we don't have a clip color change callback for this clip yet
if not (self.clip_color_callbacks.has_key(clip)):
# adding clip color change callback
clip.add_color_listener(color_callback)
# saving callback for future release
self.clip_color_callbacks[clip] = color_callback
def has_clip_listener(self, cs):
# clip slot has clip listener callback
if cs.has_clip:
# add clip listener
self.add_clip_listener(cs.clip)
else:
# update display if clip slot was removed
self.update_display_clips()
def session_offset_changed(self):
# if session component offset changes, update display
self.update_display_clips()
def selected_scene_changed(self):
# if on clip mode update display
if (self._operation_mode_selector.mode_index == OP1_MODE_CLIP):
self.update_display_clip_mode()
def e3_push_callback(self, value):
self._e3_pressed = True if value == 127 else False
def e1_transport_scrub(self, value):
if value == 4:
self.song().scrub_by(1)
else:
self.song().scrub_by(-1)
def e2_transport_scrub(self, value):
if value == 4:
x = 1
else:
x = -1
idx = get_q_idx(self.song().clip_trigger_quantization)
self.song().clip_trigger_quantization = get_q_enum(idx + x)
def e_transport_scroll(self, value, b):
if value == 4:
x = Live.Application.Application.View.NavDirection.right
else:
x = Live.Application.Application.View.NavDirection.left
self.app.view.scroll_view(x, "Arranger", b)
def e3_transport_scroll(self, value):
self.e_transport_scroll(value, self._e3_pressed)
def play_button_callback(self, value):
if self.shift_pressed == True:
self.song().play_selection()
else:
self.song().start_playing()
def mode_index_changed(self):
# update display to current mode info
self._encoder_1.remove_value_listener(self.e1_transport_scrub)
self._encoder_2.remove_value_listener(self.e2_transport_scrub)
self._encoder_3.remove_value_listener(self.e3_transport_scroll)
if (self._operation_mode_selector.mode_index == OP1_MODE_PERFORM):
self.update_display_perform_mode()
elif (self._operation_mode_selector.mode_index == OP1_MODE_CLIP):
self.update_display_clip_mode()
elif (self._operation_mode_selector.mode_index == OP1_MODE_TRANSPORT):
self.update_display_transport_mode()
self.clear_tracks_assigments()
self._encoder_1.add_value_listener(self.e1_transport_scrub)
self._encoder_2.add_value_listener(self.e2_transport_scrub)
self._encoder_3.add_value_listener(self.e3_transport_scroll)
elif (self._operation_mode_selector.mode_index == OP1_MODE_MIXER):
self.update_display_mixer_mode()
def clear_track_button_callback(self, value):
# if clear track button was called, reset track
if (value == 127):
for i in range(len(self.song().tracks)):
self.song().tracks[i].arm = 0
self.song().tracks[i].solo = 0
self.song().tracks[i].mute = 0
for i in range(len(self.song().return_tracks)):
self.song().tracks[i].solo = 0
self.song().tracks[i].mute = 0
def clear_return_track_assignment(self, strip):
# clear return track assingments
strip.set_volume_control(None)
strip.set_pan_control(None)
strip.set_mute_button(None)
strip.set_solo_button(None)
def clear_track_assignment(self, strip):
# clear track assignments
strip.set_volume_control(None)
strip.set_pan_control(None)
strip.set_mute_button(None)
strip.set_solo_button(None)
strip.set_arm_button(None)
def clear_tracks_assigments(self):
# for all normal tracks, clear assignments
self.clear_track_assignment(self._mixer.selected_strip())
self.clear_return_track_assignment(self._mixer.selected_strip())
self._mixer.selected_strip().set_send_controls(tuple((None, None)))
for i in range(NUM_TRACKS):
strip = self._mixer.channel_strip(i)
if (strip != None):
self.clear_track_assignment(strip)
# for all return tracks, clear assignments
for i in range(2):
return_strip = self._mixer.return_strip(i)
if (return_strip != None):
self.clear_return_track_assignment(return_strip)
def selected_track_changed(self):
# if on mixer mode update display
if (self._operation_mode_selector.mode_index == OP1_MODE_MIXER):
self.update_display_mixer_mode()
# clear track assignments
self.clear_tracks_assigments()
# if transport mode, we don't want to control stuff
if (self._operation_mode_selector.mode_index == OP1_MODE_TRANSPORT):
return
# getting selected strip
self._channel_strip = self._mixer.selected_strip()
# perform track assignments
self._channel_strip.set_volume_control(self._encoder_1)
self._channel_strip.set_pan_control(self._encoder_2)
# setting a tuple of encoders to control sends
send_controls = self._encoder_3, self._encoder_4,
# setting send encoders
self._channel_strip.set_send_controls(tuple(send_controls))
# setting solo button
self._channel_strip.set_solo_button(
ButtonElement(True, MIDI_CC_TYPE, CHANNEL, OP1_SS6_BUTTON))
# if track can be armed, set arm button
if (self._channel_strip._track.can_be_armed):
self._channel_strip.set_arm_button(
ButtonElement(True, MIDI_CC_TYPE, CHANNEL, OP1_SS7_BUTTON))
# if track is no master, set mute button
if (self._channel_strip._track != self.song().master_track):
self._channel_strip.set_mute_button(
ButtonElement(True, MIDI_CC_TYPE, CHANNEL, OP1_SS5_BUTTON))
def back_to_arranger_button_callback(self, value):
if (value == 127):
self.song().back_to_arranger = False
def mainview_toggle_button_callback(self, value):
if (value == 127):
if (self.session_visible == True):
self.session_visible = False
self.arrange_visible = True
self.app.view.show_view("Arranger")
self.arrange_browser_visible = self.app.view.is_view_visible(
"Browser")
else:
self.session_visible = True
self.arrange_visible = False
self.app.view.show_view("Session")
self.session_browser_visible = self.app.view.is_view_visible(
"Browser")
def detailview_toggle_button_callback(self, value):
if (value == 127):
if (self.detail_visible == True):
self.detail_visible = False
self.app.view.hide_view("Detail")
else:
self.detail_visible = True
self.app.view.show_view("Detail")
def write_text(self, msg):
text_list = []
sequence = ()
text_list.append(len(msg.strip()))
for i in msg.strip():
text_list.append(ord(i))
sequence = self.text_start_sequence + tuple(
text_list) + self.text_end_sequence
self._send_midi(sequence)
def suggest_input_port(self):
return "OP-1 Midi Device"
def suggest_output_port(self):
return "OP-1 Midi Device"
def update_display_perform_mode(self):
self.write_text("perform\rmode")
def reset_display_clips(self):
count = 0
colors = []
length = []
sequence = ()
for i in range(NUM_TRACKS):
count += 1
colors.append(0x00)
colors.append(0x00)
colors.append(0x00)
length.append(count)
sequence = self.text_color_start_sequence + tuple(length) + tuple(
colors) + self.text_end_sequence
self._send_midi(sequence)
def update_display_clips(self):
#self.log("UPDATING DISPLAY CLIPS")
count = 0
colors = []
length = []
sequence = ()
tracks_len = len(self.song().tracks) - self._session._track_offset
if (tracks_len > NUM_TRACKS):
tracks_len = NUM_TRACKS
for i in range(tracks_len):
count += 1
clip_slot = self._session.scene(0).clip_slot(i)
if (clip_slot != None):
if (clip_slot.has_clip() != False):
clip_color = clip_slot._clip_slot.clip.color
colors.append(((clip_color >> 16) & 0x000000ff) >> 1)
colors.append(((clip_color >> 8) & 0x000000ff) >> 1)
colors.append((clip_color & 0x000000ff) >> 1)
else:
colors.append(0x00)
colors.append(0x00)
colors.append(0x00)
else:
colors.append(0x00)
colors.append(0x00)
colors.append(0x00)
length.append(count)
sequence = self.text_color_start_sequence + tuple(length) + tuple(
colors) + self.text_end_sequence
self._send_midi(sequence)
def update_display_clip_mode(self):
self.write_text(
"sel. scene\r" +
str(self.song().view.selected_scene.name.lower().strip()))
def get_quant_str(self, q):
if q == Live.Song.Quantization.q_2_bars: return "2b"
if q == Live.Song.Quantization.q_4_bars: return "4b"
if q == Live.Song.Quantization.q_8_bars: return "8b"
if q == Live.Song.Quantization.q_bar: return "1b"
if q == Live.Song.Quantization.q_half: return "/2"
if q == Live.Song.Quantization.q_half_triplet: return "/2t"
if q == Live.Song.Quantization.q_quarter: return "/4"
if q == Live.Song.Quantization.q_quarter_triplet: return "/4t"
if q == Live.Song.Quantization.q_eight: return "/8"
if q == Live.Song.Quantization.q_eight_triplet: return "/8t"
if q == Live.Song.Quantization.q_sixtenth: return "/16"
if q == Live.Song.Quantization.q_sixtenth_triplet: return "/16t"
if q == Live.Song.Quantization.q_thirtytwoth: return "/32"
if q == Live.Song.Quantization.q_no_q: return "non"
return ":("
def update_display_transport_mode(self):
song_time = str(self.song().get_current_beats_song_time())
playing = '>' if self.song().is_playing else ''
record = '*' if self.song().record_mode else ''
self.write_text(
playing + record + " " +
self.get_quant_str(self.song().clip_trigger_quantization) + " " +
str("%.2f" % round(self.song().tempo, 2)) + "\r" +
song_time[:len(song_time) - 4])
def update_display_mixer_mode(self):
self.write_text("sel. track\r" +
str(self.song().view.selected_track.name.lower()))
def update_display(self):
if not (self.device_connected):
if (self.retries_count < 5):
self.log("TRYING OP-1 CONNECTION")
self.retries_count += 1
self._send_midi(self.id_sequence)
time.sleep(1)
# if in transport mode, update display with song position
if (self._operation_mode_selector.mode_index == OP1_MODE_TRANSPORT):
self.update_display_transport_mode()
# checking if app current view is session
if (self.app.view.is_view_visible("Session")):
# checking if session browser state is diferent from the internal
if (self.session_browser_visible !=
self.app.view.is_view_visible("Browser")):
self.session_browser_visible = self.app.view.is_view_visible(
"Browser")
# checking if app current view is arrange
if (self.app.view.is_view_visible("Arranger")):
# checking if arrange browser state is diferent from the internal
if (self.arrange_browser_visible !=
self.app.view.is_view_visible("Browser")):
self.arrange_browser_visible = self.app.view.is_view_visible(
"Browser")
# checking if app current view is detail
if (self.app.view.is_view_visible("Detail")):
# checking if detail state is diferent from the internal
if (self.detail_visible !=
self.app.view.is_view_visible("Detail")):
self.detail_visible = self.app.view.is_view_visible("Detail")
def refresh_state(self):
self.log("REFRESH STATE")
self.retries_count = 0
self.device_connected = False
def build_midi_map(self, midi_map_handle):
self._current_midi_map = midi_map_handle
ControlSurface.build_midi_map(self, midi_map_handle)
# remove clip listeners
self.rem_clip_slot_listeners()
# add clip listeners
self.add_clip_slot_listeners()
# update display
self.update_display_clips()
def log(self, msg):
self.c_instance.log_message("[TE OP-1] " + msg)
def disconnect(self):
# removing clip slots listeners
self.rem_clip_slot_listeners()
# removing value listener for track changed
self.song().view.remove_selected_track_listener(
self.selected_track_changed)
# removing value listener for scene changed
self.song().view.remove_selected_scene_listener(
self.selected_scene_changed)
# removing value listener for operation mode index
self._operation_mode_selector.remove_mode_index_listener(
self.mode_index_changed)
# removing global transport assignments
self._transport.set_punch_buttons(None, None)
self._transport.set_loop_button(None)
self._transport.set_overdub_button(None)
self._transport.set_record_button(None)
self._transport.set_play_button(None)
self._transport.set_stop_button(None)
self._transport.set_metronome_button(None)
self._transport.set_tap_tempo_button(None)
# removing global session assignments
self._session.set_scene_bank_buttons(None, None)
# removing misc listeners
self.browser_toggle_button.remove_value_listener(
self.browser_toggle_button_callback)
self.mainview_toggle_button.remove_value_listener(
self.mainview_toggle_button_callback)
self.detailview_toggle_button.remove_value_listener(
self.detailview_toggle_button_callback)
self.clear_track_button.remove_value_listener(
self.clear_track_button_callback)
self.back_to_arranger_button.remove_value_listener(
self.back_to_arranger_button_callback)
# sending special ableton mode disable sequence
self._send_midi(self.disable_sequence)
# disconnecting control surface
ControlSurface.disconnect(self)
self.log("DISCONNECTED")
class joyMIDI(ControlSurface):
def __init__(self, c_instance):
ControlSurface.__init__(self, c_instance)
with self.component_guard():
self.setup_transport()
self.setup_mixer()
self.setup_session()
def setup_transport(self):
# elements
self.play_button = ButtonElement(True, MIDI_NOTE_TYPE, 0, 93)
self.stop_button = ButtonElement(True, MIDI_NOTE_TYPE, 0, 94)
self.record_button = ButtonElement(True, MIDI_NOTE_TYPE, 0, 95)
# transport
self.transport = TransportComponent()
self.transport.set_play_button(self.play_button)
self.transport.set_stop_button(self.stop_button)
self.transport.set_record_button(self.record_button)
def setup_mixer(self):
# elements
self.mute_button = ButtonElement(True, MIDI_NOTE_TYPE, 0,
92) # tracks, return_tracks
self.solo_button = ButtonElement(True, MIDI_NOTE_TYPE, 0,
84) # tracks, return_tracks
self.arm_button = ButtonElement(True, MIDI_NOTE_TYPE, 0, 85) # tracks
self.senda_up_button = ButtonElement(True, MIDI_NOTE_TYPE, 0,
96) # tracks, return_tracks
self.senda_down_button = ButtonElement(True, MIDI_NOTE_TYPE, 0,
88) # tracks, return_tracks
self.sendb_up_button = ButtonElement(True, MIDI_NOTE_TYPE, 0,
97) # tracks, return_tracks
self.sendb_down_button = ButtonElement(True, MIDI_NOTE_TYPE, 0,
89) # tracks, return_tracks
self.pan_up_button = ButtonElement(
True, MIDI_NOTE_TYPE, 0, 98) # tracks, return_tracks, master_track
self.pan_down_button = ButtonElement(
True, MIDI_NOTE_TYPE, 0, 90) # tracks, return_tracks, master_track
self.volume_up_button = ButtonElement(
True, MIDI_NOTE_TYPE, 0, 99) # tracks, return_tracks, master_track
self.volume_down_button = ButtonElement(
True, MIDI_NOTE_TYPE, 0, 91) # tracks, return_tracks, master_track
self.track_nav_encoder = EncoderElement(
MIDI_CC_TYPE, 0, 14, Live.MidiMap.MapMode.relative_binary_offset)
# mixer
self.mixer = MixerComponent(7, 2)
self.mixer.selected_strip().set_mute_button(self.mute_button)
self.mixer.selected_strip().set_solo_button(self.solo_button)
self.mixer.selected_strip().set_arm_button(self.arm_button)
# send A/B, pan, volume
self.senda_up_button.add_value_listener(self.on_senda_up_changed)
self.senda_down_button.add_value_listener(self.on_senda_down_changed)
self.sendb_up_button.add_value_listener(self.on_sendb_up_changed)
self.sendb_down_button.add_value_listener(self.on_sendb_down_changed)
self.pan_up_button.add_value_listener(self.on_pan_up_changed)
self.pan_down_button.add_value_listener(self.on_pan_down_changed)
self.volume_up_button.add_value_listener(self.on_volume_up_changed)
self.volume_down_button.add_value_listener(self.on_volume_down_changed)
# nav
self.track_nav_encoder.add_value_listener(self.on_mixer_track_nav)
def on_senda_up_changed(self, value):
if value > 0:
param = self.song().view.selected_track.mixer_device.sends[0]
param.value = max(
param.min,
min(param.max,
param.value + ((param.max - param.min) / SEND_STEPS)))
def on_senda_down_changed(self, value):
if value > 0:
param = self.song().view.selected_track.mixer_device.sends[0]
param.value = max(
param.min,
min(param.max,
param.value - ((param.max - param.min) / SEND_STEPS)))
def on_sendb_up_changed(self, value):
if value > 0:
param = self.song().view.selected_track.mixer_device.sends[1]
param.value = max(
param.min,
min(param.max,
param.value + ((param.max - param.min) / SEND_STEPS)))
def on_sendb_down_changed(self, value):
if value > 0:
param = self.song().view.selected_track.mixer_device.sends[1]
param.value = max(
param.min,
min(param.max,
param.value - ((param.max - param.min) / SEND_STEPS)))
def on_pan_up_changed(self, value):
if value > 0:
param = self.song().view.selected_track.mixer_device.panning
param.value = max(
param.min,
min(param.max,
param.value + ((param.max - param.min) / PAN_STEPS)))
def on_pan_down_changed(self, value):
if value > 0:
param = self.song().view.selected_track.mixer_device.panning
param.value = max(
param.min,
min(param.max,
param.value - ((param.max - param.min) / PAN_STEPS)))
def on_volume_up_changed(self, value):
if value > 0:
param = self.song().view.selected_track.mixer_device.volume
param.value = max(
param.min,
min(param.max,
param.value + ((param.max - param.min) / VOLUME_STEPS)))
def on_volume_down_changed(self, value):
if value > 0:
param = self.song().view.selected_track.mixer_device.volume
param.value = max(
param.min,
min(param.max,
param.value - ((param.max - param.min) / VOLUME_STEPS)))
def on_mixer_track_nav(self, value):
move = -1 if value > 64 else +1
# get tracks-info
tracks = self.song().tracks
return_tracks = self.song().return_tracks
master_track = self.song().master_track
all_tracks = list(chain(tracks, return_tracks))
all_tracks.append(master_track)
num_tracks = len(tracks)
num_return_tracks = len(return_tracks)
num_master_track = 1
num_all_tracks = num_tracks + num_return_tracks + num_master_track
# update selected-track
index = index_if(lambda t: t == self.song().view.selected_track,
all_tracks)
index += move
index = min(max(index, 0), num_all_tracks - 1)
self.song().view.selected_track = all_tracks[index]
def setup_session(self):
num_tracks = 7
num_scenes = 1
track_offset = 0
scene_offset = 0
# elements
self.clip_launch_buttons = ButtonMatrixElement(rows=[[
ButtonElement(True, MIDI_NOTE_TYPE, 0, 76 + i)
for i in range(num_tracks)
]])
self.clip_stop_buttons = [
ButtonElement(True, MIDI_NOTE_TYPE, 0, 68 + i)
for i in range(num_tracks)
]
self.scene_launch_buttons = ButtonMatrixElement(rows=[[
ButtonElement(True, MIDI_NOTE_TYPE, 0, 83 + i)
for i in range(num_scenes)
]])
self.scene_stop_button = ButtonElement(True, MIDI_NOTE_TYPE, 0, 75)
self.session_scene_nav_encoder = EncoderElement(
MIDI_CC_TYPE, 0, 15, Live.MidiMap.MapMode.relative_binary_offset)
# session
self.session = SessionComponent(num_tracks, num_scenes)
self.session.set_offsets(track_offset, scene_offset)
self.session.add_offset_listener(self.on_session_offset_changed)
self.set_highlighting_session_component(self.session)
# clips
self.session.set_clip_launch_buttons(self.clip_launch_buttons)
self.session.set_stop_track_clip_buttons(self.clip_stop_buttons)
self.session.set_scene_launch_buttons(self.scene_launch_buttons)
self.session.set_stop_all_clips_button(self.scene_stop_button)
# nav
self.session_scene_nav_encoder.add_value_listener(
self.on_session_scene_nav)
def on_session_offset_changed(self):
pass
def on_session_scene_nav(self, value):
value -= 64
value = -value
track_offset = self.session.track_offset()
scene_offset = max(0, self.session.scene_offset() + value)
self.session.set_offsets(track_offset, scene_offset)
def disconnect(self):
u"""Live -> Script
Called right before we get disconnected from Live.
"""
self.log_message('disconnect')
self.show_message('disconnect')
