Beispiel #1
0
    def disconnect(self):
        for button in self._modes_buttons:
            button.remove_value_listener(self._mode_value)

        self._controls = None
        self._mixer = None
        ModeSelectorComponent.disconnect(self)
    def __init__(self, mixer_modes, device, encoders, page_buttons):
        raise isinstance(mixer_modes,
                         EncoderMixerModeSelector) or AssertionError
        raise isinstance(device, PageableDeviceComponent) or AssertionError
        raise isinstance(encoders, tuple) or AssertionError
        raise isinstance(page_buttons, tuple) or AssertionError
        ModeSelectorComponent.__init__(self)
        self._mixer_modes = mixer_modes
        self._device = device
        self._encoders = encoders
        self._page_buttons = page_buttons
        self._peek_button = None
        self._encoders_display = None
        self._value_display = None
        self._device_display = None
        self._page_displays = None
        self._device_dummy_source = DisplayDataSource()
        self._parameter_source = DisplayDataSource()
        self._device_dummy_source.set_display_string('Mixer')
        self._clean_value_display_in = -1
        self._must_update_encoder_display = False
        self._register_timer_callback(self._on_timer)
        identify_sender = True
        for encoder in self._encoders:
            encoder.add_value_listener(self._parameter_value, identify_sender)

        self.set_mode(0)
 def disconnect(self):
     self._unregister_timer_callback(self._on_timer)
     ModeSelectorComponent.disconnect(self)
     self._mixer = None
     self._fader_buttons = None
     self._flashing_button = None
     return
 def __init__(self, parent, select_buttons, master_button, stop_buttons,
              stop_all_button, mute_buttons, solo_buttons, arm_buttons,
              scene_buttons, matrix, session, zooming, mixer, slider_modes,
              matrix_modes, sequencer):
     assert len(select_buttons) == 8
     assert len(arm_buttons) == 8
     ModeSelectorComponent.__init__(self)
     self._toggle_pressed = False
     self._note_mode_active = False
     self._invert_assignment = False
     self._select_buttons = select_buttons
     self._master_button = master_button
     self._slider_modes = slider_modes
     self._matrix_modes = matrix_modes  #added new
     self._stop_buttons = stop_buttons
     self._stop_all_button = stop_all_button
     self._mute_buttons = mute_buttons
     self._solo_buttons = solo_buttons
     self._arm_buttons = arm_buttons
     self._scene_launch_buttons = scene_buttons
     # self._transport = transport
     self._session = session
     self._zooming = zooming
     self._matrix = matrix
     self._mixer = mixer
     # self._mode_callback = mode_callback
     self._parent = parent  #use this to call methods of parent class
     self._sequencer = sequencer
     self._sequencer.set_enabled(False)
     self._master_button.add_value_listener(self._master_value)
     self._step_sequencer_active = False  # temporary!!!!
 def __init__(self, parent, select_buttons, master_button, stop_buttons, stop_all_button, mute_buttons, solo_buttons, arm_buttons, scene_buttons, matrix, session, zooming, mixer, slider_modes, matrix_modes, sequencer):
     assert len(select_buttons) == 8
     assert len(arm_buttons) == 8
     ModeSelectorComponent.__init__(self)
     self._toggle_pressed = False
     self._note_mode_active = False
     self._invert_assignment = False
     self._select_buttons = select_buttons
     self._master_button = master_button
     self._slider_modes = slider_modes
     self._matrix_modes = matrix_modes #added new 
     self._stop_buttons = stop_buttons
     self._stop_all_button = stop_all_button
     self._mute_buttons = mute_buttons
     self._solo_buttons = solo_buttons
     self._arm_buttons = arm_buttons
     self._scene_launch_buttons = scene_buttons
     # self._transport = transport
     self._session = session
     self._zooming = zooming
     self._matrix = matrix
     self._mixer = mixer
     # self._mode_callback = mode_callback
     self._parent = parent #use this to call methods of parent class
     self._sequencer = sequencer
     self._sequencer.set_enabled(False)
     self._master_button.add_value_listener(self._master_value)
     self._step_sequencer_active = False # temporary!!!!
Beispiel #6
0
    def __init__(self, matrix, top_buttons, side_buttons, config_button):
        raise isinstance(matrix, ButtonMatrixElement) or AssertionError
        raise matrix.width() == 8 and matrix.height() == 8 or AssertionError
        raise isinstance(top_buttons, tuple) or AssertionError
        raise len(top_buttons) == 8 or AssertionError
        raise isinstance(side_buttons, tuple) or AssertionError
        raise len(side_buttons) == 8 or AssertionError
        raise isinstance(config_button, ButtonElement) or AssertionError
        ModeSelectorComponent.__init__(self)
        self._session = SpecialSessionComponent(matrix.width(),
                                                matrix.height())
        self._zooming = DeprecatedSessionZoomingComponent(self._session)
        self._session.name = 'Session_Control'
        self._zooming.name = 'Session_Overview'
        self._matrix = matrix
        self._side_buttons = side_buttons
        self._nav_buttons = top_buttons[:4]
        self._config_button = config_button
        self._zooming.set_empty_value(LED_OFF)
        self._all_buttons = []
        for button in self._side_buttons + self._nav_buttons:
            self._all_buttons.append(button)

        self._sub_modes = SubSelectorComponent(matrix, side_buttons,
                                               self._session)
        self._sub_modes.name = 'Mixer_Modes'
        self._sub_modes.set_update_callback(self._update_control_channels)
        self._init_session()
        self._all_buttons = tuple(self._all_buttons)
        self.set_modes_buttons(top_buttons[4:])
 def __init__(self, select_buttons, show_pot_values_button, p1buttons, scene_up_button, scene_down_button, scene_launch_button, session, mixer, encoder_modes, device, device_control, clip_launch_buttons, pot_modes, pad_buttons = None, pot_encoders = None, parent=None):
     assert len(select_buttons) == 8
     if BROWSER_ENABLE:
         assert len(pad_buttons) == 8
         assert len(pot_encoders) == 8
     self._parent = parent
     ModeSelectorComponent.__init__(self)
     self._master_mode = False
     self._toggle_pressed = False
     self._select_buttons = select_buttons
     self._show_pot_values_button = show_pot_values_button
     self._scene_up_button = scene_up_button
     self._scene_down_button = scene_down_button 
     self._scene_launch_button = scene_launch_button
     self._clip_launch_buttons = clip_launch_buttons
     if BROWSER_ENABLE:
         self._pad_buttons = pad_buttons
         self._pot_encoders = pot_encoders
     self._encoder_mode_buttons = self._select_buttons + (self._scene_up_button,)
     self._p1buttons = p1buttons
     self._encoder_modes = encoder_modes
     self._pot_modes = pot_modes
     self._pot_mode_buttons = None
     self._session = session
     self._mixer = mixer
     self._device = device
     self._device_control = device_control
    def disconnect(self):
        for button in self._modes_buttons:
            button.remove_value_listener(self._mode_value)

        self._controls = None
        self._mixer = None
        ModeSelectorComponent.disconnect(self)
 def disconnect(self):
     ModeSelectorComponent.disconnect(self)
     self._transport = None
     self._session = None
     self._ffwd_button = None
     self._rwd_button = None
     self._app_view().remove_is_view_visible_listener('Session', self._on_view_changed)
 def disconnect(self):
     ModeSelectorComponent.disconnect(self)
     self._transport = None
     self._session = None
     self._ffwd_button = None
     self._rwd_button = None
     self._app_view().remove_is_view_visible_listener('Session', self._on_view_changed)
Beispiel #11
0
 def __init__(self, script, callback):
     ModeSelectorComponent.__init__(self)
     self._script = script
     self.update = callback
     self._modes_buttons = []
     self._mode_index = 0
     self._last_mode = 0
 def __init__(
     self,
     device_0,
     device_1,
     session,
     mixer,
     device_nav,
     up_button,
     down_button,
     left_button,
     right_button,
     select_button,
 ):
     ModeSelectorComponent.__init__(self)
     self._device_0 = device_0
     self._device_1 = device_1
     self._session = session
     self._mixer = mixer
     self._device_nav = device_nav
     self._select_button = select_button
     self._left_button = left_button
     self._right_button = right_button
     self._up_button = up_button
     self._down_button = down_button
     self._mode_index = 0
	def __init__(self, matrix, top_buttons, side_buttons, config_button):
		assert isinstance(matrix, ButtonMatrixElement)
		assert ((matrix.width() == 8) and (matrix.height() == 8))
		assert isinstance(top_buttons, tuple)
		assert (len(top_buttons) == 8)
		assert isinstance(side_buttons, tuple)
		assert (len(side_buttons) == 8)
		assert isinstance(config_button, ButtonElement)
		ModeSelectorComponent.__init__(self)
		self._session = SpecialSessionComponent(self, len(self.song().tracks), matrix.height(), side_buttons)
		self._session.name = "Session_Control"
		self._matrix = matrix
		self._side_buttons = side_buttons
		self._nav_buttons = top_buttons[:4]
		self._config_button = config_button
		self._all_buttons = []
		for button in (self._side_buttons + self._nav_buttons):
			self._all_buttons.append(button)
		self._sub_modes = SpecialMixerSelectorComponent(matrix, side_buttons, self._session)
		self._sub_modes.name = "Mixer_Modes"
		self._sub_modes.set_update_callback(self._update_control_channels)
		self._init_session()
		self._all_buttons = tuple(self._all_buttons)
		self.set_modes_buttons(top_buttons[4:])
		# mixer-session hack
		self._buttons_for_mixer = []
		for button in (self._side_buttons[5:]):
			self._buttons_for_mixer.append(button)
		for scene_index in range(self._matrix.height()):
			for track_index in range(self._matrix.width()):
				if scene_index > SESSION_HEIGHT_FOR_MIXER:
					self._buttons_for_mixer.append(self._matrix.get_button(track_index, scene_index))
    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 __init__(self, mixer_modes, device, encoders, page_buttons):
        raise isinstance(mixer_modes, EncoderMixerModeSelector) or AssertionError
        raise isinstance(device, PageableDeviceComponent) or AssertionError
        raise isinstance(encoders, tuple) or AssertionError
        raise isinstance(page_buttons, tuple) or AssertionError
        ModeSelectorComponent.__init__(self)
        self._mixer_modes = mixer_modes
        self._device = device
        self._encoders = encoders
        self._page_buttons = page_buttons
        self._peek_button = None
        self._encoders_display = None
        self._value_display = None
        self._device_display = None
        self._page_displays = None
        self._device_dummy_source = DisplayDataSource()
        self._parameter_source = DisplayDataSource()
        self._device_dummy_source.set_display_string('Mixer')
        self._clean_value_display_in = -1
        self._must_update_encoder_display = False
        self._register_timer_callback(self._on_timer)
        identify_sender = True
        for encoder in self._encoders:
            encoder.add_value_listener(self._parameter_value, identify_sender)

        self.set_mode(0)
        return
Beispiel #16
0
    def __init__(self, mixer, session, mx_first_buttons, mx_second_buttons,
                 transport, ts_lock_button, ts_buttons):
        assert len(mx_first_buttons) == 8
        assert len(mx_second_buttons) == 8
        ModeSelectorComponent.__init__(self)
        self._master_mode = False
        self._mixer = mixer
        self._session = session

        self._mx_first_buttons = mx_first_buttons
        self._mx_second_buttons = mx_second_buttons

        self._transport = transport
        self._ts_lock_button = ts_lock_button
        #self._ts_locked = False
        #self._ts_lock_button.turn_off()
        self._ts_lock_button.add_value_listener(self._ts_lock_value)
        self._ts_buttons = ts_buttons
        self._transport.set_seek_buttons(self._ts_buttons[1],
                                         self._ts_buttons[0])
        self._transport.set_stop_button(self._ts_buttons[2],
                                        self._mx_second_buttons[2])
        self._transport.set_play_button(self._ts_buttons[3],
                                        self._mx_second_buttons[3])
        self._transport.set_loop_button(self._ts_buttons[4],
                                        self._mx_second_buttons[4])
        self._transport.set_record_button(self._ts_buttons[5],
                                          self._mx_second_buttons[5])
        self.set_mode(0)
 def disconnect(self):
     ModeSelectorComponent.disconnect(self)
     self._mixer = None
     self._device = None
     self._faders = None
     self._fader_button_modes = None
     self._master_fader_button = None
Beispiel #18
0
    def __init__(self, matrix, top_buttons, side_buttons, config_button):
        raise isinstance(matrix, ButtonMatrixElement) or AssertionError
        raise matrix.width() == 8 and matrix.height() == 8 or AssertionError
        raise isinstance(top_buttons, tuple) or AssertionError
        raise len(top_buttons) == 8 or AssertionError
        raise isinstance(side_buttons, tuple) or AssertionError
        raise len(side_buttons) == 8 or AssertionError
        raise isinstance(config_button, ButtonElement) or AssertionError
        ModeSelectorComponent.__init__(self)
        self._session = SpecialSessionComponent(matrix.width(), matrix.height())
        self._zooming = DeprecatedSessionZoomingComponent(self._session)
        self._session.name = 'Session_Control'
        self._zooming.name = 'Session_Overview'
        self._matrix = matrix
        self._side_buttons = side_buttons
        self._nav_buttons = top_buttons[:4]
        self._config_button = config_button
        self._zooming.set_empty_value(LED_OFF)
        self._all_buttons = []
        for button in self._side_buttons + self._nav_buttons:
            self._all_buttons.append(button)

        self._sub_modes = SubSelectorComponent(matrix, side_buttons, self._session)
        self._sub_modes.name = 'Mixer_Modes'
        self._sub_modes.set_update_callback(self._update_control_channels)
        self._init_session()
        self._all_buttons = tuple(self._all_buttons)
        self.set_modes_buttons(top_buttons[4:])
Beispiel #19
0
 def __init__(self, parent, c_instance, transport, session, ffwd_button,
              rwd_button, loop_button):
     if not isinstance(transport, TransportComponent):
         raise AssertionError
     if not isinstance(session, SessionComponent):
         raise AssertionError
     if not isinstance(ffwd_button, ButtonElement):
         raise AssertionError
     if not isinstance(rwd_button, ButtonElement):
         raise AssertionError
     if not isinstance(loop_button, ButtonElement):
         raise AssertionError
     ModeSelectorComponent.__init__(self)
     self._parent = parent
     self.c_instance = c_instance
     self._transport = transport
     self._session = session
     self._ffwd_button = ffwd_button
     self._rwd_button = rwd_button
     self._loop_button = loop_button
     self._shift_pressed = False
     self.application().view.add_is_view_visible_listener(
         'Session', self._on_view_changed)
     self._loop_button.add_value_listener(self._loop_pressed)
     self.update()
Beispiel #20
0
	def disconnect(self):
		self._session = None
		self._mixer = None
		self._matrix = None
		self._side_buttons = None
		self._update_callback = None
		ModeSelectorComponent.disconnect(self)
    def __init__(self, matrix, side_buttons, session):
        raise isinstance(matrix, ButtonMatrixElement) or AssertionError
        raise matrix.width() == 8 and matrix.height() == 8 or AssertionError
        raise isinstance(side_buttons, tuple) or AssertionError
        raise len(side_buttons) == 8 or AssertionError
        raise isinstance(session, SessionComponent) or AssertionError
        ModeSelectorComponent.__init__(self)
        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 __init__(
     self,
     encoders,
     select_button,
     up_button,
     down_button,
     left_button,
     right_button,
     mixer,
     session,
     device,
     mixer_modes,
     device_nav,
 ):
     ModeSelectorComponent.__init__(self)
     self._encoders = encoders
     self._select_button = select_button
     self._up_button = up_button
     self._down_button = down_button
     self._left_button = left_button
     self._right_button = right_button
     self._mixer = mixer
     self._session = session
     self._device = device
     self._mixer_modes = mixer_modes
     self._device_nav = device_nav
	def __init__(self, script, callback):
		ModeSelectorComponent.__init__(self)
		self._script = script
		self.update = callback
		self._modes_buttons = []
		self._mode_index = 0
		self._last_mode = 0
Beispiel #24
0
 def __init__(self, matrix, top_buttons, side_buttons, config_button):
     assert isinstance(matrix, ButtonMatrixElement)
     assert ((matrix.width() == 8) and (matrix.height() == 8))
     assert isinstance(top_buttons, tuple)
     assert (len(top_buttons) == 8)
     assert isinstance(side_buttons, tuple)
     assert (len(side_buttons) == 8)
     assert isinstance(config_button, ButtonElement)
     ModeSelectorComponent.__init__(self)
     self._session = SpecialSessionComponent(self, len(self.song().tracks),
                                             matrix.height(), side_buttons)
     self._session.name = "Session_Control"
     self._matrix = matrix
     self._side_buttons = side_buttons
     self._nav_buttons = top_buttons[:4]
     self._config_button = config_button
     self._all_buttons = []
     for button in (self._side_buttons + self._nav_buttons):
         self._all_buttons.append(button)
     self._sub_modes = SpecialMixerSelectorComponent(
         matrix, side_buttons, self._session)
     self._sub_modes.name = "Mixer_Modes"
     self._sub_modes.set_update_callback(self._update_control_channels)
     self._init_session()
     self._all_buttons = tuple(self._all_buttons)
     self.set_modes_buttons(top_buttons[4:])
     # mixer-session hack
     self._buttons_for_mixer = []
     for button in (self._side_buttons[5:]):
         self._buttons_for_mixer.append(button)
     for scene_index in range(self._matrix.height()):
         for track_index in range(self._matrix.width()):
             if scene_index > SESSION_HEIGHT_FOR_MIXER:
                 self._buttons_for_mixer.append(
                     self._matrix.get_button(track_index, scene_index))
 def disconnect(self):
     self._unregister_timer_callback(self._on_timer)
     ModeSelectorComponent.disconnect(self)
     self._mixer = None
     self._fader_button = None
     self._flashing_button = None
     return
 def __init__(self, matrix, session, zooming, stop_buttons, parent):
     assert isinstance(matrix, ButtonMatrixElement)
     ModeSelectorComponent.__init__(self)
     self._controls = None
     self._session = session
     self._session_zoom = zooming
     self._matrix = matrix
     self._track_stop_buttons = stop_buttons
     self._stop_button_matrix = ButtonMatrixElement(
     )  #new dummy matrix for stop buttons, to allow note mode/user mode switching
     button_row = []
     for track_index in range(8):
         button = self._track_stop_buttons[track_index]
         button_row.append(button)
     self._stop_button_matrix.add_row(tuple(button_row))
     self._nav_left_button = None
     self._nav_right_button = None
     self._mode_index = 0
     self._last_mode = 0
     self._parent = parent
     self._parent.set_pad_translations(
         PAD_TRANSLATIONS)  #comment out to remove Drum Rack mapping
     self._vu = None
     self._shift_button = self._parent._shift_button
     self._shift_button.add_value_listener(self._shift_value)
	def __init__(self, script, update):
		ModeSelectorComponent.__init__(self)
		self._script = script
		self._update = update
		self._mode_index = 0
		self._l_mode_index = 0
		self._r_mode_index = 0
		self._m_mode_index = 0
Beispiel #28
0
    def disconnect(self):
        for button in self._modes_buttons:
            button.remove_value_listener(self._mode_value)

        self._controls = None
        self._mixer = None
        self._unregister_timer_callback(self._on_timer)  #added
        ModeSelectorComponent.disconnect(self)
Beispiel #29
0
 def __init__(self, script, update):
     ModeSelectorComponent.__init__(self)
     self._script = script
     self._update = update
     self._mode_index = 0
     self._l_mode_index = 0
     self._r_mode_index = 0
     self._m_mode_index = 0
    def disconnect(self):
        for button in self._modes_buttons:
            button.remove_value_listener(self._mode_value)

        self._controls = None
        self._mixer = None
        self._unregister_timer_callback(self._on_timer) #added
        ModeSelectorComponent.disconnect(self)
 def __init__(self, matrix, session, mixer, sequencer, parent): 
   ModeSelectorComponent.__init__(self)
   self._matrix = matrix
   self._session = session
   self._mixer = mixer
   self._parent = parent
   self._sequencer = sequencer
   self.set_mode(0)
 def __init__(self, transport, session, ffwd_button, rwd_button):
     ModeSelectorComponent.__init__(self)
     self._transport = transport
     self._session = session
     self._ffwd_button = ffwd_button
     self._rwd_button = rwd_button
     self._app_view().add_is_view_visible_listener('Session', self._on_view_changed)
     self.update()
Beispiel #33
0
 def __init__(self, script):
     ModeSelectorComponent.__init__(self)
     self._script = script
     self._mode_toggle1 = None
     self._mode_toggle2 = None
     self._mode_toggle3 = None
     self._mode_index = 0
     self._last_mode = 0
	def __init__(self, script):
		ModeSelectorComponent.__init__(self)
		self._script = script
		self._mode_toggle1 = None
		self._mode_toggle2 = None
		self._mode_toggle3 = None
		self._mode_index = 0
		self._last_mode = 0
	def __init__(self, script):
		ModeSelectorComponent.__init__(self)
		self._script = script
		self._mode_index = 0
		self._number_of_modes = 0
		self._offset = 0
		self._buttons = None
		self._last_preset = 0
 def __init__(self, mixer, device, encoders):
     ModeSelectorComponent.__init__(self)
     self._mixer = mixer
     self._device = device
     self._encoders = encoders
     self._mode_index = 1
     self._submode_index = 1
     self._number_of_modes = 4
	def __init__(self, script):
		ModeSelectorComponent.__init__(self)
		self._script = script
		self._mode_index = 0
		self._number_of_modes = 0
		self._offset = 0
		self._buttons = None
		self._last_preset = 0
 def disconnect(self):
     ModeSelectorComponent.disconnect(self)
     self._transport = None
     self._session = None
     self._ffwd_button = None
     self._rwd_button = None
     self._loop_button = None
     self.application().view.remove_is_view_visible_listener("Session", self._on_view_changed)
 def __init__(self, mixer, device, encoders):
     ModeSelectorComponent.__init__(self)
     self._mixer = mixer
     self._device = device
     self._encoders = encoders
     self._mode_index = 1
     self._submode_index = 1
     self._number_of_modes = 4
 def __init__(self, transport, session, ffwd_button, rwd_button):
     ModeSelectorComponent.__init__(self)
     self._transport = transport
     self._session = session
     self._ffwd_button = ffwd_button
     self._rwd_button = rwd_button
     self._app_view().add_is_view_visible_listener('Session', self._on_view_changed)
     self.update()
Beispiel #41
0
    def __init__(self, matrix, top_buttons, side_buttons, config_button, osd,
                 parent):
        assert isinstance(matrix, ButtonMatrixElement)
        assert ((matrix.width() == 8) and (matrix.height() == 8))
        assert isinstance(top_buttons, tuple)
        assert (len(top_buttons) == 8)
        assert isinstance(side_buttons, tuple)
        assert (len(side_buttons) == 8)
        assert isinstance(config_button, ButtonElement)
        ModeSelectorComponent.__init__(self)
        self._osd = osd
        self._parent = parent
        self._mode_index = 0
        self._previous_mode_index = -1
        self._main_mode_index = 0
        self._sub_mode_index = [0, 0, 0, 0]
        for index in range(4):
            self._sub_mode_index[index] = 0
        self.set_mode_buttons(top_buttons[4:])
        self._session = SpecialSessionComponent(matrix.width(),
                                                matrix.height(), self)
        self._session.set_osd(self._osd)
        self._zooming = SessionZoomingComponent(self._session)
        self._session.name = 'Session_Control'
        self._zooming.name = 'Session_Overview'
        self._matrix = matrix
        self._side_buttons = side_buttons
        self._nav_buttons = top_buttons[:4]
        self._config_button = config_button
        self._zooming.set_empty_value(LED_OFF)
        self._all_buttons = []
        for button in self._side_buttons + self._nav_buttons:
            self._all_buttons.append(button)

        self._sub_modes = SubSelectorComponent(matrix, side_buttons,
                                               self._session)
        self._sub_modes.name = 'Mixer_Modes'
        self._sub_modes._mixer.set_osd(self._osd)
        self._sub_modes.set_update_callback(self._update_control_channels)
        self._stepseq = StepSequencerComponent(self._matrix,
                                               self._side_buttons,
                                               self._nav_buttons, self)
        self._stepseq.set_osd(self._osd)
        self._stepseq2 = StepSequencerComponent2(self._matrix,
                                                 self._side_buttons,
                                                 self._nav_buttons, self)
        self._stepseq2.set_osd(self._osd)

        self._instrument_controller = InstrumentControllerComponent(
            self._matrix, self._side_buttons, self._nav_buttons, self)
        self._instrument_controller.set_osd(self._osd)

        self._device_controller = DeviceControllerComponent(
            self._matrix, self._side_buttons, self._nav_buttons, self)
        self._device_controller.set_osd(self._osd)

        self._init_session()
        self._all_buttons = tuple(self._all_buttons)
 def disconnect(self):
     ModeSelectorComponent.disconnect(self)
     self._parent = None #added
     self._bank_buttons = None #added
     self._encoder_modes = None
     self._encoder_user_modes = None
     self._encoder_eq_modes = None
     self._encoder_device_modes = None
     return None
	def __init__(self, script, prefix, devices):
		ModeSelectorComponent.__init__(self)
		self._script = script
		self._mode_index = 0
		self._number_of_modes = 0
		self._prefix = prefix
		self._devices = devices
		self._select_buttons = [None for index in range(len(self._devices))]
		self._selected_device = self._devices[0]
 def __init__(self, transport, session, ffwd_button, rwd_button, loop_button):
     ModeSelectorComponent.__init__(self)
     self._transport = transport
     self._session = session
     self._ffwd_button = ffwd_button
     self._rwd_button = rwd_button
     self._loop_button = loop_button
     self.application().view.add_is_view_visible_listener("Session", self._on_view_changed)
     self._on_view_changed()
Beispiel #45
0
 def disconnect(self):
     ModeSelectorComponent.disconnect(self)
     self._parent = None  #added
     self._bank_buttons = None  #added
     self._encoder_modes = None
     self._encoder_user_modes = None
     self._encoder_eq_modes = None
     self._encoder_device_modes = None
     return None
 def disconnect(self):
     ModeSelectorComponent.disconnect(self)
     self._select_buttons = None
     self._show_pot_values_button = None
     self._encoder_modes = None
     self._slider_modes = None
     self._mixer = None
     self._device = None
     return None
 def __init__(self, transport, session, ffwd_button, rwd_button, loop_button):
     ModeSelectorComponent.__init__(self)
     self._transport = transport
     self._session = session
     self._ffwd_button = ffwd_button
     self._rwd_button = rwd_button
     self._loop_button = loop_button
     self.application().view.add_is_view_visible_listener('Session', self._on_view_changed)
     self._on_view_changed()
 def disconnect(self):
     ModeSelectorComponent.disconnect(self)
     self._transport = None
     self._session = None
     self._ffwd_button = None
     self._rwd_button = None
     self._loop_button = None
     self.application().view.remove_is_view_visible_listener('Session', self._on_view_changed)
     return
 def __init__(self, mixer):
     assert isinstance(mixer, MixerComponent)
     ModeSelectorComponent.__init__(self)
     self._controls = None
     self._mixer = mixer
     self.set_mode(0) #moved here
     self._pan_to_vol_ticks_delay = -1 #added
     self._mode_is_pan = True #new
     self._register_timer_callback(self._on_timer) #added
 def disconnect(self):
     ModeSelectorComponent.disconnect(self)
     self._mixer = None
     self._session = None
     self._master_mode = None
     self._slider_row_select_button = None
     self._button_modes = None
     self._first_row_select_button = None        
     return None
 def __init__(self, script, prefix, devices):
     ModeSelectorComponent.__init__(self)
     self._script = script
     self._mode_index = 0
     self._number_of_modes = 0
     self._prefix = prefix
     self._devices = devices
     self._select_buttons = [None for index in range(len(self._devices))]
     self._selected_device = self._devices[0]
Beispiel #52
0
 def disconnect(self):
     ModeSelectorComponent.disconnect(self)
     self._select_buttons = None
     self._show_pot_values_button = None
     self._encoder_modes = None
     self._slider_modes = None
     self._mixer = None
     self._device = None
     return None
Beispiel #53
0
 def __init__(self, mixer):
     assert isinstance(mixer, MixerComponent)
     ModeSelectorComponent.__init__(self)
     self._controls = None
     self._mixer = mixer
     self.set_mode(0)  #moved here
     self._pan_to_vol_ticks_delay = -1  #added
     self._mode_is_pan = True  #new
     self._register_timer_callback(self._on_timer)  #added
Beispiel #54
0
 def disconnect(self):
     ModeSelectorComponent.disconnect(self)
     self._mixer = None
     self._session = None
     self._master_mode = None
     self._slider_row_select_button = None
     self._button_modes = None
     self._first_row_select_button = None
     return None
 def disconnect(self):
     self._bank_down_button.remove_value_listener(self._bank_down_value)
     self._bank_up_button.remove_value_listener(self._bank_up_value)
     self.set_device_mixer_buttons(None, None)
     ModeSelectorComponent.disconnect(self)
     self._mixer = None
     self._device = None
     self._bank_up_button = None
     self._bank_down_button = None
     self._encoders = None
 def __init__(self, mixer, buttons):
     raise isinstance(mixer, MixerComponent) or AssertionError
     raise isinstance(buttons, tuple) or AssertionError
     raise len(buttons) == 8 or AssertionError
     ModeSelectorComponent.__init__(self)
     self._mixer = mixer
     self._buttons = buttons
     self._mode_display = None
     self._mode_index = 0
     self.update()
 def __init__(self, mixer, fader_button):
     ModeSelectorComponent.__init__(self)
     self._mixer = mixer
     self._fader_button = fader_button
     self._mode_index = 0
     self._number_of_modes = 3
     self._flashing_button = None
     self._flashing_button_on = True
     self._flashing_reset_delay = 0
     self._register_timer_callback(self._on_timer)
 def disconnect(self):
     for button in self._modes_buttons:
         button.remove_value_listener(self._mode_value)
     self._controls = None
     self._session = None
     self._session_zoom = None
     self._matrix = None
     self._track_stop_buttons = None
     self._stop_button_matrix = None
     ModeSelectorComponent.disconnect(self)