From 6ddeddbc26833c9b9d22c45266231af3a19e2d1c Mon Sep 17 00:00:00 2001 From: dataf1ow Date: Tue, 29 Nov 2016 11:47:30 -0500 Subject: [PATCH] Adding version 1.1 --- .../ConfigurableButtonElement.py | 0 {K_Mix => K_Mix_ver_1_0}/Device_Mode.py | 0 .../FaderSelectorComponent.py | 0 {K_Mix => K_Mix_ver_1_0}/K_Mix.py | 0 {K_Mix => K_Mix_ver_1_0}/K_MixSession.py | 0 {K_Mix => K_Mix_ver_1_0}/K_MixUtility.py | 0 {K_Mix => K_Mix_ver_1_0}/MIDI.py | 0 {K_Mix => K_Mix_ver_1_0}/Mix_Mode.py | 0 {K_Mix => K_Mix_ver_1_0}/VU_Mode.py | 0 {K_Mix => K_Mix_ver_1_0}/__init__.py | 0 K_Mix_ver_1_1/ConfigurableButtonElement.py | 84 +++++++ K_Mix_ver_1_1/DeviceSelector.py | 59 +++++ K_Mix_ver_1_1/Device_Mode.py | 135 +++++++++++ K_Mix_ver_1_1/K_Mix.py | 71 ++++++ K_Mix_ver_1_1/K_MixSession.py | 37 +++ K_Mix_ver_1_1/K_MixUtility.py | 14 ++ K_Mix_ver_1_1/MIDI.py | 32 +++ K_Mix_ver_1_1/Mix_Mode.py | 228 ++++++++++++++++++ K_Mix_ver_1_1/SendModeSelector.py | 83 +++++++ K_Mix_ver_1_1/VUModeSelector.py | 91 +++++++ K_Mix_ver_1_1/__init__.py | 13 + 21 files changed, 847 insertions(+) rename {K_Mix => K_Mix_ver_1_0}/ConfigurableButtonElement.py (100%) rename {K_Mix => K_Mix_ver_1_0}/Device_Mode.py (100%) rename {K_Mix => K_Mix_ver_1_0}/FaderSelectorComponent.py (100%) rename {K_Mix => K_Mix_ver_1_0}/K_Mix.py (100%) rename {K_Mix => K_Mix_ver_1_0}/K_MixSession.py (100%) rename {K_Mix => K_Mix_ver_1_0}/K_MixUtility.py (100%) rename {K_Mix => K_Mix_ver_1_0}/MIDI.py (100%) rename {K_Mix => K_Mix_ver_1_0}/Mix_Mode.py (100%) rename {K_Mix => K_Mix_ver_1_0}/VU_Mode.py (100%) rename {K_Mix => K_Mix_ver_1_0}/__init__.py (100%) create mode 100755 K_Mix_ver_1_1/ConfigurableButtonElement.py create mode 100644 K_Mix_ver_1_1/DeviceSelector.py create mode 100644 K_Mix_ver_1_1/Device_Mode.py create mode 100644 K_Mix_ver_1_1/K_Mix.py create mode 100644 K_Mix_ver_1_1/K_MixSession.py create mode 100644 K_Mix_ver_1_1/K_MixUtility.py create mode 100644 K_Mix_ver_1_1/MIDI.py create mode 100644 K_Mix_ver_1_1/Mix_Mode.py create mode 100644 K_Mix_ver_1_1/SendModeSelector.py create mode 100644 K_Mix_ver_1_1/VUModeSelector.py create mode 100644 K_Mix_ver_1_1/__init__.py diff --git a/K_Mix/ConfigurableButtonElement.py b/K_Mix_ver_1_0/ConfigurableButtonElement.py similarity index 100% rename from K_Mix/ConfigurableButtonElement.py rename to K_Mix_ver_1_0/ConfigurableButtonElement.py diff --git a/K_Mix/Device_Mode.py b/K_Mix_ver_1_0/Device_Mode.py similarity index 100% rename from K_Mix/Device_Mode.py rename to K_Mix_ver_1_0/Device_Mode.py diff --git a/K_Mix/FaderSelectorComponent.py b/K_Mix_ver_1_0/FaderSelectorComponent.py similarity index 100% rename from K_Mix/FaderSelectorComponent.py rename to K_Mix_ver_1_0/FaderSelectorComponent.py diff --git a/K_Mix/K_Mix.py b/K_Mix_ver_1_0/K_Mix.py similarity index 100% rename from K_Mix/K_Mix.py rename to K_Mix_ver_1_0/K_Mix.py diff --git a/K_Mix/K_MixSession.py b/K_Mix_ver_1_0/K_MixSession.py similarity index 100% rename from K_Mix/K_MixSession.py rename to K_Mix_ver_1_0/K_MixSession.py diff --git a/K_Mix/K_MixUtility.py b/K_Mix_ver_1_0/K_MixUtility.py similarity index 100% rename from K_Mix/K_MixUtility.py rename to K_Mix_ver_1_0/K_MixUtility.py diff --git a/K_Mix/MIDI.py b/K_Mix_ver_1_0/MIDI.py similarity index 100% rename from K_Mix/MIDI.py rename to K_Mix_ver_1_0/MIDI.py diff --git a/K_Mix/Mix_Mode.py b/K_Mix_ver_1_0/Mix_Mode.py similarity index 100% rename from K_Mix/Mix_Mode.py rename to K_Mix_ver_1_0/Mix_Mode.py diff --git a/K_Mix/VU_Mode.py b/K_Mix_ver_1_0/VU_Mode.py similarity index 100% rename from K_Mix/VU_Mode.py rename to K_Mix_ver_1_0/VU_Mode.py diff --git a/K_Mix/__init__.py b/K_Mix_ver_1_0/__init__.py similarity index 100% rename from K_Mix/__init__.py rename to K_Mix_ver_1_0/__init__.py diff --git a/K_Mix_ver_1_1/ConfigurableButtonElement.py b/K_Mix_ver_1_1/ConfigurableButtonElement.py new file mode 100755 index 0000000..3e9f44a --- /dev/null +++ b/K_Mix_ver_1_1/ConfigurableButtonElement.py @@ -0,0 +1,84 @@ +import Live + +from _Framework.ButtonElement import * + +class ConfigurableButtonElement(ButtonElement): + __module__ = __name__ + __doc__ = ' Special button class that can be configured with custom on- and off-values ' + + def __init__(self, is_momentary, msg_type, channel, identifier, vel = 127): + ButtonElement.__init__(self, is_momentary, msg_type, channel, identifier) + if vel != 0: + self._on_value = vel #127 for Launchpad #0=off, 1=green, 2=green blink, 3=red, 4=red blink, 5=yellow, 6=yellow blink, 7-127=green + else: + self._on_value = 127 + self._note = identifier + self._off_value = 0 #4 for Launchpad, 0 for APC40/20 + self._blink_on = None + self._last_active_value = 0 + self._blinking = False + self._led_on = 0 + self._is_enabled = True + self._is_notifying = False + self._force_next_value = False + self._pending_listeners = [] + self.count = 0 + + def note_on(self): + if (self.count > 1): + self.count = 0 + else: + None + if (self.count == 1): + self.turn_on() + else: + self.turn_off() + + def set_on_off_values(self, on_value, off_value): + assert (on_value in range(128)) + assert (off_value in range(128)) + self._last_sent_value = -1 + self._on_value = on_value + self._off_value = off_value + + def set_force_next_value(self): + self._force_next_value = True + + def set_enabled(self, enabled): + self._is_enabled = enabled + + #def turn_on(self): + #self.send_value(self._on_value) + + #def turn_off(self): + #self.send_value(self._off_value) + + def reset(self): + self.send_value(0) #4 for Launchpad, 0 for APC40/20 + + def add_value_listener(self, callback, identify_sender = False): + if (not self._is_notifying): + ButtonElement.add_value_listener(self, callback, identify_sender) + else: + self._pending_listeners.append((callback, identify_sender)) + + def receive_value(self, value): + self._is_notifying = True + ButtonElement.receive_value(self, value) + + self._is_notifying = False + for listener in self._pending_listeners: + self.add_value_listener(listener[0], listener[1]) + + self._pending_listeners = [] + + def send_value(self, value, force = False): + ButtonElement.send_value(self, value, (force or self._force_next_value)) + self._last_active_value = value + self._force_next_value = False + + def install_connections(self, install_translation_callback, install_mapping_callback, install_forwarding_callback): + if self._is_enabled: + ButtonElement.install_connections(self, install_translation_callback, install_mapping_callback, install_forwarding_callback) + elif self._msg_channel != self._original_channel or self._msg_identifier != self._original_identifier: + install_translation_callback(self._msg_type, self._original_identifier, self._original_channel, self._msg_identifier, self._msg_channel) diff --git a/K_Mix_ver_1_1/DeviceSelector.py b/K_Mix_ver_1_1/DeviceSelector.py new file mode 100644 index 0000000..fd68f85 --- /dev/null +++ b/K_Mix_ver_1_1/DeviceSelector.py @@ -0,0 +1,59 @@ +from _Framework.ModeSelectorComponent import ModeSelectorComponent +from ConfigurableButtonElement import ConfigurableButtonElement +from K_MixUtility import K_MixUtility +from MIDI import * + +class DeviceSelector(ModeSelectorComponent, K_MixUtility): + """Class that selects between modes""" + + def __init__(self,mixer,device): + ModeSelectorComponent.__init__(self) + self._mixer = mixer + self._device = device + self.set_mode_toggle(self.button(CHANNEL,FINE_BUTTON)) + #self.update() + + def set_mode_toggle(self, button): + #if not (button == None or isinstance(button, ConfigurableButtonElement)): + # raise AssertionError + if self._mode_toggle != None: + self._mode_toggle.remove_value_listener(self._toggle_value) + #self._mode_toggle.remove_value_listener(self._mode_release) + self._mode_toggle = button + self._mode_toggle != None and self._mode_toggle.add_value_listener(self._toggle_value) + #self._mode_toggle.add_value_listener(self._mode_release) + self.set_mode(0) + + def number_of_modes(self): + return 2 + + def on_enabled_changed(self): + self.update() + ''' + def set_mode(self, mode): + if mode < self.number_of_modes(): + self._mode_index = mode + self.update() + ''' + + def _toggle_value(self, value): + index = self._mode_index + if value != 0: + if index == 0: + self.set_mode(1) + self._mixer.setup(False) + self._device.setup(True) + if index == 1: + self.set_mode(0) + self._device.setup(False) + self._mixer.setup(True) + if value == 0: + if index == 1: + self._mode_toggle.send_value(1) + + def _mode_release(self, value): + if value == 0: + index = self._mode_index + if index == 1: + self._mode_toggle.send_value(1) + \ No newline at end of file diff --git a/K_Mix_ver_1_1/Device_Mode.py b/K_Mix_ver_1_1/Device_Mode.py new file mode 100644 index 0000000..139dc5f --- /dev/null +++ b/K_Mix_ver_1_1/Device_Mode.py @@ -0,0 +1,135 @@ +from _Framework.DeviceComponent import DeviceComponent +from K_MixUtility import K_MixUtility +from MIDI import * +from _Framework.Debug import debug_print +from _Framework.SubjectSlot import subject_slot, subject_slot_group, Subject + + +def device_to_appoint(device): + appointed_device = device + if device != None and device.can_have_drum_pads and not device.has_macro_mappings and len(device.chains) > 0 and device.view.selected_chain != None and len(device.view.selected_chain.devices) > 0: + appointed_device = device_to_appoint(device.view.selected_chain.devices[0]) + return appointed_device + + +class Device_Mode(DeviceComponent,K_MixUtility): + def __init__(self, parent, *a, **k): + super(Device_Mode, self).__init__(*a, **k) + self.encoders = [] + self._device_left_button = None + self._device_right_button = None + self.selected_device = None + self.parent = parent + self.track = None + self._active = False + + def make_button_slot(name): + return self.register_slot(None, getattr(self, '_%s_value' % name), 'value') + + for index in range(8): + self.encoders.append(self.encoder(CHANNEL, SLIDERS[index])) + + + self._device_left_slot = make_button_slot('device_left') + self._device_right_slot = make_button_slot('device_right') + + def set_device_left_button(self, button): + if button != None: + if button != self._device_left_button: + self._device_left_button = button + self._device_left_slot.subject = button + + def set_device_right_button(self, button): + if button != None: + if button != self._device_right_button: + self._device_right_button = button + self._device_right_slot.subject = button + + def _device_right_value(self, value): + if value == 127: + count = 0 + for device in self.song().view.selected_track.devices: + if device == self.song().view.selected_track.view.selected_device: + index = count + count = count + 1 + if index + 1 == len(self.song().view.selected_track.devices): + index = -1 + self.song().appointed_device = device_to_appoint(self.song().view.selected_track.devices[index + 1]) + self.song().view.select_device(self.song().view.selected_track.devices[index + 1], False) + if self.selected_device != self.song().view.selected_track.view.selected_device: + self.selected_device = self.song().view.selected_track.view.selected_device + self.set_device(self.selected_device) + + def _device_left_value(self, value): + if value == 127: + count = 0 + for device in self.song().view.selected_track.devices: + if device == self.song().view.selected_track.view.selected_device: + index = count + count = count + 1 + self.song().appointed_device = device_to_appoint(self.song().view.selected_track.devices[index - 1]) + self.song().view.select_device(self.song().view.selected_track.devices[index - 1], False) + if self.selected_device != self.song().view.selected_track.view.selected_device: + self.selected_device = self.song().view.selected_track.view.selected_device + self.set_device(self.selected_device) + + def log_message(self, *message): + """ Writes the given message into Live's main log file """ + message = '(%s) %s' % (self.__class__.__name__, ' '.join(map(str, message))) + console_message = 'LOG: ' + message + if debug_print != None: + debug_print(console_message) + else: + print console_message + if self.parent._c_instance: + self.parent._c_instance.log_message(message) + + def on_selected_track_changed(self): + track = self.song().view.selected_track + device_count = track.devices + self.log_message(len(device_count)) + if len(device_count) != 0: + if self.selected_device != self.song().view.selected_track.devices[0]: + self.song().view.select_device(self.song().view.selected_track.devices[0]) + self.selected_device = self.song().view.selected_track.devices[0] + self.parent.mixer.on_selected_track_changed() + self.set_device(self.selected_device) + + def on_selected_device_changed(self): + if self.selected_device != self.song().view.selected_track.view.selected_device: + self.selected_device = self.song().view.selected_track.view.selected_device + self.set_device(self.selected_device) + + def setup(self, as_enabled): + if self.selected_device != self.song().view.selected_track.view.selected_device: + self.selected_device = self.song().view.selected_track.view.selected_device + self.set_device(self.selected_device) + self.set_parameter_controls(None) + + for slider in range(8): + self.encoders[slider].send_value(0) + #device = DeviceComponent() + #self.set_device_component(device) + #device.set_parameter_controls(self._sliders) + if as_enabled: + if self._active == False: + self.set_parameter_controls(None) + for slider in range(8): + self.encoders[slider].send_value(0) + self.set_parameter_controls(self.encoders) + self.set_device_left_button(self.button(CHANNEL, HEADPHONE_BUTTON)) + self.set_device_right_button(self.button(CHANNEL,TRIM_BUTTON)) + self.set_bank_nav_buttons(self.button(CHANNEL, EQ_BUTTON), self.button(CHANNEL, GATE_BUTTON)) + self._active = True + self.update() + else: + if self._active == True: + self.set_parameter_controls(None) + for slider in range(8): + self.encoders[slider].send_value(0) + self.set_device_left_button(None) + self.set_device_right_button(None) + self.set_bank_nav_buttons(None, None) + self._active = False + self.update() + diff --git a/K_Mix_ver_1_1/K_Mix.py b/K_Mix_ver_1_1/K_Mix.py new file mode 100644 index 0000000..a467419 --- /dev/null +++ b/K_Mix_ver_1_1/K_Mix.py @@ -0,0 +1,71 @@ +from __future__ import with_statement + +import Live +import time +import math + +from _Framework.Debug import debug_print +from _Framework.ControlSurface import ControlSurface +from _Framework.MixerComponent import MixerComponent +from _Framework.SubjectSlot import subject_slot, subject_slot_group, Subject +from K_MixSession import K_MixSession +from SendModeSelector import SendModeSelector +from VUModeSelector import VUModeSelector +from DeviceSelector import DeviceSelector +from Device_Mode import Device_Mode +from Mix_Mode import Mix_Mode +from K_MixUtility import K_MixUtility +from MIDI import * + + +class K_Mix(ControlSurface,K_MixUtility): + '''Our K Mix Class''' + + def __init__(self, c_instance): + ControlSurface.__init__(self, c_instance) + with self.component_guard(): + self.setup_mixer() + self.setup_device() + self.setup_send_selector() + self.setup_VU_selector() + self.setup_device_selector() + self.setup_session() + self.set_highlighting_session_component(self.session) + + self.register_slot(self.song().view.selected_track.view, self._on_selected_device_changed, 'selected_device') + + def log_message(self, *message): + #""" Writes the given message into Live's main log file """ + message = '(%s) %s' % (self.__class__.__name__, ' '.join(map(str, message))) + console_message = 'LOG: ' + message + if debug_print != None: + debug_print(console_message) + else: + print console_message + if self._c_instance: + self._c_instance.log_message(message) + + def setup_session(self): + self.session = K_MixSession(8, 6, self) + self.session.set_offsets(0,0) + self.session.set_mixer(self.mixer) + self.session.update() + + def setup_device(self): + self.device = Device_Mode(self) + + def setup_mixer(self): + self.mixer = Mix_Mode(8,8,self) + self.mixer.setup_master(True) + + def setup_send_selector(self): + self.send_selector = SendModeSelector(self.mixer) + + def setup_device_selector(self): + self.device_selector = DeviceSelector(self.mixer,self.device) + + def setup_VU_selector(self): + self.VU_selector = VUModeSelector(self.mixer) + + def _on_selected_device_changed(self): + self.device.on_selected_device_changed() diff --git a/K_Mix_ver_1_1/K_MixSession.py b/K_Mix_ver_1_1/K_MixSession.py new file mode 100644 index 0000000..149bf3b --- /dev/null +++ b/K_Mix_ver_1_1/K_MixSession.py @@ -0,0 +1,37 @@ +from _Framework.SessionComponent import SessionComponent +from K_MixUtility import K_MixUtility +from MIDI import * +from _Framework.Debug import debug_print + +class K_MixSession(SessionComponent, K_MixUtility): + def __init__(self, num_tracks, num_scenes,parent): + SessionComponent.__init__(self, num_tracks, num_scenes) + self.sends = ROTARIES[1:] + self.setup(num_scenes) + self.parent = parent + + def setup(self,num_scenes): + self.set_scene_bank_buttons( + self.button(CHANNEL, STOP_BUTTON), + self.button(CHANNEL, RECORD_BUTTON)) + + self.set_track_bank_buttons( + self.button(CHANNEL, PLAY_BUTTON), + self.button(CHANNEL, REWIND_BUTTON)) + + for scenes in range(num_scenes): + self.scene(scenes).set_launch_button(self.button(CHANNEL, SCENE_LAUNCH_BUTTONS[scenes])) + + def on_track_list_changed(self): + super(K_MixSession,self).on_track_list_changed() + + def log_message(self, *message): + #""" Writes the given message into Live's main log file """ + message = '(%s) %s' % (self.__class__.__name__, ' '.join(map(str, message))) + console_message = 'LOG: ' + message + if debug_print != None: + debug_print(console_message) + else: + print console_message + if self.parent._c_instance: + self.parent._c_instance.log_message(message) \ No newline at end of file diff --git a/K_Mix_ver_1_1/K_MixUtility.py b/K_Mix_ver_1_1/K_MixUtility.py new file mode 100644 index 0000000..cf2a7eb --- /dev/null +++ b/K_Mix_ver_1_1/K_MixUtility.py @@ -0,0 +1,14 @@ +from ConfigurableButtonElement import ConfigurableButtonElement +from _Framework.InputControlElement import * +from _Framework.SliderElement import SliderElement + +class K_MixUtility(object): + """ Provides some functionality shared across ALL classes """ + + def button(self, channel, note): + return ConfigurableButtonElement(True, MIDI_NOTE_TYPE, channel, note) + + + def encoder(self, channel, cc): + return SliderElement(MIDI_CC_TYPE, channel, cc) + diff --git a/K_Mix_ver_1_1/MIDI.py b/K_Mix_ver_1_1/MIDI.py new file mode 100644 index 0000000..6af7a93 --- /dev/null +++ b/K_Mix_ver_1_1/MIDI.py @@ -0,0 +1,32 @@ +CHANNEL = 0 + +SLIDERS = [1, 2, 3, 4, 5, 6, 7, 8] +MASTER_SLIDER = 9 +MASTER_BUTTON = 9 + +RECORD_BUTTON = 26 +STOP_BUTTON = 27 +REWIND_BUTTON = 28 +PLAY_BUTTON = 29 + +SELECT_BUTTONS = [1, 2, 3, 4, 5, 6, 7, 8] + +ROTARIES = [10, 11, 12, 13] + +VU_BUTTON = 12 +FINE_BUTTON = 11 +BYPASS_BUTTON = 10 +MAIN_BUTTON = 14 +AUX1_BUTTON = 15 +AUX2_BUTTON = 16 +AUX3_BUTTON = 17 +COMP_BUTTON = 18 +GATE_BUTTON = 19 +PAN_BUTTON = 20 +EQ_BUTTON = 21 +VERB_BUTTON = 22 +TRIM_BUTTON =23 +PHANTOM_BUTTON = 24 +HEADPHONE_BUTTON = 25 + +SCENE_LAUNCH_BUTTONS = [MAIN_BUTTON, AUX2_BUTTON, COMP_BUTTON, PAN_BUTTON, VERB_BUTTON, PHANTOM_BUTTON] \ No newline at end of file diff --git a/K_Mix_ver_1_1/Mix_Mode.py b/K_Mix_ver_1_1/Mix_Mode.py new file mode 100644 index 0000000..dd9a145 --- /dev/null +++ b/K_Mix_ver_1_1/Mix_Mode.py @@ -0,0 +1,228 @@ +from _Framework.MixerComponent import MixerComponent +from _Framework.ChannelStripComponent import ChannelStripComponent +from K_MixUtility import K_MixUtility +from MIDI import * +import math +from _Framework.Debug import debug_print + + +class Mix_Mode(MixerComponent,K_MixUtility): + def __init__(self,num_tracks,num_returns,parent): + self._is_active = False + MixerComponent.__init__(self,num_tracks,num_returns) + self.parent = parent + self.num_tracks = num_tracks + self._sliders = [] + self._sends = [] + self._select_buttons = [] + self._rotaries = [] + self.VU_mode = 0 + self.send_mode = 0 + self.is_active = True + #self.device = device + self._master_fader = self.encoder(CHANNEL,MASTER_SLIDER) + self._master_select = self.button(CHANNEL,MASTER_BUTTON) + + for track in range(num_tracks): + self._sliders.append(self.encoder(CHANNEL,SLIDERS[track])) + + for index in range(4): + self._rotaries.append(self.encoder(CHANNEL,ROTARIES[index])) + + for track in range(num_tracks): + self._select_buttons.append(self.button(CHANNEL,SELECT_BUTTONS[track])) + self._is_active = True + + + def _create_strip(self): + return K_MixChannelStrip() + + def setup_master(self,as_enabled = True): + if as_enabled: + for index in range(3): + self._sends.append(self._rotaries[index + 1]) + self.selected_strip().set_send_controls(tuple(self._sends)) + self.selected_strip().set_pan_control(self._rotaries[0]) + self.master_strip().set_select_button(self._master_select) + self.master_strip().set_volume_control(self._master_fader) + + def setup(self, is_active): + self.is_active = is_active + if self.is_active == True: + self.setup_sliders() + if self.is_active == False: + for track in range(self.num_tracks): + if self._sliders[track] != None: + self._sliders[track].send_value(0) + strip = self.channel_strip(track) + return_strip = self.return_strip(track) + if strip._volume_control != None: + strip.set_volume_control(None) + if strip._VU_control != None: + strip.set_VU_control(None) + + + def setup_tracks(self): + for track in range(self.num_tracks): + strip = self.channel_strip(track) + return_strip = self.return_strip(track) + return_strip.set_select_button(None) + strip.set_select_button(self._select_buttons[track]) + if self.VU_mode == 0: + return_strip.set_volume_control(None) + strip.set_volume_control(self._sliders[track]) + if self.VU_mode == 1: + return_strip.set_VU_control(None) + strip.set_VU_control(self._sliders[track]) + self.update() + + def setup_sends(self): + for track in range(self.num_tracks): + strip = self.channel_strip(track) + return_strip = self.return_strip(track) + strip.set_select_button(None) + return_strip.set_select_button(self._select_buttons[track]) + if self.VU_mode == 0: + strip.set_volume_control(None) + return_strip.set_volume_control(self._sliders[track]) + if self.VU_mode == 1: + strip.set_VU_control(None) + return_strip.set_VU_control(self._sliders[track]) + self.update() + + def setup_sliders(self): + for track in range(self.num_tracks): + if self._sliders[track] != None: + self._sliders[track].send_value(0) + strip = self.channel_strip(track) + return_strip = self.return_strip(track) + if self.send_mode == 0: + if strip._volume_control != None: + strip.set_volume_control(None) + if strip._VU_control != None: + strip.set_VU_control(None) + self.setup_tracks() + if self.send_mode == 1: + if return_strip._volume_control != None: + return_strip.set_volume_control(None) + if return_strip._VU_control != None: + return_strip.set_VU_control(None) + self.setup_sends() + if self.VU_mode == 0: + self.master_strip().set_VU_control(None) + self.master_strip().set_volume_control(self._master_fader) + if self.VU_mode == 1: + self.master_strip().set_volume_control(None) + self.master_strip().set_VU_control(self._master_fader) + + + def flush_LEDs(self, num_tracks): + for track in range(num_tracks): + self._sliders[track].send_value(0) + + def _reassign_tracks(self): + super(Mix_Mode,self)._reassign_tracks() + if self._is_active == True: + for track in range(self.num_tracks): + strip = self.channel_strip(track) + selected_track = self.song().view.selected_track + if strip._track == selected_track: + self._select_buttons[track].send_value(1) + if track > len(self.song().visible_tracks) - self._track_offset - 1: + self._sliders[track].send_value(0) + + + def restore_sliders(self,num_tracks): + for track in range(num_tracks): + value_to_send = self._sliders[track].value + self._sliders[track].send_value(value_to_send) + + def log_message(self, *message): + #""" Writes the given message into Live's main log file """ + message = '(%s) %s' % (self.__class__.__name__, ' '.join(map(str, message))) + console_message = 'LOG: ' + message + if debug_print != None: + debug_print(console_message) + else: + print console_message + if self.parent._c_instance: + self.parent._c_instance.log_message(message) + + def on_track_list_changed(self): + super(Mix_Mode,self).on_track_list_changed() + + +class K_MixChannelStrip(ChannelStripComponent): + def __init__(self, *a, **k): + super(K_MixChannelStrip, self).__init__(*a, **k) + + self.frames = [0.0] * 2 + self.scale = 127 + self.current_level = 0 + self.master = None + self._VU_control = None + + def observe(self): + if self._track != None: + if self._track.has_audio_output == True: + new_frame = self.track.output_meter_left + self.store_frame(new_frame) + level = self.rms(self.frames) + if level != self.current_level: + self.set_leds(level) + + def store_frame(self,frame): + self.frames.pop(0) + self.frames.append(frame) + + def rms(self,frames): + return math.sqrt(sum(frame*frame for frame in frames)/len(frames)) + + def set_VU_control(self,slider): + identify_sender = True + if slider != None: + self._VU_control = slider + slider.add_value_listener(self._VU_value) + if self._track != None: + if self._track.has_audio_output: + if not self._track.output_meter_left_has_listener(self.observe): + self._track.add_output_meter_left_listener(self.observe) + self.update() + else: + if self._VU_control != None: + self._VU_control.remove_value_listener(self._VU_value) + self._VU_control = None + if self._track != None: + if self._track.has_audio_output: + if self._track.output_meter_left_has_listener(self.observe): + self._track.remove_output_meter_left_listener(self.observe) + self.update() + + def set_leds(self, level): + if self._VU_control != None: + self._VU_control.send_value(level * self.scale) + + def _VU_value(self, data): + self._track.mixer_device.volume.value = float(data)/127.0 + + + def set_select_button(self, button): + if button != None: + if button != self._select_button: + self.reset_button_on_exchange(self._select_button) + self._select_button = button + self._select_button_slot.subject = button + self.update() + if button == None: + self.reset_button_on_exchange(self._select_button) + self._select_button = button + self._select_button_slot.subject = button + self.update() + + def _select_value(self, value): + super(K_MixChannelStrip,self)._select_value(value) + if value == 0: + if self._track != None and self.song().view.selected_track == self._track: + self._select_button.send_value(1) + + diff --git a/K_Mix_ver_1_1/SendModeSelector.py b/K_Mix_ver_1_1/SendModeSelector.py new file mode 100644 index 0000000..669ea99 --- /dev/null +++ b/K_Mix_ver_1_1/SendModeSelector.py @@ -0,0 +1,83 @@ +from _Framework.ModeSelectorComponent import ModeSelectorComponent +from ConfigurableButtonElement import ConfigurableButtonElement +from K_MixUtility import K_MixUtility +from MIDI import * + +class SendModeSelector(ModeSelectorComponent, K_MixUtility): + """Class that selects between modes""" + + def __init__(self,mixer): + ModeSelectorComponent.__init__(self) + self._mixer = mixer + self.set_mode_toggle(self.button(CHANNEL,AUX1_BUTTON)) + #self.update() + + + def set_modes_buttons(self, buttons): + #raise buttons == None or isinstance(buttons, tuple) or len(buttons) == self.number_of_modes() or AssertionError + identify_sender = True + for button in self._modes_buttons: + button.remove_value_listener(self._mode_value) + button.remove_value_listener(self._mode_release) + self._modes_buttons = [] + if buttons != None: + for button in buttons: + #raise isinstance(button, ButtonElement) or AssertionError + self._modes_buttons.append(button) + button.add_value_listener(self._mode_value, identify_sender) + button.add_value_listener(self._mode_release, identify_sender) + self.set_mode(0) + + + def set_mode_toggle(self, button): + #if not (button == None or isinstance(button, ConfigurableButtonElement)): + # raise AssertionError + if self._mode_toggle != None: + self._mode_toggle.remove_value_listener(self._toggle_value) + #self._mode_toggle.remove_value_listener(self._mode_release) + self._mode_toggle = button + self._mode_toggle != None and self._mode_toggle.add_value_listener(self._toggle_value) + #self._mode_toggle.add_value_listener(self._mode_release) + self.set_mode(0) + + def number_of_modes(self): + return 2 + + def on_enabled_changed(self): + self.update() + ''' + def set_mode(self, mode): + if mode < self.number_of_modes(): + self._mode_index = mode + self.update() + ''' + def update(self): + super(SendModeSelector, self).update() + for track in range(len(self._mixer._sliders)): + self._mixer._sliders[track].send_value(0) + if self._mode_index == 0: + self._mixer.setup_tracks() + elif self._mode_index == 1: + self._mixer.setup_sends() + + + def _toggle_value(self, value): + index = self._mode_index + if self._mixer.is_active == True: + if value != 0: + if index == 0: + self.set_mode(1) + self._mixer.send_mode = 1 + if index == 1: + self.set_mode(0) + self._mixer.send_mode = 0 + if value == 0: + if index == 1: + self._mode_toggle.send_value(1) + + def _mode_release(self, value): + if value == 0: + index = self._mode_index + if index == 1: + self._mode_toggle.send_value(1) + \ No newline at end of file diff --git a/K_Mix_ver_1_1/VUModeSelector.py b/K_Mix_ver_1_1/VUModeSelector.py new file mode 100644 index 0000000..466113f --- /dev/null +++ b/K_Mix_ver_1_1/VUModeSelector.py @@ -0,0 +1,91 @@ +from _Framework.ModeSelectorComponent import ModeSelectorComponent +from ConfigurableButtonElement import ConfigurableButtonElement +from K_MixUtility import K_MixUtility +from MIDI import * + +class VUModeSelector(ModeSelectorComponent, K_MixUtility): + """Class that selects between modes""" + + def __init__(self,mixer): + ModeSelectorComponent.__init__(self) + self._mixer = mixer + self.set_mode_toggle(self.button(CHANNEL,VU_BUTTON)) + #self.update() + + + def set_modes_buttons(self, buttons): + #raise buttons == None or isinstance(buttons, tuple) or len(buttons) == self.number_of_modes() or AssertionError + identify_sender = True + for button in self._modes_buttons: + button.remove_value_listener(self._mode_value) + button.remove_value_listener(self._mode_release) + self._modes_buttons = [] + if buttons != None: + for button in buttons: + #raise isinstance(button, ButtonElement) or AssertionError + self._modes_buttons.append(button) + button.add_value_listener(self._mode_value, identify_sender) + button.add_value_listener(self._mode_release, identify_sender) + self.set_mode(0) + + + def set_mode_toggle(self, button): + #if not (button == None or isinstance(button, ConfigurableButtonElement)): + # raise AssertionError + if self._mode_toggle != None: + self._mode_toggle.remove_value_listener(self._toggle_value) + #self._mode_toggle.remove_value_listener(self._mode_release) + self._mode_toggle = button + self._mode_toggle != None and self._mode_toggle.add_value_listener(self._toggle_value) + #self._mode_toggle.add_value_listener(self._mode_release) + self.set_mode(0) + + def number_of_modes(self): + return 2 + + def on_enabled_changed(self): + self.update() + ''' + def set_mode(self, mode): + if mode < self.number_of_modes(): + self._mode_index = mode + self.update() + ''' + def update(self): + super(VUModeSelector, self).update() + + def on_selected_track_changed(self): + track = self.song().view.selected_track + device_count = track.devices + ''' + if len(device_count) != 0: + if self._device.selected_device != self.song().view.selected_track.devices[0]: + self.song().view.select_device(self.song().view.selected_track.devices[0]) + #self._device.selected_device = self.song().view.selected_track.devices[0] + self._mixer.on_selected_track_changed() + else: + self._mixer.on_selected_track_changed() + ''' + self._mixer.on_selected_track_changed() + + def _toggle_value(self, value): + index = self._mode_index + if self._mixer.is_active == True: + if value != 0: + if index == 0: + self.set_mode(1) + self._mixer.VU_mode = 1 + if index == 1: + self.set_mode(0) + self._mixer.VU_mode = 0 + self._mixer.setup_sliders() + if value == 0: + if index == 1: + self._mode_toggle.send_value(1) + + def _mode_release(self, value): + if value == 0: + index = self._mode_index + if index == 1: + self._mode_toggle.send_value(1) + \ No newline at end of file diff --git a/K_Mix_ver_1_1/__init__.py b/K_Mix_ver_1_1/__init__.py new file mode 100644 index 0000000..f5a52d4 --- /dev/null +++ b/K_Mix_ver_1_1/__init__.py @@ -0,0 +1,13 @@ + + +""" + +Created By Evan Bogunia 2016 +evanbeta@keithmcmillen.com + +""" + +from K_Mix import K_Mix + +def create_instance(c_instance): + return K_Mix(c_instance)