def _setup_transport_control(self): self._transport = TransportComponent() self._transport.layer = Layer(play_button = self._button[6], loop_button = self._button[7], seek_backward_button = self._button[8], record_button = self._button[9]) self._transport.set_enabled(True)
def _create_transport(self):
self._transport = TransportComponent(name=u'Transport',
is_enabled=False,
layer=Layer(
loop_button=u'loop_button',
stop_button=u'stop_button',
play_button=u'play_button'))
self._transport.set_enabled(True)
def _create_transport(self):
self._transport = TransportComponent(
name=u'Transport',
is_enabled=False,
layer=Layer(play_button=u'play_button',
loop_button=u'play_button_with_shift',
stop_button=u'stop_button',
metronome_button=u'click_button'))
self._transport.set_enabled(True)
def _create_transport(self):
self._transport = TransportComponent(name='Transport',
is_enabled=False,
layer=Layer(loop_button='loop_button',
stop_button='stop_button',
play_button='play_button',
metronome_button='metronome_button',
seek_forward_button='fastforward_button',
seek_backward_button='rewind_button'))
self._transport.set_enabled(True)
def _create_transport(self):
self._transport = TransportComponent(
name='Transport',
is_enabled=False,
layer=Layer(seek_forward_button=self._ff_button,
seek_backward_button=self._rw_button,
stop_button=self._stop_button,
play_button=self._play_button,
record_button=self._record_button))
self._transport.set_enabled(True)
def _setup_transport_control(self): self._transport = TransportComponent() self._transport.layer = Layer(play_button = self._button[6], loop_button = self._button[7], seek_backward_button = self._button[8], record_button = self._button[9]) self._transport.set_enabled(True)
def _create_transport(self):
self._transport = TransportComponent(name='Transport')
self._transport.layer = Layer(play_button=(self._play_button),
stop_button=(self._stop_button))
self._session_recording = SessionRecordingComponent(
name='Session_Recording')
self._session_recording.layer = Layer(
record_button=(self._record_button),
record_stop_button=(self._record_stop_button))
class Code(ControlSurface):
mixer_navigation_type = MixerNavigationComponent
def __init__(self, *a, **k):
super(Code, self).__init__(*a, **k)
with self.component_guard():
with inject(skin=const(make_default_skin())).everywhere():
self._create_controls()
self._create_transport()
self._create_mixer()
self._create_mixer_navigation()
def _create_controls(self):
self._rw_button = make_button(91, 'RW_Button')
self._ff_button = make_button(92, 'FF_Button')
self._stop_button = make_button(93, 'Stop_Button')
self._play_button = make_button(94, 'Play_Button')
self._record_button = make_button(95, 'Record_Button')
self._faders = ButtonMatrixElement(rows=[[ make_slider(index, 'Fader_%d' % (index + 1,)) for index in xrange(8) ]], name='Faders')
self._master_fader = make_slider(8, 'Master_Fader')
self._encoders = ButtonMatrixElement(rows=[[ make_encoder(index + 16, 'Encoder_%d' % (index + 1,)) for index in xrange(8) ]], name='Encoders')
self._track_select_buttons = ButtonMatrixElement(rows=[[ make_button(index + 24, 'Track_Select_Button_%d' % (index + 1,)) for index in xrange(8) ]], name='Track_Select_Buttons')
self._mute_buttons = ButtonMatrixElement(rows=[[ make_button(index + 8, 'Mute_Button_%d' % (index + 1,)) for index in xrange(8) ]], name='Mute_Buttons')
self._solo_buttons = ButtonMatrixElement(rows=[[ make_button(index + 16, 'Solo_Button_%d' % (index + 1,)) for index in xrange(8) ]], name='Solo_Buttons')
self._arm_buttons = ButtonMatrixElement(rows=[[ make_button(index, 'Record_Arm_Button_%d' % (index + 1,)) for index in xrange(8) ]], name='Record_Arm_Buttons')
self._bank_up_button = make_button(47, 'Bank_Up_Button')
self._bank_down_button = make_button(46, 'Bank_Down_Button')
def _create_transport(self):
self._transport = TransportComponent(name='Transport', is_enabled=False, layer=Layer(seek_forward_button=self._ff_button, seek_backward_button=self._rw_button, stop_button=self._stop_button, play_button=self._play_button, record_button=self._record_button))
self._transport.set_enabled(True)
def _create_mixer(self):
self._session_ring = SessionRingComponent(name='Session_Navigation', num_tracks=8, num_scenes=0, is_enabled=False)
self._mixer = MixerComponent(name='Mixer', is_enabled=False, tracks_provider=self._session_ring, invert_mute_feedback=True, layer=Layer(volume_controls=self._faders, pan_controls=self._encoders, track_select_buttons=self._track_select_buttons, solo_buttons=self._solo_buttons, mute_buttons=self._mute_buttons, arm_buttons=self._arm_buttons))
self._mixer.master_strip().layer = Layer(volume_control=self._master_fader)
self._mixer.set_enabled(True)
def _create_mixer_navigation(self):
self._mixer_navigation = self.mixer_navigation_type(name='Mixer_Navigation', is_enabled=False, session_ring=self._session_ring, layer=Layer(page_left_button=self._bank_down_button, page_right_button=self._bank_up_button))
self._mixer_navigation.set_enabled(True)
class GuitarWing(LividControlSurface): _sysex_id = 20 _model_name = 'GuitarWing' def __init__(self, *a, **k): super(GuitarWing, self).__init__(*a, **k) self._skin = Skin(GuitarWingColors) with self.component_guard(): self._setup_controls() self._setup_m4l_interface() self._setup_session_control() self._setup_mixer_control() self._setup_device_control() self._setup_transport_control() self._setup_view_control() def _setup_controls(self): is_momentary = True optimized = True resource = PrioritizedResource self._button = [MonoButtonElement(is_momentary = is_momentary, msg_type = MIDI_NOTE_TYPE, channel = CHANNEL, identifier = BUTTONS[index], name = 'Button_' + str(index), script = self, skin = self._skin, optimized_send_midi = optimized, resource_type = resource, monobridge = self._monobridge) for index in range(10)] self._fader = [MonoEncoderElement(msg_type = MIDI_CC_TYPE, channel = CHANNEL, identifier = SLIDERS[index], name = 'Fader_' + str(index), num = index, script = self, optimized_send_midi = optimized, resource_type = resource, monobridge = self._monobridge) for index in range(3)] self._fader_button = [MonoEncoderElement(msg_type = MIDI_NOTE_TYPE, channel = CHANNEL, identifier = SLIDERS[index], name = 'Fader_Button_' + str(index), num = index, script = self, optimized_send_midi = optimized, resource_type = resource, monobridge = self._monobridge) for index in range(3)] self._ccs = [MonoEncoderElement(msg_type = MIDI_CC_TYPE, channel = CHANNEL, identifier = CCS[index], name = 'CCs_' + str(index), num = index, script = self, optimized_send_midi = optimized, resource_type = resource, monobridge = self._monobridge) for index in range(4)] self._pad = [MonoButtonElement(is_momentary = is_momentary, msg_type = MIDI_NOTE_TYPE, channel = CHANNEL, identifier = PADS[index], name = 'Pad_' + str(index), script = self, skin = self._skin, optimized_send_midi = optimized, resource_type = resource, monobridge = self._monobridge) for index in range(5)] self._padCC = [MonoEncoderElement(msg_type = MIDI_CC_TYPE, channel = CHANNEL, identifier = PADS[index], name = 'PadCC_' + str(index), num = index, script = self, optimized_send_midi = optimized, resource_type = resource, monobridge = self._monobridge) for index in range(5)] self._accel = [MonoEncoderElement(msg_type = MIDI_CC_TYPE, channel = CHANNEL, identifier = ACCELS[index], name = 'Accel_' + str(index), num = index, script = self, optimized_send_midi = optimized, resource_type = resource, monobridge = self._monobridge) for index in range(3)] self._parameter_control_matrix = ButtonMatrixElement(rows = [ [ self._fader[0], self._fader[1], self._fader[2], self._accel[2], self._ccs[0], self._ccs[1], self._ccs[2], self._ccs[3] ]]) self._scene_launch_matrix = ButtonMatrixElement(rows = [self._pad[:4]]) def _setup_session_control(self): self._session_ring = SessionRingComponent(num_tracks = 1, num_scenes = 4, tracks_to_use = lambda : self.song.visible_tracks + self.song.return_tracks) self._session_ring.set_enabled(False) self._session = SessionComponent(session_ring = self._session_ring, auto_name = True) hasattr(self._session, '_enable_skinning') and self._session._enable_skinning() self._session.layer = Layer(scene_launch_buttons = self._scene_launch_matrix) self._session_navigation =SessionNavigationComponent(name = 'SessionNavigation', session_ring = self._session_ring) self._session_navigation._horizontal_banking.scroll_up_button.color = 'Session.NavigationButtonOn' self._session_navigation._horizontal_banking.scroll_down_button.color = 'Session.NavigationButtonOn' self._session_navigation.layer = Layer(left_button = self._button[1], right_button = self._button[0]) self._session_navigation.set_enabled(True) def _setup_mixer_control(self): self._mixer = MonoMixerComponent(name = 'Mixer', tracks_provider = self._session_ring, track_assigner = SimpleTrackAssigner(), invert_mute_feedback = True, auto_name = True, enable_skinning = True, channel_strip_component_type = MonoChannelStripComponent) self.song.view.selected_track = self._mixer.channel_strip(0)._track def _setup_transport_control(self): self._transport = TransportComponent() self._transport.layer = Layer(play_button = self._button[6], loop_button = self._button[7], seek_backward_button = self._button[8], record_button = self._button[9]) self._transport.set_enabled(True) def _setup_device_control(self): self._device = DeviceComponent(name = 'Device_Component', device_provider = self._device_provider, device_bank_registry = DeviceBankRegistry()) self._device.layer = Layer(parameter_controls = self._parameter_control_matrix) self._device.set_enabled(True) def _setup_m4l_interface(self): self._m4l_interface = M4LInterfaceComponent(controls=self.controls, component_guard=self.component_guard) self.get_control_names = self._m4l_interface.get_control_names self.get_control = self._m4l_interface.get_control self.grab_control = self._m4l_interface.grab_control self.release_control = self._m4l_interface.release_control def _setup_view_control(self): self._view_control = ViewControlComponent() self._view_control.layer = Layer(prev_track_button = self._button[1], next_track_button = self._button[0])
class Oxygen_Pro(IdentifiableControlSurface):
session_height = 2
session_width = 8
live_mode_byte = midi.LIVE_MODE_BYTE
pad_ids = ((40, 41, 42, 43, 48, 49, 50, 51), (36, 37, 38, 39, 44, 45, 46, 47))
device_parameter_component = SimpleDeviceParameterComponent
has_session_component = True
def __init__(self, *a, **k):
(super(Oxygen_Pro, self).__init__)(a, product_id_bytes=midi.M_AUDIO_MANUFACTURER_ID + (0, ), **k)
self._last_selected_knob_mode = 'device'
with self.component_guard():
self._elements = Elements(self.session_height, self.session_width, self.pad_ids)
with inject(element_container=(const(self._elements))).everywhere():
self._create_background()
self._create_transport()
self._create_undo_redo()
self._create_session()
self._create_mixer()
self._create_device_parameters()
self._create_record_modes()
self._create_button_modes()
self._create_knob_modes()
self._create_takeover_modes()
self._Oxygen_Pro__on_main_view_changed.subject = self.application.view
def on_identified(self, response_bytes):
self._elements.firmware_mode_switch.send_value(self.live_mode_byte)
self._elements.control_mode_switch.send_value(midi.RECORD_MODE_BYTE)
self._elements.control_mode_switch.send_value(midi.DEVICE_MODE_BYTE)
self._elements.led_control_switch.send_value(midi.LED_ENABLE_BYTE)
self._elements.led_mode_switch.send_value(midi.SOFTWARE_CONTROL_BYTE)
self._button_modes.selected_mode = 'arm'
self._knob_modes.selected_mode = 'device'
if self.has_session_component:
self._session_ring.set_enabled(True)
super(Oxygen_Pro, self).on_identified(response_bytes)
def port_settings_changed(self):
if self.has_session_component:
self._session_ring.set_enabled(False)
super(Oxygen_Pro, self).port_settings_changed()
def _create_background(self):
self._background = BackgroundComponent(name='Background',
is_enabled=False,
add_nop_listeners=True,
layer=Layer(shift_button='shift_button'))
self._background.set_enabled(True)
def _create_transport(self):
self._transport = TransportComponent(name='Transport',
is_enabled=False,
layer=Layer(loop_button='loop_button',
stop_button='stop_button',
play_button='play_button',
metronome_button='metronome_button',
seek_forward_button='fastforward_button',
seek_backward_button='rewind_button'))
self._transport.set_enabled(True)
def _create_undo_redo(self):
self._undo_redo = UndoRedoComponent(name='Undo_Redo',
is_enabled=False,
layer=Layer(undo_button='back_button'))
self._undo_redo.set_enabled(True)
def _create_session(self):
self._session_ring = SessionRingComponent(name='Session_Ring',
is_enabled=False,
num_tracks=(self.session_width),
num_scenes=(self.session_height))
if self.has_session_component:
self._session = SessionComponent(name='Session',
is_enabled=False,
session_ring=(self._session_ring),
layer=Layer(clip_launch_buttons='pads',
scene_launch_buttons='scene_launch_buttons',
selected_scene_launch_button='encoder_push_button',
scene_encoder='encoder_with_encoder_push'))
self._session.set_enabled(True)
self._session_navigation = SessionNavigationComponent(name='Session_Navigation',
is_enabled=False,
session_ring=(self._session_ring),
layer=Layer(left_button='bank_left_button',
right_button='bank_right_button',
scene_encoder='encoder'))
self._session_navigation.set_enabled(True)
def _create_mixer(self):
self._mixer = MixerComponent(name='Mixer',
is_enabled=False,
auto_name=True,
channel_strip_component_type=ChannelStripComponent,
tracks_provider=(self._session_ring),
track_assigner=(SimpleTrackAssigner()),
layer=Layer(volume_controls='faders'))
self._mixer.master_strip().set_volume_control(self._elements.master_fader)
self._mixer.set_enabled(True)
def _create_device_parameters(self):
self._device_parameters = self.device_parameter_component(name='Device_Parameters',
is_enabled=False,
layer=Layer(parameter_controls='knobs'))
def _create_record_modes(self):
self._session_record = SessionRecordingComponent(name='Session_Record',
is_enabled=False,
layer=Layer(record_button='record_button'))
self._record_modes = ModesComponent(name='Record_Modes')
self._record_modes.add_mode('session', EnablingMode(self._session_record))
self._record_modes.add_mode('arrange', AddLayerMode((self._transport), layer=Layer(record_button='record_button')))
self._Oxygen_Pro__on_main_view_changed()
def _create_button_modes(self):
self._button_modes = ModesComponent(name='Button_Modes',
is_enabled=False,
layer=Layer(off_button='off_mode_button',
arm_button='arm_mode_button',
track_select_button='track_select_mode_button',
mute_button='mute_mode_button',
solo_button='solo_mode_button'))
self._button_modes.add_mode('off', None, behaviour=(ImmediateBehaviour()))
self._button_modes.add_mode('arm',
AddLayerMode((self._mixer), layer=Layer(arm_buttons='fader_buttons')),
behaviour=(ImmediateBehaviour()))
self._button_modes.add_mode('track_select',
AddLayerMode((self._mixer), layer=Layer(track_select_buttons='fader_buttons')),
behaviour=(ImmediateBehaviour()))
self._button_modes.add_mode('mute',
AddLayerMode((self._mixer), layer=Layer(mute_buttons='fader_buttons')),
behaviour=(ImmediateBehaviour()))
self._button_modes.add_mode('solo',
AddLayerMode((self._mixer), layer=Layer(solo_buttons='fader_buttons')),
behaviour=(ImmediateBehaviour()))
self._button_modes.selected_mode = 'arm'
self._button_modes.set_enabled(True)
def _create_knob_modes(self):
self._knob_modes = ModesComponent(name='Knob_Modes',
is_enabled=False,
layer=Layer(volume_button='volume_mode_button',
pan_button='pan_mode_button',
sends_button='sends_mode_button',
device_button='device_mode_button'))
self._knob_modes.add_mode('volume',
AddLayerMode((self._mixer), layer=Layer(volume_controls='knobs')),
behaviour=(ImmediateBehaviour()))
self._knob_modes.add_mode('pan',
AddLayerMode((self._mixer), layer=Layer(pan_controls='knobs')),
behaviour=(ImmediateBehaviour()))
self._knob_modes.add_mode('sends',
AddLayerMode((self._mixer), layer=Layer(send_controls='knobs')),
behaviour=ReenterBehaviour(on_reenter=(self._on_reenter_sends_mode)))
self._knob_modes.add_mode('device',
(self._device_parameters), behaviour=(self._get_device_mode_behaviour()))
self._knob_modes.add_mode('takeover', None)
self._knob_modes.selected_mode = 'device'
self._Oxygen_Pro__on_knob_mode_changed.subject = self._knob_modes
self._knob_modes.set_enabled(True)
def _get_device_mode_behaviour(self):
return ImmediateBehaviour()
def _on_reenter_sends_mode(self):
new_send_index = 1 if self._mixer.send_index == 0 else 0
if new_send_index in range(self._mixer.num_sends):
self._mixer.send_index = new_send_index
def _create_takeover_modes(self):
self._takeover_modes = ModesComponent(name='Takeover_Modes',
is_enabled=False,
layer=Layer(daw_button='daw_mode_button', preset_button='preset_mode_button'))
self._takeover_modes.add_mode('daw', self._select_knob_mode)
self._takeover_modes.add_mode('preset', (
self._select_knob_mode,
AddLayerMode((self._background),
layer=Layer(faders='faders', knobs='knobs'))))
self._takeover_modes.selected_mode = 'daw'
self._takeover_modes.set_enabled(True)
def _select_knob_mode(self):
if self._takeover_modes.selected_mode == 'daw':
self._knob_modes.selected_mode = self._last_selected_knob_mode
else:
self._knob_modes.selected_mode = 'takeover'
@listens('selected_mode')
def __on_knob_mode_changed(self, mode):
if mode != 'takeover':
self._last_selected_knob_mode = mode
@listens('is_view_visible', 'Session')
def __on_main_view_changed(self):
if self.application.view.is_view_visible('Session'):
self._record_modes.selected_mode = 'session'
else:
self._record_modes.selected_mode = 'arrange'
def _setup_transport_control(self): self._transport = TransportComponent() self._transport.name = 'Transport' self._transport.set_enabled(False)
class ATOM(ControlSurface):
def __init__(self, *a, **k):
super(ATOM, self).__init__(*a, **k)
with self.component_guard():
with inject(skin=const(skin)).everywhere():
self._elements = Elements()
with self.component_guard():
with inject(element_container=const(self._elements)).everywhere():
self._create_lighting()
self._create_transport()
self._create_record_modes()
self._create_undo()
self._create_view_toggle()
self._create_background()
self._create_session()
self._create_mixer()
self._create_encoder_modes()
self._create_session_navigation_modes()
self._create_keyboard()
self._create_drum_group()
self._create_note_modes()
self._create_pad_modes()
self._create_user_assignments_mode()
self._target_track = ArmedTargetTrackComponent(
name=u'Target_Track')
self.__on_target_track_changed.subject = self._target_track
self._drum_group_finder = self.register_disconnectable(
PercussionInstrumentFinder(
device_parent=self._target_track.target_track))
self.__on_drum_group_changed.subject = self._drum_group_finder
self.__on_drum_group_changed()
self.__on_main_view_changed.subject = self.application.view
def disconnect(self):
self._send_midi(midi.NATIVE_MODE_OFF_MESSAGE)
super(ATOM, self).disconnect()
def port_settings_changed(self):
self._send_midi(midi.NATIVE_MODE_ON_MESSAGE)
super(ATOM, self).port_settings_changed()
def _create_lighting(self):
self._lighting = LightingComponent(name=u'Lighting',
is_enabled=False,
layer=Layer(
shift_button=u'shift_button',
zoom_button=u'zoom_button'))
self._lighting.set_enabled(True)
def _create_transport(self):
self._transport = TransportComponent(
name=u'Transport',
is_enabled=False,
layer=Layer(play_button=u'play_button',
loop_button=u'play_button_with_shift',
stop_button=u'stop_button',
metronome_button=u'click_button'))
self._transport.set_enabled(True)
def _create_record_modes(self):
self._session_record = SessionRecordingComponent(
name=u'Session_Record',
is_enabled=False,
layer=Layer(record_button=u'record_button'))
self._record_modes = ModesComponent(name=u'Record_Modes')
self._record_modes.add_mode(u'session', self._session_record)
self._record_modes.add_mode(
u'arrange',
AddLayerMode(self._transport,
layer=Layer(record_button=u'record_button')))
self.__on_main_view_changed()
def _create_undo(self):
self._undo = UndoRedoComponent(
name=u'Undo',
is_enabled=False,
layer=Layer(undo_button=u'stop_button_with_shift'))
self._undo.set_enabled(True)
def _create_view_toggle(self):
self._view_toggle = ViewToggleComponent(
name=u'View_Toggle',
is_enabled=False,
layer=Layer(detail_view_toggle_button=u'show_hide_button',
main_view_toggle_button=u'preset_button'))
self._view_toggle.set_enabled(True)
def _create_background(self):
self._background = BackgroundComponent(
name=u'Background',
is_enabled=False,
add_nop_listeners=True,
layer=Layer(set_loop_button=u'set_loop_button',
nudge_button=u'nudge_button',
bank_button=u'bank_button'))
self._background.set_enabled(True)
def _create_session(self):
self._session_ring = SessionRingComponent(name=u'Session_Ring',
num_tracks=SESSION_WIDTH,
num_scenes=SESSION_HEIGHT)
self._session = SessionComponent(name=u'Session',
session_ring=self._session_ring)
self._session_navigation = SessionNavigationComponent(
name=u'Session_Navigation',
is_enabled=False,
session_ring=self._session_ring,
layer=Layer(left_button=u'left_button',
right_button=u'right_button'))
self._session_navigation.set_enabled(True)
self._session_overview = SessionOverviewComponent(
name=u'Session_Overview',
is_enabled=False,
session_ring=self._session_ring,
enable_skinning=True,
layer=Layer(button_matrix=u'pads_with_zoom'))
def _create_mixer(self):
self._mixer = MixerComponent(
name=u'Mixer',
auto_name=True,
tracks_provider=self._session_ring,
track_assigner=SimpleTrackAssigner(),
invert_mute_feedback=True,
channel_strip_component_type=ChannelStripComponent)
def _create_encoder_modes(self):
self._encoder_modes = ModesComponent(name=u'Encoder_Modes',
enable_skinning=True)
self._encoder_modes.add_mode(
u'volume',
AddLayerMode(self._mixer, Layer(volume_controls=u'encoders')))
self._encoder_modes.add_mode(
u'pan', AddLayerMode(self._mixer, Layer(pan_controls=u'encoders')))
self._encoder_modes.add_mode(
u'send_a',
AddLayerMode(self._mixer, Layer(send_a_controls=u'encoders')))
self._encoder_modes.add_mode(
u'send_b',
AddLayerMode(self._mixer, Layer(send_b_controls=u'encoders')))
self._encoder_modes.selected_mode = u'volume'
def _create_session_navigation_modes(self):
self._session_navigation_modes = ModesComponent(
name=u'Session_Navigation_Modes',
is_enabled=False,
layer=Layer(cycle_mode_button=u'bank_button'))
self._session_navigation_modes.add_mode(
u'default',
AddLayerMode(self._session_navigation,
layer=Layer(up_button=u'up_button',
down_button=u'down_button')),
cycle_mode_button_color=u'DefaultButton.Off')
self._session_navigation_modes.add_mode(
u'paged',
AddLayerMode(self._session_navigation,
layer=Layer(page_up_button=u'up_button',
page_down_button=u'down_button',
page_left_button=u'left_button',
page_right_button=u'right_button')),
cycle_mode_button_color=u'DefaultButton.On')
self._session_navigation_modes.selected_mode = u'default'
def _create_keyboard(self):
self._keyboard = KeyboardComponent(
midi.KEYBOARD_CHANNEL,
name=u'Keyboard',
is_enabled=False,
layer=Layer(matrix=u'pads',
scroll_up_button=u'up_button',
scroll_down_button=u'down_button'))
def _create_drum_group(self):
self._drum_group = DrumGroupComponent(
name=u'Drum_Group',
is_enabled=False,
translation_channel=midi.DRUM_CHANNEL,
layer=Layer(matrix=u'pads',
scroll_page_up_button=u'up_button',
scroll_page_down_button=u'down_button'))
def _create_note_modes(self):
self._note_modes = ModesComponent(name=u'Note_Modes', is_enabled=False)
self._note_modes.add_mode(u'keyboard', self._keyboard)
self._note_modes.add_mode(u'drum', self._drum_group)
self._note_modes.selected_mode = u'keyboard'
def _create_pad_modes(self):
self._pad_modes = ModesComponent(
name=u'Pad_Modes',
is_enabled=False,
layer=Layer(session_button=u'full_level_button',
note_button=u'note_repeat_button',
channel_button=u'select_button',
encoder_modes_button=u'setup_button'))
self._pad_modes.add_mode(
u'session',
(AddLayerMode(self._background,
Layer(unused_pads=u'pads_with_shift')),
AddLayerMode(
self._session,
Layer(clip_launch_buttons=u'pads',
scene_launch_buttons=self._elements.pads_with_shift.
submatrix[3:, :])), self._session_overview,
self._session_navigation_modes))
self._pad_modes.add_mode(u'note', self._note_modes)
self._pad_modes.add_mode(
u'channel',
(self._elements.pads.reset,
AddLayerMode(
self._mixer,
Layer(
arm_buttons=self._elements.pads.submatrix[:, :1],
solo_buttons=self._elements.pads.submatrix[:, 1:2],
track_select_buttons=self._elements.pads.submatrix[:,
2:3])),
AddLayerMode(
self._session,
Layer(stop_track_clip_buttons=self._elements.pads.
submatrix[:, 3:])), self._session_navigation_modes))
self._pad_modes.add_mode(
u'encoder_modes',
(LayerMode(
self._encoder_modes,
Layer(volume_button=self._elements.pads_raw[0][0],
pan_button=self._elements.pads_raw[0][1],
send_a_button=self._elements.pads_raw[0][2],
send_b_button=self._elements.pads_raw[0][3])),
AddLayerMode(
self._background,
Layer(unused_pads=self._elements.pads.submatrix[:, 1:]))),
behaviour=MomentaryBehaviour())
self._pad_modes.selected_mode = u'session'
self._pad_modes.set_enabled(True)
def _create_user_assignments_mode(self):
self._translating_background = TranslatingBackgroundComponent(
midi.USER_CHANNEL,
name=u'Translating_Background',
is_enabled=False,
add_nop_listeners=True,
layer=Layer(note_repeat_button=u'note_repeat_button',
full_level_button=u'full_level_button',
bank_button=u'bank_button',
preset_button=u'preset_button',
show_hide_button=u'show_hide_button',
nudge_button=u'nudge_button',
set_loop_button=u'set_loop_button',
setup_button=u'setup_button',
up_button=u'up_button',
down_button=u'down_button',
left_button=u'left_button',
right_button=u'right_button',
select_button=u'select_button',
click_button=u'click_button',
record_button=u'record_button',
play_button=u'play_button',
stop_button=u'stop_button',
pads=u'pads',
encoders=u'encoders'))
self._top_level_modes = ModesComponent(
name=u'Top_Level_Modes',
is_enabled=False,
support_momentary_mode_cycling=False,
layer=Layer(cycle_mode_button=u'editor_button'))
self._top_level_modes.add_mode(
u'default',
self.refresh_state,
cycle_mode_button_color=u'DefaultButton.Off')
self._top_level_modes.add_mode(
u'user',
self._translating_background,
cycle_mode_button_color=u'DefaultButton.On')
self._top_level_modes.selected_mode = u'default'
self._top_level_modes.set_enabled(True)
@listens(u'is_view_visible', u'Session')
def __on_main_view_changed(self):
if self.application.view.is_view_visible(u'Session'):
self._record_modes.selected_mode = u'session'
else:
self._record_modes.selected_mode = u'arrange'
@listens(u'target_track')
def __on_target_track_changed(self):
self._drum_group_finder.device_parent = self._target_track.target_track
@listens(u'instrument')
def __on_drum_group_changed(self):
drum_group = self._drum_group_finder.drum_group
self._drum_group.set_drum_group_device(drum_group)
self._note_modes.selected_mode = u'drum' if liveobj_valid(
drum_group) else u'keyboard'
class Oxygen_Pro(ControlSurface):
def __init__(self, *a, **k):
super(Oxygen_Pro, self).__init__(*a, **k)
with self.component_guard():
self._elements = Elements()
with inject(element_container=const(self._elements)).everywhere():
self._create_transport()
self._create_undo_redo()
self._create_device_parameters()
self._create_session()
self._create_mixer()
self._create_record_modes()
self.__on_main_view_changed.subject = self.application.view
def _create_transport(self):
self._transport = TransportComponent(name=u'Transport',
is_enabled=False,
layer=Layer(
loop_button=u'loop_button',
stop_button=u'stop_button',
play_button=u'play_button'))
self._transport.set_enabled(True)
def _create_undo_redo(self):
self._undo_redo = UndoRedoComponent(
name=u'Undo_Redo',
is_enabled=False,
layer=Layer(undo_button=u'back_button'))
self._undo_redo.set_enabled(True)
def _create_device_parameters(self):
self._device_parameters = SimpleDeviceParameterComponent(
name=u'Device_Parameters',
is_enabled=False,
layer=Layer(parameter_controls=u'knobs'))
self._device_parameters.set_enabled(True)
def _create_session(self):
self._session_ring = SessionRingComponent(name=u'Session_Ring',
num_tracks=SESSION_WIDTH,
num_scenes=SESSION_HEIGHT)
self._session = SessionComponent(
name=u'Session',
is_enabled=False,
session_ring=self._session_ring,
layer=Layer(clip_launch_buttons=u'pads',
scene_launch_buttons=u'scene_launch_buttons',
scene_encoder=u'encoder'))
self._session.selected_scene().set_launch_button(
self._elements.encoder_push_button)
self._session.set_enabled(True)
self._session_navigation = SessionNavigationComponent(
name=u'Session_Navigation',
is_enabled=False,
session_ring=self._session_ring,
layer=Layer(left_button=u'bank_left_button',
right_button=u'bank_right_button'))
self._session_navigation.set_up_button(self._elements.rewind_button)
self._session_navigation.set_down_button(
self._elements.fastforward_button)
self._session_navigation.set_enabled(True)
def _create_mixer(self):
self._mixer = MixerComponent(name=u'Mixer',
is_enabled=False,
auto_name=True,
tracks_provider=self._session_ring,
track_assigner=SimpleTrackAssigner(),
layer=Layer(volume_controls=u'faders',
arm_buttons=u'fader_buttons'))
self._mixer.master_strip().set_volume_control(
self._elements.master_fader)
self._mixer.set_enabled(True)
def _create_record_modes(self):
self._session_record = SessionRecordingComponent(
name=u'Session_Record',
is_enabled=False,
layer=Layer(record_button=u'record_button'))
self._record_modes = ModesComponent(name=u'Record_Modes')
self._record_modes.add_mode(u'session',
EnablingMode(self._session_record))
self._record_modes.add_mode(
u'arrange',
AddLayerMode(self._transport,
layer=Layer(record_button=u'record_button')))
self.__on_main_view_changed()
@listens(u'is_view_visible', u'Session')
def __on_main_view_changed(self):
if self.application.view.is_view_visible(u'Session'):
self._record_modes.selected_mode = u'session'
else:
self._record_modes.selected_mode = u'arrange'
def _create_transport(self):
self._transport = TransportComponent(name='Transport', is_enabled=False, layer=Layer(seek_forward_button=self._ff_button, seek_backward_button=self._rw_button, stop_button=self._stop_button, play_button=self._play_button, record_button=self._record_button))
self._transport.set_enabled(True)
class Code(ControlSurface):
mixer_navigation_type = MixerNavigationComponent
def __init__(self, *a, **k):
super(Code, self).__init__(*a, **k)
with self.component_guard():
with inject(skin=const(make_default_skin())).everywhere():
self._create_controls()
self._create_transport()
self._create_mixer()
self._create_mixer_navigation()
def _create_controls(self):
self._rw_button = make_button(91, 'RW_Button')
self._ff_button = make_button(92, 'FF_Button')
self._stop_button = make_button(93, 'Stop_Button')
self._play_button = make_button(94, 'Play_Button')
self._record_button = make_button(95, 'Record_Button')
self._faders = ButtonMatrixElement(rows=[[
make_slider(index, 'Fader_%d' % (index + 1, ))
for index in xrange(8)
]],
name='Faders')
self._master_fader = make_slider(8, 'Master_Fader')
self._encoders = ButtonMatrixElement(rows=[[
make_encoder(index + 16, 'Encoder_%d' % (index + 1, ))
for index in xrange(8)
]],
name='Encoders')
self._track_select_buttons = ButtonMatrixElement(
rows=[[
make_button(index + 24,
'Track_Select_Button_%d' % (index + 1, ))
for index in xrange(8)
]],
name='Track_Select_Buttons')
self._mute_buttons = ButtonMatrixElement(rows=[[
make_button(index + 8, 'Mute_Button_%d' % (index + 1, ))
for index in xrange(8)
]],
name='Mute_Buttons')
self._solo_buttons = ButtonMatrixElement(rows=[[
make_button(index + 16, 'Solo_Button_%d' % (index + 1, ))
for index in xrange(8)
]],
name='Solo_Buttons')
self._arm_buttons = ButtonMatrixElement(rows=[[
make_button(index, 'Record_Arm_Button_%d' % (index + 1, ))
for index in xrange(8)
]],
name='Record_Arm_Buttons')
self._bank_up_button = make_button(47, 'Bank_Up_Button')
self._bank_down_button = make_button(46, 'Bank_Down_Button')
def _create_transport(self):
self._transport = TransportComponent(
name='Transport',
is_enabled=False,
layer=Layer(seek_forward_button=self._ff_button,
seek_backward_button=self._rw_button,
stop_button=self._stop_button,
play_button=self._play_button,
record_button=self._record_button))
self._transport.set_enabled(True)
def _create_mixer(self):
self._session_ring = SessionRingComponent(name='Session_Navigation',
num_tracks=8,
num_scenes=0,
is_enabled=False)
self._mixer = MixerComponent(
name='Mixer',
is_enabled=False,
tracks_provider=self._session_ring,
invert_mute_feedback=True,
layer=Layer(volume_controls=self._faders,
pan_controls=self._encoders,
track_select_buttons=self._track_select_buttons,
solo_buttons=self._solo_buttons,
mute_buttons=self._mute_buttons,
arm_buttons=self._arm_buttons))
self._mixer.master_strip().layer = Layer(
volume_control=self._master_fader)
self._mixer.set_enabled(True)
def _create_mixer_navigation(self):
self._mixer_navigation = self.mixer_navigation_type(
name='Mixer_Navigation',
is_enabled=False,
session_ring=self._session_ring,
layer=Layer(page_left_button=self._bank_down_button,
page_right_button=self._bank_up_button))
self._mixer_navigation.set_enabled(True)
class Codec(LividControlSurface):
_sysex_id = 4
_model_name = 'Code'
_host_name = 'Codec'
_version_check = 'b996'
monomodular = None
def __init__(self, c_instance, *a, **k):
self.log_message = logger.warning
super(Codec, self).__init__(c_instance, *a, **k)
self._locked = False
self._shift_button = None
self._device_selection_follows_track_selection=FOLLOW
self._leds_last = 0
self._shift_latching = LatchingShiftedBehaviour if SHIFT_LATCHING else ShiftedBehaviour
self._skin = Skin(CodecColors)
with self.component_guard():
self._define_sysex()
self._setup_controls()
self._setup_background()
self._setup_mixer_controls()
self._setup_device_navigator()
self._setup_device_controls()
self._setup_special_device_control()
self._setup_device_chooser()
self._setup_device_selector()
self._setup_send_reset()
self._setup_default_buttons()
self._setup_shift_modes()
self._setup_mod()
self._setup_modswitcher()
self._setup_modes()
self._setup_m4l_interface()
self._background.set_enabled(True)
def _initialize_hardware(self):
super(Codec, self)._initialize_hardware()
def _initialize_script(self):
super(Codec, self)._initialize_script()
self._on_device_changed.subject = self._device_provider
self._main_modes.set_enabled(True)
self._main_modes.selected_mode = 'mix'
def _define_sysex(self):
self.fast_encoder_sysex = SendLividSysexMode(livid_settings = self._livid_settings, call = 'set_encoder_speed', message = FAST_ENCODER_MSG)
self.normal_encoder_sysex = SendLividSysexMode(livid_settings = self._livid_settings, call = 'set_encoder_speed', message = NORMAL_ENCODER_MSG)
self.slow_encoder_sysex = SendLividSysexMode(livid_settings = self._livid_settings, call = 'set_encoder_speed', message = SLOW_ENCODER_MSG)
def _setup_controls(self):
is_momentary = True
optimized = False
resource = PrioritizedResource
self._livid = DoublePressElement(MonoButtonElement(is_momentary = is_momentary, msg_type = MIDI_NOTE_TYPE, channel = CHANNEL, identifier = LIVID, name = 'Livid_Button', script = self, skin = self._skin, color_map = COLOR_MAP, optimized_send_midi = optimized, resource_type = resource, monobridge = self._monobridge))
self._dial = [[CodecEncoderElement(msg_type = MIDI_CC_TYPE, channel = CHANNEL, identifier = CODE_DIALS[row][column], name = 'Dial_' + str(column) + '_' + str(row), num = (column + (row*8)), script = self, optimized_send_midi = optimized, resource_type = resource, monobridge = self._monobridge) for row in range(4)] for column in range(8)]
self._button = [[MonoButtonElement(is_momentary = is_momentary, msg_type = MIDI_NOTE_TYPE, channel = CHANNEL, identifier = CODE_BUTTONS[row][column], name = 'Button_' + str(column) + '_' + str(row), script = self, skin = self._skin, color_map = COLOR_MAP, optimized_send_midi = optimized, resource_type = resource, monobridge = self._monobridge) for row in range(4)] for column in range(8)]
self._column_button = [MonoButtonElement(is_momentary = is_momentary, msg_type = MIDI_NOTE_TYPE, channel = CHANNEL, identifier = CODE_COLUMN_BUTTONS[index], name = 'Column_Button_' + str(index), script = self, skin = self._skin, color_map = COLOR_MAP, optimized_send_midi = optimized, resource_type = resource, monobridge = self._monobridge) for index in range(8)]
self._row_button = [MonoButtonElement(is_momentary = is_momentary, msg_type = MIDI_NOTE_TYPE, channel = CHANNEL, identifier = CODE_ROW_BUTTONS[index], name = 'Row_Button_' + str(index), script = self, skin = self._skin, color_map = COLOR_MAP, optimized_send_midi = optimized, resource_type = resource, monobridge = self._monobridge) for index in range(4)]
self._code_keys = ButtonMatrixElement(name = 'Code_Keys', rows = [self._column_button])
self._code_buttons = ButtonMatrixElement(name = 'Code_Buttons', rows = [self._row_button])
self._encoder_matrix = ButtonMatrixElement(name = 'Encoder_Matrix', rows = [[self._dial[column][row] for column in range(8)] for row in range(4)])
self._button_matrix = ButtonMatrixElement(name = 'Button_Matrix', rows = [[self._button[column][row] for column in range(8)] for row in range(4)])
def _setup_background(self):
self._background = BackgroundComponent()
self._background.layer = Layer(priority = 3, matrix = self._button_matrix, encoders = self._encoder_matrix, livid = self._livid, buttons = self._code_buttons, keys = self._code_keys)
self._background.set_enabled(False)
def _setup_transport_control(self):
self._transport = TransportComponent()
self._transport.name = 'Transport'
self._transport.set_enabled(False)
def _setup_mixer_controls(self):
self._session_ring = SessionRingComponent(name = 'Session_Ring', num_tracks = 8, num_scenes = 0)
self._session_navigation = SessionNavigationComponent(name = 'Session_Navigation', session_ring = self._session_ring)
self._session_navigation.layer = Layer(priority = 4, left_button = self._button[6][0], right_button = self._button[7][0])
self._session_navigation.set_enabled(False)
#self._session = SessionComponent(name = 'Session', session_ring = self._session_ring)
self._mixer = CodecMixerComponent(num_returns = 4, name = 'Mixer', tracks_provider = self._session_ring, invert_mute_feedback = True, auto_name = True)
self._mixer._mix_layer = AddLayerMode(self._mixer, Layer(priority = 4, volume_controls = self._encoder_matrix.submatrix[:8,3],
pan_controls = self._encoder_matrix.submatrix[:8,2],
send_controls = self._encoder_matrix.submatrix[:8, :2],
))
self._mixer._solo_mute_layer = AddLayerMode(self._mixer, Layer(priority = 4, solo_buttons = self._button_matrix.submatrix[:8,2],
mute_buttons = self._button_matrix.submatrix[:8,3],
))
self._mixer._select_layer = AddLayerMode(self._mixer, Layer(priority = 4, track_select_buttons = self._code_keys))
self._mixer._sends_layer = AddLayerMode(self._mixer, Layer(priority = 4, send_controls = self._encoder_matrix.submatrix[:, :]))
self._mixer.set_enabled(False)
def _setup_device_navigator(self):
self._device_navigator = DeviceNavigator(self._device_provider, self._mixer, self)
self._device_navigator._dev1_layer = AddLayerMode(self._device_navigator, Layer(priority = 4, prev_button = self._button[4][0], next_button = self._button[5][0], prev_chain_button = self._button[6][0], next_chain_button = self._button[7][0]))
self._device_navigator._dev2_layer = AddLayerMode(self._device_navigator, Layer(priority = 4, prev_button = self._button[4][1], next_button = self._button[5][1], prev_chain_button = self._button[6][1], next_chain_button = self._button[7][1]))
self._device_navigator._dev3_layer = AddLayerMode(self._device_navigator, Layer(priority = 4, prev_button = self._button[4][2], next_button = self._button[5][2], prev_chain_button = self._button[6][2], next_chain_button = self._button[7][2]))
self._device_navigator._dev4_layer = AddLayerMode(self._device_navigator, Layer(priority = 4, prev_button = self._button[4][3], next_button = self._button[5][3], prev_chain_button = self._button[6][3], next_chain_button = self._button[7][3]))
self._device_navigator.set_enabled(False)
def _setup_device_controls(self):
self._device = [None for index in range(4)]
for index in range(4):
self._device[index] = CodecDeviceComponent(self, index+1, device_bank_registry = DeviceBankRegistry())
self._device[index].name = 'CodecDevice_Component_' + str(index+1)
self._device[index].layer = Layer(priority = 4, parameter_controls = self._encoder_matrix.submatrix[:, index],
on_off_button = self._button[1][index],
bank_prev_button = self._button[2][index],
bank_next_button = self._button[3][index],
)
self._device[index]._nav_layer = AddLayerMode(self._device[index], Layer(priority = 4, nav_prev_button = self._button[6][index],
nav_next_button = self._button[7][index],))
self._device[index].set_enabled(False)
def _setup_special_device_control(self):
self._special_device = SpecialCodecDeviceComponent(self, device_bank_registry = DeviceBankRegistry(), device_provider = self._device_provider)
self._special_device.name = 'SpecialCodecDeviceComponent'
self._is_active_device = True
self._special_device.layer = Layer(priority = 4, parameter_controls = self._encoder_matrix.submatrix[:,:],
on_off_button = self._button[1][0],
bank_prev_button = self._button[4][0],
bank_next_button = self._button[5][0],
)
self._special_device.set_enabled(False)
def _setup_device_chooser(self):
self._selected_device = self._device[0]
self._last_selected_device = self._device[0]
self._selected_device_modes = ModesComponent()
self._selected_device_modes.add_mode('disabled', [None])
self._selected_device_modes.add_mode('device_0', [self._device_navigator._dev1_layer], behaviour = DefaultedBehaviour())
self._selected_device_modes.add_mode('device_1', [self._device_navigator._dev2_layer], behaviour = DefaultedBehaviour())
self._selected_device_modes.add_mode('device_2', [self._device_navigator._dev3_layer], behaviour = DefaultedBehaviour())
self._selected_device_modes.add_mode('device_3', [self._device_navigator._dev4_layer], behaviour = DefaultedBehaviour())
self._selected_device_modes.layer = Layer(priority = 4, device_0_button = self._button[0][0], device_1_button = self._button[0][1], device_2_button = self._button[0][2], device_3_button = self._button[0][3])
self._selected_device_modes.selected_mode = 'device_0'
self._selected_device_modes.set_enabled(False)
self._on_device_selector_mode_changed.subject = self._selected_device_modes
def _setup_device_selector(self):
self._device_selector = DeviceSelectorComponent(self)
self._device_selector.name = 'Device_Selector'
self._device_selector.layer = Layer(priority = 4, matrix = self._code_keys)
self._device_selector.set_enabled(False)
def _setup_send_reset(self):
self._send_reset = CodecResetSendsComponent(self)
self._send_reset.set_enabled(False)
#self._send_reset.set_buttons(self._button)
def _setup_default_buttons(self):
self._value_default = ParameterDefaultComponent(script = self, dials = self._dial)
self._value_default.layer = Layer(priority = 3, matrix = self._button_matrix)
self._value_default.set_enabled(False)
def _setup_shift_modes(self):
self._main_shift_modes = ModesComponent(name = 'MainShiftModes')
self._main_shift_modes.add_mode('disabled', [self.normal_encoder_sysex], cycle_mode_button_color = 'DefaultButton.Off')
self._main_shift_modes.add_mode('enabled', [self.slow_encoder_sysex], cycle_mode_button_color = 'DefaultButton.On') #, self._value_default
self._main_shift_modes.layer = Layer(priority = 4, cycle_mode_button = self._livid)
self._main_shift_modes.set_enabled(False)
self._main_shift_modes.selected_mode = 'disabled'
self._mod_shift_modes = ModesComponent(name = 'ModShiftModes')
self._mod_shift_modes.layer = Layer(priority = 4, cycle_mode_button = self._livid)
self._mod_shift_modes.set_enabled(False)
def _setup_mod(self):
self.monomodular = get_monomodular(self)
self.monomodular.name = 'monomodular_switcher'
self.modhandler = CodecModHandler(script = self, device_provider = self._device_provider)
self.modhandler.name = 'ModHandler'
self.modhandler.layer = Layer(priority = 4, code_grid = self._button_matrix.submatrix[:,:], code_encoder_grid = self._encoder_matrix.submatrix[:,:])
self.modhandler.set_enabled(False)
self.modhandler.code_buttons_layer = AddLayerMode(self.modhandler, Layer(priority = 5, code_buttons = self._code_buttons))
self.modhandler.keys_layer = AddLayerMode(self.modhandler, Layer(priority = 5, key_buttons = self._code_keys))
self.modhandler.code_keys_layer = AddLayerMode(self.modhandler, Layer(priority = 5, code_keys = self._code_buttons))
self.modhandler.alt_layer = AddLayerMode(self.modhandler, Layer(priority = 4, lock_button = self._livid))
def _setup_modswitcher(self):
self._modswitcher = ModesComponent(name = 'ModSwitcher')
self._modswitcher.add_mode('mod', [self.modhandler, self._mod_shift_modes])
self._modswitcher.add_mode('special_device', [self._special_device, self._mixer, self._mixer._select_layer, self._main_shift_modes])
self._modswitcher.selected_mode = 'special_device'
self._modswitcher.set_enabled(False)
self._mod_shift_modes.add_mode('disabled', [self.modhandler.keys_layer], cycle_mode_button_color = 'Mod.ShiftOff')
self._mod_shift_modes.add_mode('enabled', [self.modhandler.code_keys_layer, self.modhandler.code_buttons_layer, tuple([self._send_mod_shift, self._release_mod_shift])], cycle_mode_button_color = 'Mod.ShiftOn')
self._mod_shift_modes.selected_mode = 'disabled'
def _setup_modes(self):
self._main_modes = ModesComponent(name = 'MainModes')
self._main_modes.add_mode('disabled', [])
self._main_modes.add_mode('mix_shifted', [self._mixer, self._mixer._mix_layer, self._mixer._solo_mute_layer, self._device_selector, self._background], groups = ['shifted'], behaviour = self._shift_latching(color = 'Mode.Main'))
self._main_modes.add_mode('mix', [self._mixer, self._mixer._mix_layer, self._mixer._select_layer, self._mixer._solo_mute_layer, self._session_navigation, self._background, self._main_shift_modes], behaviour = self._shift_latching(color = 'Mode.Main'))
self._main_modes.add_mode('sends_shifted', [self._mixer, self._mixer._sends_layer, self._mixer._select_layer, self._device_selector, self._background], groups = ['shifted'], behaviour = self._shift_latching(color = 'Mode.Main'))
self._main_modes.add_mode('sends', [self._mixer, self._mixer._sends_layer, self._mixer._select_layer, self._background, self._main_shift_modes], behaviour = self._shift_latching(color = 'Mode.Main'))
self._main_modes.add_mode('device_shifted', [self._selected_device_modes, self._device_selector, self._device[0], self._device[1], self._device[2], self._device[3], self._device_selector, self._background], groups = ['shifted'], behaviour = self._shift_latching(color = 'Mode.Main'))
self._main_modes.add_mode('device', [self._mixer, self._mixer._select_layer, self._selected_device_modes, self._device[0], self._device[1], self._device[2], self._device[3], self._background, self._mixer._select_layer, self._main_shift_modes], behaviour = self._shift_latching(color = 'Mode.Main'))
self._main_modes.add_mode('special_device_shifted', [self._modswitcher, self._device_selector, self._background], groups = ['shifted'], behaviour = self._shift_latching(color = 'Mode.Main'))
self._main_modes.add_mode('special_device', [self._modswitcher, self._background], behaviour = self._shift_latching(color = 'Mode.Main'))
#self._main_modes.add_mode('select', [self.normal_encoder_sysex], behaviour = DelayedExcludingMomentaryBehaviour(excluded_groups = ['shifted']))
self._main_modes.layer = Layer(priority = 4,
mix_button = self._row_button[0],
sends_button = self._row_button[1],
device_button = self._row_button[2],
special_device_button = self._row_button[3],
)
self._main_modes.selected_mode = 'disabled'
self._main_modes.set_enabled(False)
def _setup_m4l_interface(self):
self._m4l_interface = M4LInterfaceComponent(controls=self.controls, component_guard=self.component_guard)
self.get_control_names = self._m4l_interface.get_control_names
self.get_control = self._m4l_interface.get_control
self.grab_control = self._m4l_interface.grab_control
self.release_control = self._m4l_interface.release_control
@listens('selected_mode')
def _on_device_selector_mode_changed(self, mode):
if mode == 'disabled':
for device in self._device:
device.set_dynamic_device_provider(None)
elif mode in DEVICE_COMPONENTS:
active_device = self._device[DEVICE_COMPONENTS.index(self._selected_device_modes.selected_mode)]
for device in self._device:
if device is active_device:
device.set_dynamic_device_provider(self._device_provider)
else:
device.set_dynamic_device_provider(None)
if active_device.find_track(active_device._get_device()) == self.song.view.selected_track:
active_device.display_device()
@listens('device')
def _on_device_changed(self):
self._on_device_name_changed.subject = self._device_provider.device
self.schedule_message(1, self._update_modswitcher)
@listens('name')
def _on_device_name_changed(self):
for device in self._device:
device.scan_all()
def _on_selected_track_changed(self):
super(Codec, self)._on_selected_track_changed()
#self.schedule_message(1, self._update_modswitcher)
if not len(self.song.view.selected_track.devices):
self._update_modswitcher()
def _update_modswitcher(self):
debug('update modswitcher', self.modhandler.active_mod())
if self.modhandler.active_mod():
self._modswitcher.selected_mode = 'mod'
else:
self._modswitcher.selected_mode = 'special_device'
"""general functionality"""
def disconnect(self):
self.log_message('<<<<<<<<<<<<<<<<<<<<<<<<< Codec log closed >>>>>>>>>>>>>>>>>>>>>>>>>')
super(Codec, self).disconnect()
def update_display(self):
super(Codec, self).update_display()
self.modhandler.send_ring_leds()
def restart_monomodular(self):
#self.log_message('restart monomodular')
self.modhandler.disconnect()
with self.component_guard():
self._setup_mod()
def _send_mod_shift(self):
self.modhandler._shift_value(1)
def _release_mod_shift(self):
self.modhandler._shift_value(0)
class GuitarWing(LividControlSurface): _sysex_id = 20 _model_name = 'GuitarWing' def __init__(self, *a, **k): super(GuitarWing, self).__init__(*a, **k) self._skin = Skin(GuitarWingColors) with self.component_guard(): self._setup_controls() self._setup_m4l_interface() self._setup_session_control() self._setup_mixer_control() self._setup_device_control() self._setup_transport_control() self._setup_view_control() def _setup_controls(self): is_momentary = True optimized = True resource = PrioritizedResource self._button = [MonoButtonElement(is_momentary = is_momentary, msg_type = MIDI_NOTE_TYPE, channel = CHANNEL, identifier = BUTTONS[index], name = 'Button_' + str(index), script = self, skin = self._skin, optimized_send_midi = optimized, resource_type = resource, monobridge = self._monobridge) for index in range(10)] self._fader = [MonoEncoderElement(msg_type = MIDI_CC_TYPE, channel = CHANNEL, identifier = SLIDERS[index], name = 'Fader_' + str(index), num = index, script = self, optimized_send_midi = optimized, resource_type = resource, monobridge = self._monobridge) for index in range(3)] self._fader_button = [MonoEncoderElement(msg_type = MIDI_NOTE_TYPE, channel = CHANNEL, identifier = SLIDERS[index], name = 'Fader_Button_' + str(index), num = index, script = self, optimized_send_midi = optimized, resource_type = resource, monobridge = self._monobridge) for index in range(3)] self._ccs = [MonoEncoderElement(msg_type = MIDI_CC_TYPE, channel = CHANNEL, identifier = CCS[index], name = 'CCs_' + str(index), num = index, script = self, optimized_send_midi = optimized, resource_type = resource, monobridge = self._monobridge) for index in range(4)] self._pad = [MonoButtonElement(is_momentary = is_momentary, msg_type = MIDI_NOTE_TYPE, channel = CHANNEL, identifier = PADS[index], name = 'Pad_' + str(index), script = self, skin = self._skin, optimized_send_midi = optimized, resource_type = resource, monobridge = self._monobridge) for index in range(5)] self._padCC = [MonoEncoderElement(msg_type = MIDI_CC_TYPE, channel = CHANNEL, identifier = PADS[index], name = 'PadCC_' + str(index), num = index, script = self, optimized_send_midi = optimized, resource_type = resource, monobridge = self._monobridge) for index in range(5)] self._accel = [MonoEncoderElement(msg_type = MIDI_CC_TYPE, channel = CHANNEL, identifier = ACCELS[index], name = 'Accel_' + str(index), num = index, script = self, optimized_send_midi = optimized, resource_type = resource, monobridge = self._monobridge) for index in range(3)] self._parameter_control_matrix = ButtonMatrixElement(rows = [ [ self._fader[0], self._fader[1], self._fader[2], self._accel[2], self._ccs[0], self._ccs[1], self._ccs[2], self._ccs[3] ]]) self._scene_launch_matrix = ButtonMatrixElement(rows = [self._pad[:4]]) def _setup_session_control(self): self._session_ring = SessionRingComponent(num_tracks = 1, num_scenes = 4, tracks_to_use = lambda : self.song.visible_tracks + self.song.return_tracks) self._session_ring.set_enabled(False) self._session = SessionComponent(session_ring = self._session_ring, auto_name = True) hasattr(self._session, '_enable_skinning') and self._session._enable_skinning() self._session.layer = Layer(scene_launch_buttons = self._scene_launch_matrix) self._session_navigation =SessionNavigationComponent(name = 'SessionNavigation', session_ring = self._session_ring) self._session_navigation._horizontal_banking.scroll_up_button.color = 'Session.NavigationButtonOn' self._session_navigation._horizontal_banking.scroll_down_button.color = 'Session.NavigationButtonOn' self._session_navigation.layer = Layer(left_button = self._button[1], right_button = self._button[0]) self._session_navigation.set_enabled(True) def _setup_mixer_control(self): self._mixer = MonoMixerComponent(name = 'Mixer', tracks_provider = self._session_ring, track_assigner = simple_track_assigner, invert_mute_feedback = True, auto_name = True, enable_skinning = True) self.song.view.selected_track = self._mixer.channel_strip(0)._track def _setup_transport_control(self): self._transport = TransportComponent() self._transport.layer = Layer(play_button = self._button[6], loop_button = self._button[7], seek_backward_button = self._button[8], record_button = self._button[9]) self._transport.set_enabled(True) def _setup_device_control(self): self._device = DeviceComponent(name = 'Device_Component', device_provider = self._device_provider, device_bank_registry = DeviceBankRegistry()) self._device.layer = Layer(parameter_controls = self._parameter_control_matrix) self._device.set_enabled(True) def _setup_m4l_interface(self): self._m4l_interface = M4LInterfaceComponent(controls=self.controls, component_guard=self.component_guard) self.get_control_names = self._m4l_interface.get_control_names self.get_control = self._m4l_interface.get_control self.grab_control = self._m4l_interface.grab_control self.release_control = self._m4l_interface.release_control def _setup_view_control(self): self._view_control = ViewControlComponent() self._view_control.layer = Layer(prev_track_button = self._button[1], next_track_button = self._button[0]) # a
