latest from gluon

ADVANCE/Advance.py

@@ -0,0 +1,45 @@
+#Embedded file name: /Users/versonator/Jenkins/live/output/mac_64_static/Release/python-bundle/MIDI Remote Scripts/ADVANCE/Advance.py
+from __future__ import with_statement
+import Live
+from _Framework.ControlSurface import ControlSurface
+from _Framework.Layer import Layer
+from _Framework.DeviceComponent import DeviceComponent
+from _Framework.DrumRackComponent import DrumRackComponent
+from _Framework.TransportComponent import TransportComponent
+from _Framework.InputControlElement import MIDI_CC_TYPE, MIDI_NOTE_TYPE
+from _Framework.ButtonMatrixElement import ButtonMatrixElement
+from _Framework.ButtonElement import ButtonElement
+from _Framework.EncoderElement import EncoderElement
+PAD_CHANNEL = 1
+PAD_IDS = ((81, 83, 84, 86),
+ (74, 76, 77, 79),
+ (67, 69, 71, 72),
+ (60, 62, 64, 65))
+
+def make_encoder(identifier, name):
+    return EncoderElement(MIDI_CC_TYPE, 0, identifier, Live.MidiMap.MapMode.absolute, name=name)
+
+
+def make_button(identifier, name, msg_type = MIDI_NOTE_TYPE, channel = PAD_CHANNEL):
+    return ButtonElement(True, msg_type, channel, identifier, name=name)
+
+
+class Advance(ControlSurface):
+
+    def __init__(self, *a, **k):
+        super(Advance, self).__init__(*a, **k)
+        with self.component_guard():
+            encoders = ButtonMatrixElement(rows=[[ make_encoder(index + 22, 'Encoder_%d' % index) for index in xrange(8) ]])
+            pads = ButtonMatrixElement(rows=[ [ make_button(identifier, 'Pad_%d_%d' % (col, row)) for col, identifier in enumerate(row_ids) ] for row, row_ids in enumerate(PAD_IDS) ])
+            device = DeviceComponent(is_enabled=False, layer=Layer(parameter_controls=encoders))
+            device.set_enabled(True)
+            self.set_device_component(device)
+            self._device_selection_follows_track_selection = True
+            drums = DrumRackComponent(is_enabled=False, layer=Layer(pads=pads))
+            drums.set_enabled(True)
+            play_button = make_button(118, 'Play_Button', MIDI_CC_TYPE, 0)
+            stop_button = make_button(117, 'Stop_Button', MIDI_CC_TYPE, 0)
+            record_button = make_button(119, 'Record_Button', MIDI_CC_TYPE, 0)
+            loop_button = make_button(114, 'Loop_Button', MIDI_CC_TYPE, 0)
+            transport = TransportComponent(is_enabled=False, layer=Layer(play_button=play_button, stop_button=stop_button, record_button=record_button, loop_button=loop_button))
+            transport.set_enabled(True)

ADVANCE/__init__.py

@@ -0,0 +1,11 @@
+#Embedded file name: /Users/versonator/Jenkins/live/output/mac_64_static/Release/python-bundle/MIDI Remote Scripts/ADVANCE/__init__.py
+import _Framework.Capabilities as caps
+from .Advance import Advance
+
+def get_capabilities():
+    return {caps.CONTROLLER_ID_KEY: caps.controller_id(vendor_id=2536, product_ids=[46, 47, 48], model_name=['ADVANCE25', 'ADVANCE49', 'ADVANCE61']),
+     caps.PORTS_KEY: [caps.inport(props=[caps.NOTES_CC, caps.SCRIPT, caps.REMOTE]), caps.outport(props=[caps.NOTES_CC, caps.SCRIPT])]}
+
+
+def create_instance(c_instance):
+    return Advance(c_instance)

AIRA_MX_1/Colors.py

@@ -0,0 +1,21 @@
+#Embedded file name: /Users/versonator/Jenkins/live/output/mac_64_static/Release/python-bundle/MIDI Remote Scripts/AIRA_MX_1/Colors.py
+from _Framework.ButtonElement import Color
+BLINK_LED_CHANNEL = 14
+
+class Blink(Color):
+
+    def draw(self, interface):
+        interface.send_value(self.midi_value)
+        interface.send_value(0, channel=BLINK_LED_CHANNEL)
+
+
+class Rgb:
+    BLACK = Color(0)
+    RED = Color(5)
+    RED_BLINK = Blink(5)
+    GREEN_HALF = Color(20)
+    GREEN = Color(21)
+    GREEN_BLINK = Blink(21)
+    BLUE_HALF = Color(44)
+    BLUE = Color(45)
+    BLUE_BLINK = Blink(45)

AIRA_MX_1/ControlElementUtils.py

@@ -0,0 +1,20 @@
+#Embedded file name: /Users/versonator/Jenkins/live/output/mac_64_static/Release/python-bundle/MIDI Remote Scripts/AIRA_MX_1/ControlElementUtils.py
+import Live
+from _Framework.Resource import PrioritizedResource
+from _Framework.Dependency import depends
+from _Framework.InputControlElement import MIDI_NOTE_TYPE, MIDI_CC_TYPE
+from _Framework.ComboElement import ComboElement
+from _Framework.ButtonElement import ButtonElement
+from _Framework.EncoderElement import EncoderElement
+
+@depends(skin=None)
+def make_button(name, identifier, channel = 0, msg_type = MIDI_NOTE_TYPE, is_momentary = True, is_modifier = False, skin = None):
+    return ButtonElement(is_momentary, msg_type, channel, identifier, name=name, resource_type=PrioritizedResource if is_modifier else None, skin=skin)
+
+
+def make_encoder(name, identifier, channel = 0):
+    return EncoderElement(MIDI_CC_TYPE, channel, identifier, Live.MidiMap.MapMode.absolute, name=name)
+
+
+def with_modifier(control, modifier):
+    return ComboElement(control, modifiers=[modifier], name=control.name + '_With_Modifier')

AIRA_MX_1/NotifyingMixerComponent.py

@@ -0,0 +1,30 @@
+#Embedded file name: /Users/versonator/Jenkins/live/output/mac_64_static/Release/python-bundle/MIDI Remote Scripts/AIRA_MX_1/NotifyingMixerComponent.py
+from _Framework.MixerComponent import MixerComponent
+from _Framework.Control import ButtonControl
+
+class NotifyingMixerComponent(MixerComponent):
+    """
+    Special mixer class that uses return tracks alongside midi and
+    audio tracks and includes controls for incrementing/decrementing
+    between sends.
+    """
+    send_index_up_button = ButtonControl()
+    send_index_down_button = ButtonControl()
+    modifier_button = ButtonControl(color=0, pressed_color=127)
+
+    def tracks_to_use(self):
+        return tuple(self.song().visible_tracks) + tuple(self.song().return_tracks)
+
+    @send_index_up_button.pressed
+    def send_index_up_button(self, button):
+        self._adjust_send_index(1)
+
+    @send_index_down_button.pressed
+    def send_index_down_button(self, button):
+        self._adjust_send_index(-1)
+
+    def _adjust_send_index(self, factor):
+        new_index = self.send_index + factor
+        if 0 <= new_index < self.num_sends:
+            self.send_index = new_index
+            self._show_msg_callback('Tone/Filter Controlling Send: %s' % self.song().return_tracks[self.send_index].name)

AIRA_MX_1/NotifyingSessionComponent.py

@@ -0,0 +1,118 @@
+#Embedded file name: /Users/versonator/Jenkins/live/output/mac_64_static/Release/python-bundle/MIDI Remote Scripts/AIRA_MX_1/NotifyingSessionComponent.py
+from itertools import count, izip_longest
+from _Framework.SubjectSlot import subject_slot, subject_slot_group
+from _Framework.SessionComponent import SessionComponent, SceneComponent
+
+class SpecialSceneComponent(SceneComponent):
+    """
+    Special scene class that indicates whether any clips are
+    playing/triggered on the scene.
+    """
+
+    def __init__(self, *a, **k):
+        super(SpecialSceneComponent, self).__init__(*a, **k)
+        self._playing_value = 127
+        self._scene_index = 0
+
+    def scene_name(self):
+        if self._scene and self._scene.name:
+            return self._scene.name
+
+    def set_playing_value(self, value):
+        self._playing_value = value
+
+    def set_scene(self, scene):
+        if scene != self._scene or type(self._scene) != type(scene):
+            self._scene = scene
+            self._on_is_triggered_changed.subject = scene
+            self._on_scene_color_changed.subject = scene
+            if self._scene:
+                self._scene_index = list(self.song().scenes).index(self._scene)
+            self.update()
+
+    def update_light(self):
+        self._update_launch_button()
+
+    def _update_launch_button(self):
+        if self.is_enabled() and self._launch_button is not None:
+            value_to_send = self._no_scene_value
+            if self._scene:
+                if self._has_fired_slots():
+                    value_to_send = self._triggered_value
+                elif self._has_playing_slots():
+                    value_to_send = self._playing_value
+                else:
+                    value_to_send = self._scene_value
+            if value_to_send is None:
+                self._launch_button.turn_off()
+            else:
+                self._launch_button.set_light(value_to_send)
+
+    def _has_fired_slots(self):
+        for track in self.song().tracks:
+            if track.fired_slot_index == self._scene_index:
+                return True
+
+        return False
+
+    def _has_playing_slots(self):
+        for track in self.song().tracks:
+            if track.playing_slot_index == self._scene_index:
+                return True
+
+        return False
+
+
+class NotifyingSessionComponent(SessionComponent):
+    """
+    Special session class that uses the status bar to display
+    the scene name or number being controlled.
+    """
+    scene_component_type = SpecialSceneComponent
+
+    def __init__(self, *a, **k):
+        super(NotifyingSessionComponent, self).__init__(*a, **k)
+        self._last_scene_offset = self._scene_offset
+        self._on_offset_changed.subject = self
+
+    def set_clip_launch_buttons(self, buttons):
+        first_scene = self.scene(0)
+        for track_index, button in izip_longest(xrange(self._num_tracks), buttons or []):
+            slot = first_scene.clip_slot(track_index)
+            slot.set_launch_button(button)
+
+    def _enable_skinning(self):
+        super(NotifyingSessionComponent, self)._enable_skinning()
+        for scene_index in xrange(self._num_scenes):
+            scene = self.scene(scene_index)
+            scene.set_playing_value('Session.ScenePlaying')
+
+    def _reassign_tracks(self):
+        tracks_to_use = self.song().tracks
+        self._on_fired_slot_index_changed.replace_subjects(tracks_to_use, count())
+        self._on_playing_slot_index_changed.replace_subjects(tracks_to_use, count())
+        self._update_stop_track_clip_buttons()
+        self._update_scene_launch_buttons()
+
+    @subject_slot_group('fired_slot_index')
+    def _on_fired_slot_index_changed(self, track_index):
+        super(NotifyingSessionComponent, self)._on_fired_slot_index_changed(track_index)
+        self._update_scene_launch_buttons()
+
+    @subject_slot_group('playing_slot_index')
+    def _on_playing_slot_index_changed(self, track_index):
+        super(NotifyingSessionComponent, self)._on_playing_slot_index_changed(track_index)
+        self._update_scene_launch_buttons()
+
+    def _update_scene_launch_buttons(self):
+        for scene in self._scenes:
+            scene.update_light()
+
+    @subject_slot('offset')
+    def _on_offset_changed(self):
+        if self._last_scene_offset != self._scene_offset:
+            name = self._scenes[0].scene_name()
+            if not name:
+                name = self._scene_offset + 1
+            self._show_msg_callback('Controlling Scene %s' % name)
+            self._last_scene_offset = self._scene_offset

AIRA_MX_1/README.md

@@ -0,0 +1,5 @@
+# Roland MX 1
+This scripts adds support for the Roland MX 1 mixer.
+
+## Maintainers
+stm

AIRA_MX_1/RolandMX1.py

@@ -0,0 +1,73 @@
+#Embedded file name: /Users/versonator/Jenkins/live/output/mac_64_static/Release/python-bundle/MIDI Remote Scripts/AIRA_MX_1/RolandMX1.py
+from __future__ import with_statement
+from functools import partial
+from _Framework.Util import recursive_map
+from _Framework.ControlSurface import OptimizedControlSurface
+from _Framework.TransportComponent import TransportComponent
+from _Framework.ModesComponent import ModesComponent, AddLayerMode
+from _Framework.ButtonMatrixElement import ButtonMatrixElement
+from _Framework.Layer import Layer
+from _Framework.Util import const
+from _Framework.Dependency import inject
+from .ControlElementUtils import make_button, make_encoder, with_modifier
+from .NotifyingMixerComponent import NotifyingMixerComponent
+from .NotifyingSessionComponent import NotifyingSessionComponent
+from .SkinDefault import make_default_skin
+NUM_TRACKS = 11
+NUM_SCENES = 11
+
+class RolandMX1(OptimizedControlSurface):
+
+    def __init__(self, *a, **k):
+        super(RolandMX1, self).__init__(*a, **k)
+        with self.component_guard():
+            self._skin = make_default_skin()
+            with inject(skin=const(self._skin)).everywhere():
+                self._create_controls()
+            self._transport = self._create_transport()
+            self._mixer = self._create_mixer()
+            self._session = self._create_session()
+            self._step_button_modes = self._create_step_button_modes()
+
+    def _create_controls(self):
+        self._aux_button = make_button('Aux_Button', 32, is_modifier=True)
+        self._cursor_up_button = make_button('Cursor_Up_Button', 12)
+        self._cursor_down_button = make_button('Cursor_Down_Button', 13)
+        self._modified_cursor_up_button = with_modifier(self._cursor_up_button, self._aux_button)
+        self._modified_cursor_down_button = with_modifier(self._cursor_down_button, self._aux_button)
+        self._start_stop_button = make_button('Start_Stop_Button', 16)
+        self._modified_start_stop_button = with_modifier(self._start_stop_button, self._aux_button)
+        self._recall_button = make_button('Recall_Button', 17)
+        self._store_button = make_button('Store_Button', 18)
+        self._tone_filter_knobs = ButtonMatrixElement(rows=[[ make_encoder('Tone_Filter_Encoder_%d' % (col,), identifier) for col, identifier in enumerate(xrange(102, 113)) ]], name='Tone_Filter_Knobs')
+        step_buttons_raw = [[ make_button('Step_Button_%d' % (col,), identifier) for col, identifier in enumerate(xrange(20, 31)) ]]
+        self._step_buttons = ButtonMatrixElement(rows=step_buttons_raw, name='Step_Buttons')
+        self._modified_step_buttons = ButtonMatrixElement(rows=recursive_map(partial(with_modifier, modifier=self._aux_button), step_buttons_raw), name='Step_Buttons_With_Modifier')
+        self._select_buttons = ButtonMatrixElement(rows=[[ make_button('Select_Button_%d' % (col,), identifier) for col, identifier in enumerate(xrange(60, 71)) ]], name='Select_Buttons')
+        self._bfx_buttons = ButtonMatrixElement(rows=[[ make_button('BFX_Button_%d' % (col,), identifier) for col, identifier in enumerate(xrange(80, 91)) ]], name='BFX_Buttons')
+        self._mfx_buttons = ButtonMatrixElement(rows=[[ make_button('MFX_Button_%d' % (col,), identifier) for col, identifier in enumerate(xrange(100, 111)) ]], name='MFX_Buttons')
+
+    def _create_transport(self):
+        transport = TransportComponent(play_toggle_model_transform=lambda v: v)
+        transport.layer = Layer(record_button=self._modified_start_stop_button, play_button=self._start_stop_button)
+        return transport
+
+    def _create_mixer(self):
+        mixer = NotifyingMixerComponent(NUM_TRACKS, auto_name=True)
+        mixer.layer = Layer(send_controls=self._tone_filter_knobs, track_select_buttons=self._select_buttons, arm_buttons=self._bfx_buttons, solo_buttons=self._mfx_buttons, send_index_up_button=self._modified_cursor_up_button, send_index_down_button=self._modified_cursor_down_button, modifier_button=self._aux_button)
+        return mixer
+
+    def _create_session(self):
+        session = NotifyingSessionComponent(NUM_TRACKS, NUM_SCENES, enable_skinning=True, auto_name=True)
+        session.layer = Layer(scene_bank_down_button=self._cursor_up_button, scene_bank_up_button=self._cursor_down_button)
+        return session
+
+    def _create_step_button_modes(self):
+        matrix_modes = ModesComponent(name='Step_Button_Modes')
+        clip_mode = AddLayerMode(self._session, Layer(clip_launch_buttons=self._step_buttons, stop_track_clip_buttons=self._modified_step_buttons))
+        scene_mode = AddLayerMode(self._session, Layer(scene_launch_buttons=self._step_buttons))
+        matrix_modes.add_mode('clip', clip_mode)
+        matrix_modes.add_mode('scene', scene_mode)
+        matrix_modes.layer = Layer(clip_button=self._recall_button, scene_button=self._store_button)
+        matrix_modes.selected_mode = 'clip'
+        return matrix_modes

AIRA_MX_1/SkinDefault.py

@@ -0,0 +1,23 @@
+#Embedded file name: /Users/versonator/Jenkins/live/output/mac_64_static/Release/python-bundle/MIDI Remote Scripts/AIRA_MX_1/SkinDefault.py
+from _Framework.Skin import Skin
+from Colors import Rgb
+
+class Colors:
+
+    class Session:
+        ClipEmpty = Rgb.BLACK
+        ClipStopped = Rgb.GREEN_HALF
+        ClipStarted = Rgb.GREEN
+        ClipRecording = Rgb.RED
+        ClipTriggeredPlay = Rgb.GREEN_BLINK
+        ClipTriggeredRecord = Rgb.RED_BLINK
+        NoScene = Rgb.BLACK
+        Scene = Rgb.BLUE_HALF
+        SceneTriggered = Rgb.BLUE_BLINK
+        ScenePlaying = Rgb.BLUE
+        StopClip = Rgb.RED
+        StopClipTriggered = Rgb.RED_BLINK
+
+
+def make_default_skin():
+    return Skin(Colors)

AIRA_MX_1/__init__.py

@@ -0,0 +1,14 @@
+#Embedded file name: /Users/versonator/Jenkins/live/output/mac_64_static/Release/python-bundle/MIDI Remote Scripts/AIRA_MX_1/__init__.py
+from _Framework.Capabilities import CONTROLLER_ID_KEY, PORTS_KEY, SCRIPT, controller_id, inport, outport
+from RolandMX1 import RolandMX1
+
+def get_capabilities():
+    return {CONTROLLER_ID_KEY: controller_id(vendor_id=1410, product_ids=[419], model_name=['MX-1']),
+     PORTS_KEY: [inport(props=[]),
+                 inport(props=[SCRIPT]),
+                 outport(props=[]),
+                 outport(props=[SCRIPT])]}
+
+
+def create_instance(c_instance):
+    return RolandMX1(c_instance=c_instance)