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, 81 + 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
def __init__(self, c_instance):
ControlSurface.__init__(self, c_instance)
with self.component_guard():
self._note_map_scenes = []
self._note_map_buttons = []
self._ctrl_map_sliders = []
self._note_map_trk_stop_buttons = []
self._note_map_trk_sel_buttons = []
self._note_map_trk_mute_buttons = []
self._note_map_trk_solo_buttons = []
self._note_map_trk_rec_buttons = []
self._ctrl_map_trk_volume = []
self._ctrl_map_trk_pan = []
self._ctrl_map_senda = []
self._ctrl_map_sendb = []
self._ctrl_map_sendc = []
self._note_map_bank_buttons = []
self._ctrl_map_parameter = []
self._load_MIDI_map()
self._session = None
self._session_zoom = None
self._mixer = None
self._setup_session_control()
self._setup_mixer_control()
self._session.set_mixer(self._mixer)
self._setup_device_and_transport_control()
self.set_highlighting_session_component(self._session)
self._pads = []
self._load_pad_translations()
self._do_combine()
def __init__(self, *args, **kwargs):
ControlSurface.__init__(self, *args, **kwargs)
self.log_message('__init__()')
self.show_message("Version: " + VERSION)
# Data for tracking connection attempts
self.device_connected = False
self.next_retry_delay = 1
self.next_retry_ts = None
self.retries_count = 0
self._current_midi_map = None
# State of display text
self.text_top = ''
self.text_bottom = ''
# State of display key slots
self.display_color_by_slot_num = {}
for i in range(NUM_DISPLAY_CLIP_SLOTS):
self.display_color_by_slot_num[i] = COLOR_BLACK_BYTES
with self.component_guard():
self._build_components()
self.init_modes()
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
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)
return
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"
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))
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 __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)
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(
time.strftime("%d.%m.%Y %H:%M:%S", time.localtime()) +
"--------------= ProjectX log opened =--------------"
) # Writes message into Live's main log file. This is a ControlSurface method.
self.set_suppress_rebuild_requests(
True
) # Turn off rebuild MIDI map until after we're done setting up
self._setup_transport_control(
) # Run the transport setup part of the script
self._setup_mixer_control() # Setup the mixer object
self._setup_session_control() # Setup the session object
""" Here is some Live API stuff just for fun """
app = Live.Application.get_application() # get a handle to the App
maj = app.get_major_version() # get the major version from the App
min = app.get_minor_version() # get the minor version from the App
bug = app.get_bugfix_version() # get the bugfix version from the App
self.show_message(
str(maj) + "." + str(min) + "." + str(bug)
) #put them together and use the ControlSurface show_message method to output version info to console
self.set_suppress_rebuild_requests(
False) #Turn rebuild back on, now that we're done setting up
def __init__(self, c_instance):
ControlSurface.__init__(self, c_instance)
self.log_message("LOG: AAAMatrix __init__")
with self.component_guard():
self._set_suppress_features(True)
self._setup_session_control()
self._set_suppress_features(False)
def __init__(self, c_instance):
ControlSurface.__init__(self, c_instance)
#self._suppress_session_highlight = True
self._suppress_send_midi = True # Turn off rebuild MIDI map until after we're done setting up
Live.Base.log(time.strftime("%d.%m.%Y %H:%M:%S", time.localtime()) + "--------------= NanoKontrolLP95 log opened =--------------") # Writes message into Live's main log file. This is a ControlSurface method.
with self.component_guard():
# OBJECTS
self._session = None #session object
self._mixer = None #mixer object
self._transport = None #transport object
self._last_button_time = time.time()
self._io_list_index = 0
self._setup_controls()
self._setup_session_control() # Setup the session object
self._setup_mixer_control() # Setup the mixer object
self._session.set_mixer(self._mixer) # Bind mixer to session
self._setup_transport_control() # Setup transport object
self._set_mode_button()
self._set_normal_mode()
self._track = self.song().view.selected_track
self.set_highlighting_session_component(self._session)
self._flash_counter = 0
self._flash_on = True
for component in self.components:
component.set_enabled(True)
self._suppress_send_midi = True # Turn rebuild back on, once we're done setting up
Live.Base.log("NanoKontrolLP95 Loaded !")
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, 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'])
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)
self.set_suppress_rebuild_requests(False)
def __init__(self, c_instance):
ControlSurface.__init__(self, c_instance)
with self.component_guard():
is_momentary = True
self._suggested_input_port = 'Oxygen'
self._suggested_output_port = 'Oxygen'
self._has_slider_section = True
self._device_selection_follows_track_selection = True
self._shift_button = ButtonElement(is_momentary, MIDI_CC_TYPE, GLOBAL_CHANNEL, 57)
self._shift_button.add_value_listener(self._shift_value)
self._mixer = SpecialMixerComponent(NUM_TRACKS)
self._mute_solo_buttons = []
self._track_up_button = ButtonElement(is_momentary, MIDI_CC_TYPE, GLOBAL_CHANNEL, 111)
self._track_down_button = ButtonElement(is_momentary, MIDI_CC_TYPE, GLOBAL_CHANNEL, 110)
self._master_slider = SliderElement(MIDI_CC_TYPE, GLOBAL_CHANNEL, 41)
for index in range(NUM_TRACKS):
self._mute_solo_buttons.append(ButtonElement(is_momentary, MIDI_CC_TYPE, GLOBAL_CHANNEL, 49 + index))
self._mixer.channel_strip(index).set_volume_control(SliderElement(MIDI_CC_TYPE, GLOBAL_CHANNEL, 33 + index))
self._shift_value(0)
self._mixer.master_strip().set_volume_control(self._master_slider)
self._mixer.selected_strip().set_volume_control(None)
device = DeviceComponent()
device.set_parameter_controls(tuple([ EncoderElement(MIDI_CC_TYPE, GLOBAL_CHANNEL, 17 + index, Live.MidiMap.MapMode.absolute) for index in range(8) ]))
self.set_device_component(device)
ffwd_button = ButtonElement(is_momentary, MIDI_CC_TYPE, GLOBAL_CHANNEL, 115)
rwd_button = ButtonElement(is_momentary, MIDI_CC_TYPE, GLOBAL_CHANNEL, 114)
loop_button = ButtonElement(is_momentary, MIDI_CC_TYPE, GLOBAL_CHANNEL, 113)
transport = TransportComponent()
transport.set_stop_button(ButtonElement(is_momentary, MIDI_CC_TYPE, GLOBAL_CHANNEL, 116))
transport.set_play_button(ButtonElement(is_momentary, MIDI_CC_TYPE, GLOBAL_CHANNEL, 117))
transport.set_record_button(ButtonElement(is_momentary, MIDI_CC_TYPE, GLOBAL_CHANNEL, 118))
session = SessionComponent(0, 0)
transport_view_modes = TransportViewModeSelector(transport, session, ffwd_button, rwd_button, loop_button)
def __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()
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 = 'b994'
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 __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 __init__(self, c_instance):
ControlSurface.__init__(self, c_instance)
with self.component_guard():
self.log_message("DeleteClip started")
self.show_message('DeleteClip started')
self.DeleteButton = ButtonElement(IS_MOMENTARY, MIDI_NOTE_TYPE, 8, 39)
self.DeleteButton.add_value_listener(self._delete_clip,identify_sender= False)
def __init__(self, c_instance):
ControlSurface.__init__(self, c_instance)
with self.component_guard():
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._shift_button = None
self._matrix = None
self._session = None
self._session_zoom = None
self._mixer = None
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.set_highlighting_session_component(self._session)
for component in self.components:
component.set_enabled(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))
def __init__(self, c_instance):
ControlSurface.__init__(self, c_instance)
self._suppress_session_highlight = True
self._suppress_send_midi = True # Turn off rebuild MIDI map until after we're done setting up
self.log("--------------= ControlMI log opened =--------------")
with self.component_guard():
# OBJECTS
self.session = None
self.mixer = None
self.view = None
self.device = None
self.transport = None
# INITIALIZE MIXER, SESSIONS
self._setup_session_control() # Setup the session object
self._setup_mixer_control() # Setup the mixer object
self.session.set_mixer(self.mixer) # Bind mixer to session
self._setup_device_control() # Setup the device object
self._setup_transport_control() # Setup transport object
self._set_initial_mode()
self.set_device_component(
self.device) # Bind device to control surface-
self.set_highlighting_session_component(self.session)
for component in self.components:
component.set_enabled(True)
self._suppress_session_highlight = True
self._suppress_send_midi = True # Turn rebuild back on, once we're done setting up
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._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.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 __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)
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
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
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)
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)
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)
def __init__(self, c_instance):
ControlSurface.__init__(self, c_instance)
self._alt_device_component = None
with self.component_guard():
self.set_pad_translations(PAD_TRANSLATIONS)
self._device_selection_follows_track_selection = True
self._suggested_input_port = "HyperControl"
self._suggested_output_port = "HyperControl"
self._single_fader_button_modes = None
self._has_faders = True
self._display_reset_delay = -1
self._hc_byte = HC_BYTE
self._waiting_for_first_response = True
self._setup_controls()
self._setup_displays()
self._setup_mixer()
self._setup_session()
self._setup_transport()
self._setup_device()
self._setup_modes()
self._drum_group_midi_button = None
self._drum_group_hyper_button = None
for component in self.components:
component.set_enabled(False)
return
def __init__(self, c_instance):
ControlSurface.__init__(self, c_instance)
self._alt_device_component = None
with self.component_guard():
self.set_pad_translations(PAD_TRANSLATIONS)
self._device_selection_follows_track_selection = True
self._suggested_input_port = 'HyperControl'
self._suggested_output_port = 'HyperControl'
self._single_fader_button_modes = None
self._has_faders = True
self._display_reset_delay = -1
self._hc_byte = HC_BYTE
self._waiting_for_first_response = True
self._setup_controls()
self._setup_displays()
self._setup_mixer()
self._setup_session()
self._setup_transport()
self._setup_device()
self._setup_modes()
self._drum_group_midi_button = None
self._drum_group_hyper_button = None
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._setup_controls()
self._setup_mixer()
self._setup_transport()
self._setup_transport()
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)
#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
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()
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)
def __init__(self, c_instance):
ControlSurface.__init__(self, c_instance)
with self.component_guard():
self._suggested_input_port = u'HyperControl'
self._suggested_output_port = u'HyperControl'
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(device_selection_follows_track_selection=True)
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):
ControlSurface.__init__(self, c_instance)
live = Live.Application.get_application()
self._live_major_version = live.get_major_version()
self._live_minor_version = live.get_minor_version()
self._live_bugfix_version = live.get_bugfix_version()
self._selector = None #needed because update hardware is called.
self._lpx = False
self._mk2_rgb = False
self._mk3_rgb = False
with self.component_guard():
self._suppress_send_midi = True
self._suppress_session_highlight = True
self._suggested_input_port = ("Launchpad", "Launchpad Mini",
"Launchpad S", "Launchpad MK2",
"Launchpad X", "Launchpad Mini MK3")
self._suggested_output_port = ("Launchpad", "Launchpad Mini",
"Launchpad S", "Launchpad MK2",
"Launchpad X", "Launchpad Mini MK3")
self._control_is_with_automap = False
self._user_byte_write_button = None
self._config_button = None
self._wrote_user_byte = False
self._challenge = Live.Application.get_random_int(
0, 400000000) & 2139062143
self._init_done = False
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)
def __init__(self, c_instance):
ControlSurface.__init__(self, c_instance)
with self.component_guard():
self._suppress_send_midi = True
self._suppress_session_highlight = True
#non-throw-away variables ???
#self._suggested_input_port = 'LiveStrip' #???
#self._suggested_output_port = 'LiveStrip' #???
#self._control_is_with_automap = False #for buttons ??? mabye for user-defined mappings
self._transport = None #setup a blank transport
self._session = None #setup a blank session
self._device = None #setup a blank device
#self._is_locked = False #for device or track
self.setup_button_control() #buttons first - important
#self.setup_rotary_control() #then rotary encoders - important
self.setup_transport_control() #then transport..
self.setup_session_control() #..then the rest
self.setup_device_control()
self.assign_button_control(
) #after everything is set up we can then assign the buttons to things. ref this for updating aswell ???
self._end_buttons[0].add_value_listener(self._bt0_value)
self._end_buttons[1].add_value_listener(self._bt1_value)
self._end_buttons[2].add_value_listener(self._bt2_value)
self._end_buttons[3].add_value_listener(self._bt3_value)
self.set_highlighting_session_component(self._session)
self._suppress_session_highlight = False
self.log_message("LiveStrip loaded")
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._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):
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.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 __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)
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 __init__(self, c_instance):
ControlSurface.__init__(self, c_instance)
LC2Sysex.set_log(self.log_message)
if LC2Sysex.l9():
with self.component_guard():
self.do_setup()
else:
self.do_setup()
def __init__(self, c_instance):
ControlSurface.__init__(self, c_instance)
with self.component_guard():
self.log_message(time.strftime("%d.%m.%Y %H:%M:%S", time.localtime()) + "--------------= Block opened =--------------") # Writes message into Live's main log file. This is a ControlSurface method.
self._send_midi(switchxfader)
self._setup_transport_control()
self._setup_mixer_control() # Setup the mixer object
self._setup_session_control() # Setup the session object
def __init__(self, c_instance):
ControlSurface.__init__(self, c_instance)
with self.component_guard():
self._setup_session_control()
self._setup_mixer_control()
self._setup_device_control()
self._setup_transport_control()
self._setup_view_control()
def __init__(self, c_instance):
ControlSurface.__init__(self, c_instance)
with self.component_guard():
self._suppress_send_midi = True
self._suppress_session_highlight = True
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 = []
for column in range(8):
button = ConfigurableButtonElement(is_momentary, MIDI_NOTE_TYPE, 0, row * 16 + column)
button.name = str(column) + '_Clip_' + str(row) + '_Button'
button_row.append(button)
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_buttons = [ ConfigurableButtonElement(is_momentary, MIDI_CC_TYPE, 0, 104 + index) for index in range(8) ]
side_buttons = [ ConfigurableButtonElement(is_momentary, MIDI_NOTE_TYPE, 0, SIDE_NOTES[index]) for index in range(8) ]
top_buttons[0].name = 'Bank_Select_Up_Button'
top_buttons[1].name = 'Bank_Select_Down_Button'
top_buttons[2].name = 'Bank_Select_Left_Button'
top_buttons[3].name = 'Bank_Select_Right_Button'
top_buttons[4].name = 'Session_Button'
top_buttons[5].name = 'User1_Button'
top_buttons[6].name = 'User2_Button'
top_buttons[7].name = 'Mixer_Button'
side_buttons[0].name = 'Vol_Button'
side_buttons[1].name = 'Pan_Button'
side_buttons[2].name = 'SndA_Button'
side_buttons[3].name = 'SndB_Button'
side_buttons[4].name = 'Stop_Button'
side_buttons[5].name = 'Trk_On_Button'
side_buttons[6].name = 'Solo_Button'
side_buttons[7].name = 'Arm_Button'
self._selector = MainSelectorComponent(matrix, tuple(top_buttons), tuple(side_buttons), self._config_button, self)
self._selector.name = 'Main_Modes'
self._do_combine()
for control in self.controls:
if isinstance(control, ConfigurableButtonElement):
control.add_value_listener(self._button_value)
self.set_highlighting_session_component(self._selector.session_component())
self._suppress_session_highlight = False
#self.set_suppress_rebuild_requests(False)
self.log_message("LaunchPad95 Loaded !")
def __init__(self, *a, **k):
ControlSurface.__init__(self, *a, **k)
with self.component_guard():
self._monomod_version = 'b996'
self._host_name = 'LaunchMod'
self._color_type = 'Launchpad'
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._side_buttons = ButtonMatrixElement()
self._side_buttons.add_row(side_buttons)
self._setup_monobridge()
self._setup_mod()
self._selector = MainSelectorComponent(self, matrix, tuple(top_buttons), tuple(side_buttons), self._config_button)
self._selector.name = 'Main_Modes'
for control in self.controls:
isinstance(control, MonoButtonElement) and 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 =--------------')
def __init__(self, c_instance):
ControlSurface.__init__(self, c_instance)
self.log_message("====================== MaschineAble Log opened ======================")
self.set_suppress_rebuild_requests(True)
self._suggested_input_port = 'Maschine Controller In'
self._suggested_output_port = 'Maschine Controller Out'
self.session = None
self._setup_session_control()
self.set_suppress_rebuild_requests(False)
def __init__(self, c_instance):
ControlSurface.__init__(self, c_instance)
self.set_suppress_rebuild_requests(True)
self._setup_session_control()
self._setup_mixer_control()
self._setup_device_control()
self._setup_transport_control()
self._setup_view_control()
self.set_suppress_rebuild_requests(False)
def __init__(self, c_instance):
ControlSurface.__init__(self, c_instance)
self._handle_track_change.subject = self.song().view
with self.component_guard():
self._setup_controls()
self._setup_device()
self._setup_strip()
self._setup_transport()
self._handle_track_change()
