def session_record_change(self):
overdub = LiveUtils.getSong().session_record
self.oscServer.sendOSC("/live/set/session_record", (int(overdub) + 1))
trackNumber = 0
numberOfTracks = len(LiveUtils.getSong().tracks)
for i in range(numberOfTracks):
track = LiveUtils.getSong().tracks[i]
if track.can_be_armed == 1:
if track.arm == 1:
if track.playing_slot_index != -2:
if track.playing_slot_index != -1:
tid = trackNumber
cid = track.playing_slot_index
if track.clip_slots[cid].clip.is_audio_clip == 0:
if overdub == 1:
self.oscServer.sendOSC(
'/clip/playing_status', (tid, cid, 3))
else:
self.oscServer.sendOSC(
'/clip/playing_status', (tid, cid, 1))
else:
self.oscServer.sendOSC('/clip/playing_status',
(tid, cid, 3))
trackNumber = trackNumber + 1
def muteTrackCB(self, msg):
"""Called when a /live/mute message is received.
Messages:
/live/mute (int track) Mutes track number track
"""
ty = msg[0] == '/live/return/mute' and 1 or 0
track = msg[2]
if len(msg) == 4:
if msg[3] == 1:
if ty == 1:
status = LiveUtils.getSong().return_tracks[track].mute
else:
status = LiveUtils.getTrack(track).mute
if status == 1:
LiveUtils.unmuteTrack(track, ty)
elif status == 0:
LiveUtils.muteTrack(track, ty)
else:
LiveUtils.unmuteTrack(track, ty)
elif len(msg) == 3:
if ty == 1:
status = LiveUtils.getSong().return_tracks[track].mute
self.oscServer.sendOSC("/return/mute", (track, int(status)))
else:
status = LiveUtils.getTrack(track).mute
self.oscServer.sendOSC("/mute", (track, int(status)))
def rem_all_device_listeners(self):
#self.oscServer.sendOSC('/live/track/removing_all_dev_listeners', 1)
try:
self.do_remove_device_listeners(LiveUtils.getSong().tracks,0)
except:
err_message = "DeviceListener: do_remove_device_listeners for track " + str(0) + " failed"
self.error_log(err_message)
try:
self.do_remove_device_listeners(LiveUtils.getSong().return_tracks,2)
except:
err_message = "DeviceListener: do_remove_device_listeners for track " + str(1) + " failed"
self.error_log(err_message)
try:
self.do_remove_device_listeners([LiveUtils.getSong().master_track],1)
except:
err_message = "DeviceListener: do_remove_device_listeners for track " + str(2) + " failed"
self.error_log(err_message)
#self.oscServer.sendOSC('/live/track/removing_all_dev_listeners', 2)
for key in self.drum_pad_listen:
#self.oscServer.sendOSC('/live/track/removing_all_dev_listeners', 3)
drum_pad_listen = self.drum_pad_listen[key]
for drum_pad in drum_pad_listen:
if drum_pad != None:
ocb = drum_pad_listen[drum_pad]
if drum_pad.name_has_listener(ocb) == 1:
drum_pad.remove_name_listener(ocb)
#self.oscServer.sendOSC('/live/track/removing_all_dev_listeners', 4)
self.drum_pad_listen = {}
def redoCB(self, msg):
"""Called when a /live/redo message is received.
Messages:
/live/redo Requests the song to redo the last action
"""
LiveUtils.getSong().redo()
def devices_changed(self, track, tid, type):
message = "devices changed for track :" + str(tid) + " and type :" + str(type)
self.ta_logger(message, 4)
a = Live.Application.get_application().get_major_version()
length_tracks = len(LiveUtils.getSong().tracks)
for a_tid in range(length_tracks):
atrack = LiveUtils.getSong().tracks[a_tid]
if atrack == track:
tid = a_tid
self.oscServer.sendOSC("/devices_empty", (int(type), int(tid)))
did = 0
number_of_steps = 0
i = 0
indices = []
for device in track.devices:
lis = list(indices)
self.touchAble.tACommon.send_update_for_device(device, track, tid, did, type, len(track.devices), number_of_steps, lis, -1)
did = did+1
self.oscServer.sendOSC('/devices_loaded', (int(type), int(tid)))
self.add_device_listeners_for_track(track, int(tid), int(type))
def add_session_automation_record_listener(self):
self.rem_session_automation_record_listener()
if LiveUtils.getSong().session_automation_record_has_listener(
self.session_automation_record_change) != 1:
LiveUtils.getSong().add_session_automation_record_listener(
self.session_automation_record_change)
def add_arrangement_overdub_listener(self):
self.rem_arrangement_overdub_listener()
if LiveUtils.getSong().arrangement_overdub_has_listener(
self.overdub_change) != 1:
LiveUtils.getSong().add_arrangement_overdub_listener(
self.overdub_change)
def add_session_record_status_listener(self):
self.rem_session_record_status_listener()
if LiveUtils.getSong().session_record_status_has_listener(
self.session_record_status_changed) != 1:
LiveUtils.getSong().add_session_record_status_listener(
self.session_record_status_changed)
def add_re_enable_automation_enabled_listener(self):
self.rem_re_enable_automation_enabled_listener()
if LiveUtils.getSong().re_enable_automation_enabled_has_listener(
self.re_enable_automation_enabled_changed) != 1:
LiveUtils.getSong().add_re_enable_automation_enabled_listener(
self.re_enable_automation_enabled_changed)
def quant_change(self):
tquant = LiveUtils.getSong().clip_trigger_quantization
rquant = LiveUtils.getSong().midi_recording_quantization
self.oscServer.sendOSC(
"/set/quantization",
(int(LiveUtils.getSong().clip_trigger_quantization),
int(LiveUtils.getSong().midi_recording_quantization)))
def rem_can_capture_midi_listener(self):
a_version = Live.Application.get_application().get_major_version()
if a_version >= 10.0:
if LiveUtils.getSong().can_capture_midi_has_listener(
self.can_capture_midi_change) == 1:
LiveUtils.getSong().remove_can_capture_midi_listener(
self.can_capture_midi_change)
def cuelevelCB(self, msg):
if len(msg) == 2:
value = LiveUtils.getSong().master_track.mixer_device.cue_volume.value
self.oscServer.sendOSC("/set/cuelevel", float(value))
elif len(msg) == 3:
value = msg[2]
LiveUtils.getSong().master_track.mixer_device.cue_volume.value = value
def drumpadSolo(self, msg):
type = msg[2]
track_id = msg[3]
device_id = msg[4]
number_of_steps = msg[5]
drum_id = msg[6]
solod = msg[7]
if type == 1:
track = LiveUtils.getSong().tracks[track_id]
elif type == 3:
track = LiveUtils.getSong().return_tracks[track_id]
else:
track = LiveUtils.getSong().master_track
device = track.devices[device_id]
for i in range(number_of_steps):
chain_id = msg[8+i*2]
device_id = msg[9+i*2]
chain = device.chains[chain_id]
device = chain.devices[device_id]
if device.can_have_drum_pads == 1:
drum_pad = device.drum_pads[drum_id]
drum_pad.solo = solod
def get_device_for_message(self, msg):
type = msg[2]
tid = msg[3]
did = msg[4]
number_of_steps = msg[5]
if type == 0:
track = LiveUtils.getSong().tracks[tid]
elif type == 2:
track = LiveUtils.getSong().return_tracks[tid]
elif type == 1:
track = LiveUtils.getSong().master_track
device = track.devices[did]
for i in range(number_of_steps):
chain_id = msg[6 + i * 2]
device_id = msg[7 + i * 2]
track = device.chains[chain_id]
device = track.devices[device_id]
return device
def overdub_change(self):
try:
overdub = LiveUtils.getSong().arrangement_overdub
except:
overdub = LiveUtils.getSong().overdub
self.oscServer.sendOSC("/set/overdub_status", (int(overdub) + 1))
trackNumber = 0
if Live.Application.get_application().get_major_version() == 8:
for track in LiveUtils.getSong().tracks:
if track.can_be_armed == 1:
if track.arm == 1:
if track.playing_slot_index != -2:
tid = trackNumber
cid = track.playing_slot_index
if track.clip_slots[cid].clip.is_audio_clip == 0:
if overdub == 1:
self.oscServer.sendOSC(
'/clip/playing_status', (tid, cid, 3))
else:
self.oscServer.sendOSC(
'/clip/playing_status', (tid, cid, 1))
else:
self.oscServer.sendOSC('/clip/playing_status',
(tid, cid, 3))
trackNumber = trackNumber + 1
def add_can_capture_midi_listener(self):
a_version = Live.Application.get_application().get_major_version()
if a_version >= 10.0:
self.can_capture_midi_change()
if LiveUtils.getSong().can_capture_midi_has_listener(
self.can_capture_midi_change) != 1:
LiveUtils.getSong().add_can_capture_midi_listener(
self.can_capture_midi_change)
def stopAllCB(self, msg):
"""Called when a /live/stop/track message is received.
Messages:
/live/stop/track (int track, int clip) Stops track number track
"""
if len(msg) == 2:
LiveUtils.getSong().stop_all_clips()
def mviewTrackCB(self, msg):
"""Called when a /live/master/view message is received.
Messages:
/live/track/view (int track) Selects a track to view
"""
track = LiveUtils.getSong().master_track
LiveUtils.getSong().view.selected_track = track
Live.Application.get_application().view.show_view("Detail/DeviceChain")
def chainLoad(self, msg):
type = msg[2]
tid = msg[3]
steps = msg[4]
#self.oscServer.sendOSC("/browser/loadstart", 1)
track = LiveUtils.getSong().master_track
if type == 0:
track = LiveUtils.getSong().tracks[tid]
elif type == 2:
track = LiveUtils.getSong().return_tracks[tid]
#LiveUtils.getSong().view.selected_track = track
browser = Live.Application.get_application().browser
#self.oscServer.sendOSC("/browser/loadstart", 2)
track.view.device_insert_mode = Live.Track.DeviceInsertMode.default
#self.oscServer.sendOSC("/browser/loadstart", 3)
root_items = []
root_items.append(browser.sounds)
root_items.append(browser.drums)
root_items.append(browser.instruments)
root_items.append(browser.audio_effects)
root_items.append(browser.midi_effects)
root_items.append(browser.max_for_live)
root_items.append(browser.plugins)
root_items.append(browser.clips)
root_items.append(browser.samples)
root_items.append(browser.packs)
root_items.append(browser.user_library)
item = root_items[msg[5]]
#self.oscServer.sendOSC("/browser/loadstart", 4)
for i in range(steps-1):
index = msg[6+i]
item = item.children[index]
#self.oscServer.sendOSC("/browser/loadstart", 5)
if not Live.Application.get_application().view.browse_mode:
Live.Application.get_application().view.toggle_browse()
browser.load_item(item)
browser.hotswap_target = None
if Live.Application.get_application().view.browse_mode:
Live.Application.get_application().view.toggle_browse()
def device_changestate(self):
self.ta_logger("device_changestate",5)
device = LiveUtils.getSong().appointed_device
if device == None:
return
else:
pass
track = device.canonical_parent
did = 0
type = 0
number_of_steps = 0
indices = []
while track.canonical_parent != LiveUtils.getSong():
if number_of_steps % 2 != 0:
indices.append(touchAbleUtils.tuple_idx(track.chains, device))
else:
indices.append(touchAbleUtils.tuple_idx(track.devices, device))
number_of_steps = number_of_steps + 1
device = track
track = device.canonical_parent
self.ta_logger("got canonical_parent device",4)
if track.canonical_parent == LiveUtils.getSong():
did = touchAbleUtils.tuple_idx(track.devices, device)
tid = touchAbleUtils.tuple_idx(LiveUtils.getSong().tracks, track)
type = 0
if tid < 0:
tid = touchAbleUtils.tuple_idx(LiveUtils.getSong().return_tracks, track)
if tid >= 0:
type = 2
else:
type = 1
tid = 0
indis = [type, tid, did, int(number_of_steps/2)]
for i in range(len(indices)):
indis.append(int(indices[len(indices)-1-i]))
self.oscServer.sendOSC("/selected_device", tuple(indis))
self.ta_logger("sent selected device",4)
def viewSceneCB(self, msg):
"""Called when a /live/scene/view message is received.
Messages:
/live/scene/view (int track) Selects a track to view
"""
if len(msg) == 3:
scene = msg[2]
LiveUtils.getSong().view.selected_scene = LiveUtils.getSong(
).scenes[scene]
def soloTrackCB(self, msg):
"""Called when a /live/solo message is received.
Messages:
/live/solo (int track) Solos track number track
"""
ty = msg[0] == '/live/return/solo' and 1 or 0
track = msg[2]
if len(msg) == 4:
if msg[3] == 1:
status = 0
if ty == 1:
status = LiveUtils.getSong().return_tracks[track].solo
if LiveUtils.getSong().exclusive_solo == 1:
i = 0
for tr in LiveUtils.getSong().return_tracks:
LiveUtils.unsoloTrack(i, ty)
i = i + 1
else:
trk = LiveUtils.getTrack(track)
status = trk.solo
#trk.color = 12410829
if LiveUtils.getSong().exclusive_solo == 1:
i = 0
all_tracks = LiveUtils.getTracks()
for tr in all_tracks:
LiveUtils.unsoloTrack(i, ty)
i = i + 1
if status == 1:
LiveUtils.unsoloTrack(track, ty)
elif status == 0:
LiveUtils.soloTrack(track, ty)
elif msg[3] == 2:
message = "solo track nr: " + str(track)
tr = LiveUtils.getTrack(track)
if tr.can_be_armed:
LiveUtils.soloTrack(track)
else:
LiveUtils.unsoloTrack(track, ty)
elif len(msg) == 3:
if ty == 1:
status = LiveUtils.getSong().return_tracks[track].solo
self.oscServer.sendOSC("/return/solo", (track, int(status)))
else:
status = LiveUtils.getTrack(track).solo
self.oscServer.sendOSC("/solo", (track, int(status)))
def update_simpler_waveformcb(self, msg):
#self.oscServer.sendOSC("/NSLOG_REPLACE", "update_simpler_waveformcb")
type = msg[2]
tid = msg[3]
did = msg[4]
start_in_percent = msg[5]
end_in_percent = msg[6]
number_of_steps = msg[7]
#self.oscServer.sendOSC("/NSLOG_REPLACE", "update_simpler_waveformcb0")
if type == 0:
track = LiveUtils.getSong().tracks[tid]
elif type == 2:
track = LiveUtils.getSong().return_tracks[tid]
elif type == 1:
track = LiveUtils.getSong().master_track
#self.oscServer.sendOSC("/NSLOG_REPLACE", "update_simpler_waveformcb05")
device = track.devices[did]
#self.oscServer.sendOSC("/NSLOG_REPLACE", "update_simpler_waveformcb1115")
num = len(track.devices)
#self.oscServer.sendOSC("/NSLOG_REPLACE", "update_simpler_waveformcb15")
indices = []
device_id = -1
#self.oscServer.sendOSC("/NSLOG_REPLACE", "update_simpler_waveformcb25")
#self.oscServer.sendOSC("/NSLOG_REPLACE", "update_simpler_waveformcb1")
for i in range(number_of_steps):
chain_id = msg[8 + i * 2]
device_id = msg[9 + i * 2]
chain = device.chains[chain_id]
indices.append(int(chain_id))
device = chain.devices[device_id]
num = len(chain.devices)
indices.append(int(device_id))
if device.class_name == 'OriginalSimpler':
simpler = device
#self.oscServer.sendOSC("/NSLOG_REPLACE", "update_simpler_waveformcb2")
self.update_simpler_waveform(simpler, track, tid, did, type,
number_of_steps, indices,
start_in_percent, end_in_percent)
def sendCB(self, msg):
"""Called when a /live/send message is received.
Messages:
/live/send (int track, int send) Returns the send level of send (send) on track number track as: /live/send (int track, int send, float level(0.0 to 1.0))
/live/send (int track, int send, float level(0.0 to 1.0)) Sets the send (send) of track number (track)'s level to (level)
"""
ty = msg[0] == '/live/return/send' and 1 or 0
track = msg[2]
if len(msg) == 5:
send = msg[3]
level = msg[4]
if ty == 1:
LiveUtils.getSong(
).return_tracks[track].mixer_device.sends[send].value = level
else:
LiveUtils.trackSend(track, send, level)
elif len(msg) == 4:
send = msg[3]
if ty == 1:
self.oscServer.sendOSC(
"/live/return/send",
(track, send,
float(LiveUtils.getSong().return_tracks[track].
mixer_device.sends[send].value)))
else:
self.oscServer.sendOSC(
"/live/send",
(track, send, float(LiveUtils.trackSend(track, send))))
elif len(msg) == 3:
if ty == 1:
sends = LiveUtils.getSong(
).return_tracks[track].mixer_device.sends
else:
sends = LiveUtils.getSong().tracks[track].mixer_device.sends
so = [track]
length_sends = len(sends)
for i in range(length_sends):
so.append(i)
so.append(float(sends[i].value))
if ty == 1:
self.oscServer.sendOSC("/return/send", tuple(so))
else:
self.oscServer.sendOSC("/send", tuple(so))
def scene_change(self):
selected_scene = LiveUtils.getSong().view.selected_scene
scenes = LiveUtils.getSong().scenes
index = 0
selected_index = 0
for scene in scenes:
index = index + 1
if scene == selected_scene:
selected_index = index
if selected_index != self.scene:
self.scene = selected_index
self.oscServer.sendOSC("/set/selected_scene", (selected_index))
def simpler_meta(self, msg):
type = msg[2]
tid = msg[3]
did = msg[4]
number_of_steps = msg[5]
if type == 0:
track = LiveUtils.getSong().tracks[tid]
elif type == 2:
track = LiveUtils.getSong().return_tracks[tid]
elif type == 1:
track = LiveUtils.getSong().master_track
device = track.devices[did]
num = len(track.devices)
indices = []
device_id = -1
for i in range(number_of_steps):
chain_id = msg[6+i*2]
device_id = msg[7+i*2]
chain = device.chains[chain_id]
indices.append(int(chain_id))
device = chain.devices[device_id]
num = len(chain.devices)
indices.append(int(device_id))
if device.class_name == 'OriginalSimpler':
try:
self.simplerListener.update_playbackmode(device, track, tid, did, type , number_of_steps, indices)
simpler = device
sample = simpler.sample
if not sample:
return
self.simplerListener.update_slices(device, track, tid, did, type, number_of_steps, indices,sample)
self.simplerListener.update_gain(device, track, tid, did, type, number_of_steps, indices,sample)
self.simplerListener.update_marker(device, track, tid, did, type, number_of_steps, indices,sample)
self.simplerListener.update_sample_warping(device, track, tid, did, type, number_of_steps, indices,sample)
self.simplerListener.update_sample_warping_mode(device, track, tid, did, type, number_of_steps, indices,sample)
except:
self.error_log("DeviceCallbacks: simpler_meta failed")
def session_record_status_chang(self, msg):
newActive = 0
selected_scene = LiveUtils.getSong().view.selected_scene
index = 0
selected_index = 0
for scene in LiveUtils.getSong().scenes:
if scene == selected_scene:
selected_index = index
index = index + 1
tracks = LiveUtils.getSong().tracks
for track in tracks:
if track.can_be_armed:
if track.arm:
if track.clip_slots[selected_index].clip != None:
newActive = 1
break
if newActive == 1:
maxScenes = len(LiveUtils.getSong().scenes)
startIndex = selected_index
sceneIsEmpty = 0
newSceneIndex = 0
for i in range(startIndex, maxScenes):
sceneIsEmpty = 1
for track in tracks:
if track.can_be_armed:
if track.arm:
if track.clip_slots[i].clip != None:
sceneIsEmpty = 0
break
if sceneIsEmpty == 1:
newSceneIndex = i
break
if len(LiveUtils.getSong().scenes) == newSceneIndex:
LiveUtils.getSong().create_scene()
newScene = LiveUtils.getSong().scenes[newSceneIndex]
LiveUtils.getSong().view.selected_scene = newScene
for track in tracks:
if track.can_be_armed:
if track.arm:
track.stop_all_clips()
def getslots(self):
tracks = LiveUtils.getSong().tracks
clipSlots = []
for track in tracks:
clipSlots.append(track.clip_slots)
return clipSlots
def mixert_changestate(self, type, tid, track, r=0):
val = eval("track." + type)
#self.oscServer.sendOSC("/NSLOG_REPLACE", ("mixert_changestate"))
if r == 1:
self.oscServer.sendOSC('/return/' + type, (tid, int(val)))
else:
self.oscServer.sendOSC('/track/' + type, (tid, int(val)))
if type == "arm":
if val == 0:
if LiveUtils.getTrack(tid).playing_slot_index != -2:
cid = LiveUtils.getTrack(tid).playing_slot_index
self.oscServer.sendOSC('/clip/playing_status',
(tid, cid, 1))
else:
pass
elif val == 1:
if LiveUtils.getTrack(tid).playing_slot_index != -2:
cid = LiveUtils.getTrack(tid).playing_slot_index
if LiveUtils.getSong(
).overdub == 1 or LiveUtils.getTrack(
tid).has_midi_input == 0:
self.oscServer.sendOSC('/clip/playing_status',
(tid, cid, 3))
else:
self.oscServer.sendOSC('/clip/playing_status',
(tid, cid, 1))
else:
pass
else:
pass
def add_device_listeners(self):
try:
self.do_add_device_listeners(LiveUtils.getSong().tracks,0)
except:
self.error_log("DeviceListener: do_add_device_listeners 0 failed")
try:
self.do_add_device_listeners(LiveUtils.getSong().return_tracks,2)
except:
self.error_log("DeviceListener: do_add_device_listeners 2 failed")
try:
self.do_add_device_listeners([LiveUtils.getSong().master_track],1)
except:
self.error_log("DeviceListener: do_add_device_listeners 1 failed")
try:
self.add_app_device_listener()
except:
self.error_log("DeviceListener: add_app_device_listener failed")
