def __init__(self, parent, device, name, *a, **k):
super(ModClient, self).__init__(*a, **k)
self.name = name
self.device = device
self._device_parent = None
self._parent = parent
self.log_message = parent.log_message
self._active_handlers = []
self._addresses = {}
self._translations = {}
self._translation_groups = {}
self._color_maps = {}
self.legacy = False
self.register_addresses()
self._param_component = MonoDeviceComponent(self, MOD_BANK_DICT, MOD_TYPES)
def __init__(self, parent, device, name, *a, **k):
super(ModClient, self).__init__(*a, **k)
self.name = name
self.device = device
self._device_parent = None
self._parent = parent
self.log_message = parent.log_message
self._active_handlers = []
self._addresses = {}
self._translations = {}
self._translation_groups = {}
self._color_maps = {}
self.legacy = False
self.register_addresses()
self._param_component = MonoDeviceComponent(self, MOD_BANK_DICT,
MOD_TYPES)
def __init__(self, parent, device, name, *a, **k):
super(ModClient, self).__init__(*a, **k)
self.name = name
self.device = device
self._device_parent = device.canonical_parent
self._parent = parent
self.log_message = parent.log_message
self._active_handlers = []
self._addresses = {}
self._translations = {}
self._translation_groups = {}
self._color_maps = {}
self.legacy = False
self._param_component = MonoDeviceComponent(self, MOD_BANK_DICT, MOD_TYPES)
self._param_component._device = self.device
self.register_addresses()
#self._device_listener.subject = device.canonical_parent
self._parent._task_group.add(sequence(delay(2), self.connect))
def __init__(self, parent, device, name, *a, **k):
super(ModClient, self).__init__(*a, **k)
self.name = name
self.device = device
self._device_parent = device.canonical_parent
self._parent = parent
self.log_message = parent.log_message
self._active_handlers = []
self._addresses = {}
self._translations = {}
self._translation_groups = {}
self._color_maps = {}
self.legacy = False
self._param_component = MonoDeviceComponent(self, MOD_BANK_DICT, MOD_TYPES)
self._param_component._device = self.device
self.register_addresses()
#self._device_listener.subject = device.canonical_parent
self._parent._task_group.add(sequence(delay(2), self.connect))
class ModClient(NotifyingControlElement):
__subject_events__ = (SubjectEvent(name='value', signal=InputSignal, override=True),)
_input_signal_listener_count = 0
def __init__(self, parent, device, name, *a, **k):
super(ModClient, self).__init__(*a, **k)
self.name = name
self.device = device
self._device_parent = device.canonical_parent
self._parent = parent
self.log_message = parent.log_message
self._active_handlers = []
self._addresses = {}
self._translations = {}
self._translation_groups = {}
self._color_maps = {}
self.legacy = False
self._param_component = MonoDeviceComponent(self, MOD_BANK_DICT, MOD_TYPES)
self._param_component._device = self.device
self.register_addresses()
#self._device_listener.subject = device.canonical_parent
self._parent._task_group.add(sequence(delay(2), self.connect))
def connect(self, *a):
#self._device_listener.subject = self.device.canonical_parent
#self._device_parent.add_devices_listener(self._device_listener)
#self._parent._host.schedule_message(5, update_handlers())
if self._device_parent.devices_has_listener(self._device_listener):
self._device_parent.remove_devices_listener(self._device_listener)
self._device_parent.add_devices_listener(self._device_listener)
self._parent._task_group.add(sequence(delay(5), self._parent.update_handlers))
def register_addresses(self):
for handler in self._parent._handlers:
handler._register_addresses(self)
self.send('register_handler', handler.name)
def addresses(self):
return self._addresses
def translations(self):
return self._translations
def active_handlers(self):
return self._active_handlers
def receive(self, address_name, method = 'value', values = 0, *a, **k):
if address_name in self._addresses.keys():
address = self._addresses[address_name]
value_list = unpack_items(values)
#debug('address: ' + str(address) + ' value_list: ' + str(value_list))
try:
getattr(address, method)(*value_list)
except:
debug('receive method exception', address_name, method, values)
def distribute(self, function_name, values = 0, *a, **k):
if hasattr(self, function_name):
value_list = unpack_items(values)
#debug('distribute: ' + str(function_name) + ' ' + str(values) + ' ' + str(value_list))
try:
getattr(self, function_name)(*value_list)
except:
debug('distribute method exception', function_name, value_list)
def receive_translation(self, translation_name, method = 'value', *values):
#value_list = unpack_items(values)
#debug('receive_translation: ' + str(translation_name) + ' ' + str(method) + ' ' + str(values))
try:
self._translations[translation_name].receive(method, *values)
except:
debug('receive_translation method exception', translation_name, method, values)
def trans(self, translation_name, method = 'value', *values):
#value_list = unpack_items(values)
#debug('receive_translation: ' + str(translation_name) + 'is avail: ' + str(translation_name in self._translations.keys()) + ' ' + str(method) + ' ' + str(values))# + ' ' + str(value_list))
try:
self._translations[translation_name].receive(method, *values)
except:
debug('receive_translation method exception', translation_name, method, values)
def send(self, control_name, *a):
#with self._parent._host.component_guard():
self.notify_value(control_name, *a)
def is_active(self):
return (len(self._active_host) > 0)
def set_enabled(self, val):
self._enabled = val!=0
def reset(self):
pass
def restore(self):
for address_name, address in self._addresses.iteritems():
address.restore()
self._param_component.update()
#@subject_slot('devices')
def _device_listener(self, *a, **k):
debug('device listener....')
if self.device == None:
self._disconnect_client()
def _disconnect_client(self, reconnect = False):
#self._device_listener.subject = None
self.device = None
self.send('disconnect')
for handler in self.active_handlers():
handler.select_mod(None)
self._parent.remove_mod(self)
self.disconnect()
def disconnect(self):
self._active_handlers = []
if self._device_parent.devices_has_listener(self._device_listener):
self._device_parent.remove_devices_listener(self._device_listener)
super(ModClient, self).disconnect()
def linked_device(self):
return self.device
def script_wants_forwarding(self):
return True
def add_translation(self, name, target, group=None, *args, **k):
#debug('name: ' + str(name) + ' target: ' + str(target) + ' args: ' + str(args))
if target in self._addresses.keys():
if not name in self._translations.keys():
self._translations[name] = ElementTranslation(name, self)
#debug('adding new target')
self._translations[name].add_target(target, self._addresses[target], *args)
if not group is None:
if not group in self._translation_groups.keys():
self._translation_groups[group] = []
self._translation_groups[group].append([name, target])
#debug('added to group ' + str(group) + ' : ' + str(self._translation_groups[group]))
def enable_translation(self, name, target, enabled = True):
if name in self._translations.keys():
self._translations[name].set_enabled(target, enabled)
def enable_translation_group(self, group, enabled = True):
if group in self._translation_groups.keys():
for pair in self._translation_groups[group]:
#debug('enabling for ' + str(pair))
self.enable_translation(pair[0], pair[1], enabled)
def receive_device(self, command, *args):
#debug('receive_device ' + str(command) +str(args))
try:
getattr(self._param_component, command)(*args)
except:
debug('receive_device exception: %(c)s %(a)s' % {'c':command, 'a':args})
def update_device(self):
for handler in self.active_handlers():
handler.update_device()
def set_legacy(self, value):
#debug('set_legacy: ' + str(value))
self.legacy = value > 0
for handler in self.active_handlers():
handler.update()
def select_device_from_key(self, key):
key = str(key)
preset = None
for track in self._parent.song().tracks:
for device in enumerate_track_device(track):
if(match(key, str(device.name)) != None):
preset = device
break
for return_track in self._parent.song().return_tracks:
for device in enumerate_track_device(return_track):
if(match(key, str(device.name)) != None):
preset = device
break
for device in enumerate_track_device(self._parent.song().master_track):
if(match(key, str(device.name)) != None):
preset = device
break
if preset != None:
self._parent.song().view.select_device(preset)
def fill_color_map(self, color_type = None, *color_map):
#debug('fill color map: ' + str(color_type) + ' ' + str(color_map))
if not color_type is None:
self._color_maps[color_type] = [color_map[index%(len(color_map))] for index in range(128)]
self._color_maps[color_type][0:0] = [0]
for handler in self.active_handlers():
if handler._color_type is color_type:
handler._colors = self._color_maps[color_type]
handler.update()
def set_color_map(self, color_type, *color_map):
#debug('set color map: ' + str(color_type) + ' ' + str(color_map))
if color_type:
for index in xrange(color_map):
self._color_maps[color_type][index] = color_map[index]
for handler in self.active_handlers():
if handler._color_type is color_type:
handler._colors = self._color_maps[color_type]
handler.update()
class ModClient(NotifyingControlElement):
__subject_events__ = (SubjectEvent(name='value',
signal=InputSignal,
override=True), )
_input_signal_listener_count = 0
def __init__(self, parent, device, name, *a, **k):
super(ModClient, self).__init__(*a, **k)
self.name = name
self.device = device
self._device_parent = None
self._parent = parent
self.log_message = parent.log_message
self._active_handlers = []
#self._addresses = {'grid':Grid(self.active_handlers, 'grid', 16, 16)}
self._addresses = {}
self._translations = {}
self._translation_groups = {}
self._color_maps = {}
self.legacy = False
for handler in self._parent._handlers:
handler._register_addresses(self)
self._param_component = MonoDeviceComponent(self, MOD_BANK_DICT,
MOD_TYPES)
def addresses(self):
return self._addresses
def translations(self):
return self._translations
def active_handlers(self):
return self._active_handlers
def receive(self, address_name, method='value', values=0, *a, **k):
if address_name in self._addresses.keys():
address = self._addresses[address_name]
value_list = unpack_items(values)
#self.log_message('address: ' + str(address) + ' value_list: ' + str(value_list))
try:
#with self._parent._host.component_guard():
getattr(address, method)(*value_list)
except:
if debug():
self.log_message(
'receive method exception %(a)s %(m)s %(vl)s' % {
'a': address_name,
'm': method,
'vl': values
})
def distribute(self, function_name, values=0, *a, **k):
if hasattr(self, function_name):
value_list = unpack_items(values)
#self.log_message('distribute: ' + str(function_name) + ' ' + str(values) + ' ' + str(value_list))
try:
getattr(self, function_name)(*value_list)
except:
if debug():
self.log_message(
'distribute method exception %(fn)s %(vl)s' % {
'fn': function_name,
'vl': value_list
})
def receive_translation(self, translation_name, method='value', *values):
#value_list = unpack_items(values)
#self.log_message('receive_translation: ' + str(translation_name) + ' ' + str(method) + ' ' + str(values))
try:
self._translations[translation_name].receive(method, *values)
except:
if debug():
self.log_message(
'receive_translation method exception %(n)s %(m)s %(vl)s' %
{
'n': translation_name,
'm': method,
'vl': values
})
def trans(self, translation_name, method='value', *values):
#value_list = unpack_items(values)
#self.log_message('receive_translation: ' + str(translation_name) + 'is avail: ' + str(translation_name in self._translations.keys()) + ' ' + str(method) + ' ' + str(values))# + ' ' + str(value_list))
try:
self._translations[translation_name].receive(method, *values)
except:
if debug():
self.log_message(
'receive_translation method exception %(n)s %(m)s %(vl)s' %
{
'n': translation_name,
'm': method,
'vl': values
})
def send(self, control_name, *a):
#with self._parent._host.component_guard():
self.notify_value(control_name, *a)
def is_active(self):
return (len(self._active_host) > 0)
def set_enabled(self, val):
self._enabled = val != 0
def is_connected(self):
return self._connected
def disconnect(self):
self._active_handler = []
if self._device_parent != None:
if self._device_parent.devices_has_listener(self._device_listener):
self._device_parent.remove_devices_listener(
self._device_listener)
super(ModClient, self).disconnect()
self._enabled = True
def reset(self):
pass
def restore(self):
for address_name, address in self._addresses.iteritems():
address.restore()
self._param_component.update()
def _connect_to(self, device):
self._connected = True
self.device = device
if self._device_parent != None:
if self._device_parent.devices_has_listener(self._device_listener):
self._device_parent.remove_devices_listener(
self._device_listener)
self._device_parent = device.canonical_parent
if not self._device_parent.devices_has_listener(self._device_listener):
self._device_parent.add_devices_listener(self._device_listener)
for handler in self._active_handler:
handler.update()
def _disconnect_client(self, reconnect=False):
if self._device_parent != None:
if self._device_parent.devices_has_listener(self._device_listener):
self._device_parent.remove_devices_listener(
self._device_listener)
self._connected = False
self.device = None
for handler in self._active_handler:
handler.set_mod(None)
def _device_listener(self):
if self.device == None:
self._disconnect_client()
def linked_device(self):
return self.device
def script_wants_forwarding(self):
return True
def add_translation(self, name, target, group=None, *args, **k):
#self.log_message('name: ' + str(name) + ' target: ' + str(target) + ' args: ' + str(args))
if target in self._addresses.keys():
if not name in self._translations.keys():
self._translations[name] = ElementTranslation(name, self)
#self.log_message('adding new target')
self._translations[name].add_target(target,
self._addresses[target], *args)
if not group is None:
if not group in self._translation_groups.keys():
self._translation_groups[group] = []
self._translation_groups[group].append([name, target])
#self.log_message('added to group ' + str(group) + ' : ' + str(self._translation_groups[group]))
def enable_translation(self, name, target, enabled=True):
if name in self._translations.keys():
self._translations[name].set_enabled(target, enabled)
def enable_translation_group(self, group, enabled=True):
if group in self._translation_groups.keys():
for pair in self._translation_groups[group]:
#self.log_message('enabling for ' + str(pair))
self.enable_translation(pair[0], pair[1], enabled)
def receive_device(self, command, *args):
#self.log_message('receive_device ' + str(command) +str(args))
try:
getattr(self._param_component, command)(*args)
except:
self.log_message('receive_device exception: %(c)s %(a)s' % {
'c': command,
'a': args
})
def update_device(self):
for handler in self.active_handlers():
handler.update_device()
def set_legacy(self, value):
#self.log_message('set_legacy: ' + str(value))
self.legacy = value > 0
def select_device_from_key(self, key):
key = str(key)
preset = None
for track in self._parent.song().tracks:
for device in enumerate_track_device(track):
if (match(key, str(device.name)) != None):
preset = device
break
for return_track in self._parent.song().return_tracks:
for device in enumerate_track_device(return_track):
if (match(key, str(device.name)) != None):
preset = device
break
for device in enumerate_track_device(self._parent.song().master_track):
if (match(key, str(device.name)) != None):
preset = device
break
if preset != None:
self._parent.song().view.select_device(preset)
def set_color_map(self, color_type, color_map):
#new_map = color_map.split('*')
#for index in xrange(len(new_map)):
# new_map[index] = int(new_map[index])
#self._color_maps[color_type] = new_map
pass
