def _setup_mixer(self):
self._mixer_for_encoders = SpecialMixerComponent(
self._name_display, self._value_display, 8)
self._mixer_for_encoders.name = 'Mixer_for_encoders'
self._mixer_for_faders = SpecialMixerComponent(self._name_display,
self._value_display, 8)
self._mixer_for_faders.name = 'Mixer_for_faders'
def _setup_mixer_control(self):
is_momentary = True
self._mixer = SpecialMixerComponent(TRACK_NUMBER)
self._mixer.name = 'Mixer'
self._mixer.master_strip().name = 'Master_Channel_Strip'
self._mixer.master_strip().set_select_button(
self._note_map_buttons[39])
self._mixer.selected_strip().name = 'Selected_Channel_Strip'
self._mixer.set_select_buttons(self._note_map_buttons[33],
self._note_map_buttons[32])
self._mixer.set_crossfader_control(self._ctrl_map_sliders[2])
self._mixer.set_prehear_volume_control(self._ctrl_map_sliders[1])
self._mixer.master_strip().set_volume_control(
self._ctrl_map_sliders[0])
for track in range(TRACK_NUMBER):
strip = self._mixer.channel_strip(track)
strip.name = 'Channel_Strip_' + str(track)
strip.set_arm_button(self._note_map_trk_rec_buttons[track])
strip.set_solo_button(self._note_map_trk_solo_buttons[track])
strip.set_mute_button(self._note_map_trk_mute_buttons[track])
strip.set_select_button(self._note_map_trk_sel_buttons[track])
strip.set_volume_control(self._ctrl_map_trk_volume[track])
strip.set_pan_control(self._ctrl_map_trk_pan[track])
strip.set_send_controls(
(self._ctrl_map_senda[track], self._ctrl_map_sendb[track],
self._ctrl_map_sendc[track]))
strip.set_invert_mute_feedback(True)
def _setup_mixer_control(self): is_momentary = True self._mixer = SpecialMixerComponent(8) self._mixer.name = 'Mixer' self._mixer.master_strip().name = 'Master_Channel_Strip' self._mixer.selected_strip().name = 'Selected_Channel_Strip' self._solo_buttons = [] for track in range(8): strip = self._mixer.channel_strip(track) strip.name = 'Channel_Strip_' + str(track) solo_button = FlashingButtonElement(is_momentary, MIDI_NOTE_TYPE, track, 50, self) self._solo_buttons.append(solo_button) mute_button = ButtonElement(is_momentary, MIDI_NOTE_TYPE, track, 49) solo_button.name = str(track) + '_Solo_Button' mute_button.name = str(track) + '_Mute_Button' strip.set_solo_button(solo_button) strip.set_mute_button(mute_button) strip.set_shift_button(self._shift_button) strip.set_invert_mute_feedback(True) master_volume_control = SliderElement(MIDI_CC_TYPE, 0, 14) prehear_control = EncoderElement(MIDI_CC_TYPE, 0, 47, Live.MidiMap.MapMode.relative_two_compliment) master_volume_control.name = 'Master_Volume_Control' prehear_control.name = 'Prehear_Volume_Control' self._mixer.set_prehear_volume_control(prehear_control) self._mixer.master_strip().set_volume_control(master_volume_control)
def _setup_mixer_control(self):
is_momentary = True
self._mixer = SpecialMixerComponent(8)
self._mixer.name = 'Mixer'
self._mixer.master_strip().name = 'Master_Channel_Strip'
self._mixer.master_strip().set_select_button(self._note_map[MASTERSEL])
self._mixer.selected_strip().name = 'Selected_Channel_Strip'
self._mixer.set_select_buttons(self._note_map[TRACKRIGHT],
self._note_map[TRACKLEFT])
self._mixer.set_crossfader_control(self._ctrl_map[CROSSFADER])
self._mixer.set_prehear_volume_control(self._ctrl_map[CUELEVEL])
self._mixer.master_strip().set_volume_control(
self._ctrl_map[MASTERVOLUME])
for track in range(8):
strip = self._mixer.channel_strip(track)
strip.name = 'Channel_Strip_' + str(track)
strip.set_arm_button(self._note_map[TRACKREC[track]])
strip.set_solo_button(self._note_map[TRACKSOLO[track]])
strip.set_mute_button(self._note_map[TRACKMUTE[track]])
strip.set_select_button(self._note_map[TRACKSEL[track]])
strip.set_volume_control(self._ctrl_map[TRACKVOL[track]])
strip.set_pan_control(self._ctrl_map[TRACKPAN[track]])
strip.set_send_controls((self._ctrl_map[TRACKSENDA[track]],
self._ctrl_map[TRACKSENDB[track]],
self._ctrl_map[TRACKSENDC[track]]))
strip.set_invert_mute_feedback(True)
def _setup_mixer(self):
self._next_nav_button = make_button(103, 'Next_Track_Button')
self._prev_nav_button = make_button(102, 'Prev_Track_Button')
mute_solo_flip_button = make_button(59, 'Master_Button')
self._mixer = SpecialMixerComponent(8)
self._mixer.name = 'Mixer'
self._mixer.set_select_buttons(self._next_nav_button,
self._prev_nav_button)
self._mixer.selected_strip().name = 'Selected_Channel_Strip'
self._mixer.master_strip().name = 'Master_Channel_Strip'
self._mixer.master_strip().set_volume_control(self._master_slider)
self._sliders = []
self._strip_buttons = []
for index in range(8):
strip = self._mixer.channel_strip(index)
strip.name = 'Channel_Strip_' + str(index)
strip.set_invert_mute_feedback(True)
self._sliders.append(
make_slider(41 + index, 'Volume_Control_%d' % index))
strip.set_volume_control(self._sliders[-1])
self._strip_buttons.append(
make_button(51 + index, 'Mute_Button_%d' % index))
self._mixer.set_strip_mute_solo_buttons(tuple(self._strip_buttons),
mute_solo_flip_button)
def __init__(self, matrix, side_buttons, session, control_surface):
assert isinstance(matrix, ButtonMatrixElement)
assert ((matrix.width() == 8) and (matrix.height() == 8))
assert isinstance(side_buttons, tuple)
assert (len(side_buttons) == 8)
assert isinstance(session, SessionComponent)
ModeSelectorComponent.__init__(self)
self._control_surface = control_surface
self._session = session
self._mixer = SpecialMixerComponent(matrix.width())
self._matrix = matrix
self._sliders = []
self._mixer.name = 'Mixer'
self._mixer.master_strip().name = 'Master_Channel_strip'
self._mixer.selected_strip().name = 'Selected_Channel_strip'
for column in range(matrix.width()):
self._mixer.channel_strip(
column).name = 'Channel_Strip_' + str(column)
self._sliders.append(
PreciseButtonSliderElement(
tuple([
matrix.get_button(column, 7 - row) for row in range(8)
])))
self._sliders[-1].name = 'Button_Slider_' + str(column)
self._side_buttons = side_buttons[4:]
self._update_callback = None
self._session.set_mixer(self._mixer)
self.set_modes_buttons(side_buttons[:4])
def _setup_mixer(self):
mute_solo_flip_button = ButtonElement(not IS_MOMENTARY, MIDI_CC_TYPE, 0, 34)
self._next_nav_button = ButtonElement(IS_MOMENTARY, MIDI_CC_TYPE, 0, 37)
self._prev_nav_button = ButtonElement(IS_MOMENTARY, MIDI_CC_TYPE, 0, 38)
self._strip_buttons = []
mute_solo_flip_button.name = 'Mute_Solo_Flip_Button'
self._next_nav_button.name = 'Next_Track_Button'
self._prev_nav_button.name = 'Prev_Track_Button'
self._mixer = SpecialMixerComponent(8)
self._mixer.name = 'Mixer'
self._mixer.set_select_buttons(self._next_nav_button, self._prev_nav_button)
self._mixer.selected_strip().name = 'Selected_Channel_Strip'
self._mixer.master_strip().name = 'Master_Channel_Strip'
self._mixer.master_strip().set_volume_control(self._master_slider)
self._sliders = []
for index in range(8):
strip = self._mixer.channel_strip(index)
strip.name = 'Channel_Strip_' + str(index)
strip.set_invert_mute_feedback(True)
self._sliders.append(SliderElement(MIDI_CC_TYPE, 0, index))
self._sliders[-1].name = str(index) + '_Volume_Control'
self._sliders[-1].set_feedback_delay(-1)
self._sliders[-1].add_value_listener(self._slider_value, identify_sender=True)
strip.set_volume_control(self._sliders[-1])
self._strip_buttons.append(ButtonElement(IS_MOMENTARY, MIDI_CC_TYPE, 0, 9 + index))
self._strip_buttons[-1].name = str(index) + '_Mute_Button'
self._strip_buttons[-1].add_value_listener(self._mixer_button_value, identify_sender=True)
self._mixer.master_strip().set_mute_button(ButtonElement(IS_MOMENTARY, MIDI_CC_TYPE, 1, 17))
self._mixer.set_strip_mute_solo_buttons(tuple(self._strip_buttons), mute_solo_flip_button)
def _setup_mixer_control(self):
#CREATE MIXER, SET OFFSET (SPECIALMIXERCOMPONENT USES SPECIALCHANNELSTRIP THAT ALLOWS US TO UNFOLD TRACKS WITH TRACK SELECT BUTTON)
self._mixer = SpecialMixerComponent(self, num_tracks, 0, False, False) # 8 tracks, 2 returns, no EQ, no filters
self._mixer.name = 'Mixer'
self._mixer.set_track_offset(0) #Sets start point for mixer strip (offset from left)
self._mixer.set_select_buttons(self._track_right_button,self._track_left_button)
self._mixer.set_knobs(self._knobs)
def __init__(self, c_instance):
ControlSurface.__init__(self, c_instance)
with self.component_guard():
is_momentary = True
self._suggested_input_port = 'Oxygen'
self._suggested_output_port = 'Oxygen'
self._has_slider_section = True
self._device_selection_follows_track_selection = True
self._shift_button = ButtonElement(is_momentary, MIDI_CC_TYPE, GLOBAL_CHANNEL, 57)
self._shift_button.add_value_listener(self._shift_value)
self._mixer = SpecialMixerComponent(NUM_TRACKS)
self._mute_solo_buttons = []
self._track_up_button = ButtonElement(is_momentary, MIDI_CC_TYPE, GLOBAL_CHANNEL, 111)
self._track_down_button = ButtonElement(is_momentary, MIDI_CC_TYPE, GLOBAL_CHANNEL, 110)
self._master_slider = SliderElement(MIDI_CC_TYPE, GLOBAL_CHANNEL, 41)
for index in range(NUM_TRACKS):
self._mute_solo_buttons.append(ButtonElement(is_momentary, MIDI_CC_TYPE, GLOBAL_CHANNEL, 49 + index))
self._mixer.channel_strip(index).set_volume_control(SliderElement(MIDI_CC_TYPE, GLOBAL_CHANNEL, 33 + index))
self._shift_value(0)
self._mixer.master_strip().set_volume_control(self._master_slider)
self._mixer.selected_strip().set_volume_control(None)
device = DeviceComponent()
device.set_parameter_controls(tuple([ EncoderElement(MIDI_CC_TYPE, GLOBAL_CHANNEL, 17 + index, Live.MidiMap.MapMode.absolute) for index in range(8) ]))
self.set_device_component(device)
ffwd_button = ButtonElement(is_momentary, MIDI_CC_TYPE, GLOBAL_CHANNEL, 115)
rwd_button = ButtonElement(is_momentary, MIDI_CC_TYPE, GLOBAL_CHANNEL, 114)
loop_button = ButtonElement(is_momentary, MIDI_CC_TYPE, GLOBAL_CHANNEL, 113)
transport = TransportComponent()
transport.set_stop_button(ButtonElement(is_momentary, MIDI_CC_TYPE, GLOBAL_CHANNEL, 116))
transport.set_play_button(ButtonElement(is_momentary, MIDI_CC_TYPE, GLOBAL_CHANNEL, 117))
transport.set_record_button(ButtonElement(is_momentary, MIDI_CC_TYPE, GLOBAL_CHANNEL, 118))
session = SessionComponent(0, 0)
transport_view_modes = TransportViewModeSelector(transport, session, ffwd_button, rwd_button, loop_button)
def _setup_mixer_control(self):
self.mixer = SpecialMixerComponent(self.num_tracks, self)
self.mixer.name = 'Mixer'
self.mixer.set_track_offset(0)
self.mixer.set_select_buttons(self.button(PAD_CHANNEL, TRACK_RIGHT), self.button(PAD_CHANNEL, TRACK_LEFT))
self.mixer.set_crossfader_control(self.slider(SLIDER_CHANNEL, CROSSFADER))
for index in range(4):
self.mixer.channel_strip(index).set_volume_control(self.slider(SLIDER_CHANNEL, TRACK_VOL[index]))
self.num_o_tracks = self.song().visible_tracks
if self.num_o_tracks != None:
index_count = -1
index_table = []
for index in self.song().visible_tracks:
index_count += 1
if index.has_midi_output != True:
index_table.append(index_count)
else:
None
if index_table != None:
for index in range(len(index_table)):
x = index_table[index]
if x > 3:
None
else:
None
def _setup_mixer_control(self):
is_momentary = True
self._mixer = SpecialMixerComponent(NUM_TRACKS)
self._mixer.set_serato_interface(self._serato_interface)
self._mixer.master_strip().set_serato_interface(self._serato_interface)
self._track_arm_buttons = []
self._track_solo_buttons = []
self._track_mute_buttons = []
self._track_select_buttons = []
self._shift_button = ButtonElement(is_momentary, MIDI_NOTE_TYPE, 0, 0)
for track in range(NUM_TRACKS):
strip = self._mixer.channel_strip(track)
strip.set_serato_interface(self._serato_interface)
self._track_arm_buttons.append(
ButtonElement(not is_momentary, MIDI_NOTE_TYPE, 0, 0))
self._track_solo_buttons.append(
ButtonElement(not is_momentary, MIDI_NOTE_TYPE, 0, 0))
self._track_mute_buttons.append(
ButtonElement(not is_momentary, MIDI_NOTE_TYPE, 0, 0))
self._track_select_buttons.append(
ButtonElement(not is_momentary, MIDI_NOTE_TYPE, 0, 0))
strip.set_arm_button(self._track_arm_buttons[-1])
strip.set_solo_button(self._track_solo_buttons[-1])
strip.set_mute_button(self._track_mute_buttons[-1])
strip.set_select_button(self._track_select_buttons[-1])
strip.set_shift_button(self._shift_button)
def _setup_mixer_control(self):
is_momentary = True
# CREATE MIXER, SET OFFSET (SPECIALMIXERCOMPONENT USES SPECIALCHANNELSTRIP THAT ALLOWS US TO UNFOLD TRACKS WITH TRACK SELECT BUTTON)
self.mixer = SpecialMixerComponent(
num_tracks, 0, False,
False) # 4 tracks, 2 returns, no EQ, no filters
self.mixer.name = 'Mixer'
self.mixer.set_track_offset(
0) # Sets start point for mixer strip (offset from left)
def _setup_mixer_control(self):
is_momentary = True
self._mixer = SpecialMixerComponent(self, 8) #added self for parent
self._mixer.name = 'Mixer'
self._mixer.master_strip().name = 'Master_Channel_Strip'
master_select_button = ButtonElement(is_momentary, MIDI_NOTE_TYPE, 0, 80)
master_select_button.name = 'Master_Select_Button'
self._mixer.master_strip().set_select_button(master_select_button) #set in ShiftableSelectorComponent instead if used for Note Mode
self._mixer.selected_strip().name = 'Selected_Channel_Strip'
select_buttons = [] #added
arm_buttons = [] #added
sliders = [] #added
for track in range(8):
strip = self._mixer.channel_strip(track)
strip.name = 'Channel_Strip_' + str(track)
#volume_control = SliderElement(MIDI_CC_TYPE, track, 7) #set in ShiftableSelectorComponent instead
#arm_button = ButtonElement(is_momentary, MIDI_NOTE_TYPE, track, 48) #see below
solo_button = ButtonElement(is_momentary, MIDI_NOTE_TYPE, track, 49)
solo_button.name = str(track) + '_Solo_Button'
strip.set_solo_button(solo_button)
if track < 4:
mute_button = ButtonElement(is_momentary, MIDI_NOTE_TYPE, track, 50)
mute_button.name = str(track) + '_Mute_Button'
strip.set_mute_button(mute_button)
strip.set_invert_mute_feedback(True)
strip.set_shift_button(self._shift_button)
select_buttons.append(ButtonElement(is_momentary, MIDI_NOTE_TYPE, track, 51)) #added
select_buttons[-1].name = str(track) + '_Select_Button' #added
#strip.set_select_button(select_buttons[-1]) #added
arm_buttons.append(ButtonElement(is_momentary, MIDI_NOTE_TYPE, track, 48)) #added
arm_buttons[-1].name = str(track) + '_Arm_Button' #added
sliders.append(SliderElement(MIDI_CC_TYPE, track, 7)) #added
sliders[-1].name = str(track) + '_Volume_Control' #added
self._crossfader = SliderElement(MIDI_CC_TYPE, 0, 15)
master_volume_control = SliderElement(MIDI_CC_TYPE, 0, 14)
self._prehear_control = EncoderElement(MIDI_CC_TYPE, 0, 47, Live.MidiMap.MapMode.relative_two_compliment)
self._crossfader.name = 'Crossfader' #not used in APC20
master_volume_control.name = 'Master_Volume_Control'
self._prehear_control.name = 'Prehear_Volume_Control'
self._mixer.set_shift_button(self._shift_button) #added for shifting prehear
self._mixer.set_crossfader_control(self._crossfader) #not used in APC20
self._mixer.set_prehear_volume_control(self._prehear_control) #functionality overridden in SpecialMixerComponent
self._mixer.master_strip().set_volume_control(master_volume_control)
self._slider_modes = SliderModesComponent(self._mixer, tuple(sliders)) #added from APC20 script
self._slider_modes.name = 'Slider_Modes' #added from APC20 script
matrix_modes = MatrixModesComponent(self._matrix, self._session, self._session_zoom, tuple(self._track_stop_buttons), self) #added new
matrix_modes.name = 'Matrix_Modes' #added new
# Original method args for ShiftableSelectorComponent: (self, select_buttons, master_button, arm_buttons, matrix, session, zooming, mixer, transport, slider_modes, mode_callback)
#self._shift_modes = ShiftableSelectorComponent(tuple(select_buttons), master_select_button, tuple(arm_buttons), self._matrix, self._session, self._session_zoom, self._mixer, transport, slider_modes, self._send_introduction_message)
self._shift_modes = ShiftableSelectorComponent(self, tuple(select_buttons), master_select_button, tuple(arm_buttons), self._matrix, self._session, self._session_zoom, self._mixer, self._slider_modes, matrix_modes) #, self._send_introduction_message) #also added self for _parent
self._shift_modes.name = 'Shift_Modes'
self._shift_modes.set_mode_toggle(self._shift_button)
def _setup_mixer_control(self):
self.mixer = SpecialMixerComponent(
self.box_width, self) # get a local mixer object ready
self.mixer.name = 'Mixer' # name
self.mixer.set_track_offset(self.gutter) # gutter ----marwei
# compare width with track vol count to qualify -- put somewhere else
for index in range(
self.box_width): # @marwei must kill this style and count
self.mixer.channel_strip(index).set_volume_control(
self.slider(midi_channel, track_volume[index]))
def _setup_mixer_control(self):
is_momentary = True
self._mixer = SpecialMixerComponent(8)
self._mixer.name = 'Mixer'
self._mixer.master_strip().name = 'Master_Channel_Strip'
self._mixer.selected_strip().name = 'Selected_Channel_Strip'
self._solo_buttons = [] # added a
self._select_buttons = [] # added a
for track in range(8):
strip = self._mixer.channel_strip(track)
strip.name = 'Channel_Strip_' + str(track)
volume_control = MonoEncoderElement2(MIDI_CC_TYPE, track, 7,
Live.MidiMap.MapMode.absolute,
'Slider_' + str(track), track,
self)
arm_button = ButtonElement(is_momentary, MIDI_NOTE_TYPE, track, 48)
solo_button = FlashingButtonElement(is_momentary, MIDI_NOTE_TYPE,
track, 50, self)
self._solo_buttons.append(solo_button) # added a
mute_button = ButtonElement(is_momentary, MIDI_NOTE_TYPE, track,
49)
select_button = FlashingButtonElement(is_momentary, MIDI_NOTE_TYPE,
track, 51, self)
self._select_buttons.append(select_button) # added a
#volume_control.name = str(track) + '_Volume_Control'
arm_button.name = str(track) + '_Arm_Button'
solo_button.name = str(track) + '_Solo_Button'
mute_button.name = str(track) + '_Mute_Button'
select_button.name = str(track) + '_Select_Button'
strip.set_volume_control(volume_control)
strip.set_arm_button(arm_button)
strip.set_solo_button(solo_button)
strip.set_mute_button(mute_button)
strip.set_select_button(select_button)
strip.set_shift_button(self._shift_button)
strip.set_invert_mute_feedback(True)
crossfader = SliderElement(MIDI_CC_TYPE, 0, 15)
master_volume_control = SliderElement(MIDI_CC_TYPE, 0, 14)
master_select_button = ButtonElement(is_momentary, MIDI_NOTE_TYPE, 0,
80)
self._master_select_button = master_select_button
prehear_control = EncoderElement(
MIDI_CC_TYPE, 0, 47, Live.MidiMap.MapMode.relative_two_compliment)
crossfader.name = 'Crossfader'
master_volume_control.name = 'Master_Volume_Control'
master_select_button.name = 'Master_Select_Button'
prehear_control.name = 'Prehear_Volume_Control'
self._mixer.set_crossfader_control(crossfader)
self._mixer.set_prehear_volume_control(prehear_control)
self._mixer.master_strip().set_volume_control(master_volume_control)
self._mixer.master_strip().set_select_button(master_select_button)
def _setup_mixer_control(self): global mixer is_momentary = True self._num_tracks = 7 mixer = SpecialMixerComponent(7, 0, True, False) mixer.name = 'Mixer' self._mixer = mixer for index in range(7): mixer.channel_strip(index).set_volume_control(self._fader[index]) for index in range(7): mixer.channel_strip(index).name = 'Mixer_ChannelStrip_' + str(index) mixer.track_eq(index).name = 'Mixer_EQ_' + str(index) mixer.channel_strip(index)._invert_mute_feedback = True self.song().view.selected_track = mixer.channel_strip(0)._track
def _setup_mixer_control(self):
is_momentary = True
self._num_tracks = (7) #A mixer is one-dimensional;
global mixer
mixer = SpecialMixerComponent(7, 0, True, False)
mixer.name = 'Mixer'
self._mixer = mixer
mixer.set_track_offset(
0) #Sets start point for mixer strip (offset from left)
for index in range(7):
mixer.channel_strip(index).set_volume_control(self._fader[index])
for index in range(7):
mixer.channel_strip(
index).name = 'Mixer_ChannelStrip_' + str(index)
mixer.track_eq(index).name = 'Mixer_EQ_' + str(index)
mixer.channel_strip(index)._invert_mute_feedback = True
self.song().view.selected_track = mixer.channel_strip(
0
)._track #set the selected strip to the first track, so that we don't, for example, try to assign a button to arm the master track, which would cause an assertion error
def _init_session(self):
make_button = partial(make_launch_control_button, channel=9)
make_encoder = partial(make_launch_control_encoder, channel=9)
bottom_encoders, top_encoders = make_all_encoders(
'Session_Mixer', make_encoder)
pan_volume_layer = Layer(
volume_controls=ButtonMatrixElement(rows=[bottom_encoders]),
pan_controls=ButtonMatrixElement(rows=[top_encoders]))
self._session_mixer = SpecialMixerComponent(8, Layer(),
pan_volume_layer, Layer())
self._session_mixer.set_enabled(False)
self._session_mixer.name = 'Session_Mixer'
clip_launch_buttons = [
make_button(identifier,
'Clip_Launch_Button_' + str(i),
is_pad=True)
for i, identifier in enumerate(pad_identifiers)
]
self._session = SpecialSessionComponent(num_tracks=8,
num_scenes=0,
name='Session')
self._session.set_enabled(False)
self._session.set_mixer(self._session_mixer)
self._session_layer = Layer(
track_bank_left_button=make_button(116, 'Track_Bank_Left_Button'),
track_bank_right_button=make_button(117,
'Track_Bank_Right_Button'),
select_prev_button=make_button(114, 'Scene_Bank_Up_Button'),
select_next_button=make_button(115, 'Scene_Bank_Down_Button'),
clip_launch_buttons=ButtonMatrixElement(
rows=[clip_launch_buttons]))
scene = self._session.selected_scene()
for index in range(8):
clip_slot = scene.clip_slot(index)
clip_slot.set_triggered_to_play_value(Colors.GREEN_BLINK)
clip_slot.set_triggered_to_record_value(Colors.RED_BLINK)
clip_slot.set_stopped_value(Colors.AMBER_FULL)
clip_slot.set_started_value(Colors.GREEN_FULL)
clip_slot.set_recording_value(Colors.RED_FULL)
clip_slot.name = 'Selected_Clip_Slot_' + str(index)
self._on_track_offset.subject = self._session
def __init__(self, matrix, side_buttons, session):
assert isinstance(matrix, ButtonMatrixElement)
assert ((matrix.width() == 8) and (matrix.height() == 8))
assert isinstance(side_buttons, tuple)
assert (len(side_buttons) == 8)
assert isinstance(session, SessionComponent)
ModeSelectorComponent.__init__(self)
self._session = session
self._mixer = SpecialMixerComponent(len(self.song().tracks))
self._matrix = matrix
self._mixer.name = "Mixer"
self._mixer.master_strip().name = "Master_Channel_strip"
self._mixer.selected_strip().name = "Selected_Channel_strip"
for column in range(len(self.song().tracks)):
button_index = 0
if self.song().tracks[column].is_foldable:
if button_index < GROUPS_CONSIDERED:
self._mixer.channel_strip(column).name = ("Channel_Strip_" + str(column))
button_index = button_index + 1
self._side_buttons = side_buttons[5:]
self._update_callback = None
self._session.set_mixer(self._mixer)
def __init__(self, matrix, side_buttons, session):
assert isinstance(matrix, ButtonMatrixElement)
assert ((matrix.width() == 8) and (matrix.height() == 8))
assert isinstance(side_buttons, tuple)
assert (len(side_buttons) == 8)
assert isinstance(session, SessionComponent)
ModeSelectorComponent.__init__(self)
self._session = session
self._mixer = SpecialMixerComponent(matrix.width())
self._matrix = matrix
self._sliders = []
for column in range(8):
self._sliders.append(
PreciseButtonSliderElement(
tuple([
matrix.get_button(column, (7 - row))
for row in range(8)
])))
self._side_buttons = side_buttons[4:]
self._update_callback = None
self._session.set_mixer(self._mixer)
self.set_modes_buttons(side_buttons[:4])
def _init_mixer(self):
make_button = partial(make_launch_control_button, channel=8)
make_encoder = partial(make_launch_control_encoder, channel=8)
bottom_encoders, top_encoders = make_all_encoders('Mixer', make_encoder)
pan_volume_layer = Layer(volume_controls=ButtonMatrixElement(rows=[bottom_encoders]), pan_controls=ButtonMatrixElement(rows=[top_encoders]))
sends_layer = Layer(sends_controls=ButtonMatrixElement(rows=[bottom_encoders, top_encoders]))
modes_layer = Layer(pan_volume_button=make_button(114, 'Pan_Volume_Mode_Button'), sends_button=make_button(115, 'Sends_Mode_Button'))
self._mixer = SpecialMixerComponent(8, modes_layer, pan_volume_layer, sends_layer)
self._mixer.name = 'Mixer'
self._mixer.selected_strip().name = 'Selected_Channel_Strip'
self._mixer.master_strip().name = 'Master_Channel_Strip'
self._mixer_track_nav_layer = Layer(track_bank_left_button=make_button(116, 'Mixer_Track_Left_Button'), track_bank_right_button=make_button(117, 'Mixer_Track_Right_Button'))
for index in xrange(8):
strip = self._mixer.channel_strip(index)
strip.name = 'Channel_Strip_' + str(index)
strip.empty_color = Colors.LED_OFF
strip.set_invert_mute_feedback(True)
mute_button = make_button(pad_identifiers[index], 'Track_Mute_Button_' + str(index), is_pad=True)
mute_button.set_on_off_values(Colors.AMBER_FULL, Colors.AMBER_THIRD)
strip.set_mute_button(mute_button)
self._on_selected_send_index.subject = self._mixer
self._on_selected_mixer_mode.subject = self._mixer
def _init_mixer_component(self, volume_controls, trackarm_controls, mixer_options, global_channel, volume_map_mode):
if volume_controls != None and trackarm_controls != None:
num_strips = max(len(volume_controls), len(trackarm_controls))
send_info = []
momentary_buttons = False
mixer = SpecialMixerComponent(num_strips)
mixer.name = 'Mixer'
mixer.master_strip().name = 'Master_Channel_Strip'
mixer.selected_strip().name = 'Selected_Channel_Strip'
if mixer_options != None:
if 'MASTERVOLUME' in mixer_options.keys() and mixer_options['MASTERVOLUME'] in range(128):
encoder = EncoderElement(MIDI_CC_TYPE, global_channel, mixer_options['MASTERVOLUME'], volume_map_mode)
encoder.name = 'Master_Volume_Control'
mixer.master_strip().set_volume_control(encoder)
if 'NUMSENDS' in mixer_options.keys() and mixer_options['NUMSENDS'] > 0:
for send in range(mixer_options['NUMSENDS']):
key = 'SEND' + str(send + 1)
raise key in mixer_options.keys() or AssertionError
send_info.append(mixer_options[key])
momentary_buttons = 'NOTOGGLE' in mixer_options.keys()
next_bank_button = None
prev_bank_button = None
if 'NEXTBANK' in mixer_options.keys() and mixer_options['NEXTBANK'] in range(128):
next_bank_button = ButtonElement(momentary_buttons, MIDI_CC_TYPE, global_channel, mixer_options['NEXTBANK'])
next_bank_button.name = 'Mixer_Next_Bank_Button'
if 'PREVBANK' in mixer_options.keys() and mixer_options['PREVBANK'] in range(128):
prev_bank_button = ButtonElement(momentary_buttons, MIDI_CC_TYPE, global_channel, mixer_options['PREVBANK'])
prev_bank_button.name = 'Mixer_Previous_Bank_Button'
mixer.set_bank_buttons(next_bank_button, prev_bank_button)
for track in range(num_strips):
strip = mixer.channel_strip(track)
strip.name = 'Channel_Strip_' + str(track)
if track in range(len(volume_controls)):
channel = global_channel
cc = volume_controls[track]
if isinstance(volume_controls[track], (tuple, list)):
cc = volume_controls[track][0]
if volume_controls[track][1] in range(16):
channel = volume_controls[track][1]
if cc in range(128) and channel in range(16):
encoder = EncoderElement(MIDI_CC_TYPE, channel, cc, volume_map_mode)
encoder.name = str(track) + '_Volume_Control'
strip.set_volume_control(encoder)
if track in range(len(trackarm_controls)) and trackarm_controls[track] in range(128):
button = ButtonElement(momentary_buttons, MIDI_CC_TYPE, global_channel, trackarm_controls[track])
button.name = str(track) + '_Arm_Button'
strip.set_arm_button(button)
send_controls = []
for send in send_info:
encoder = None
if track in range(len(send)):
channel = global_channel
cc = send[track]
if isinstance(send[track], (tuple, list)):
cc = send[track][0]
if send[track][1] in range(16):
channel = send[track][1]
if cc in range(128) and channel in range(16):
encoder = EncoderElement(MIDI_CC_TYPE, channel, cc, volume_map_mode)
encoder.name = str(track) + '_Send_' + str(list(send_info).index(send)) + '_Control'
send_controls.append(encoder)
strip.set_send_controls(tuple(send_controls))
def _setup_mixer_control(self):
is_momentary = True
self._mixer = SpecialMixerComponent(self, 8)
self._mixer.name = 'Mixer'
self._mixer.master_strip().name = 'Master_Channel_Strip'
master_select_button = ButtonElement(is_momentary, MIDI_NOTE_TYPE, 0,
80)
master_select_button.name = 'Master_Select_Button'
self._mixer.master_strip().set_select_button(master_select_button)
self._mixer.selected_strip().name = 'Selected_Channel_Strip'
select_buttons = []
arm_buttons = []
solo_buttons = []
mute_buttons = []
sliders = []
for track in range(8):
strip = self._mixer.channel_strip(track)
strip.name = 'Channel_Strip_' + str(track)
solo_button = ButtonElement(is_momentary, MIDI_NOTE_TYPE, track,
49)
solo_buttons.append(solo_button)
mute_button = ButtonElement(is_momentary, MIDI_NOTE_TYPE, track,
50)
mute_buttons.append(mute_button)
solo_button.name = str(track) + '_Solo_Button'
mute_button.name = str(track) + '_Mute_Button'
strip.set_solo_button(solo_button)
strip.set_mute_button(mute_button)
strip.set_shift_button(self._shift_button)
strip.set_invert_mute_feedback(True)
select_buttons.append(
ButtonElement(is_momentary, MIDI_NOTE_TYPE, track, 51))
select_buttons[-1].name = str(track) + '_Select_Button'
arm_buttons.append(
ButtonElement(is_momentary, MIDI_NOTE_TYPE, track, 48))
arm_buttons[-1].name = str(track) + '_Arm_Button'
sliders.append(SliderElement(MIDI_CC_TYPE, track, 7))
sliders[-1].name = str(track) + '_Volume_Control'
self._crossfader = SliderElement(MIDI_CC_TYPE, 0, 15)
master_volume_control = SliderElement(MIDI_CC_TYPE, 0, 14)
self._prehear_control = EncoderElement(
MIDI_CC_TYPE, 0, 47, Live.MidiMap.MapMode.relative_two_compliment)
self._crossfader.name = 'Crossfader'
master_volume_control.name = 'Master_Volume_Control'
self._prehear_control.name = 'Prehear_Volume_Control'
self._mixer.set_shift_button(self._shift_button)
self._mixer.set_crossfader_control(self._crossfader)
self._mixer.set_prehear_volume_control(self._prehear_control)
self._mixer.master_strip().set_volume_control(master_volume_control)
self._slider_modes = SliderModesComponent(self._mixer, tuple(sliders))
self._slider_modes.name = 'Slider_Modes'
matrix_modes = MatrixModesComponent(self._matrix, self._session,
self._session_zoom,
tuple(self._track_stop_buttons),
self)
matrix_modes.name = 'Matrix_Modes'
self._sequencer = StepSequencerComponent(
self, self._session, self._matrix, tuple(self._track_stop_buttons))
self._sequencer.set_bank_buttons(tuple(select_buttons))
self._sequencer.set_nav_buttons(self._up_button, self._down_button,
self._left_button, self._right_button)
self._sequencer.set_button_matrix(self._matrix)
self._sequencer.set_follow_button(master_select_button)
self._sequencer.set_velocity_buttons(tuple(arm_buttons))
self._sequencer.set_shift_button(self._shift_button)
self._sequencer.set_lane_mute_buttons(tuple(
self._scene_launch_buttons))
self._sequencer.set_loop_start_buttons(tuple(mute_buttons))
self._sequencer.set_loop_length_buttons(tuple(solo_buttons))
self._shift_modes = ShiftableSelectorComponent(
self, tuple(select_buttons), master_select_button,
tuple(self._track_stop_buttons), self._stop_all_button,
tuple(mute_buttons), tuple(solo_buttons), tuple(arm_buttons),
tuple(self._scene_launch_buttons), self._matrix, self._session,
self._session_zoom, self._mixer, self._slider_modes, matrix_modes,
self._sequencer)
self._shift_modes.name = 'Shift_Modes'
self._shift_modes.set_mode_toggle(self._shift_button)
