Example #1
0
 def disconnect(self):
     self.console_lock.set()
     self.push_socket.close()
     self.pull_socket.close()
     self.pub_socket.close()
     self.context.term()
     ControlSurface.disconnect(self)
Example #2
0
 def __init__(self, c_instance):
     publish_in_cs_list = True
     ControlSurface.__init__(self, c_instance, not publish_in_cs_list)
     self._device_selection_follows_track_selection = True
     with self.component_guard():
         self._matrix = None
         self._session = None
         self._mixer = None
         self._device = None
         self._scene_launch_buttons = None
         self._track_arm_buttons = None
         self._track_solo_buttons = None
         self._track_mute_buttons = None
         self._track_stop_buttons = None
         self._track_select_buttons = None
         self._device_on_off_button = None
         self._shift_button = None
         self._serato_interface = PySCAClipControl()
         self._serato_interface.PySCA_InitializeClipControl()
         self._setup_session_control()
         self._setup_mixer_control()
         self._setup_device_control()
         self._session.set_mixer(self._mixer)
         self.set_highlighting_session_component(self._session)
     return
    def _on_selected_track_changed(self):
        ControlSurface._on_selected_track_changed(self)
        
        ## Quirksmode
        if(self._newDjModeToggle_state):
        
	    	if self.application().view.is_view_visible('Detail/Clip'):
	    		self.application().view.show_view('Detail/DeviceChain')
	    		self.application().view.is_view_visible('Detail/DeviceChain')
	    	else:
	    		self.application().view.show_view('Detail/Clip')
	    		self.application().view.is_view_visible('Detail/Clip')
		
	    	if(self.song().view.selected_track != self.song().master_track):
		    	if (self.song().view.selected_track.playing_slot_index > -1):
		            self.song().view.selected_scene = self.song().scenes[self.song().view.selected_track.playing_slot_index]
	    
        
	        track_index = 0
	        for track in self.song().tracks:
	        	if track == self.song().view.selected_track:
	        		break
	        	track_index += 1
	        self.current_track = track_index
            
        
        
        track = self.song().view.selected_track
        device_to_select = track.view.selected_device
        if device_to_select == None and len(track.devices) > 0:
            device_to_select = track.devices[0]
        if device_to_select != None:
            self.song().view.select_device(device_to_select)
        self._device_component.set_device(device_to_select)
        return None
Example #4
0
    def disconnect(self):
        self._display_data_source.set_display_string("  ")
        self._shift_button.remove_value_listener(self._shift_value)
        self._inst_button.remove_value_listener(self._inst_value)
        for encoder in self._encoders:
            encoder.remove_value_listener(self._encoder_value)

        for slider in tuple(self._sliders) + (self._master_slider,):
            slider.remove_value_listener(self._slider_value)

        for button in tuple(self._strip_buttons) + (self._selected_mute_solo_button,):
            button.remove_value_listener(self._mixer_button_value)

        for button in self._device_bank_buttons:
            button.remove_value_listener(self._device_bank_value)

        self._encoders = None
        self._sliders = None
        self._strip_buttons = None
        self._master_slider = None
        self._current_midi_map = None
        self._selected_mute_solo_button = None
        self._inst_button = None
        self._shift_button = None
        self._device_navigation = None
        self._display = None
        ControlSurface.disconnect(self)
        self._send_midi(SYSEX_START + (32, 0, 247))
        return
Example #5
0
	def disconnect(self):
		"""clean things up on disconnect"""
		if not self._shift_button is None:
			if self._shift_button.value_has_listener(self._shift_value):
				self._shift_button.remove_value_listener(self._shift_value)
		for button in self._device_select_buttons:
			if button.value_has_listener(self._device_select_value):
				button.remove_value_listener(self._device_select_value)
		if self._session._is_linked():
			self._session._unlink()
		self.song().view.remove_selected_track_listener(self._update_selected_device)
		"""for cs in self._control_surfaces():
			for host in self._hosts:
				self.log_message('installed: ' + str(cs) + ' vs. ' + str(host))
				if str(type(cs)) == str(type(host)):
					self.log_message('disconnecting: ' + str(type(cs)))
					cs.disconnect(cs)"""
		#self._host._set_parameter_controls(None)
		self._hosts = []
		if self._linked_script != None:
			self._linked_script._update_linked_device_selection = None
		self._linked_script = None
		#self._disconnect_notifier.set_mode(0)
		self.log_message('<<<<<<<<<<<<<<<<<<<<<<<<< Codec log closed >>>>>>>>>>>>>>>>>>>>>>>>>')
		ControlSurface.disconnect(self)
		return None
Example #6
0
 def __init__(self, c_instance):
     #log(True, __name__)
     # basic init
     ControlSurface.__init__(self, c_instance)
     self.set_suppress_rebuild_requests(True)        
     self._suggested_input_port = "Traktor F1 - 1"
     self._suggested_output_port = "Traktor F1 - 1"
Example #7
0
    def __init__(self, c_instance):
        ControlSurface.__init__(self, c_instance)
        with self.component_guard():
            self.set_pad_translations(PAD_TRANSLATIONS)
            self._device_selection_follows_track_selection = True
            self._suggested_input_port = "DirectLink"
            self._suggested_output_port = "DirectLink"
            self._waiting_for_first_response = True
            self._has_sliders = True
            self._current_midi_map = None
            self._display_reset_delay = -1
            self._shift_pressed = False
            self._shift_button = ButtonElement(IS_MOMENTARY, MIDI_CC_TYPE, 15, 13)
            self._master_slider = SliderElement(MIDI_CC_TYPE, 15, 41)
            self._next_nav_button = ButtonElement(IS_MOMENTARY, MIDI_CC_TYPE, 15, 111)
            self._prev_nav_button = ButtonElement(IS_MOMENTARY, MIDI_CC_TYPE, 15, 110)
            self._device_bank_buttons = None
            self._device_navigation = None
            self._shift_button.name = "Shift_Button"
            self._master_slider.name = "Master_Volume_Control"
            self._next_nav_button.name = "Next_Track_Button"
            self._prev_nav_button.name = "Prev_Track_Button"
            self._master_slider.add_value_listener(self._slider_value, identify_sender=True)
            self._shift_button.add_value_listener(self._shift_value)
            self._setup_mixer()
            self._setup_transport_and_session()
            self._setup_device()
            self._setup_display()
            for component in self.components:
                component.set_enabled(False)

        return
    def disconnect(self):
        self._name_display_data_source.set_display_string('  ')
        for encoder in self._encoders:
            encoder.remove_value_listener(self._encoder_value)

        self._master_slider.remove_value_listener(self._slider_value)
        if self._has_sliders:
            for slider in tuple(self._sliders):
                slider.remove_value_listener(self._slider_value)

        for button in self._strip_buttons:
            button.remove_value_listener(self._mixer_button_value)

        self._preview_button.remove_value_listener(self._preview_value)
        ControlSurface.disconnect(self)
        self._encoders = None
        self._sliders = None
        self._strip_buttons = None
        self._master_slider = None
        self._current_midi_map = None
        self._shift_button = None
        self._name_display = None
        self._prev_bank_button = None
        self._next_bank_button = None
        self._encoder_modes = None
        self._transport_view_modes = None
        self._send_midi(SYSEX_START + (6, 0, 0, 0, 247))
Example #9
0
 def __init__(self, c_instance, macro_map_mode, volume_map_mode, device_controls, transport_controls, volume_controls, trackarm_controls, bank_controls, descriptions = None, mixer_options = None):
     ControlSurface.__init__(self, c_instance)
     self.set_suppress_rebuild_requests(True)
     global_channel = 0
     if descriptions:
         if list(descriptions.keys()).count('INPUTPORT') > 0:
             self._suggested_input_port = descriptions['INPUTPORT']
         
         if list(descriptions.keys()).count('OUTPUTPORT') > 0:
             self._suggested_output_port = descriptions['OUTPUTPORT']
         
         if list(descriptions.keys()).count('CHANNEL') > 0:
             global_channel = descriptions['CHANNEL']
             if global_channel not in range(16):
                 global_channel = 0
             
         
         if list(descriptions.keys()).count('PAD_TRANSLATION') > 0:
             self.set_pad_translations(descriptions['PAD_TRANSLATION'])
     #delete this print
     self.log_message("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!"+str(type(macro_map_mode)))
     self._init_mixer_component(volume_controls, trackarm_controls, mixer_options, global_channel, volume_map_mode)
     self._init_device_component(device_controls, bank_controls, global_channel, macro_map_mode)
     self._init_transport_component(transport_controls, global_channel, macro_map_mode) #that last arg is new and shold be deleted
     #this is a new method call
     self._init_clip_slot_component(volume_controls)#this should take some args)
     #this is too
     self._init_session_component(global_channel, 3, 1)
     self.set_suppress_rebuild_requests(False)
Example #10
0
	def disconnect(self):
		"""clean things up on disconnect"""
		if self._session._is_linked():
			self._session._unlink()
		self.log_message(time.strftime("%d.%m.%Y %H:%M:%S", time.localtime()) + "--------------= Code log closed =--------------") #Create entry in log file
		ControlSurface.disconnect(self)
		return None
Example #11
0
    def __init__(self,c_instance):
        ControlSurface.__init__(self, c_instance)
        AbletonPlus.__init__(self, options)
        
        #setup the navigation controls
        self.setup_nav()
        self._nav.add_offset_listener(self.offset_modify)

        #setup the switchable button matrix
        self._buttonmatrix = LaunchpadButtonMatrix(options['width'], options['height'], options['hold'], options['defaultgridmode'])

        #setup the mode selector, and put it into mode 0 (init mode)
        self._mode = LaunchpadModeSelectorComponent()        
        
        #setup and add the sessionmode to the mode selector
        self.init_session_mode()
                
        #setup and add the user1 mode to the mode selector
        self.init_user1_mode()
        
        #setup and add the user2 mode to the mode selector
        self.init_user2_mode()
       
        #setup and add the user2 mode to the mode selector
        self.init_mixer_mode()
        
        #user2_mode_button = LaunchpadButtonComponent(options['hold'], MIDI_CC_TYPE,0,0x6E)
        #user2_mode_button.set_on_off_values(60,28)
        
        self._mode.set_mode(options['defaultmode'])
        
        #enable abletonplus last, so that any information it needs to pass along has already been initialized!
        self._enable_abletonplus()
               
        return None
Example #12
0
    def disconnect(self):
        ControlSurface.disconnect(self)

        self._encoders = None
        self._transport_view_modes = None
        self._send_midi(LED_FLASHING_OFF)
        self._send_midi(LIVE_MODE_OFF)
    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)
        return
Example #14
0
	def __init__(self, c_instance):
		ControlSurface.__init__(self, c_instance)
		self.set_suppress_rebuild_requests(True)
		self._suppress_session_highlight = True
		self._suppress_send_midi = True
		self._suggested_input_port = ('Akai ' + self.__class__.__name__)
		self._suggested_output_port = ('Akai ' + self.__class__.__name__)
		self._monomod_version = 'b994'
		self._host_name = 'AumPC'
		self._color_type = 'Monochrome'
		self.log_message("--------------= " + str(self._host_name) + " " + str(self._monomod_version) + " log opened =--------------") 
		self.hosts = []
		self._timer = 0
		self._touched = 0
		self.flash_status = 0
		self._shift_button = None
		self._matrix = None
		self._session = None
		self._session_zoom = None
		self._mixer = None
		self._setup_monobridge()
		self._setup_session_control()
		self._setup_mixer_control()
		self._session.set_mixer(self._mixer)
		self._shift_button.name = 'Shift_Button'
		self._setup_custom_components()
		self._setup_monomod()
		for component in self.components:
			component.set_enabled(False)
		self.set_suppress_rebuild_requests(False)
		self._device_id = 0
		self._common_channel = 0
		self._dongle_challenge = (Live.Application.get_random_int(0, 2000000), Live.Application.get_random_int(2000001, 4000000))
Example #15
0
    def __init__(self, c_instance, control_factory = LaunchkeyControlFactory(), identity_response = SIZE_RESPONSE):
        ControlSurface.__init__(self, c_instance)
        self._control_factory = control_factory
        self._identity_response = identity_response
        with self.component_guard():
            self.set_pad_translations(PAD_TRANSLATIONS)
            self._device_selection_follows_track_selection = True
            self._suggested_input_port = 'Launchkey InControl'
            self._suggested_output_port = 'Launchkey InControl'
            self._has_sliders = True
            self._current_midi_map = None
            self._master_slider = make_slider(7, 'Master_Volume_Control')
            self._modes_buttons = []
            for index in range(3):
                button = ButtonElement(IS_MOMENTARY, MIDI_NOTE_TYPE, 0, 13 + index)
                self._modes_buttons.append(button)
                self._modes_buttons[-1].add_value_listener(self._dummy_listener)

            self._setup_mixer()
            self._setup_session()
            self._setup_transport()
            self._setup_device()
            self._setup_navigation()
            for component in self.components:
                component.set_enabled(False)

        return
 def __init__(self, c_instance):
     ControlSurface.__init__(self, c_instance)
     with self.component_guard():
         self._suggested_input_port = 'HyperControl'
         self._suggested_output_port = 'HyperControl'
         self._device_selection_follows_track_selection = True
         self.set_pad_translations(PAD_TRANSLATIONS)
         stop_button = make_button(116)
         play_button = make_button(117)
         record_button = make_button(118)
         select_button = make_button(98)
         nav_left_button = make_button(99)
         nav_right_button = make_button(100)
         nav_up_button = make_button(101)
         nav_down_button = make_button(102)
         mixer_modes_toggle = make_button(58)
         mixer_or_device_toggle = make_button(59)
         hypercontrol_mode_toggle = make_button(60)
         encoders = tuple([ make_encoder(33 + index) for index in range(8) ])
         transport = TransportComponent()
         transport.set_stop_button(stop_button)
         transport.set_play_button(play_button)
         transport.set_record_button(record_button)
         session = SessionComponent(8, 0)
         device = BestBankDeviceComponent()
         self.set_device_component(device)
         device_nav = DeviceNavComponent()
         mixer = SpecialMixerComponent(NUM_TRACKS)
         session.set_mixer(mixer)
         mixer_encoder_modes = EncoderMixerModeSelector(mixer)
         mixer_encoder_modes.set_mode_toggle(mixer_modes_toggle)
         mixer_or_device = MixerOrDeviceModeSelector(encoders, select_button, nav_up_button, nav_down_button, nav_left_button, nav_right_button, mixer, session, device, mixer_encoder_modes, device_nav)
         mixer_or_device.set_mode_buttons((mixer_modes_toggle, mixer_or_device_toggle, hypercontrol_mode_toggle))
 def __init__(
     self,
     c_instance,
     macro_map_mode,
     volume_map_mode,
     device_controls,
     transport_controls,
     volume_controls,
     trackarm_controls,
     bank_controls,
     descriptions=None,
     mixer_options=None,
 ):
     ControlSurface.__init__(self, c_instance)
     with self.component_guard():
         global_channel = 0
         if descriptions:
             if list(descriptions.keys()).count("INPUTPORT") > 0:
                 self._suggested_input_port = descriptions["INPUTPORT"]
             if list(descriptions.keys()).count("OUTPUTPORT") > 0:
                 self._suggested_output_port = descriptions["OUTPUTPORT"]
             if list(descriptions.keys()).count("CHANNEL") > 0:
                 global_channel = descriptions["CHANNEL"]
                 if global_channel not in range(16):
                     global_channel = 0
             if list(descriptions.keys()).count("PAD_TRANSLATION") > 0:
                 self.set_pad_translations(descriptions["PAD_TRANSLATION"])
         self._init_mixer_component(
             volume_controls, trackarm_controls, mixer_options, global_channel, volume_map_mode
         )
         self._init_device_component(device_controls, bank_controls, global_channel, macro_map_mode)
         self._init_transport_component(transport_controls, global_channel)
Example #18
0
 def __init__(self,c_instance):
     ControlSurface.__init__(self, c_instance)
     AbletonPlus.__init__(self, options)
     
     self._main_encoders = []
     self._main_buttons = []
     self._effects_encoders = []
     self._extra_buttons = []
     self._mixer = None
            
     for index in range(0, 24):
         encoder = EncoderElement(MIDI_CC_TYPE,0,92 + index,Live.MidiMap.MapMode.absolute)
         self._main_encoders.append(encoder)
     
     for index in range(0,16):
         button = ButtonElement(False, MIDI_CC_TYPE,0, 76 + index)
         self._main_buttons.append(button)
         
     self._mixer = MixerComponent(8)
     
     self._remap_track_mixer_controls()
     
     self._enable_abletonplus()
     
     return None
Example #19
0
 def __init__(self, c_instance):
     ControlSurface.__init__(self, c_instance)
     self.set_suppress_rebuild_requests(True) 
     self._folder_location = '/ClyphX/'
     self._macrobat = Macrobat(self)
     self._extra_prefs = ExtraPrefs(self)
     self._track_actions = ClyphXTrackActions(self)
     self._snap_actions = ClyphXSnapActions(self)
     self._global_actions = ClyphXGlobalActions(self)
     self._device_actions = ClyphXDeviceActions(self)
     self._clip_actions = ClyphXClipActions(self)
     self._control_surface_actions = ClyphXControlSurfaceActions(self)
     self._control_component = ClyphXControlComponent(self)
     ClyphXCueComponent(self)
     self._startup_actions_complete = False
     self._user_variables = {}
     self._play_seq_clips = {}
     self._loop_seq_clips = {}
     self._current_tracks = []
     live = Live.Application.get_application()
     self._can_have_nested_devices = False
     if live.get_major_version() == 8 and live.get_minor_version() >= 2 and live.get_bugfix_version() >= 2:
         self._can_have_nested_devices = True
     self.setup_tracks()
     self.log_message('nativeKONTROL LOG ------- nativeKONTROL ClyphX v2.0.3 for Live 8 ------- Live Version: ' + str(live.get_major_version()) + '.' + str(live.get_minor_version()) + '.' + str(live.get_bugfix_version()) + ' ------- END LOG')
     self.show_message('nativeKONTROL ClyphX v2.0.3 for Live 8')
     self.set_suppress_rebuild_requests(False) 
Example #20
0
	def disconnect(self):
		"""clean things up on disconnect"""
		if self._session._is_linked():
			self._session._unlink()
		self.log_message("--------------= Tweaker Mixer " + str(self._tweaker_version) + " log closed =--------------") #Create entry in log file
		ControlSurface.disconnect(self)
		return None
Example #21
0
    def __init__(self, c_instance):
        ControlSurface.__init__(self, c_instance)
        #self.log_message(time.strftime("%d.%m.%Y %H:%M:%S", time.localtime()) + "--------------= PocketDial log opened =--------------")
 
        # turn off rebuild MIDI map until after setup
        #self._set_suppress_rebuild_requests(True)
        with self.component_guard():
            self._controls = [EncoderElement(MIDI_CC_TYPE, settings.CHANNEL, cc, settings.MAP_MODE) for cc in settings.CCS]
 
            mixer = MixerControl(self)
            session = SessionControl(self)
            device = DeviceControl(self)
            track = TrackControl(self)
         
            # bind mixer to session
            session.component.set_mixer(mixer.component)
            self.set_highlighting_session_component(session.component)
         
            # "magic" internal self._device_component, which enables lock to device, etc.
            self.set_device_component(device.component)
         
            # register components (Live 8 only?)
            #self._register_component(session.component)
            #self._register_component(mixer.component)
            #self._register_component(device.component)
             
         
            self._device = device
            self._track = track
    def __init__(self, c_instance):
        ControlSurface.__init__(self, c_instance)

        with self.component_guard():
            self._setup_controls()
            self._setup_device()
            self._setup_sibling_devices()
 def __init__(self, c_instance):
     ControlSurface.__init__(self, c_instance)
     with self.component_guard():
         self._setup_controls()
         self._setup_mixer()
         self._setup_transport()
         self._setup_transport()
Example #24
0
 def __init__(self, c_instance):
     ControlSurface.__init__(self, c_instance)
     transport = TransportComponent()
     transport.set_play_button(ButtonElement(True, 0, ABLETON["GENERAL_CHANNEL"], ABLETON["START_NOTE"]))
     transport.set_stop_button(ButtonElement(True, 0, ABLETON["GENERAL_CHANNEL"], ABLETON["STOP_NOTE"]))
     self.log_message("MiniCommand surface")
     self.get_track_name(0)
Example #25
0
 def __init__(self, c_instance):
     """everything except the '_on_selected_track_changed' override and 'disconnect' runs from here"""
     ControlSurface.__init__(self, c_instance)
     self.log_message("--------------= Lemaur256 log opened =--------------")
     self._suggested_input_port = "None"
     self._suggested_output_port = "None"
     self.set_suppress_rebuild_requests(True)
     self._monomod_version = "b995"
     self._host_name = "AumPad"
     self._color_type = "AumPad"
     self.connected = 0
     self.hosts = []
     self._osc_registry = {}
     self._bright = True
     self._rgb = 0
     self._timer = 0
     self.flash_status = 1
     self._setup_monobridge()
     self._setup_controls()
     self._setup_monomod()
     self._setup_touchosc()
     self._host2._set_shift_button(self._bank_button[0])
     self._host2._set_alt_button(self._bank_button[1])
     self._host2._set_button_matrix(self._monomod256)
     self._host2._set_key_buttons(self._key_button)
     self._host2.set_enabled(True)
     self.set_suppress_rebuild_requests(False)
     self.reset()
     self.refresh_state()
     self.show_message("Aum256 Control Surface Loaded")
 def disconnect(self):
     self._shift_mode = None
     self._right_shift = None
     self._encoder_modes = None
     self._pot_modes = None
     self._master_mode = None
     self._button_modes = None
     self._mute_mode = None
     self._transport_mode = None
     self._scene_up_button = None
     self._scene_down_button = None    
     self._clip_launch_buttons = None
     self._shift_button = None
     self._session = None
     self._mixer = None   
     self._transport = None
     self._device = None
     self._display = None
     self._master_mode = False
     self.song().master_track.remove_output_meter_level_listener(self._on_master_peak_level_changed)
     ControlSurface.disconnect(self)
     self._send_midi(ALL_LEDS_OFF_MESSAGE)
     #self._send_midi(CLEAR_LEFT_DISPLAY)
     #self._send_midi(CLEAR_RIGHT_DISPLAY)
     self._send_midi(GOOD_BYE_SYSEX_MESSAGE) 
     self.log('disconnected')
     return None
Example #27
0
    def __init__(self, c_instance):
        ControlSurface.__init__(self, c_instance)
        #self.log_message(time.strftime("%d.%m.%Y %H:%M:%S", time.localtime()) + "--------------= PocketDial log opened =--------------")

        # turn off rebuild MIDI map until after setup
        # self.set_suppress_rebuild_requests(True)

        with self.component_guard():
            session = SessionControl(self)
            mixer = MixerControl(self)
            device = DeviceControl(self)
            track = TrackControl(self)
            GlobalControl(self) # play/pause, undo/redo

            # bind mixer to session
            session.component.set_mixer(mixer.component)

            # "magic" internal self._device_component, which enables lock to device, etc.
            self.set_device_component(device.component)

            # register components
            #self._register_component(session.component)
            #self._register_component(mixer.component)
            #self._register_component(device.component)

            self.set_highlighting_session_component(session.component)
            for component in self.components:
                component.set_enabled(True)


            self._device = device
            self._track = track
Example #28
0
	def __init__(self, c_instance):
		ControlSurface.__init__(self, c_instance)
		self._monomod_version = 'b994'
		self.hosts = []
		self._host_name = 'BlockPad'
		self._color_type = 'Monochrome'
		self._timer = 0
		is_momentary = True
		self._suggested_input_port = 'block (Controls)'
		self._suggested_output_port = 'block (Controls)'
		self._wrote_user_byte = False
		matrix = ButtonMatrixElement()
		for row in range(8):
			button_row = [ FlashingButtonElement(is_momentary, MIDI_NOTE_TYPE, 0, ((column * 8) + row), 'Button_'+str(column)+'_'+str(row), self) for column in range(8) ]
			matrix.add_row(tuple(button_row))
		knobs = [ EncoderElement(MIDI_CC_TYPE, 0, KNOB_CC[index], Live.MidiMap.MapMode.absolute) for index in range(8) ]
		sliders = [ EncoderElement(MIDI_CC_TYPE, 0, SLIDER_CC[index], Live.MidiMap.MapMode.absolute) for index in range(2) ]
		self._config_button = ButtonElement(is_momentary, MIDI_CC_TYPE, 0, 0)
		self._config_button.add_value_listener(self._config_value)
		top_buttons = [ FlashingButtonElement(is_momentary, MIDI_NOTE_TYPE, 0, TOP_NOTES[index], 'Top_Button'+str(index), self) for index in range(8) ]
		side_buttons = [ FlashingButtonElement(is_momentary, MIDI_NOTE_TYPE, 0, SIDE_NOTES[index], 'Side_Button'+str(index), self) for index in range(8) ]
		self._setup_monobridge()
		self._setup_monomod()
		self._selector = MainSelectorComponent(matrix, tuple(top_buttons), tuple(side_buttons), self._config_button, tuple(knobs), tuple(sliders), self)
		self._user_byte_write_button = ButtonElement(is_momentary, MIDI_CC_TYPE, 0, 16)
		self._user_byte_value(1)
		self._user_byte_write_button.add_value_listener(self._user_byte_value)
		self.set_enabled(True)
		self.log_message("--------------= BlockPad log opened =--------------") #Create entry in log file
		self.refresh_state()
Example #29
0
    def __init__(self, c_instance):
        ControlSurface.__init__(self, c_instance)
        with self.component_guard():
            self.cInstance = c_instance
            self._suppress_send_midi = True
            self.endpoint = None

            Log.set_logger(self.log_message)
            Log.set_log_level(Log.LOG_WARN)
            Log.set_log_network(True)
            Log.write("-----------------------")
            Log.write("ShowtimeBridge starting")
            Log.write("Python version " + sys.version)
            Log.info(sys.version)

            # Network endpoint
            self.endpoint = LiveNetworkEndpoint()
            self.endpoint.set_song_root_accessor(LiveUtils.getSong)
            LiveWrapper.set_endpoint(self.endpoint)

            # Midi clock to trigger incoming message check
            self.clock = LoopingEncoderElement(0, 119)

            self.refresh_state()
            self._suppress_send_midi = False
 def __init__(self, c_instance):
     ControlSurface.__init__(self, c_instance)
     with self.component_guard():
         self.set_pad_translations(PAD_TRANSLATIONS)
         self._device_selection_follows_track_selection = True
         self._suggested_input_port = 'Impulse'
         self._suggested_output_port = 'Impulse'
         self._has_sliders = True
         self._current_midi_map = None
         self._display_reset_delay = -1
         self._shift_button = ButtonElement(IS_MOMENTARY, MIDI_CC_TYPE, 0, 39)
         self._preview_button = ButtonElement(IS_MOMENTARY, MIDI_CC_TYPE, 0, 41)
         self._master_slider = SliderElement(MIDI_CC_TYPE, 0, 8)
         self._shift_button.name = 'Shift_Button'
         self._master_slider.name = 'Master_Volume_Control'
         self._master_slider.add_value_listener(self._slider_value, identify_sender=True)
         self._preview_button.add_value_listener(self._preview_value)
         self._setup_mixer()
         self._setup_session()
         self._setup_transport()
         self._setup_device()
         self._setup_name_display()
         device_button = ButtonElement(not IS_MOMENTARY, MIDI_CC_TYPE, 1, 10)
         mixer_button = ButtonElement(not IS_MOMENTARY, MIDI_CC_TYPE, 1, 9)
         device_button.name = 'Encoder_Device_Mode'
         mixer_button.name = 'Encoder_Mixer_Mode'
         self._encoder_modes = EncoderModeSelector(self._device_component, self._mixer, self._next_bank_button, self._prev_bank_button, self._encoders)
         self._encoder_modes.set_device_mixer_buttons(device_button, mixer_button)
         self._string_to_display = None
         for component in self.components:
             component.set_enabled(False)
 def update_display(self):
     ControlSurface.update_display(self)
     if self._display_reset_delay >= 0:
         self._display_reset_delay -= 1
         if self._display_reset_delay == -1:
             self._set_displays_to_default()
Example #32
0
 def refresh_state(self):
     ControlSurface.refresh_state(self)
     self._update_hardware()
Example #33
0
 def disconnect(self):
     """clean things up on disconnect"""
     ControlSurface.disconnect(self)
     return None
Example #34
0
	def _set_session_highlight(self, track_offset, scene_offset, width, height, include_return_tracks):
		if not self._suppress_session_highlight:
			ControlSurface._set_session_highlight(self, track_offset, scene_offset, width, height, include_return_tracks)
Example #35
0
	def _send_midi(self, midi_bytes, optimized=None):
		sent_successfully = False
		if not self._suppress_send_midi:
			sent_successfully = ControlSurface._send_midi(self, midi_bytes, optimized=optimized)
		return sent_successfully
 def restore_bank(self, bank_index):
     ControlSurface.restore_bank(self, bank_index)
     if self._alt_device_component != None:
         self._alt_device_component.restore_bank(bank_index)
     return
Example #37
0
 def refresh_state(self):
     ControlSurface.refresh_state(self)
     self.schedule_message(3, self._send_midi, SYSEX_START + (6, 1, 1, 1, 247))
Example #38
0
 def build_midi_map(self, midi_map_handle):
     self._current_midi_map = midi_map_handle
     ControlSurface.build_midi_map(self, midi_map_handle)
    def disconnect(self):
        self._scheduled_messages = []
        for encoder in self._encoders:
            encoder.remove_value_listener(self._encoder_value)

        for fader in self._faders:
            fader.remove_value_listener(self._fader_value)

        for fader_button in self._fader_buttons:
            fader_button.remove_value_listener(self._fader_button_value)

        self._master_fader.remove_value_listener(self._fader_value)
        self._master_fader_button.remove_value_listener(self._fader_button_value)
        self._select_button.remove_value_listener(self._select_button_value)
        self._identify_button.remove_value_listener(self._identify_value)
        self._fader_group_midi_button.remove_value_listener(self._midi_button_value)
        self._fader_group_mix_button.remove_value_listener(self._hyper_button_value)
        self._fader_group_fx_button.remove_value_listener(self._hyper_button_value)
        self._encoder_group_midi_button.remove_value_listener(self._midi_button_value)
        self._encoder_group_mix_button.remove_value_listener(self._hyper_button_value)
        self._encoder_group_fx_button.remove_value_listener(self._hyper_button_value)
        if self._drum_group_midi_button != None:
            self._drum_group_midi_button.remove_value_listener(self._midi_button_value)
        if self._drum_group_hyper_button != None:
            self._drum_group_hyper_button.remove_value_listener(self._hyper_button_value)
        self._alt_device_component = None
        self._name_display = None
        self._value_display = None
        self._bank_display = None
        self._pad_display = None
        self._name_display_data_source = None
        self._value_display_data_source = None
        self._bank_display_data_source = None
        self._pad_display_data_source = None
        self._select_button = None
        self._left_button = None
        self._right_button = None
        self._up_button = None
        self._down_button = None
        self._loop_button = None
        self._ffwd_button = None
        self._rwd_button = None
        self._play_button = None
        self._stop_button = None
        self._rec_button = None
        self._master_fader_button = None
        self._fader_buttons = None
        self._faders = None
        self._encoders = None
        self._drum_pads = None
        self._identify_button = None
        self._main_group_hyper_button = None
        self._main_group_track_button = None
        self._main_group_fx_button = None
        self._encoder_group_midi_button = None
        self._encoder_group_mix_button = None
        self._encoder_group_fx_button = None
        self._fader_group_mode_button = None
        self._fader_group_midi_button = None
        self._fader_group_mix_button = None
        self._fader_group_fx_button = None
        self._drum_group_midi_button = None
        self._drum_group_roll_button = None
        self._drum_group_hyper_button = None
        self._mixer_for_encoders = None
        self._mixer_for_faders = None
        self._device_for_encoders = None
        self._device_for_faders = None
        self._transport = None
        self._session = None
        ControlSurface.disconnect(self)
        self._send_midi(SYSEX_START + DISABLE_HYPERCONTROL)
        return
 def set_appointed_device(self, device):
     ControlSurface.set_appointed_device(self, device)
     with self.component_guard():
         if self._alt_device_component != None:
             self._alt_device_component.set_device(device)
     return
Example #41
0
 def receive_midi(self, midi_bytes):
     """ Receive user-specified messages and send to control script """
     ControlSurface.receive_midi(self, midi_bytes)
     self._control_component.receive_midi(midi_bytes)
 def _on_selected_track_changed(self):
     ControlSurface._on_selected_track_changed(self)
     self._display_reset_delay = 0
Example #43
0
    def __init__(self, c_instance):

        ControlSurface.__init__(self, c_instance)
        with self.component_guard():
            self._support_mkII = False
            self._lock_enquiry_delay = 0
            self._suppress_session_highlight = True

            self._shift_button = None
            self._shift_mode = None
            self._right_shift = None
            self._encoder_modes = None
            self._pot_modes = None
            self._master_mode = None
            self._button_modes = None
            self._mute_mode = None
            self._transport_mode = None

            self._automap_has_control = False
            self.log(self._script_name + ' ' + self._script_ver)
            self.log('initialization')
            #self.set_suppress_rebuild_requests(True)
            self._device_selection_follows_track_selection = True
            self._scene_up_button = None
            self._scene_down_button = None
            self._scene_launch_button = None
            self._clip_launch_buttons = []
            self._ts_buttons = []

            self._encoders = None
            self._session = None
            self._mixer = None
            self._transport = None
            self._device = None
            self._device_control = None
            self._display = SLDisplay(self)
            self._display.set_block_messages(True)
            self._setup_session_control()
            self._setup_mixer_control()
            self._session.set_mixer(self._mixer)
            self._shift_button.name = 'Shift_Button'
            self._setup_custom_controls()

            self.song().master_track.add_output_meter_level_listener(
                self._on_master_peak_level_changed)

            self.set_pad_translations(PAD_TRANSLATION)
            #self.set_suppress_rebuild_requests(False)

            self._displays.append(self._display)

            #self._session._do_show_highlight()

            self._update_hardware_delay = -1

            self.set_highlighting_session_component(self._session)
            self._suppress_session_highlight = False

            #self._display.set_block_messages(False)

            self.show_message(self.__doc__ + "script loaded...")
            self.log('loaded')
        return None
 def refresh_state(self):
     ControlSurface.refresh_state(self)
     self.schedule_message(5, self._send_midi, IDENTITY_REQUEST)
    def __init__(self, c_instance):
        ControlSurface.__init__(self, c_instance)
        with self.component_guard():
            self.c_instance = c_instance

            self.retries_count = 0
            self.device_connected = False

            self.clip_color_callbacks = {}
            self.slot_callbacks = {}

            self.text_start_sequence = (0xf0, 0x0, 0x20, 0x76, 0x00, 0x03)
            self.text_end_sequence = (0xf7, )
            self.enable_sequence = (0xf0, 0x00, 0x20, 0x76, 0x00, 0x01, 0x02,
                                    0xf7)
            self.disable_sequence = (0xf0, 0x00, 0x20, 0x76, 0x00, 0x01, 0x00,
                                     0xf7)

            self.id_sequence = (0xf0, 0x7e, 0x7f, 0x06, 0x01, 0xf7)

            self.text_color_start_sequence = (0xf0, 0x0, 0x20, 0x76, 0x00,
                                              0x04)

            #			self.log('INITIALIZING')

            self.app = Live.Application.get_application()

            #maj = self.app.get_major_version()
            #min = self.app.get_minor_version()
            #bug = self.app.get_bugfix_version()

            #self.show_message(str(maj) + "." + str(min) + "." + str(bug))

            self.show_message("Version: " + VERSION)

            # reseting text
            self.write_text(' ')

            # reset display clips
            self.reset_display_clips()

            # getting browser visible state
            self.session_browser_visible = self.app.view.is_view_visible(
                "Browser")

            # getting browser visible state
            self.arrange_browser_visible = self.app.view.is_view_visible(
                "Browser")

            # getting session view visible state
            self.session_visible = self.app.view.is_view_visible("Session")

            # getting arrange view visible state
            self.arrange_visible = self.app.view.is_view_visible("Arranger")

            # getting detail view visible state
            self.detail_visible = self.app.view.is_view_visible("Detail")

            # getting back to arranger state
            self.back_to_arranger_state = self.song().back_to_arranger

            # initializing channel strip to null
            self._channel_strip = None

            # initializing mixer component
            self._mixer = MixerComponent(NUM_TRACKS, 2)

            # initializing session component
            self._session = SessionComponent(NUM_TRACKS, NUM_ROWS)
            self._session.add_offset_listener(self.session_offset_changed)
            self.set_highlighting_session_component(self._session)
            self._suppress_session_highlight = False

            # initializing transport component
            self._transport = TransportComponent()

            # configuring operation mode selector buttons
            self._operation_mode_buttons = ButtonElement(
                True, MIDI_CC_TYPE, CHANNEL, OP1_MODE_1_BUTTON), ButtonElement(
                    True, MIDI_CC_TYPE,
                    CHANNEL, OP1_MODE_2_BUTTON), ButtonElement(
                        True, MIDI_CC_TYPE, CHANNEL,
                        OP1_MODE_3_BUTTON), ButtonElement(
                            True, MIDI_CC_TYPE, CHANNEL, OP1_MODE_4_BUTTON),

            # initializing operation mode selector
            self._operation_mode_selector = OP1ModeSelectorComponent(
                self, self._transport, self._mixer, self._session)

            # setting operation mode selector buttons
            self._operation_mode_selector.set_mode_buttons(
                self._operation_mode_buttons)

            # adding value listener for operation mode index
            self._operation_mode_selector.add_mode_index_listener(
                self.mode_index_changed)

            # setting global transport assignments
            self._transport.set_record_button(
                ButtonElement(True, MIDI_CC_TYPE, CHANNEL, OP1_REC_BUTTON))
            self._transport.set_stop_button(
                ButtonElement(True, MIDI_CC_TYPE, CHANNEL, OP1_STOP_BUTTON))
            self._transport.set_metronome_button(
                ButtonElement(True, MIDI_CC_TYPE, CHANNEL,
                              OP1_METRONOME_BUTTON))
            self._transport.set_tap_tempo_button(
                ButtonElement(True, MIDI_CC_TYPE, CHANNEL, OP1_HELP_BUTTON))
            #			self._transport.set_punch_buttons(ButtonElement(True, MIDI_CC_TYPE, CHANNEL, OP1_SS1_BUTTON), ButtonElement(True,MIDI_CC_TYPE, CHANNEL, OP1_SS2_BUTTON))
            self._transport.set_loop_button(
                ButtonElement(True, MIDI_CC_TYPE, CHANNEL, OP1_SS3_BUTTON))
            self._transport.set_overdub_button(
                ButtonElement(True, MIDI_CC_TYPE, CHANNEL, OP1_SS4_BUTTON))

            self._play_button = ButtonElement(True, MIDI_CC_TYPE, CHANNEL,
                                              OP1_PLAY_BUTTON)
            #                        self._transport.set_play_button(self._play_button)
            self.shift_pressed = False
            self._play_button.add_value_listener(self.play_button_callback)

            # setting global session assignments
            self._session.set_scene_bank_buttons(
                ButtonElement(True, MIDI_CC_TYPE, CHANNEL, OP1_COM),
                ButtonElement(True, MIDI_CC_TYPE, CHANNEL, OP1_MICRO))

            # encoder for transport control - leave it empty for now
            self._encoder_1 = EncoderElement(
                MIDI_CC_TYPE, CHANNEL, OP1_ENCODER_1,
                Live.MidiMap.MapMode.relative_two_compliment)
            self._encoder_2 = EncoderElement(
                MIDI_CC_TYPE, CHANNEL, OP1_ENCODER_2,
                Live.MidiMap.MapMode.relative_two_compliment)
            self._encoder_3 = EncoderElement(
                MIDI_CC_TYPE, CHANNEL, OP1_ENCODER_3,
                Live.MidiMap.MapMode.relative_two_compliment)
            self._encoder_4 = EncoderElement(
                MIDI_CC_TYPE, CHANNEL, OP1_ENCODER_4,
                Live.MidiMap.MapMode.relative_two_compliment)
            # setting misc listeners

            self._encoder_1_push = ButtonElement(True, MIDI_CC_TYPE, CHANNEL,
                                                 OP1_ENCODER_1_PUSH)
            self._encoder_2_push = ButtonElement(True, MIDI_CC_TYPE, CHANNEL,
                                                 OP1_ENCODER_2_PUSH)
            self._encoder_3_push = ButtonElement(True, MIDI_CC_TYPE, CHANNEL,
                                                 OP1_ENCODER_3_PUSH)
            self._encoder_4_push = ButtonElement(True, MIDI_CC_TYPE, CHANNEL,
                                                 OP1_ENCODER_4_PUSH)

            self._encoder_3_push.add_value_listener(self.e3_push_callback)
            self._e3_pressed = False

            self.mainview_toggle_button = ButtonElement(
                False, MIDI_CC_TYPE, CHANNEL, OP1_ARROW_DOWN_BUTTON)
            self.mainview_toggle_button.add_value_listener(
                self.mainview_toggle_button_callback)

            self.detailview_toggle_button = ButtonElement(
                False, MIDI_CC_TYPE, CHANNEL, OP1_SCISSOR_BUTTON)
            self.detailview_toggle_button.add_value_listener(
                self.detailview_toggle_button_callback)

            self.clear_track_button = ButtonElement(True, MIDI_CC_TYPE,
                                                    CHANNEL, OP1_SS8_BUTTON)
            self.clear_track_button.add_value_listener(
                self.clear_track_button_callback)

            self.back_to_arranger_button = ButtonElement(
                True, MIDI_CC_TYPE, CHANNEL, OP1_SEQ_BUTTON)
            self.back_to_arranger_button.add_value_listener(
                self.back_to_arranger_button_callback)

            # adding value listener for selected track change
            self.song().view.add_selected_track_listener(
                self.selected_track_changed)

            # adding value listener for selected scene change
            self.song().view.add_selected_scene_listener(
                self.selected_scene_changed)

            # setting assignments for currently selected track
            self.selected_track_changed()

            # setting assignments for currently selected scene
            self.selected_scene_changed()
Example #46
0
 def _on_track_list_changed(self):
     ControlSurface._on_track_list_changed(self)
     self.setup_tracks()
 def disconnect(self):
     self._shift_button.remove_value_listener(self._shift_value)
     self._shift_button = None
     ControlSurface.disconnect(self)
     return
Example #48
0
	def refresh_state(self):
		ControlSurface.refresh_state(self)
		self.schedule_message(5, self._update_hardware)
Example #49
0
 def refresh_state(self):
     ControlSurface.refresh_state(self)
     self.schedule_message(5, self._init)
Example #50
0
	def disconnect(self):
		"""clean things up on disconnect"""
		self.song().view.remove_selected_track_listener(self._update_selected_device)
		self.log_message(time.strftime('%d.%m.%Y %H:%M:%S', time.localtime()) + '--------------= OhmModes log closed =--------------')
		ControlSurface.disconnect(self)
Example #51
0
	def _set_session_highlight(self, track_offset, scene_offset, width, height, include_return_tracks):
		if ((not self._suppress_session_highlight) or ((track_offset,
		 scene_offset,
		 width,
		 height) == (-1, -1, -1, -1))):
			ControlSurface._set_session_highlight(self, track_offset, scene_offset, width, height, include_return_tracks)
Example #52
0
	def _send_midi(self, midi_bytes):
		sent_successfully = False
		if not self._suppress_send_midi:
			sent_successfully = ControlSurface._send_midi(self, midi_bytes)
		return sent_successfully
Example #53
0
	def disconnect(self):
		"""clean things up on disconnect"""
		#self._disconnect_notifier.set_mode(0)
		self.log_message("--------------= Lemaur256 log closed =--------------") #Create entry in log file
		ControlSurface.disconnect(self)
		return None
Example #54
0
 def disconnect(self):
     #log(__name__, "disconnect")
     #self.buttonCols = None
     #self._unregister_timer_callback(self.process)
     ControlSurface.disconnect(self)
Example #55
0
 def update_display(self):
     ControlSurface.update_display(self)
     self._timer = (self._timer + 1) % 256
     self.flash()
Example #56
0
 def disconnect(self):
     ControlSurface.disconnect(self)
     self._serato_interface.PySCA_DeinitializeClipControl()
     self._serato_interface = None
Example #57
0
 def refresh_state(self):
     ControlSurface.refresh_state(self)
     self.schedule_message(2, self._send_midi, LIVE_MODE_ON)
     self.schedule_message(3, self._send_midi, SIZE_QUERY)
 def update_display(self):
     ControlSurface.update_display(self)
     if self._monolink_is_enabled:
         self._client[16].call_network_functions()
Example #59
0
 def __init__(self, c_instance):
     ControlSurface.__init__(self, c_instance)
     with self.component_guard():
         self._monomod_version = 'b995'
         self._host_name = 'LaunchMod'
         self._color_type = 'Launchpad'
         self.hosts = []
         self._timer = 0
         self._suppress_send_midi = True
         self._suppress_session_highlight = True
         self._suppress_highlight = False
         is_momentary = True
         self._suggested_input_port = 'Launchpad'
         self._suggested_output_port = 'Launchpad'
         self._control_is_with_automap = False
         self._user_byte_write_button = ButtonElement(
             is_momentary, MIDI_CC_TYPE, 0, 16)
         self._user_byte_write_button.name = 'User_Byte_Button'
         self._user_byte_write_button.send_value(1)
         self._user_byte_write_button.add_value_listener(
             self._user_byte_value)
         self._wrote_user_byte = False
         self._challenge = Live.Application.get_random_int(
             0, 400000000) & 2139062143
         matrix = ButtonMatrixElement()
         matrix.name = 'Button_Matrix'
         for row in range(8):
             button_row = [
                 ConfigurableButtonElement(
                     is_momentary, MIDI_NOTE_TYPE, 0, ((row * 16) + column),
                     str(column) + '_Clip_' + str(row) + '_Button', self)
                 for column in range(8)
             ]
             matrix.add_row(tuple(button_row))
         self._config_button = ButtonElement(is_momentary,
                                             MIDI_CC_TYPE,
                                             0,
                                             0,
                                             optimized_send_midi=False)
         self._config_button.add_value_listener(self._config_value)
         top_button_names = [
             'Bank_Select_Up_Button', 'Bank_Select_Down_Button',
             'Bank_Select_Left_Button', 'Bank_Select_Right_Button',
             'Session_Button', 'User1_Button', 'User2_Button',
             'Mixer_Button'
         ]
         side_button_names = [
             'Vol_Button', 'Pan_Button', 'SndA_Button', 'SndB_Button',
             'Stop_Button', 'Trk_On_Button', 'Solo_Button', 'Arm_Button'
         ]
         top_buttons = [
             ConfigurableButtonElement(is_momentary, MIDI_CC_TYPE, 0,
                                       (104 + index),
                                       top_button_names[index], self)
             for index in range(8)
         ]
         side_buttons = [
             ConfigurableButtonElement(is_momentary, MIDI_NOTE_TYPE, 0,
                                       SIDE_NOTES[index],
                                       side_button_names[index], self)
             for index in range(8)
         ]
         self._setup_monobridge()
         self._setup_monomod()
         self._selector = MainSelectorComponent(matrix, tuple(top_buttons),
                                                tuple(side_buttons),
                                                self._config_button, self)
         self._selector.name = 'Main_Modes'
         for control in self.controls:
             if isinstance(control, MonoButtonElement):
                 control.add_value_listener(self._button_value)
         self.set_highlighting_session_component(
             self._selector.session_component())
         self._suppress_session_highlight = False
     self.log_message(
         "--------------= " + str(self._monomod_version) +
         " log opened =--------------")  #Create entry in log file
Example #60
0
 def disconnect(self):
   self.log_message("--------------= LividAlias8M4L log END =--------------")
   ControlSurface.disconnect(self)
   return None