class LemurPad(MonOhm):
__module__ = __name__
__doc__ = " Lemur version of the MonOhm companion controller script "
def __init__(self, *a, **k):
self._timer_callbacks = [
] #Used for _monobridge, which uses L8 method for registering timer callbacks. deprecated, needs to be replaced by new L9 Task class.
self._osc_registry = {}
self._display_button_names = DISPLAY_BUTTON_NAMES
super(LemurPad, self).__init__(*a, **k)
self._host_name = "LemurPad"
self._color_type = 'AumPad'
self.connected = 0
with self.component_guard():
self._setup_touchosc()
self._assign_host2()
self._assign_session_colors()
def query_ohm(self):
pass
"""script initialization methods"""
def _setup_monobridge(self):
self._monobridge = OSCMonoBridgeElement(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(8):
self._fader[index] = OSCMonoEncoderElement(
MIDI_CC_TYPE,
CHANNEL,
OHM_FADERS[index],
Live.MidiMap.MapMode.absolute,
'Fader_' + str(index),
index,
self,
osc='/Fader_' + str(index) + '/x',
osc_parameter='/Strip' + str(index + 8) + '/set',
osc_name='/Strip' + str(index) + '/set')
for index in range(8):
self._button[index] = OSCMonoButtonElement(
is_momentary,
MIDI_NOTE_TYPE,
CHANNEL,
OHM_BUTTONS[index],
'Button_' + str(index),
self,
osc='/Select_' + str(index) + '/value',
osc_alt='/Select/set ' + str(index),
osc_name='/Select/text ' + str(index))
for index in range(16):
self._dial[index] = OSCMonoEncoderElement(
MIDI_CC_TYPE,
CHANNEL,
OHM_DIALS[index],
Live.MidiMap.MapMode.absolute,
'Dial_' + str(index),
index + 8,
self,
osc='/Dial_' + str(index) + '/x',
osc_parameter='/Dial' + str(index) + 'val/set',
osc_name='/Dial' + str(index) + 'name/set')
for index in range(6):
self._menu[index] = OSCMonoButtonElement(
is_momentary,
MIDI_NOTE_TYPE,
CHANNEL,
OHM_MENU[index],
'Menu_' + str(index),
self,
osc='/Function_' + str(index) + '/value',
osc_alt='/Function/set ' + str(index),
osc_name='/Function/text ' + str(index))
self._crossfader = OSCMonoEncoderElement(MIDI_CC_TYPE,
CHANNEL,
CROSSFADER,
Live.MidiMap.MapMode.absolute,
"Crossfader",
24,
self,
osc='/XFader/x',
osc_parameter='/XFader/none',
osc_name=None)
self._livid = OSCMonoButtonElement(is_momentary,
MIDI_NOTE_TYPE,
CHANNEL,
LIVID,
'Livid_Button',
self,
osc='/Livid/x',
osc_alt='/Livid/x',
osc_name=None)
self._shift_l = OSCMonoButtonElement(is_momentary,
MIDI_NOTE_TYPE,
CHANNEL,
SHIFT_L,
'Shift_Button_Left',
self,
osc='/ShiftL/x',
osc_alt='/ShiftL/x',
osc_name=None)
self._shift_r = OSCMonoButtonElement(is_momentary,
MIDI_NOTE_TYPE,
CHANNEL,
SHIFT_R,
'Shift_Button_Right',
self,
osc='/ShiftR/x',
osc_alt='/ShiftR/x',
osc_name=None)
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] = OSCMonoButtonElement(
is_momentary,
MIDI_NOTE_TYPE,
CHANNEL, (column * 8) + row,
'Grid_' + str(column) + '_' + str(row),
self,
osc='/ClipGrid_' + str(column) + '_' + str(row) + '/value',
osc_alt='/ClipGrid/set ' + str(column) + ' ' + str(row),
osc_name='/ClipGrid/text ' + str(column) + ' ' + str(row))
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'
self._monomod256 = ButtonMatrixElement()
self._monomod256.name = 'Monomod256'
self._square = [None for index in range(16)]
for column in range(16):
self._square[column] = [None for index in range(16)]
for row in range(16):
self._square[column][row] = OSCMonoButtonElement(
is_momentary,
MIDI_NOTE_TYPE,
int(column / 8) + 1,
row + ((column % 8) * 16),
'256Grid_' + str(column) + '_' + str(row),
self,
osc='/Grid_' + str(column) + '_' + str(row) + '/value',
osc_alt='/Grid/set ' + str(column) + ' ' + str(row),
osc_name=None)
#self._square[column][row] = FlashingButtonElement(is_momentary, 0, 15, -1, '256Grid_' + str(column) + '_' + str(row), '/1/p_grid/'+str(column)+'/'+str(row), '/1/c_grid/'+str(column)+'/'+str(row), self)
for row in range(16):
button_row = []
for column in range(16):
button_row.append(self._square[column][row])
self._monomod256.add_row(tuple(button_row))
self._bank_buttons = ButtonMatrixElement()
self._key_buttons = ButtonMatrixElement()
self._bank_button = [None for index in range(2)]
for index in range(2):
self._bank_button[index] = OSCMonoButtonElement(
is_momentary,
MIDI_NOTE_TYPE,
15,
index,
'256Grid_Bank_' + str(index),
self,
osc='/Shift_' + str(index) + '/value',
osc_alt='/Shift/set ' + str(index),
osc_name=None)
button_row = []
for index in range(2):
button_row.append(self._bank_button[index])
self._bank_buttons.add_row(tuple(button_row))
button_row = []
self._key_button = [None for index in range(8)]
for index in range(8):
self._key_button[index] = OSCMonoButtonElement(
is_momentary,
MIDI_NOTE_TYPE,
15,
index + 8,
'256Grid_Key_' + str(index),
self,
osc='/Keys_' + str(index) + '/value',
osc_alt='/Keys/set ' + str(index),
osc_name=None)
for index in range(8):
button_row.append(self._key_button[index])
self._key_buttons.add_row(tuple(button_row))
def _setup_session_control(self):
is_momentary = True
num_tracks = 4
num_scenes = 5
self._session = NameServerSessionComponent(num_tracks, num_scenes,
self)
self._session.name = "Left_Session"
self._session.set_offsets(0, 0)
self._session.set_stop_clip_value(self._color_defs['STOP_CLIP'])
self._scene = [None for index in range(5)]
for row in range(num_scenes):
self._scene[row] = self._session.scene(row)
self._scene[row].name = 'L_Scene_' + str(row)
for column in range(num_tracks):
clip_slot = self._scene[row].clip_slot(column)
clip_slot.name = str(column) + '_Clip_Slot_L_' + str(row)
clip_slot.set_triggered_to_play_value(
self._color_defs['CLIP_TRG_PLAY'])
clip_slot.set_triggered_to_record_value(
self._color_defs['CLIP_TRG_REC'])
clip_slot.set_stopped_value(self._color_defs['CLIP_STOP'])
clip_slot.set_started_value(self._color_defs['CLIP_STARTED'])
clip_slot.set_recording_value(
self._color_defs['CLIP_RECORDING'])
self._session.set_mixer(self._mixer)
self._session_zoom = SessionZoomingComponent(self._session)
self._session_zoom.name = 'L_Session_Overview'
self._session_zoom.set_stopped_value(self._color_defs['ZOOM_STOPPED'])
self._session_zoom.set_playing_value(self._color_defs['ZOOM_PLAYING'])
self._session_zoom.set_selected_value(
self._color_defs['ZOOM_SELECTED'])
self._session_zoom._zoom_button = (self._dummy_button)
self._session_zoom.set_enabled(True)
self._session2 = SessionComponent(num_tracks, num_scenes)
self._session2.name = 'Right_Session'
self._session2.set_offsets(4, 0)
self._session2.set_stop_clip_value(self._color_defs['STOP_CLIP'])
self._scene2 = [None for index in range(5)]
for row in range(num_scenes):
self._scene2[row] = self._session2.scene(row)
self._scene2[row].name = 'R_Scene_' + str(row)
for column in range(num_tracks):
clip_slot = self._scene2[row].clip_slot(column)
clip_slot.name = str(column) + '_Clip_Slot_R_' + str(row)
clip_slot.set_triggered_to_play_value(
self._color_defs['CLIP_TRG_PLAY'])
clip_slot.set_triggered_to_record_value(
self._color_defs['CLIP_TRG_REC'])
clip_slot.set_stopped_value(self._color_defs['CLIP_STOP'])
clip_slot.set_started_value(self._color_defs['CLIP_STARTED'])
clip_slot.set_recording_value(
self._color_defs['CLIP_RECORDING'])
self._session2.set_mixer(self._mixer2)
self._session2.add_offset_listener(self._on_session_offset_changes)
self._session_zoom2 = SessionZoomingComponent(self._session2)
self._session_zoom2.name = 'R_Session_Overview'
self._session_zoom2.set_stopped_value(self._color_defs['ZOOM_STOPPED'])
self._session_zoom2.set_playing_value(self._color_defs['ZOOM_PLAYING'])
self._session_zoom2.set_selected_value(
self._color_defs['ZOOM_SELECTED'])
self._session_zoom.set_enabled(True)
self._session_zoom2._zoom_button = (self._dummy_button2)
self._session_main = SessionComponent(8, num_scenes)
self._session_main.name = 'Main_Session'
self._session_main.set_stop_clip_value(self._color_defs['STOP_CLIP'])
self._scene_main = [None for index in range(5)]
for row in range(num_scenes):
self._scene_main[row] = self._session_main.scene(row)
self._scene_main[row].name = 'M_Scene_' + str(row)
for column in range(8):
clip_slot = self._scene_main[row].clip_slot(column)
clip_slot.name = str(column) + '_Clip_Slot_M_' + str(row)
clip_slot.set_triggered_to_play_value(
self._color_defs['CLIP_TRG_PLAY'])
clip_slot.set_triggered_to_record_value(
self._color_defs['CLIP_TRG_REC'])
clip_slot.set_stopped_value(self._color_defs['CLIP_STOP'])
clip_slot.set_started_value(self._color_defs['CLIP_STARTED'])
clip_slot.set_recording_value(
self._color_defs['CLIP_RECORDING'])
self._session_main.set_mixer(self._mixer)
self._session_zoom_main = SessionZoomingComponent(self._session_main)
self._session_zoom_main.name = 'M_Session_Overview'
self._session_zoom_main.set_stopped_value(
self._color_defs['ZOOM_STOPPED'])
self._session_zoom_main.set_playing_value(
self._color_defs['ZOOM_PLAYING'])
self._session_zoom_main.set_selected_value(
self._color_defs['ZOOM_SELECTED'])
self._session_zoom_main.set_enabled(True)
self._session_zoom_main._zoom_button = (self._dummy_button3)
self._sessions = [self._session, self._session2, self._session_main]
self._zooms = [
self._session_zoom, self._session_zoom2, self._session_zoom_main
]
def _setup_mod(self):
self.monomodular = get_monomodular(self)
self.monomodular.name = 'monomodular_switcher'
self.modhandler = LemurOhmModHandler(self)
self.modhandler.name = 'ModHandler'
self.modhandler256 = LemurModHandler(self)
self.modhandler256.name = 'ModHandler256'
def _assign_host2(self):
self.modhandler256.set_shift_button(self._bank_button[0])
self.modhandler256.set_alt_button(self._bank_button[1])
self.modhandler256.set_grid(self._monomod256)
self.modhandler256.set_key_buttons(self._key_buttons)
self.modhandler256.set_enabled(True)
def _setup_touchosc(self):
self._osc_registry = {}
#self._osc_registry['/ping'] = self._monobridge.ping
#self._osc_registry['/1'] = self._monobridge.page1
#self._osc_registry['/2'] = self._monobridge.page2
for control in self.controls:
if hasattr(control, 'osc'):
self._osc_registry[control.osc] = control.set_value
#if hasattr(control, 'osc_alt'):
# self._osc_registry[control.osc_alt] = control.set_value
#self.log_message('create dict key: ' + str(control.osc) + str(control.name))
"""shift/zoom methods"""
def deassign_matrix(self):
super(LemurPad, self).deassign_matrix()
self.clear_grid_names()
"""menu button management methods"""
def deassign_menu(self):
super(LemurPad, self).deassign_menu()
for index in range(6):
self._monobridge._send_osc(self._menu[index].osc_name,
self.generate_strip_string(' '))
def assign_device_nav_to_menu(self):
super(LemurPad, self).assign_device_nav_to_menu()
for index in range(6):
self._monobridge._send_osc(
self._menu[index].osc_name,
self.generate_strip_string(str(DEVICE_NAV_NAMES[index])))
def assign_transport_to_menu(self):
super(LemurPad, self).assign_transport_to_menu()
for index in range(6):
self._monobridge._send_osc(
self._menu[index].osc_name,
self.generate_strip_string(str(TRANSPORT_NAMES[index])))
def assign_session_nav_to_menu(self):
super(LemurPad, self).assign_session_nav_to_menu()
for index in range(6):
self._monobridge._send_osc(
self._menu[index].osc_name,
self.generate_strip_string(str(SESSION_NAV_NAMES[index])))
def assign_session_main_nav_to_menu(self):
super(LemurPad, self).assign_session_main_nav_to_menu()
for index in range(6):
self._monobridge._send_osc(
self._menu[index].osc_name,
self.generate_strip_string(str(SESSION_NAV_NAMES[index])))
def assign_monomod_shift_to_menu(self):
super(LemurPad, self).assign_monomod_shift_to_menu()
for index in range(6):
self._monobridge._send_osc(
self._menu[index].osc_name,
self.generate_strip_string(str(MONOMOD_SHIFT_NAMES[index])))
def assign_monomod_to_menu(self):
super(LemurPad, self).assign_monomod_shift_to_menu()
for index in range(6):
self._monobridge._send_osc(
self._menu[index].osc_name,
self.generate_strip_string(str(MONOMOD_NAMES[index])))
def assign_session_bank_to_menu(self):
super(LemurPad, self).assign_session_bank_to_menu()
for index in range(6):
self._monobridge._send_osc(
self._menu[index].osc_name,
self.generate_strip_string(str(SESSION_BANK_NAMES[index])))
def assign_session2_bank_to_menu(self):
super(LemurPad, self).assign_session2_bank_to_menu()
for index in range(6):
self._monobridge._send_osc(
self._menu[index].osc_name,
self.generate_strip_string(str(SESSION_BANK2_NAMES[index])))
def assign_session_main_nav_to_menu(self):
super(LemurPad, self).assign_session_main_nav_to_menu()
for index in range(6):
self._monobridge._send_osc(
self._menu[index].osc_name,
self.generate_strip_string(str(
SESSION_MAIN_BANK_NAMES[index])))
"""m4l bridge"""
def generate_strip_string(self, display_string):
NUM_CHARS_PER_DISPLAY_STRIP = 9
if (not display_string):
return ('`_')
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.replace(' ', '_')
def notification_to_bridge(self, name, value, sender):
if (isinstance(sender, MonoEncoderElement2)):
#self.log_message(str(name) + str(value) + str(sender.num))
self._monobridge._send('lcd_name', sender.name,
self.generate_strip_string(str(name)))
self._monobridge._send('lcd_value', sender.name,
self.generate_strip_string(str(value)))
def clip_name(self, sender, name):
#self.log_message('clip name ' + str(sender.osc_name) + ' ' + str(self.generate_strip_string(str(name))))
self._monobridge._send_osc(sender.osc_name,
self.generate_strip_string(str(name)))
"""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():
clip_names.append(clip_slot._clip_slot)##.clip.name)
#return clip_slot._clip_slot
#self.log_message('clip name' + str(clip_slot._clip_slot.clip.name))
return clip_names"""
"""called on timer"""
def update_display(self):
super(LemurPad, self).update_display()
for callback in self._timer_callbacks:
callback()
def strobe(self):
pass
"""general functionality"""
def disconnect(self):
super(MonOhm, self).disconnect()
def clear_grid_names(self):
#self.log_message('clear grid names' + str(self))
for column in range(8):
for row in range(8):
self._monobridge._send_osc(self._grid[column][row].osc_name,
'`_')
def _register_timer_callback(self, callback):
""" Registers a callback that is triggerd on every call of update_display """
assert (callback != None)
assert (dir(callback).count('im_func') is 1)
assert (self._timer_callbacks.count(callback) == 0)
self._timer_callbacks.append(callback)
return None
def _unregister_timer_callback(self, callback):
""" Unregisters a timer callback """
assert (callback != None)
assert (dir(callback).count('im_func') is 1)
assert (self._timer_callbacks.count(callback) == 1)
self._timer_callbacks.remove(callback)
return None
def _set_brightness(self, value):
#self._bright = (value != 0)
#for control in self.controls:
# if isinstance(control, OSCMonoButtonElement):
# self._monobridge._send_osc(control.osc_alt, int(self._bright), True)
pass
def reset(self):
#self._monobridge._send_osc('/reset')
for control in self.controls:
control.reset()
def assign_lower_grid_names(self, mode):
if self._display_button_names is True:
for column in range(8):
for row in range(3):
self._monobridge._send_osc(
self._grid[column][row + 5].osc_name,
self.generate_strip_string(
str(GRID_NAMES[mode][row][column])))
def reset_and_refresh_state(self, *a, **k):
self.schedule_message(1, self.reset)
self.schedule_message(2, self.refresh_state)
class LemurPad(MonOhm):
__module__ = __name__
__doc__ = " Lemur version of the MonOhm companion controller script "
def __init__(self, *a, **k):
self._timer_callbacks = [] #Used for _monobridge, which uses L8 method for registering timer callbacks. deprecated, needs to be replaced by new L9 Task class.
self._osc_registry = {}
self._display_button_names = DISPLAY_BUTTON_NAMES
super(LemurPad, self).__init__(*a, **k)
self._host_name = "LemurPad"
self._color_type = 'AumPad'
self.connected = 0
with self.component_guard():
self._setup_touchosc()
self._assign_host2()
self._assign_session_colors()
def query_ohm(self):
pass
"""script initialization methods"""
def _setup_monobridge(self):
self._monobridge = OSCMonoBridgeElement(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(8):
self._fader[index] = OSCMonoEncoderElement(MIDI_CC_TYPE, CHANNEL, OHM_FADERS[index], Live.MidiMap.MapMode.absolute, 'Fader_' + str(index), index, self, osc = '/Fader_'+str(index)+'/x', osc_parameter = '/Strip'+str(index+8)+'/set', osc_name = '/Strip'+str(index)+'/set')
for index in range(8):
self._button[index] = OSCMonoButtonElement(is_momentary, MIDI_NOTE_TYPE, CHANNEL, OHM_BUTTONS[index], 'Button_'+str(index), self, osc = '/Select_'+str(index)+'/value', osc_alt = '/Select/set '+str(index), osc_name = '/Select/text '+str(index))
for index in range(16):
self._dial[index] = OSCMonoEncoderElement(MIDI_CC_TYPE, CHANNEL, OHM_DIALS[index], Live.MidiMap.MapMode.absolute, 'Dial_' + str(index), index + 8, self, osc = '/Dial_'+str(index)+'/x', osc_parameter = '/Dial'+str(index)+'val/set', osc_name = '/Dial'+str(index)+'name/set')
for index in range(6):
self._menu[index] = OSCMonoButtonElement(is_momentary, MIDI_NOTE_TYPE, CHANNEL, OHM_MENU[index], 'Menu_' + str(index), self, osc = '/Function_'+str(index)+'/value', osc_alt = '/Function/set '+str(index), osc_name = '/Function/text '+str(index))
self._crossfader = OSCMonoEncoderElement(MIDI_CC_TYPE, CHANNEL, CROSSFADER, Live.MidiMap.MapMode.absolute, "Crossfader", 24, self, osc = '/XFader/x', osc_parameter = '/XFader/none', osc_name = None)
self._livid = OSCMonoButtonElement(is_momentary, MIDI_NOTE_TYPE, CHANNEL, LIVID, 'Livid_Button', self, osc = '/Livid/x', osc_alt = '/Livid/x', osc_name = None)
self._shift_l = OSCMonoButtonElement(is_momentary, MIDI_NOTE_TYPE, CHANNEL, SHIFT_L, 'Shift_Button_Left', self, osc = '/ShiftL/x', osc_alt = '/ShiftL/x', osc_name = None)
self._shift_r = OSCMonoButtonElement(is_momentary, MIDI_NOTE_TYPE, CHANNEL, SHIFT_R, 'Shift_Button_Right', self, osc = '/ShiftR/x', osc_alt = '/ShiftR/x', osc_name = None)
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] = OSCMonoButtonElement(is_momentary, MIDI_NOTE_TYPE, CHANNEL, (column * 8) + row, 'Grid_' + str(column) + '_' + str(row), self, osc = '/ClipGrid_'+str(column)+'_'+str(row)+'/value', osc_alt = '/ClipGrid/set '+str(column)+' '+str(row), osc_name = '/ClipGrid/text '+str(column)+' '+str(row))
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'
self._monomod256 = ButtonMatrixElement()
self._monomod256.name = 'Monomod256'
self._square = [None for index in range(16)]
for column in range(16):
self._square[column] = [None for index in range(16)]
for row in range(16):
self._square[column][row] = OSCMonoButtonElement(is_momentary, MIDI_NOTE_TYPE, int(column/8) + 1, row + ((column%8) * 16), '256Grid_' + str(column) + '_' + str(row), self, osc = '/Grid_'+str(column)+'_'+str(row)+'/value', osc_alt = '/Grid/set '+str(column)+' '+str(row), osc_name = None)
#self._square[column][row] = FlashingButtonElement(is_momentary, 0, 15, -1, '256Grid_' + str(column) + '_' + str(row), '/1/p_grid/'+str(column)+'/'+str(row), '/1/c_grid/'+str(column)+'/'+str(row), self)
for row in range(16):
button_row = []
for column in range(16):
button_row.append(self._square[column][row])
self._monomod256.add_row(tuple(button_row))
self._bank_buttons = ButtonMatrixElement()
self._key_buttons = ButtonMatrixElement()
self._bank_button = [None for index in range(2)]
for index in range(2):
self._bank_button[index] = OSCMonoButtonElement(is_momentary, MIDI_NOTE_TYPE, 15, index, '256Grid_Bank_' + str(index), self, osc = '/Shift_'+str(index)+'/value', osc_alt = '/Shift/set '+str(index), osc_name = None)
button_row = []
for index in range(2):
button_row.append(self._bank_button[index])
self._bank_buttons.add_row(tuple(button_row))
button_row = []
self._key_button = [None for index in range(8)]
for index in range(8):
self._key_button[index] = OSCMonoButtonElement(is_momentary, MIDI_NOTE_TYPE, 15, index+8, '256Grid_Key_' + str(index), self, osc = '/Keys_'+str(index)+'/value', osc_alt = '/Keys/set '+str(index), osc_name = None)
for index in range(8):
button_row.append(self._key_button[index])
self._key_buttons.add_row(tuple(button_row))
def _setup_session_control(self):
is_momentary = True
num_tracks = 4
num_scenes = 5
self._session = NameServerSessionComponent(num_tracks, num_scenes, self)
self._session.name = "Left_Session"
self._session.set_offsets(0, 0)
self._session.set_stop_clip_value(self._color_defs['STOP_CLIP'])
self._scene = [None for index in range(5)]
for row in range(num_scenes):
self._scene[row] = self._session.scene(row)
self._scene[row].name = 'L_Scene_' + str(row)
for column in range(num_tracks):
clip_slot = self._scene[row].clip_slot(column)
clip_slot.name = str(column) + '_Clip_Slot_L_' + str(row)
clip_slot.set_triggered_to_play_value(self._color_defs['CLIP_TRG_PLAY'])
clip_slot.set_triggered_to_record_value(self._color_defs['CLIP_TRG_REC'])
clip_slot.set_stopped_value(self._color_defs['CLIP_STOP'])
clip_slot.set_started_value(self._color_defs['CLIP_STARTED'])
clip_slot.set_recording_value(self._color_defs['CLIP_RECORDING'])
self._session.set_mixer(self._mixer)
self._session_zoom = SessionZoomingComponent(self._session)
self._session_zoom.name = 'L_Session_Overview'
self._session_zoom.set_stopped_value(self._color_defs['ZOOM_STOPPED'])
self._session_zoom.set_playing_value(self._color_defs['ZOOM_PLAYING'])
self._session_zoom.set_selected_value(self._color_defs['ZOOM_SELECTED'])
self._session_zoom._zoom_button = (self._dummy_button)
self._session_zoom.set_enabled(True)
self._session2 = SessionComponent(num_tracks, num_scenes)
self._session2.name = 'Right_Session'
self._session2.set_offsets(4, 0)
self._session2.set_stop_clip_value(self._color_defs['STOP_CLIP'])
self._scene2 = [None for index in range(5)]
for row in range(num_scenes):
self._scene2[row] = self._session2.scene(row)
self._scene2[row].name = 'R_Scene_' + str(row)
for column in range(num_tracks):
clip_slot = self._scene2[row].clip_slot(column)
clip_slot.name = str(column) + '_Clip_Slot_R_' + str(row)
clip_slot.set_triggered_to_play_value(self._color_defs['CLIP_TRG_PLAY'])
clip_slot.set_triggered_to_record_value(self._color_defs['CLIP_TRG_REC'])
clip_slot.set_stopped_value(self._color_defs['CLIP_STOP'])
clip_slot.set_started_value(self._color_defs['CLIP_STARTED'])
clip_slot.set_recording_value(self._color_defs['CLIP_RECORDING'])
self._session2.set_mixer(self._mixer2)
self._session2.add_offset_listener(self._on_session_offset_changes)
self._session_zoom2 = SessionZoomingComponent(self._session2)
self._session_zoom2.name = 'R_Session_Overview'
self._session_zoom2.set_stopped_value(self._color_defs['ZOOM_STOPPED'])
self._session_zoom2.set_playing_value(self._color_defs['ZOOM_PLAYING'])
self._session_zoom2.set_selected_value(self._color_defs['ZOOM_SELECTED'])
self._session_zoom.set_enabled(True)
self._session_zoom2._zoom_button = (self._dummy_button2)
self._session_main = SessionComponent(8, num_scenes)
self._session_main.name = 'Main_Session'
self._session_main.set_stop_clip_value(self._color_defs['STOP_CLIP'])
self._scene_main = [None for index in range(5)]
for row in range(num_scenes):
self._scene_main[row] = self._session_main.scene(row)
self._scene_main[row].name = 'M_Scene_' + str(row)
for column in range(8):
clip_slot = self._scene_main[row].clip_slot(column)
clip_slot.name = str(column) + '_Clip_Slot_M_' + str(row)
clip_slot.set_triggered_to_play_value(self._color_defs['CLIP_TRG_PLAY'])
clip_slot.set_triggered_to_record_value(self._color_defs['CLIP_TRG_REC'])
clip_slot.set_stopped_value(self._color_defs['CLIP_STOP'])
clip_slot.set_started_value(self._color_defs['CLIP_STARTED'])
clip_slot.set_recording_value(self._color_defs['CLIP_RECORDING'])
self._session_main.set_mixer(self._mixer)
self._session_zoom_main = SessionZoomingComponent(self._session_main)
self._session_zoom_main.name = 'M_Session_Overview'
self._session_zoom_main.set_stopped_value(self._color_defs['ZOOM_STOPPED'])
self._session_zoom_main.set_playing_value(self._color_defs['ZOOM_PLAYING'])
self._session_zoom_main.set_selected_value(self._color_defs['ZOOM_SELECTED'])
self._session_zoom_main.set_enabled(True)
self._session_zoom_main._zoom_button = (self._dummy_button3)
self._sessions = [self._session, self._session2, self._session_main]
self._zooms = [self._session_zoom, self._session_zoom2, self._session_zoom_main]
def _setup_mod(self):
self.monomodular = get_monomodular(self)
self.monomodular.name = 'monomodular_switcher'
self.modhandler = LemurOhmModHandler(self)
self.modhandler.name = 'ModHandler'
self.modhandler256 = LemurModHandler(self)
self.modhandler256.name = 'ModHandler256'
def _assign_host2(self):
self.modhandler256.set_shift_button(self._bank_button[0])
self.modhandler256.set_alt_button(self._bank_button[1])
self.modhandler256.set_grid(self._monomod256)
self.modhandler256.set_key_buttons(self._key_buttons)
self.modhandler256.set_enabled(True)
def _setup_touchosc(self):
self._osc_registry = {}
#self._osc_registry['/ping'] = self._monobridge.ping
#self._osc_registry['/1'] = self._monobridge.page1
#self._osc_registry['/2'] = self._monobridge.page2
for control in self.controls:
if hasattr(control, 'osc'):
self._osc_registry[control.osc] = control.set_value
#if hasattr(control, 'osc_alt'):
# self._osc_registry[control.osc_alt] = control.set_value
#self.log_message('create dict key: ' + str(control.osc) + str(control.name))
"""shift/zoom methods"""
def deassign_matrix(self):
super(LemurPad, self).deassign_matrix()
self.clear_grid_names()
"""menu button management methods"""
def deassign_menu(self):
super(LemurPad, self).deassign_menu()
for index in range(6):
self._monobridge._send_osc(self._menu[index].osc_name, self.generate_strip_string(' '))
def assign_device_nav_to_menu(self):
super(LemurPad, self).assign_device_nav_to_menu()
for index in range(6):
self._monobridge._send_osc(self._menu[index].osc_name, self.generate_strip_string(str(DEVICE_NAV_NAMES[index])))
def assign_transport_to_menu(self):
super(LemurPad, self).assign_transport_to_menu()
for index in range(6):
self._monobridge._send_osc(self._menu[index].osc_name, self.generate_strip_string(str(TRANSPORT_NAMES[index])))
def assign_session_nav_to_menu(self):
super(LemurPad, self).assign_session_nav_to_menu()
for index in range(6):
self._monobridge._send_osc(self._menu[index].osc_name, self.generate_strip_string(str(SESSION_NAV_NAMES[index])))
def assign_session_main_nav_to_menu(self):
super(LemurPad, self).assign_session_main_nav_to_menu()
for index in range(6):
self._monobridge._send_osc(self._menu[index].osc_name, self.generate_strip_string(str(SESSION_NAV_NAMES[index])))
def assign_monomod_shift_to_menu(self):
super(LemurPad, self).assign_monomod_shift_to_menu()
for index in range(6):
self._monobridge._send_osc(self._menu[index].osc_name, self.generate_strip_string(str(MONOMOD_SHIFT_NAMES[index])))
def assign_monomod_to_menu(self):
super(LemurPad, self).assign_monomod_shift_to_menu()
for index in range(6):
self._monobridge._send_osc(self._menu[index].osc_name, self.generate_strip_string(str(MONOMOD_NAMES[index])))
def assign_session_bank_to_menu(self):
super(LemurPad, self).assign_session_bank_to_menu()
for index in range(6):
self._monobridge._send_osc(self._menu[index].osc_name, self.generate_strip_string(str(SESSION_BANK_NAMES[index])))
def assign_session2_bank_to_menu(self):
super(LemurPad, self).assign_session2_bank_to_menu()
for index in range(6):
self._monobridge._send_osc(self._menu[index].osc_name, self.generate_strip_string(str(SESSION_BANK2_NAMES[index])))
def assign_session_main_nav_to_menu(self):
super(LemurPad, self).assign_session_main_nav_to_menu()
for index in range(6):
self._monobridge._send_osc(self._menu[index].osc_name, self.generate_strip_string(str(SESSION_MAIN_BANK_NAMES[index])))
"""m4l bridge"""
def generate_strip_string(self, display_string):
NUM_CHARS_PER_DISPLAY_STRIP = 9
if (not display_string):
return ('`_')
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.replace(' ', '_')
def notification_to_bridge(self, name, value, sender):
if(isinstance(sender, MonoEncoderElement2)):
#self.log_message(str(name) + str(value) + str(sender.num))
self._monobridge._send('lcd_name', sender.name, self.generate_strip_string(str(name)))
self._monobridge._send('lcd_value', sender.name, self.generate_strip_string(str(value)))
def clip_name(self, sender, name):
#self.log_message('clip name ' + str(sender.osc_name) + ' ' + str(self.generate_strip_string(str(name))))
self._monobridge._send_osc(sender.osc_name, self.generate_strip_string(str(name)))
"""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():
clip_names.append(clip_slot._clip_slot)##.clip.name)
#return clip_slot._clip_slot
#self.log_message('clip name' + str(clip_slot._clip_slot.clip.name))
return clip_names"""
"""called on timer"""
def update_display(self):
super(LemurPad, self).update_display()
for callback in self._timer_callbacks:
callback()
def strobe(self):
pass
"""general functionality"""
def disconnect(self):
super(MonOhm, self).disconnect()
def clear_grid_names(self):
#self.log_message('clear grid names' + str(self))
for column in range(8):
for row in range(8):
self._monobridge._send_osc(self._grid[column][row].osc_name, '`_')
def _register_timer_callback(self, callback):
""" Registers a callback that is triggerd on every call of update_display """
assert (callback != None)
assert (dir(callback).count('im_func') is 1)
assert (self._timer_callbacks.count(callback) == 0)
self._timer_callbacks.append(callback)
return None
def _unregister_timer_callback(self, callback):
""" Unregisters a timer callback """
assert (callback != None)
assert (dir(callback).count('im_func') is 1)
assert (self._timer_callbacks.count(callback) == 1)
self._timer_callbacks.remove(callback)
return None
def _set_brightness(self, value):
#self._bright = (value != 0)
#for control in self.controls:
# if isinstance(control, OSCMonoButtonElement):
# self._monobridge._send_osc(control.osc_alt, int(self._bright), True)
pass
def reset(self):
#self._monobridge._send_osc('/reset')
for control in self.controls:
control.reset()
def assign_lower_grid_names(self, mode):
if self._display_button_names is True:
for column in range(8):
for row in range(3):
self._monobridge._send_osc(self._grid[column][row+5].osc_name, self.generate_strip_string(str(GRID_NAMES[mode][row][column])))
def reset_and_refresh_state(self, *a, **k):
self.schedule_message(1, self.reset)
self.schedule_message(2, self.refresh_state)
class OhmModes(ControlSurface):
__module__ = __name__
__doc__ = ' OhmModes controller script '
def __init__(self, c_instance):
super(OhmModes, self).__init__(c_instance)
self._version_check = 'b996'
self._host_name = 'Ohm'
self._color_type = 'OhmRGB'
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
with self.component_guard():
self._setup_monobridge()
self._setup_controls()
self._setup_m4l_interface()
self._setup_transport_control()
self._setup_mixer_control()
self._setup_session_control()
self._setup_device_control()
self._setup_crossfader()
self._setup_translations()
self._setup_mod()
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('<<<<<<<<<<<<<<<<<<<<<<<<< OhmModes ' + str(self._version_check) + ' log opened >>>>>>>>>>>>>>>>>>>>>>>>>')
debug('DEBUG ON for OhmModes script.')
def query_ohm(self):
self._send_midi(tuple(check_model))
def update_display(self):
super(OhmModes, self).update_display()
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] = MonoEncoderElement(MIDI_CC_TYPE, CHANNEL, OHM_FADERS[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(16):
self._dial[index] = MonoEncoderElement(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] = 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) ]
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] = 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._dial_matrix = ButtonMatrixElement()
for row in range(3):
dial_row = []
for column in range(4):
dial_row.append(self._dial[column + (row*4)])
self._dial_matrix.add_row(tuple(dial_row))
self._menu_matrix = ButtonMatrixElement([self._menu])
def _setup_m4l_interface(self):
self._m4l_interface = M4LInterfaceComponent(controls=self.controls, component_guard=self.component_guard)
self.get_control_names = self._m4l_interface.get_control_names
self.get_control = self._m4l_interface.get_control
self.grab_control = self._m4l_interface.grab_control
self.release_control = self._m4l_interface.release_control
def _setup_translations(self):
controls = []
for array in self._grid:
for button in array:
controls.append(button)
if FADER_BANKING:
controls = controls + self._dial
if DIAL_BANKING:
controls = controls + self._dial
self._translations = TranslationComponent(controls, USER_CHANNEL)
self._translations.layer = Layer(priority = 7, channel_selector_buttons = self._menu_matrix)
def _setup_mod(self):
self.monomodular = get_monomodular(self)
self.monomodular.name = 'monomodular_switcher'
self.modhandler = OhmModHandler(self)
self.modhandler.name = 'ModHandler'
self.modhandler.layer = Layer(priority = 5,
grid = self._monomod,
nav_up_button = self._menu[2],
nav_down_button = self._menu[5],
nav_left_button = self._menu[3],
nav_right_button = self._menu[4],
shift_button = self._menu[1],
alt_button = self._menu[0],
parameter_controls = self._dial_matrix)
self.modhandler.legacy_shift_mode = AddLayerMode(self.modhandler, Layer(priority = 6,
channel_buttons = self._monomod.submatrix[:, 1:2],
nav_matrix = self._monomod.submatrix[4:8, 2:6]))
self.modhandler.shift_mode = AddLayerMode(self.modhandler, Layer(priority = 6,
device_selector_matrix = self._monomod.submatrix[:, :1],
lock_button = self._livid,
key_buttons = self._monomod.submatrix[:, 7:8]))
self.modhandler.set_enabled(False)
self.modhandler.set_mod_button(self._livid)
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._shift_mode.layer = Layer(priority = 4, mode_toggle1 = self._shift_l, mode_toggle2 = self._shift_r, mode_toggle3 = self._livid)
self._shift_mode.set_enabled(True)
self._scale_mode = ScaleModeComponent(self)
self._scale_mode.name = 'Scale_Mode'
self._octave_mode = OctaveModeComponent(self)
self._octave_mode.name = 'Octave_Mode'
def _setup_transport_control(self):
self._transport = TransportComponent()
self._transport.name = 'Transport'
#self._transport.layer = Layer(priority = 4, play_button = self._menu[2], stop_button = self._menu[3])
def _setup_mixer_control(self):
global mixer
is_momentary = True
self._num_tracks = 7
mixer = SpecialMixerComponent(7, 0, True, True)
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_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 =--------------')
super(OhmModes, self).disconnect()
rebuild_sys()
def _get_num_tracks(self):
return self.num_tracks
def flash(self):
if(self.flash_status > 0):
for control in self.controls:
if isinstance(control, MonoButtonElement):
control.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.modhandler.set_enabled(False)
self._translations.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_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):
self.modhandler.set_enabled(True)
def assign_translation(self):
self._translations.set_enabled(True)
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._dial:
knob.set_channel(chan)
knob.set_enabled(chan is 0)
self.request_rebuild_midi_map()
def _update_selected_device(self):
if self._device_selection_follows_track_selection is True:
self._update_device_selection()
def handle_sysex(self, midi_bytes):
#self.log_message('sysex: ' + str(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
for button in self._button:
button._color_map = COLOR_MAP
for column in self._grid:
for button in column:
button._color_map = COLOR_MAP
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
for button in self._button:
button._color_map = [127 for index in range(0, 7)]
for column in self._grid:
for button in column:
button._color_map = [127 for index in range(0, 7)]
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_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, MonoButtonElement)
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([MonoButtonElement, 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)
return clip_slot._clip_slot
return clip_names
