def __init__(self):
     TransportComponent.__init__(self)
     self._shift_button = None
     self._shift_pressed = False
     self._undo_button = None #added from OpenLabs SpecialTransportComponent script
     self._redo_button = None #added from OpenLabs SpecialTransportComponent script
     self._bts_button = None #added from OpenLabs SpecialTransportComponent script
     self._tempo_encoder_control = None #new addition
     return None
示例#2
0
 def __init__(self):
     TransportComponent.__init__(self)
     self._shift_button = None
     self._shift_pressed = False
     self._undo_button = None  #added from OpenLabs SpecialTransportComponent script
     self._redo_button = None  #added from OpenLabs SpecialTransportComponent script
     self._bts_button = None  #added from OpenLabs SpecialTransportComponent script
     self._tempo_encoder_control = None  #new addition
     return None
	def __init__(self):
		TransportComponent.__init__(self)
		self._shift_button = None
		self._quant_toggle_button = None
		self._shift_pressed = False
		self._last_quant_value = Live.Song.RecordingQuantization.rec_q_eight
		self.song().add_midi_recording_quantization_listener(self._on_quantisation_changed)
		self._on_quantisation_changed()
		self._undo_button = None #added from OpenLabs SpecialTransportComponent script
		self._redo_button = None #added from OpenLabs SpecialTransportComponent script
		self._bts_button = None #added from OpenLabs SpecialTransportComponent script
		self._tempo_encoder_control = None #new addition
		return None
 def __init__(self):
     TransportComponent.__init__(self)
     self._shift_button = None
     self._quant_toggle_button = None
     self._shift_pressed = False
     self._last_quant_value = Live.Song.RecordingQuantization.rec_q_eight
     self.song().add_midi_recording_quantization_listener(self._on_quantisation_changed)
     self._on_quantisation_changed()
     self._undo_button = None  # added from OpenLabs SpecialTransportComponent script
     self._redo_button = None  # added from OpenLabs SpecialTransportComponent script
     self._bts_button = None  # added from OpenLabs SpecialTransportComponent script
     self._tempo_encoder_control = None  # new addition
     return None
示例#5
0
    def _setup_transport_control(self):
        """set up the sliders"""

        self._transport = TransportComponent(self,
                                             name=u'Transport',
                                             is_enabled=False)

        #set tempo-fader
        self._transport.set_tempo_control(
            self._left_tempo_fader,
            fine_control=self._right_tempo_fader)  #(control, fine_control)

        self._transport.set_enabled(True)
 def disconnect(self):
     TransportComponent.disconnect(self)
     if self._shift_button != None:
         self._shift_button.remove_value_listener(self._shift_value)
         self._shift_button = None
     if (self._undo_button != None): #added from OpenLabs SpecialTransportComponent script
         self._undo_button.remove_value_listener(self._undo_value)
         self._undo_button = None
     if (self._redo_button != None): #added from OpenLabs SpecialTransportComponent script
         self._redo_button.remove_value_listener(self._redo_value)
         self._redo_button = None
     if (self._bts_button != None): #added from OpenLabs SpecialTransportComponent script
         self._bts_button.remove_value_listener(self._bts_value)
         self._bts_button = None
     if (self._tempo_encoder_control != None): #new addition
         self._tempo_encoder_control.remove_value_listener(self._tempo_encoder_value)
         self._tempo_encoder_control = None
     return None
示例#7
0
 def disconnect(self):
     TransportComponent.disconnect(self)
     if self._shift_button != None:
         self._shift_button.remove_value_listener(self._shift_value)
         self._shift_button = None
     if (self._undo_button !=
             None):  #added from OpenLabs SpecialTransportComponent script
         self._undo_button.remove_value_listener(self._undo_value)
         self._undo_button = None
     if (self._redo_button !=
             None):  #added from OpenLabs SpecialTransportComponent script
         self._redo_button.remove_value_listener(self._redo_value)
         self._redo_button = None
     if (self._bts_button !=
             None):  #added from OpenLabs SpecialTransportComponent script
         self._bts_button.remove_value_listener(self._bts_value)
         self._bts_button = None
     if (self._tempo_encoder_control != None):  #new addition
         self._tempo_encoder_control.remove_value_listener(
             self._tempo_encoder_value)
         self._tempo_encoder_control = None
     return None
	def disconnect(self):
		TransportComponent.disconnect(self)
		if self._shift_button != None:
			self._shift_button.remove_value_listener(self._shift_value)
			self._shift_button = None
		if self._quant_toggle_button != None:
			self._quant_toggle_button.remove_value_listener(self._quant_toggle_value)
			self._quant_toggle_button = None
		self.song().remove_midi_recording_quantization_listener(self._on_quantisation_changed)
		if (self._undo_button != None): #added from OpenLabs SpecialTransportComponent script
			self._undo_button.remove_value_listener(self._undo_value)
			self._undo_button = None
		if (self._redo_button != None): #added from OpenLabs SpecialTransportComponent script
			self._redo_button.remove_value_listener(self._redo_value)
			self._redo_button = None
		if (self._bts_button != None): #added from OpenLabs SpecialTransportComponent script
			self._bts_button.remove_value_listener(self._bts_value)
			self._bts_button = None
		if (self._tempo_encoder_control != None): #new addition
			self._tempo_encoder_control.remove_value_listener(self._tempo_encoder_value)
			self._tempo_encoder_control = None
		return None
 def disconnect(self):
     TransportComponent.disconnect(self)
     if self._shift_button != None:
         self._shift_button.remove_value_listener(self._shift_value)
         self._shift_button = None
     if self._quant_toggle_button != None:
         self._quant_toggle_button.remove_value_listener(self._quant_toggle_value)
         self._quant_toggle_button = None
     self.song().remove_midi_recording_quantization_listener(self._on_quantisation_changed)
     if self._undo_button != None:  # added from OpenLabs SpecialTransportComponent script
         self._undo_button.remove_value_listener(self._undo_value)
         self._undo_button = None
     if self._redo_button != None:  # added from OpenLabs SpecialTransportComponent script
         self._redo_button.remove_value_listener(self._redo_value)
         self._redo_button = None
     if self._bts_button != None:  # added from OpenLabs SpecialTransportComponent script
         self._bts_button.remove_value_listener(self._bts_value)
         self._bts_button = None
     if self._tempo_encoder_control != None:  # new addition
         self._tempo_encoder_control.remove_value_listener(self._tempo_encoder_value)
         self._tempo_encoder_control = None
     return None
 def _create_transport(self):
     self._transport = TransportComponent(
         name='Transport',
         is_enabled=False,
         layer=Layer(shift_button=self._shift_button,
                     play_button=self._play_button,
                     stop_button=ComboElement(
                         self._play_button, modifiers=[self._shift_button]),
                     record_button=self._record_button,
                     metronome_button=self._metronome_button,
                     tap_tempo_button=self._tap_tempo_button,
                     nudge_down_button=self._nudge_down_button,
                     nudge_up_button=self._nudge_up_button,
                     tempo_encoder=self._tempo_control),
         play_toggle_model_transform=lambda v: v)
 def _create_transport(self):
     self._transport = TransportComponent(
         name='Transport',
         is_enabled=False,
         layer=Layer(play_button=self._play_button,
                     stop_button=self._stop_button,
                     record_button=self._record_button,
                     nudge_up_button=self._nudge_up_button,
                     nudge_down_button=self._nudge_down_button,
                     tap_tempo_button=self._tap_tempo_button,
                     quant_toggle_button=self._rec_quantization_button,
                     overdub_button=self._overdub_button,
                     metronome_button=self._metronome_button))
     self._bank_button_translator = ChannelTranslationSelector(
         name='Bank_Button_Translations', is_enabled=False)
	def _metronome_value(self, value):
		if not self._shift_pressed:
		##if self._shift_pressed: 
			TransportComponent._metronome_value(self, value)
 def _on_metronome_changed(self):
     if not self._shift_pressed:
     #if self._shift_pressed:
         TransportComponent._on_metronome_changed(self)
 def _on_overdub_changed(self):
     if not self._shift_pressed:
         TransportComponent._on_overdub_changed(self)
	def _on_nudge_down_changed(self): #added
		if not self._shift_pressed:
			TransportComponent._on_nudge_down_changed(self)
	def _on_overdub_changed(self):
		if not self._shift_pressed:
			TransportComponent._on_overdub_changed(self)
	def _on_metronome_changed(self):
		if not self._shift_pressed:
		#if self._shift_pressed:
			TransportComponent._on_metronome_changed(self)
 def _nudge_down_value(self, value): #added
     if not self._shift_pressed:
         TransportComponent._nudge_down_value(self, value)            
	def _nudge_down_value(self, value): #added
		if not self._shift_pressed:
			TransportComponent._nudge_down_value(self, value)			 
 def _on_nudge_down_changed(self): #added
     if not self._shift_pressed:
         TransportComponent._on_nudge_down_changed(self)
 def _metronome_value(self, value):
     if not self._shift_pressed:
     ##if self._shift_pressed: 
         TransportComponent._metronome_value(self, value)
示例#22
0
 def _setup_transport_control(self):
     is_momentary = True
     transport = TransportComponent()
     transport.set_play_button(
         ButtonElement(is_momentary, MIDI_NOTE_TYPE, 12, 80))
     transport.set_record_button(
         ButtonElement(is_momentary, MIDI_NOTE_TYPE, 12, 81))
     transport.set_nudge_buttons(
         ButtonElement(is_momentary, MIDI_NOTE_TYPE, 12, 86),
         ButtonElement(is_momentary, MIDI_NOTE_TYPE, 12, 85))
     transport.set_loop_button(
         ButtonElement(is_momentary, MIDI_NOTE_TYPE, 12, 84))
     transport.set_punch_buttons(
         ButtonElement(is_momentary, MIDI_NOTE_TYPE, 12, 82),
         ButtonElement(is_momentary, MIDI_NOTE_TYPE, 12, 83))
     transport.set_tempo_control(SliderElement(MIDI_CC_TYPE, 12, 26),
                                 SliderElement(MIDI_CC_TYPE, 12, 25))
示例#23
0
class KorgKaossDJ(ControlSurface):
    __module__ = __name__
    __doc__ = " Korg Kaoss DJ controller script "

    def __init__(self, c_instance):
        """everything except the '_on_selected_track_changed' override and 'disconnect' runs from here"""
        ControlSurface.__init__(self, c_instance)

        self._selected_track = None
        self._current_clip = None

        with self.component_guard():
            self._create_controls()
            self._setup_transport_control(
            )  # Run the transport setup part of the script
            self._setup_loop_control()
            self._setup_scrub_control()
            self._setup_fx_control()
            self._setup_mixer_control()  # Setup the mixer object
            self._setup_session_control()  # Setup the session object

    def _create_controls(self):

        # ------ SLIDER
        self._crossfader_slider = SliderElement(MIDI_CC_TYPE, CHANNEL_CENTER,
                                                23)

        self._left_volume_slider = SliderElement(MIDI_CC_TYPE, CHANNEL_LEFT,
                                                 24)
        self._right_volume_slider = SliderElement(MIDI_CC_TYPE, CHANNEL_RIGHT,
                                                  24)

        self._left_tempo_fader = SliderElement(MIDI_CC_TYPE, CHANNEL_LEFT, 25)
        self._right_tempo_fader = SliderElement(MIDI_CC_TYPE, CHANNEL_RIGHT,
                                                25)

        # ------ BUTTONS
        self._left_play_button = ButtonElement(True, MIDI_NOTE_TYPE,
                                               CHANNEL_LEFT, 27)
        self._right_play_button = ButtonElement(True, MIDI_NOTE_TYPE,
                                                CHANNEL_RIGHT, 27)

        self._left_prelisten_button = ButtonElement(True, MIDI_NOTE_TYPE,
                                                    CHANNEL_LEFT, 25)
        self._right_prelisten_button = ButtonElement(True, MIDI_NOTE_TYPE,
                                                     CHANNEL_RIGHT, 25)

        self._left_fx_button = ButtonElement(True, MIDI_NOTE_TYPE,
                                             CHANNEL_LEFT, 24)
        self._right_fx_button = ButtonElement(True, MIDI_NOTE_TYPE,
                                              CHANNEL_RIGHT, 24)

        self._left_A_button = ButtonElement(True, MIDI_NOTE_TYPE, CHANNEL_LEFT,
                                            14)
        self._right_B_button = ButtonElement(True, MIDI_NOTE_TYPE,
                                             CHANNEL_RIGHT, 14)

        self._left_shift_button = ButtonElement(
            True,
            MIDI_NOTE_TYPE,
            CHANNEL_LEFT,
            26,
            name='Shift_Button',
            resource_type=PrioritizedResource)
        self._right_shift_button = ButtonElement(
            True,
            MIDI_NOTE_TYPE,
            CHANNEL_RIGHT,
            26,
            name='Shift_Button',
            resource_type=PrioritizedResource)

        self._left_sync_button = ButtonElement(True, MIDI_NOTE_TYPE,
                                               CHANNEL_LEFT, 29)
        self._right_sync_button = ButtonElement(True, MIDI_NOTE_TYPE,
                                                CHANNEL_RIGHT, 29)

        self._left_cue_button = ButtonElement(True, MIDI_NOTE_TYPE,
                                              CHANNEL_LEFT, 30)
        self._right_cue_button = ButtonElement(True, MIDI_NOTE_TYPE,
                                               CHANNEL_RIGHT, 30)

        self._left_sync_button_shift = ButtonElement(True, MIDI_NOTE_TYPE,
                                                     CHANNEL_LEFT, 47)
        self._right_sync_button_shift = ButtonElement(True, MIDI_NOTE_TYPE,
                                                      CHANNEL_RIGHT, 47)

        self._left_cue_button_shift = ButtonElement(True, MIDI_NOTE_TYPE,
                                                    CHANNEL_LEFT, 48)
        self._right_cue_button_shift = ButtonElement(True, MIDI_NOTE_TYPE,
                                                     CHANNEL_RIGHT, 48)

        for i in range(3):
            for side, channel in zip(['_left', '_right'],
                                     [CHANNEL_LEFT, CHANNEL_RIGHT]):
                setattr(self, side + '_loop_' + str(i + 1),
                        ButtonElement(True, MIDI_NOTE_TYPE, channel, 15 + i))
                setattr(self, side + '_loop_' + str(i + 1) + '_shift',
                        ButtonElement(True, MIDI_NOTE_TYPE, channel, 40 + i))
                setattr(self, side + '_hotcue_' + str(i + 1),
                        ButtonElement(True, MIDI_NOTE_TYPE, channel, 18 + i))
                setattr(self, side + '_hotcue_' + str(i + 1) + '_shift',
                        ButtonElement(True, MIDI_NOTE_TYPE, channel, 43 + i))
                setattr(self, side + '_nolight_' + str(i + 1),
                        ButtonElement(True, MIDI_NOTE_TYPE, channel, 21 + i))

        # ------ ENCODER

        # browser
        self._center_browse_encoder = EncoderElement(
            MIDI_CC_TYPE, CHANNEL_CENTER, 30,
            Live.MidiMap.MapMode.relative_smooth_two_compliment)
        # gain left
        self._left_gain_encoder = EncoderElement(MIDI_CC_TYPE, CHANNEL_LEFT,
                                                 26,
                                                 Live.MidiMap.MapMode.absolute)
        # gain right
        self._right_gain_encoder = EncoderElement(
            MIDI_CC_TYPE, CHANNEL_RIGHT, 26, Live.MidiMap.MapMode.absolute)

        # middle light off -> does not send on-off messages!
        self._left_jogwheel_encoder = EncoderElement(
            MIDI_CC_TYPE, CHANNEL_LEFT, 14,
            Live.MidiMap.MapMode.relative_smooth_two_compliment)
        self._right_jogwheel_encoder = EncoderElement(
            MIDI_CC_TYPE, CHANNEL_RIGHT, 14,
            Live.MidiMap.MapMode.relative_smooth_two_compliment)

        self._left_jogwheel_encoder_shift = EncoderElement(
            MIDI_CC_TYPE, CHANNEL_LEFT, 15,
            Live.MidiMap.MapMode.relative_smooth_two_compliment)
        self._right_jogwheel_encoder_shift = EncoderElement(
            MIDI_CC_TYPE, CHANNEL_RIGHT, 15,
            Live.MidiMap.MapMode.relative_smooth_two_compliment)

        # middle light on  -> sends on-off message on channel 31!
        self._left_jogwheel_encoder_active = EncoderElement(
            MIDI_CC_TYPE, CHANNEL_LEFT, 16,
            Live.MidiMap.MapMode.relative_smooth_two_compliment)
        self._left_jogwheel_encoder_active_button = ButtonElement(
            True, MIDI_NOTE_TYPE, CHANNEL_LEFT, 31)

        self._right_jogwheel_encoder_active = EncoderElement(
            MIDI_CC_TYPE, CHANNEL_RIGHT, 16,
            Live.MidiMap.MapMode.relative_smooth_two_compliment)
        self._right_jogwheel_encoder_active_button = ButtonElement(
            True, MIDI_NOTE_TYPE, CHANNEL_RIGHT, 31)

        # FX touchpad (same for both channels so we need to read only one)
        self._touchpad_x_encoder = EncoderElement(
            MIDI_CC_TYPE, CHANNEL_LEFT, 12, Live.MidiMap.MapMode.absolute)
        self._touchpad_y_encoder = EncoderElement(
            MIDI_CC_TYPE, CHANNEL_LEFT, 13, Live.MidiMap.MapMode.absolute)
        self._touchpad_x_encoder_shift = EncoderElement(
            MIDI_CC_TYPE, CHANNEL_CENTER, 17, Live.MidiMap.MapMode.absolute)
        self._touchpad_y_encoder_shift = EncoderElement(
            MIDI_CC_TYPE, CHANNEL_CENTER, 18, Live.MidiMap.MapMode.absolute)

        # hi-mid-lo encoders
        _device_MSG_IDS = [27, 28, 29]
        self._device_encoders = ButtonMatrixElement(
            rows=[[
                EncoderElement(MIDI_CC_TYPE, CHANNEL_LEFT, MSG_ID,
                               Live.MidiMap.MapMode.absolute)
                for MSG_ID in _device_MSG_IDS
            ],
                  [
                      EncoderElement(MIDI_CC_TYPE, CHANNEL_RIGHT, MSG_ID,
                                     Live.MidiMap.MapMode.absolute)
                      for MSG_ID in _device_MSG_IDS
                  ]])

    def _setup_loop_control(self):
        # set looping function ality to Loop- and HotCue buttons
        self._looper_left = LooperComponent(self,
                                            assign_track=0,
                                            move_increment=4,
                                            increase_factor=(0, 2),
                                            decrease_factor=(0, 2),
                                            start_loop_length=32,
                                            quantize_start=4)
        self._looper_right = LooperComponent(self,
                                             assign_track=1,
                                             move_increment=4,
                                             increase_factor=(0, 2),
                                             decrease_factor=(0, 2),
                                             start_loop_length=32,
                                             quantize_start=1)

        self._looper_left_fine = LooperComponent(self,
                                                 assign_track=0,
                                                 move_increment=1,
                                                 increase_factor=(1, 1),
                                                 decrease_factor=(1, 1),
                                                 start_loop_length=16,
                                                 quantize_start=1)
        self._looper_right_fine = LooperComponent(self,
                                                  assign_track=1,
                                                  move_increment=1,
                                                  increase_factor=(1, 1),
                                                  decrease_factor=(1, 1),
                                                  start_loop_length=16,
                                                  quantize_start=1)

        self._looper_left.set_loop_decrease_button(self._left_loop_1)
        self._looper_left.set_loop_start_button(self._left_loop_2)
        self._looper_left.set_loop_increase_button(self._left_loop_3)
        self._looper_left.set_loop_move_left_button(self._left_loop_1_shift)
        self._looper_left.set_loop_toggle_button(self._left_loop_2_shift)
        self._looper_left.set_loop_move_right_button(self._left_loop_3_shift)

        self._looper_left_fine.set_loop_decrease_button(self._left_hotcue_1)
        self._looper_left_fine.set_loop_start_button(self._left_hotcue_2)
        self._looper_left_fine.set_loop_increase_button(self._left_hotcue_3)
        self._looper_left_fine.set_loop_move_left_button(
            self._left_hotcue_1_shift)
        self._looper_left_fine.set_loop_toggle_button(
            self._left_hotcue_2_shift)
        self._looper_left_fine.set_loop_move_right_button(
            self._left_hotcue_3_shift)

        self._looper_right.set_loop_decrease_button(self._right_loop_1)
        self._looper_right.set_loop_start_button(self._right_loop_2)
        self._looper_right.set_loop_increase_button(self._right_loop_3)
        self._looper_right.set_loop_move_left_button(self._right_loop_1_shift)
        self._looper_right.set_loop_toggle_button(self._right_loop_2_shift)
        self._looper_right.set_loop_move_right_button(self._right_loop_3_shift)

        self._looper_right_fine.set_loop_decrease_button(self._right_hotcue_1)
        self._looper_right_fine.set_loop_start_button(self._right_hotcue_2)
        self._looper_right_fine.set_loop_increase_button(self._right_hotcue_3)
        self._looper_right_fine.set_loop_move_left_button(
            self._right_hotcue_1_shift)
        self._looper_right_fine.set_loop_toggle_button(
            self._right_hotcue_2_shift)
        self._looper_right_fine.set_loop_move_right_button(
            self._right_hotcue_3_shift)

    def _setup_scrub_control(self):
        self._scrub_left = ScrubComponent(self,
                                          assign_track=LEFT_STRIP_ID,
                                          increment_scrub=1,
                                          increment_fine=0.1)
        self._scrub_right = ScrubComponent(self,
                                           assign_track=RIGHT_STRIP_ID,
                                           increment_scrub=1,
                                           increment_fine=0.1)

        self._scrub_left.set_move_position_button(self._left_jogwheel_encoder)
        self._scrub_left.set_move_position_coarse_button(
            self._left_jogwheel_encoder_shift)
        self._scrub_left.set_scrub_position_button(
            self._left_jogwheel_encoder_active)
        self._scrub_left.set_scrub_on_off_button(
            self._left_jogwheel_encoder_active_button)

        self._scrub_right.set_move_position_button(
            self._right_jogwheel_encoder)
        self._scrub_right.set_move_position_coarse_button(
            self._right_jogwheel_encoder_shift)
        self._scrub_right.set_scrub_position_button(
            self._right_jogwheel_encoder_active)
        self._scrub_right.set_scrub_on_off_button(
            self._right_jogwheel_encoder_active_button)

    def _setup_fx_control(self):
        self._fx_left = FXComponent(self, assign_track=LEFT_STRIP_ID)
        self._fx_left.set_touchpad_x_button(self._touchpad_x_encoder)
        self._fx_left.set_touchpad_y_button(self._touchpad_y_encoder)
        self._fx_left.set_touchpad_x_shift_button(
            self._touchpad_x_encoder_shift)
        self._fx_left.set_touchpad_y_shift_button(
            self._touchpad_y_encoder_shift)
        self._fx_left.set_fx_on_off_button(self._left_fx_button)
        self._fx_left.set_gain_encoder_button(self._left_gain_encoder)

        self._fx_left.set_warping_button(self._left_sync_button_shift)
        self._fx_left.set_warp_mode_button(self._left_sync_button)

        self._fx_left.set_pitch_down_button(self._left_nolight_1)
        self._fx_left.set_pitch_up_button(self._left_nolight_3)

        self._fx_right = FXComponent(self, assign_track=RIGHT_STRIP_ID)
        self._fx_right.set_touchpad_x_button(self._touchpad_x_encoder)
        self._fx_right.set_touchpad_y_button(self._touchpad_y_encoder)
        self._fx_right.set_touchpad_x_shift_button(
            self._touchpad_x_encoder_shift)
        self._fx_right.set_touchpad_y_shift_button(
            self._touchpad_y_encoder_shift)
        self._fx_right.set_fx_on_off_button(self._right_fx_button)
        self._fx_right.set_gain_encoder_button(self._right_gain_encoder)

        self._fx_right.set_warping_button(self._right_sync_button_shift)
        self._fx_right.set_warp_mode_button(self._right_sync_button)

    def _setup_transport_control(self):
        """set up the sliders"""

        self._transport = TransportComponent(self,
                                             name=u'Transport',
                                             is_enabled=False)

        #set tempo-fader
        self._transport.set_tempo_control(
            self._left_tempo_fader,
            fine_control=self._right_tempo_fader)  #(control, fine_control)

        self._transport.set_enabled(True)

    def _setup_mixer_control(self):
        self._mixer = MixerComponent(num_tracks=2,
                                     num_returns=0,
                                     name=u'Mixer',
                                     is_enabled=False)

        self._mixer.set_crossfader_control(self._crossfader_slider)

        # set volume sliders
        self._mixer.channel_strip(LEFT_STRIP_ID).set_volume_control(
            self._left_volume_slider)
        self._mixer.channel_strip(RIGHT_STRIP_ID).set_volume_control(
            self._right_volume_slider)

        # set prelisten buttons
        self._mixer.channel_strip(LEFT_STRIP_ID).set_solo_button(
            self._left_prelisten_button)
        self._mixer.channel_strip(RIGHT_STRIP_ID).set_solo_button(
            self._right_prelisten_button)

        # use fx buttons to select a track
        self._mixer.channel_strip(LEFT_STRIP_ID).set_select_button(
            self._left_A_button)
        self._mixer.channel_strip(RIGHT_STRIP_ID).set_select_button(
            self._right_B_button)

        self._mixer.set_enabled(True)

    def _setup_session_control(self):
        self._session = SessionComponent(num_tracks=2,
                                         num_scenes=1,
                                         name=u'Session',
                                         is_enabled=False)

        # set horizontal scene selector (this is why we import SessionComponent from _Arturia!)
        self._session.set_scene_select_control(self._center_browse_encoder)

        # set launch-buttons for scene
        self._session.selected_scene().clip_slot(0).set_launch_button(
            self._left_play_button)
        self._session.selected_scene().clip_slot(1).set_launch_button(
            self._right_play_button)

        # hightlite the current selection
        self.set_highlighting_session_component(self._session)
        self._session.set_enabled(True)

        # ----------- add functionality to turn playing-light on-off
        def update_lights(track, button):
            playing_clip_idx = track.playing_slot_index
            if playing_clip_idx >= 0:
                button.turn_on()
            else:
                button.turn_off()

        def update_playlight_left():
            track = self.song().tracks[LEFT_STRIP_ID]
            update_lights(track, self._left_play_button)

        def update_playlight_right():
            track = self.song().tracks[RIGHT_STRIP_ID]
            update_lights(track, self._right_play_button)

        self.song().tracks[LEFT_STRIP_ID].add_playing_slot_index_listener(
            update_playlight_left)
        self.song().tracks[RIGHT_STRIP_ID].add_playing_slot_index_listener(
            update_playlight_right)
        # override the selected scene change behaviour of the playing light
        self.song().view.add_selected_scene_listener(update_playlight_left)
        self.song().view.add_selected_scene_listener(update_playlight_right)
 def _tap_tempo_value(self, value): # Added as Shift + Tap Tempo
     if not self._shift_pressed:
     #if self._shift_pressed:
         TransportComponent._tap_tempo_value(self, value)
	def _overdub_value(self, value):
		if not self._shift_pressed:
			TransportComponent._overdub_value(self, value)
	def _tap_tempo_value(self, value): # Added as Shift + Tap Tempo
		if not self._shift_pressed:
		#if self._shift_pressed:
			TransportComponent._tap_tempo_value(self, value)
 def _setup_transport_control(self):
     is_momentary = True
     transport = TransportComponent()
     transport.set_play_button(ButtonElement(is_momentary, MIDI_NOTE_TYPE, 12, 80))
     transport.set_record_button(ButtonElement(is_momentary, MIDI_NOTE_TYPE, 12, 81))
     transport.set_nudge_buttons(ButtonElement(is_momentary, MIDI_NOTE_TYPE, 12, 86), ButtonElement(is_momentary, MIDI_NOTE_TYPE, 12, 85))
     transport.set_loop_button(ButtonElement(is_momentary, MIDI_NOTE_TYPE, 12, 84))
     transport.set_punch_buttons(ButtonElement(is_momentary, MIDI_NOTE_TYPE, 12, 82), ButtonElement(is_momentary, MIDI_NOTE_TYPE, 12, 83))
     transport.set_tempo_control(SliderElement(MIDI_CC_TYPE, 12, 26), SliderElement(MIDI_CC_TYPE, 12, 25))
 def _overdub_value(self, value):
     if not self._shift_pressed:
         TransportComponent._overdub_value(self, value)