class OhmModesHH(ControlSurface): __module__ = __name__ __doc__ = " OhmModes controller script, custom script for Herbie Hancock by amounra " 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()) + "--------------= OhmModesHH2 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.revision = 'HH' self.flash_status = 1 self._backlight = 127 self._backlight_type = 'static' self._ohm = 127 self._ohm_type = 'static' self._pad_translations = PAD_TRANSLATION self._rgb = 1 self._keys_octave = 5 self._keys_scale = 0 self._tempo_buttons = None self._scene_indexes = [[[0,0], [8, 0], [16, 0], [24, 0], [32, 0], [40, 0]], [[0,0], [8, 0], [16, 0], [24, 0], [32, 0], [40, 0]], [[0,0], [8, 0], [16, 0], [24, 0], [32, 0], [40, 0]], [[0,0], [8, 0], [16, 0], [24, 0], [32, 0], [40, 0]], [[0,0], [8, 0], [16, 0], [24, 0], [32, 0], [40, 0]]] self._scene_bank = 0 self._bank_is_on = False self._setup_monobridge() self._setup_controls() 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 self._setup_device_control() # Setup the device object self._setup_crossfader() self._setup_looper() #self._setup_scene_selector() #self._setup_modes() self._assign_page_constants() self.assign_page_0() self._setup_hilight_knobs() self._last_device = None self._timer = 0 #self.set_suppress_rebuild_requests(False) #Turn rebuild back on, now that we're done setting up self.song().view.add_selected_track_listener(self._update_selected_device) self._on_selected_scene_changed() self.show_message('OhmModes Control Surface Loaded') self._send_midi(tuple(switchxfader)) #self.schedule_message(10, self.query_ohm, None) #self.song().view.selected_scene = self.song().scenes[0] self._assign_session_colors() def query_ohm(self): #self.log_message('querying Ohm') self._send_midi(tuple(check_model)) def _setup_monobridge(self): self._monobridge = MonoBridgeElement(self) self._monobridge.name = 'MonoBridge' def update_display(self): ControlSurface.update_display(self) self._timer = (self._timer + 1) % 256 self.flash() def get_device_bank(self): return self._device._bank_index def _setup_controls(self): is_momentary = True self._fader = [None for index in range(8)] self._dial = [None for index in range(16)] self._button = [None for index in range(8)] self._menu = [None for index in range(6)] for index in range(8): self._fader[index] = EncoderElement(MIDI_CC_TYPE, CHANNEL, OHM_FADERS[index], Live.MidiMap.MapMode.absolute) self._fader[index].name = 'Fader_' + str(index), self for index in range(8): self._button[index] = MonoButtonElement(is_momentary, MIDI_NOTE_TYPE, CHANNEL, OHM_BUTTONS[index], 'Button_' + str(index), self) for index in range(16): self._dial[index] = EncoderElement(MIDI_CC_TYPE, CHANNEL, OHM_DIALS[index], Live.MidiMap.MapMode.absolute) self._dial[index].name = 'Dial_' + str(index) for index in range(6): self._menu[index] = MonoButtonElement(is_momentary, MIDI_NOTE_TYPE, CHANNEL, OHM_MENU[index], 'Menu_' + str(index), self) self._crossfader = EncoderElement(MIDI_CC_TYPE, CHANNEL, CROSSFADER, Live.MidiMap.MapMode.absolute) self._crossfader.name = "Crossfader" self._livid = MonoButtonElement(is_momentary, MIDI_NOTE_TYPE, CHANNEL, LIVID, 'Livid_Button', self) self._shift_l = MonoButtonElement(is_momentary, MIDI_NOTE_TYPE, CHANNEL, SHIFT_L, 'Page_Button_Left', self) self._shift_r = MonoButtonElement(is_momentary, MIDI_NOTE_TYPE, CHANNEL, SHIFT_R, 'Page_Button_Right', self) self._matrix = ButtonMatrixElement() self._matrix.name = 'Matrix' self._grid = [None for index in range(8)] for column in range(8): self._grid[column] = [None for index in range(8)] for row in range(8): self._grid[column][row] = MonoButtonElement(is_momentary, MIDI_NOTE_TYPE, CHANNEL, (column * 8) + row, 'Grid_' + str(column) + '_' + str(row), self) for row in range(6): button_row = [] for column in range(7): button_row.append(self._grid[column][row]) self._matrix.add_row(tuple(button_row)) def _setup_modes(self): self._shift_mode = ShiftModeComponent(self) self._shift_mode.name = 'Shift_Mode' #self._shift_mode.set_mode_toggle(self._shift_l, self._shift_r) #self._select_mode = ModeSelectorComponent(self) #self._select_mode.name = 'Select_Mode' #self._select_mode.set_mode_toggle(self._menu[5]) #self._select_mode.update = self.select_mode_update(self._select_mode) #self._menu[5].add_value_listener(self._select_mode) #self._scale_mode = ScaleModeComponent(self) #self._scale_mode.name = "Scale_Mode" #self._octave_mode = OctaveModeComponent(self) #self._octave_mode.name = "Octave_Mode" def select_mode_update(self, mode_selector): def update(): if mode_selector._mode_index>0: pass return update def _setup_looper(self): self._looper = [None for index in range(2)] for index in range(2): self._looper[index] = LooperListenerComponent(self, index + 1) self._looper[index].assign_buttons(self._button[index*4], self._button[(index*4)+1], self._button[(index*4)+2], self._button[(index*4)+3]) def _setup_transport_control(self): self._transport = TransportComponent() self._transport.name = 'Transport' def _setup_mixer_control(self): is_momentary = True self._num_tracks = (7) #A mixer is one-dimensional; global mixer mixer = SpecialMixerComponent(7, 0, True, False) mixer.name = 'Mixer' self._mixer = mixer mixer.set_track_offset(0) #Sets start point for mixer strip (offset from left) for index in range(7): mixer.channel_strip(index).set_volume_control(self._fader[index]) for index in range(7): mixer.channel_strip(index).name = 'Mixer_ChannelStrip_' + str(index) mixer.track_eq(index).name = 'Mixer_EQ_' + str(index) mixer.channel_strip(index)._invert_mute_feedback = True self.song().view.selected_track = mixer.channel_strip(0)._track #set the selected strip to the first track, so that we don't, for example, try to assign a button to arm the master track, which would cause an assertion error def _setup_session_control(self): is_momentary = True num_tracks = 7 num_scenes = 7 ###changed from 5 for HH global session session = SessionComponent(num_tracks, num_scenes) session.name = "Session" session.set_offsets(0, 0) self._session = session self._scene = [None for index in range(num_scenes)] for row in range(num_scenes): self._scene[row] = session.scene(row) self._scene[row].name = 'Scene_' + str(row) for column in range(num_tracks): clip_slot = self._scene[row].clip_slot(column) clip_slot.name = str(column) + '_Clip_Slot_' + str(row) session.set_mixer(mixer) self._session_zoom = SessionZoomingComponent(session) self._session_zoom.name = 'Session_Overview' #self._session_zoom.set_enabled(False) self.set_highlighting_session_component(self._session) def _assign_session_colors(self): num_tracks = 7 num_scenes = 7 self._session.set_stop_clip_value(STOP_CLIP_COLOR[self._rgb]) for row in range(num_scenes): for column in range(num_tracks): self._scene[row].clip_slot(column).set_triggered_to_play_value(CLIP_TRIGD_TO_PLAY_COLOR[self._rgb]) self._scene[row].clip_slot(column).set_triggered_to_record_value(CLIP_TRIGD_TO_RECORD_COLOR[self._rgb]) self._scene[row].clip_slot(column).set_stopped_value(CLIP_STOPPED_COLOR[self._rgb]) self._scene[row].clip_slot(column).set_started_value(CLIP_STARTED_COLOR[self._rgb]) self._scene[row].clip_slot(column).set_recording_value(CLIP_RECORDING_COLOR[self._rgb]) self._session_zoom.set_stopped_value(ZOOM_STOPPED_COLOR[self._rgb]) self._session_zoom.set_playing_value(ZOOM_PLAYING_COLOR[self._rgb]) self._session_zoom.set_selected_value(ZOOM_SELECTED_COLOR[self._rgb]) def _setup_device_control(self): self._device = DeviceComponent() self._device.name = 'Device_Component' self.set_device_component(self._device) self._device_navigator = DetailViewControllerComponent() self._device_navigator.name = 'Device_Navigator' self._device_selection_follows_track_selection = FOLLOW def device_follows_track(self, val): self._device_selection_follows_track_selection = (val == 1) return self def _setup_crossfader(self): self._mixer.set_crossfader_control(self._crossfader) def _setup_scene_selector(self): for index in range(5): self._menu[index].add_value_listener(self._select_new_scene, True) def set_bank(self, val): self._scene_bank = int(val) self._monobridge._send('bank', self._scene_bank) self._display_bank() def _select_mode(self, value): self.log_message('select mode update' + str(value)) self._bank_is_on = value!=0 if self._bank_is_on is True: self._display_bank() else: self._on_selected_scene_changed() def _select_new_scene(self, value, sender): if self._bank_is_on is False: if value > 0: new_scene = int(self._scene_indexes[self._scene_bank][self._menu.index(sender)][0]) new_track = int(self._scene_indexes[self._scene_bank][self._menu.index(sender)][1]) self.log_message('select new scene ' + str(new_scene) + ' and track ' + str(new_track)) all_scenes = self.song().scenes all_tracks = self.song().tracks if (new_scene < len(all_scenes)) and (new_track < len(all_tracks)): self.song().view.selected_scene = all_scenes[(new_scene)] self.song().view.selected_track = all_tracks[(new_track)] self._session.set_offsets(self._scene_indexes[self._scene_bank][self._menu.index(sender)][1], self._scene_indexes[self._scene_bank][self._menu.index(sender)][0]) else: if value > 0: self._scene_bank = int(self._menu.index(sender)) self._monobridge._send('bank', self._scene_bank) self._display_bank() def _display_bank(self): if(self._bank_is_on): for index in range(5): if index == self._scene_bank: self._menu[index].send_value(11) else: self._menu[index].send_value(0) def _on_selected_scene_changed(self): ControlSurface._on_selected_scene_changed(self) #self.log_message('scene offset: ' + str(self._session._scene_offset)) for index in range(6): if self._session._scene_offset == self._scene_indexes[self._scene_bank][index][0]: ## and self._session._scene_offset < self._scene_indexes[index + 1]: self._menu[index].turn_on() else: self._menu[index].turn_off() #if self._session._scene_offset >= self._scene_indexes[5]: # self._menu[5].turn_on #else: # self._menu[5].turn_off def _setup_hilight_knobs(self): self._dial[15].add_value_listener(self._knob_set_scene, True) self._dial[14].add_value_listener(self._knob_set_track, True) def _knob_set_scene(self, value, sender): all_scenes = self.song().scenes num_scenes = len(all_scenes) new_scene = float(value/127.0) * float(num_scenes - 1) self.song().view.selected_scene = all_scenes[int(new_scene)] self._session.set_offsets(self._session._track_offset, int(new_scene)) def _knob_set_track(self, value, sender): #self.log_message(str(value)) all_tracks = self.song().visible_tracks #self.song().tracks num_tracks = len(self.song().visible_tracks) new_track = float(value/127.0) * float(num_tracks - 1) #self.log_message(str(int(new_track))) #self.log_message(str(value) + str(float(value/127.0))) self.song().view.selected_track = all_tracks[int(new_track)] self._session.set_offsets(int(new_track), self._session._scene_offset) def disconnect(self): """clean things up on disconnect""" for index in range(5): if self._menu[index].value_has_listener(self._select_new_scene): self._menu[index].remove_value_listener(self._select_new_scene) if self._menu[5].value_has_listener(self._select_mode): self._menu[5].remove_value_listener(self._select_mode) if self._dial[15].value_has_listener(self._knob_set_scene): self._dial[15].remove_value_listener(self._knob_set_scene) if self._dial[15].value_has_listener(self._knob_set_scene): self._dial[15].remove_value_listener(self._knob_set_scene) self.song().view.remove_selected_track_listener(self._update_selected_device) ControlSurface.disconnect(self) self.log_message(time.strftime("%d.%m.%Y %H:%M:%S", time.localtime()) + "--------------= OhmModes log closed =--------------") #Create entry in log file return None def _get_num_tracks(self): return self.num_tracks def flash(self): #if(self.flash_status > 0): for index in range(6): if(self._menu[index]._flash_state>0): self._menu[index].flash(self._timer) for row in range(8): if(self._button[row]._flash_state > 0): self._button[row].flash(self._timer) for column in range(8): button = self._grid[column][row] if(button._flash_state > 0): button.flash(self._timer) def strobe(self): if(self._backlight_type != 'static'): if(self._backlight_type is 'pulse'): self._backlight = int(math.fabs(((self._timer * 16) % 64) -32) +32) if(self._backlight_type is 'up'): self._backlight = int(((self._timer * 8) % 64) + 16) if(self._backlight_type is 'down'): self._backlight = int(math.fabs(int(((self._timer * 8) % 64) - 64)) + 16) self._send_midi(tuple([176, 27, int(self._backlight)])) if(self._ohm_type != 'static'): if(self._ohm_type is 'pulse'): self._ohm = int(math.fabs(((self._timer * 16) % 64) -32) +32) if(self._ohm_type is 'up'): self._ohm = int(((self._timer * 8) % 64) + 16) if(self._ohm_type is 'down'): self._ohm = int(math.fabs(int(((self._timer * 8) % 64) - 64)) + 16) self._send_midi(tuple([176, 63, int(self._ohm)])) self._send_midi(tuple([176, 31, int(self._ohm)])) def deassign_matrix(self): #self._scale_mode.set_mode_buttons(None) #self._scale_mode.set_enabled(False) #self._octave_mode.set_mode_buttons(None) #self._octave_mode.set_enabled(False) #self._session_zoom.set_button_matrix(None) #if self._dial[15].has_value_listener(self._knob_set_scene): # self._dial[15].remove_value_listener(self._knob_set_scene) #if self._dial[14].has_value_listener(self._knob_set_track): # self._dial[14].remove_value_listener(self._knob_set_track) self._session_zoom.set_enabled(False) self._session_zoom.set_nav_buttons(None, None, None, None) self._session.set_track_bank_buttons(None, None) self._session.set_scene_bank_buttons(None, None) for column in range(7): self._mixer.channel_strip(column).set_crossfade_toggle(None) self._mixer.channel_strip(column).set_mute_button(None) self._mixer.channel_strip(column).set_solo_button(None) self._mixer.channel_strip(column).set_arm_button(None) self._mixer.channel_strip(column).set_send_controls(None) self._mixer.channel_strip(column).set_pan_control(None) self._mixer.track_eq(column).set_enabled(False) for row in range(7): self._scene[row].clip_slot(column).set_launch_button(None) for column in range(8): #self._button[column]._on_value = SELECT_COLOR[self._rgb] for row in range(8): self._grid[column][row].set_channel(0) self._grid[column][row].release_parameter() self._grid[column][row].use_default_message() self._grid[column][row].set_enabled(True) self._grid[column][row].send_value(0, True) self._grid[column][row]._on_value = 127 self._grid[column][row]._off_value = 0 #for index in range(8): # self._button[index].set_channel(0) # self._button[index].use_default_message() # self._button[index].set_enabled(True) # self._button[index].reset() #for index in range(6): # self._menu[index]._on_value = 127 # self._menu[index]._off_value = 0 # self._menu[index].reset() #for index in range(16): # self._dial[index].use_default_message() # self._dial[index].release_parameter() #self._dial[index].set_enabled(True) if(self._device._parameter_controls != None): for control in self._device._parameter_controls: control.release_parameter() self._device._parameter_controls = None self._device_navigator.set_enabled(False) self._mixer.update() self._matrix.reset() """HH Specific""" #self._mixer.master_strip().set_select_button(None) #for column in range(7): # self._mixer.channel_strip(column).set_select_button(None) self._session_zoom.set_zoom_button(None) self._transport.set_play_button(None) self._transport.set_stop_button(None) self._device_navigator.set_device_nav_buttons(None, None) #for index in range(2): # self._looper[index].find_looper() def _assign_page_constants(self): #self._session_zoom.set_zoom_button(self._button[7]) #commented out pn 070111 #self._session_zoom.set_zoom_button(self._grid[7][7]) #added pn 070111 #self._session_zoom.set_button_matrix(self._matrix) #self._session_zoom.set_enabled(True) #for column in range(7): #self._mixer.channel_strip(column).set_select_button(self._button[column]) # self._mixer.channel_strip(column).set_volume_control(self._fader[column]) #self._mixer.master_strip().set_volume_control(self._fader[7]) #for column in range(8): # self._button[column]._on_value = SELECT_COLOR[self._rgb] #self._mixer.master_strip().set_select_button(self._button[7]) #added pn 070111 #self._mixer.set_prehear_volume_control(self._dial[15]) #self._transport.set_play_button(self._menu[0]) #self._menu[0].send_value(PLAY_COLOR[self._rgb], True) #self._menu[0]._on_value = PLAY_COLOR[self._rgb] #self._transport.set_stop_button(self._menu[1]) #self._menu[1]._off_value = STOP_COLOR[self._rgb] #self._menu[1]._on_value = STOP_COLOR[self._rgb] #self._menu[1].send_value(STOP_COLOR[self._rgb], True) self._livid._on_value = TAP_COLOR[self._rgb] self._transport.set_tap_tempo_button(self._livid) #self._livid.send_value(TAP_COLOR, True) #self._device_navigator.set_device_nav_buttons(self._menu[3], self._menu[4]) for index in range(2): self._menu[index + 4]._on_value = SESSION_NAV[self._rgb] self._menu[index * 3]._on_value = SESSION_NAV[self._rgb] self._session.set_track_bank_buttons(self._menu[5], self._menu[4]) self._session.set_scene_bank_buttons(self._menu[3], self._menu[0]) def assign_page_0(self): self._backlight_type = 'static' #self._session_zoom.set_button_matrix(self._matrix) self._session_zoom.set_enabled(True) for column in range(7): #self._grid[column][5]._on_value = MUTE_COLOR[self._rgb] #self._mixer.channel_strip(column).set_mute_button(self._grid[column][5]) #self._grid[column][6]._on_value = SOLO_COLOR[self._rgb] #self._mixer.channel_strip(column).set_solo_button(self._grid[column][6]) #self._grid[column][7]._on_value = ARM_COLOR[self._rgb] #self._mixer.channel_strip(column).set_arm_button(self._grid[column][7]) #self._mixer.channel_strip(column).set_pan_control(self._dial[column + 8]) for row in range(7): self._scene[row].clip_slot(column).set_launch_button(self._grid[column][row]) #for column in range(4): # self._mixer.channel_strip(column).set_send_controls(tuple([self._dial[column], self._dial[column + 4]])) track_stop_buttons = [] for index in range(7): self._grid[7][index]._off_value = SCENE_LAUNCH_COLOR[self._rgb] self._scene[index].set_launch_button(self._grid[7][index]) self._grid[index][7]._on_value = TRACK_STOP[self._rgb] self._grid[index][7]._off_value = TRACK_STOP[self._rgb] track_stop_buttons.append(self._grid[index][7]) self._session.set_stop_track_clip_buttons(tuple(track_stop_buttons)) self._session.set_stop_all_clips_button(self._grid[7][7]) #for index in range(4): # self._menu[2 + index]._on_value = NAV_BUTTON_COLOR[self._rgb] #self._session.set_track_bank_buttons(self._menu[4], self._menu[3]) #self._session.set_scene_bank_buttons(self._menu[5], self._menu[2]) #for index in range(6): # self._menu[index]._on_value = HHMENU[index][1] # self._menu[index]._off_value = HHMENU[index][0] for index in range(8): self._button[index].set_channel(2) self._button[index].set_identifier(index) #self._button[index].reset() self._button[index].set_enabled(False) self.request_rebuild_midi_map() for index in range(7): self._grid[index][7].turn_on() for index in range(2): self._looper[index]._state_change() self._button[1 + (index * 4)].send_value(3) self._button[2 + (index * 4)].send_value(6) self._button[3 + (index * 4)].send_value(1) def assign_page_1(self): self._backlight_type = 'pulse' self._session_zoom.set_enabled(False) for column in range(4): for row in range(4): self._grid[column][row].set_channel(PAGE1_DRUM_CHANNEL) self._grid[column][row].set_identifier(PAGE1_DRUM_MAP[column][row]) self._grid[column][row].send_value(DRUM_COLOR[self._rgb], True) self._grid[column][row].set_enabled(False) self._grid[column + 4][row].set_channel(PAGE1_BASS_CHANNEL) self._grid[column + 4][row].set_identifier(PAGE1_BASS_MAP[column][row]) self._grid[column + 4][row].send_value(BASS_COLOR[self._rgb], True) self._grid[column + 4][row].set_enabled(False) scale_mode_buttons = [] for column in range(8): for row in range(3): self._grid[column][row + 4].set_enabled(False) self._grid[column][row + 4].set_channel(PAGE1_KEYS_CHANNEL) self._grid[column][row + 4].set_identifier(int(PAGE1_KEYS_MAP[column][row]) + int(PAGE1_MODES_MAP[self._scale_mode._mode_index][column]) + int(self._octave_mode._mode_index * 12)) self._grid[column][row + 4].send_value(KEYS_COLOR[self._rgb], True) for row in range(1): scale_mode_buttons.append(self._grid[column][7]) self._scale_mode.set_mode_buttons(tuple(scale_mode_buttons)) self._scale_mode.set_enabled(True) #self._octave_mode.set_mode_buttons(tuple([self._menu[5], self._menu[2]])) #self._octave_mode.set_enabled(True) for column in range(7): self._mixer.channel_strip(column).set_send_controls(tuple([self._dial[column + 8]])) #self._button[column].set_on_off_values(REC_ARM, 0) #self._mixer.channel_strip(column).set_arm_button(self._button[column]) self._device.set_enabled(True) device_param_controls = [] for index in range(8): device_param_controls.append(self._dial[index]) self._device.set_parameter_controls(tuple(device_param_controls)) #for index in range(4): # self._menu[2 + index]._on_value = (DEVICE_NAV_COLOR[self._rgb]) #self._device_navigator.set_enabled(True) """HH Specific from Constants""" #self._mixer.master_strip().set_select_button(self._button[7]) #for column in range(7): # self._button[column].set_on_off_values(REC_ARM, 0) #self._session_zoom.set_zoom_button(self._grid[7][7]) #self._transport.set_play_button(self._menu[0]) #self._menu[0].send_value(PLAY_COLOR[self._rgb], True) #self._menu[0]._on_value = PLAY_COLOR[self._rgb] #self._transport.set_stop_button(self._menu[1]) #self._menu[1]._off_value = STOP_COLOR[self._rgb] #self._menu[1]._on_value = STOP_COLOR[self._rgb] #self._menu[1].send_value(STOP_COLOR[self._rgb], True) #self._device_navigator.set_device_nav_buttons(self._menu[3], self._menu[4]) for index in range(8): self._button[index].set_channel(2) self._button[index].set_identifier(index) #self._button[index].reset() self._button[index].set_enabled(False) self.request_rebuild_midi_map() #for index in range(8): # self._grid[index][7].send(self. for index in range(2): self._looper[index]._state_change() self._button[1 + (index * 4)].send_value(3) self._button[2 + (index * 4)].send_value(6) self._button[3 + (index * 4)].send_value(1) def assign_page_2(self): self._backlight_type = 'up' #self._session_zoom.set_button_matrix(self._matrix) self._session_zoom.set_enabled(False) for column in range(7): self._grid[column][5]._on_value = MUTE_COLOR[self._rgb] self._mixer.channel_strip(column).set_mute_button(self._grid[column][5]) self._grid[column][6]._on_value = CROSSFADE_ASSIGN_COLOR[self._rgb] self._mixer.channel_strip(column).set_crossfade_toggle(self._grid[column][6]) self._grid[column][7].set_channel(2) self._grid[column][7].set_identifier(column) self._grid[column][7].reset() self._grid[column][7].set_enabled(False) self._grid[column][7].send_value(4, True) for row in range(5): self._scene[row].clip_slot(column).set_launch_button(self._grid[column][row]) for row in range(5): self._grid[7][row]._off_value = SCENE_LAUNCH_COLOR[self._rgb] self._scene[row].set_launch_button(self._grid[7][row]) for column in range(4): self._mixer.track_eq(column).set_gain_controls(tuple([self._dial[column + 8], self._dial[column + 4], self._dial[column]])) self._mixer.track_eq(column).set_enabled(True) for column in range(3): self._mixer.channel_strip(column+4).set_pan_control(self._dial[column + 12]) #for index in range(4): # self._menu[2 + index]._on_value = NAV_BUTTON_COLOR[self._rgb] #self._session.set_track_bank_buttons(self._menu[4], self._menu[3]) #self._session.set_scene_bank_buttons(self._menu[5], self._menu[2]) self._set_tempo_buttons([self._grid[7][5], self._grid[7][6]]) """HH Specific from Constants""" #self._mixer.master_strip().set_select_button(self._button[7]) #for column in range(7): # self._mixer.channel_strip(column).set_select_button(self._button[column]) #for index in range(8): # self._button[index].set_on_off_values(SELECT_COLOR[self._rgb], 0) self._session_zoom.set_zoom_button(self._grid[7][7]) #self._transport.set_play_button(self._menu[0]) #self._menu[0].send_value(PLAY_COLOR[self._rgb], True) #self._menu[0]._on_value = PLAY_COLOR[self._rgb] #self._transport.set_stop_button(self._menu[1]) #self._menu[1]._off_value = STOP_COLOR[self._rgb] #self._menu[1]._on_value = STOP_COLOR[self._rgb] #self._menu[1].send_value(STOP_COLOR[self._rgb], True) #self._device_navigator.set_device_nav_buttons(self._menu[3], self._menu[4]) for index in range(8): self._button[index].set_channel(2) self._button[index].set_identifier(index) #self._button[index].reset() self._button[index].set_enabled(False) self.request_rebuild_midi_map() for index in range(2): self._looper[index]._state_change() self._button[1 + (index * 4)].send_value(3) self._button[2 + (index * 4)].send_value(6) self._button[3 + (index * 4)].send_value(1) def _update_selected_device(self): if self._device_selection_follows_track_selection is True: 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.set_device(device_to_select) self.set_appointed_device(device_to_select) #self._device_selector.set_enabled(True) self.request_rebuild_midi_map() return None def handle_sysex(self, midi_bytes): #self.log_message(str('>>sysexIN') + str(midi_bytes)) if len(midi_bytes) > 10: #self.log_message(str('>>sysex>10') + str(midi_bytes[:11])) if midi_bytes[:11] == tuple([240, 126, 0, 6, 2, 0, 1, 97, 1, 0, 7]): self.log_message(str('>>>color detected')) self._rgb = 1 elif midi_bytes[:11] == tuple([240, 126, 0, 6, 2, 0, 1, 97, 1, 0, 2]): self.log_message(str('>>>mono detected')) self._rgb = 0 self._assign_session_colors() #self._shift_mode.update() self.deassign_matrix() self._assign_page_constants() self.assign_page_0() #self._setup_hilight_knobs() for index in range(8): self._grid[7][index].send_value(SCENE_LAUNCH_COLOR[self._rgb]) for index in range(7): self._grid[index][7].turn_on() # def handle_sysex(self, midi_bytes): # #assert(isinstance (midi_bytes, tuple)) # ##self.log_message(str('sysex') + str(midi_bytes)) # if midi_bytes == tuple([240, 126, 0, 6, 2, 0, 1, 97, 1, 0, 7, 0, 15, 10, 0, 0, 247]): # self.log_message(str('color detected')) # self._rgb = 1 # elif midi_bytes == tuple([240, 126, 0, 6, 2, 0, 1, 97, 1, 0, 2, 0, 0, 1, 1, 0, 247]): # self.log_message(str('mono detected')) # self._rgb = 0 # self._assign_session_colors() def receive_midi(self, midi_bytes): """ Live -> Script MIDI messages are only received through this function, when explicitly forwarded in 'build_midi_map'. """ assert (midi_bytes != None) assert isinstance(midi_bytes, tuple) ##self.log_message('got message' + str(midi_bytes)) #self.set_suppress_rebuild_requests(True) with self.component_guard(): if (len(midi_bytes) is 3): msg_type = (midi_bytes[0] & 240) forwarding_key = [midi_bytes[0]] if (msg_type is not MIDI_PB_TYPE): forwarding_key.append(midi_bytes[1]) if (tuple(forwarding_key) in self._forwarding_registry.keys()): recipient = self._forwarding_registry[tuple(forwarding_key)] if (recipient != None): recipient.receive_value(midi_bytes[2]) else: self.log_message(('Got unknown message: ' + str(midi_bytes))) else: self.handle_sysex(midi_bytes) #self.set_suppress_rebuild_requests(False) def _set_tempo_buttons(self, buttons): if self._tempo_buttons != None: self._tempo_buttons[0].remove_value_listener(self._tempo_value) self._tempo_buttons[1].remove_value_listener(self._tempo_value) self._tempo_buttons = buttons if buttons != None: for button in buttons: assert isinstance(button, FlashingButtonElement) self._tempo_buttons[0].set_on_off_values(4, 0) self._tempo_buttons[0].add_value_listener(self._tempo_value, True) self._tempo_buttons[1].set_on_off_values(4, 0) self._tempo_buttons[1].add_value_listener(self._tempo_value, True) self._tempo_buttons[0].turn_on() self._tempo_buttons[1].turn_on() def _tempo_value(self, value, sender): if (value > 0) and (self._tempo_buttons.index(sender) == 0): self.song().tempo = round(min((self.song().tempo + 1), 999)) elif (value > 0) and (self._tempo_buttons.index(sender) == 1): self.song().tempo = round(max((self.song().tempo - 1), 20)) def set_scene_index_value(self, bank_index, scene, track): bank = int(bank_index)/5 index = int(bank_index)%5 self.log_message('set_scene_index_value' + str(bank) + str(index) + str(scene) + str(track)) #self.log_message( str(type(index)) + str(type(scene)) + str(type(track))) self._scene_indexes[bank][index][0] = scene self._scene_indexes[bank][index][1] = track #self._on_selected_scene_changed() def connect_script_instances(self, instanciated_scripts): #link = False #offsets = [0, 0] #new_channel = CHAN for s in instanciated_scripts: if isinstance(s, APC) or s is self: #link = True if not s._session._is_linked(): s._session._link() #self.log_message('found other linked instance') #offsets[0] += (int(self._link_offset[0]) * 8) #offsets[1] += (int(self._link_offset[1]) * 4) #new_channel += 1 #if link and not self._session._is_linked(): #self._session.set_offsets(offsets[0], offsets[1]) #self._session._link() #self._set_code_channels(new_channel) # #
class AumPC20(APC): __doc__ = " Script for Akai's APC20 Controller " def __init__(self, c_instance): self._shift_modes = None APC.__init__(self, c_instance) return None def disconnect(self): self._shift_modes = None APC.disconnect(self) return None def _activate_combination_mode(self, track_offset, support_devices): APC._activate_combination_mode(self, track_offset, support_devices) if support_devices: self._shift_modes.invert_assignment() def _setup_session_control(self): is_momentary = True self._shift_button = FlashingButtonElement(is_momentary, MIDI_NOTE_TYPE, 0, 81, self) self._session = APCSessionComponent(8, 5) self._session.name = 'Session_Control' self._matrix = ButtonMatrixElement() self._matrix.name = 'Button_Matrix' scene_launch_buttons = [ FlashingButtonElement(is_momentary, MIDI_NOTE_TYPE, 0, (index + 82), self) for index in range(5) ] self._scene_launch_buttons = scene_launch_buttons track_stop_buttons = [ FlashingButtonElement(is_momentary, MIDI_NOTE_TYPE, index, 52, self) for index in range(8) ] self._track_stop_buttons = track_stop_buttons for index in range(len(scene_launch_buttons)): scene_launch_buttons[index].name = 'Scene_'+ str(index) + '_Launch_Button' for index in range(len(track_stop_buttons)): track_stop_buttons[index].name = 'Track_' + str(index) + '_Stop_Button' self._session.set_stop_track_clip_buttons(tuple(track_stop_buttons)) self._session.set_stop_track_clip_value(2) for scene_index in range(5): scene = self._session.scene(scene_index) scene.name = 'Scene_' + str(scene_index) button_row = [] scene.set_launch_button(scene_launch_buttons[scene_index]) scene.set_triggered_value(2) for track_index in range(8): button = FlashingButtonElement(is_momentary, MIDI_NOTE_TYPE, track_index, (scene_index + 53), self) button.name = str(track_index) + '_Clip_' + str(scene_index) + '_Button' button_row.append(button) clip_slot = scene.clip_slot(track_index) clip_slot.name = str(track_index) + '_Clip_Slot_' + str(scene_index) clip_slot.set_triggered_to_play_value(2) clip_slot.set_triggered_to_record_value(4) clip_slot.set_stopped_value(5) clip_slot.set_started_value(1) clip_slot.set_recording_value(3) clip_slot.set_launch_button(button) self._matrix.add_row(tuple(button_row)) self._session.selected_scene().name = 'Selected_Scene' self._session.selected_scene().set_launch_button(ButtonElement(is_momentary, MIDI_CC_TYPE, 0, 64)) self._session_zoom = ShiftableZoomingComponent(self._session, tuple(track_stop_buttons)) self._session_zoom.name = 'Session_Overview' self._session_zoom.set_button_matrix(self._matrix) self._session_zoom.set_zoom_button(self._shift_button) self._session_zoom.set_scene_bank_buttons(tuple(scene_launch_buttons)) self._session_zoom.set_stopped_value(3) self._session_zoom.set_selected_value(5) def _setup_mixer_control(self): is_momentary = True self._mixer = SpecialMixerComponent(8) self._mixer.name = 'Mixer' self._mixer.master_strip().name = 'Master_Channel_Strip' self._mixer.selected_strip().name = 'Selected_Channel_Strip' self._solo_buttons = [] for track in range(8): strip = self._mixer.channel_strip(track) strip.name = 'Channel_Strip_' + str(track) solo_button = FlashingButtonElement(is_momentary, MIDI_NOTE_TYPE, track, 50, self) self._solo_buttons.append(solo_button) mute_button = ButtonElement(is_momentary, MIDI_NOTE_TYPE, track, 49) solo_button.name = str(track) + '_Solo_Button' mute_button.name = str(track) + '_Mute_Button' strip.set_solo_button(solo_button) strip.set_mute_button(mute_button) strip.set_shift_button(self._shift_button) strip.set_invert_mute_feedback(True) master_volume_control = SliderElement(MIDI_CC_TYPE, 0, 14) prehear_control = EncoderElement(MIDI_CC_TYPE, 0, 47, Live.MidiMap.MapMode.relative_two_compliment) master_volume_control.name = 'Master_Volume_Control' prehear_control.name = 'Prehear_Volume_Control' self._mixer.set_prehear_volume_control(prehear_control) self._mixer.master_strip().set_volume_control(master_volume_control) def _setup_custom_components(self): is_momentary = True master_select_button = ButtonElement(is_momentary, MIDI_NOTE_TYPE, 0, 80) self._master_select_button = master_select_button master_select_button.name = 'Master_Select_Button' select_buttons = [] self._select_buttons = [] arm_buttons = [] sliders = [] for track in range(8): select_buttons.append(FlashingButtonElement(is_momentary, MIDI_NOTE_TYPE, track, 51, self)) self._select_buttons.append(select_buttons[track]) arm_buttons.append(ButtonElement(is_momentary, MIDI_NOTE_TYPE, track, 48)) if track is 7: self._user3 = arm_buttons[track] sliders.append(MonoEncoderElement2(MIDI_CC_TYPE, track, 7, Live.MidiMap.MapMode.absolute, 'Slider_' + str(track), track, self)) #sliders.append(MonoEncoderElement2(MIDI_CC_TYPE, track, 7)) select_buttons[-1].name = str(track) + '_Select_Button' arm_buttons[-1].name = str(track) + '_Arm_Button' #sliders[-1].name = str(track) + '_Volume_Control' transport = TransportComponent() transport.name = 'Transport' slider_modes = SliderModesComponent(self._mixer, tuple(sliders)) slider_modes.name = 'Slider_Modes' self._shift_modes = ShiftableSelectorComponent(tuple(select_buttons), master_select_button, tuple(arm_buttons), self._matrix, self._session, self._session_zoom, self._mixer, transport, slider_modes, self._send_introduction_message, self) self._shift_modes.name = 'Shift_Modes' self._shift_modes.set_mode_toggle(self._shift_button) def _product_model_id_byte(self): return 123 def _setup_monobridge(self): self._monobridge = MonoBridgeElement(self) self._monobridge.name = 'MonoBridge' def _setup_monomod(self): self._host = MonomodComponent(self) self._host.name = 'Monomod_Host' self._host._set_nav_buttons = self._mod_set_nav_buttons(self._host) self._host._update_nav_buttons = self._mod_update_nav_buttons(self._host) self._host._set_nav_buttons = self._mod_set_nav_buttons(self._host) self.hosts = [self._host] self._monomod = ButtonMatrixElement() self._monomod.name = 'Monomod' for row in range(5): button_row = [] for column in range(8): button_row.append(self._matrix.get_button(column, row)) self._monomod.add_row(tuple(button_row)) self._monomod.add_row(tuple(self._track_stop_buttons)) self._monomod.add_row(tuple(self._select_buttons)) self._monomod.add_row(tuple(self._solo_buttons)) self._monomod_mode = MonomodModeComponent(self._monomod_mode_update, self) self._monomod_mode.name = "Monomod_Mode_Component" def _monomod_mode_update(self): if(self._monomod_mode._mode_index == 0) or (self._host._active_client == None): self.flash_status = 0 self._host.set_enabled(False) self._host._set_button_matrix(None) #self._host._set_nav_buttons(None) self._host._set_lock_button(None) self._host._set_alt_button(None) self._host._set_shift_button(None) self._host._set_nav_buttons(None) self._scene_launch_buttons[2].set_on_off_values(127, 0) self._scene_launch_buttons[3].set_on_off_values(127, 0) self._monomod.reset() self._shift_modes.set_enabled(True) #self._session.set_track_bank_buttons(self._right_button, self._left_button) #self._session.set_scene_bank_buttons(self._down_button, self._up_button) for track in range(8): self._mixer.channel_strip(track).set_select_button(self._select_buttons[track]) self._mixer.channel_strip(track).set_solo_button(self._solo_buttons[track]) #self._transport.set_nudge_buttons(self._nudge_up_button, self._nudge_down_button) self._session.set_enabled(True) self._session_zoom._is_zoomed_out = False self._session_zoom.set_enabled(True) self.request_rebuild_midi_map() self._master_select_button.turn_off() elif(self._monomod_mode._mode_index == 1): if self._shift_modes._note_mode_active is True: self._shift_modes._mode_callback(ABLETON_MODE) self._shift_modes._note_mode_active = False self._session_zoom.set_ignore_buttons(False) self._shift_modes._transport.update() self._shift_modes._on_note_mode_changed() #self._transport.set_nudge_buttons(None, None) self._shift_modes.set_enabled(False) for track in range(8): self._mixer.channel_strip(track).set_select_button(None) self._mixer.channel_strip(track).set_solo_button(None) for scene in range(5): self._scene_launch_buttons[scene].turn_off() self._session.set_enabled(False) self._session_zoom.set_enabled(False) #self._session.set_track_bank_buttons(None, None) #self._session.set_scene_bank_buttons(None, None) self.flash_status = 1 self._monomod.reset() self._host._set_button_matrix(self._monomod) #self._host._set_nav_buttons([self._up_button, self._down_button, self._left_button, self._right_button]) self._host._set_shift_button(self._shift_button) self._host._set_lock_button(self._scene_launch_buttons[0]) self._host._set_alt_button(self._scene_launch_buttons[1]) self._host._set_nav_buttons([self._scene_launch_buttons[2], self._scene_launch_buttons[3]]) self._host.set_enabled(True) self.request_rebuild_midi_map() self._master_select_button.turn_on() """m4l bridge""" def generate_strip_string(self, display_string): #self.log_message(display_string) NUM_CHARS_PER_DISPLAY_STRIP = 12 if (not display_string): return (' ' * NUM_CHARS_PER_DISPLAY_STRIP) if ((len(display_string.strip()) > (NUM_CHARS_PER_DISPLAY_STRIP - 1)) and (display_string.endswith('dB') and (display_string.find('.') != -1))): display_string = display_string[:-2] if (len(display_string) > (NUM_CHARS_PER_DISPLAY_STRIP - 1)): for um in [' ', 'i', 'o', 'u', 'e', 'a']: while ((len(display_string) > (NUM_CHARS_PER_DISPLAY_STRIP - 1)) and (display_string.rfind(um, 1) != -1)): um_pos = display_string.rfind(um, 1) display_string = (display_string[:um_pos] + display_string[(um_pos + 1):]) else: display_string = display_string.center((NUM_CHARS_PER_DISPLAY_STRIP - 1)) ret = u'' for i in range((NUM_CHARS_PER_DISPLAY_STRIP - 1)): if ((ord(display_string[i]) > 127) or (ord(display_string[i]) < 0)): ret += ' ' else: ret += display_string[i] ret += ' ' assert (len(ret) == NUM_CHARS_PER_DISPLAY_STRIP) return ret def notification_to_bridge(self, name, value, sender): if isinstance(sender, MonoEncoderElement2): self._monobridge._send(sender.name, 'lcd_name', str(self.generate_strip_string(name))) self._monobridge._send(sender.name, 'lcd_value', str(self.generate_strip_string(value))) def touched(self): if self._touched is 0: self._monobridge._send('touch', 'on') self.schedule_message(2, self.check_touch) self._touched +=1 def check_touch(self): if self._touched > 5: self._touched = 5 elif self._touched > 0: self._touched -= 1 if self._touched is 0: self._monobridge._send('touch', 'off') else: self.schedule_message(2, self.check_touch) def get_clip_names(self): clip_names = [] for scene in self._session._scenes: for clip_slot in scene._clip_slots: if clip_slot.has_clip() is True: clip_names.append(clip_slot._clip_slot)##.clip.name) return clip_slot._clip_slot ##self.log_message(str(clip_slot._clip_slot.clip.name)) return clip_names def update_display(self): """ Live -> Script Aka on_timer. Called every 100 ms and should be used to update display relevant parts of the controller """ for message in self._scheduled_messages: message['Delay'] -= 1 if (message['Delay'] == 0): if (message['Parameter'] != None): message['Message'](message['Parameter']) else: message['Message']() del self._scheduled_messages[self._scheduled_messages.index(message)] for callback in self._timer_callbacks: callback() self._timer = (self._timer + 1) % 256 self.flash() def flash(self): if(self.flash_status > 0): for row in range(8): for column in range(8): button = self._monomod.get_button(column, row) if(button._flash_state > 0): button.flash(self._timer) ### Mod Overrides #### def _mod_set_nav_buttons(self, mod): def _set_nav_buttons(buttons): if mod._nav_buttons != None: mod._nav_buttons[0].remove_value_listener(mod._nav_up_value) mod._nav_buttons[1].remove_value_listener(mod._nav_down_value) mod._nav_buttons = buttons if buttons != None: assert len(buttons) == 2 for button in buttons: assert isinstance(button, FlashingButtonElement) mod._nav_buttons[0].set_on_off_values(8, 2) mod._nav_buttons[0].add_value_listener(mod._nav_up_value) mod._nav_buttons[1].set_on_off_values(8, 2) mod._nav_buttons[1].add_value_listener(mod._nav_down_value) return _set_nav_buttons def _mod_update_nav_buttons(self, mod): def _update_nav_buttons(): if mod._nav_buttons != None: if(mod._y > 0): mod._nav_buttons[0].turn_on() else: mod._nav_buttons[0].turn_off() if(mod._y < 8): mod._nav_buttons[1].turn_on() else: mod._nav_buttons[1].turn_off() return _update_nav_buttons
class Codec(ControlSurface): __module__ = __name__ __doc__ = " MonoCode controller script " def __init__(self, c_instance, *a, **k): super(Codec, self).__init__(c_instance, *a, **k) self._monomod_version = 'b995' self._version_check = 'b995' self._host_name = 'Codec' self._color_type = 'Monochrome' self._link_mixer = LINK_MIXER self._hosts = [] self._linked_script = None self._local_ring_control = True self._last_device = None self._device_list = [None, None, None, None] self._device_select_buttons = None self._last_device_component = None self._timer = 0 self._touched = 0 self._locked = False self.flash_status = 1 self._shift_button = None self._shift_pressed = 0 self._shift_pressed_timer = 0 self._shift_thresh = SHIFT_THRESH self._use_device_selector = USE_DEVICE_SELECTOR self._device_selection_follows_track_selection=FOLLOW with self.component_guard(): #self.local_ring_control(True) #self.set_absolute_mode(True) self._setup_controls() self._setup_monobridge() self._setup_device_controls() self._setup_special_device_control() self._device.append(self._special_device) #necessary for device browsing to work with special device self._setup_device_chooser() self._setup_mixer_controls() self._setup_monomod() self._setup_modes() self._setup_device_selector() self._setup_send_reset() self._setup_default_buttons() self.set_local_ring_control(1) self.song().view.add_selected_track_listener(self._update_selected_device) self._initialize_code() #self._shift_mode.set_mode(0) #self._monomod_mode.set_mode(0) self.log_message('<<<<<<<<<<<<<<<<<<<<<<<<< Codec ' + str(self._monomod_version) + ' log opened >>>>>>>>>>>>>>>>>>>>>>>>>') self.show_message('Codec Control Surface Loaded') self.request_rebuild_midi_map() """script initialization methods""" def _initialize_code(self): self._send_midi(factoryreset) self._send_midi(btn_channels) self._send_midi(enc_channels) def _setup_monobridge(self): self._monobridge = MonoBridgeElement(self) self._monobridge.name = 'MonoBridge' def _setup_controls(self): is_momentary = True self._livid = CodecMonoButtonElement(is_momentary, MIDI_NOTE_TYPE, CHANNEL, LIVID, 'Livid_Button', self) self._dial = [None for index in range(8)] for column in range(8): self._dial[column] = [None for index in range(4)] for row in range(4): self._dial[column][row] = CodecEncoderElement(MIDI_CC_TYPE, CHANNEL, CODE_DIALS[row][column], Live.MidiMap.MapMode.absolute, 'Dial_' + str(column) + '_' + str(row), (column + (row*8)), self) #CODE_DIALS[row][column] self._button = [None for index in range(8)] for column in range(8): self._button[column] = [None for index in range(4)] for row in range(4): self._button[column][row] = CodecMonoButtonElement(is_momentary, MIDI_NOTE_TYPE, CHANNEL, CODE_BUTTONS[row][column], 'Button_' + str(column) + '_' + str(row), self) self._column_button = [None for index in range(8)] for index in range(8): self._column_button[index] = CodecMonoButtonElement(is_momentary, MIDI_NOTE_TYPE, CHANNEL, CODE_COLUMN_BUTTONS[index], 'Column_Button_' + str(index), self) self._row_button = [None for index in range(4)] for index in range(4): self._row_button[index] = CodecMonoButtonElement(is_momentary, MIDI_NOTE_TYPE, CHANNEL, CODE_ROW_BUTTONS[index], 'Row_Button_' + str(index), self) self._dial_matrix = EncoderMatrixElement(self) self._dial_matrix.name = 'Encoder_Matrix' for row in range(4): dial_row = tuple([self._dial[column][row] for column in range(8)]) self._dial_matrix.add_row(dial_row) self._button_matrix = ButtonMatrixElement() self._button_matrix.name = 'Button_Matrix' for row in range(4): button_row = [self._button[column][row] for column in range(8)] button_row.append(self._row_button[row]) self._button_matrix.add_row(tuple(button_row)) self._button_matrix.add_row(tuple(self._column_button + [self._livid])) def _setup_modes(self): self._monomod_mode = MonomodModeComponent(self._mod_mode_update, self) self._monomod_mode.name = 'Monomod_Mode' self.set_shift_button(self._livid) self._shift_mode = ShiftModeComponent(self._shift_update, self) self._shift_mode.name = 'Shift_Mode' self._shift_mode.set_mode_buttons(tuple([self._row_button[0], self._row_button[1], self._row_button[2], self._row_button[3]])) def _setup_transport_control(self): self._transport = TransportComponent() self._transport.name = 'Transport' def _setup_monomod(self): self._host = CodecMonomodComponent(self) self._host.name = 'Monomod_Host' self._host._set_dial_matrix(self._dial_matrix, self._button_matrix) self.hosts = [self._host] encs = [] for row in range(4): for col in range(8): encs.append(self._dial[col][row]) self._host._set_parameter_controls(encs) def _setup_mixer_controls(self): is_momentary = True self._num_tracks = (8) self._session = SessionComponent(self._num_tracks, 0) self._session.name = 'Session' self._mixer = MixerComponent(self._num_tracks, 0, False, False) self._mixer.name = 'Mixer' self._mixer._next_track_value = self._mixer_next_track_value(self._mixer) self._mixer._prev_track_value = self._mixer_prev_track_value(self._mixer) self._mixer.set_track_offset(0) #Sets start point for mixer strip (offset from left) #for index in range(8): #use the bottom row of encoders for volume, so add 24 to offset the index # self._mixer.channel_strip(index).set_volume_control(self._dial[index+24]) for index in range(8): self._mixer.channel_strip(index).name = 'Mixer_ChannelStrip_' + str(index) self._mixer.channel_strip(index)._invert_mute_feedback = True self._mixer.channel_strip(index)._mute_value = self._channelstrip_mute_value(self._mixer.channel_strip(index)) self._mixer.channel_strip(index)._solo_value = self._channelstrip_solo_value(self._mixer.channel_strip(index)) #mixer.channel_strip(index).set_select_button(ButtonElement(is_momentary, MIDI_NOTE_TYPE, CH, track_select_notes[index])) self.song().view.selected_track = self._mixer.channel_strip(0)._track #set the selected strip to the first track, so that we don't, for example, try to assign a button to arm the master track, which would cause an assertion error self._session.set_mixer(self._mixer) def _setup_device_controls(self): self._device = [None for index in range(4)] for index in range(4): self._device[index] = CodecDeviceComponent(self) self._device[index].name = 'CodecDevice_Component_' + str(index) device_param_controls = [] for control in range(8): device_param_controls.append(self._dial[control][index]) self._device[index].set_on_off_button(self._button[1][index]) self._device[index].set_lock_button(self._button[2][index]) self._device[index].set_bank_nav_buttons(self._button[4][index], self._button[5][index]) self._device[index].set_nav_buttons(self._button[6][index], self._button[7][index]) self._device[index].set_parameter_controls(tuple(device_param_controls)) self.set_device_component(self._device[0]) self._last_device_component = self._device[0] def _setup_special_device_control(self): self._special_device = SpecialCodecDeviceComponent(self) self._special_device.name = 'SpecialCodecDeviceComponent' self._special_device.set_on_off_button(self._button[1][0]) self._special_device.set_lock_button(self._button[2][0]) self._special_device.set_bank_nav_buttons(self._button[4][0], self._button[5][0]) self._special_device.set_nav_buttons(self._button[6][0], self._button[7][0]) device_param_controls = [] for row in range(4): for column in range(8): device_param_controls.append(self._dial[column][row]) self._special_device.set_parameter_controls(tuple(device_param_controls)) def _setup_device_chooser(self): self._selected_device = self._device[0] self._last_selected_device = self._device[0] self._device_select_buttons = [self._button[0][index] for index in range(4)] for button in self._device_select_buttons: button.add_value_listener(self._device_select_value, True) def _setup_device_selector(self): self._device_selector = CodecDeviceSelectorComponent(self, 'c', self._device + [self._special_device]) self._device_selector.name = 'Device_Selector' self._device_selector.set_mode_buttons(self._column_button) #self._device_selector.set_mode_toggle(self._livid) def _setup_send_reset(self): self._send_reset = CodecResetSendsComponent(self) self._send_reset.set_buttons(self._button) def _setup_default_buttons(self): self._value_default = ParameterDefaultComponent(self) buttons = [] dials = [] for column in self._button: for button in column: buttons.append(button) for column in self._dial: for dial in column: dials.append(dial) self._value_default.set_buttons(buttons) self._value_default.set_dials(dials) """multiple device support""" def _device_select_value(self, value, sender): #self.log_message('device_select_value ' + str(value) + ' ' + str(self._device_select_buttons.index(sender))) if not self._shift_pressed: if sender.is_momentary or value > 0: if self._shift_mode._mode_index == 2: self.set_device_component(self._device[self._device_select_buttons.index(sender)]) self._last_device_component = self._device_component if self._device_component != None and isinstance(self._device_component._device, Live.Device.Device): if self._device_component.find_track(self._device_component._device) == self.song().view.selected_track: self._device_component.display_device() """livid double press mechanism""" def set_shift_button(self, button): assert ((button == None) or (isinstance(button, MonoButtonElement))) if self._shift_button != None: self._shift_button.remove_value_listener(self._shift_value) self._shift_button = button if self._shift_button != None: self._shift_button.add_value_listener(self._shift_value) def _shift_value(self, value): self._shift_pressed = int(value != 0) if self._shift_pressed > 0: self._send_midi(SLOWENCODER) if (self._shift_pressed_timer + self._shift_thresh) > self._timer: #if(self._host.is_enabled() != True) self.log_message('mod mode: ' + str(abs(self._monomod_mode._mode_index - 1))) self._monomod_mode.set_mode(max(0, min(1, abs(self._monomod_mode._mode_index - 1)))) #else: # self._monomod_mode.set_mode(0) self._shift_pressed_timer = self._timer % 256 else: self._send_midi(NORMALENCODER) def _mod_mode_update(self): if(self._monomod_mode._mode_index == 0): self._host._set_shift_button(None) self._host.set_enabled(False) self._dial_matrix.reset() self._shift_mode.set_enabled(True) self._shift_update() self.request_rebuild_midi_map() self._livid.turn_off() elif(self._monomod_mode._mode_index == 1): self._shift_mode.set_enabled(False) self._deassign_all() self._dial_matrix.reset() self._button_matrix.reset() self._livid.turn_on() if not self._host._active_client == None: self._host.set_enabled(True) self._host._set_shift_button(self._livid) else: self._assign_alternate_mappings(1) self.request_rebuild_midi_map() """Mode Functions""" def _shift_update(self): if(self._shift_mode.is_enabled()): with self.component_guard(): self.allow_updates(False) #if(not self._in_build_midi_map): # self.set_suppress_rebuild_requests(True) self._deassign_all() if(self._shift_mode._mode_index is 0): self._assign_volume() elif(self._shift_mode._mode_index is 1): self._assign_sends() elif(self._shift_mode._mode_index is 2): self._assign_devices() elif(self._shift_mode._mode_index is 3): self._assign_special_device() for index in range(self._shift_mode.number_of_modes()): if index == self._shift_mode._mode_index: self._shift_mode._modes_buttons[index].turn_on() else: self._shift_mode._modes_buttons[index].turn_off() self.allow_updates(True) #self.set_suppress_rebuild_requests(False) self.request_rebuild_midi_map() def _deassign_all(self): self._assign_alternate_mappings(0) self._device_selector.set_enabled(False) for index in range(8): self._mixer.channel_strip(index).set_volume_control(None) self._mixer.channel_strip(index).set_pan_control(None) self._mixer.channel_strip(index).set_send_controls(tuple([None, None, None, None])) for index in range(4): self._device[index].set_enabled(False) self._device[index]._parameter_controls = None #self._device_navigator[index].set_enabled(False) self._special_device.set_enabled(False) self._special_device._parameter_controls = None self._device_selector.set_enabled(False) self._deassign_buttons() for control in self.controls: control.reset() self.request_rebuild_midi_map() def _deassign_buttons(self): for index in range(8): self._mixer.channel_strip(index).set_select_button(None) self._mixer.channel_strip(index).set_solo_button(None) self._mixer.channel_strip(index).set_mute_button(None) self._mixer.set_select_buttons(None, None) self._send_reset.set_enabled(False) def _assign_volume(self): for index in range(8): self._mixer.channel_strip(index).set_volume_control(self._dial[index][3]) self._mixer.channel_strip(index).set_pan_control(self._dial[index][2]) self._mixer.channel_strip(index).set_send_controls(tuple([self._dial[index][0], self._dial[index][1]])) self._mixer.channel_strip(index).set_select_button(self._column_button[index]) self._mixer.channel_strip(index).set_solo_button(self._button[index][2]) self._mixer.channel_strip(index).set_mute_button(self._button[index][3]) self._mixer.set_select_buttons(self._button[7][0], self._button[6][0]) def _assign_sends(self): for index in range(8): self._mixer.channel_strip(index).set_send_controls(tuple([self._dial[index][0], self._dial[index][1], self._dial[index][2], self._dial[index][3]])) self._mixer.channel_strip(index).set_select_button(self._column_button[index]) self._send_reset.set_enabled(True) def _assign_devices(self): self.set_device_component(self._last_device_component) self._device_select_value(1, self._device_select_buttons[self._device.index(self._device_component)]) for index in range(4): device_param_controls = [] for control in range(8): device_param_controls.append(self._dial[control][index]) self._device[index].set_parameter_controls(tuple(device_param_controls)) self._device[index].set_enabled(True) self._device_selector.set_enabled(self._use_device_selector) if not self._use_device_selector: for index in range(8): self._mixer.channel_strip(index).set_select_button(self._column_button[index]) def _assign_special_device(self): self.set_device_component(self._special_device) device_param_controls = [] for row in range(4): for column in range(8): device_param_controls.append(self._dial[column][row]) self._special_device.set_parameter_controls(tuple(device_param_controls)) self._special_device.set_enabled(True) self._device_selector.set_enabled(self._use_device_selector) if not self._use_device_selector: for index in range(8): self._mixer.channel_strip(index).set_select_button(self._column_button[index]) def _assign_alternate_mappings(self, chan): for column in self._dial: for control in column: control.set_channel(chan) control.set_enabled(chan is 0) for column in self._button: for control in column: control.set_channel(chan) control.set_enabled(chan is 0) for control in self._column_button: control.set_channel(chan) control.set_enabled(chan is 0) for control in self._row_button: control.set_channel(chan) control.set_enabled(chan is 0) """general functionality""" 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 def connect_script_instances(self, instanciated_scripts): found = False for s in instanciated_scripts: if '_codec_version' in dir(s): if s._codec_version == self._version_check: if s._host_name == ('MonOhm'): self.log_message('found codec version ' + str(s._codec_version) + ' in script ' + str(s._host_name)) found = True self._linked_script = s self._linked_script._update_linked_device_selection = self._update_linked_device_selection if not self._session._is_linked() and self._link_mixer is True: self._session.set_offsets(LINK_OFFSET[0], LINK_OFFSET[1]) self._session._link() else: self.log_message('version mismatch: Monomod version ' + str(self._version_check) + ' vs. Host version ' + str(s._codec_version)) if found == False: for s in instanciated_scripts: if '_codec_version' in dir(s): if s._codec_version == self._version_check: if s._host_name == 'BlockMod': self.log_message('found codec version ' + str(s._codec_version) + ' in script ' + str(s._host_name)) self._linked_script = s self._linked_script._update_linked_device_selection = self._update_linked_device_selection if not self._session._is_linked() and self._link_mixer is True: self._session.set_offsets(LINK_OFFSET[0], LINK_OFFSET[1]) self._session._link() else: self.log_message('version mismatch: Monomod version ' + str(self._version_check) + ' vs. Host version ' + str(s._codec_version)) #self.log_message('hosts: ' + str(self._hosts))""" def update_display(self): ControlSurface.update_display(self) #since we are overriding this from the inherited method, we need to call the original routine as well self._timer = (self._timer + 1) % 256 if(self._timer == 0): self._shift_pressed_timer = -12 if(self._local_ring_control is False): self.send_ring_leds() self.flash() def handle_sysex(self, midi_bytes): #self._send_midi(tuple([240, 00, 01, 97, 04, 15, 01, 247])) #response = [long(0),long(0)] #self.log_message(response) pass def flash(self): if(self.flash_status > 0): for control in self.controls: if isinstance(control, MonoButtonElement): control.flash(self._timer) def send_ring_leds(self): leds = [240, 0, 1, 97, 4, 31] for column in range(8): for row in range(4): wheel = self._dial[column][row] bytes = wheel._get_ring() leds.append(bytes[0]) leds.append(int(bytes[1]) + int(bytes[2])) #if(row == 1 and column == 0): # self.log_message(str(leds) + ' ' + str(bytes[0]) + ' ' + str(bytes[1]) + ' ' + str(bytes[2])) leds.append(247) self._send_midi(tuple(leds)) def set_absolute_mode(self, val = 1): self._absolute_mode = (val!=0) if self._absolute_mode is True: self._send_midi(tuple([240, 0, 1, 97, 4, 17, 0, 0, 0, 0, 0, 0, 0, 0, 247])) else: self._send_midi(tuple([240, 0, 1, 97, 4, 17, 127, 127, 127, 127, 127, 127, 127, 127, 247])) def set_local_ring_control(self, val = 1): self._local_ring_control = (val!=0) if(self._local_ring_control is True): #self._send_midi(tuple([240, 0, 1, 97, 4, 32, 0, 247])) self._send_midi(tuple([240, 0, 1, 97, 4, 8, 72, 247])) else: #self._send_midi(tuple([240, 0, 1, 97, 4, 32, 1, 247])) self._send_midi(tuple([240, 0, 1, 97, 4, 8, 64, 247])) def device_follows_track(self, val): self._device_selection_follows_track_selection = (val == 1) return self """m4l bridge""" def generate_strip_string(self, display_string): NUM_CHARS_PER_DISPLAY_STRIP = 12 if (not display_string): return (' ' * NUM_CHARS_PER_DISPLAY_STRIP) if ((len(display_string.strip()) > (NUM_CHARS_PER_DISPLAY_STRIP - 1)) and (display_string.endswith('dB') and (display_string.find('.') != -1))): display_string = display_string[:-2] if (len(display_string) > (NUM_CHARS_PER_DISPLAY_STRIP - 1)): for um in [' ', 'i', 'o', 'u', 'e', 'a']: while ((len(display_string) > (NUM_CHARS_PER_DISPLAY_STRIP - 1)) and (display_string.rfind(um, 1) != -1)): um_pos = display_string.rfind(um, 1) display_string = (display_string[:um_pos] + display_string[(um_pos + 1):]) else: display_string = display_string.center((NUM_CHARS_PER_DISPLAY_STRIP - 1)) ret = u'' for i in range((NUM_CHARS_PER_DISPLAY_STRIP - 1)): if ((ord(display_string[i]) > 127) or (ord(display_string[i]) < 0)): ret += ' ' else: ret += display_string[i] ret += ' ' assert (len(ret) == NUM_CHARS_PER_DISPLAY_STRIP) return ret def notification_to_bridge(self, name, value, sender): if(isinstance(sender, CodecEncoderElement)): self._monobridge._send(sender.name, 'lcd_name', str(self.generate_strip_string(name))) self._monobridge._send(sender.name, 'lcd_value', str(self.generate_strip_string(value))) def touched(self): if not self._host.is_enabled(): if self._touched is 0: self._monobridge._send('touch', 'on') self.schedule_message(2, self.check_touch) self._touched +=1 def check_touch(self): if self._touched > 5: self._touched = 5 elif self._touched > 0: self._touched -= 1 if self._touched is 0: self._monobridge._send('touch', 'off') else: self.schedule_message(2, self.check_touch) def get_clip_names(self): clip_names = [] for scene in self._session._scenes: for clip_slot in scene._clip_slots: if clip_slot.has_clip() is True: clip_names.append(clip_slot._clip_slot)##.clip.name) return clip_slot._clip_slot ##self.log_message(str(clip_slot._clip_slot.clip.name)) return clip_names """overrides""" def allow_updates(self, allow_updates): for component in self.components: component.set_allow_update(int(allow_updates!=0)) def set_device_component(self, device_component): if self._device_component != None: self._device_component._lock_callback = None assert (device_component != None) assert isinstance(device_component, DeviceComponent) self._device_component = device_component self._device_component._lock_callback = self._toggle_lock #old: self._device_component.set_lock_callback(self._toggle_lock) if self._device_select_buttons != None: for button in self._device_select_buttons: button.send_value(self._device_select_buttons.index(button) == self._device.index(self._device_component)) self._update_device_selection() return None def _update_selected_device(self): if self._device_selection_follows_track_selection is True: self._update_device_selection() return None def _update_linked_device_selection(self, device): #self.log_message('codec received ' + str(device.name)) if self._device_component != None and device != None: if not self._device_component.is_locked(): self._device_component.set_device(device) def _get_num_tracks(self): return self.num_tracks def _update_device_selection(self): #self.log_message('_update_device_selection') if self._device_component != None: if not self._device_component.is_locked(): 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) def _channelstrip_mute_value(self, channelstrip): def _mute_value(value): if not self._shift_pressed: self.log_message('shift not pressed') ChannelStripComponent._mute_value(channelstrip, value) return _mute_value def _channelstrip_solo_value(self, channelstrip): def _solo_value(value): if not self._shift_pressed: ChannelStripComponent._solo_value(channelstrip, value) return _solo_value def _mixer_next_track_value(self, mixer): def _next_track_value(value): if not self._shift_pressed: MixerComponent._next_track_value(mixer, value) return _next_track_value def _mixer_prev_track_value(self, mixer): def _prev_track_value(value): if not self._shift_pressed: MixerComponent._prev_track_value(mixer, value) return _prev_track_value
class BlockMod(MonOhm): __module__ = __name__ __doc__ = " Monomodular controller script for Livid Block " def __init__(self, *a, **k): self._shift_button = None self._shift_pressed = 0 self._shift_pressed_timer = 0 self._shift_thresh = SHIFT_THRESH super(BlockMod, self).__init__(*a, **k) self._host_name = 'BlockMod' self._color_type = 'Monochrome' self._link_mixer = LINK_MIXER self._rgb = 1 self._ohm = 127 self._ohm_type = 'static' self._pad_translations = PAD_TRANSLATION self._mem = [4, 8, 12, 16] self._host._navbox_selected = 8 """script initialization methods""" def _setup_monobridge(self): self._monobridge = MonoBridgeElement(self) self._monobridge.name = 'MonoBridge' def _setup_controls(self): is_momentary = True self._fader = [None for index in range(8)] self._dial = [None for index in range(16)] self._button = [None for index in range(8)] self._menu = [None for index in range(6)] for index in range(2): self._fader[index] = MonoEncoderElement(MIDI_CC_TYPE, CHANNEL, SLIDER_CC[index], Live.MidiMap.MapMode.absolute, 'Fader_' + str(index), index, self) #for index in range(8): # self._button[index] = MonoButtonElement(is_momentary, MIDI_NOTE_TYPE, CHANNEL, OHM_BUTTONS[index], 'Button_' + str(index), self) for index in range(8): self._dial[index] = MonoEncoderElement(MIDI_CC_TYPE, CHANNEL, KNOB_CC[index], Live.MidiMap.MapMode.absolute, 'Dial_' + str(index), index + 8, self) for index in range(4): self._menu[index] = MonoButtonElement(is_momentary, MIDI_NOTE_TYPE, CHANNEL, FUNCTION_NOTES[index], 'Menu_' + str(index), self) self._livid = MonoButtonElement(is_momentary, MIDI_NOTE_TYPE, CHANNEL, LIVID, 'Livid_Button', self) self._shift_l = MonoButtonElement(is_momentary, MIDI_NOTE_TYPE, CHANNEL, SHIFT_L, 'Shift_Button_Left', self) self._shift_r = MonoButtonElement(is_momentary, MIDI_NOTE_TYPE, CHANNEL, SHIFT_R, 'Shift_Button_Right', self) self._matrix = ButtonMatrixElement() self._matrix.name = 'Matrix' self._monomod = ButtonMatrixElement() self._monomod.name = 'Monomod' self._grid = [None for index in range(8)] for column in range(8): self._grid[column] = [None for index in range(8)] for row in range(8): self._grid[column][row] = MonoButtonElement(is_momentary, MIDI_NOTE_TYPE, CHANNEL, (column * 8) + row, 'Grid_' + str(column) + '_' + str(row), self) for row in range(5): button_row = [] for column in range(7): button_row.append(self._grid[column][row]) self._matrix.add_row(tuple(button_row)) for row in range(8): button_row = [] for column in range(8): button_row.append(self._grid[column][row]) self._monomod.add_row(tuple(button_row)) self._dummy_button = ButtonElement(is_momentary, MIDI_NOTE_TYPE, 15, 125) self._dummy_button.name = 'Dummy1' self._dummy_button2 = ButtonElement(is_momentary, MIDI_NOTE_TYPE, 15, 126) self._dummy_button2.name = 'Dummy2' self._dummy_button3 = ButtonElement(is_momentary, MIDI_NOTE_TYPE, 15, 127) self._dummy_button2.name = 'Dummy3' def _setup_transport_control(self): self._transport = TransportComponent() self._transport.name = 'Transport' def _setup_crossfader(self): pass def _setup_modes(self): self._monomod_mode = MonomodModeComponent(self, self.monomod_mode_update) self._monomod_mode.name = 'Monomod_Mode' self.set_shift_button(self._livid) self._shift_mode = BlockModShiftModeComponent(self, self.shift_update) self._shift_mode.name = 'Shift_Mode' self._shift_mode.set_mode_toggle(self._shift_l, self._shift_r) self._l_function_mode = FunctionModeComponent(self, self.l_function_update) self._l_function_mode.name = 'Left_Function_Mode' self._r_function_mode = FunctionModeComponent(self, self.r_function_update) self._r_function_mode.name = 'Right_Function_Mode' self._m_function_mode = FunctionModeComponent(self, self.m_function_update) self._m_function_mode.name = 'Main_Function_Mode' self._function_modes = [self._l_function_mode, self._r_function_mode, self._m_function_mode] """livid double press mechanism""" def set_shift_button(self, button): assert ((button == None) or (isinstance(button, MonoButtonElement))) if self._shift_button != None: self._shift_button.remove_value_listener(self._shift_value) self._shift_button = button if self._shift_button != None: self._shift_button.add_value_listener(self._shift_value) def _shift_value(self, value): self._shift_pressed = int(value != 0) if self._shift_pressed > 0: if (self._shift_pressed_timer + self._shift_thresh) > self._timer: if(self._host._active_client != None): if(self._host.is_enabled() != True): self._monomod_mode.set_mode(1) else: self._monomod_mode.set_mode(0) else: self._shift_pressed_timer = self._timer % 256 if(self._cntrlr != None): self._cntrlr._monohm_shift(2) else: if(self._cntrlr != None): self._cntrlr._monohm_shift(0) """shift/zoom methods""" def deassign_matrix(self): self._session_zoom.set_button_matrix(None) self._session_zoom2.set_button_matrix(None) self._session.set_stop_track_clip_buttons(None) self._session2.set_stop_track_clip_buttons(None) self._session_zoom_main.set_button_matrix(None) self._session_main.set_stop_track_clip_buttons(None) for column in range(4): self._mixer2.channel_strip(column).set_select_button(None) self._mixer2.return_strip(column).set_mute_button(None) self._mixer2.return_strip(column).set_solo_button(None) self._mixer2.return_strip(column).set_arm_button(None) self._mixer2.return_strip(column).set_crossfade_toggle(None) self._mixer2.return_strip(column).set_select_button(None) #shouldn't this be somewhere else? self._mixer2.channel_strip(column).set_crossfade_toggle(None) self._mixer2.channel_strip(column).set_mute_button(None) self._mixer2.channel_strip(column).set_solo_button(None) self._mixer2.channel_strip(column).set_arm_button(None) for row in range(5): self._scene[row].clip_slot(column).set_launch_button(None) self._scene2[row].clip_slot(column).set_launch_button(None) for index in range(5): self._scene[index].set_launch_button(None) self._scene2[index].set_launch_button(None) self._scene_main[index].set_launch_button(None) self._session_zoom.set_nav_buttons(None, None, None, None) self._session_zoom2.set_nav_buttons(None, None, None, None) self._session_zoom_main.set_nav_buttons(None, None, None, None) self._session.set_track_bank_buttons(None, None) self._session.set_scene_bank_buttons(None, None) self._session2.set_track_bank_buttons(None, None) self._session2.set_scene_bank_buttons(None, None) self._session_main.set_track_bank_buttons(None, None) self._session_main.set_scene_bank_buttons(None, None) for column in range(8): self._mixer.channel_strip(column).set_select_button(None) self._mixer.channel_strip(column).set_crossfade_toggle(None) self._mixer.channel_strip(column).set_mute_button(None) self._mixer.channel_strip(column).set_solo_button(None) self._mixer.channel_strip(column).set_arm_button(None) for row in range(5): self._scene_main[row].clip_slot(column).set_launch_button(None) for row in range(8): self._grid[column][row].set_channel(0) self._grid[column][row].release_parameter() self._grid[column][row].use_default_message() self._grid[column][row].set_enabled(True) self._grid[column][row].set_on_off_values(127, 0) self._grid[column][row].send_value(0, True) self._send_reset.set_buttons(tuple(None for index in range(4))) def zoom_off(self): for column in range(4): self._grid[column][5].set_on_value(MUTE[self._rgb]) self._mixer.channel_strip(column).set_mute_button(self._grid[column][5]) self._grid[column][6].set_on_value(ARM[self._rgb]) self._mixer.channel_strip(column).set_arm_button(self._grid[column][6]) for row in range(5): self._scene[row].clip_slot(column).set_launch_button(self._grid[column][row]) if(self._r_function_mode._mode_index in range(0,3)): self._grid[column + 4][5].set_on_value(MUTE[self._rgb]) self._mixer2.channel_strip(column).set_mute_button(self._grid[column + 4][5]) self._grid[column + 4][6].set_on_value(ARM[self._rgb]) self._mixer2.channel_strip(column).set_arm_button(self._grid[column + 4][6]) for row in range(5): self._scene2[row].clip_slot(column).set_launch_button(self._grid[column + 4][row]) elif(self._r_function_mode._mode_index is 3): self._grid[column + 4][5].set_on_value(MUTE[self._rgb]) self._mixer2.return_strip(column).set_mute_button(self._grid[column + 4][5]) for row in range(5): self._grid[column + 4][row].send_value(USER1_COLOR[self._rgb], True) self._grid[column + 4][row].set_channel(RIGHT_USER1_CHANNEL) self._grid[column + 4][row].set_identifier(RIGHT_USER1_MAP[column][row]) self._grid[column + 4][row].set_enabled(False) #this has to happen for translate to work #self._session_zoom2.set_ignore_buttons(True) if(self._r_function_mode._mode_index is 0): for index in range(4): self._grid[index + 4][7].send_value(SEND_RESET[self._rgb], True) self._send_reset.set_buttons(tuple(self._grid[index + 4][7] for index in range(4))) def zoom_off_m(self): self.deassign_dials() for column in range(8): self._grid[column][5].set_on_value(MUTE[self._rgb]) self._mixer.channel_strip(column).set_mute_button(self._grid[column][5]) self._grid[column][6].set_on_value(ARM[self._rgb]) self._mixer.channel_strip(column).set_arm_button(self._grid[column][6]) for row in range(5): self._scene_main[row].clip_slot(column).set_launch_button(self._grid[column][row]) #self._session_zoom.set_button_matrix(self._matrix) def zoom_left(self): track_stop_buttons = [] track_stop_buttons2 = [] for index in range(4): self._grid[index][6].set_off_value(TRACK_STOP[self._rgb]) track_stop_buttons.append(self._grid[index][6]) self._grid[index + 4][6].set_off_value(TRACK_STOP[self._rgb]) track_stop_buttons2.append(self._grid[index + 4][6]) for index in range(5): self._grid[7][index].set_off_value(SCENE_LAUNCH[self._rgb]) self._scene[index].set_launch_button(self._grid[7][index]) self._session.set_stop_track_clip_buttons(tuple(track_stop_buttons)) self._session2.set_stop_track_clip_buttons(tuple(track_stop_buttons2)) self._session_zoom.set_button_matrix(self._matrix) self._grid[0][5].set_on_value(RECORD[self._rgb]) self._transport.set_record_button(self._grid[0][5]) self._grid[1][5].set_on_value(OVERDUB[self._rgb]) self._transport.set_overdub_button(self._grid[1][5]) self._grid[2][5].set_on_value(LOOP[self._rgb]) self._transport.set_loop_button(self._grid[2][5]) self._grid[3][5].set_on_value(STOP_ALL[self._rgb]) self._session.set_stop_all_clips_button(self._grid[3][5]) for index in range(4): self._grid[index + 4][5].send_value(SEND_RESET[self._rgb], True) self._send_reset.set_buttons(tuple(self._grid[index + 4][5] for index in range(4))) for index in range(4): self._grid[index + 4][7].set_off_value(DEVICE_SELECT[self._rgb]) self._device_selector.assign_buttons(tuple(self._grid[index + 4][7] for index in range(4)), 4) def zoom_right(self): track_stop_buttons = [] track_stop_buttons2 = [] for index in range(4): self._grid[index][6].set_off_value(TRACK_STOP[self._rgb]) track_stop_buttons.append(self._grid[index][6]) for index in range(5): self._grid[7][index].set_off_value(SCENE_LAUNCH[self._rgb]) self._scene2[index].set_launch_button(self._grid[7][index]) self._session.set_stop_track_clip_buttons(tuple(track_stop_buttons)) if(self._r_function_mode._mode_index < 3): for index in range(4): self._grid[index + 4][6].set_off_value(TRACK_STOP[self._rgb]) track_stop_buttons2.append(self._grid[index + 4][6]) self._session2.set_stop_track_clip_buttons(tuple(track_stop_buttons2)) self._session_zoom2.set_button_matrix(self._matrix) self._grid[0][5].set_on_value(RECORD[self._rgb]) self._transport.set_record_button(self._grid[0][5]) self._grid[1][5].set_on_value(OVERDUB[self._rgb]) self._transport.set_overdub_button(self._grid[1][5]) self._grid[2][5].set_on_value(LOOP[self._rgb]) self._transport.set_loop_button(self._grid[2][5]) self._grid[3][5].set_on_value(STOP_ALL[self._rgb]) self._session.set_stop_all_clips_button(self._grid[3][5]) for index in range(4): self._grid[index + 4][5].send_value(SEND_RESET[self._rgb], True) self._send_reset.set_buttons(tuple(self._grid[index + 4][5] for index in range(4))) for index in range(4): self._grid[index][7].set_off_value(DEVICE_SELECT[self._rgb]) self._device_selector.assign_buttons(tuple(self._grid[index][7] for index in range(4)), 0) def zoom_main(self): track_stop_buttons = [] for index in range(8): self._grid[index][6].set_on_value(TRACK_STOP[self._rgb]) track_stop_buttons.append(self._grid[index][6]) for index in range(5): self._grid[7][index].set_on_value(SCENE_LAUNCH[self._rgb]) self._scene_main[index].set_launch_button(self._grid[7][index]) self._session_main.set_stop_track_clip_buttons(tuple(track_stop_buttons)) self._session_zoom_main.set_button_matrix(self._matrix) self._grid[0][5].set_on_value(RECORD[self._rgb]) self._transport.set_record_button(self._grid[0][5]) self._grid[1][5].set_on_value(OVERDUB[self._rgb]) self._transport.set_overdub_button(self._grid[1][5]) self._grid[2][5].set_on_value(LOOP[self._rgb]) self._transport.set_loop_button(self._grid[2][5]) self._grid[3][5].set_on_value(STOP_ALL[self._rgb]) self._session.set_stop_all_clips_button(self._grid[3][5]) for index in range(4): self._grid[index + 4][5].send_value(SEND_RESET[self._rgb], True) self._send_reset.set_buttons(tuple(self._grid[index + 4][5] for index in range(4))) for index in range(4): self._grid[index + 4][7].set_off_value(DEVICE_SELECT[self._rgb]) self._device_selector.assign_buttons(tuple(self._grid[index + 4][7] for index in range(4)), 4) """function mode callbacks""" def l_function_update(self): mode = self._l_function_mode._mode_index #if(self._l_function_mode.is_enabled() is False): # self._l_function_mode.set_mode_buttons(None) if(self._l_function_mode.is_enabled() is True): if(len(self._l_function_mode._modes_buttons) is 0): for index in range(4): self._mixer.channel_strip(index).set_select_button(None) buttons = [] for index in range(4): buttons.append(self._grid[index][7]) self._l_function_mode.set_mode_buttons(tuple(buttons)) if(self._shift_mode._mode_index is 2): for index in range(4): if(mode != index): self._grid[index][7].turn_off() else: self._grid[index][7].turn_on() if(mode is 0): self.assign_device_dials() self.show_message('Mixer Split:Dials Device Mode') elif(mode is 1): self.assign_send_dials() self.show_message('Mixer Split:Dials Send Mode') elif(mode is 2): self.assign_split_volume_dials() self.show_message('Mixer Split:Dials Volume Mode') elif(mode is 3): self.assign_user_dials() self.show_message('Mixer Split:Dials User Map Mode') def r_function_update(self): mode = self._r_function_mode._mode_index #if(self._r_function_mode.is_enabled() is False): # self._r_function_mode.set_mode_buttons(None) #self._session2.set_show_highlight(False) #self._session._highlighting_callback(self._session._track_offset, self._session._scene_offset, 4, 5, 1) if(self._r_function_mode.is_enabled() is True): if(len(self._r_function_mode._modes_buttons) is 0): for index in range(4): self._mixer2.channel_strip(index).set_select_button(None) buttons = [] for index in range(4): buttons.append(self._grid[index + 4][7]) self._r_function_mode.set_mode_buttons(tuple(buttons)) if(self._shift_mode._mode_index is 3): for index in range(4): if(mode != index): self._grid[index + 4][7].turn_off() else: self._grid[index + 4][7].turn_on() self._session2.set_offsets(int(self._mem[mode]), self._session2._scene_offset) self.show_message('Mixer Split: Track Offset' + str(RIGHT_MODE_OFFSETS[mode])) def m_function_update(self): mode = self._m_function_mode._mode_index #if(self._m_function_mode.is_enabled() is False): # self._m_function_mode.set_mode_buttons(None) #self._session.set_show_highlight(False) #self._session2.set_show_highlight(False) #self._session_main._highlighting_callback(self._session_main._track_offset, self._session_main._scene_offset, 8, 5, 1) if(self._m_function_mode.is_enabled() is True): if(len(self._m_function_mode._modes_buttons) is 0): for index in range(8): self._mixer.channel_strip(index).set_select_button(None) buttons = [] for index in range(4): buttons.append(self._grid[index][7]) self._m_function_mode.set_mode_buttons(tuple(buttons)) if(self._shift_mode._mode_index is 4): for index in range(4): if(mode != index): self._grid[index][7].turn_off() else: self._grid[index][7].turn_on() if(mode is 0): self.assign_device_dials() self.show_message('Mixer Linked:Dials Device Mode') elif(mode is 1): self.assign_send_dials() self.show_message('Mixer Linked:Dials Send Mode') elif(mode is 2): self.assign_volume_dials() self.show_message('Mixer Linked:Dials Volume Mode') elif(mode is 3): self.assign_user_dials() self.show_message('Mixer Linked:Dials User Map Mode') def shift_update(self): self._clutch_device_selection = True #self.allow_updates(False) #if(not self._in_build_midi_map): # self.set_suppress_rebuild_requests(True) self.deassign_channel_select_buttons() self.deassign_matrix() self.deassign_menu() if(self._monomod_mode._mode_index is 0): #if monomod is not on if(self._shift_mode._mode_index is 0): #if no shift is pressed self._shift_mode._mode_toggle1.turn_off() self._shift_mode._mode_toggle2.turn_off() if(self.split_mixer() is False): self.set_split_mixer(True) for zoom in self._zooms: zoom._on_zoom_value(0) self.zoom_off() self._device_selector.set_enabled(False) for mode in self._function_modes: mode.set_enabled(False) self.assign_channel_select_buttons() #self._recalculate_selected_channel() #self.assign_transport_to_menu() self.assign_session_nav_to_menu() self.l_function_update() self.r_function_update() self.assign_crossfader() self.set_highlighting_session_component(self._session) self._session._do_show_highlight() #self._session.set_show_highlight(True) elif(self._shift_mode._mode_index is 1): #if no shift is pressed, but mixer is linked self._shift_mode._mode_toggle1.turn_on() self._shift_mode._mode_toggle2.turn_on() if(self.split_mixer() is True): self.set_split_mixer(False) for zoom in self._zooms: zoom._on_zoom_value(0) self.zoom_off_m() self._device_selector.set_enabled(False) for mode in self._function_modes: mode.set_enabled(False) self.assign_main_channel_select_buttons() self.assign_session_main_nav_to_menu() self.m_function_update() self.assign_crossfader() self.set_highlighting_session_component(self._session_main) self._session_main._do_show_highlight() elif(self._shift_mode._mode_index > 1): #if a shift is pressed self.assign_device_nav_to_menu() self.deassign_channel_select_buttons() if(self._shift_mode._mode_index is 2): #if shift left self._shift_mode._mode_toggle1.turn_on() self.zoom_left() self._session_zoom._on_zoom_value(1) self._session.set_enabled(True) #this is a workaround so that the stop buttons still function self._l_function_mode.set_enabled(True) self.set_highlighting_session_component(self._session) self._session._do_show_highlight() elif(self._shift_mode._mode_index is 3): #if shift right self._shift_mode._mode_toggle2.turn_on() self.zoom_right() self._session_zoom2._on_zoom_value(1) self._session2.set_enabled(True) #this is a workaround so that the stop buttons still function self._r_function_mode.set_enabled(True) self.assign_master_fader() if(self._r_function_mode._mode_index < 4): self.set_highlighting_session_component(self._session2) self._session2._do_show_highlight() elif(self._shift_mode._mode_index is 4): #if either shift pressed while mixer is linked self._shift_mode._mode_toggle1.turn_on() self._shift_mode._mode_toggle2.turn_on() self.zoom_main() self._session_zoom_main._on_zoom_value(1) self._session_main.set_enabled(True) #this is a workaround so that the stop buttons still function self._m_function_mode.set_enabled(True) self.assign_master_fader() self.set_highlighting_session_component(self._session_main) self._session_main._do_show_highlight() self._device_selector.set_enabled(True) self.allow_updates(True) #self.set_suppress_rebuild_requests(False) self._clutch_device_selection = False if(self._shift_mode._mode_index < 2): self._monobridge._send('touch', 'off') else: self._monobridge._send('touch', 'on') def monomod_mode_update(self): if (self._monomod_mode._mode_index == 0) or (self._host._active_client == None): self._host.set_enabled(False) self._host._set_button_matrix(None) self._host._set_nav_buttons(None) self._host._set_lock_button(None) self._host._set_alt_button(None) self._host._set_shift_button(None) self._livid.turn_off() self._shift_mode.set_mode_toggle(self._shift_l, self._shift_r) self._shift_mode.update() #self._session._reassign_scenes() elif(self._monomod_mode._mode_index == 1): self._livid.turn_on() self.deassign_matrix() self.deassign_menu() self._monomod.reset() self._host._set_button_matrix(self._monomod) self._host._set_nav_buttons(self._menu[0:4]) self._host._set_lock_button(self._shift_l) self._host._set_alt_button(self._shift_r) self._host._set_shift_button(self._livid) self._shift_mode.set_mode_toggle(None, None) self._host.set_enabled(True) self._shift_mode.update() #self.show_message('Monomod grid enabled') """left control management methods""" def deassign_dials(self): for index in range(8): self._dial[index].use_default_message() self._dial[index].release_parameter() self._dial[index].set_enabled(True) if(self._device._parameter_controls != None): for control in self._device._parameter_controls: control.release_parameter() self._device._parameter_controls = None self._mixer.selected_strip().set_send_controls(None) self._mixer.selected_strip().set_volume_control(None) for track in range(4): self._mixer.channel_strip(track).set_volume_control(None) self._mixer.channel_strip(track+4).set_volume_control(None) self._mixer2.channel_strip(track).set_volume_control(None) self._mixer2.return_strip(track).set_volume_control(None) def assign_device_dials(self): self._ohm_type = OHM_TYPE[0] self._ohm = OHM_VALUE[0] self.deassign_dials() self._device.set_enabled(True) device_param_controls = [] for index in range(8): device_param_controls.append(self._dial[index]) self._device.set_parameter_controls(tuple(device_param_controls)) self._mixer.selected_strip().set_volume_control(self._fader[0]) def assign_send_dials(self): self._ohm_type = OHM_TYPE[1] self._ohm = OHM_VALUE[1] self.deassign_dials() dials = [] for index in range(4): dials.append(self._dial[index]) for index in range(4): if(self._mixer2.return_strip(index)): self._mixer2.return_strip(index).set_volume_control(self._dial[index + 4]) self._mixer.selected_strip().set_send_controls(tuple(dials)) self._mixer.selected_strip().set_volume_control(self._fader[0]) def assign_volume_dials(self): self._ohm_type = OHM_TYPE[2] self._ohm = OHM_VALUE[2] self.deassign_dials() for track in range(8): self._mixer.channel_strip(track).set_volume_control(self._dial[track]) self._mixer.selected_strip().set_volume_control(self._fader[0]) def assign_split_volume_dials(self): self._ohm_type = OHM_TYPE[2] self._ohm = OHM_VALUE[2] self.deassign_dials() for track in range(4): self._mixer.channel_strip(track).set_volume_control(self._dial[track]) self._mixer2.channel_strip(track).set_volume_control(self._dial[track+4]) self._mixer.selected_strip().set_volume_control(self._fader[0]) def assign_user_dials(self): self._ohm_type = OHM_TYPE[3] self._ohm = OHM_VALUE[3] self.deassign_dials() for index in range(8): self._dial[index].set_channel(L_USER_DIAL_CHAN) self._dial[index].set_identifier(L_USER_DIAL_MAP[index]) self._dial[index].set_enabled(False) self._mixer.selected_strip().set_volume_control(self._fader[0]) """menu button management methods""" def deassign_menu(self): self._device.set_lock_button(None) self._device.set_on_off_button(None) self._device_navigator.set_device_nav_buttons(None, None) self._device.set_bank_nav_buttons(None, None) self._transport.set_play_button(None) self._transport.set_record_button(None) self._transport.set_stop_button(None) self._transport.set_loop_button(None) self._transport.set_overdub_button(None) self._session.set_stop_all_clips_button(None) self._transport.set_play_button(None) self._transport.set_stop_button(None) self._session_main.set_track_bank_buttons(None, None) self._session_main.set_scene_bank_buttons(None, None) def assign_device_nav_to_menu(self): self._device_navigator.set_device_nav_buttons(self._menu[2], self._menu[3]) self._device.set_bank_nav_buttons(self._menu[0], self._menu[1]) def assign_transport_to_menu(self): self._transport.set_play_button(self._menu[0]) self._transport.set_record_button(self._menu[2]) self._transport.set_stop_button(self._menu[1]) session.set_stop_all_clips_button(self._menu[3]) def assign_session_nav_to_menu(self): self._session.set_track_bank_buttons(self._menu[3], self._menu[2]) self._session.set_scene_bank_buttons(self._menu[1], self._menu[0]) def assign_monomod_shift_to_menu(self): self._device_navigator.set_device_nav_buttons(self._menu[3], self._menu[2]) self._device.set_bank_nav_buttons(self._menu[1], self._menu[0]) def assign_session_bank_to_menu(self): self._session.set_track_bank_buttons(self._menu[3], self._menu[2]) self._session.set_scene_bank_buttons(self._menu[1], self._menu[0]) def assign_session2_bank_to_menu(self): self._session2.set_track_bank_buttons(self._menu[3], self._menu[2]) self._session2.set_scene_bank_buttons(self._menu[1], self._menu[0]) def assign_session_main_nav_to_menu(self): self._session_main.set_track_bank_buttons(self._menu[3], self._menu[2]) self._session_main.set_scene_bank_buttons(self._menu[1], self._menu[0]) """channel selection management methods""" def deassign_channel_select_buttons(self): for index in range(8): if(self._mixer.channel_strip(index)): self._mixer.channel_strip(index).set_select_button(None) self._grid[index][7].release_parameter() for index in range(4): self._mixer2.channel_strip(index).set_select_button(None) self._mixer2.return_strip(index).set_select_button(None) self._mixer2.master_strip().set_select_button(None) self._grid[index + 4][7].release_parameter() def assign_channel_select_buttons(self): for index in range(4): #if(self._mixer.channel_strip(index)): self._grid[index][7].set_on_off_values(127, 0) self._mixer.channel_strip(index).set_select_button(self._grid[index][7]) if(self._r_function_mode._mode_index < 3): for index in range(4): self._grid[index][7].set_on_off_values(127, 0) self._mixer2.channel_strip(index).set_select_button(self._grid[index + 4][7]) else: for index in range(4): self._grid[index][7].set_on_off_values(1, 0) self._mixer2.return_strip(index).set_select_button(self._grid[index + 4][7]) def assign_return_select_buttons(self): for index in range(4): self._grid[index + 4][7].set_off_value(0) if(self._mixer.channel_strip(index)): self._grid[index + 4][7].set_on_value(1) self._mixer.channel_strip(index).set_select_button(self._grid[index + 4][7]) def assign_l_channel_select_buttons(self): self._mixer.set_select_buttons(None, None) self._session.set_select_buttons(None, None) for index in range(4): self._grid[index][7].set_off_value(0) if(self._mixer.channel_strip(index)): self._mixer.channel_strip(index).set_select_button(self._grid[index][7]) def assign_r_channel_select_buttons(self): self._mixer2.set_select_buttons(None, None) self._session2.set_select_buttons(None, None) for index in range(4): self._grid[index + 4][7].set_off_value(0) if(self._mixer2.channel_strip(index)): self._mixer2.channel_strip(index).set_select_button(self._grid[index + 4][7]) def assign_main_channel_select_buttons(self): for index in range(8): self._grid[index][7].set_off_value(0) if(self._mixer.channel_strip(index)): self._grid[index][7].set_on_value(127) self._mixer.channel_strip(index).set_select_button(self._grid[index][7]) def assign_master_fader(self): self._mixer.set_crossfader_control(None) self._mixer.master_strip().set_volume_control(self._fader[1]) def assign_crossfader(self): self._mixer.master_strip().set_volume_control(None) self._mixer.set_crossfader_control(self._fader[1]) """called on timer""" def update_display(self): super(BlockMod, self).update_display() if(self._timer == 0): self._shift_pressed_timer = -12 def strobe(self): if(self._ohm_type != 'static'): if(self._ohm_type is 'pulse'): self._ohm = int(math.fabs(((self._timer * 8) % 64) -32) +32) if(self._ohm_type is 'up'): self._ohm = int(((self._timer * 4) % 64) + 16) if(self._ohm_type is 'down'): self._ohm = int(math.fabs(int(((self._timer * 4) % 64) - 64)) + 16) self._send_midi(tuple([176, 63, int(self._ohm)])) self._send_midi(tuple([176, 31, int(self._ohm)])) def handle_sysex(self, midi_bytes): pass def _on_session_offset_changes(self): if self._r_function_mode._mode_index in range(0,4): self._mem[int(self._r_function_mode._mode_index)] = self._session2.track_offset() # a
class Codec(ControlSurface): __module__ = __name__ __doc__ = " MonoCode controller script " def __init__(self, c_instance): """everything except the '_on_selected_track_CHANNELged' override and 'disconnect' runs from here""" ControlSurface.__init__(self, c_instance) self.set_suppress_rebuild_requests( True ) # Turn off rebuild MIDI map until after we're done setting up self._monomod_version = 'b995' self._version_check = 'b995' self._host_name = 'Codec' self._color_type = 'Monochrome' self._link_mixer = LINK_MIXER self.log_message('<<<<<<<<<<<<<<<<<<<<<<<<< Codec ' + str(self._monomod_version) + ' log opened >>>>>>>>>>>>>>>>>>>>>>>>>') self._hosts = [] self._linked_script = None self._local_ring_control = True self.set_local_ring_control(1) self._setup_controls() self._last_device = None self._device_list = [None, None, None, None] self._device_select_buttons = None self._last_device_component = None self._timer = 0 self._touched = 0 self._locked = False self.flash_status = 1 self._shift_button = None self._shift_pressed = 0 self._shift_pressed_timer = 0 self._shift_thresh = SHIFT_THRESH self._use_device_selector = USE_DEVICE_SELECTOR self._device_selection_follows_track_selection = FOLLOW self.set_suppress_rebuild_requests( False) #Turn rebuild back on, now that we're done setting up self.song().view.add_selected_track_listener( self._update_selected_device) self.show_message('Codec Control Surface Loaded') #self.local_ring_control(True) #self.set_absolute_mode(True) self._setup_monobridge() self._setup_device_controls() self._setup_special_device_control() self._device.append( self._special_device ) #necessary for device browsing to work with special device self._setup_device_chooser() self._setup_mixer_controls() self._setup_monomod() self._setup_modes() self._setup_device_selector() self._setup_send_reset() self._setup_default_buttons() self._initialize_code() self.request_rebuild_midi_map() #Monomodular.create_instance(c_instance) #self._setup_disconnect() """script initialization methods""" def _initialize_code(self): self._send_midi(factoryreset) self._send_midi(btn_channels) self._send_midi(enc_channels) #pass def _setup_monobridge(self): self._monobridge = MonoBridgeElement(self) self._monobridge.name = 'MonoBridge' def _setup_controls(self): is_momentary = True self._livid = FlashingButtonElement(is_momentary, MIDI_NOTE_TYPE, CHANNEL, LIVID, 'Livid_Button', self) self._dial = [None for index in range(8)] for column in range(8): self._dial[column] = [None for index in range(4)] for row in range(4): self._dial[column][row] = CodecEncoderElement( MIDI_CC_TYPE, CHANNEL, CODE_DIALS[row][column], Live.MidiMap.MapMode.absolute, 'Dial_' + str(column) + '_' + str(row), (column + (row * 8)), self) #CODE_DIALS[row][column] self._button = [None for index in range(8)] for column in range(8): self._button[column] = [None for index in range(4)] for row in range(4): self._button[column][row] = FlashingButtonElement( is_momentary, MIDI_NOTE_TYPE, CHANNEL, CODE_BUTTONS[row][column], 'Button_' + str(column) + '_' + str(row), self) self._column_button = [None for index in range(8)] for index in range(8): self._column_button[index] = FlashingButtonElement( is_momentary, MIDI_NOTE_TYPE, CHANNEL, CODE_COLUMN_BUTTONS[index], 'Column_Button_' + str(index), self) self._row_button = [None for index in range(4)] for index in range(4): self._row_button[index] = FlashingButtonElement( is_momentary, MIDI_NOTE_TYPE, CHANNEL, CODE_ROW_BUTTONS[index], 'Row_Button_' + str(index), self) self._dial_matrix = EncoderMatrixElement(self) self._dial_matrix.name = 'Encoder_Matrix' for row in range(4): dial_row = tuple([self._dial[column][row] for column in range(8)]) self._dial_matrix.add_row(dial_row) self._button_matrix = ButtonMatrixElement() self._button_matrix.name = 'Button_Matrix' for row in range(4): button_row = [self._button[column][row] for column in range(8)] button_row.append(self._row_button[row]) self._button_matrix.add_row(tuple(button_row)) self._button_matrix.add_row(tuple(self._column_button + [self._livid])) def _setup_modes(self): self._monomod_mode = MonomodModeComponent(self) self._monomod_mode.name = 'Monomod_Mode' self._monomod_mode.update = self._mod_mode_update #self._monomod_mode.set_mode_toggle(self._livid) self.set_shift_button(self._livid) self._shift_mode = ShiftModeComponent(self, self._shift_update) self._shift_mode.name = 'Shift_Mode' self._shift_mode.set_mode_buttons( tuple([ self._row_button[0], self._row_button[1], self._row_button[2], self._row_button[3] ])) def _setup_transport_control(self): self._transport = TransportComponent() self._transport.name = 'Transport' def _setup_monomod(self): self._host = MonomodComponent(self) self._host.name = 'Monomod_Host' self._host._set_dial_matrix(self._dial_matrix, self._button_matrix) self.hosts = [self._host] encs = [] for row in range(4): for col in range(8): encs.append(self._dial[col][row]) self._host._set_parameter_controls(encs) def _setup_mixer_controls(self): is_momentary = True self._num_tracks = (8) self._session = SessionComponent(self._num_tracks, 0) self._session.name = 'Session' self._mixer = MixerComponent(self._num_tracks, 0, False, False) self._mixer.name = 'Mixer' self._mixer._next_track_value = self._mixer_next_track_value( self._mixer) self._mixer._prev_track_value = self._mixer_prev_track_value( self._mixer) self._mixer.set_track_offset( 0) #Sets start point for mixer strip (offset from left) #for index in range(8): #use the bottom row of encoders for volume, so add 24 to offset the index # self._mixer.channel_strip(index).set_volume_control(self._dial[index+24]) for index in range(8): self._mixer.channel_strip( index).name = 'Mixer_ChannelStrip_' + str(index) self._mixer.channel_strip(index)._invert_mute_feedback = True self._mixer.channel_strip( index)._mute_value = self._channelstrip_mute_value( self._mixer.channel_strip(index)) self._mixer.channel_strip( index)._solo_value = self._channelstrip_solo_value( self._mixer.channel_strip(index)) #mixer.channel_strip(index).set_select_button(ButtonElement(is_momentary, MIDI_NOTE_TYPE, CH, track_select_notes[index])) self.song().view.selected_track = self._mixer.channel_strip( 0 )._track #set the selected strip to the first track, so that we don't, for example, try to assign a button to arm the master track, which would cause an assertion error self._session.set_mixer(self._mixer) def _setup_device_controls(self): self._device = [None for index in range(4)] for index in range(4): self._device[index] = CodecDeviceComponent(self) self._device[index].name = 'CodecDevice_Component_' + str(index) device_param_controls = [] for control in range(8): device_param_controls.append(self._dial[control][index]) self._device[index].set_on_off_button(self._button[1][index]) self._device[index].set_lock_button(self._button[2][index]) self._device[index].set_bank_nav_buttons(self._button[4][index], self._button[5][index]) self._device[index].set_nav_buttons(self._button[6][index], self._button[7][index]) self._device[index].set_parameter_controls( tuple(device_param_controls)) self.set_device_component(self._device[0]) self._last_device_component = self._device[0] def _setup_special_device_control(self): self._special_device = SpecialCodecDeviceComponent(self) self._special_device.name = 'SpecialCodecDeviceComponent' self._special_device.set_on_off_button(self._button[1][0]) self._special_device.set_lock_button(self._button[2][0]) self._special_device.set_bank_nav_buttons(self._button[4][0], self._button[5][0]) self._special_device.set_nav_buttons(self._button[6][0], self._button[7][0]) device_param_controls = [] for row in range(4): for column in range(8): device_param_controls.append(self._dial[column][row]) self._special_device.set_parameter_controls( tuple(device_param_controls)) def _setup_device_chooser(self): self._selected_device = self._device[0] self._last_selected_device = self._device[0] self._device_select_buttons = [ self._button[0][index] for index in range(4) ] for button in self._device_select_buttons: button.add_value_listener(self._device_select_value, True) def _setup_device_selector(self): self._device_selector = CodecDeviceSelectorComponent( self, 'c', self._device + [self._special_device]) self._device_selector.name = 'Device_Selector' self._device_selector.set_mode_buttons(self._column_button) #self._device_selector.set_mode_toggle(self._livid) def _setup_send_reset(self): self._send_reset = CodecResetSendsComponent(self) self._send_reset.set_buttons(self._button) def _setup_default_buttons(self): self._value_default = ParameterDefaultComponent(self) buttons = [] dials = [] for column in self._button: for button in column: buttons.append(button) for column in self._dial: for dial in column: dials.append(dial) self._value_default.set_buttons(buttons) self._value_default.set_dials(dials) """multiple device support""" def _device_select_value(self, value, sender): #self.log_message('device_select_value ' + str(value) + ' ' + str(self._device_select_buttons.index(sender))) if not self._shift_pressed: if sender.is_momentary or value > 0: if self._shift_mode._mode_index == 2: self.set_device_component(self._device[ self._device_select_buttons.index(sender)]) self._last_device_component = self._device_component if self._device_component != None and isinstance( self._device_component._device, Live.Device.Device): if self._device_component.find_track( self._device_component._device) == self.song( ).view.selected_track: self._device_component.display_device() """livid double press mechanism""" def set_shift_button(self, button): assert ((button == None) or (isinstance(button, FlashingButtonElement))) if self._shift_button != None: self._shift_button.remove_value_listener(self._shift_value) self._shift_button = button if self._shift_button != None: self._shift_button.add_value_listener(self._shift_value) def _shift_value(self, value): self._shift_pressed = int(value != 0) if self._shift_pressed > 0: self._send_midi(SLOWENCODER) if (self._shift_pressed_timer + self._shift_thresh) > self._timer: #if(self._host.is_enabled() != True) self._monomod_mode.set_mode( abs(self._monomod_mode._mode_index - 1)) #else: # self._monomod_mode.set_mode(0) self._shift_pressed_timer = self._timer % 256 else: self._send_midi(NORMALENCODER) def _mod_mode_update(self): if (self._monomod_mode._mode_index == 0): self._host._set_shift_button(None) self._host.set_enabled(False) self._dial_matrix.reset() self._shift_mode.set_enabled(True) self._shift_update() self.request_rebuild_midi_map() self._livid.turn_off() elif (self._monomod_mode._mode_index == 1): self._shift_mode.set_enabled(False) self._deassign_all() self._dial_matrix.reset() self._button_matrix.reset() self._livid.turn_on() if not self._host._active_client == None: self._host.set_enabled(True) self._host._set_shift_button(self._livid) else: self._assign_alternate_mappings(1) self.request_rebuild_midi_map() """Mode Functions""" def _shift_update(self): if (self._shift_mode.is_enabled()): self.allow_updates(False) if (not self._in_build_midi_map): self.set_suppress_rebuild_requests(True) self._deassign_all() if (self._shift_mode._mode_index is 0): self._assign_volume() elif (self._shift_mode._mode_index is 1): self._assign_sends() elif (self._shift_mode._mode_index is 2): self._assign_devices() elif (self._shift_mode._mode_index is 3): self._assign_special_device() for index in range(self._shift_mode.number_of_modes()): if index == self._shift_mode._mode_index: self._shift_mode._modes_buttons[index].turn_on() else: self._shift_mode._modes_buttons[index].turn_off() self.allow_updates(True) self.set_suppress_rebuild_requests(False) self.request_rebuild_midi_map() def _deassign_all(self): self._assign_alternate_mappings(0) self._device_selector.set_enabled(False) for index in range(8): self._mixer.channel_strip(index).set_volume_control(None) self._mixer.channel_strip(index).set_pan_control(None) self._mixer.channel_strip(index).set_send_controls( tuple([None, None, None, None])) for index in range(4): self._device[index].set_enabled(False) self._device[index]._parameter_controls = None #self._device_navigator[index].set_enabled(False) self._special_device.set_enabled(False) self._special_device._parameter_controls = None self._device_selector.set_enabled(False) self._deassign_buttons() for control in self.controls: control.reset() self.request_rebuild_midi_map() def _deassign_buttons(self): for index in range(8): self._mixer.channel_strip(index).set_select_button(None) self._mixer.channel_strip(index).set_solo_button(None) self._mixer.channel_strip(index).set_mute_button(None) self._mixer.set_select_buttons(None, None) self._send_reset.set_enabled(False) def _assign_volume(self): for index in range(8): self._mixer.channel_strip(index).set_volume_control( self._dial[index][3]) self._mixer.channel_strip(index).set_pan_control( self._dial[index][2]) self._mixer.channel_strip(index).set_send_controls( tuple([self._dial[index][0], self._dial[index][1]])) self._mixer.channel_strip(index).set_select_button( self._column_button[index]) self._mixer.channel_strip(index).set_solo_button( self._button[index][2]) self._mixer.channel_strip(index).set_mute_button( self._button[index][3]) self._mixer.set_select_buttons(self._button[7][0], self._button[6][0]) def _assign_sends(self): for index in range(8): self._mixer.channel_strip(index).set_send_controls( tuple([ self._dial[index][0], self._dial[index][1], self._dial[index][2], self._dial[index][3] ])) self._mixer.channel_strip(index).set_select_button( self._column_button[index]) self._send_reset.set_enabled(True) def _assign_devices(self): self.set_device_component(self._last_device_component) self._device_select_value( 1, self._device_select_buttons[self._device.index( self._device_component)]) for index in range(4): device_param_controls = [] for control in range(8): device_param_controls.append(self._dial[control][index]) self._device[index].set_parameter_controls( tuple(device_param_controls)) self._device[index].set_enabled(True) self._device_selector.set_enabled(self._use_device_selector) if not self._use_device_selector: for index in range(8): self._mixer.channel_strip(index).set_select_button( self._column_button[index]) def _assign_special_device(self): self.set_device_component(self._special_device) device_param_controls = [] for row in range(4): for column in range(8): device_param_controls.append(self._dial[column][row]) self._special_device.set_parameter_controls( tuple(device_param_controls)) self._special_device.set_enabled(True) self._device_selector.set_enabled(self._use_device_selector) if not self._use_device_selector: for index in range(8): self._mixer.channel_strip(index).set_select_button( self._column_button[index]) def _assign_alternate_mappings(self, chan): for column in self._dial: for control in column: control.set_channel(chan) control.set_enabled(chan is 0) for column in self._button: for control in column: control.set_channel(chan) control.set_enabled(chan is 0) for control in self._column_button: control.set_channel(chan) control.set_enabled(chan is 0) for control in self._row_button: control.set_channel(chan) control.set_enabled(chan is 0) """general functionality""" 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 def connect_script_instances(self, instanciated_scripts): found = False for s in instanciated_scripts: if '_codec_version' in dir(s): if s._codec_version == self._version_check: if s._host_name == ('MonOhm'): self.log_message('found codec version ' + str(s._codec_version) + ' in script ' + str(s._host_name)) found = True self._linked_script = s self._linked_script._update_linked_device_selection = self._update_linked_device_selection if not self._session._is_linked( ) and self._link_mixer is True: self._session.set_offsets(LINK_OFFSET[0], LINK_OFFSET[1]) self._session._link() else: self.log_message('version mismatch: Monomod version ' + str(self._version_check) + ' vs. Host version ' + str(s._codec_version)) if found == False: for s in instanciated_scripts: if '_codec_version' in dir(s): if s._codec_version == self._version_check: if s._host_name == 'BlockMod': self.log_message('found codec version ' + str(s._codec_version) + ' in script ' + str(s._host_name)) self._linked_script = s self._linked_script._update_linked_device_selection = self._update_linked_device_selection if not self._session._is_linked( ) and self._link_mixer is True: self._session.set_offsets(LINK_OFFSET[0], LINK_OFFSET[1]) self._session._link() else: self.log_message('version mismatch: Monomod version ' + str(self._version_check) + ' vs. Host version ' + str(s._codec_version)) #self.log_message('hosts: ' + str(self._hosts))""" def update_display(self): ControlSurface.update_display( self ) #since we are overriding this from the inherited method, we need to call the original routine as well self._timer = (self._timer + 1) % 256 if (self._timer == 0): self._shift_pressed_timer = -12 if (self._local_ring_control is False): self.send_ring_leds() self.flash() def handle_sysex(self, midi_bytes): #self._send_midi(tuple([240, 00, 01, 97, 04, 15, 01, 247])) #response = [long(0),long(0)] #self.log_message(response) pass def flash(self): if (self.flash_status > 0): for control in self.controls: if isinstance(control, FlashingButtonElement): control.flash(self._timer) def send_ring_leds(self): leds = [240, 0, 1, 97, 4, 31] for column in range(8): for row in range(4): wheel = self._dial[column][row] bytes = wheel._get_ring() leds.append(bytes[0]) leds.append(int(bytes[1]) + int(bytes[2])) #if(row == 1 and column == 0): # self.log_message(str(leds) + ' ' + str(bytes[0]) + ' ' + str(bytes[1]) + ' ' + str(bytes[2])) leds.append(247) self._send_midi(tuple(leds)) def set_absolute_mode(self, val=1): self._absolute_mode = (val != 0) if self._absolute_mode is True: self._send_midi( tuple([240, 0, 1, 97, 4, 17, 0, 0, 0, 0, 0, 0, 0, 0, 247])) else: self._send_midi( tuple([ 240, 0, 1, 97, 4, 17, 127, 127, 127, 127, 127, 127, 127, 127, 247 ])) def set_local_ring_control(self, val=1): self._local_ring_control = (val != 0) if (self._local_ring_control is True): #self._send_midi(tuple([240, 0, 1, 97, 4, 32, 0, 247])) self._send_midi(tuple([240, 0, 1, 97, 4, 8, 72, 247])) else: #self._send_midi(tuple([240, 0, 1, 97, 4, 32, 1, 247])) self._send_midi(tuple([240, 0, 1, 97, 4, 8, 64, 247])) def device_follows_track(self, val): self._device_selection_follows_track_selection = (val == 1) return self """m4l bridge""" def generate_strip_string(self, display_string): NUM_CHARS_PER_DISPLAY_STRIP = 12 if (not display_string): return (' ' * NUM_CHARS_PER_DISPLAY_STRIP) if ((len(display_string.strip()) > (NUM_CHARS_PER_DISPLAY_STRIP - 1)) and (display_string.endswith('dB') and (display_string.find('.') != -1))): display_string = display_string[:-2] if (len(display_string) > (NUM_CHARS_PER_DISPLAY_STRIP - 1)): for um in [' ', 'i', 'o', 'u', 'e', 'a']: while ((len(display_string) > (NUM_CHARS_PER_DISPLAY_STRIP - 1)) and (display_string.rfind(um, 1) != -1)): um_pos = display_string.rfind(um, 1) display_string = (display_string[:um_pos] + display_string[(um_pos + 1):]) else: display_string = display_string.center( (NUM_CHARS_PER_DISPLAY_STRIP - 1)) ret = u'' for i in range((NUM_CHARS_PER_DISPLAY_STRIP - 1)): if ((ord(display_string[i]) > 127) or (ord(display_string[i]) < 0)): ret += ' ' else: ret += display_string[i] ret += ' ' assert (len(ret) == NUM_CHARS_PER_DISPLAY_STRIP) return ret def notification_to_bridge(self, name, value, sender): if (isinstance(sender, CodecEncoderElement)): self._monobridge._send(sender.name, 'lcd_name', str(self.generate_strip_string(name))) self._monobridge._send(sender.name, 'lcd_value', str(self.generate_strip_string(value))) def touched(self): if not self._host.is_enabled(): if self._touched is 0: self._monobridge._send('touch', 'on') self.schedule_message(2, self.check_touch) self._touched += 1 def check_touch(self): if self._touched > 5: self._touched = 5 elif self._touched > 0: self._touched -= 1 if self._touched is 0: self._monobridge._send('touch', 'off') else: self.schedule_message(2, self.check_touch) def get_clip_names(self): clip_names = [] for scene in self._session._scenes: for clip_slot in scene._clip_slots: if clip_slot.has_clip() is True: clip_names.append(clip_slot._clip_slot) ##.clip.name) return clip_slot._clip_slot ##self.log_message(str(clip_slot._clip_slot.clip.name)) return clip_names """overrides""" def allow_updates(self, allow_updates): for component in self.components: component.set_allow_update(int(allow_updates != 0)) def set_device_component(self, device_component): if self._device_component != None: self._device_component._lock_callback = None assert (device_component != None) assert isinstance(device_component, DeviceComponent) self._device_component = device_component self._device_component._lock_callback = self._toggle_lock #old: self._device_component.set_lock_callback(self._toggle_lock) if self._device_select_buttons != None: for button in self._device_select_buttons: button.send_value( self._device_select_buttons.index(button) == self._device.index(self._device_component)) self._update_device_selection() return None def _update_selected_device(self): if self._device_selection_follows_track_selection is True: self._update_device_selection() return None def _update_linked_device_selection(self, device): #self.log_message('codec received ' + str(device.name)) if self._device_component != None and device != None: if not self._device_component.is_locked(): self._device_component.set_device(device) def _get_num_tracks(self): return self.num_tracks def _update_device_selection(self): #new method: code to verify #self.log_message('_update_device_selection') if self._device_component != None: if not self._device_component.is_locked(): 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) def _channelstrip_mute_value(self, channelstrip): def _mute_value(value): if not self._shift_pressed: self.log_message('shift not pressed') ChannelStripComponent._mute_value(channelstrip, value) return _mute_value def _channelstrip_solo_value(self, channelstrip): def _solo_value(value): if not self._shift_pressed: ChannelStripComponent._solo_value(channelstrip, value) return _solo_value def _mixer_next_track_value(self, mixer): def _next_track_value(value): if not self._shift_pressed: MixerComponent._next_track_value(mixer, value) return _next_track_value def _mixer_prev_track_value(self, mixer): def _prev_track_value(value): if not self._shift_pressed: MixerComponent._prev_track_value(mixer, value) return _prev_track_value
class AumPC40(APC40): def __init__(self, c_instance, *a, **k): super(AumPC40, self).__init__(c_instance, *a, **k) self._monomod_version = 'b996' self._host_name = 'AumPC' self._color_type = 'APC' self._timer = 0 self._touched = 0 self.flash_status = False with self.component_guard(): self._setup_monobridge() self._setup_mod() self._device_component._current_bank_details = self._make_current_bank_details(self._device_component) def disconnect(self): super(AumPC40, self).disconnect() rebuild_sys() def _create_controls(self): make_on_off_button = partial(make_button, skin=self._default_skin) make_color_button = partial(make_button, skin=self._color_skin) self._shift_button = make_button(0, 98, resource_type=PrioritizedResource, name='Shift_Button') self._right_button = make_button(0, 96, name='Bank_Select_Right_Button') self._left_button = make_button(0, 97, name='Bank_Select_Left_Button') self._up_button = make_button(0, 94, name='Bank_Select_Up_Button') self._down_button = make_button(0, 95, name='Bank_Select_Down_Button') self._session_matrix = ButtonMatrixElement(name='Button_Matrix') self._scene_launch_buttons = [ make_color_button(0, index + 82, name='Scene_%d_Launch_Button' % index, cs = self) for index in xrange(SESSION_HEIGHT) ] self._track_stop_buttons = [ make_color_button(index, 52, name='Track_%d_Stop_Button' % index, cs = self) for index in xrange(SESSION_WIDTH) ] self._stop_all_button = make_color_button(0, 81, name='Stop_All_Clips_Button', cs = self) self._matrix_rows_raw = [ [ make_color_button(track_index, scene_index + 53, name='%d_Clip_%d_Button' % (track_index, scene_index), cs = self) for track_index in xrange(SESSION_WIDTH) ] for scene_index in xrange(SESSION_HEIGHT) ] for row in self._matrix_rows_raw: self._session_matrix.add_row(row) self._selected_slot_launch_button = make_pedal_button(67, name='Selected_Slot_Launch_Button') self._selected_scene_launch_button = make_pedal_button(64, name='Selected_Scene_Launch_Button') self._volume_controls = [] self._arm_buttons = [] self._original_solo_buttons = [] self._original_mute_buttons = [] self._select_buttons = [] for index in xrange(MIXER_SIZE): self._volume_controls.append(make_slider(index, 7, name='%d_Volume_Control' % index, num=index, script = self)) self._arm_buttons.append(make_on_off_button(index, 48, name='%d_Arm_Button' % index, cs = self)) self._original_solo_buttons.append(make_on_off_button(index, 49, name='%d_Solo_Button' % index, cs = self)) self._original_mute_buttons.append(make_on_off_button(index, 50, name='%d_Mute_Button' % index, cs = self)) self._select_buttons.append(make_on_off_button(index, 51, name='%d_Select_Button' % index, cs = self)) self._crossfader_control = make_slider(0, 15, name='Crossfader', script = self) self._master_volume_control = make_slider(0, 14, name='Master_Volume_Control', script = self) self._master_select_button = make_on_off_button(0, 80, name='Master_Select_Button', cs = self) self._prehear_control = make_encoder(0, 47, name='Prehear_Volume_Control', script = self) self._device_bank_buttons = [] self._device_param_controls_raw = [] bank_button_labels = ('Clip_Track_Button', 'Device_On_Off_Button', 'Previous_Device_Button', 'Next_Device_Button', 'Detail_View_Button', 'Rec_Quantization_Button', 'Midi_Overdub_Button', 'Metronome_Button') for index in range(8): self._device_bank_buttons.append(make_on_off_button(0, 58 + index, name=bank_button_labels[index])) encoder_name = 'Device_Control_%d' % index ringed_encoder = make_ring_encoder(16 + index, 24 + index, name=encoder_name, num = index + 8, script = self) self._device_param_controls_raw.append(ringed_encoder) self._play_button = make_button(0, 91, name='Play_Button') self._stop_button = make_button(0, 92, name='Stop_Button') self._record_button = make_button(0, 93, name='Record_Button') self._nudge_up_button = make_button(0, 100, name='Nudge_Up_Button') self._nudge_down_button = make_button(0, 101, name='Nudge_Down_Button') self._tap_tempo_button = make_button(0, 99, name='Tap_Tempo_Button') self._global_bank_buttons = [] self._global_param_controls = [] for index in range(8): encoder_name = 'Track_Control_%d' % index ringed_encoder = make_ring_encoder(48 + index, 56 + index, name=encoder_name, num = index, script = self) self._global_param_controls.append(ringed_encoder) self._global_bank_buttons = [ make_on_off_button(0, 87 + index, name=name) for index, name in enumerate(('Pan_Button', 'Send_A_Button', 'Send_B_Button', 'Send_C_Button')) ] self._device_clip_toggle_button = self._device_bank_buttons[0] self._device_on_off_button = self._device_bank_buttons[1] self._detail_left_button = self._device_bank_buttons[2] self._detail_right_button = self._device_bank_buttons[3] self._detail_toggle_button = self._device_bank_buttons[4] self._rec_quantization_button = self._device_bank_buttons[5] self._overdub_button = self._device_bank_buttons[6] self._metronome_button = self._device_bank_buttons[7] self._monomod = ButtonMatrixElement(name = 'Monomod') for row in self._matrix_rows_raw: self._monomod.add_row(row) self._monomod.add_row(self._track_stop_buttons) self._monomod.add_row(self._select_buttons) self._monomod.add_row(self._original_mute_buttons) #self._doublepress_detail_button = DoublePressElement(self._detail_toggle_button) def wrap_matrix(control_list, wrapper = nop): return ButtonMatrixElement(rows=[map(wrapper, control_list)]) self._scene_launch_buttons = wrap_matrix(self._scene_launch_buttons) self._track_stop_buttons = wrap_matrix(self._track_stop_buttons) self._volume_controls = wrap_matrix(self._volume_controls) self._arm_buttons = wrap_matrix(self._arm_buttons) self._original_solo_buttons = wrap_matrix(self._original_solo_buttons) self._original_mute_buttons = wrap_matrix(self._original_mute_buttons) self._select_buttons = wrap_matrix(self._select_buttons) self._device_param_controls = wrap_matrix(self._device_param_controls_raw) self._device_bank_buttons = wrap_matrix(self._device_bank_buttons, partial(DeviceBankButtonElement, modifiers=[self._shift_button])) self._solo_buttons = self._original_solo_buttons self._mute_buttons = self._original_mute_buttons def _create_detail_view_control(self): self._detail_view_toggler = DetailViewCntrlComponent(name='Detail_View_Control', is_enabled=False, layer=Layer(device_clip_toggle_button=self._device_clip_toggle_button, device_nav_left_button=self._detail_left_button, device_nav_right_button=self._detail_right_button)) #detail_toggle_button=self._detail_toggle_button def _setup_monobridge(self): self._monobridge = MonoBridgeElement(self) self._monobridge.name = 'MonoBridge' def _setup_mod(self): self.monomodular = get_monomodular(self) self.monomodular.name = 'monomodular_switcher' self.modhandler = APCModHandler(self) self.modhandler.name = 'ModHandler' self.modhandler.layer = Layer(priority = 5, grid = self._monomod, nav_up_button = self._up_button, nav_down_button = self._down_button, nav_left_button = self._left_button, nav_right_button = self._right_button, shiftlock_button = self._nudge_up_button, alt_button = self._nudge_down_button, shift_button = self._shift_button) self.modhandler.set_device_component(self._device_component) self.modhandler.set_enabled(False) self._monomod_mode = MonomodModeComponent(self._monomod_mode_update, self) self._monomod_mode.name = "Monomod_Mode_Component" self._monomod_mode.layer = Layer(priority = 5, mode_toggle = self._detail_toggle_button) self._on_shift_value.subject = self._shift_button @subject_slot('value') def _on_shift_value(self, value): #self._monomod_mode.set_enabled(value>0) self._monomod_mode.set_enabled(value is 0) #self.modhandler.is_enabled() and self.modhanlder._shift_value(value) if value: self.modhandler.set_lock_button(self._detail_toggle_button) else: self.modhandler.set_lock_button(None) def _monomod_mode_update(self): #self.log_message('mode update: ' + str(self._monomod_mode._mode_index)) if(self._monomod_mode._mode_index == 0): self.flash_status = False self.modhandler.set_enabled(False) self._monomod.reset() self._on_selected_track_changed() elif(self._monomod_mode._mode_index == 1): self.flash_status = True self._monomod.reset() self.modhandler.set_enabled(True) self._detail_toggle_button.send_value(self._monomod_mode._mode_index) """m4l bridge""" def generate_strip_string(self, display_string): #self.log_message(display_string) NUM_CHARS_PER_DISPLAY_STRIP = 12 if (not display_string): return (' ' * NUM_CHARS_PER_DISPLAY_STRIP) if ((len(display_string.strip()) > (NUM_CHARS_PER_DISPLAY_STRIP - 1)) and (display_string.endswith('dB') and (display_string.find('.') != -1))): display_string = display_string[:-2] if (len(display_string) > (NUM_CHARS_PER_DISPLAY_STRIP - 1)): for um in [' ', 'i', 'o', 'u', 'e', 'a']: while ((len(display_string) > (NUM_CHARS_PER_DISPLAY_STRIP - 1)) and (display_string.rfind(um, 1) != -1)): um_pos = display_string.rfind(um, 1) display_string = (display_string[:um_pos] + display_string[(um_pos + 1):]) else: display_string = display_string.center((NUM_CHARS_PER_DISPLAY_STRIP - 1)) ret = u'' for i in range((NUM_CHARS_PER_DISPLAY_STRIP - 1)): if ((ord(display_string[i]) > 127) or (ord(display_string[i]) < 0)): ret += ' ' else: ret += display_string[i] ret += ' ' assert (len(ret) == NUM_CHARS_PER_DISPLAY_STRIP) return ret def notification_to_bridge(self, name, value, sender): if isinstance(sender, (MonoRingedEncoderElement, MonoEncoderElement)): self._monobridge._send(sender.name, 'lcd_name', str(self.generate_strip_string(name))) self._monobridge._send(sender.name, 'lcd_value', str(self.generate_strip_string(value))) def touched(self): if self._touched is 0: self._monobridge._send('touch', 'on') self.schedule_message(2, self.check_touch) self._touched +=1 def check_touch(self): if self._touched > 5: self._touched = 5 elif self._touched > 0: self._touched -= 1 if self._touched is 0: self._monobridge._send('touch', 'off') else: self.schedule_message(2, self.check_touch) def get_clip_names(self): clip_names = [] for scene in self._session._scenes: for clip_slot in scene._clip_slots: if clip_slot.has_clip() is True: clip_names.append(clip_slot._clip_slot)##.clip.name) return clip_slot._clip_slot ##self.log_message(str(clip_slot._clip_slot.clip.name)) return clip_names def update_display(self): super(AumPC40, self).update_display() self._timer = (self._timer + 1) % 256 self.flash() def flash(self): if self.flash_status: for control, _ in self._monomod.iterbuttons(): if isinstance(control, MonoButtonElement): control.flash(self._timer) def _make_current_bank_details(self, device_component): def _current_bank_details(): if not self.modhandler.active_mod() is None: if self.modhandler.active_mod() and self.modhandler.active_mod()._param_component._device_parent != None: bank_name = self.modhandler.active_mod()._param_component._bank_name bank = [param._parameter for param in self.modhandler.active_mod()._param_component._params] if self.modhandler._alt_value.subject and self.modhandler._alt_value.subject.is_pressed(): bank = bank[8:] #self.log_message('current mod bank details: ' + str(bank_name) + ' ' + str(bank)) return (bank_name, bank) else: return DeviceComponent._current_bank_details(device_component) else: return DeviceComponent._current_bank_details(device_component) return _current_bank_details
class AumPC40(APC): __doc__ = " Script for Akai's APC40 Controller " def __init__(self, c_instance, *a, **k): super(AumPC40, self).__init__(c_instance, *a, **k) self._device_selection_follows_track_selection = True def _setup_session_control(self): is_momentary = True self._shift_button = AumPCMonoButtonElement(is_momentary, MIDI_NOTE_TYPE, 0, 98, 'Shift_Button', self) right_button = AumPCMonoButtonElement(is_momentary, MIDI_NOTE_TYPE, 0, 96, 'Right_Button', self) self._right_button = right_button left_button = AumPCMonoButtonElement(is_momentary, MIDI_NOTE_TYPE, 0, 97, 'Left_Button', self) self._left_button = left_button up_button = AumPCMonoButtonElement(is_momentary, MIDI_NOTE_TYPE, 0, 94, 'Up_Button', self) self._up_button = up_button down_button = AumPCMonoButtonElement(is_momentary, MIDI_NOTE_TYPE, 0, 95, 'Down_Button', self) self._down_button = down_button self._session = PedaledSessionComponent(8, 5) self._session.name = 'Session_Control' self._session.set_track_bank_buttons(right_button, left_button) self._session.set_scene_bank_buttons(down_button, up_button) matrix = ButtonMatrixElement() self._matrix = matrix # added a matrix.name = 'Button_Matrix' scene_launch_buttons = [ ButtonElement(is_momentary, MIDI_NOTE_TYPE, 0, (index + 82)) for index in range(5) ] track_stop_buttons = [ AumPCMonoButtonElement(is_momentary, MIDI_NOTE_TYPE, index, 52, 'Track_' + str(index) + '_Stop_Button', self) for index in range(8) ] self._track_stop_buttons = track_stop_buttons # added a for index in range(len(scene_launch_buttons)): scene_launch_buttons[index].name = 'Scene_' + str( index) + '_Launch_Button' stop_all_button = ButtonElement(is_momentary, MIDI_NOTE_TYPE, 0, 81) stop_all_button.name = 'Stop_All_Clips_Button' self._session.set_stop_all_clips_button(stop_all_button) self._session.set_stop_track_clip_buttons(tuple(track_stop_buttons)) self._session.set_stop_track_clip_value(2) for scene_index in range(5): scene = self._session.scene(scene_index) scene.name = 'Scene_' + str(scene_index) button_row = [] scene.set_launch_button(scene_launch_buttons[scene_index]) scene.set_triggered_value(2) for track_index in range(8): button = AumPCMonoButtonElement( is_momentary, MIDI_NOTE_TYPE, track_index, (scene_index + 53), str(track_index) + '_Clip_' + str(scene_index) + '_Button', self) #button.name = str(track_index) + '_Clip_' + str(scene_index) + '_Button' button_row.append(button) clip_slot = scene.clip_slot(track_index) clip_slot.name = str(track_index) + '_Clip_Slot_' + str( scene_index) clip_slot.set_triggered_to_play_value(2) clip_slot.set_triggered_to_record_value(4) clip_slot.set_stopped_value(5) clip_slot.set_started_value(1) clip_slot.set_recording_value(3) clip_slot.set_launch_button(button) matrix.add_row(tuple(button_row)) self._session.set_slot_launch_button( ButtonElement(is_momentary, MIDI_CC_TYPE, 0, 67)) self._session.selected_scene().name = 'Selected_Scene' self._session.selected_scene().set_launch_button( ButtonElement(is_momentary, MIDI_CC_TYPE, 0, 64)) self._session_zoom = SessionZoomingComponent(self._session) self._session_zoom.name = 'Session_Overview' self._session_zoom.set_button_matrix(matrix) self._session_zoom.set_zoom_button(self._shift_button) self._session_zoom.set_nav_buttons(up_button, down_button, left_button, right_button) self._session_zoom.set_scene_bank_buttons(tuple(scene_launch_buttons)) self._session_zoom.set_stopped_value(3) self._session_zoom.set_selected_value(5) def _setup_mixer_control(self): is_momentary = True self._mixer = SpecialMixerComponent(8) self._mixer.name = 'Mixer' self._mixer.master_strip().name = 'Master_Channel_Strip' self._mixer.selected_strip().name = 'Selected_Channel_Strip' self._solo_buttons = [] # added a self._select_buttons = [] # added a for track in range(8): strip = self._mixer.channel_strip(track) strip.name = 'Channel_Strip_' + str(track) volume_control = EncoderElement( MIDI_CC_TYPE, track, 7, Live.MidiMap.MapMode.absolute ) # 'Slider_' + str(track), track, self) arm_button = ButtonElement(is_momentary, MIDI_NOTE_TYPE, track, 48) solo_button = AumPCMonoButtonElement(is_momentary, MIDI_NOTE_TYPE, track, 50, str(track) + '_Solo_Button', self) self._solo_buttons.append(solo_button) # added a mute_button = ButtonElement(is_momentary, MIDI_NOTE_TYPE, track, 49) select_button = AumPCMonoButtonElement( is_momentary, MIDI_NOTE_TYPE, track, 51, str(track) + '_Select_Button', self) self._select_buttons.append(select_button) # added a #volume_control.name = str(track) + '_Volume_Control' arm_button.name = str(track) + '_Arm_Button' #solo_button.name = str(track) + '_Solo_Button' mute_button.name = str(track) + '_Mute_Button' #select_button.name = str(track) + '_Select_Button' strip.set_volume_control(volume_control) strip.set_arm_button(arm_button) strip.set_solo_button(solo_button) strip.set_mute_button(mute_button) strip.set_select_button(select_button) strip.set_shift_button(self._shift_button) strip.set_invert_mute_feedback(True) crossfader = SliderElement(MIDI_CC_TYPE, 0, 15) self._crossfader = crossfader self._crossfader.name = 'Crossfader' master_volume_control = SliderElement(MIDI_CC_TYPE, 0, 14) master_select_button = ButtonElement(is_momentary, MIDI_NOTE_TYPE, 0, 80) self._master_select_button = master_select_button prehear_control = EncoderElement( MIDI_CC_TYPE, 0, 47, Live.MidiMap.MapMode.relative_two_compliment) crossfader.name = 'Crossfader' master_volume_control.name = 'Master_Volume_Control' master_select_button.name = 'Master_Select_Button' prehear_control.name = 'Prehear_Volume_Control' self._mixer.set_crossfader_control(crossfader) self._mixer.set_prehear_volume_control(prehear_control) self._mixer.master_strip().set_volume_control(master_volume_control) self._mixer.master_strip().set_select_button(master_select_button) def _setup_custom_components(self): self._setup_device_and_transport_control() self._setup_global_control() def _setup_device_and_transport_control(self): is_momentary = True device_bank_buttons = [] device_param_controls = [] bank_button_labels = ('Clip_Track_Button', 'Device_On_Off_Button', 'Previous_Device_Button', 'Next_Device_Button', 'Detail_View_Button', 'Rec_Quantization_Button', 'Midi_Overdub_Button', 'Metronome_Button') for index in range(8): device_bank_buttons.append( ButtonElement(is_momentary, MIDI_NOTE_TYPE, 0, 58 + index)) device_bank_buttons[-1].name = bank_button_labels[index] ring_mode_button = ButtonElement(not is_momentary, MIDI_CC_TYPE, 0, 24 + index) ringed_encoder = MonoRingedEncoderElement( MIDI_CC_TYPE, 0, 16 + index, Live.MidiMap.MapMode.absolute, index, self) ringed_encoder.set_ring_mode_button(ring_mode_button) ringed_encoder.name = 'Device_Control_' + str(index) ring_mode_button.name = ringed_encoder.name + '_Ring_Mode_Button' device_param_controls.append(ringed_encoder) device = ShiftableDeviceComponent() device.name = 'Device_Component' device.set_bank_buttons(tuple(device_bank_buttons)) device.set_shift_button(self._shift_button) device.set_parameter_controls(tuple(device_param_controls)) device.set_on_off_button(device_bank_buttons[1]) self.set_device_component(device) self._device = device detail_view_toggler = DetailViewCntrlComponent() detail_view_toggler.name = 'Detail_View_Control' detail_view_toggler.set_shift_button(self._shift_button) detail_view_toggler.set_device_clip_toggle_button( device_bank_buttons[0]) detail_view_toggler.set_detail_toggle_button(device_bank_buttons[4]) detail_view_toggler.set_device_nav_buttons(device_bank_buttons[2], device_bank_buttons[3]) transport = ShiftableTransportComponent() transport.name = 'Transport' self._transport = transport play_button = ButtonElement(is_momentary, MIDI_NOTE_TYPE, 0, 91) stop_button = ButtonElement(is_momentary, MIDI_NOTE_TYPE, 0, 92) record_button = ButtonElement(is_momentary, MIDI_NOTE_TYPE, 0, 93) nudge_up_button = AumPCMonoButtonElement(is_momentary, MIDI_NOTE_TYPE, 0, 100, 'Nudge_Up_Button', self) self._nudge_up_button = nudge_up_button nudge_down_button = AumPCMonoButtonElement(is_momentary, MIDI_NOTE_TYPE, 0, 101, 'Nudge_Down_Button', self) self._nudge_down_button = nudge_down_button tap_tempo_button = ButtonElement(is_momentary, MIDI_NOTE_TYPE, 0, 99) play_button.name = 'Play_Button' stop_button.name = 'Stop_Button' record_button.name = 'Record_Button' #nudge_up_button.name = 'Nudge_Up_Button' #nudge_down_button.name = 'Nudge_Down_Button' tap_tempo_button.name = 'Tap_Tempo_Button' transport.set_shift_button(self._shift_button) transport.set_play_button(play_button) transport.set_stop_button(stop_button) transport.set_record_button(record_button) transport.set_nudge_buttons(nudge_up_button, nudge_down_button) transport.set_tap_tempo_button(tap_tempo_button) transport.set_quant_toggle_button(device_bank_buttons[5]) transport.set_overdub_button(device_bank_buttons[6]) transport.set_metronome_button(device_bank_buttons[7]) bank_button_translator = ShiftTranslatorComponent() bank_button_translator.set_controls_to_translate( tuple(device_bank_buttons)) bank_button_translator.set_shift_button(self._shift_button) def _setup_global_control(self): is_momentary = True global_bank_buttons = [] global_param_controls = [] for index in range(8): ring_button = ButtonElement(not is_momentary, MIDI_CC_TYPE, 0, 56 + index) ringed_encoder = MonoRingedEncoderElement( MIDI_CC_TYPE, 0, 48 + index, Live.MidiMap.MapMode.absolute, index + 8, self) ringed_encoder.name = 'Track_Control_' + str(index) ring_button.name = ringed_encoder.name + '_Ring_Mode_Button' ringed_encoder.set_ring_mode_button(ring_button) global_param_controls.append(ringed_encoder) global_bank_buttons = [] global_bank_labels = ('Pan_Button', 'Send_A_Button', 'Send_B_Button', 'Send_C_Button') for index in range(4): global_bank_buttons.append( ButtonElement(not is_momentary, MIDI_NOTE_TYPE, 0, 87 + index)) global_bank_buttons[-1].name = global_bank_labels[index] encoder_modes = EncModeSelectorComponent(self._mixer) encoder_modes.name = 'Track_Control_Modes' encoder_modes.set_modes_buttons(global_bank_buttons) encoder_modes.set_controls(tuple(global_param_controls)) global_translation_selector = ChannelTranslationSelector() global_translation_selector.name = 'Global_Translations' global_translation_selector.set_controls_to_translate( tuple(global_param_controls)) global_translation_selector.set_mode_buttons( tuple(global_bank_buttons)) def _product_model_id_byte(self): return 115 def _setup_monobridge(self): self._monobridge = MonoBridgeElement(self) self._monobridge.name = 'MonoBridge' def _setup_monomod(self): self._host = MonomodComponent(self) self._host.name = 'Monomod_Host' self._host._navbox_selected = 16 self._host._navbox_unselected = 1 self.hosts = [self._host] self._monomod = ButtonMatrixElement() self._monomod.name = 'Monomod' for row in range(5): button_row = [] for column in range(8): button_row.append(self._matrix.get_button(column, row)) self._monomod.add_row(tuple(button_row)) self._monomod.add_row(tuple(self._track_stop_buttons)) self._monomod.add_row(tuple(self._select_buttons)) self._monomod.add_row(tuple(self._solo_buttons)) self._monomod_mode = MonomodModeComponent(self._monomod_mode_update, self) self._monomod_mode.name = "Monomod_Mode_Component" self._shift_button.add_value_listener(self._shift_value) def _shift_value(self, value): if value > 0: self._mixer.master_strip().set_select_button(None) self._monomod_mode.set_mode_toggle(self._master_select_button) else: self._mixer.master_strip().set_select_button( self._master_select_button) self._monomod_mode.set_mode_toggle(None) def _monomod_mode_update(self): #self.log_message('mode update: ' + str(self._monomod_mode._mode_index)) if (self._monomod_mode._mode_index == 0) or (self._host._active_client == None): self.flash_status = 0 self._host.set_enabled(False) self._host._set_button_matrix(None) self._host._set_nav_buttons(None) self._host._set_lock_button(None) self._host._set_alt_button(None) self._host._set_shift_button(None) self._monomod.reset() self._session.set_track_bank_buttons(self._right_button, self._left_button) self._session.set_scene_bank_buttons(self._down_button, self._up_button) for track in range(8): self._mixer.channel_strip(track).set_select_button( self._select_buttons[track]) self._mixer.channel_strip(track).set_solo_button( self._solo_buttons[track]) self._transport.set_nudge_buttons(self._nudge_up_button, self._nudge_down_button) self._session.set_enabled(True) self._session_zoom._is_zoomed_out = False self._session_zoom.set_enabled(True) self.request_rebuild_midi_map() self._master_select_button.turn_off() elif (self._monomod_mode._mode_index == 1): self._transport.set_nudge_buttons(None, None) for track in range(8): self._mixer.channel_strip(track).set_select_button(None) self._mixer.channel_strip(track).set_solo_button(None) self._session.set_enabled(False) self._session_zoom.set_enabled(False) self._session.set_track_bank_buttons(None, None) self._session.set_scene_bank_buttons(None, None) self.flash_status = 1 self._monomod.reset() self._host._set_button_matrix(self._monomod) self._host._set_nav_buttons([ self._up_button, self._down_button, self._left_button, self._right_button ]) self._host._set_shift_button(self._shift_button) self._host._set_lock_button(self._nudge_up_button) self._host._set_alt_button(self._nudge_down_button) self._host.set_enabled(True) self.request_rebuild_midi_map() self._master_select_button.turn_on() #self.log_message('mod mode') """m4l bridge""" def generate_strip_string(self, display_string): #self.log_message(display_string) NUM_CHARS_PER_DISPLAY_STRIP = 12 if (not display_string): return (' ' * NUM_CHARS_PER_DISPLAY_STRIP) if ((len(display_string.strip()) > (NUM_CHARS_PER_DISPLAY_STRIP - 1)) and (display_string.endswith('dB') and (display_string.find('.') != -1))): display_string = display_string[:-2] if (len(display_string) > (NUM_CHARS_PER_DISPLAY_STRIP - 1)): for um in [' ', 'i', 'o', 'u', 'e', 'a']: while ((len(display_string) > (NUM_CHARS_PER_DISPLAY_STRIP - 1)) and (display_string.rfind(um, 1) != -1)): um_pos = display_string.rfind(um, 1) display_string = (display_string[:um_pos] + display_string[(um_pos + 1):]) else: display_string = display_string.center( (NUM_CHARS_PER_DISPLAY_STRIP - 1)) ret = u'' for i in range((NUM_CHARS_PER_DISPLAY_STRIP - 1)): if ((ord(display_string[i]) > 127) or (ord(display_string[i]) < 0)): ret += ' ' else: ret += display_string[i] ret += ' ' assert (len(ret) == NUM_CHARS_PER_DISPLAY_STRIP) return ret def notification_to_bridge(self, name, value, sender): if isinstance(sender, (MonoRingedEncoderElement, MonoEncoderElement)): self._monobridge._send(sender.name, 'lcd_name', str(self.generate_strip_string(name))) self._monobridge._send(sender.name, 'lcd_value', str(self.generate_strip_string(value))) def touched(self): if self._touched is 0: self._monobridge._send('touch', 'on') self.schedule_message(2, self.check_touch) self._touched += 1 def check_touch(self): if self._touched > 5: self._touched = 5 elif self._touched > 0: self._touched -= 1 if self._touched is 0: self._monobridge._send('touch', 'off') else: self.schedule_message(2, self.check_touch) def get_clip_names(self): clip_names = [] for scene in self._session._scenes: for clip_slot in scene._clip_slots: if clip_slot.has_clip() is True: clip_names.append(clip_slot._clip_slot) ##.clip.name) return clip_slot._clip_slot ##self.log_message(str(clip_slot._clip_slot.clip.name)) return clip_names def update_display(self): ControlSurface.update_display(self) self._timer = (self._timer + 1) % 256 self.flash() def flash(self): if self.flash_status: for control in self.controls: if isinstance(control, MonoButtonElement): control.flash(self._timer)
class AumPC20(APC20): def __init__(self, c_instance, *a, **k): self._monomod_version = 'b996' self._host_name = 'AumPC' self._color_type = 'APC' self._timer = 0 self._touched = 0 self.flash_status = False super(AumPC20, self).__init__(c_instance, *a, **k) with self.component_guard(): self._setup_mod() def disconnect(self): super(AumPC20, self).disconnect() rebuild_sys() def _create_controls(self): make_color_button = partial(make_button, skin=self._skin) self._shift_button = make_button(0, 81, name='Shift_Button', num=0, cs=self) self._matrix = ButtonMatrixElement(name='Button_Matrix') self._scene_launch_buttons_raw = [ make_color_button(0, index + 82, name='Scene_%d_Launch_Button' % index, num=index, cs=self) for index in xrange(SESSION_HEIGHT) ] self._track_stop_buttons = [ make_color_button(index, 52, name='Track_%d_Stop_Button' % index, num=index, cs=self) for index in xrange(SESSION_WIDTH) ] self._matrix_rows_raw = [] for scene_index in xrange(SESSION_HEIGHT): row = [ make_color_button( track_index, scene_index + 53, name='%d_Clip_%d_Button' % (track_index, scene_index), num=index, cs=self) for track_index in xrange(SESSION_WIDTH) ] self._matrix_rows_raw.append(row) self._matrix.add_row(row) self._selected_scene_launch_button = make_pedal_button( 64, name='Selected_Scene_Launch_Button') self._scene_launch_buttons = ButtonMatrixElement( rows=[self._scene_launch_buttons_raw]) self._solo_buttons = [ make_button(track_index, 49, name='%d_Solo_Button' % track_index, num=track_index, cs=self) for track_index in xrange(MIXER_SIZE) ] self._mute_buttons = [ make_button(track_index, 50, name='%d_Mute_Button' % track_index, num=track_index, cs=self) for track_index in xrange(MIXER_SIZE) ] self._master_volume_control = make_slider(0, 14, name='Master_Volume_Control', num=0, script=self) self._prehear_control = EncoderElement(MIDI_CC_TYPE, 0, 47, MapMode.relative_two_compliment, name='Prehear_Volume_Control', num=0, script=self) self._master_select_button = make_button(0, 80, name='Master_Select_Button', num=index, cs=self) self._select_buttons = [ make_button(track_index, 51, name='%d_Select_Button' % track_index, num=track_index, cs=self) for track_index in xrange(8) ] self._arm_buttons = [ make_button(track_index, 48, name='%d_Arm_Button' % track_index, num=track_index, cs=self) for track_index in xrange(8) ] self._sliders = [ make_slider(track_index, 7, name='%d_Volume_Control' % track_index, num=track_index, script=self) for track_index in xrange(8) ] self._monomod = ButtonMatrixElement(name='Monomod') for row in self._matrix_rows_raw: self._monomod.add_row(row) self._monomod.add_row(self._track_stop_buttons) self._monomod.add_row(self._select_buttons) self._monomod.add_row(self._mute_buttons) self._setup_monobridge( ) #had to put this here b/c the original author foolishly placed assignment methods inside of creation methods...argh. def _setup_monobridge(self): self._monobridge = MonoBridgeElement(self) self._monobridge.name = 'MonoBridge' def _setup_mod(self): self.monomodular = get_monomodular(self) self.monomodular.name = 'monomodular_switcher' self.modhandler = APCModHandler(self) self.modhandler.name = 'ModHandler' self.modhandler.layer = Layer( priority=5, grid=self._monomod, nav_up_button=self._scene_launch_buttons_raw[2], nav_down_button=self._scene_launch_buttons_raw[3], lock_button=self._scene_launch_buttons_raw[4], shiftlock_button=self._scene_launch_buttons_raw[0], alt_button=self._scene_launch_buttons_raw[1], shift_button=self._shift_button) self.modhandler.set_enabled(False) self._monomod_mode = MonomodModeComponent(self._monomod_mode_update, self) self._monomod_mode.name = "Monomod_Mode_Component" self._monomod_mode.layer = Layer( priority=5, mode_toggle=self._master_select_button) self._on_shift_value.subject = self._shift_button self._on_master_value.subject = self._master_select_button @subject_slot('value') def _on_shift_value(self, value): self._monomod_mode.set_enabled(value > 0) @subject_slot('value') def _on_master_value(self, value): if not self._shift_button.is_pressed( ) and not self.modhandler.is_enabled(): self.schedule_message(1, self._shift_modes.update) def _monomod_mode_update(self): #self.log_message('mode update: ' + str(self._monomod_mode._mode_index)) if (self._monomod_mode._mode_index == 0): self.flash_status = False self.modhandler.set_enabled(False) self._slider_modes.set_enabled(True) self._shift_modes.set_enabled(True) self._scene_launch_buttons[2].set_on_off_values(127, 0) self._scene_launch_buttons[3].set_on_off_values(127, 0) self._monomod.reset() self._shift_modes.set_enabled(True) for track in range(8): self._mixer.channel_strip(track).set_mute_button( self._mute_buttons[track]) self._session.set_enabled(True) self._session_zoom._is_zoomed_out = False self._session_zoom.set_enabled(True) self._transport.set_enabled(True) self.request_rebuild_midi_map() self.schedule_message(1, self._shift_modes.update) elif (self._monomod_mode._mode_index == 1): self._slider_modes.set_enabled(False) if self._shift_modes._note_mode_active is True: self._shift_modes._mode_callback(ABLETON_MODE) self._shift_modes._note_mode_active = False self._session_zoom.set_ignore_buttons(False) self._shift_modes._transport.update() self._shift_modes._on_note_mode_changed() self._shift_modes.set_enabled(False) self._session.set_clip_launch_buttons(None) for track in range(8): self._mixer.channel_strip(track).set_select_button(None) self._mixer.channel_strip(track).set_mute_button(None) self._session.set_track_bank_buttons(None, None) self._session.set_scene_bank_buttons(None, None) for scene in range(5): self._scene_launch_buttons[scene].turn_off() self._transport.set_enabled(False) self._session.set_enabled(False) self._session_zoom.set_enabled(False) self.flash_status = True self._monomod.reset() self.modhandler.set_enabled(True) self._master_select_button.send_value(self._monomod_mode._mode_index) """m4l bridge""" def generate_strip_string(self, display_string): #self.log_message(display_string) NUM_CHARS_PER_DISPLAY_STRIP = 12 if (not display_string): return (' ' * NUM_CHARS_PER_DISPLAY_STRIP) if ((len(display_string.strip()) > (NUM_CHARS_PER_DISPLAY_STRIP - 1)) and (display_string.endswith('dB') and (display_string.find('.') != -1))): display_string = display_string[:-2] if (len(display_string) > (NUM_CHARS_PER_DISPLAY_STRIP - 1)): for um in [' ', 'i', 'o', 'u', 'e', 'a']: while ((len(display_string) > (NUM_CHARS_PER_DISPLAY_STRIP - 1)) and (display_string.rfind(um, 1) != -1)): um_pos = display_string.rfind(um, 1) display_string = (display_string[:um_pos] + display_string[(um_pos + 1):]) else: display_string = display_string.center( (NUM_CHARS_PER_DISPLAY_STRIP - 1)) ret = u'' for i in range((NUM_CHARS_PER_DISPLAY_STRIP - 1)): if ((ord(display_string[i]) > 127) or (ord(display_string[i]) < 0)): ret += ' ' else: ret += display_string[i] ret += ' ' assert (len(ret) == NUM_CHARS_PER_DISPLAY_STRIP) return ret def notification_to_bridge(self, name, value, sender): if isinstance(sender, (MonoRingedEncoderElement, MonoEncoderElement)): self._monobridge._send(sender.name, 'lcd_name', str(self.generate_strip_string(name))) self._monobridge._send(sender.name, 'lcd_value', str(self.generate_strip_string(value))) def touched(self): if self._touched is 0: self._monobridge._send('touch', 'on') self.schedule_message(2, self.check_touch) self._touched += 1 def check_touch(self): if self._touched > 5: self._touched = 5 elif self._touched > 0: self._touched -= 1 if self._touched is 0: self._monobridge._send('touch', 'off') else: self.schedule_message(2, self.check_touch) def get_clip_names(self): clip_names = [] for scene in self._session._scenes: for clip_slot in scene._clip_slots: if clip_slot.has_clip() is True: clip_names.append(clip_slot._clip_slot) ##.clip.name) return clip_slot._clip_slot ##self.log_message(str(clip_slot._clip_slot.clip.name)) return clip_names def update_display(self): super(AumPC20, self).update_display() self._timer = (self._timer + 1) % 256 self.flash() def flash(self): if self.flash_status: for control, _ in self._monomod.iterbuttons(): if isinstance(control, MonoButtonElement): control.flash(self._timer)
class AumPC20(APC20): def __init__(self, c_instance, *a, **k): self._monomod_version = 'b996' self._host_name = 'AumPC' self._color_type = 'APC' self._timer = 0 self._touched = 0 self.flash_status = False super(AumPC20, self).__init__(c_instance, *a, **k) with self.component_guard(): self._setup_mod() def disconnect(self): super(AumPC20, self).disconnect() rebuild_sys() def _create_controls(self): make_color_button = partial(make_button, skin=self._skin) self._shift_button = make_button(0, 81, name='Shift_Button', num = 0, cs = self) self._matrix = ButtonMatrixElement(name='Button_Matrix') self._scene_launch_buttons_raw = [ make_color_button(0, index + 82, name='Scene_%d_Launch_Button' % index, num = index, cs = self) for index in xrange(SESSION_HEIGHT) ] self._track_stop_buttons = [ make_color_button(index, 52, name='Track_%d_Stop_Button' % index, num = index, cs = self) for index in xrange(SESSION_WIDTH) ] self._matrix_rows_raw = [] for scene_index in xrange(SESSION_HEIGHT): row = [ make_color_button(track_index, scene_index + 53, name='%d_Clip_%d_Button' % (track_index, scene_index), num = index, cs = self) for track_index in xrange(SESSION_WIDTH) ] self._matrix_rows_raw.append(row) self._matrix.add_row(row) self._selected_scene_launch_button = make_pedal_button(64, name='Selected_Scene_Launch_Button') self._scene_launch_buttons = ButtonMatrixElement(rows=[self._scene_launch_buttons_raw]) self._solo_buttons = [ make_button(track_index, 49, name='%d_Solo_Button' % track_index, num = track_index, cs = self) for track_index in xrange(MIXER_SIZE) ] self._mute_buttons = [ make_button(track_index, 50, name='%d_Mute_Button' % track_index, num = track_index, cs = self) for track_index in xrange(MIXER_SIZE) ] self._master_volume_control = make_slider(0, 14, name='Master_Volume_Control', num = 0, script = self) self._prehear_control = EncoderElement(MIDI_CC_TYPE, 0, 47, MapMode.relative_two_compliment, name='Prehear_Volume_Control', num = 0, script = self) self._master_select_button = make_button(0, 80, name='Master_Select_Button', num = index, cs = self) self._select_buttons = [ make_button(track_index, 51, name='%d_Select_Button' % track_index, num = track_index, cs = self ) for track_index in xrange(8) ] self._arm_buttons = [ make_button(track_index, 48, name='%d_Arm_Button' % track_index, num = track_index, cs = self) for track_index in xrange(8) ] self._sliders = [ make_slider(track_index, 7, name='%d_Volume_Control' % track_index, num = track_index, script = self) for track_index in xrange(8) ] self._monomod = ButtonMatrixElement(name = 'Monomod') for row in self._matrix_rows_raw: self._monomod.add_row(row) self._monomod.add_row(self._track_stop_buttons) self._monomod.add_row(self._select_buttons) self._monomod.add_row(self._mute_buttons) self._setup_monobridge() #had to put this here b/c the original author foolishly placed assignment methods inside of creation methods...argh. def _setup_monobridge(self): self._monobridge = MonoBridgeElement(self) self._monobridge.name = 'MonoBridge' def _setup_mod(self): self.monomodular = get_monomodular(self) self.monomodular.name = 'monomodular_switcher' self.modhandler = APCModHandler(self) self.modhandler.name = 'ModHandler' self.modhandler.layer = Layer(priority = 5, grid = self._monomod, nav_up_button = self._scene_launch_buttons_raw[2], nav_down_button = self._scene_launch_buttons_raw[3], lock_button = self._scene_launch_buttons_raw[4], shiftlock_button = self._scene_launch_buttons_raw[0], alt_button = self._scene_launch_buttons_raw[1], shift_button = self._shift_button) self.modhandler.set_enabled(False) self._monomod_mode = MonomodModeComponent(self._monomod_mode_update, self) self._monomod_mode.name = "Monomod_Mode_Component" self._monomod_mode.layer = Layer(priority = 5, mode_toggle = self._master_select_button) self._on_shift_value.subject = self._shift_button self._on_master_value.subject = self._master_select_button @subject_slot('value') def _on_shift_value(self, value): self._monomod_mode.set_enabled(value>0) @subject_slot('value') def _on_master_value(self, value): if not self._shift_button.is_pressed() and not self.modhandler.is_enabled(): self.schedule_message(1, self._shift_modes.update) def _monomod_mode_update(self): #self.log_message('mode update: ' + str(self._monomod_mode._mode_index)) if(self._monomod_mode._mode_index == 0): self.flash_status = False self.modhandler.set_enabled(False) self._slider_modes.set_enabled(True) self._shift_modes.set_enabled(True) self._scene_launch_buttons[2].set_on_off_values(127, 0) self._scene_launch_buttons[3].set_on_off_values(127, 0) self._monomod.reset() self._shift_modes.set_enabled(True) for track in range(8): self._mixer.channel_strip(track).set_mute_button(self._mute_buttons[track]) self._session.set_enabled(True) self._session_zoom._is_zoomed_out = False self._session_zoom.set_enabled(True) self._transport.set_enabled(True) self.request_rebuild_midi_map() self.schedule_message(1, self._shift_modes.update) elif(self._monomod_mode._mode_index == 1): self._slider_modes.set_enabled(False) if self._shift_modes._note_mode_active is True: self._shift_modes._mode_callback(ABLETON_MODE) self._shift_modes._note_mode_active = False self._session_zoom.set_ignore_buttons(False) self._shift_modes._transport.update() self._shift_modes._on_note_mode_changed() self._shift_modes.set_enabled(False) self._session.set_clip_launch_buttons(None) for track in range(8): self._mixer.channel_strip(track).set_select_button(None) self._mixer.channel_strip(track).set_mute_button(None) self._session.set_track_bank_buttons(None, None) self._session.set_scene_bank_buttons(None, None) for scene in range(5): self._scene_launch_buttons[scene].turn_off() self._transport.set_enabled(False) self._session.set_enabled(False) self._session_zoom.set_enabled(False) self.flash_status = True self._monomod.reset() self.modhandler.set_enabled(True) self._master_select_button.send_value(self._monomod_mode._mode_index) """m4l bridge""" def generate_strip_string(self, display_string): #self.log_message(display_string) NUM_CHARS_PER_DISPLAY_STRIP = 12 if (not display_string): return (' ' * NUM_CHARS_PER_DISPLAY_STRIP) if ((len(display_string.strip()) > (NUM_CHARS_PER_DISPLAY_STRIP - 1)) and (display_string.endswith('dB') and (display_string.find('.') != -1))): display_string = display_string[:-2] if (len(display_string) > (NUM_CHARS_PER_DISPLAY_STRIP - 1)): for um in [' ', 'i', 'o', 'u', 'e', 'a']: while ((len(display_string) > (NUM_CHARS_PER_DISPLAY_STRIP - 1)) and (display_string.rfind(um, 1) != -1)): um_pos = display_string.rfind(um, 1) display_string = (display_string[:um_pos] + display_string[(um_pos + 1):]) else: display_string = display_string.center((NUM_CHARS_PER_DISPLAY_STRIP - 1)) ret = u'' for i in range((NUM_CHARS_PER_DISPLAY_STRIP - 1)): if ((ord(display_string[i]) > 127) or (ord(display_string[i]) < 0)): ret += ' ' else: ret += display_string[i] ret += ' ' assert (len(ret) == NUM_CHARS_PER_DISPLAY_STRIP) return ret def notification_to_bridge(self, name, value, sender): if isinstance(sender, (MonoRingedEncoderElement, MonoEncoderElement)): self._monobridge._send(sender.name, 'lcd_name', str(self.generate_strip_string(name))) self._monobridge._send(sender.name, 'lcd_value', str(self.generate_strip_string(value))) def touched(self): if self._touched is 0: self._monobridge._send('touch', 'on') self.schedule_message(2, self.check_touch) self._touched +=1 def check_touch(self): if self._touched > 5: self._touched = 5 elif self._touched > 0: self._touched -= 1 if self._touched is 0: self._monobridge._send('touch', 'off') else: self.schedule_message(2, self.check_touch) def get_clip_names(self): clip_names = [] for scene in self._session._scenes: for clip_slot in scene._clip_slots: if clip_slot.has_clip() is True: clip_names.append(clip_slot._clip_slot)##.clip.name) return clip_slot._clip_slot ##self.log_message(str(clip_slot._clip_slot.clip.name)) return clip_names def update_display(self): super(AumPC20, self).update_display() self._timer = (self._timer + 1) % 256 self.flash() def flash(self): if self.flash_status: for control, _ in self._monomod.iterbuttons(): if isinstance(control, MonoButtonElement): control.flash(self._timer)
class OhmModes(ControlSurface): __module__ = __name__ __doc__ = ' OhmModes controller script ' def __init__(self, c_instance): ControlSurface.__init__(self, c_instance) with self.component_guard(): self._version_check = 'b994' self._host_name = 'Ohm' self._color_type = 'OhmRGB' self._hosts = [] self.hosts = [] self._client = [ None for index in range(6) ] self._active_client = None self.log_message('<<<<<<<<<<<<<<<<<<<<<<<<< OhmModes ' + str(self._version_check) + ' log opened >>>>>>>>>>>>>>>>>>>>>>>>>') self._rgb = 0 self._timer = 0 self._touched = 0 self.flash_status = 1 self._backlight = 127 self._backlight_type = 'static' self._ohm = 127 self._ohm_type = 'static' self._pad_translations = PAD_TRANSLATION self._device_selection_follows_track_selection = FOLLOW self._keys_octave = 5 self._keys_scale = 0 self._tempo_buttons = None self._setup_monobridge() self._setup_controls() self._setup_transport_control() self._setup_mixer_control() self._setup_session_control() self._setup_device_control() self._setup_crossfader() self._setup_ohmmod() self._setup_switchboard() self._setup_modes() self._assign_page_constants() self._last_device = None self.song().view.add_selected_track_listener(self._update_selected_device) self.show_message('OhmModes Control Surface Loaded') self._send_midi(tuple(switchxfader)) if FORCE_TYPE is True: self._rgb = FORCE_COLOR_TYPE else: self.schedule_message(10, self.query_ohm, None) self.log_message(str(self._highlighting_session_component)) def query_ohm(self): self._send_midi(tuple(check_model)) def update_display(self): ControlSurface.update_display(self) self._timer = (self._timer + 1) % 256 self.flash() self.strobe() def _setup_monobridge(self): self._monobridge = MonoBridgeElement(self) self._monobridge.name = 'MonoBridge' def get_device_bank(self): return self._device._bank_index def _setup_controls(self): is_momentary = True self._fader = [ None for index in range(8) ] self._dial = [ None for index in range(16) ] self._button = [ None for index in range(8) ] self._menu = [ None for index in range(6) ] for index in range(8): self._fader[index] = MonoEncoderElement2(MIDI_CC_TYPE, CHANNEL, OHM_FADERS[index], Live.MidiMap.MapMode.absolute, 'Fader_' + str(index), index, self) for index in range(8): self._button[index] = FlashingButtonElement(is_momentary, MIDI_NOTE_TYPE, CHANNEL, OHM_BUTTONS[index], 'Button_' + str(index), self) for index in range(16): self._dial[index] = CodecEncoderElement(MIDI_CC_TYPE, CHANNEL, OHM_DIALS[index], Live.MidiMap.MapMode.absolute, 'Encoder_' + str(index), index, self) self._knobs = [] for index in range(12): self._knobs.append(self._dial[index]) for index in range(6): self._menu[index] = FlashingButtonElement(is_momentary, MIDI_NOTE_TYPE, CHANNEL, OHM_MENU[index], 'Menu_' + str(index), self) self._crossfader = EncoderElement(MIDI_CC_TYPE, CHANNEL, CROSSFADER, Live.MidiMap.MapMode.absolute) self._crossfader.name = 'Crossfader' self._livid = FlashingButtonElement(is_momentary, MIDI_NOTE_TYPE, CHANNEL, LIVID, 'Livid_Button', self) self._shift_l = FlashingButtonElement(is_momentary, MIDI_NOTE_TYPE, CHANNEL, SHIFT_L, 'Page_Button_Left', self) self._shift_r = FlashingButtonElement(is_momentary, MIDI_NOTE_TYPE, CHANNEL, SHIFT_R, 'Page_Button_Right', self) self._matrix = ButtonMatrixElement() self._matrix.name = 'Matrix' self._grid = [ None for index in range(8) ] self._monomod = ButtonMatrixElement() self._monomod.name = 'Monomod' for column in range(8): self._grid[column] = [ None for index in range(8) ] for row in range(8): self._grid[column][row] = FlashingButtonElement(is_momentary, MIDI_NOTE_TYPE, CHANNEL, column * 8 + row, 'Grid_' + str(column) + '_' + str(row), self) for row in range(5): button_row = [] for column in range(7): button_row.append(self._grid[column][row]) self._matrix.add_row(tuple(button_row)) for row in range(8): button_row = [] for column in range(8): button_row.append(self._grid[column][row]) self._monomod.add_row(tuple(button_row)) self._mod_matrix = ButtonMatrixElement() self._mod_matrix.name = 'Matrix' self._dial_matrix = EncoderMatrixElement(self) self._dial_matrix.name = 'Dial_Matrix' self._dial_button_matrix = ButtonMatrixElement() self._dial_button_matrix.name = 'Dial_Button_Matrix' for row in range(4): button_row = [] for column in range(4): button_row.append(self._grid[column + 4][row]) self._mod_matrix.add_row(tuple(button_row)) for row in range(3): dial_row = [] for column in range(4): dial_row.append(self._dial[row * 4 + column]) self._dial_matrix.add_row(tuple(dial_row)) for row in range(3): dial_button_row = [] for column in range(4): dial_button_row.append(self._grid[column][row]) self._dial_button_matrix.add_row(tuple(dial_button_row)) self._key = [ self._grid[KEYS[index][1]][KEYS[index][0]] for index in range(32) ] self._encoder = [ self._dial[index] for index in range(12) ] self._key_matrix = ButtonMatrixElement() button_row = [] for column in range(16): button_row.append(self._key[16 + column]) self._key_matrix.add_row(tuple(button_row)) def _setup_ohmmod(self): self._host = MonomodComponent(self) self._host.name = 'Monomod_Host' self.hosts = [self._host] self._hosts = [self._host] for index in range(6): self._client[index] = MonoClient(self, index) self._client[index].name = 'Client_' + str(index) self._client[index]._device_component.set_parameter_controls(tuple([ self._dial[num] for num in range(12) ])) self._client[index]._control_defs = {'dials': self._dial_matrix, 'buttons': self._dial_button_matrix, 'grid': self._mod_matrix, 'keys': self._key, 'knobs': [ self._dial[num + 12] for num in range(4) ]} self._host._active_client = self._client[0] self._host._active_client._is_active = True self._host.connect_to_clients(self) def _setup_switchboard(self): self._switchboard = SwitchboardElement(self, self._client) self._switchboard.name = 'Switchboard' def _setup_modes(self): self._shift_mode = ShiftModeComponent(self) self._shift_mode.name = 'Shift_Mode' self._shift_mode.set_mode_toggle(self._shift_l, self._shift_r, self._livid) self._scale_mode = ScaleModeComponent(self) self._scale_mode.name = 'Scale_Mode' self._octave_mode = OctaveModeComponent(self) self._octave_mode.name = 'Octave_Mode' self._modNum = ModNumModeComponent(self, self.modNum_update) self._modNum.name = 'Mod_Number' self._modNum.set_mode = self._modNum_set_mode(self._modNum) self._modNum.set_mode_buttons([ self._menu[index] for index in range(6) ]) def _modNum_set_mode(self, modNum): def set_mode(mode): if modNum._is_enabled == True: assert isinstance(mode, int) assert (mode in range(modNum.number_of_modes())) if (modNum._mode_index != mode): modNum._mode_index = mode modNum.update() return set_mode def _setup_transport_control(self): self._transport = TransportComponent() self._transport.name = 'Transport' def _setup_mixer_control(self): global mixer is_momentary = True self._num_tracks = 7 mixer = SpecialMixerComponent(7, 0, True, False) mixer.name = 'Mixer' self._mixer = mixer for index in range(7): mixer.channel_strip(index).set_volume_control(self._fader[index]) for index in range(7): mixer.channel_strip(index).name = 'Mixer_ChannelStrip_' + str(index) mixer.track_eq(index).name = 'Mixer_EQ_' + str(index) mixer.channel_strip(index)._invert_mute_feedback = True self.song().view.selected_track = mixer.channel_strip(0)._track def _setup_session_control(self): global session is_momentary = True num_tracks = 7 num_scenes = 5 session = SessionComponent(num_tracks, num_scenes) session.name = 'Session' self._session = session session.set_offsets(0, 0) self._scene = [ None for index in range(6) ] for row in range(num_scenes): self._scene[row] = session.scene(row) self._scene[row].name = 'Scene_' + str(row) for column in range(num_tracks): clip_slot = self._scene[row].clip_slot(column) clip_slot.name = str(column) + '_Clip_Slot_' + str(row) session.set_mixer(self._mixer) session.set_show_highlight(True) self._session_zoom = SessionZoomingComponent(session) self._session_zoom.name = 'Session_Overview' self.set_highlighting_session_component(self._session) def _assign_session_colors(self): self.log_message('assign session colors') num_tracks = 7 num_scenes = 5 self._session.set_stop_track_clip_value(STOP_CLIP_COLOR[self._rgb]) for row in range(num_scenes): for column in range(num_tracks): self._scene[row].clip_slot(column).set_triggered_to_play_value(CLIP_TRIGD_TO_PLAY_COLOR[self._rgb]) self._scene[row].clip_slot(column).set_triggered_to_record_value(CLIP_TRIGD_TO_RECORD_COLOR[self._rgb]) self._scene[row].clip_slot(column).set_stopped_value(CLIP_STOPPED_COLOR[self._rgb]) self._scene[row].clip_slot(column).set_started_value(CLIP_STARTED_COLOR[self._rgb]) self._scene[row].clip_slot(column).set_recording_value(CLIP_RECORDING_COLOR[self._rgb]) self._session_zoom.set_stopped_value(ZOOM_STOPPED_COLOR[self._rgb]) self._session_zoom.set_playing_value(ZOOM_PLAYING_COLOR[self._rgb]) self._session_zoom.set_selected_value(ZOOM_SELECTED_COLOR[self._rgb]) for row in range(8): for column in range(8): self._grid[column][row].set_force_next_value() self._session.on_scene_list_changed() self._shift_mode.update() def _setup_device_control(self): self._device = DeviceComponent() self._device.name = 'Device_Component' self.set_device_component(self._device) self._device_navigator = DetailViewControllerComponent() self._device_navigator.name = 'Device_Navigator' self._device_selection_follows_track_selection = FOLLOW def device_follows_track(self, val): self._device_selection_follows_track_selection = val == 1 return self def _setup_crossfader(self): self._mixer.set_crossfader_control(self._crossfader) 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) def _get_num_tracks(self): return self.num_tracks def flash(self): for row in range(8): if self._button[row]._flash_state > 0: self._button[row].flash(self._timer) for column in range(8): button = self._grid[column][row] if button._flash_state > 0: button.flash(self._timer) def strobe(self): if self._backlight_type != 'static': if self._backlight_type is 'pulse': self._backlight = int(math.fabs(self._timer * 16 % 64 - 32) + 32) if self._backlight_type is 'up': self._backlight = int(self._timer * 8 % 64 + 16) if self._backlight_type is 'down': self._backlight = int(math.fabs(int(self._timer * 8 % 64 - 64)) + 16) self._send_midi(tuple([176, 27, int(self._backlight)])) if self._ohm_type != 'static': if self._ohm_type is 'pulse': self._ohm = int(math.fabs(self._timer * 16 % 64 - 32) + 32) if self._ohm_type is 'up': self._ohm = int(self._timer * 8 % 64 + 16) if self._ohm_type is 'down': self._ohm = int(math.fabs(int(self._timer * 8 % 64 - 64)) + 16) self._send_midi(tuple([176, 63, int(self._ohm)])) self._send_midi(tuple([176, 31, int(self._ohm)])) def deassign_matrix(self): with self.component_guard(): self._host._set_knobs(None) self._host._set_button_matrix(None) self._host.set_enabled(False) self._modNum.set_enabled(False) self.assign_alternate_mappings(0) self._scale_mode.set_mode_buttons(None) self._scale_mode.set_enabled(False) self._octave_mode.set_mode_buttons(None) self._octave_mode.set_enabled(False) self._session_zoom.set_enabled(False) self._session_zoom.set_nav_buttons(None, None, None, None) self._session.set_track_bank_buttons(None, None) self._session.set_scene_bank_buttons(None, None) self._transport.set_enabled(False) for column in range(4): self._mixer.track_eq(column)._gain_controls = None self._mixer.track_eq(column).set_enabled(False) for column in range(7): self._mixer.channel_strip(column).set_crossfade_toggle(None) self._mixer.channel_strip(column).set_mute_button(None) self._mixer.channel_strip(column).set_solo_button(None) self._mixer.channel_strip(column).set_arm_button(None) self._mixer.channel_strip(column).set_send_controls(None) self._mixer.channel_strip(column).set_pan_control(None) self._mixer.track_eq(column).set_enabled(False) for row in range(5): self._scene[row].clip_slot(column).set_launch_button(None) """for column in range(8): self._button[column]._on_value = SELECT_COLOR[self._rgb] for row in range(8): self._grid[column][row].set_enabled(True) self._grid[column][row].release_parameter() self._grid[column][row].use_default_message() self._grid[column][row].set_on_off_values(127, 0) self._grid[column][row].send_value(0, True)""" for column in range(8): self._button[column]._on_value = SELECT_COLOR[self._rgb] for row in range(8): #self._grid[column][row].set_channel(0) self._grid[column][row].release_parameter() self._grid[column][row].use_default_message() self._grid[column][row].set_enabled(True) self._grid[column][row].send_value(0, True) self._grid[column][row]._on_value = 127 self._grid[column][row]._off_value = 0 self._grid[column][row].force_next_send() for index in range(6): self._menu[index]._on_value = 127 self._menu[index]._off_value = 0 for index in range(16): self._dial[index].use_default_message() self._dial[index].release_parameter() self._device.set_parameter_controls(None) self._device.set_enabled(False) self._device_navigator.set_enabled(False) self._mixer.update() self._matrix.reset() self.request_rebuild_midi_map() def _assign_page_constants(self): with self.component_guard(): self._session_zoom.set_zoom_button(self._grid[7][7]) self._session_zoom.set_button_matrix(self._matrix) for column in range(7): self._mixer.channel_strip(column).set_select_button(self._button[column]) self._mixer.channel_strip(column).set_volume_control(self._fader[column]) self._mixer.master_strip().set_volume_control(self._fader[7]) self._mixer.master_strip().set_select_button(self._button[7]) self._mixer.set_prehear_volume_control(self._dial[15]) self._transport.set_play_button(self._menu[0]) self._menu[0].send_value(PLAY_COLOR[self._rgb], True) self._menu[0]._on_value = PLAY_COLOR[self._rgb] self._transport.set_stop_button(self._menu[1]) self._menu[1]._off_value = STOP_COLOR[self._rgb] self._menu[1]._on_value = STOP_COLOR[self._rgb] self._menu[1].send_value(STOP_COLOR[self._rgb], True) self._device_navigator.set_device_nav_buttons(self._menu[3], self._menu[4]) def assign_page_0(self): with self.component_guard(): self._backlight_type = 'static' self._session_zoom.set_enabled(True) for column in range(7): self._grid[column][5]._on_value = MUTE_COLOR[self._rgb] self._mixer.channel_strip(column).set_mute_button(self._grid[column][5]) self._grid[column][6]._on_value = SOLO_COLOR[self._rgb] self._mixer.channel_strip(column).set_solo_button(self._grid[column][6]) self._grid[column][7]._on_value = ARM_COLOR[self._rgb] self._mixer.channel_strip(column).set_arm_button(self._grid[column][7]) self._mixer.channel_strip(column).set_pan_control(self._dial[column + 8]) for row in range(5): self._scene[row].clip_slot(column).set_launch_button(self._grid[column][row]) for column in range(4): self._mixer.channel_strip(column).set_send_controls(tuple([self._dial[column], self._dial[column + 4]])) for index in range(5): self._grid[7][index]._off_value = SCENE_LAUNCH_COLOR[self._rgb] self._scene[index].set_launch_button(self._grid[7][index]) self._grid[7][index].set_force_next_value() self._grid[7][index].turn_off() for index in range(4): self._menu[2 + index]._on_value = NAV_BUTTON_COLOR[self._rgb] self._session.set_track_bank_buttons(self._menu[4], self._menu[3]) self._session.set_scene_bank_buttons(self._menu[5], self._menu[2]) self._menu[0]._on_value = PLAY_COLOR[self._rgb] self._menu[1]._off_value = STOP_COLOR[self._rgb] self._menu[1]._on_value = STOP_COLOR[self._rgb] self._transport.set_enabled(True) #self._mixer.update_all() self.request_rebuild_midi_map() #self.log_message('assign_page_0') def assign_page_1(self): with self.component_guard(): self._backlight_type = 'pulse' self._session_zoom.set_enabled(False) for column in range(4): for row in range(4): self._grid[column][row].send_value(DRUM_COLOR[self._rgb], True) self._grid[column + 4][row].send_value(BASS_COLOR[self._rgb], True) self._grid[column][row].set_enabled(False) self._grid[column][row]._msg_channel = PAGE1_DRUM_CHANNEL self._grid[column][row].set_identifier(PAGE1_DRUM_MAP[column][row]) self._grid[column + 4][row].set_enabled(False) self._grid[column + 4][row]._msg_channel = PAGE1_BASS_CHANNEL self._grid[column + 4][row].set_identifier(PAGE1_BASS_MAP[column][row]) scale_mode_buttons = [] for column in range(8): for row in range(3): self._grid[column][row + 4].set_enabled(False) self._grid[column][row + 4].send_value(KEYS_COLOR[self._rgb], True) self._grid[column][row + 4]._msg_channel = PAGE1_KEYS_CHANNEL self._grid[column][row + 4].set_identifier(int(PAGE1_KEYS_MAP[column][row]) + int(PAGE1_MODES_MAP[self._scale_mode._mode_index][column]) + int(self._octave_mode._mode_index * 12)) for row in range(1): scale_mode_buttons.append(self._grid[column][7]) self._scale_mode.set_mode_buttons(tuple(scale_mode_buttons)) self._scale_mode.set_enabled(True) self._octave_mode.set_mode_buttons(tuple([self._menu[5], self._menu[2]])) self._octave_mode.set_enabled(True) for column in range(7): self._mixer.channel_strip(column).set_send_controls(tuple([self._dial[column + 8]])) self._mixer.channel_strip(column).set_arm_button(self._button[column]) self._device.set_enabled(True) device_param_controls = [] for index in range(8): device_param_controls.append(self._dial[index]) self._device.set_parameter_controls(tuple(device_param_controls)) self._menu[0]._on_value = PLAY_COLOR[self._rgb] for index in range(4): self._menu[2 + index]._on_value = DEVICE_NAV_COLOR[self._rgb] self._device_navigator.set_enabled(True) self._menu[0]._on_value = PLAY_COLOR[self._rgb] self._menu[1]._off_value = STOP_COLOR[self._rgb] self._menu[1]._on_value = STOP_COLOR[self._rgb] self._transport.set_enabled(True) self.request_rebuild_midi_map() def assign_page_2(self): with self.component_guard(): self._backlight_type = 'up' self._session_zoom.set_enabled(True) for column in range(7): self._grid[column][5]._on_value = MUTE_COLOR[self._rgb] self._mixer.channel_strip(column).set_mute_button(self._grid[column][5]) self._grid[column][6]._on_value = CROSSFADE_ASSIGN_COLOR[self._rgb] self._mixer.channel_strip(column).set_crossfade_toggle(self._grid[column][6]) self._grid[column][7]._msg_channel = 2 self._grid[column][7].set_identifier(column) self._grid[column][7].reset() self._grid[column][7].set_enabled(False) self._grid[column][7].send_value(4, True) for row in range(5): self._scene[row].clip_slot(column).set_launch_button(self._grid[column][row]) for row in range(5): self._grid[7][row]._off_value = SCENE_LAUNCH_COLOR[self._rgb] self._scene[row].set_launch_button(self._grid[7][row]) self._grid[7][row].set_force_next_value() self._grid[7][row].turn_off() for column in range(4): self._mixer.track_eq(column).set_gain_controls(tuple([self._dial[column + 8], self._dial[column + 4], self._dial[column]])) self._mixer.track_eq(column).set_enabled(True) for column in range(3): self._mixer.channel_strip(column + 4).set_pan_control(self._dial[column + 12]) for index in range(4): self._menu[2 + index]._on_value = NAV_BUTTON_COLOR[self._rgb] self._session.set_track_bank_buttons(self._menu[4], self._menu[3]) self._session.set_scene_bank_buttons(self._menu[5], self._menu[2]) self._set_tempo_buttons([self._grid[7][5], self._grid[7][6]]) self._menu[0]._on_value = PLAY_COLOR[self._rgb] self._menu[1]._off_value = STOP_COLOR[self._rgb] self._menu[1]._on_value = STOP_COLOR[self._rgb] self._transport.set_enabled(True) #self._mixer.update() self.request_rebuild_midi_map() def assign_mod(self): with self.component_guard(): self.deassign_matrix() self._host.set_enabled(True) self._modNum.set_enabled(True) self._host._set_dial_matrix(self._dial_matrix, self._dial_button_matrix) self._host._set_button_matrix(self._mod_matrix) self._host._set_key_buttons(tuple(self._key)) if not self._host._active_client.is_connected(): self.assign_alternate_mappings(self._modNum._mode_index + 1) def modNum_update(self): if self._modNum._is_enabled == True: self.assign_alternate_mappings(0) self._host._select_client(int(self._modNum._mode_index)) self._host.display_active_client() if not self._host._active_client.is_connected(): self.assign_alternate_mappings(self._modNum._mode_index + 1) for button in self._modNum._modes_buttons: if self._modNum._mode_index == self._modNum._modes_buttons.index(button): button.send_value(1) else: button.send_value(self._client[self._modNum._modes_buttons.index(button)]._mod_color) def assign_alternate_mappings(self, chan): for column in range(8): for row in range(8): self._grid[column][row].set_channel(chan) for knob in self._encoder: knob.set_channel(chan) knob.set_enabled(chan is 0) self.request_rebuild_midi_map() def display_mod_colors(self): pass def _update_selected_device(self): if self._device_selection_follows_track_selection is True: 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.set_appointed_device(device_to_select) self.request_rebuild_midi_map() def handle_sysex(self, midi_bytes): if len(midi_bytes) > 10: if midi_bytes[:11] == tuple([240, 126, 0, 6, 2, 0, 1, 97, 1, 0, 7]): self.log_message(str('>>>color detected')) self._rgb = 0 elif midi_bytes[:11] == tuple([240, 126, 0, 6, 2, 0, 1, 97, 1, 0, 2]): self.log_message(str('>>>mono detected')) self._rgb = 1 self._assign_session_colors() def to_encoder(self, num, val): rv = int(val * 127) self._device._parameter_controls[num].receive_value(rv) p = self._device._parameter_controls[num]._parameter_to_map_to newval = val * (p.max - p.min) + p.min p.value = newval def set_local_ring_control(self, val = 1): self._local_ring_control = val != 0 def set_absolute_mode(self, val = 1): self._absolute_mode = val != 0 def send_ring_leds(self): """if self._host._is_enabled == True: leds = [240, 0, 1, 97, 8, 31] for index in range(12): wheel = self._encoder[index] bytes = wheel._get_ring() leds.append(bytes[0]) leds.append(int(bytes[1]) + int(bytes[2])) leds.append(247) self._send_midi(tuple(leds))""" pass def _set_tempo_buttons(self, buttons): if self._tempo_buttons != None: self._tempo_buttons[0].remove_value_listener(self._tempo_value) self._tempo_buttons[1].remove_value_listener(self._tempo_value) self._tempo_buttons = buttons if buttons != None: for button in buttons: assert isinstance(button, FlashingButtonElement) self._tempo_buttons[0].set_on_off_values(4, 0) self._tempo_buttons[0].add_value_listener(self._tempo_value, True) self._tempo_buttons[1].set_on_off_values(4, 0) self._tempo_buttons[1].add_value_listener(self._tempo_value, True) self._tempo_buttons[0].turn_on() self._tempo_buttons[1].turn_on() def _tempo_value(self, value, sender): if value > 0 and self._tempo_buttons.index(sender) == 0: self.song().tempo = round(min(self.song().tempo + 1, 999)) elif value > 0 and self._tempo_buttons.index(sender) == 1: self.song().tempo = round(max(self.song().tempo - 1, 20)) def generate_strip_string(self, display_string): NUM_CHARS_PER_DISPLAY_STRIP = 12 if not display_string: return ' ' * NUM_CHARS_PER_DISPLAY_STRIP if len(display_string.strip()) > NUM_CHARS_PER_DISPLAY_STRIP - 1 and display_string.endswith('dB') and display_string.find('.') != -1: display_string = display_string[:-2] if len(display_string) > NUM_CHARS_PER_DISPLAY_STRIP - 1: for um in [' ', 'i', 'o', 'u', 'e', 'a']: while len(display_string) > NUM_CHARS_PER_DISPLAY_STRIP - 1 and display_string.rfind(um, 1) != -1: um_pos = display_string.rfind(um, 1) display_string = display_string[:um_pos] + display_string[um_pos + 1:] else: display_string = display_string.center(NUM_CHARS_PER_DISPLAY_STRIP - 1) ret = u'' for i in range(NUM_CHARS_PER_DISPLAY_STRIP - 1): if ord(display_string[i]) > 127 or ord(display_string[i]) < 0: ret += ' ' else: ret += display_string[i] ret += ' ' return ret def notification_to_bridge(self, name, value, sender): if isinstance(sender, tuple([MonoEncoderElement2, CodecEncoderElement])): self._monobridge._send(sender.name, 'lcd_name', str(self.generate_strip_string(name))) self._monobridge._send(sender.name, 'lcd_value', str(self.generate_strip_string(value))) def touched(self): if self._touched is 0: self._monobridge._send('touch', 'on') self.schedule_message(2, self.check_touch) self._touched += 1 def check_touch(self): if self._touched > 5: self._touched = 5 elif self._touched > 0: self._touched -= 1 if self._touched is 0: self._monobridge._send('touch', 'off') else: self.schedule_message(2, self.check_touch) def get_clip_names(self): clip_names = [] for scene in self._session._scenes: for clip_slot in scene._clip_slots: if clip_slot.has_clip() is True: clip_names.append(clip_slot._clip_slot) return clip_slot._clip_slot return clip_names def shift_update(self): pass
class BlockMod(MonOhm): __module__ = __name__ __doc__ = " Monomodular controller script for Livid Block " def __init__(self, *a, **k): self._shift_button = None self._shift_pressed = 0 self._shift_pressed_timer = 0 self._shift_thresh = SHIFT_THRESH super(BlockMod, self).__init__(*a, **k) self._host_name = 'BlockMod' self._color_type = 'Monochrome' self._link_mixer = LINK_MIXER self._rgb = 1 self._ohm = 127 self._ohm_type = 'static' self._pad_translations = PAD_TRANSLATION self._mem = [4, 8, 12, 16] self._host._navbox_selected = 8 """script initialization methods""" def _setup_monobridge(self): self._monobridge = MonoBridgeElement(self) self._monobridge.name = 'MonoBridge' def _setup_controls(self): is_momentary = True self._fader = [None for index in range(8)] self._dial = [None for index in range(16)] self._button = [None for index in range(8)] self._menu = [None for index in range(6)] for index in range(2): self._fader[index] = MonoEncoderElement(MIDI_CC_TYPE, CHANNEL, SLIDER_CC[index], Live.MidiMap.MapMode.absolute, 'Fader_' + str(index), index, self) #for index in range(8): # self._button[index] = MonoButtonElement(is_momentary, MIDI_NOTE_TYPE, CHANNEL, OHM_BUTTONS[index], 'Button_' + str(index), self) for index in range(8): self._dial[index] = MonoEncoderElement(MIDI_CC_TYPE, CHANNEL, KNOB_CC[index], Live.MidiMap.MapMode.absolute, 'Dial_' + str(index), index + 8, self) for index in range(4): self._menu[index] = MonoButtonElement(is_momentary, MIDI_NOTE_TYPE, CHANNEL, FUNCTION_NOTES[index], 'Menu_' + str(index), self) self._livid = MonoButtonElement(is_momentary, MIDI_NOTE_TYPE, CHANNEL, LIVID, 'Livid_Button', self) self._shift_l = MonoButtonElement(is_momentary, MIDI_NOTE_TYPE, CHANNEL, SHIFT_L, 'Shift_Button_Left', self) self._shift_r = MonoButtonElement(is_momentary, MIDI_NOTE_TYPE, CHANNEL, SHIFT_R, 'Shift_Button_Right', self) self._matrix = ButtonMatrixElement() self._matrix.name = 'Matrix' self._monomod = ButtonMatrixElement() self._monomod.name = 'Monomod' self._grid = [None for index in range(8)] for column in range(8): self._grid[column] = [None for index in range(8)] for row in range(8): self._grid[column][row] = MonoButtonElement(is_momentary, MIDI_NOTE_TYPE, CHANNEL, (column * 8) + row, 'Grid_' + str(column) + '_' + str(row), self) for row in range(5): button_row = [] for column in range(7): button_row.append(self._grid[column][row]) self._matrix.add_row(tuple(button_row)) for row in range(8): button_row = [] for column in range(8): button_row.append(self._grid[column][row]) self._monomod.add_row(tuple(button_row)) self._dummy_button = ButtonElement(is_momentary, MIDI_NOTE_TYPE, 15, 125) self._dummy_button.name = 'Dummy1' self._dummy_button2 = ButtonElement(is_momentary, MIDI_NOTE_TYPE, 15, 126) self._dummy_button2.name = 'Dummy2' self._dummy_button3 = ButtonElement(is_momentary, MIDI_NOTE_TYPE, 15, 127) self._dummy_button2.name = 'Dummy3' def _setup_transport_control(self): self._transport = TransportComponent() self._transport.name = 'Transport' def _setup_crossfader(self): pass def _setup_modes(self): self._monomod_mode = MonomodModeComponent(self, self.monomod_mode_update) self._monomod_mode.name = 'Monomod_Mode' self.set_shift_button(self._livid) self._shift_mode = BlockModShiftModeComponent(self, self.shift_update) self._shift_mode.name = 'Shift_Mode' self._shift_mode.set_mode_toggle(self._shift_l, self._shift_r) self._l_function_mode = FunctionModeComponent(self, self.l_function_update) self._l_function_mode.name = 'Left_Function_Mode' self._r_function_mode = FunctionModeComponent(self, self.r_function_update) self._r_function_mode.name = 'Right_Function_Mode' self._m_function_mode = FunctionModeComponent(self, self.m_function_update) self._m_function_mode.name = 'Main_Function_Mode' self._function_modes = [self._l_function_mode, self._r_function_mode, self._m_function_mode] """livid double press mechanism""" def set_shift_button(self, button): assert ((button == None) or (isinstance(button, MonoButtonElement))) if self._shift_button != None: self._shift_button.remove_value_listener(self._shift_value) self._shift_button = button if self._shift_button != None: self._shift_button.add_value_listener(self._shift_value) def _shift_value(self, value): self._shift_pressed = int(value != 0) if self._shift_pressed > 0: if (self._shift_pressed_timer + self._shift_thresh) > self._timer: if(self._host._active_client != None): if(self._host.is_enabled() != True): self._monomod_mode.set_mode(1) else: self._monomod_mode.set_mode(0) else: self._shift_pressed_timer = self._timer % 256 if(self._cntrlr != None): self._cntrlr._monohm_shift(2) else: if(self._cntrlr != None): self._cntrlr._monohm_shift(0) """shift/zoom methods""" def deassign_matrix(self): self._session_zoom.set_button_matrix(None) self._session_zoom2.set_button_matrix(None) self._session.set_stop_track_clip_buttons(None) self._session2.set_stop_track_clip_buttons(None) self._session_zoom_main.set_button_matrix(None) self._session_main.set_stop_track_clip_buttons(None) for column in range(4): self._mixer2.channel_strip(column).set_select_button(None) self._mixer2.return_strip(column).set_mute_button(None) self._mixer2.return_strip(column).set_solo_button(None) self._mixer2.return_strip(column).set_arm_button(None) self._mixer2.return_strip(column).set_crossfade_toggle(None) self._mixer2.return_strip(column).set_select_button(None) #shouldn't this be somewhere else? self._mixer2.channel_strip(column).set_crossfade_toggle(None) self._mixer2.channel_strip(column).set_mute_button(None) self._mixer2.channel_strip(column).set_solo_button(None) self._mixer2.channel_strip(column).set_arm_button(None) for row in range(5): self._scene[row].clip_slot(column).set_launch_button(None) self._scene2[row].clip_slot(column).set_launch_button(None) for index in range(5): self._scene[index].set_launch_button(None) self._scene2[index].set_launch_button(None) self._scene_main[index].set_launch_button(None) self._session_zoom.set_nav_buttons(None, None, None, None) self._session_zoom2.set_nav_buttons(None, None, None, None) self._session_zoom_main.set_nav_buttons(None, None, None, None) self._session.set_track_bank_buttons(None, None) self._session.set_scene_bank_buttons(None, None) self._session2.set_track_bank_buttons(None, None) self._session2.set_scene_bank_buttons(None, None) self._session_main.set_track_bank_buttons(None, None) self._session_main.set_scene_bank_buttons(None, None) for column in range(8): self._mixer.channel_strip(column).set_select_button(None) self._mixer.channel_strip(column).set_crossfade_toggle(None) self._mixer.channel_strip(column).set_mute_button(None) self._mixer.channel_strip(column).set_solo_button(None) self._mixer.channel_strip(column).set_arm_button(None) for row in range(5): self._scene_main[row].clip_slot(column).set_launch_button(None) for row in range(8): self._grid[column][row].set_channel(0) self._grid[column][row].release_parameter() self._grid[column][row].use_default_message() self._grid[column][row].set_enabled(True) self._grid[column][row].set_on_off_values(127, 0) self._grid[column][row].send_value(0, True) self._send_reset.set_buttons(tuple(None for index in range(4))) def zoom_off(self): for column in range(4): self._grid[column][5].set_on_value(MUTE[self._rgb]) self._mixer.channel_strip(column).set_mute_button(self._grid[column][5]) self._grid[column][6].set_on_value(ARM[self._rgb]) self._mixer.channel_strip(column).set_arm_button(self._grid[column][6]) for row in range(5): self._scene[row].clip_slot(column).set_launch_button(self._grid[column][row]) if(self._r_function_mode._mode_index in range(0,3)): self._grid[column + 4][5].set_on_value(MUTE[self._rgb]) self._mixer2.channel_strip(column).set_mute_button(self._grid[column + 4][5]) self._grid[column + 4][6].set_on_value(ARM[self._rgb]) self._mixer2.channel_strip(column).set_arm_button(self._grid[column + 4][6]) for row in range(5): self._scene2[row].clip_slot(column).set_launch_button(self._grid[column + 4][row]) elif(self._r_function_mode._mode_index is 3): self._grid[column + 4][5].set_on_value(MUTE[self._rgb]) self._mixer2.return_strip(column).set_mute_button(self._grid[column + 4][5]) for row in range(5): self._grid[column + 4][row].send_value(USER1_COLOR[self._rgb], True) self._grid[column + 4][row].set_channel(RIGHT_USER1_CHANNEL) self._grid[column + 4][row].set_identifier(RIGHT_USER1_MAP[column][row]) self._grid[column + 4][row].set_enabled(False) #this has to happen for translate to work #self._session_zoom2.set_ignore_buttons(True) if(self._r_function_mode._mode_index is 0): for index in range(4): self._grid[index + 4][7].send_value(SEND_RESET[self._rgb], True) self._send_reset.set_buttons(tuple(self._grid[index + 4][7] for index in range(4))) def zoom_off_m(self): self.deassign_dials() for column in range(8): self._grid[column][5].set_on_value(MUTE[self._rgb]) self._mixer.channel_strip(column).set_mute_button(self._grid[column][5]) self._grid[column][6].set_on_value(ARM[self._rgb]) self._mixer.channel_strip(column).set_arm_button(self._grid[column][6]) for row in range(5): self._scene_main[row].clip_slot(column).set_launch_button(self._grid[column][row]) #self._session_zoom.set_button_matrix(self._matrix) def zoom_left(self): track_stop_buttons = [] track_stop_buttons2 = [] for index in range(4): self._grid[index][6].set_off_value(TRACK_STOP[self._rgb]) track_stop_buttons.append(self._grid[index][6]) self._grid[index + 4][6].set_off_value(TRACK_STOP[self._rgb]) track_stop_buttons2.append(self._grid[index + 4][6]) for index in range(5): self._grid[7][index].set_off_value(SCENE_LAUNCH[self._rgb]) self._scene[index].set_launch_button(self._grid[7][index]) self._session.set_stop_track_clip_buttons(tuple(track_stop_buttons)) self._session2.set_stop_track_clip_buttons(tuple(track_stop_buttons2)) self._session_zoom.set_button_matrix(self._matrix) self._grid[0][5].set_on_value(RECORD[self._rgb]) self._transport.set_record_button(self._grid[0][5]) self._grid[1][5].set_on_value(OVERDUB[self._rgb]) self._transport.set_overdub_button(self._grid[1][5]) self._grid[2][5].set_on_value(LOOP[self._rgb]) self._transport.set_loop_button(self._grid[2][5]) self._grid[3][5].set_on_value(STOP_ALL[self._rgb]) self._session.set_stop_all_clips_button(self._grid[3][5]) for index in range(4): self._grid[index + 4][5].send_value(SEND_RESET[self._rgb], True) self._send_reset.set_buttons(tuple(self._grid[index + 4][5] for index in range(4))) for index in range(4): self._grid[index + 4][7].set_off_value(DEVICE_SELECT[self._rgb]) self._device_selector.assign_buttons(tuple(self._grid[index + 4][7] for index in range(4)), 4) def zoom_right(self): track_stop_buttons = [] track_stop_buttons2 = [] for index in range(4): self._grid[index][6].set_off_value(TRACK_STOP[self._rgb]) track_stop_buttons.append(self._grid[index][6]) for index in range(5): self._grid[7][index].set_off_value(SCENE_LAUNCH[self._rgb]) self._scene2[index].set_launch_button(self._grid[7][index]) self._session.set_stop_track_clip_buttons(tuple(track_stop_buttons)) if(self._r_function_mode._mode_index < 3): for index in range(4): self._grid[index + 4][6].set_off_value(TRACK_STOP[self._rgb]) track_stop_buttons2.append(self._grid[index + 4][6]) self._session2.set_stop_track_clip_buttons(tuple(track_stop_buttons2)) self._session_zoom2.set_button_matrix(self._matrix) self._grid[0][5].set_on_value(RECORD[self._rgb]) self._transport.set_record_button(self._grid[0][5]) self._grid[1][5].set_on_value(OVERDUB[self._rgb]) self._transport.set_overdub_button(self._grid[1][5]) self._grid[2][5].set_on_value(LOOP[self._rgb]) self._transport.set_loop_button(self._grid[2][5]) self._grid[3][5].set_on_value(STOP_ALL[self._rgb]) self._session.set_stop_all_clips_button(self._grid[3][5]) for index in range(4): self._grid[index + 4][5].send_value(SEND_RESET[self._rgb], True) self._send_reset.set_buttons(tuple(self._grid[index + 4][5] for index in range(4))) for index in range(4): self._grid[index][7].set_off_value(DEVICE_SELECT[self._rgb]) self._device_selector.assign_buttons(tuple(self._grid[index][7] for index in range(4)), 0) def zoom_main(self): track_stop_buttons = [] for index in range(8): self._grid[index][6].set_on_value(TRACK_STOP[self._rgb]) track_stop_buttons.append(self._grid[index][6]) for index in range(5): self._grid[7][index].set_on_value(SCENE_LAUNCH[self._rgb]) self._scene_main[index].set_launch_button(self._grid[7][index]) self._session_main.set_stop_track_clip_buttons(tuple(track_stop_buttons)) self._session_zoom_main.set_button_matrix(self._matrix) self._grid[0][5].set_on_value(RECORD[self._rgb]) self._transport.set_record_button(self._grid[0][5]) self._grid[1][5].set_on_value(OVERDUB[self._rgb]) self._transport.set_overdub_button(self._grid[1][5]) self._grid[2][5].set_on_value(LOOP[self._rgb]) self._transport.set_loop_button(self._grid[2][5]) self._grid[3][5].set_on_value(STOP_ALL[self._rgb]) self._session.set_stop_all_clips_button(self._grid[3][5]) for index in range(4): self._grid[index + 4][5].send_value(SEND_RESET[self._rgb], True) self._send_reset.set_buttons(tuple(self._grid[index + 4][5] for index in range(4))) for index in range(4): self._grid[index + 4][7].set_off_value(DEVICE_SELECT[self._rgb]) self._device_selector.assign_buttons(tuple(self._grid[index + 4][7] for index in range(4)), 4) """function mode callbacks""" def l_function_update(self): mode = self._l_function_mode._mode_index #if(self._l_function_mode.is_enabled() is False): # self._l_function_mode.set_mode_buttons(None) if(self._l_function_mode.is_enabled() is True): if(len(self._l_function_mode._modes_buttons) is 0): for index in range(4): self._mixer.channel_strip(index).set_select_button(None) buttons = [] for index in range(4): buttons.append(self._grid[index][7]) self._l_function_mode.set_mode_buttons(tuple(buttons)) if(self._shift_mode._mode_index is 2): for index in range(4): if(mode != index): self._grid[index][7].turn_off() else: self._grid[index][7].turn_on() if(mode is 0): self.assign_device_dials() self.show_message('Mixer Split:Dials Device Mode') elif(mode is 1): self.assign_send_dials() self.show_message('Mixer Split:Dials Send Mode') elif(mode is 2): self.assign_split_volume_dials() self.show_message('Mixer Split:Dials Volume Mode') elif(mode is 3): self.assign_user_dials() self.show_message('Mixer Split:Dials User Map Mode') def r_function_update(self): mode = self._r_function_mode._mode_index #if(self._r_function_mode.is_enabled() is False): # self._r_function_mode.set_mode_buttons(None) #self._session2.set_show_highlight(False) #self._session._highlighting_callback(self._session._track_offset, self._session._scene_offset, 4, 5, 1) if(self._r_function_mode.is_enabled() is True): if(len(self._r_function_mode._modes_buttons) is 0): for index in range(4): self._mixer2.channel_strip(index).set_select_button(None) buttons = [] for index in range(4): buttons.append(self._grid[index + 4][7]) self._r_function_mode.set_mode_buttons(tuple(buttons)) if(self._shift_mode._mode_index is 3): for index in range(4): if(mode != index): self._grid[index + 4][7].turn_off() else: self._grid[index + 4][7].turn_on() self._session2.set_offsets(int(self._mem[mode]), self._session2._scene_offset) self.show_message('Mixer Split: Track Offset' + str(RIGHT_MODE_OFFSETS[mode])) def m_function_update(self): mode = self._m_function_mode._mode_index #if(self._m_function_mode.is_enabled() is False): # self._m_function_mode.set_mode_buttons(None) #self._session.set_show_highlight(False) #self._session2.set_show_highlight(False) #self._session_main._highlighting_callback(self._session_main._track_offset, self._session_main._scene_offset, 8, 5, 1) if(self._m_function_mode.is_enabled() is True): if(len(self._m_function_mode._modes_buttons) is 0): for index in range(8): self._mixer.channel_strip(index).set_select_button(None) buttons = [] for index in range(4): buttons.append(self._grid[index][7]) self._m_function_mode.set_mode_buttons(tuple(buttons)) if(self._shift_mode._mode_index is 4): for index in range(4): if(mode != index): self._grid[index][7].turn_off() else: self._grid[index][7].turn_on() if(mode is 0): self.assign_device_dials() self.show_message('Mixer Linked:Dials Device Mode') elif(mode is 1): self.assign_send_dials() self.show_message('Mixer Linked:Dials Send Mode') elif(mode is 2): self.assign_volume_dials() self.show_message('Mixer Linked:Dials Volume Mode') elif(mode is 3): self.assign_user_dials() self.show_message('Mixer Linked:Dials User Map Mode') def shift_update(self): self._clutch_device_selection = True #self.allow_updates(False) #if(not self._in_build_midi_map): # self.set_suppress_rebuild_requests(True) self.deassign_channel_select_buttons() self.deassign_matrix() self.deassign_menu() if(self._monomod_mode._mode_index is 0): #if monomod is not on if(self._shift_mode._mode_index is 0): #if no shift is pressed self._shift_mode._mode_toggle1.turn_off() self._shift_mode._mode_toggle2.turn_off() if(self.split_mixer() is False): self.set_split_mixer(True) for zoom in self._zooms: zoom._on_zoom_value(0) self.zoom_off() self._device_selector.set_enabled(False) for mode in self._function_modes: mode.set_enabled(False) self.assign_channel_select_buttons() #self._recalculate_selected_channel() #self.assign_transport_to_menu() self.assign_session_nav_to_menu() self.l_function_update() self.r_function_update() self.assign_crossfader() self.set_highlighting_session_component(self._session) self._session._do_show_highlight() #self._session.set_show_highlight(True) elif(self._shift_mode._mode_index is 1): #if no shift is pressed, but mixer is linked self._shift_mode._mode_toggle1.turn_on() self._shift_mode._mode_toggle2.turn_on() if(self.split_mixer() is True): self.set_split_mixer(False) for zoom in self._zooms: zoom._on_zoom_value(0) self.zoom_off_m() self._device_selector.set_enabled(False) for mode in self._function_modes: mode.set_enabled(False) self.assign_main_channel_select_buttons() self.assign_session_main_nav_to_menu() self.m_function_update() self.assign_crossfader() self.set_highlighting_session_component(self._session_main) self._session_main._do_show_highlight() elif(self._shift_mode._mode_index > 1): #if a shift is pressed self.assign_device_nav_to_menu() self.deassign_channel_select_buttons() if(self._shift_mode._mode_index is 2): #if shift left self._shift_mode._mode_toggle1.turn_on() self.zoom_left() self._session_zoom._on_zoom_value(1) self._session.set_enabled(True) #this is a workaround so that the stop buttons still function self._l_function_mode.set_enabled(True) self.set_highlighting_session_component(self._session) self._session._do_show_highlight() elif(self._shift_mode._mode_index is 3): #if shift right self._shift_mode._mode_toggle2.turn_on() self.zoom_right() self._session_zoom2._on_zoom_value(1) self._session2.set_enabled(True) #this is a workaround so that the stop buttons still function self._r_function_mode.set_enabled(True) self.assign_master_fader() if(self._r_function_mode._mode_index < 4): self.set_highlighting_session_component(self._session2) self._session2._do_show_highlight() elif(self._shift_mode._mode_index is 4): #if either shift pressed while mixer is linked self._shift_mode._mode_toggle1.turn_on() self._shift_mode._mode_toggle2.turn_on() self.zoom_main() self._session_zoom_main._on_zoom_value(1) self._session_main.set_enabled(True) #this is a workaround so that the stop buttons still function self._m_function_mode.set_enabled(True) self.assign_master_fader() self.set_highlighting_session_component(self._session_main) self._session_main._do_show_highlight() self._device_selector.set_enabled(True) self.allow_updates(True) #self.set_suppress_rebuild_requests(False) self._clutch_device_selection = False if(self._shift_mode._mode_index < 2): self._monobridge._send('touch', 'off') else: self._monobridge._send('touch', 'on') def monomod_mode_update(self): if (self._monomod_mode._mode_index == 0) or (self._host._active_client == None): self._host.set_enabled(False) self._host._set_button_matrix(None) self._host._set_nav_buttons(None) self._host._set_lock_button(None) self._host._set_alt_button(None) self._host._set_shift_button(None) self._livid.turn_off() self._shift_mode.set_mode_toggle(self._shift_l, self._shift_r) self._shift_mode.update() #self._session._reassign_scenes() elif(self._monomod_mode._mode_index == 1): self._livid.turn_on() self.deassign_matrix() self.deassign_menu() self._monomod.reset() self._host._set_button_matrix(self._monomod) self._host._set_nav_buttons(self._menu[0:4]) self._host._set_lock_button(self._shift_l) self._host._set_alt_button(self._shift_r) self._host._set_shift_button(self._livid) self._shift_mode.set_mode_toggle(None, None) self._host.set_enabled(True) self._shift_mode.update() #self.show_message('Monomod grid enabled') """left control management methods""" def deassign_dials(self): for index in range(8): self._dial[index].use_default_message() self._dial[index].release_parameter() self._dial[index].set_enabled(True) if(self._device._parameter_controls != None): for control in self._device._parameter_controls: control.release_parameter() self._device._parameter_controls = None self._mixer.selected_strip().set_send_controls(None) self._mixer.selected_strip().set_volume_control(None) for track in range(4): self._mixer.channel_strip(track).set_volume_control(None) self._mixer.channel_strip(track+4).set_volume_control(None) self._mixer2.channel_strip(track).set_volume_control(None) self._mixer2.return_strip(track).set_volume_control(None) def assign_device_dials(self): self._ohm_type = OHM_TYPE[0] self._ohm = OHM_VALUE[0] self.deassign_dials() self._device.set_enabled(True) device_param_controls = [] for index in range(8): device_param_controls.append(self._dial[index]) self._device.set_parameter_controls(tuple(device_param_controls)) self._mixer.selected_strip().set_volume_control(self._fader[0]) def assign_send_dials(self): self._ohm_type = OHM_TYPE[1] self._ohm = OHM_VALUE[1] self.deassign_dials() dials = [] for index in range(4): dials.append(self._dial[index]) for index in range(4): if(self._mixer2.return_strip(index)): self._mixer2.return_strip(index).set_volume_control(self._dial[index + 4]) self._mixer.selected_strip().set_send_controls(tuple(dials)) self._mixer.selected_strip().set_volume_control(self._fader[0]) def assign_volume_dials(self): self._ohm_type = OHM_TYPE[2] self._ohm = OHM_VALUE[2] self.deassign_dials() for track in range(8): self._mixer.channel_strip(track).set_volume_control(self._dial[track]) self._mixer.selected_strip().set_volume_control(self._fader[0]) def assign_split_volume_dials(self): self._ohm_type = OHM_TYPE[2] self._ohm = OHM_VALUE[2] self.deassign_dials() for track in range(4): self._mixer.channel_strip(track).set_volume_control(self._dial[track]) self._mixer2.channel_strip(track).set_volume_control(self._dial[track+4]) self._mixer.selected_strip().set_volume_control(self._fader[0]) def assign_user_dials(self): self._ohm_type = OHM_TYPE[3] self._ohm = OHM_VALUE[3] self.deassign_dials() for index in range(8): self._dial[index].set_channel(L_USER_DIAL_CHAN) self._dial[index].set_identifier(L_USER_DIAL_MAP[index]) self._dial[index].set_enabled(False) self._mixer.selected_strip().set_volume_control(self._fader[0]) """menu button management methods""" def deassign_menu(self): self._device.set_lock_button(None) self._device.set_on_off_button(None) self._device_navigator.set_device_nav_buttons(None, None) self._device.set_bank_nav_buttons(None, None) self._transport.set_play_button(None) self._transport.set_record_button(None) self._transport.set_stop_button(None) self._transport.set_loop_button(None) self._transport.set_overdub_button(None) self._session.set_stop_all_clips_button(None) self._transport.set_play_button(None) self._transport.set_stop_button(None) self._session_main.set_track_bank_buttons(None, None) self._session_main.set_scene_bank_buttons(None, None) def assign_device_nav_to_menu(self): self._device_navigator.set_device_nav_buttons(self._menu[2], self._menu[3]) self._device.set_bank_nav_buttons(self._menu[0], self._menu[1]) def assign_transport_to_menu(self): self._transport.set_play_button(self._menu[0]) self._transport.set_record_button(self._menu[2]) self._transport.set_stop_button(self._menu[1]) session.set_stop_all_clips_button(self._menu[3]) def assign_session_nav_to_menu(self): self._session.set_track_bank_buttons(self._menu[3], self._menu[2]) self._session.set_scene_bank_buttons(self._menu[1], self._menu[0]) def assign_monomod_shift_to_menu(self): self._device_navigator.set_device_nav_buttons(self._menu[3], self._menu[2]) self._device.set_bank_nav_buttons(self._menu[1], self._menu[0]) def assign_session_bank_to_menu(self): self._session.set_track_bank_buttons(self._menu[3], self._menu[2]) self._session.set_scene_bank_buttons(self._menu[1], self._menu[0]) def assign_session2_bank_to_menu(self): self._session2.set_track_bank_buttons(self._menu[3], self._menu[2]) self._session2.set_scene_bank_buttons(self._menu[1], self._menu[0]) def assign_session_main_nav_to_menu(self): self._session_main.set_track_bank_buttons(self._menu[3], self._menu[2]) self._session_main.set_scene_bank_buttons(self._menu[1], self._menu[0]) """channel selection management methods""" def deassign_channel_select_buttons(self): for index in range(8): if(self._mixer.channel_strip(index)): self._mixer.channel_strip(index).set_select_button(None) self._grid[index][7].release_parameter() for index in range(4): self._mixer2.channel_strip(index).set_select_button(None) self._mixer2.return_strip(index).set_select_button(None) self._mixer2.master_strip().set_select_button(None) self._grid[index + 4][7].release_parameter() def assign_channel_select_buttons(self): for index in range(4): #if(self._mixer.channel_strip(index)): self._grid[index][7].set_on_off_values(127, 0) self._mixer.channel_strip(index).set_select_button(self._grid[index][7]) if(self._r_function_mode._mode_index < 3): for index in range(4): self._grid[index][7].set_on_off_values(127, 0) self._mixer2.channel_strip(index).set_select_button(self._grid[index + 4][7]) else: for index in range(4): self._grid[index][7].set_on_off_values(1, 0) self._mixer2.return_strip(index).set_select_button(self._grid[index + 4][7]) def assign_return_select_buttons(self): for index in range(4): self._grid[index + 4][7].set_off_value(0) if(self._mixer.channel_strip(index)): self._grid[index + 4][7].set_on_value(1) self._mixer.channel_strip(index).set_select_button(self._grid[index + 4][7]) def assign_l_channel_select_buttons(self): self._mixer.set_select_buttons(None, None) self._session.set_select_buttons(None, None) for index in range(4): self._grid[index][7].set_off_value(0) if(self._mixer.channel_strip(index)): self._mixer.channel_strip(index).set_select_button(self._grid[index][7]) def assign_r_channel_select_buttons(self): self._mixer2.set_select_buttons(None, None) self._session2.set_select_buttons(None, None) for index in range(4): self._grid[index + 4][7].set_off_value(0) if(self._mixer2.channel_strip(index)): self._mixer2.channel_strip(index).set_select_button(self._grid[index + 4][7]) def assign_main_channel_select_buttons(self): for index in range(8): self._grid[index][7].set_off_value(0) if(self._mixer.channel_strip(index)): self._grid[index][7].set_on_value(127) self._mixer.channel_strip(index).set_select_button(self._grid[index][7]) def assign_master_fader(self): self._mixer.set_crossfader_control(None) self._mixer.master_strip().set_volume_control(self._fader[1]) def assign_crossfader(self): self._mixer.master_strip().set_volume_control(None) self._mixer.set_crossfader_control(self._fader[1]) """called on timer""" def update(self): super(BlockMod, self).update_display() if(self._timer == 0): self._shift_pressed_timer = -12 def strobe(self): if(self._ohm_type != 'static'): if(self._ohm_type is 'pulse'): self._ohm = int(math.fabs(((self._timer * 8) % 64) -32) +32) if(self._ohm_type is 'up'): self._ohm = int(((self._timer * 4) % 64) + 16) if(self._ohm_type is 'down'): self._ohm = int(math.fabs(int(((self._timer * 4) % 64) - 64)) + 16) self._send_midi(tuple([176, 63, int(self._ohm)])) self._send_midi(tuple([176, 31, int(self._ohm)])) def handle_sysex(self, midi_bytes): pass def _on_session_offset_changes(self): if self._r_function_mode._mode_index in range(0,4): self._mem[int(self._r_function_mode._mode_index)] = self._session2.track_offset() # a
class AumPC40(APC): __doc__ = " Script for Akai's APC40 Controller " def __init__(self, c_instance): APC.__init__(self, c_instance) self._device_selection_follows_track_selection = True def _setup_session_control(self): is_momentary = True self._shift_button = FlashingButtonElement(is_momentary, MIDI_NOTE_TYPE, 0, 98, self) right_button = FlashingButtonElement(is_momentary, MIDI_NOTE_TYPE, 0, 96, self) self._right_button = right_button left_button = FlashingButtonElement(is_momentary, MIDI_NOTE_TYPE, 0, 97, self) self._left_button = left_button up_button = FlashingButtonElement(is_momentary, MIDI_NOTE_TYPE, 0, 94, self) self._up_button = up_button down_button = FlashingButtonElement(is_momentary, MIDI_NOTE_TYPE, 0, 95, self) self._down_button = down_button right_button.name = 'Bank_Select_Right_Button' left_button.name = 'Bank_Select_Left_Button' up_button.name = 'Bank_Select_Up_Button' down_button.name = 'Bank_Select_Down_Button' self._session = PedaledSessionComponent(8, 5) self._session.name = 'Session_Control' self._session.set_track_bank_buttons(right_button, left_button) self._session.set_scene_bank_buttons(down_button, up_button) matrix = ButtonMatrixElement() self._matrix = matrix # added a matrix.name = 'Button_Matrix' scene_launch_buttons = [ ButtonElement(is_momentary, MIDI_NOTE_TYPE, 0, (index + 82)) for index in range(5) ] track_stop_buttons = [ FlashingButtonElement(is_momentary, MIDI_NOTE_TYPE, index, 52, self) for index in range(8) ] self._track_stop_buttons = track_stop_buttons # added a for index in range(len(scene_launch_buttons)): scene_launch_buttons[index].name = 'Scene_'+ str(index) + '_Launch_Button' for index in range(len(track_stop_buttons)): track_stop_buttons[index].name = 'Track_' + str(index) + '_Stop_Button' stop_all_button = ButtonElement(is_momentary, MIDI_NOTE_TYPE, 0, 81) stop_all_button.name = 'Stop_All_Clips_Button' self._session.set_stop_all_clips_button(stop_all_button) self._session.set_stop_track_clip_buttons(tuple(track_stop_buttons)) self._session.set_stop_track_clip_value(2) for scene_index in range(5): scene = self._session.scene(scene_index) scene.name = 'Scene_' + str(scene_index) button_row = [] scene.set_launch_button(scene_launch_buttons[scene_index]) scene.set_triggered_value(2) for track_index in range(8): button = FlashingButtonElement(is_momentary, MIDI_NOTE_TYPE, track_index, (scene_index + 53), self) button.name = str(track_index) + '_Clip_' + str(scene_index) + '_Button' button_row.append(button) clip_slot = scene.clip_slot(track_index) clip_slot.name = str(track_index) + '_Clip_Slot_' + str(scene_index) clip_slot.set_triggered_to_play_value(2) clip_slot.set_triggered_to_record_value(4) clip_slot.set_stopped_value(5) clip_slot.set_started_value(1) clip_slot.set_recording_value(3) clip_slot.set_launch_button(button) matrix.add_row(tuple(button_row)) self._session.set_slot_launch_button(ButtonElement(is_momentary, MIDI_CC_TYPE, 0, 67)) self._session.selected_scene().name = 'Selected_Scene' self._session.selected_scene().set_launch_button(ButtonElement(is_momentary, MIDI_CC_TYPE, 0, 64)) self._session_zoom = SessionZoomingComponent(self._session) self._session_zoom.name = 'Session_Overview' self._session_zoom.set_button_matrix(matrix) self._session_zoom.set_zoom_button(self._shift_button) self._session_zoom.set_nav_buttons(up_button, down_button, left_button, right_button) self._session_zoom.set_scene_bank_buttons(tuple(scene_launch_buttons)) self._session_zoom.set_stopped_value(3) self._session_zoom.set_selected_value(5) return None def _setup_mixer_control(self): is_momentary = True self._mixer = SpecialMixerComponent(8) self._mixer.name = 'Mixer' self._mixer.master_strip().name = 'Master_Channel_Strip' self._mixer.selected_strip().name = 'Selected_Channel_Strip' self._solo_buttons = [] # added a self._select_buttons = [] # added a for track in range(8): strip = self._mixer.channel_strip(track) strip.name = 'Channel_Strip_' + str(track) volume_control = MonoEncoderElement2(MIDI_CC_TYPE, track, 7, Live.MidiMap.MapMode.absolute, 'Slider_' + str(track), track, self) arm_button = ButtonElement(is_momentary, MIDI_NOTE_TYPE, track, 48) solo_button = FlashingButtonElement(is_momentary, MIDI_NOTE_TYPE, track, 50, self) self._solo_buttons.append(solo_button) # added a mute_button = ButtonElement(is_momentary, MIDI_NOTE_TYPE, track, 49) select_button = FlashingButtonElement(is_momentary, MIDI_NOTE_TYPE, track, 51, self) self._select_buttons.append(select_button) # added a #volume_control.name = str(track) + '_Volume_Control' arm_button.name = str(track) + '_Arm_Button' solo_button.name = str(track) + '_Solo_Button' mute_button.name = str(track) + '_Mute_Button' select_button.name = str(track) + '_Select_Button' strip.set_volume_control(volume_control) strip.set_arm_button(arm_button) strip.set_solo_button(solo_button) strip.set_mute_button(mute_button) strip.set_select_button(select_button) strip.set_shift_button(self._shift_button) strip.set_invert_mute_feedback(True) crossfader = SliderElement(MIDI_CC_TYPE, 0, 15) master_volume_control = SliderElement(MIDI_CC_TYPE, 0, 14) master_select_button = ButtonElement(is_momentary, MIDI_NOTE_TYPE, 0, 80) self._master_select_button = master_select_button prehear_control = EncoderElement(MIDI_CC_TYPE, 0, 47, Live.MidiMap.MapMode.relative_two_compliment) crossfader.name = 'Crossfader' master_volume_control.name = 'Master_Volume_Control' master_select_button.name = 'Master_Select_Button' prehear_control.name = 'Prehear_Volume_Control' self._mixer.set_crossfader_control(crossfader) self._mixer.set_prehear_volume_control(prehear_control) self._mixer.master_strip().set_volume_control(master_volume_control) self._mixer.master_strip().set_select_button(master_select_button) def _setup_custom_components(self): self._setup_device_and_transport_control() self._setup_global_control() def _setup_device_and_transport_control(self): is_momentary = True device_bank_buttons = [] device_param_controls = [] bank_button_labels = ('Clip_Track_Button', 'Device_On_Off_Button', 'Previous_Device_Button', 'Next_Device_Button', 'Detail_View_Button', 'Rec_Quantization_Button', 'Midi_Overdub_Button', 'Metronome_Button') for index in range(8): device_bank_buttons.append(ButtonElement(is_momentary, MIDI_NOTE_TYPE, 0, 58 + index)) device_bank_buttons[-1].name = bank_button_labels[index] ring_mode_button = ButtonElement(not is_momentary, MIDI_CC_TYPE, 0, 24 + index) ringed_encoder = MonoRingedEncoderElement(MIDI_CC_TYPE, 0, 16 + index, Live.MidiMap.MapMode.absolute, index, self) ringed_encoder.set_ring_mode_button(ring_mode_button) ringed_encoder.name = 'Device_Control_' + str(index) ring_mode_button.name = ringed_encoder.name + '_Ring_Mode_Button' device_param_controls.append(ringed_encoder) device = ShiftableDeviceComponent(self) device.name = 'Device_Component' device.set_bank_buttons(tuple(device_bank_buttons)) device.set_shift_button(self._shift_button) device.set_parameter_controls(tuple(device_param_controls)) device.set_on_off_button(device_bank_buttons[1]) self.set_device_component(device) detail_view_toggler = DetailViewCntrlComponent() detail_view_toggler.name = 'Detail_View_Control' detail_view_toggler.set_shift_button(self._shift_button) detail_view_toggler.set_device_clip_toggle_button(device_bank_buttons[0]) detail_view_toggler.set_detail_toggle_button(device_bank_buttons[4]) detail_view_toggler.set_device_nav_buttons(device_bank_buttons[2], device_bank_buttons[3]) transport = ShiftableTransportComponent() transport.name = 'Transport' self._transport = transport play_button = ButtonElement(is_momentary, MIDI_NOTE_TYPE, 0, 91) stop_button = ButtonElement(is_momentary, MIDI_NOTE_TYPE, 0, 92) record_button = ButtonElement(is_momentary, MIDI_NOTE_TYPE, 0, 93) nudge_up_button = FlashingButtonElement(is_momentary, MIDI_NOTE_TYPE, 0, 100, self) self._nudge_up_button = nudge_up_button nudge_down_button = FlashingButtonElement(is_momentary, MIDI_NOTE_TYPE, 0, 101, self) self._nudge_down_button = nudge_down_button tap_tempo_button = ButtonElement(is_momentary, MIDI_NOTE_TYPE, 0, 99) play_button.name = 'Play_Button' stop_button.name = 'Stop_Button' record_button.name = 'Record_Button' nudge_up_button.name = 'Nudge_Up_Button' nudge_down_button.name = 'Nudge_Down_Button' tap_tempo_button.name = 'Tap_Tempo_Button' transport.set_shift_button(self._shift_button) transport.set_play_button(play_button) transport.set_stop_button(stop_button) transport.set_record_button(record_button) transport.set_nudge_buttons(nudge_up_button, nudge_down_button) transport.set_tap_tempo_button(tap_tempo_button) transport.set_quant_toggle_button(device_bank_buttons[5]) transport.set_overdub_button(device_bank_buttons[6]) transport.set_metronome_button(device_bank_buttons[7]) bank_button_translator = ShiftTranslatorComponent() bank_button_translator.set_controls_to_translate(tuple(device_bank_buttons)) bank_button_translator.set_shift_button(self._shift_button) def _setup_global_control(self): is_momentary = True global_bank_buttons = [] global_param_controls = [] for index in range(8): ring_button = ButtonElement(not is_momentary, MIDI_CC_TYPE, 0, 56 + index) ringed_encoder = MonoRingedEncoderElement(MIDI_CC_TYPE, 0, 48 + index, Live.MidiMap.MapMode.absolute, index + 8, self) ringed_encoder.name = 'Track_Control_' + str(index) ring_button.name = ringed_encoder.name + '_Ring_Mode_Button' ringed_encoder.set_ring_mode_button(ring_button) global_param_controls.append(ringed_encoder) global_bank_buttons = [] global_bank_labels = ('Pan_Button', 'Send_A_Button', 'Send_B_Button', 'Send_C_Button') for index in range(4): global_bank_buttons.append(ButtonElement(not is_momentary, MIDI_NOTE_TYPE, 0, 87 + index)) global_bank_buttons[-1].name = global_bank_labels[index] encoder_modes = EncModeSelectorComponent(self._mixer) encoder_modes.name = 'Track_Control_Modes' encoder_modes.set_modes_buttons(global_bank_buttons) encoder_modes.set_controls(tuple(global_param_controls)) global_translation_selector = ChannelTranslationSelector() global_translation_selector.name = 'Global_Translations' global_translation_selector.set_controls_to_translate(tuple(global_param_controls)) global_translation_selector.set_mode_buttons(tuple(global_bank_buttons)) def _product_model_id_byte(self): return 115 def _setup_monobridge(self): self._monobridge = MonoBridgeElement(self) self._monobridge.name = 'MonoBridge' def _setup_monomod(self): self._host = MonomodComponent(self) self._host.name = 'Monomod_Host' self.hosts = [self._host] self._monomod = ButtonMatrixElement() self._monomod.name = 'Monomod' for row in range(5): button_row = [] for column in range(8): button_row.append(self._matrix.get_button(column, row)) self._monomod.add_row(tuple(button_row)) self._monomod.add_row(tuple(self._track_stop_buttons)) self._monomod.add_row(tuple(self._select_buttons)) self._monomod.add_row(tuple(self._solo_buttons)) self._monomod_mode = MonomodModeComponent(self._monomod_mode_update, self) self._monomod_mode.name = "Monomod_Mode_Component" def _monomod_mode_update(self): if(self._monomod_mode._mode_index == 0) or (self._host._active_client == None): self.flash_status = 0 self._host.set_enabled(False) self._host._set_button_matrix(None) self._host._set_nav_buttons(None) self._host._set_lock_button(None) self._host._set_alt_button(None) self._host._set_shift_button(None) self._monomod.reset() self._session.set_track_bank_buttons(self._right_button, self._left_button) self._session.set_scene_bank_buttons(self._down_button, self._up_button) for track in range(8): self._mixer.channel_strip(track).set_select_button(self._select_buttons[track]) self._mixer.channel_strip(track).set_solo_button(self._solo_buttons[track]) self._transport.set_nudge_buttons(self._nudge_up_button, self._nudge_down_button) self._session.set_enabled(True) self._session_zoom._is_zoomed_out = False self._session_zoom.set_enabled(True) self.request_rebuild_midi_map() self._master_select_button.turn_off() elif(self._monomod_mode._mode_index == 1): self._transport.set_nudge_buttons(None, None) for track in range(8): self._mixer.channel_strip(track).set_select_button(None) self._mixer.channel_strip(track).set_solo_button(None) self._session.set_enabled(False) self._session_zoom.set_enabled(False) self._session.set_track_bank_buttons(None, None) self._session.set_scene_bank_buttons(None, None) self.flash_status = 1 self._monomod.reset() self._host._set_button_matrix(self._monomod) self._host._set_nav_buttons([self._up_button, self._down_button, self._left_button, self._right_button]) self._host._set_shift_button(self._shift_button) self._host._set_lock_button(self._nudge_up_button) self._host._set_alt_button(self._nudge_down_button) self._host.set_enabled(True) self.request_rebuild_midi_map() self._master_select_button.turn_on() """m4l bridge""" def generate_strip_string(self, display_string): #self.log_message(display_string) NUM_CHARS_PER_DISPLAY_STRIP = 12 if (not display_string): return (' ' * NUM_CHARS_PER_DISPLAY_STRIP) if ((len(display_string.strip()) > (NUM_CHARS_PER_DISPLAY_STRIP - 1)) and (display_string.endswith('dB') and (display_string.find('.') != -1))): display_string = display_string[:-2] if (len(display_string) > (NUM_CHARS_PER_DISPLAY_STRIP - 1)): for um in [' ', 'i', 'o', 'u', 'e', 'a']: while ((len(display_string) > (NUM_CHARS_PER_DISPLAY_STRIP - 1)) and (display_string.rfind(um, 1) != -1)): um_pos = display_string.rfind(um, 1) display_string = (display_string[:um_pos] + display_string[(um_pos + 1):]) else: display_string = display_string.center((NUM_CHARS_PER_DISPLAY_STRIP - 1)) ret = u'' for i in range((NUM_CHARS_PER_DISPLAY_STRIP - 1)): if ((ord(display_string[i]) > 127) or (ord(display_string[i]) < 0)): ret += ' ' else: ret += display_string[i] ret += ' ' assert (len(ret) == NUM_CHARS_PER_DISPLAY_STRIP) return ret def notification_to_bridge(self, name, value, sender): if isinstance(sender, (MonoRingedEncoderElement, MonoEncoderElement2)): self._monobridge._send(sender.name, 'lcd_name', str(self.generate_strip_string(name))) self._monobridge._send(sender.name, 'lcd_value', str(self.generate_strip_string(value))) def touched(self): if self._touched is 0: self._monobridge._send('touch', 'on') self.schedule_message(2, self.check_touch) self._touched +=1 def check_touch(self): if self._touched > 5: self._touched = 5 elif self._touched > 0: self._touched -= 1 if self._touched is 0: self._monobridge._send('touch', 'off') else: self.schedule_message(2, self.check_touch) def get_clip_names(self): clip_names = [] for scene in self._session._scenes: for clip_slot in scene._clip_slots: if clip_slot.has_clip() is True: clip_names.append(clip_slot._clip_slot)##.clip.name) return clip_slot._clip_slot ##self.log_message(str(clip_slot._clip_slot.clip.name)) return clip_names def update_display(self): """ Live -> Script Aka on_timer. Called every 100 ms and should be used to update display relevant parts of the controller """ for message in self._scheduled_messages: message['Delay'] -= 1 if (message['Delay'] == 0): if (message['Parameter'] != None): message['Message'](message['Parameter']) else: message['Message']() del self._scheduled_messages[self._scheduled_messages.index(message)] for callback in self._timer_callbacks: callback() self._timer = (self._timer + 1) % 256 self.flash() def flash(self): if(self.flash_status > 0): for row in range(8): for column in range(8): button = self._monomod.get_button(column, row) if(button._flash_state > 0): button.flash(self._timer)
class OhmModes(ControlSurface): __module__ = __name__ __doc__ = " OhmModes controller script " def __init__(self, c_instance): """everything except the '_on_selected_track_changed' override and 'disconnect' runs from here""" ControlSurface.__init__(self, c_instance) self.log_message(time.strftime("%d.%m.%Y %H:%M:%S", time.localtime()) + "--------------= OhmModes 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._version_check = 'b993' self._host_name = 'Ohm' self._hosts = [] self.hosts = [] self._client = [None for index in range(6)] self._active_client = None self._bright = True self.flash_status = 1 self._touched = 0 self._backlight = 127 self._backlight_type = 'static' self._ohm = 127 self._ohm_type = 'static' self._pad_translations = PAD_TRANSLATION self._rgb = 1 self._keys_octave = 5 self._keys_scale = 0 self._tempo_buttons = None self._setup_monobridge() self._setup_controls() 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 self._setup_device_control() # Setup the device object self._setup_crossfader() self._setup_ohmmod() self._setup_switchboard() self._setup_modes() self._assign_page_constants() self._last_device = None self._timer = 0 self.set_suppress_rebuild_requests(False) #Turn rebuild back on, now that we're done setting up self.song().view.add_selected_track_listener(self._update_selected_device) self.show_message('OhmModes Control Surface Loaded') self._send_midi(tuple(switchxfader)) self.schedule_message(10, self.query_ohm, None) def query_ohm(self): #self.log_message('querying Ohm') self._send_midi(tuple(check_model)) def update_display(self): """ Live -> Script Aka on_timer. Called every 100 ms and should be used to update display relevant parts of the controller """ for message in self._scheduled_messages: message['Delay'] -= 1 if (message['Delay'] == 0): if (message['Parameter'] != None): message['Message'](message['Parameter']) else: message['Message']() del self._scheduled_messages[self._scheduled_messages.index(message)] for callback in self._timer_callbacks: callback() self._timer = (self._timer + 1) % 256 self.flash() self.strobe() def _setup_monobridge(self): self._monobridge = MonoBridgeElement(self) self._monobridge.name = 'MonoBridge' def get_device_bank(self): return self._device._bank_index def _setup_controls(self): is_momentary = True self._fader = [None for index in range(8)] self._dial = [None for index in range(16)] self._button = [None for index in range(8)] self._menu = [None for index in range(6)] for index in range(8): self._fader[index] = MonoEncoderElement2(MIDI_CC_TYPE, CHANNEL, OHM_FADERS[index], Live.MidiMap.MapMode.absolute, 'Fader_' + str(index), index, self) #self._fader[index].name = 'Fader_' + str(index), self for index in range(8): self._button[index] = FlashingButtonElement(is_momentary, MIDI_NOTE_TYPE, CHANNEL, OHM_BUTTONS[index], 'Button_' + str(index), self) for index in range(16): self._dial[index] = MonoEncoderElement2(MIDI_CC_TYPE, CHANNEL, OHM_DIALS[index], Live.MidiMap.MapMode.absolute, 'Dial_' + str(index), index, self) #self._dial[index].name = 'Dial_' + str(index) self._knobs = [] for index in range(12): self._knobs.append(self._dial[index]) for index in range(6): self._menu[index] = FlashingButtonElement(is_momentary, MIDI_NOTE_TYPE, CHANNEL, OHM_MENU[index], 'Menu_' + str(index), self) self._crossfader = EncoderElement(MIDI_CC_TYPE, CHANNEL, CROSSFADER, Live.MidiMap.MapMode.absolute) self._crossfader.name = "Crossfader" self._livid = FlashingButtonElement(is_momentary, MIDI_NOTE_TYPE, CHANNEL, LIVID, 'Livid_Button', self) self._shift_l = FlashingButtonElement(is_momentary, MIDI_NOTE_TYPE, CHANNEL, SHIFT_L, 'Page_Button_Left', self) self._shift_r = FlashingButtonElement(is_momentary, MIDI_NOTE_TYPE, CHANNEL, SHIFT_R, 'Page_Button_Right', self) self._matrix = ButtonMatrixElement() self._matrix.name = 'Matrix' self._grid = [None for index in range(8)] self._monomod = ButtonMatrixElement() self._monomod.name = 'Monomod' for column in range(8): self._grid[column] = [None for index in range(8)] for row in range(8): self._grid[column][row] = FlashingButtonElement(is_momentary, MIDI_NOTE_TYPE, CHANNEL, (column * 8) + row, 'Grid_' + str(column) + '_' + str(row), self) for row in range(5): button_row = [] for column in range(7): button_row.append(self._grid[column][row]) self._matrix.add_row(tuple(button_row)) for row in range(8): button_row = [] for column in range(8): button_row.append(self._grid[column][row]) self._monomod.add_row(tuple(button_row)) def _setup_ohmmod(self): self._host = MonomodComponent(self) self._host.name = 'Monomod_Host' self.hosts = [self._host] self._hosts = [self._host] for index in range(6): self._client[index] = MonoClient(self, index) self._client[index].name = 'Client_' + str(index) #self._client[index]._mod_dial = self._encoder[index] self._host._active_client = self._client[0] self._host._active_client._is_active = True self._host.connect_to_clients(self) def _setup_switchboard(self): self._switchboard = SwitchboardElement(self, self._client) self._switchboard.name = 'Switchboard' def _setup_modes(self): self._shift_mode = ShiftModeComponent(self) self._shift_mode.name = 'Shift_Mode' self._shift_mode.set_mode_toggle(self._shift_l, self._shift_r, self._livid) self._scale_mode = ScaleModeComponent(self) self._scale_mode.name = "Scale_Mode" self._octave_mode = OctaveModeComponent(self) self._octave_mode.name = "Octave_Mode" self._modNum = ModNumModeComponent(self, self.modNum_update) self._modNum.name = 'Mod_Number' self._modNum.set_mode = self._modNum_set_mode(self._modNum) self._modNum.set_mode_buttons([self._menu[index] for index in range(6)]) def _modNum_set_mode(self, modNum): def set_mode(mode): if modNum._is_enabled == True: assert isinstance(mode, int) assert (mode in range(modNum.number_of_modes())) if (modNum._mode_index != mode): modNum._mode_index = mode modNum.update() return set_mode def _setup_transport_control(self): self._transport = TransportComponent() self._transport.name = 'Transport' def _setup_mixer_control(self): is_momentary = True self._num_tracks = (7) #A mixer is one-dimensional; global mixer mixer = SpecialMixerComponent(7, 0, True, False) mixer.name = 'Mixer' self._mixer = mixer mixer.set_track_offset(0) #Sets start point for mixer strip (offset from left) for index in range(7): mixer.channel_strip(index).set_volume_control(self._fader[index]) for index in range(7): mixer.channel_strip(index).name = 'Mixer_ChannelStrip_' + str(index) mixer.track_eq(index).name = 'Mixer_EQ_' + str(index) mixer.channel_strip(index)._invert_mute_feedback = True self.song().view.selected_track = mixer.channel_strip(0)._track #set the selected strip to the first track, so that we don't, for example, try to assign a button to arm the master track, which would cause an assertion error def _setup_session_control(self): is_momentary = True num_tracks = 7 num_scenes = 5 global session session = SessionComponent(num_tracks, num_scenes) session.name = "Session" self._session = session session.set_offsets(0, 0) self._scene = [None for index in range(6)] for row in range(num_scenes): self._scene[row] = session.scene(row) self._scene[row].name = 'Scene_' + str(row) for column in range(num_tracks): clip_slot = self._scene[row].clip_slot(column) clip_slot.name = str(column) + '_Clip_Slot_' + str(row) session.set_mixer(self._mixer) self._session_zoom = SessionZoomingComponent(session) self._session_zoom.name = 'Session_Overview' def _assign_session_colors(self): num_tracks = 7 num_scenes = 5 self._session.set_stop_track_clip_value(STOP_CLIP_COLOR[self._rgb]) for row in range(num_scenes): for column in range(num_tracks): self._scene[row].clip_slot(column).set_triggered_to_play_value(CLIP_TRIGD_TO_PLAY_COLOR[self._rgb]) self._scene[row].clip_slot(column).set_triggered_to_record_value(CLIP_TRIGD_TO_RECORD_COLOR[self._rgb]) self._scene[row].clip_slot(column).set_stopped_value(CLIP_STOPPED_COLOR[self._rgb]) self._scene[row].clip_slot(column).set_started_value(CLIP_STARTED_COLOR[self._rgb]) self._scene[row].clip_slot(column).set_recording_value(CLIP_RECORDING_COLOR[self._rgb]) self._session_zoom.set_stopped_value(ZOOM_STOPPED_COLOR[self._rgb]) self._session_zoom.set_playing_value(ZOOM_PLAYING_COLOR[self._rgb]) self._session_zoom.set_selected_value(ZOOM_SELECTED_COLOR[self._rgb]) def _setup_device_control(self): self._device = DeviceComponent() self._device.name = 'Device_Component' self.set_device_component(self._device) self._device_navigator = DetailViewControllerComponent() self._device_navigator.name = 'Device_Navigator' self._device_selection_follows_track_selection = FOLLOW def device_follows_track(self, val): self._device_selection_follows_track_selection = (val == 1) return self def _setup_crossfader(self): self._mixer.set_crossfader_control(self._crossfader) 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 =--------------") #Create entry in log file ControlSurface.disconnect(self) return None def _get_num_tracks(self): return self.num_tracks def flash(self): #if(self.flash_status > 0): for row in range(8): if(self._button[row]._flash_state > 0): self._button[row].flash(self._timer) for column in range(8): button = self._grid[column][row] if(button._flash_state > 0): button.flash(self._timer) def strobe(self): if(self._backlight_type != 'static'): if(self._backlight_type is 'pulse'): self._backlight = int(math.fabs(((self._timer * 16) % 64) -32) +32) if(self._backlight_type is 'up'): self._backlight = int(((self._timer * 8) % 64) + 16) if(self._backlight_type is 'down'): self._backlight = int(math.fabs(int(((self._timer * 8) % 64) - 64)) + 16) self._send_midi(tuple([176, 27, int(self._backlight)])) if(self._ohm_type != 'static'): if(self._ohm_type is 'pulse'): self._ohm = int(math.fabs(((self._timer * 16) % 64) -32) +32) if(self._ohm_type is 'up'): self._ohm = int(((self._timer * 8) % 64) + 16) if(self._ohm_type is 'down'): self._ohm = int(math.fabs(int(((self._timer * 8) % 64) - 64)) + 16) self._send_midi(tuple([176, 63, int(self._ohm)])) self._send_midi(tuple([176, 31, int(self._ohm)])) def deassign_matrix(self): self._host._set_knobs(None) self._host._set_button_matrix(None) self._modNum.set_enabled(False) self.assign_alternate_mappings(0) self._scale_mode.set_mode_buttons(None) self._scale_mode.set_enabled(False) self._octave_mode.set_mode_buttons(None) self._octave_mode.set_enabled(False) #self._session_zoom.set_button_matrix(None) self._session_zoom.set_enabled(False) self._session_zoom.set_nav_buttons(None, None, None, None) self._session.set_track_bank_buttons(None, None) self._session.set_scene_bank_buttons(None, None) for column in range(4): #self._mixer.track_eq(column).set_gain_controls(tuple([self._dial[column + 8], self._dial[column + 4], self._dial[column]])) self._mixer.track_eq(column)._gain_controls = None self._mixer.track_eq(column).set_enabled(False) for column in range(7): self._mixer.channel_strip(column).set_crossfade_toggle(None) self._mixer.channel_strip(column).set_mute_button(None) self._mixer.channel_strip(column).set_solo_button(None) self._mixer.channel_strip(column).set_arm_button(None) self._mixer.channel_strip(column).set_send_controls(None) self._mixer.channel_strip(column).set_pan_control(None) self._mixer.track_eq(column).set_enabled(False) for row in range(5): self._scene[row].clip_slot(column).set_launch_button(None) for column in range(8): self._button[column]._on_value = SELECT_COLOR[self._rgb] for row in range(8): self._grid[column][row].set_channel(0) self._grid[column][row].release_parameter() self._grid[column][row].use_default_message() self._grid[column][row].set_enabled(True) self._grid[column][row].send_value(0, True) self._grid[column][row]._on_value = 127 self._grid[column][row]._off_value = 0 for index in range(6): self._menu[index]._on_value = 127 self._menu[index]._off_value = 0 for index in range(16): self._dial[index].use_default_message() self._dial[index].release_parameter() #self._dial[index].set_enabled(True) if(self._device._parameter_controls != None): for control in self._device._parameter_controls: control.release_parameter() self._device._parameter_controls = None self._device.set_enabled(False) self._device_navigator.set_enabled(False) self._mixer.update() self._matrix.reset() self._transport.set_play_button(None) self._transport.set_stop_button(None) self.request_rebuild_midi_map() def _assign_page_constants(self): #self._session_zoom.set_zoom_button(self._button[7]) #commented out pn 070111 self._session_zoom.set_zoom_button(self._grid[7][7]) #added pn 070111 self._session_zoom.set_button_matrix(self._matrix) #self._session_zoom.set_enabled(True) for column in range(7): self._mixer.channel_strip(column).set_select_button(self._button[column]) self._mixer.channel_strip(column).set_volume_control(self._fader[column]) self._mixer.master_strip().set_volume_control(self._fader[7]) self._mixer.master_strip().set_select_button(self._button[7]) #added pn 070111 self._mixer.set_prehear_volume_control(self._dial[15]) self._transport.set_play_button(self._menu[0]) self._menu[0].send_value(PLAY_COLOR[self._rgb], True) self._menu[0]._on_value = PLAY_COLOR[self._rgb] self._transport.set_stop_button(self._menu[1]) self._menu[1]._off_value = STOP_COLOR[self._rgb] self._menu[1]._on_value = STOP_COLOR[self._rgb] self._menu[1].send_value(STOP_COLOR[self._rgb], True) #self._livid._on_value = TAP_COLOR[self._rgb] #self._transport.set_tap_tempo_button(self._livid) #self._livid.send_value(TAP_COLOR, True) self._device_navigator.set_device_nav_buttons(self._menu[3], self._menu[4]) def assign_page_0(self): self._backlight_type = 'static' #self._session_zoom.set_button_matrix(self._matrix) self._transport.set_play_button(self._menu[0]) self._transport.set_stop_button(self._menu[1]) self._session_zoom.set_enabled(True) for column in range(7): self._grid[column][5]._on_value = MUTE_COLOR[self._rgb] self._mixer.channel_strip(column).set_mute_button(self._grid[column][5]) self._grid[column][6]._on_value = SOLO_COLOR[self._rgb] self._mixer.channel_strip(column).set_solo_button(self._grid[column][6]) self._grid[column][7]._on_value = ARM_COLOR[self._rgb] self._mixer.channel_strip(column).set_arm_button(self._grid[column][7]) self._mixer.channel_strip(column).set_pan_control(self._dial[column + 8]) for row in range(5): self._scene[row].clip_slot(column).set_launch_button(self._grid[column][row]) for column in range(4): self._mixer.channel_strip(column).set_send_controls(tuple([self._dial[column], self._dial[column + 4]])) for index in range(5): self._grid[7][index]._off_value = SCENE_LAUNCH_COLOR[self._rgb] self._scene[index].set_launch_button(self._grid[7][index]) for index in range(4): self._menu[2 + index]._on_value = NAV_BUTTON_COLOR[self._rgb] self._session.set_track_bank_buttons(self._menu[4], self._menu[3]) self._session.set_scene_bank_buttons(self._menu[5], self._menu[2]) def assign_page_1(self): self._backlight_type = 'pulse' self._transport.set_play_button(self._menu[0]) self._transport.set_stop_button(self._menu[1]) self._session_zoom.set_enabled(False) for column in range(4): for row in range(4): self._grid[column][row].set_channel(PAGE1_DRUM_CHANNEL) self._grid[column][row].set_identifier(PAGE1_DRUM_MAP[column][row]) self._grid[column][row].send_value(DRUM_COLOR[self._rgb], True) self._grid[column][row].set_enabled(False) self._grid[column + 4][row].set_channel(PAGE1_BASS_CHANNEL) self._grid[column + 4][row].set_identifier(PAGE1_BASS_MAP[column][row]) self._grid[column + 4][row].send_value(BASS_COLOR[self._rgb], True) self._grid[column + 4][row].set_enabled(False) scale_mode_buttons = [] for column in range(8): for row in range(3): self._grid[column][row + 4].set_enabled(False) self._grid[column][row + 4].set_channel(PAGE1_KEYS_CHANNEL) self._grid[column][row + 4].set_identifier(int(PAGE1_KEYS_MAP[column][row]) + int(PAGE1_MODES_MAP[self._scale_mode._mode_index][column]) + int(self._octave_mode._mode_index * 12)) self._grid[column][row + 4].send_value(KEYS_COLOR[self._rgb], True) for row in range(1): scale_mode_buttons.append(self._grid[column][7]) self._scale_mode.set_mode_buttons(tuple(scale_mode_buttons)) self._scale_mode.set_enabled(True) self._octave_mode.set_mode_buttons(tuple([self._menu[5], self._menu[2]])) self._octave_mode.set_enabled(True) for column in range(7): self._mixer.channel_strip(column).set_send_controls(tuple([self._dial[column + 8]])) self._mixer.channel_strip(column).set_arm_button(self._button[column]) self._device.set_enabled(True) device_param_controls = [] for index in range(8): device_param_controls.append(self._dial[index]) self._device.set_parameter_controls(tuple(device_param_controls)) for index in range(4): self._menu[2 + index]._on_value = (DEVICE_NAV_COLOR[self._rgb]) self._device_navigator.set_enabled(True) def assign_page_2(self): self._backlight_type = 'up' self._transport.set_play_button(self._menu[0]) self._transport.set_stop_button(self._menu[1]) #self._session_zoom.set_button_matrix(self._matrix) self._session_zoom.set_enabled(True) for column in range(7): self._grid[column][5]._on_value = MUTE_COLOR[self._rgb] self._mixer.channel_strip(column).set_mute_button(self._grid[column][5]) self._grid[column][6]._on_value = CROSSFADE_ASSIGN_COLOR[self._rgb] self._mixer.channel_strip(column).set_crossfade_toggle(self._grid[column][6]) self._grid[column][7].set_channel(2) self._grid[column][7].set_identifier(column) self._grid[column][7].reset() self._grid[column][7].set_enabled(False) self._grid[column][7].send_value(4, True) for row in range(5): self._scene[row].clip_slot(column).set_launch_button(self._grid[column][row]) for row in range(5): self._grid[7][row]._off_value = SCENE_LAUNCH_COLOR[self._rgb] self._scene[row].set_launch_button(self._grid[7][row]) for column in range(4): self._mixer.track_eq(column).set_gain_controls(tuple([self._dial[column + 8], self._dial[column + 4], self._dial[column]])) self._mixer.track_eq(column).set_enabled(True) for column in range(3): self._mixer.channel_strip(column+4).set_pan_control(self._dial[column + 12]) for index in range(4): self._menu[2 + index]._on_value = NAV_BUTTON_COLOR[self._rgb] self._session.set_track_bank_buttons(self._menu[4], self._menu[3]) self._session.set_scene_bank_buttons(self._menu[5], self._menu[2]) self._set_tempo_buttons([self._grid[7][5], self._grid[7][6]]) def assign_mod(self): #for index in range(6): #self._modNum._modes_buttons[index].send_value(self._client[index]._mod_color) #if self._shift_mode._mode_index is 0: # self._host._set_dial_matrix(None, None) #self._host._set_knobs(None) #self._host._set_button_matrix(None) #self._host._set_key_buttons(None) #self._host.set_enabled(False) #self.set_local_ring_control(1) #self.assign_live_controls() #for index in range(4): # self._shift_mode._modes_buttons[index].turn_off() #else: #if self._shift_mode._mode_index is 3: self.deassign_matrix() #self.set_local_ring_control(self._host._active_client._local_ring_control) self._host.set_enabled(True) self._modNum.set_enabled(True) #self._host._set_dial_matrix(self._dial_matrix, self._dial_button_matrix) self._host._set_knobs(tuple(self._knobs)) self._host._set_button_matrix(self._monomod) #self._host._set_key_buttons(tuple(self._button)) #self._host._select_client(self._shift_mode._mode_index-1) #self._host._select_client(0) #for index in range(4): # if self._shift_mode._mode_index == (index + 1): # self._shift_mode._modes_buttons[index].send_value(1) if not self._host._active_client.is_connected(): #self.assign_alternate_mappings(self._shift_mode._mode_index) self.assign_alternate_mappings(self._modNum._mode_index + 1) #else: # self._shift_mode._modes_buttons[index].send_value(self._client[index]._mod_color) #self._shift_mode._modes_buttons[index].send_value(((index+1)==self._shift_mode._mode_index)*127) def modNum_update(self): if self._modNum._is_enabled == True: self.assign_alternate_mappings(0) self._host._select_client(int(self._modNum._mode_index)) if not self._host._active_client.is_connected(): self.assign_alternate_mappings(self._modNum._mode_index + 1) for button in self._modNum._modes_buttons: button.send_value(int(self._modNum._mode_index == self._modNum._modes_buttons.index(button))*self._host._active_client._mod_color) def assign_alternate_mappings(self, chan): for column in range(8): for row in range(8): #self._grid[column][row].set_identifier(OHM_MAP_ID[column][row]) self._grid[column][row].set_channel(chan) #self._grid[column][row].send_value(OHM_MAP_VALUE[column][row]) self._grid[column][row].set_enabled(chan is 0) #for index in range(8): # self._encoder_button[index + 4].set_channel(chan) # self._encoder_button[index + 4].set_enabled(chan is 0) for knob in self._knobs: knob.set_channel(chan) knob.set_enabled(chan is 0) #for button in self._button: # button.set_channel(chan) # button.set_enabled(chan is 0) self.request_rebuild_midi_map() def _update_selected_device(self): if self._device_selection_follows_track_selection is True: 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.set_device(device_to_select) self.set_appointed_device(device_to_select) #self._device_selector.set_enabled(True) self.request_rebuild_midi_map() return None def handle_sysex(self, midi_bytes): #self.log_message(str('>>sysexIN') + str(midi_bytes)) if len(midi_bytes) > 10: #self.log_message(str('>>sysex>10') + str(midi_bytes[:11])) if midi_bytes[:11] == tuple([240, 126, 0, 6, 2, 0, 1, 97, 1, 0, 7]): self.log_message(str('>>>color detected')) self._rgb = 1 elif midi_bytes[:11] == tuple([240, 126, 0, 6, 2, 0, 1, 97, 1, 0, 2]): self.log_message(str('>>>mono detected')) self._rgb = 0 self._assign_session_colors() def receive_midi(self, midi_bytes): """ Live -> Script MIDI messages are only received through this function, when explicitly forwarded in 'build_midi_map'. """ assert (midi_bytes != None) assert isinstance(midi_bytes, tuple) ##self.log_message('got message' + str(midi_bytes)) self.set_suppress_rebuild_requests(True) if (len(midi_bytes) is 3): msg_type = (midi_bytes[0] & 240) forwarding_key = [midi_bytes[0]] if (msg_type is not MIDI_PB_TYPE): forwarding_key.append(midi_bytes[1]) if (tuple(forwarding_key) in self._forwarding_registry.keys()): recipient = self._forwarding_registry[tuple(forwarding_key)] if (recipient != None): recipient.receive_value(midi_bytes[2]) else: self.log_message(('Got unknown message: ' + str(midi_bytes))) else: self.handle_sysex(midi_bytes) self.set_suppress_rebuild_requests(False) def _set_tempo_buttons(self, buttons): if self._tempo_buttons != None: self._tempo_buttons[0].remove_value_listener(self._tempo_value) self._tempo_buttons[1].remove_value_listener(self._tempo_value) self._tempo_buttons = buttons if buttons != None: for button in buttons: assert isinstance(button, FlashingButtonElement) self._tempo_buttons[0].set_on_off_values(4, 0) self._tempo_buttons[0].add_value_listener(self._tempo_value, True) self._tempo_buttons[1].set_on_off_values(4, 0) self._tempo_buttons[1].add_value_listener(self._tempo_value, True) self._tempo_buttons[0].turn_on() self._tempo_buttons[1].turn_on() def _tempo_value(self, value, sender): if (value > 0) and (self._tempo_buttons.index(sender) == 0): self.song().tempo = round(min((self.song().tempo + 1), 999)) elif (value > 0) and (self._tempo_buttons.index(sender) == 1): self.song().tempo = round(max((self.song().tempo - 1), 20)) """m4l bridge""" def generate_strip_string(self, display_string): #self.log_message(display_string) NUM_CHARS_PER_DISPLAY_STRIP = 12 if (not display_string): return (' ' * NUM_CHARS_PER_DISPLAY_STRIP) if ((len(display_string.strip()) > (NUM_CHARS_PER_DISPLAY_STRIP - 1)) and (display_string.endswith('dB') and (display_string.find('.') != -1))): display_string = display_string[:-2] if (len(display_string) > (NUM_CHARS_PER_DISPLAY_STRIP - 1)): for um in [' ', 'i', 'o', 'u', 'e', 'a']: while ((len(display_string) > (NUM_CHARS_PER_DISPLAY_STRIP - 1)) and (display_string.rfind(um, 1) != -1)): um_pos = display_string.rfind(um, 1) display_string = (display_string[:um_pos] + display_string[(um_pos + 1):]) else: display_string = display_string.center((NUM_CHARS_PER_DISPLAY_STRIP - 1)) ret = u'' for i in range((NUM_CHARS_PER_DISPLAY_STRIP - 1)): if ((ord(display_string[i]) > 127) or (ord(display_string[i]) < 0)): ret += ' ' else: ret += display_string[i] ret += ' ' #assert (len(ret) == NUM_CHARS_PER_DISPLAY_STRIP) return ret def notification_to_bridge(self, name, value, sender): if(isinstance(sender, MonoEncoderElement2)): self._monobridge._send(sender.name, 'lcd_name', str(self.generate_strip_string(name))) self._monobridge._send(sender.name, 'lcd_value', str(self.generate_strip_string(value))) def touched(self): if self._touched is 0: self._monobridge._send('touch', 'on') self.schedule_message(2, self.check_touch) self._touched +=1 def check_touch(self): if self._touched > 5: self._touched = 5 elif self._touched > 0: self._touched -= 1 if self._touched is 0: self._monobridge._send('touch', 'off') else: self.schedule_message(2, self.check_touch) def get_clip_names(self): clip_names = [] for scene in self._session._scenes: for clip_slot in scene._clip_slots: if clip_slot.has_clip() is True: clip_names.append(clip_slot._clip_slot)##.clip.name) return clip_slot._clip_slot ##self.log_message(str(clip_slot._clip_slot.clip.name)) return clip_names
class OhmModesHH(ControlSurface): __module__ = __name__ __doc__ = " OhmModes controller script, custom script for Herbie Hancock by amounra " 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()) + "--------------= OhmModesHH2 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.revision = 'HH' self.flash_status = 1 self._backlight = 127 self._backlight_type = 'static' self._ohm = 127 self._ohm_type = 'static' self._pad_translations = PAD_TRANSLATION self._rgb = 1 self._keys_octave = 5 self._keys_scale = 0 self._tempo_buttons = None self._scene_indexes = [[[0, 0], [8, 0], [16, 0], [24, 0], [32, 0], [40, 0]], [[0, 0], [8, 0], [16, 0], [24, 0], [32, 0], [40, 0]], [[0, 0], [8, 0], [16, 0], [24, 0], [32, 0], [40, 0]], [[0, 0], [8, 0], [16, 0], [24, 0], [32, 0], [40, 0]], [[0, 0], [8, 0], [16, 0], [24, 0], [32, 0], [40, 0]]] self._scene_bank = 0 self._bank_is_on = False self._setup_monobridge() self._setup_controls() 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 self._setup_device_control() # Setup the device object self._setup_crossfader() self._setup_looper() #self._setup_scene_selector() #self._setup_modes() self._assign_page_constants() self.assign_page_0() self._setup_hilight_knobs() self._last_device = None self._timer = 0 #self.set_suppress_rebuild_requests(False) #Turn rebuild back on, now that we're done setting up self.song().view.add_selected_track_listener( self._update_selected_device) self._on_selected_scene_changed() self.show_message('OhmModes Control Surface Loaded') self._send_midi(tuple(switchxfader)) #self.schedule_message(10, self.query_ohm, None) #self.song().view.selected_scene = self.song().scenes[0] self._assign_session_colors() def query_ohm(self): #self.log_message('querying Ohm') self._send_midi(tuple(check_model)) def _setup_monobridge(self): self._monobridge = MonoBridgeElement(self) self._monobridge.name = 'MonoBridge' def update_display(self): ControlSurface.update_display(self) self._timer = (self._timer + 1) % 256 self.flash() def get_device_bank(self): return self._device._bank_index def _setup_controls(self): is_momentary = True self._fader = [None for index in range(8)] self._dial = [None for index in range(16)] self._button = [None for index in range(8)] self._menu = [None for index in range(6)] for index in range(8): self._fader[index] = EncoderElement(MIDI_CC_TYPE, CHANNEL, OHM_FADERS[index], Live.MidiMap.MapMode.absolute) self._fader[index].name = 'Fader_' + str(index), self for index in range(8): self._button[index] = MonoButtonElement(is_momentary, MIDI_NOTE_TYPE, CHANNEL, OHM_BUTTONS[index], 'Button_' + str(index), self) for index in range(16): self._dial[index] = EncoderElement(MIDI_CC_TYPE, CHANNEL, OHM_DIALS[index], Live.MidiMap.MapMode.absolute) self._dial[index].name = 'Dial_' + str(index) for index in range(6): self._menu[index] = MonoButtonElement(is_momentary, MIDI_NOTE_TYPE, CHANNEL, OHM_MENU[index], 'Menu_' + str(index), self) self._crossfader = EncoderElement(MIDI_CC_TYPE, CHANNEL, CROSSFADER, Live.MidiMap.MapMode.absolute) self._crossfader.name = "Crossfader" self._livid = MonoButtonElement(is_momentary, MIDI_NOTE_TYPE, CHANNEL, LIVID, 'Livid_Button', self) self._shift_l = MonoButtonElement(is_momentary, MIDI_NOTE_TYPE, CHANNEL, SHIFT_L, 'Page_Button_Left', self) self._shift_r = MonoButtonElement(is_momentary, MIDI_NOTE_TYPE, CHANNEL, SHIFT_R, 'Page_Button_Right', self) self._matrix = ButtonMatrixElement() self._matrix.name = 'Matrix' self._grid = [None for index in range(8)] for column in range(8): self._grid[column] = [None for index in range(8)] for row in range(8): self._grid[column][row] = MonoButtonElement( is_momentary, MIDI_NOTE_TYPE, CHANNEL, (column * 8) + row, 'Grid_' + str(column) + '_' + str(row), self) for row in range(6): button_row = [] for column in range(7): button_row.append(self._grid[column][row]) self._matrix.add_row(tuple(button_row)) def _setup_modes(self): self._shift_mode = ShiftModeComponent(self) self._shift_mode.name = 'Shift_Mode' #self._shift_mode.set_mode_toggle(self._shift_l, self._shift_r) #self._select_mode = ModeSelectorComponent(self) #self._select_mode.name = 'Select_Mode' #self._select_mode.set_mode_toggle(self._menu[5]) #self._select_mode.update = self.select_mode_update(self._select_mode) #self._menu[5].add_value_listener(self._select_mode) #self._scale_mode = ScaleModeComponent(self) #self._scale_mode.name = "Scale_Mode" #self._octave_mode = OctaveModeComponent(self) #self._octave_mode.name = "Octave_Mode" def select_mode_update(self, mode_selector): def update(): if mode_selector._mode_index > 0: pass return update def _setup_looper(self): self._looper = [None for index in range(2)] for index in range(2): self._looper[index] = LooperListenerComponent(self, index + 1) self._looper[index].assign_buttons(self._button[index * 4], self._button[(index * 4) + 1], self._button[(index * 4) + 2], self._button[(index * 4) + 3]) def _setup_transport_control(self): self._transport = TransportComponent() self._transport.name = 'Transport' def _setup_mixer_control(self): is_momentary = True self._num_tracks = (7) #A mixer is one-dimensional; global mixer mixer = SpecialMixerComponent(7, 0, True, False) mixer.name = 'Mixer' self._mixer = mixer mixer.set_track_offset( 0) #Sets start point for mixer strip (offset from left) for index in range(7): mixer.channel_strip(index).set_volume_control(self._fader[index]) for index in range(7): mixer.channel_strip( index).name = 'Mixer_ChannelStrip_' + str(index) mixer.track_eq(index).name = 'Mixer_EQ_' + str(index) mixer.channel_strip(index)._invert_mute_feedback = True self.song().view.selected_track = mixer.channel_strip( 0 )._track #set the selected strip to the first track, so that we don't, for example, try to assign a button to arm the master track, which would cause an assertion error def _setup_session_control(self): is_momentary = True num_tracks = 7 num_scenes = 7 ###changed from 5 for HH global session session = SessionComponent(num_tracks, num_scenes) session.name = "Session" session.set_offsets(0, 0) self._session = session self._scene = [None for index in range(num_scenes)] for row in range(num_scenes): self._scene[row] = session.scene(row) self._scene[row].name = 'Scene_' + str(row) for column in range(num_tracks): clip_slot = self._scene[row].clip_slot(column) clip_slot.name = str(column) + '_Clip_Slot_' + str(row) session.set_mixer(mixer) self._session_zoom = SessionZoomingComponent(session) self._session_zoom.name = 'Session_Overview' #self._session_zoom.set_enabled(False) self.set_highlighting_session_component(self._session) def _assign_session_colors(self): num_tracks = 7 num_scenes = 7 self._session.set_stop_clip_value(STOP_CLIP_COLOR[self._rgb]) for row in range(num_scenes): for column in range(num_tracks): self._scene[row].clip_slot(column).set_triggered_to_play_value( CLIP_TRIGD_TO_PLAY_COLOR[self._rgb]) self._scene[row].clip_slot( column).set_triggered_to_record_value( CLIP_TRIGD_TO_RECORD_COLOR[self._rgb]) self._scene[row].clip_slot(column).set_stopped_value( CLIP_STOPPED_COLOR[self._rgb]) self._scene[row].clip_slot(column).set_started_value( CLIP_STARTED_COLOR[self._rgb]) self._scene[row].clip_slot(column).set_recording_value( CLIP_RECORDING_COLOR[self._rgb]) self._session_zoom.set_stopped_value(ZOOM_STOPPED_COLOR[self._rgb]) self._session_zoom.set_playing_value(ZOOM_PLAYING_COLOR[self._rgb]) self._session_zoom.set_selected_value(ZOOM_SELECTED_COLOR[self._rgb]) def _setup_device_control(self): self._device = DeviceComponent() self._device.name = 'Device_Component' self.set_device_component(self._device) self._device_navigator = DetailViewControllerComponent() self._device_navigator.name = 'Device_Navigator' self._device_selection_follows_track_selection = FOLLOW def device_follows_track(self, val): self._device_selection_follows_track_selection = (val == 1) return self def _setup_crossfader(self): self._mixer.set_crossfader_control(self._crossfader) def _setup_scene_selector(self): for index in range(5): self._menu[index].add_value_listener(self._select_new_scene, True) def set_bank(self, val): self._scene_bank = int(val) self._monobridge._send('bank', self._scene_bank) self._display_bank() def _select_mode(self, value): self.log_message('select mode update' + str(value)) self._bank_is_on = value != 0 if self._bank_is_on is True: self._display_bank() else: self._on_selected_scene_changed() def _select_new_scene(self, value, sender): if self._bank_is_on is False: if value > 0: new_scene = int(self._scene_indexes[self._scene_bank][ self._menu.index(sender)][0]) new_track = int(self._scene_indexes[self._scene_bank][ self._menu.index(sender)][1]) self.log_message('select new scene ' + str(new_scene) + ' and track ' + str(new_track)) all_scenes = self.song().scenes all_tracks = self.song().tracks if (new_scene < len(all_scenes)) and (new_track < len(all_tracks)): self.song().view.selected_scene = all_scenes[(new_scene)] self.song().view.selected_track = all_tracks[(new_track)] self._session.set_offsets( self._scene_indexes[self._scene_bank][self._menu.index( sender)][1], self._scene_indexes[self._scene_bank][ self._menu.index(sender)][0]) else: if value > 0: self._scene_bank = int(self._menu.index(sender)) self._monobridge._send('bank', self._scene_bank) self._display_bank() def _display_bank(self): if (self._bank_is_on): for index in range(5): if index == self._scene_bank: self._menu[index].send_value(11) else: self._menu[index].send_value(0) def _on_selected_scene_changed(self): ControlSurface._on_selected_scene_changed(self) #self.log_message('scene offset: ' + str(self._session._scene_offset)) for index in range(6): if self._session._scene_offset == self._scene_indexes[ self._scene_bank][index][ 0]: ## and self._session._scene_offset < self._scene_indexes[index + 1]: self._menu[index].turn_on() else: self._menu[index].turn_off() #if self._session._scene_offset >= self._scene_indexes[5]: # self._menu[5].turn_on #else: # self._menu[5].turn_off def _setup_hilight_knobs(self): self._dial[15].add_value_listener(self._knob_set_scene, True) self._dial[14].add_value_listener(self._knob_set_track, True) def _knob_set_scene(self, value, sender): all_scenes = self.song().scenes num_scenes = len(all_scenes) new_scene = float(value / 127.0) * float(num_scenes - 1) self.song().view.selected_scene = all_scenes[int(new_scene)] self._session.set_offsets(self._session._track_offset, int(new_scene)) def _knob_set_track(self, value, sender): #self.log_message(str(value)) all_tracks = self.song().visible_tracks #self.song().tracks num_tracks = len(self.song().visible_tracks) new_track = float(value / 127.0) * float(num_tracks - 1) #self.log_message(str(int(new_track))) #self.log_message(str(value) + str(float(value/127.0))) self.song().view.selected_track = all_tracks[int(new_track)] self._session.set_offsets(int(new_track), self._session._scene_offset) def disconnect(self): """clean things up on disconnect""" for index in range(5): if self._menu[index].value_has_listener(self._select_new_scene): self._menu[index].remove_value_listener(self._select_new_scene) if self._menu[5].value_has_listener(self._select_mode): self._menu[5].remove_value_listener(self._select_mode) if self._dial[15].value_has_listener(self._knob_set_scene): self._dial[15].remove_value_listener(self._knob_set_scene) if self._dial[15].value_has_listener(self._knob_set_scene): self._dial[15].remove_value_listener(self._knob_set_scene) self.song().view.remove_selected_track_listener( self._update_selected_device) ControlSurface.disconnect(self) self.log_message( time.strftime("%d.%m.%Y %H:%M:%S", time.localtime()) + "--------------= OhmModes log closed =--------------" ) #Create entry in log file return None def _get_num_tracks(self): return self.num_tracks def flash(self): #if(self.flash_status > 0): for index in range(6): if (self._menu[index]._flash_state > 0): self._menu[index].flash(self._timer) for row in range(8): if (self._button[row]._flash_state > 0): self._button[row].flash(self._timer) for column in range(8): button = self._grid[column][row] if (button._flash_state > 0): button.flash(self._timer) def strobe(self): if (self._backlight_type != 'static'): if (self._backlight_type is 'pulse'): self._backlight = int( math.fabs(((self._timer * 16) % 64) - 32) + 32) if (self._backlight_type is 'up'): self._backlight = int(((self._timer * 8) % 64) + 16) if (self._backlight_type is 'down'): self._backlight = int( math.fabs(int(((self._timer * 8) % 64) - 64)) + 16) self._send_midi(tuple([176, 27, int(self._backlight)])) if (self._ohm_type != 'static'): if (self._ohm_type is 'pulse'): self._ohm = int(math.fabs(((self._timer * 16) % 64) - 32) + 32) if (self._ohm_type is 'up'): self._ohm = int(((self._timer * 8) % 64) + 16) if (self._ohm_type is 'down'): self._ohm = int( math.fabs(int(((self._timer * 8) % 64) - 64)) + 16) self._send_midi(tuple([176, 63, int(self._ohm)])) self._send_midi(tuple([176, 31, int(self._ohm)])) def deassign_matrix(self): #self._scale_mode.set_mode_buttons(None) #self._scale_mode.set_enabled(False) #self._octave_mode.set_mode_buttons(None) #self._octave_mode.set_enabled(False) #self._session_zoom.set_button_matrix(None) #if self._dial[15].has_value_listener(self._knob_set_scene): # self._dial[15].remove_value_listener(self._knob_set_scene) #if self._dial[14].has_value_listener(self._knob_set_track): # self._dial[14].remove_value_listener(self._knob_set_track) self._session_zoom.set_enabled(False) self._session_zoom.set_nav_buttons(None, None, None, None) self._session.set_track_bank_buttons(None, None) self._session.set_scene_bank_buttons(None, None) for column in range(7): self._mixer.channel_strip(column).set_crossfade_toggle(None) self._mixer.channel_strip(column).set_mute_button(None) self._mixer.channel_strip(column).set_solo_button(None) self._mixer.channel_strip(column).set_arm_button(None) self._mixer.channel_strip(column).set_send_controls(None) self._mixer.channel_strip(column).set_pan_control(None) self._mixer.track_eq(column).set_enabled(False) for row in range(7): self._scene[row].clip_slot(column).set_launch_button(None) for column in range(8): #self._button[column]._on_value = SELECT_COLOR[self._rgb] for row in range(8): self._grid[column][row].set_channel(0) self._grid[column][row].release_parameter() self._grid[column][row].use_default_message() self._grid[column][row].set_enabled(True) self._grid[column][row].send_value(0, True) self._grid[column][row]._on_value = 127 self._grid[column][row]._off_value = 0 #for index in range(8): # self._button[index].set_channel(0) # self._button[index].use_default_message() # self._button[index].set_enabled(True) # self._button[index].reset() #for index in range(6): # self._menu[index]._on_value = 127 # self._menu[index]._off_value = 0 # self._menu[index].reset() #for index in range(16): # self._dial[index].use_default_message() # self._dial[index].release_parameter() #self._dial[index].set_enabled(True) if (self._device._parameter_controls != None): for control in self._device._parameter_controls: control.release_parameter() self._device._parameter_controls = None self._device_navigator.set_enabled(False) self._mixer.update() self._matrix.reset() """HH Specific""" #self._mixer.master_strip().set_select_button(None) #for column in range(7): # self._mixer.channel_strip(column).set_select_button(None) self._session_zoom.set_zoom_button(None) self._transport.set_play_button(None) self._transport.set_stop_button(None) self._device_navigator.set_device_nav_buttons(None, None) #for index in range(2): # self._looper[index].find_looper() def _assign_page_constants(self): #self._session_zoom.set_zoom_button(self._button[7]) #commented out pn 070111 #self._session_zoom.set_zoom_button(self._grid[7][7]) #added pn 070111 #self._session_zoom.set_button_matrix(self._matrix) #self._session_zoom.set_enabled(True) #for column in range(7): #self._mixer.channel_strip(column).set_select_button(self._button[column]) # self._mixer.channel_strip(column).set_volume_control(self._fader[column]) #self._mixer.master_strip().set_volume_control(self._fader[7]) #for column in range(8): # self._button[column]._on_value = SELECT_COLOR[self._rgb] #self._mixer.master_strip().set_select_button(self._button[7]) #added pn 070111 #self._mixer.set_prehear_volume_control(self._dial[15]) #self._transport.set_play_button(self._menu[0]) #self._menu[0].send_value(PLAY_COLOR[self._rgb], True) #self._menu[0]._on_value = PLAY_COLOR[self._rgb] #self._transport.set_stop_button(self._menu[1]) #self._menu[1]._off_value = STOP_COLOR[self._rgb] #self._menu[1]._on_value = STOP_COLOR[self._rgb] #self._menu[1].send_value(STOP_COLOR[self._rgb], True) self._livid._on_value = TAP_COLOR[self._rgb] self._transport.set_tap_tempo_button(self._livid) #self._livid.send_value(TAP_COLOR, True) #self._device_navigator.set_device_nav_buttons(self._menu[3], self._menu[4]) for index in range(2): self._menu[index + 4]._on_value = SESSION_NAV[self._rgb] self._menu[index * 3]._on_value = SESSION_NAV[self._rgb] self._session.set_track_bank_buttons(self._menu[5], self._menu[4]) self._session.set_scene_bank_buttons(self._menu[3], self._menu[0]) def assign_page_0(self): self._backlight_type = 'static' #self._session_zoom.set_button_matrix(self._matrix) self._session_zoom.set_enabled(True) for column in range(7): #self._grid[column][5]._on_value = MUTE_COLOR[self._rgb] #self._mixer.channel_strip(column).set_mute_button(self._grid[column][5]) #self._grid[column][6]._on_value = SOLO_COLOR[self._rgb] #self._mixer.channel_strip(column).set_solo_button(self._grid[column][6]) #self._grid[column][7]._on_value = ARM_COLOR[self._rgb] #self._mixer.channel_strip(column).set_arm_button(self._grid[column][7]) #self._mixer.channel_strip(column).set_pan_control(self._dial[column + 8]) for row in range(7): self._scene[row].clip_slot(column).set_launch_button( self._grid[column][row]) #for column in range(4): # self._mixer.channel_strip(column).set_send_controls(tuple([self._dial[column], self._dial[column + 4]])) track_stop_buttons = [] for index in range(7): self._grid[7][index]._off_value = SCENE_LAUNCH_COLOR[self._rgb] self._scene[index].set_launch_button(self._grid[7][index]) self._grid[index][7]._on_value = TRACK_STOP[self._rgb] self._grid[index][7]._off_value = TRACK_STOP[self._rgb] track_stop_buttons.append(self._grid[index][7]) self._session.set_stop_track_clip_buttons(tuple(track_stop_buttons)) self._session.set_stop_all_clips_button(self._grid[7][7]) #for index in range(4): # self._menu[2 + index]._on_value = NAV_BUTTON_COLOR[self._rgb] #self._session.set_track_bank_buttons(self._menu[4], self._menu[3]) #self._session.set_scene_bank_buttons(self._menu[5], self._menu[2]) #for index in range(6): # self._menu[index]._on_value = HHMENU[index][1] # self._menu[index]._off_value = HHMENU[index][0] for index in range(8): self._button[index].set_channel(2) self._button[index].set_identifier(index) #self._button[index].reset() self._button[index].set_enabled(False) self.request_rebuild_midi_map() for index in range(7): self._grid[index][7].turn_on() for index in range(2): self._looper[index]._state_change() self._button[1 + (index * 4)].send_value(3) self._button[2 + (index * 4)].send_value(6) self._button[3 + (index * 4)].send_value(1) def assign_page_1(self): self._backlight_type = 'pulse' self._session_zoom.set_enabled(False) for column in range(4): for row in range(4): self._grid[column][row].set_channel(PAGE1_DRUM_CHANNEL) self._grid[column][row].set_identifier( PAGE1_DRUM_MAP[column][row]) self._grid[column][row].send_value(DRUM_COLOR[self._rgb], True) self._grid[column][row].set_enabled(False) self._grid[column + 4][row].set_channel(PAGE1_BASS_CHANNEL) self._grid[column + 4][row].set_identifier( PAGE1_BASS_MAP[column][row]) self._grid[column + 4][row].send_value(BASS_COLOR[self._rgb], True) self._grid[column + 4][row].set_enabled(False) scale_mode_buttons = [] for column in range(8): for row in range(3): self._grid[column][row + 4].set_enabled(False) self._grid[column][row + 4].set_channel(PAGE1_KEYS_CHANNEL) self._grid[column][row + 4].set_identifier( int(PAGE1_KEYS_MAP[column][row]) + int(PAGE1_MODES_MAP[ self._scale_mode._mode_index][column]) + int(self._octave_mode._mode_index * 12)) self._grid[column][row + 4].send_value(KEYS_COLOR[self._rgb], True) for row in range(1): scale_mode_buttons.append(self._grid[column][7]) self._scale_mode.set_mode_buttons(tuple(scale_mode_buttons)) self._scale_mode.set_enabled(True) #self._octave_mode.set_mode_buttons(tuple([self._menu[5], self._menu[2]])) #self._octave_mode.set_enabled(True) for column in range(7): self._mixer.channel_strip(column).set_send_controls( tuple([self._dial[column + 8]])) #self._button[column].set_on_off_values(REC_ARM, 0) #self._mixer.channel_strip(column).set_arm_button(self._button[column]) self._device.set_enabled(True) device_param_controls = [] for index in range(8): device_param_controls.append(self._dial[index]) self._device.set_parameter_controls(tuple(device_param_controls)) #for index in range(4): # self._menu[2 + index]._on_value = (DEVICE_NAV_COLOR[self._rgb]) #self._device_navigator.set_enabled(True) """HH Specific from Constants""" #self._mixer.master_strip().set_select_button(self._button[7]) #for column in range(7): # self._button[column].set_on_off_values(REC_ARM, 0) #self._session_zoom.set_zoom_button(self._grid[7][7]) #self._transport.set_play_button(self._menu[0]) #self._menu[0].send_value(PLAY_COLOR[self._rgb], True) #self._menu[0]._on_value = PLAY_COLOR[self._rgb] #self._transport.set_stop_button(self._menu[1]) #self._menu[1]._off_value = STOP_COLOR[self._rgb] #self._menu[1]._on_value = STOP_COLOR[self._rgb] #self._menu[1].send_value(STOP_COLOR[self._rgb], True) #self._device_navigator.set_device_nav_buttons(self._menu[3], self._menu[4]) for index in range(8): self._button[index].set_channel(2) self._button[index].set_identifier(index) #self._button[index].reset() self._button[index].set_enabled(False) self.request_rebuild_midi_map() #for index in range(8): # self._grid[index][7].send(self. for index in range(2): self._looper[index]._state_change() self._button[1 + (index * 4)].send_value(3) self._button[2 + (index * 4)].send_value(6) self._button[3 + (index * 4)].send_value(1) def assign_page_2(self): self._backlight_type = 'up' #self._session_zoom.set_button_matrix(self._matrix) self._session_zoom.set_enabled(False) for column in range(7): self._grid[column][5]._on_value = MUTE_COLOR[self._rgb] self._mixer.channel_strip(column).set_mute_button( self._grid[column][5]) self._grid[column][6]._on_value = CROSSFADE_ASSIGN_COLOR[self._rgb] self._mixer.channel_strip(column).set_crossfade_toggle( self._grid[column][6]) self._grid[column][7].set_channel(2) self._grid[column][7].set_identifier(column) self._grid[column][7].reset() self._grid[column][7].set_enabled(False) self._grid[column][7].send_value(4, True) for row in range(5): self._scene[row].clip_slot(column).set_launch_button( self._grid[column][row]) for row in range(5): self._grid[7][row]._off_value = SCENE_LAUNCH_COLOR[self._rgb] self._scene[row].set_launch_button(self._grid[7][row]) for column in range(4): self._mixer.track_eq(column).set_gain_controls( tuple([ self._dial[column + 8], self._dial[column + 4], self._dial[column] ])) self._mixer.track_eq(column).set_enabled(True) for column in range(3): self._mixer.channel_strip(column + 4).set_pan_control( self._dial[column + 12]) #for index in range(4): # self._menu[2 + index]._on_value = NAV_BUTTON_COLOR[self._rgb] #self._session.set_track_bank_buttons(self._menu[4], self._menu[3]) #self._session.set_scene_bank_buttons(self._menu[5], self._menu[2]) self._set_tempo_buttons([self._grid[7][5], self._grid[7][6]]) """HH Specific from Constants""" #self._mixer.master_strip().set_select_button(self._button[7]) #for column in range(7): # self._mixer.channel_strip(column).set_select_button(self._button[column]) #for index in range(8): # self._button[index].set_on_off_values(SELECT_COLOR[self._rgb], 0) self._session_zoom.set_zoom_button(self._grid[7][7]) #self._transport.set_play_button(self._menu[0]) #self._menu[0].send_value(PLAY_COLOR[self._rgb], True) #self._menu[0]._on_value = PLAY_COLOR[self._rgb] #self._transport.set_stop_button(self._menu[1]) #self._menu[1]._off_value = STOP_COLOR[self._rgb] #self._menu[1]._on_value = STOP_COLOR[self._rgb] #self._menu[1].send_value(STOP_COLOR[self._rgb], True) #self._device_navigator.set_device_nav_buttons(self._menu[3], self._menu[4]) for index in range(8): self._button[index].set_channel(2) self._button[index].set_identifier(index) #self._button[index].reset() self._button[index].set_enabled(False) self.request_rebuild_midi_map() for index in range(2): self._looper[index]._state_change() self._button[1 + (index * 4)].send_value(3) self._button[2 + (index * 4)].send_value(6) self._button[3 + (index * 4)].send_value(1) def _update_selected_device(self): if self._device_selection_follows_track_selection is True: 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.set_device(device_to_select) self.set_appointed_device(device_to_select) #self._device_selector.set_enabled(True) self.request_rebuild_midi_map() return None def handle_sysex(self, midi_bytes): #self.log_message(str('>>sysexIN') + str(midi_bytes)) if len(midi_bytes) > 10: #self.log_message(str('>>sysex>10') + str(midi_bytes[:11])) if midi_bytes[:11] == tuple([240, 126, 0, 6, 2, 0, 1, 97, 1, 0, 7]): self.log_message(str('>>>color detected')) self._rgb = 1 elif midi_bytes[:11] == tuple( [240, 126, 0, 6, 2, 0, 1, 97, 1, 0, 2]): self.log_message(str('>>>mono detected')) self._rgb = 0 self._assign_session_colors() #self._shift_mode.update() self.deassign_matrix() self._assign_page_constants() self.assign_page_0() #self._setup_hilight_knobs() for index in range(8): self._grid[7][index].send_value(SCENE_LAUNCH_COLOR[self._rgb]) for index in range(7): self._grid[index][7].turn_on() # def handle_sysex(self, midi_bytes): # #assert(isinstance (midi_bytes, tuple)) # ##self.log_message(str('sysex') + str(midi_bytes)) # if midi_bytes == tuple([240, 126, 0, 6, 2, 0, 1, 97, 1, 0, 7, 0, 15, 10, 0, 0, 247]): # self.log_message(str('color detected')) # self._rgb = 1 # elif midi_bytes == tuple([240, 126, 0, 6, 2, 0, 1, 97, 1, 0, 2, 0, 0, 1, 1, 0, 247]): # self.log_message(str('mono detected')) # self._rgb = 0 # self._assign_session_colors() def receive_midi(self, midi_bytes): """ Live -> Script MIDI messages are only received through this function, when explicitly forwarded in 'build_midi_map'. """ assert (midi_bytes != None) assert isinstance(midi_bytes, tuple) ##self.log_message('got message' + str(midi_bytes)) #self.set_suppress_rebuild_requests(True) with self.component_guard(): if (len(midi_bytes) is 3): msg_type = (midi_bytes[0] & 240) forwarding_key = [midi_bytes[0]] if (msg_type is not MIDI_PB_TYPE): forwarding_key.append(midi_bytes[1]) if (tuple(forwarding_key) in self._forwarding_registry.keys()): recipient = self._forwarding_registry[tuple( forwarding_key)] if (recipient != None): recipient.receive_value(midi_bytes[2]) else: self.log_message( ('Got unknown message: ' + str(midi_bytes))) else: self.handle_sysex(midi_bytes) #self.set_suppress_rebuild_requests(False) def _set_tempo_buttons(self, buttons): if self._tempo_buttons != None: self._tempo_buttons[0].remove_value_listener(self._tempo_value) self._tempo_buttons[1].remove_value_listener(self._tempo_value) self._tempo_buttons = buttons if buttons != None: for button in buttons: assert isinstance(button, FlashingButtonElement) self._tempo_buttons[0].set_on_off_values(4, 0) self._tempo_buttons[0].add_value_listener(self._tempo_value, True) self._tempo_buttons[1].set_on_off_values(4, 0) self._tempo_buttons[1].add_value_listener(self._tempo_value, True) self._tempo_buttons[0].turn_on() self._tempo_buttons[1].turn_on() def _tempo_value(self, value, sender): if (value > 0) and (self._tempo_buttons.index(sender) == 0): self.song().tempo = round(min((self.song().tempo + 1), 999)) elif (value > 0) and (self._tempo_buttons.index(sender) == 1): self.song().tempo = round(max((self.song().tempo - 1), 20)) def set_scene_index_value(self, bank_index, scene, track): bank = int(bank_index) / 5 index = int(bank_index) % 5 self.log_message('set_scene_index_value' + str(bank) + str(index) + str(scene) + str(track)) #self.log_message( str(type(index)) + str(type(scene)) + str(type(track))) self._scene_indexes[bank][index][0] = scene self._scene_indexes[bank][index][1] = track #self._on_selected_scene_changed() def connect_script_instances(self, instanciated_scripts): #link = False #offsets = [0, 0] #new_channel = CHAN for s in instanciated_scripts: if isinstance(s, APC) or s is self: #link = True if not s._session._is_linked(): s._session._link()