# uncompyle6 version 3.9.3 # Python bytecode version base 2.6 (62161) # Decompiled from: Python 3.9.25 (main, Oct 31 2025, 23:16:49) # [GCC 14.2.0] # Embedded file name: control_panel.pyc # Compiled at: 2025-05-23 10:32:32 if __name__ == '__main__': import main main.run() import mytime, os.path, ConfigParser, one_unit, math, wx, sys, svg_panel, diagram, data_model, protocol, copy, dialog, traceback, threading, future, string, server, inspect def getString(strID): return one_unit.getString(strID) def rreplace(s, old, new, occurrence=1): li = s.rsplit(old, occurrence) return new.join(li) fixed_vars_list = {'ip_address': 'self.parent.active_unit.IP', 'mac_address': 'self.parent.active_unit.MAC', 'serial_number': 'self.parent.active_unit.Serial', 'firmware_version': 'self.parent.active_unit.FWVersion', 'software_version': 'one_unit.app.Version'} constant_vars_list = {'confTwoWay': (protocol.confTwoWay), 'confAllModes': (protocol.confAllModes), 'confAESBackup': (protocol.confAESBackup), 'confStandby': (protocol.confStandby)} illegal_chars = ('/', '\\') class Control_panel(svg_panel.SVG_Panel): def __init__(self, parent, id=-1, pos=(-1, -1), size=(-1, -1), style=0, name='svg_panel', config=None): self.parent = parent self.current_channel = None self.selected_channel = None self.config = config self.pos = pos self.last_panel = None self.timerExecuting = False self.style = style self.font_size = 14 self.size = size self.needRefreshAfterSync = True self.update_key = None self.peq_type_changed = False self.full_screen_diagram = False self.remote_link = parent.remote_link self.name = name svg_doc_name = config.get(name, 'svg_file') self.image_replace_list = one_unit.app.image_replace_list try: self.image_replace_list = eval(config.get('DEFAULT', 'image_replace_list')) except: pass svg_doc_name = os.path.join(parent.next_skin_path, svg_doc_name) svg_panel.SVG_Panel.__init__(self, parent, id, pos, size, style, name, svg_doc_name) self.svg_doc_name = svg_doc_name self.thread = threading.Thread(name='AllDSP Unit Panel', target=self.process) self.lock = threading.Lock() self.start() return def OnGetFocus(self, e): print mytime.displayTime(), 'cp.Got focus' self.clickTime = mytime.clock() return def start(self): self.thread.start() return def process(self): self.SetBackgroundColour((0, 0, 0)) style = self.style parent = self.parent pos = self.pos self.updates = 0 size = self.size name = self.name config = self.config self.GL = parent.GL self.editing_diagram = False self.config = config self.name = name cursor = wx.StockCursor(wx.CURSOR_ARROW) self.cursor_type = 'arrow' self.SetCursor(cursor) self.last_cursor = cursor self.index = 0 return def init_1(self): config = self.config parent = self.parent name = self.name self.csbutton = name self.last_loaded_preset_no = None self.last_loaded_preset_time = mytime.clock() - 5 self.controls = {} self.skipping_timer = 0 self.control_types = {} self.supported_units = parent.supported_units try: controls = config.get(name, 'controls') controls = [_[1] for s in controls.split(',')] except: controls = [] print mytime.clock(), 'No controls found in config, trying to resolve...' for id in self.svg_doc.active_elements: if id[:4] not in ('imag', 'rect', 'name', 'meta', 'defs', 'svg1', 'svg2', 'svg3', 'svg4', 'text', 'path', 'logo'): tmpid = id if self.svg_doc.get_bb(id) == None: continue if tmpid[-3:] in ('max', 'min', '_bg'): continue for appendix in ('_off', '_on', '_over'): tmpid2 = rreplace(tmpid, appendix, '') if tmpid2 != tmpid: tmpid = tmpid2 break if tmpid not in controls: controls.append(tmpid) controls.append('cs_button') self.wink_time = 0 self.gr_style = 'continuous' self.vu_style = 'continuous' self.vu_led_shape = 'square' self.vu_led_size = 3 self.vu_led_spacing = 5 self.gr_led_size = 3 self.gr_led_spacing = 5 self.vu_bg_colour = 'BLACK' self.waitToCreateProgressBarTime = 0 self.vu_in_led_values = None self.vu_out_led_values = None self.gr_led_values = None self.preset_names = {} self.vu_in_yellow = 0 self.vu_in_red = 6 self.block_once = False self.block_once_time = 0 self.vu_out_yellow = 0 self.vu_pwr_yellow = 10 self.vu_pwr_red = 20 self.vu_out_red = 6 self.gr_yellow = 0 self.noProgressWindow = False self.custom_write_protected_dialog = None self.gr_red = 6 self.vu_grey_on_mute = 'yes' self.gauges = {} self.string_support = False self.ctrl_keys = {} self.fixed_render = {} self.blink_timer = 0 self.update_all_controls_counter = 8 self.blink_value = 0 self.delay_unit = 'ms' self.autoScaleDelay = False self.fir_taps_from_file = None self.have_lpf = False self.have_hpf = False self.run_test = False self.repaint = False self.repaint_time = 0 self.last_repaint_time = 0 self.test_counter = 0 self.show_sync = False self.progress = None self.skin_approved = False self.select_rendering_by_channel = {} self.cursor_type = 'arrow' self.mouse_down = False self.bitmapdir = os.path.normpath(one_unit.app.cwd + '/bitmaps/') self.test_phase = 0 self.model_number_string = '' self.custom_access_key = {} self.invert_custom_access_key = {} self.visibility_key = {} self.visibility_mask = {} self.visibility_value = {} self.visibility_invert = {} self.customElementKeys = {} self.channelFlagMask = {} self.channelFlagShow = {} self.readChannelFlagMask() self.readCustomElementKeys() try: self.font_size = float(config.get(self.name, 'font_size')) except: pass try: self.auto_type_choice = eval(config.get(self.name, 'auto_type_choice')) except: self.auto_type_choice = False try: values = config.get('DEFAULT', 'vu_in_led_values') try: values = [_[2] for s in values.split(',')] except: dial = wx.MessageDialog(None, 'VU IN LED values list syntax error', 'Error', wx.OK | wx.ICON_ERROR) dial.ShowModal() self.vu_in_led_values = [] for i in range(len(values)): self.vu_in_led_values.append(values[i]) except: pass try: values = config.get('DEFAULT', 'vu_out_led_values') try: values = [_[3] for s in values.split(',')] except: dial = wx.MessageDialog(None, 'VU OUT LED values list syntax error', 'Error', wx.OK | wx.ICON_ERROR) dial.ShowModal() self.vu_out_led_values = [] for i in range(len(values)): self.vu_out_led_values.append(values[i]) except: pass try: values = config.get('DEFAULT', 'gr_led_values') try: values = [_[4] for s in values.split(',')] except: traceback.print_exc(file=sys.stdout) dial = wx.MessageDialog(None, 'GR LED values list syntax error', 'Error', wx.OK | wx.ICON_ERROR) dial.ShowModal() self.gr_led_values = [] for i in range(len(values)): self.gr_led_values.append(values[i]) except: pass try: self.peq_max_freq = float(config.get(self.name, 'peq_max_freq')) except: self.peq_max_freq = 20000.0 print self.peq_max_freq self.enableContextMenu = self.parent.getFromConfig('enableContextMenu', True) try: self.vu_style = config.get('DEFAULT', 'vu_style') except: pass try: self.vu_in_yellow = config.get('DEFAULT', 'vu_in_yellow') except: pass try: self.vu_in_red = config.get('DEFAULT', 'vu_in_red') except: pass try: self.vu_out_yellow = config.get('DEFAULT', 'vu_out_yellow') except: pass try: self.vu_out_red = config.get('DEFAULT', 'vu_out_red') except: pass try: self.vu_pwr_yellow = config.get('DEFAULT', 'vu_pwr_yellow') except: pass try: self.vu_pwr_red = config.get('DEFAULT', 'vu_pwr_red') except: pass try: self.gr_yellow = config.get('DEFAULT', 'gr_yellow') except: pass try: self.gr_red = config.get('DEFAULT', 'gr_red') except: pass try: self.vu_led_shape = config.get('DEFAULT', 'vu_led_shape') except: pass try: self.gr_led_shape = config.get('DEFAULT', 'gr_led_shape') except: self.gr_led_shape = 'square' try: self.vu_led_size = config.get('DEFAULT', 'vu_led_size') except: pass try: self.vu_led_spacing = config.get('DEFAULT', 'vu_led_spacing') except: pass try: self.gr_led_size = config.get('DEFAULT', 'gr_led_size') except: self.gr_led_size = self.vu_led_size try: self.gr_led_spacing = config.get('DEFAULT', 'gr_led_spacing') except: self.gr_led_spacing = self.vu_led_spacing try: self.vu_bg_colour = eval(config.get('DEFAULT', 'vu_bg_colour')) except: pass self.custom_colours = True self.default_text_colour = (80, 80, 80) try: self.default_text_colour = eval(config.get('DEFAULT', 'default_text_colour')) except: pass try: self.custom_write_protected_dialog = self.parent.main_config.get('ROOT', 'custom_write_protected_dialog') except: pass try: self.default_text_colour = eval(config.get(self.name, 'default_text_colour')) except: pass self.font_sizes = {} self.font_colours = {} self.show_Q_unit = False try: if config.get(name, 'show_Q_unit') == 'True': self.show_Q_unit = True except: pass self.suppress_knob_updates = True try: if config.get('DEFAULT', 'suppress_knob_updates') == 'False': self.suppress_knob_updates = False except: pass try: self.keepUserPresetName = eval(config.get('DEFAULT', 'keep_user_preset_name')) except: self.keepUserPresetName = False try: self.include_delay_unit = eval(config.get(name, 'include_delay_unit')) except: self.include_delay_unit = False self.svg_doc.compute_bb(controls) for ctrl_name in controls: if ctrl_name == '': continue if ctrl_name == 'cs_button': try: self.csbutton = config.get(name, ctrl_name + '_value') except: pass else: continue try: self.font_colours[ctrl_name] = config.get(name, ctrl_name + '_colour') except: try: self.font_colours[ctrl_name] = config.get(name, ctrl_name + '_text_colour') except: pass try: self.font_sizes[ctrl_name] = config.get(name, ctrl_name + '_font_size') except: pass try: var_name = config.get(name, ctrl_name + '_value') except ConfigParser.NoOptionError: try: var_name = config.get(name, ctrl_name + '_values') except ConfigParser.NoOptionError: var_name = ctrl_name.replace('_text', '') var_name = var_name.replace('_slider', '') var_name = var_name.replace('_knob', '') var_name = var_name.replace('_choice', '') var_name = var_name.replace('_label', '') if self.auto_type_choice: var_name = var_name.replace('_type', '') try: struct_id = config.getint(var_name, 'struct_id') config.set(name, ctrl_name + '_value', var_name) except: pass try: struct_id = config.getint(var_name, 'struct_id') if struct_id == protocol.STRUCT_ID_MIXER: num = config.getint(var_name, 'num') if num not in self.parent.unit_channels: print mytime.displayTime() + ' cp.init: skipping var for unused index', var_name continue except: pass try: channel = int(config.get(var_name, 'channel'), 0) if channel not in self.parent.unit_channels and struct_id >= 0: print mytime.displayTime() + ' cp.init: skipping var for unused channel', var_name, channel, self.parent.unit_channels continue except: pass try: ctrl = self.control_factory(name, ctrl_name) except: ctrl = None if ctrl is not None: try: var = config.get(name, ctrl_name + '_visibility_var') struct_id = config.getint(var, 'struct_id') member_id = config.getint(var, 'member_id') num = config.getint(var, 'num') try: channel = int(config.get(var, 'channel'), 0) except ConfigParser.NoOptionError: try: channel = self.current_channel except: channel = -1 key = data_model.Key(struct_id, member_id, channel, num) self.visibility_mask[ctrl_name] = config.get(name, ctrl_name + '_visibility_mask') try: self.visibility_mask[ctrl_name] = eval(self.visibility_mask[ctrl_name]) except: try: self.visibility_mask[ctrl_name] = eval('protocol.' + self.visibility_mask[ctrl_name]) except: pass try: self.visibility_invert[ctrl_name] = eval(config.get(name, ctrl_name + '_visibility_invert')) except: self.visibility_invert[ctrl_name] = False self.visibility_value[ctrl_name] = config.get(name, ctrl_name + '_visibility_value') try: self.visibility_value[ctrl_name] = eval(self.visibility_value[ctrl_name]) except: try: self.visibility_value[ctrl_name] = eval('protocol.' + self.visibility_value[ctrl_name]) except: pass self.visibility_key[ctrl_name] = key except: pass else: try: self.custom_access_key[ctrl_name] = int(config.get(name, ctrl_name + '_custom_access_key'), 0) except: pass else: try: self.invert_custom_access_key[ctrl_name] = eval(config.get(name, ctrl_name + '_invert_custom_access_key')) except: pass else: try: var_name = config.get(name, ctrl_name + '_value') except ConfigParser.NoOptionError: try: var_name = config.get(name, ctrl_name + '_values') except ConfigParser.NoOptionError: self.controls[ctrl_name] = ( ctrl, None, None) if ctrl_name.startswith('cs_') == False and ctrl_name not in ('link_status', 'delay_unit', 'preset_load', 'preset_store', 'available_units'): print mytime.displayTime() + ' cp.No variable specified for', ctrl_name else: try: var_name = config.get(name, ctrl_name + '_value') except ConfigParser.NoOptionError: try: var_name = config.get(name, ctrl_name + '_values') except ConfigParser.NoOptionError: self.controls[ctrl_name] = ( ctrl, None, None) continue else: var_names = [_[5] for s in var_name.split(',')] keys = {} for var in var_names[:]: struct_id = config.getint(var, 'struct_id') member_id = config.getint(var, 'member_id') try: default_val = config.getint(var, 'default') except: default_val = None num = config.getint(var, 'num') try: channel = int(config.get(var, 'channel'), 0) if channel not in self.parent.unit_channels: var_names.remove(var) continue except ConfigParser.NoOptionError: try: channel = self.current_channel except: channel = -1 key = data_model.Key(struct_id, member_id, channel, num) if channel > 0: self.parent.model.set_default(key, default_val) try: self.ctrl_keys[key].append(ctrl_name) except KeyError: self.ctrl_keys[key] = [] self.ctrl_keys[key].append(ctrl_name) except: traceback.print_exc(file=sys.stdout) self.controls[ctrl_name] = ( ctrl, key, var_names) continue else: struct_id = 0 member_id = 0 num = 0 channel = None try: struct_id = config.getint(var_name, 'struct_id') member_id = config.getint(var_name, 'member_id') num = config.getint(var_name, 'num') try: ctrl.variable_num = eval(config.get(var_name, 'variable_num')) print ctrl.name, 'set to variable indexing' except: ctrl.variable_num = False except: if var_name in fixed_vars_list.keys(): struct_id = protocol.STRUCT_ID_INTERNAL else: try: varNumber = int(var_name) except: varNumber = None else: if var_name in constant_vars_list.keys() or str(varNumber) == var_name: lookupkey = config.get(name, ctrl_name + '_key') struct_id = config.getint(lookupkey, 'struct_id') member_id = config.getint(lookupkey, 'member_id') num = config.getint(lookupkey, 'num') channel = config.getint(lookupkey, 'channel') try: mask = config.get(name, ctrl_name + '_mask') try: mask = int(mask) except: mask = constant_vars_list[mask] ctrl.mask = int(mask) try: mask = int(var_name) except: mask = constant_vars_list[var_name] ctrl.mask_val = int(mask) try: ctrl.radio = eval(config.get(name, ctrl_name + '_radio_button')) except: ctrl.radio = False except: print mytime.displayTime(), 'cp.i.Failed to convert mask for', ctrl_name traceback.print_exc(file=sys.stdout) else: print mytime.displayTime() + ' var_name:', var_name, 'struct_ID:', struct_id, 'member_id: ', member_id, 'num:', num, 'not found or corrupted' else: if channel == None: try: channel = int(config.get(var_name, 'channel'), 0) if channel not in self.parent.unit_channels and struct_id >= 0: print mytime.displayTime(), 'cp.i1.Skipping', ctrl_name, ' for unused channel' continue except ConfigParser.NoOptionError: channel = -1 except: if var_name in fixed_vars_list.keys(): channel = 0 channel = 0 key = data_model.Key(struct_id, member_id, channel, num) if key.struct_id == protocol.STRUCT_ID_HPF: self.have_hpf = True if key.struct_id == protocol.STRUCT_ID_LPF: self.have_lpf = True self.controls[ctrl_name] = ( ctrl, key, var_name) try: self.fixed_render[ctrl_name] = eval(config.get(name, ctrl_name + '_fixed_render')) except: pass else: try: self.ctrl_keys[key].append(ctrl_name) except KeyError: self.ctrl_keys[key] = [] self.ctrl_keys[key].append(ctrl_name) except: traceback.print_exc(file=sys.stdout) else: if hasattr(ctrl, 'set_off_value') and callable(ctrl.set_off_value): ctrl.key = key if hasattr(ctrl, 'set_limits') and callable(ctrl.set_limits): try: min_val = config.getfloat(var_name, 'min_value') max_val = config.getfloat(var_name, 'max_value') ctrl.set_limits(min_val, max_val) except: pass if hasattr(ctrl, 'set_default') and callable(ctrl.set_default): try: default = config.getfloat(var_name, 'default_value') except: default = None else: ctrl.set_default(default) if hasattr(ctrl, 'set_off_value') and callable(ctrl.set_off_value): try: off_value = config.getfloat(var_name, 'off_value') ctrl.set_off_value(off_value) except: pass else: try: off_text = config.get(var_name, 'off_text') ctrl.set_off_text(off_text) except: pass if hasattr(ctrl, 'set_max_value') and callable(ctrl.set_max_value): try: max_text = config.get(var_name, 'max_text') ctrl.set_max_text(max_text) max_value = config.getfloat(var_name, 'max_value') ctrl.set_max_value(max_value) print mytime.displayTime(), 'set max for', var_name except: pass try: render_channels = config.get(var_name, 'render_channels') self.select_rendering_by_channel[key] = eval(render_channels) print mytime.displayTime() + ' Selective rendering:', self.select_rendering_by_channel[key], key except: pass else: try: max_current = config.getfloat(name, ctrl_name + '_max_current') ctrl.max_current = max_current print mytime.displayTime(), 'cp.i.Set max current for', ctrl_name, 'to', max_current except: ctrl.max_current = 10000 else: try: self.custom_access_key[key] = int(config.get(var_name, 'custom_access_key'), 0) except: pass else: try: self.invert_custom_access_key[key] = eval(config.get(var_name, 'invert_custom_access_key')) print mytime.displayTime() + ' Inverted custom access key', key except: self.invert_custom_access_key[key] = False else: try: self.custom_access_key[key] = int(config.get(name, ctrl_name + '_custom_access_key'), 0) except: pass else: try: self.invert_custom_access_key[key] = eval(config.get(name, ctrl_name + '_invert_custom_access_key')) except: pass names = [] for (ctrl, key, var_name) in self.controls.values(): names.extend(ctrl.get_svg_labels()) self.svg_doc.compute_bb(names) for (ctrl, key, var_name) in self.controls.values(): labels = ctrl.get_svg_labels() for label in labels: if not self.svg_doc.bb_cache.has_key(label): self.svg_doc.bb_cache[label] = None names = [] for (ctrl, key, var_name) in self.controls.values(): labels = ctrl.get_svg_labels() for label in labels: if not self.svg_doc.bb_cache.has_key(label): names.extend(label) self.svg_doc.compute_bb(names) self.timer = wx.Timer(self) self.Bind(wx.EVT_TIMER, self.on_timer, self.timer) self.mousetimer = wx.Timer(self) self.Bind(wx.EVT_TIMER, self.on_mousetimer, self.mousetimer) self.test_timer = wx.Timer(self) self.Bind(wx.EVT_TIMER, self.on_test_timer, self.test_timer) self.load_time = mytime.clock() self.total_vars = 10000 try: self.redirect = self.parent.config.get(self.name, 'redirect') self.redirect_var = self.parent.config.get(self.name, 'redirect_var') self.redirect_mask = int(self.parent.config.get(self.name, 'redirect_mask'), 16) self.redirect_val = int(self.parent.config.get(self.name, 'redirect_val'), 16) except: self.redirect = None self.active_cs_button = None self.active_index_button = None self.updateControlLimits() return def refreshUnits(self): for ctrl_name in self.controls: (ctrl, key, var_name) = self.controls[ctrl_name] if key == None: continue if key.member_id == protocol.MEMBER_ID_THRESHOLD: ctrl.set_value(ctrl.get_value()) return def readCustomElementKeys(self): self.elementConfig = ConfigParser.ConfigParser() self.defaultElementConfigFile = os.path.join(self.parent.next_skin_path, 'elementKeys.cfg') if os.path.exists(self.defaultElementConfigFile): try: self.elementConfig.read(self.defaultElementConfigFile) except: traceback.print_exc(file=sys.stdout) self.userElementConfigFile = os.path.join(one_unit.app.asys_config_path, self.parent.GL.loaded_skin + '_elementKeys.cfg') if os.path.exists(self.userElementConfigFile): try: self.elementConfig.read(self.userElementConfigFile) except: traceback.print_exc(file=sys.stdout) print mytime.displayTime(), 'cp.element config sections:', self.elementConfig.sections() for section in self.elementConfig.sections(): try: view = section[:section.find('|')] print mytime.displayTime(), 'cu.ek.view:', view if view != self.name: continue rest = section[section.find('|') + 1:] channel = eval(rest[:rest.find('|')]) sectionRef = section if channel == -1: channel = None sectionRef = section.replace('-1', 'None') print mytime.displayTime(), 'cu.ek.channel', channel, self.current_channel if channel != self.current_channel: continue controlName = rest[rest.find('|') + 1:] print mytime.displayTime(), 'cu.ek.control name:', controlName Key = data_model.Key self.customElementKeys[sectionRef] = eval(self.elementConfig.get(section, 'customElementKeys')) print mytime.displayTime(), 'Found custom customElementKeys for', sectionRef, self.customElementKeys[sectionRef] except ConfigParser.NoOptionError: pass except: print mytime.displayTime(), 'cp.Error decoding custom element key for section', section traceback.print_exc(file=sys.stdout) print mytime.displayTime(), 'cp.customElementKeys:', self.customElementKeys return def readChannelFlagMask(self): self.channelFlagMaskConfig = ConfigParser.ConfigParser() self.defaultChannelFlagMaskConfigFile = os.path.join(self.parent.next_skin_path, 'channelFlagMask.cfg') if os.path.exists(self.defaultChannelFlagMaskConfigFile): try: self.channelFlagMaskConfig.read(self.defaultChannelFlagMaskConfigFile) except: traceback.print_exc(file=sys.stdout) self.userChannelFlagMaskConfigFile = os.path.join(one_unit.app.asys_config_path, self.parent.GL.loaded_skin + '_channelFlagMask.cfg') if os.path.exists(self.userChannelFlagMaskConfigFile): try: self.channelFlagMaskConfig.read(self.userChannelFlagMaskConfigFile) except: traceback.print_exc(file=sys.stdout) for section in self.channelFlagMaskConfig.sections(): try: view = section[:section.find('|')] if view.lower() == 'any': view = self.name if view != self.name: continue rest = section[section.find('|') + 1:] channel = eval(rest[:rest.find('|')]) if channel == -1: channel = None if self.current_channel != None and self.current_channel >= 0 and channel == None: channel = self.current_channel if channel != self.current_channel: continue controlName = rest[rest.find('|') + 1:] except: print mytime.displayTime(), 'cp.Error building channelflag controlName for section', section traceback.print_exc(file=sys.stdout) try: mask = eval(self.channelFlagMaskConfig.get(section, 'channelFlagMask')) for s in ('_off', '_on', '_over', '_bg', '_max', '_min', '', '_slider', '_knob'): self.channelFlagMask[controlName + s] = mask except ConfigParser.NoOptionError: pass except: print mytime.displayTime(), 'cp.Error decoding channelflag mask for section', section traceback.print_exc(file=sys.stdout) try: show = self.channelFlagMaskConfig.get(section, 'channelFlagShow') try: show = eval(show) except: pass for s in ('_off', '_on', '_over', '_bg', '_max', '_min', '', '_slider', '_knob'): self.channelFlagShow[controlName + s] = show except ConfigParser.NoOptionError: pass except: print mytime.displayTime(), 'cp.Error decoding channelflag show for section', section traceback.print_exc(file=sys.stdout) return def Refresh(self): svg_panel.SVG_Panel.Refresh(self) return def has_lpf(self): return self.have_lpf def has_hpf(self): return self.have_hpf def updateControlLimits(self, channel=None): if channel != None and self.current_channel != -1 and self.current_channel != channel: return else: for ctrl_name in self.controls: (ctrl, key, var_name) = self.controls[ctrl_name] if key == None: continue if hasattr(ctrl, 'set_limits') and callable(ctrl.set_limits): try: key = self.key_with_current_channel(key) if key.member_id == protocol.MEMBER_ID_THRESHOLD and key.channel in self.parent.thresholdCorrection: min_val = self.parent.model.get_min(key) max_val = self.parent.model.get_max(key) if min_val != None and max_val != None and (min_val != ctrl.lower_limit or max_val != ctrl.higher_limit): ctrl.set_limits(min_val, max_val) if self.parent.model.completion() == 100: try: val = self.parent.model.get(key) if val == None: print mytime.displayTime(), 'cp.ucl.got None val for key', key, val, min_val, max_val elif val > max_val: print mytime.displayTime(), 'cp.ucl.clipping max val for key', key, val, min_val, max_val val = max_val self.set_value(key, val) if val < min_val: print mytime.displayTime(), 'cp.ucl.clipping min for key', key, val, min_val, max_val val = min_val self.set_value(key, val) except: print mytime.displayTime(), 'cp.ucl.failed to clip val for key', key, val, min_val, max_val traceback.print_exc(file=sys.stdout) self.update_control(ctrl_name, force=True) except: traceback.print_exc(file=sys.stdout) return def saveElementConfig(self): f = open(self.userElementConfigFile, 'wb') self.elementConfig.write(f) f.close() return def saveChannelFlagMaskConfig(self): f = open(self.userChannelFlagMaskConfigFile, 'wb') self.channelFlagMaskConfig.write(f) f.close() return def switch_skin(self, skin=None): if skin is not None and self.parent.switching_skin is False: print mytime.displayTime() + ' cp.sw_sk', skin self.parent.switch_skin(skin) return def select_skin_to_current_user(self): if self.parent.checkRedirect(self.name): return else: if self.parent.updatingFirmware == True: return if self.parent.restartingAfterFirmwareUpdate == True or self.parent.updatingFirmware == True or self.parent.loading_library == True or self.parent.loading_preset == True or self.parent.switching_skin == True or self.parent.init_done == False or self.parent.changing_view == True or one_unit.app.application_stopping == True: return if self.parent.mv_panel == True: return if self.parent.accessGrantedToView(self.name) == False: self.parent.call_set_view = self.parent.views[0] return if self.parent.GL.current_skin == self.parent.default_skin and self.parent.GL.current_skin.lower().find('default') >= 0: return if self.parent.MAC[:4] not in ('DEMO', 'GRPdeactivated', 'VN::'): try: model_number = one_unit.app.server.peers.units[self.parent.MAC].process.conn.model_number if model_number == None: self.model_number_string = self.parent.model_number_string else: self.model_number_string = '_' + str(model_number) except: return else: if self.model_number_string in ('', '_'): return else: self.model_number_string = '' (accessrights, current_user) = self.parent.get_access() if current_user == protocol.uAllDSP and self.parent.MAC[:4] not in ('DEMO', 'GRPdeactivated'): return False if current_user == protocol.uFactory: if self.parent.GL.last_tested_skin != self.parent.active_unit.type + self.model_number_string + '_d': self.parent.switch_skin(self.parent.active_unit.type + self.model_number_string + '_d') return True else: return False if current_user == protocol.uDeveloper or one_unit.app.demo_developer_password[:8] == one_unit.app.check_password and self.parent.MAC[:4] in ('DEMO', 'GRPdeactivated'): if self.parent.GL.last_tested_skin != self.parent.active_unit.type + self.model_number_string + '_d': self.parent.switch_skin(self.parent.active_unit.type + self.model_number_string + '_d') return True else: return False if current_user == protocol.uAdmin or one_unit.app.demo_admin_password[:8] == one_unit.app.check_password and self.parent.MAC[:4] in ('DEMO', 'GRPdeactivated'): if self.parent.GL.last_tested_skin != self.parent.active_unit.type + self.model_number_string + '_a' and (accessrights & protocol.arShowFullSkin == 0 or self.parent.GL.last_tested_skin != self.parent.active_unit.type + self.model_number_string + '_d' or self.parent.MAC[:4] in ('DEMO', 'GRPdeactivated') or self.parent.ignore_arShowFullSkin == True): self.parent.switch_skin(self.parent.active_unit.type + self.model_number_string + '_a') return True else: return False if current_user == protocol.uUser or one_unit.app.demo_user_password[:8] == one_unit.app.check_password and self.parent.MAC[:4] in ('DEMO', 'GRPdeactivated'): if self.parent.GL.last_tested_skin != self.parent.active_unit.type + self.model_number_string + '_u' and (accessrights & protocol.arShowFullSkin == 0 or self.parent.GL.last_tested_skin != self.parent.active_unit.type + self.model_number_string + '_d' or self.parent.MAC[:4] in ('DEMO', 'GRPdeactivated') or self.parent.ignore_arShowFullSkin == True): self.parent.switch_skin(self.parent.active_unit.type + self.model_number_string + '_u') return True else: return False if current_user == protocol.uLocked or one_unit.app.demo_locked_password[:8] == one_unit.app.check_password and self.parent.MAC[:4] in ('DEMO', 'GRPdeactivated'): if self.parent.GL.last_tested_skin != self.parent.active_unit.type + self.model_number_string + '_l' and (accessrights & protocol.arShowFullSkin == 0 or self.parent.GL.last_tested_skin != self.parent.active_unit.type + self.model_number_string + '_d' or self.parent.MAC[:4] in ('DEMO', 'GRPdeactivated') or self.parent.ignore_arShowFullSkin == True): self.parent.switch_skin(self.parent.active_unit.type + self.model_number_string + '_l') return True else: return False if current_user != 0 and (self.parent.GL.last_tested_skin == self.parent.active_unit.type + self.model_number_string + '_f' or self.parent.GL.last_tested_skin == self.parent.active_unit.type + self.model_number_string + '_a' or self.parent.GL.last_tested_skin == self.parent.active_unit.type + self.model_number_string + '_d' or self.parent.GL.last_tested_skin == self.parent.active_unit.type + self.model_number_string + '_u'): self.parent.switch_skin(self.parent.active_unit.type + self.model_number_string) return True return False def SetMinSize(self, size): svg_panel.SVG_Panel.SetMinSize(self, size) for ctrl_name in self.controls.keys(): (ctrl, key, var_name) = self.controls[ctrl_name] rc = self.add_control(ctrl) if rc == -1: del self.controls[ctrl_name] self.update_controls() self.svg_doc.set_element_render_all() try: if self.timer.IsRunning() == False: self.timer.Start(500) if self.mousetimer.IsRunning() == False: self.mousetimer.Start(500) except: return self.virgin = True return def CheckSkin(self): if self.parent.active_unit is not None: current_skin = self.parent.GL.current_skin if current_skin.count('_') > 2: current_skin = current_skin[:-2] if self.parent.active_unit.type + self.model_number_string != current_skin and self.parent.remote_link.Connected == True and self.parent.auto_unit_switch == True: self.switch_skin(self.parent.active_unit.type + self.model_number_string) try: self.Destroy() except: pass return True if self.parent.active_unit.MAC[:4] not in ('DEMO', 'GRPdeactivated') and self.skin_approved == False: self.skin_approved = True elif self.parent.active_unit.MAC[:4] not in ('DEMO', 'GRPdeactivated') and self.skin_approved == False: self.skin_approved = True return False def on_mousetimer(self, evt): if one_unit.app.application_stopping == True: return if self.parent.model.synced() == True and self.parent.model.completion() == 100: if self.cursor_type == 'wait': cursor = wx.StockCursor(wx.CURSOR_ARROW) self.cursor_type = 'arrow' self.SetCursor(cursor) return def check_redirect(self, key): if one_unit.app.application_stopping == True: return else: name = self.parent.model.get_var_name(key) if self.redirect != None and self.redirect_var == name: redirect = self.redirect redirect_mask = self.redirect_mask redirect_val = self.redirect_val try: if int(self.parent.model.get_by_name(self.redirect_var)) & redirect_mask == redirect_val: print mytime.displayTime() + ' cp.Redirect to', redirect self.parent.prepare_set_view(self.redirect) return True except: pass return False def showSynchronizingBar(self): if self.parent.program_title.find('(Locked)') > 0: return else: try: completion = self.parent.model.completion() if completion < 100: self.parent.SetTitle(self.parent.program_title + ' (' + str(completion) + '%)') self.parent.menubar.SetTitle(self.parent.program_title + ' (' + str(completion) + '%)') else: self.parent.SetTitle(self.parent.program_title + ' (synced)') self.parent.menubar.SetTitle(self.parent.program_title + ' (synced)') except: pass return try: if self.IsShownOnScreen() == False: self.waitToCreateProgressBarTime = 0 if self.parent.restartingAfterFirmwareUpdate == False and self.IsShownOnScreen() == True and self.parent.model.completion() < 100 and one_unit.app.bootloader_progress[self.parent.MAC] == None and self.noProgressWindow == False: if self.parent.active_unit is not None and self.remote_link.ResetValues == False and self.parent.changing_view == False and self.parent.auto_progress_disabled == False and self.parent.stopping == False and one_unit.app.application_stopping == False: if self.parent.remote_link.SyncIndicateActive == True and self.show_sync == False and self.skin_approved == True: if self.progress == None: if self.parent.model.completion() < 95: if self.waitToCreateProgressBarTime != 0: if mytime.clock() - self.waitToCreateProgressBarTime > 1: self.progress = one_unit.ProgressScreen(self, -1, 'Progress', 'Synchronizing (' + str(self.parent.model.completion()) + '%)') else: return else: self.waitToCreateProgressBarTime = mytime.clock() if self.progress != None: self.show_sync = True self.progress.Show(True) if self.show_sync == True: completion = self.parent.model.completion() if completion >= 100 or self.parent.remote_link.Connected == False: if self.progress != None: self.progress.Destroy() self.progress = None self.show_sync = False self.parent.remote_link.SyncIndicateActive = False elif self.IsShownOnScreen() == True: if self.progress == None: self.progress = one_unit.ProgressScreen(self, -1, 'Progress', 'Synchronizing (' + str(self.parent.model.completion()) + '%)') if self.progress.IsShown() == False: self.progress.Show(True) if self.progress != None: self.progress.Update(completion) self.progress.SetText('Synchronizing (' + str(completion) + '%)') self.update_all_controls_counter = 15 self.updates = 0 elif self.progress != None: self.progress.Destroy() self.progress = None self.show_sync = False self.progress = None elif self.progress != None: self.progress.Destroy() self.progress = None self.show_sync = False except: pass return def on_timer(self, evt): if self.timerExecuting: return self.timerExecuting = True self.executeTimer() self.timerExecuting = False return def executeTimer(self): if self.full_screen_diagram == True: self.update_controls() return self.showSynchronizingBar() if self.IsShownOnScreen() == False: self.timer.Stop() self.timer.Start(2500) self.skipping_timer = 10 self.refreshAfterSync = True self.repaint = True self.repaint_time = mytime.clock() return if self.ctrl_with_focus == None and mytime.clock() - self.repaint_time < 3 and mytime.clock() - self.last_repaint_time > 1: self.svg_doc.set_element_render_all() self.Refresh() self.last_repaint_time = mytime.clock() if self.skipping_timer > 0: self.skipping_timer -= 1 repeat_time = 1000 else: repeat_time = 250 if self.parent.stopping == True: if self.progress != None: self.progress.Destroy() self.progress = None self.show_sync = False self.timer.Stop() return if self.IsShownOnScreen() == False: if self.progress != None: self.progress.Destroy() self.progress = None self.show_sync = False if self == self.parent.current_view and self.parent.active_unit.MAC[:4] not in ('DEMO', 'GRPd') and self.parent.updatingFirmware == False: (accessrights, current_user) = self.parent.get_access() if self.csbutton == None: if self.current_channel < 128 and self.current_channel >= 0 and accessrights & protocol.arInChannel == 0 and self.parent.active_unit.MAC[:4] not in ('DEMO', 'GRP_') or self.current_channel >= 128 and accessrights & protocol.arOutChannel == 0 and self.parent.GL.last_tested_skin.endswith('_a') == False and self.parent.current_view != self.parent.views[0]: print mytime.displayTime() + ' cp.Access to this panel has been denied (1), switching to main panel.', self.name, self.current_channel, self, self.parent.current_view, self.parent.views[0] self.parent.prepare_set_view(self.parent.views[0], force=True) return elif self.parent.GL.current_skin.endswith('_eq') and self.current_channel == None: self.current_channel = 0 if (self.current_channel < 128 and self.current_channel >= 0 and accessrights & protocol.arInChannel == 0 and self.parent.active_unit.MAC[:4] not in ('DEMO', 'GRP_') or self.current_channel >= 128 and accessrights & protocol.arOutChannel == 0 and self.parent.GL.last_tested_skin.endswith('_a') == False and self.parent.alwaysGrantAccessToOutPanel == False or self.current_channel < 0 and (self.csbutton[:5] == 'cs_in' or self.csbutton[:6] == 'cs_out' or self.csbutton == 'cs_auto_io') and self.parent.current_view != self.parent.views[0]) and self.name[:10] != 'Main_panel': print mytime.displayTime() + ' cp.Access to this panel has been denied (2), switching to main panel.', '|' + self.name[:10] + '|', self.current_channel, self, self.parent.current_view, self.parent.views[0] self.parent.prepare_set_view(self.parent.views[0], force=True) return try: view_accessrights = self.parent.config.getint(self.name, 'required_access_rights') if view_accessrights & accessrights == 0 and self.parent.current_view != self.parent.views[0]: print mytime.displayTime() + ' cp.Access to this panel has been denied (3), switching to main panel.', self.name, self.current_channel, self, self.parent.current_view, self.parent.views[0] self.parent.prepare_set_view(self.parent.views[0], force=True) return except: pass try: if self.virgin == True: if self.parent.mv_panel == True: group = self.parent.group members = one_unit.app.groups[group] for mac in members: try: one_unit.app.server.peers.units[mac].process.conn.enable_vu = True except: pass for key in self.gauges.keys(): if key.channel == -1 and self.current_channel is not None: member_id = key.member_id if self.current_channel < 128: if key.member_id == protocol.MEMBER_ID_VU_OUT: member_id = protocol.MEMBER_ID_VU_IN if key.member_id == protocol.MEMBER_ID_GR_OUT: member_id = protocol.MEMBER_ID_GR_IN elif key.member_id == protocol.MEMBER_ID_VU_IN: member_id = protocol.MEMBER_ID_VU_OUT if key.member_id == protocol.MEMBER_ID_GR_IN: member_id = protocol.MEMBER_ID_GR_OUT new_key = data_model.Key(key.struct_id, member_id, -1, key.num) if key != new_key: if new_key not in self.gauges.keys(): self.gauges[new_key] = [] for client in self.gauges[key]: self.gauges[new_key].append(client) del self.gauges[key] print mytime.displayTime() + ' Changed gauge key from ', key, 'to', new_key self.index = 0 self.virgin = False if self == self.parent.current_view: if self.CheckSkin() == True: return if self.parent.model.changed == True or self.update_all_controls_counter > 20 or self.skipping_timer > 0 or self.needRefreshAfterSync == True: if self.parent.model.synced() == True and self.parent.model.completion() == 100: self.needRefreshAfterSync = False self.update_all_controls_counter = 0 self.update_controls() self.parent.model.changed = False for gauges in self.gauges.values(): for gauge in gauges: gauge.verifyRender() gauge.Refresh() self.svg_doc.set_element_render_all() self.update_all_controls_counter += 1 if self.updates > 2: self.timer.Stop() if self.show_sync == True: self.timer.Start(250) else: self.timer.Start(repeat_time) else: self.updates += 1 else: self.virgin = True self.timer.Stop() if self.show_sync == True: self.timer.Start(250) else: self.timer.Start(repeat_time) except: traceback.print_exc(file=sys.stdout) if self.parent.mv_panel == True: try: group = self.parent.group members = one_unit.app.groups[group] vu_max_in = -100 vu_max_out = -100 gr_max = -100 vu_min_in = 100 vu_min_out = 100 gr_min = 100 for mac in members: try: (invu, outvu) = server.unit_data.vu[mac] except: invu = -100 outvu = -100 if outvu > vu_max_out: vu_max_out = outvu if invu > vu_max_in: vu_max_in = invu if outvu < vu_min_out: vu_min_out = outvu if invu < vu_min_in: vu_min_in = invu try: gr = server.unit_data.gr[mac] except: gr = -100 if gr > gr_max: gr_max = gr if gr < gr_min: gr_min = gr for key in self.gauges.keys(): if key.member_id == protocol.MEMBER_ID_VU_IN: for gauge in self.gauges[key]: if gauge.name.find('min') > 0: gauge.update(vu_min_in) else: gauge.update(vu_max_in) continue if key.member_id == protocol.MEMBER_ID_VU_OUT: for gauge in self.gauges[key]: if gauge.name.find('min') > 0: gauge.update(vu_min_out) else: gauge.update(vu_max_out) continue if key.member_id in (protocol.MEMBER_ID_GR_IN, protocol.MEMBER_ID_GR_OUT): for gauge in self.gauges[key]: if gauge.name.find('min') > 0: gauge.update(gr_min) else: gauge.update(gr_max) self.timer.Stop() self.timer.Start(100) except: traceback.print_exc(file=sys.stdout) return def unsavedChanges(self): try: key = data_model.Key(protocol.STRUCT_ID_GLOBAL, protocol.MEMBER_ID_HARDWARE_STATUS_FLAGS, 0, 0) val = self.parent.model.get(key) if val != None: val = int(val) if val & protocol.confUserConfig > 0: print mytime.displayTime(), 'cp.Jaja wel user changes' return True print mytime.displayTime(), 'cp.Nene geen user changes' return False return True except: return True return def set_index(self, index): if self.active_index_button != None: self.active_index_button.set_state('off') if int(self.index) != int(index): self.index = index self.block_once = True self.block_once_time = mytime.clock() return def on_test_timer(self, evt): if self.run_test == True: if self.test_phase == 1: self.parent.load_vars_from_file('pr1.preset', None) key = data_model.Key(protocol.STRUCT_ID_COMMAND, protocol.MEMBER_ID_COMMAND, 0, 2) self.parent.model.set_to_unit(key, 0) self.test_phase = 0 else: self.parent.load_vars_from_file('pr2.preset', None) key = data_model.Key(protocol.STRUCT_ID_COMMAND, protocol.MEMBER_ID_COMMAND, 0, 2) self.parent.model.set_to_unit(key, 1) self.test_phase = 1 self.update_controls() return def set_channel(self, chan_no): if self.active_cs_button != None: self.active_cs_button.set_state('off') self.current_channel = chan_no self.selected_channel = chan_no self.updateControlLimits() self.channelFlagMask = {} self.channelFlagShow = {} self.readChannelFlagMask() self.readCustomElementKeys() self.update_controls() return def control_factory(self, section, ctrl_name): handlers = {'slider': (self.create_slider), 'knob': (self.create_knob), 'text': (self.create_text), 'gauge': (self.create_gauge), 'toggle-button': (self.create_toggle_button), 'button': (self.create_button), 'PEQ_diagram': (self.create_PEQ_diagram), 'XV_diagram': (self.create_XV_diagram), 'choice': (self.create_choice), 'available_units': (self.create_available_units), 'delay_unit': (self.create_delay_unit), 'indicator': (self.create_indicator), 'label': (self.create_label), 'memberList': (self.createItemList), 'groupList': (self.createItemList)} try: ctrl_type = self.config.get(section, ctrl_name + '_type') except: if ctrl_name.find('_text') > 0: ctrl_type = 'text' elif ctrl_name.find('_slider') > 0: ctrl_type = 'slider' elif ctrl_name.find('_label') > 0: ctrl_type = 'label' elif ctrl_name.find('_button') > 0: ctrl_type = 'button' elif ctrl_name.find('_knob') > 0: ctrl_type = 'knob' elif ctrl_name.find('_gauge') > 0: ctrl_type = 'gauge' elif ctrl_name.find('_type') > 0 and self.auto_type_choice: ctrl_type = 'choice' elif ctrl_name.find('_choice') > 0: ctrl_type = 'choice' elif ctrl_name.find('vu_') == 0: ctrl_type = 'gauge' elif ctrl_name.find('level_') == 0: ctrl_type = 'gauge' elif ctrl_name.find('gr_') == 0: ctrl_type = 'gauge' elif ctrl_name.find('memberList') >= 0: print mytime.displayTime(), 'cp.got member list' ctrl_type = 'memberList' elif ctrl_name.find('groupList') >= 0: print mytime.displayTime(), 'cp.got group list', ctrl_name ctrl_type = 'groupList' else: ctrl_type = 'toggle-button' self.control_types[ctrl_name] = ctrl_type try: handler = handlers[ctrl_type] except KeyError: dial = wx.MessageDialog(None, os.path.join('Unsupported Control Type:', ctrl_type, ctrl_name), 'Error', wx.OK | wx.ICON_ERROR) dial.ShowModal() return else: res = handler(self.config, section, ctrl_name) res.set_change_handler(self.on_value_change) if ctrl_type == 'groupList': res.switchGroup = True if ctrl_type == 'memberList': res.switchToUnit = True return res return def is_locked_slave(self, channel): if channel > 0 and channel - 1 in self.parent.unit_channels: if self.number_of_slaves(channel - 1) > 0: return True else: return False return def number_of_slaves(self, channel): key = data_model.Key(protocol.STRUCT_ID_LINK, protocol.MEMBER_ID_LINK, channel, 2) val = self.parent.model.get(key) if val == None: return 0 else: if int(val) == 1 and channel + 1 in self.parent.unit_channels: if 130 in self.parent.unit_channels and 131 not in self.parent.unit_channels: if channel in (0, 129): return 1 else: return 0 else: if channel & 1 == 0: return 1 else: return 0 return 0 def set_value(self, key, val): self.parent.set_value(key, val) self.update_all_controls_counter = 20000 return def Q_to_Bw(self, Q, peq_type): if peq_type == protocol.fLowShelf or peq_type == protocol.fHighShelf: if Q == 0: return 10 return 30 / Q if Q == 0: return 80 return 2.88539 * math.asinh(1 / (2 * Q)) def show_q_or_bw(self, Q, ctrl, key): peq_type = self.parent.model.get(data_model.Key(protocol.STRUCT_ID_PEQ, protocol.MEMBER_ID_TYPE, key.channel, key.num)) if peq_type == protocol.fNOTCH: max_val = 80.0 min_val = 10.0 Q *= 10.0 elif peq_type == protocol.fLowPass or peq_type == protocol.fHighPass: max_val = 2.0 min_val = 0.5 Q /= 10.0 elif peq_type == protocol.fLowShelf or peq_type == protocol.fHighShelf: max_val = 25.0 min_val = 3.0 else: max_val = 25.0 min_val = 0.1 if self.parent.model.get(data_model.Key(protocol.STRUCT_ID_INTERNAL, protocol.MEMBER_ID_Q_BW, 0, 0)) == 1: ctrl.set_limits(self.Q_to_Bw(max_val, peq_type), self.Q_to_Bw(min_val, peq_type)) if self.show_Q_unit == True: if peq_type == protocol.fLowShelf or peq_type == protocol.fHighShelf: ctrl.set_unit('dB/Oct') else: ctrl.set_unit(' Oc') return self.Q_to_Bw(Q, peq_type) else: ctrl.set_limits(min_val, max_val) if self.show_Q_unit == True: try: if peq_type == protocol.fLowShelf or peq_type == protocol.fHighShelf: ctrl.set_unit('dB/Oct') else: ctrl.set_unit(' Q') except: pass return round(Q, 1) return def get_q_or_bw(self, val, key): peq_type = self.parent.model.get(data_model.Key(protocol.STRUCT_ID_PEQ, protocol.MEMBER_ID_TYPE, key.channel, key.num)) test_key = data_model.Key(protocol.STRUCT_ID_INTERNAL, protocol.MEMBER_ID_Q_BW, 0, 0) if self.parent.model.get(test_key) == 1: if val == 0: return 25 else: if peq_type == protocol.fLowShelf or peq_type == protocol.fHighShelf: val = 30.0 / val else: val = math.sqrt(math.pow(2, val)) / (pow(2, val) - 1.0) if peq_type == protocol.fNOTCH: val /= 10.0 if val > 8: val = 8 if val < 1: return 1 return val if peq_type == protocol.fHighPass or peq_type == protocol.fLowPass: val *= 10.0 if val > 20: val = 20 if val < 5: return 5 return val if val > 25: val = 25 if val < 0.1: return 0.1 return val else: if peq_type == protocol.fNOTCH: val /= 10 elif peq_type == protocol.fHighPass or peq_type == protocol.fLowPass: val *= 10 return val return def access_granted(self, key, message=True): try: if self.parent.active_unit.IP == 'Offline': if message == True: dial = dialog.Dialog(self, -1, 'Warning', 'It is not allowed to change settings while the unit is offline.', OK_Only=True) dial.ShowModal() dial.Destroy() return False except: return False else: if self.parent.full_access == True or self.parent.active_unit.MAC[:4] in ('DEMO', 'GRPdeactivated'): return True access_granted = True (accessrights, current_user) = self.parent.get_access() if key.struct_id == protocol.STRUCT_ID_GLOBAL: if key.member_id == protocol.MEMBER_ID_CHECK_PASSWORD: return True if key.member_id == protocol.MEMBER_ID_SHORT_NAME: if accessrights & protocol.arUnitName == 0: access_granted = False elif key.member_id == protocol.MEMBER_ID_STANDBY_DELAY: if accessrights & protocol.arUnitConfiguration == 0: access_granted = False else: return True elif key.struct_id == protocol.STRUCT_ID_PRESET_GLOBAL: if key.member_id == protocol.MEMBER_ID_CONFIGURATION: if accessrights & protocol.arOutChannel == 0: access_granted = False else: return True else: return True elif key.struct_id == protocol.STRUCT_ID_COMMAND: return True confkey = data_model.Key(protocol.STRUCT_ID_PRESET_GLOBAL, protocol.MEMBER_ID_CONFIGURATION, 0, 0) confval = self.parent.model.get(confkey) try: confval = int(confval) except: confval = 0 try: gain_always_allowed = eval(self.parent.main_config.get('ROOT', 'gain_always_allowed')) except: gain_always_allowed = True if gain_always_allowed: if key.channel >= 128 and accessrights & protocol.arOutChannel == 0 and key.struct_id != protocol.STRUCT_ID_MUTE and key.struct_id != protocol.STRUCT_ID_MIXER and (key.struct_id != protocol.STRUCT_ID_GAIN or confval & protocol.confAllModes != 0): access_granted = False if key.channel < 128 and accessrights & protocol.arInChannel == 0 and key.struct_id != protocol.STRUCT_ID_MUTE and (key.struct_id != protocol.STRUCT_ID_GAIN or confval & protocol.confAllModes != 0): access_granted = False elif key.channel >= 128 and accessrights & protocol.arOutChannel == 0 and key.struct_id != protocol.STRUCT_ID_MUTE and key.struct_id != protocol.STRUCT_ID_MIXER: access_granted = False if key.channel < 128 and accessrights & protocol.arInChannel == 0 and key.struct_id != protocol.STRUCT_ID_MUTE: access_granted = False if access_granted == False: if message == True: dial = dialog.Dialog(self, -1, 'Warning', 'Sorry, you do not have sufficient access rights to change this value.', OK_Only=True) dial.ShowModal() dial.Destroy() return False return True def switchActiveUnitTo(self, mac, switchSkin=False): try: val = self.parent.peers.units[mac].type except: print mytime.displayTime() + ' value', val, 'not in peers' return else: try: key = data_model.Key(protocol.STRUCT_ID_GLOBAL, protocol.MEMBER_ID_MODEL_NUMBER, 0, 0) model_number = one_unit.app.server.peers.get(key, mac) if model_number < 0: key = data_model.Key(protocol.STRUCT_ID_GLOBAL, protocol.MEMBER_ID_MODEL_FIRMWARE, 0, 0) model_number = one_unit.app.server.peers.get(key, mac) val = val + '_' + str(model_number) skin_path = os.path.join(one_unit.app.cwd, one_unit.app.skin_path, val) if os.path.exists(skin_path): print mytime.displayTime() + ' cp.ovc.Skin', skin_path, ' found' elif os.path.exists(skin_path + '_u'): print mytime.displayTime() + ' cp.ovc.Skin +_u found' val += '_u' except: traceback.print_exc(file=sys.stdout) try: val = val.replace('_None', '') except: pass if mac[:4] not in ('DEMO', 'GRPdeactivated', 'VN::'): if mac not in one_unit.app.pin_verified: dial = dialog.Dialog(self, -1, 'Error', 'The unit you have selected is not available yet. Please try again later.') dial.ShowModal() dial.Destroy() return if one_unit.app.pin_verified[mac] == False: dial = dialog.Dialog(self, -1, 'Error', 'The unit you have selected is protected by a PIN code. Please close this panel and enter the correct PIN when re-opening it.') dial.ShowModal() dial.Destroy() return if self.parent.peers.units[mac].link_status != 'available': dial = dialog.Dialog(self, -1, 'Error', 'The unit you have selected is no longer available. Please check the connection.') dial.ShowModal() dial.Destroy() return if self.parent.support_wrong_skin != True and self.parent.remote_link.Connected == True and self.parent.peers.units[mac].MAC[:4] in ('DEMO', 'GRPdeactivated'): if self.parent.peers.units[mac].type + self.model_number_string != self.parent.active_unit.type + self.model_number_string: print mytime.displayTime() + ' Wrong skin, not supported' return launchKey = one_unit.getLaunchKey(mac) print mytime.displayTime(), 'cp.saut', self.parent.launchKey, launchKey if launchKey == None: print mytime.displayTime(), 'cp.saut. None Launch Key, aborting' if self.parent.launchKey != None: if launchKey[launchKey.find('|'):] != self.parent.launchKey[self.parent.launchKey.find('|'):]: print mytime.displayTime(), 'cp.saut.restoring other closed window' wx.CallAfter(one_unit.executeLaunch, mac) wx.CallAfter(self.parent.close) return if True: print mytime.displayTime() + ' cp.ovc.auto switching to', val self.parent.active_unit = self.parent.peers.units[mac] if mac not in one_unit.app.bootloader_progress: one_unit.app.bootloader_progress[mac] = None one_unit.app.auto_load_dff[mac] = False self.parent.parent.network_window.children[self.parent.MAC] = None self.parent.MAC = mac if switchSkin == True: self.switch_skin(val) self.parent.refreshAll() return else: print mytime.displayTime() + 'cu.saut.Nothing to do!' return def on_value_change(self, ctrl): timestamp = mytime.clock() try: if self.parent.changing_view == True or self.parent.init_done == False or self.parent.switching_skin == True: return except: return else: (accessrights, current_user) = self.parent.get_access() ctrl_name = ctrl.name showMessage = True if True: (c, key, var_name) = self.controls[ctrl_name] if c is not ctrl or key is None and ctrl_name != 'available_units' and ctrl_name != 'delay_unit' and ctrl.name.startswith('cs_') == False: print mytime.displayTime(), 'cp.ovc. No key', c, ctrl, key, var_name, ctrl.name return section = self.name + '|' + str(self.current_channel) + '|' + ctrl_name if section in self.customElementKeys: keysToApply = self.customElementKeys[section] else: keysToApply = [ key] keysToApplyIndex = -1 for key in keysToApply: keysToApplyIndex += 1 value_set = False if self.block_once == True and mytime.clock() - self.block_once_time < 1: self.block_once = False try: val = self.parent.model.get(self.key_with_current_channel(key)) self.update_control(ctrl_name) except: traceback.print_exc(file=sys.stdout) return try: if ctrl_name.find('output_select') >= 0 and self.parent.autoBridgeSelect: print mytime.displayTime(), 'cp. output select changed', ctrl_name, ctrl.text bridgeKey = data_model.Key(protocol.STRUCT_ID_PRESET_GLOBAL, protocol.MEMBER_ID_CONFIGURATION, 0, 0) bridgeVal = self.parent.model.get(bridgeKey) if bridgeVal == None: bridgeVal = 0 bridgeVal = int(bridgeVal) bridgeChannel = self.key_with_current_channel(key).channel if bridgeChannel < 8: bridgeMask = protocol.confBridge << bridgeChannel / 2 if ctrl.text.lower().find('bridge') >= 0: bridgeVal |= bridgeMask else: bridgeVal &= ~bridgeMask self.parent.model.set_to_unit(bridgeKey, bridgeVal) self.simulateMouseClick(1) except: traceback.print_exc(file=sys.stdout) if ctrl_name == 'sleep' or ctrl_name == 'standby': num = protocol.cmdExitStandby try: testkey = data_model.Key(protocol.STRUCT_ID_GLOBAL, protocol.MEMBER_ID_HARDWARE_STATUS_FLAGS, 0, 0) val = self.parent.model.get(testkey) if val != None: val = int(val) if val & protocol.confStandby > 0: num = protocol.cmdExitStandby else: num = protocol.cmdGotoStandby except: pass else: key = data_model.Key(key.struct_id, key.member_id, 0, num) if ctrl_name == 'power': try: testkey = data_model.Key(protocol.STRUCT_ID_GLOBAL, protocol.MEMBER_ID_HARDWARE_STATUS_FLAGS, 0, 0) val = self.parent.model.get(testkey) if val != None: val = int(val) if val & protocol.confStandby == 0: dial = dialog.Dialog(self, -1, 'Power Off', 'Are you sure to power off?', Wrap=300) dial.ShowModal() response = dial.response dial.Destroy() if response != 'OK': return cmdkey = data_model.Key(protocol.STRUCT_ID_COMMAND, protocol.MEMBER_ID_COMMAND, 0, protocol.cmdGotoStandby) self.parent.set_value(cmdkey, 1) future.Future(1, self.parent.set_value, cmdkey, 0) else: cmdkey = data_model.Key(protocol.STRUCT_ID_COMMAND, protocol.MEMBER_ID_COMMAND, 0, protocol.cmdExitStandby) self.parent.set_value(cmdkey, 1) future.Future(1, self.parent.set_value, cmdkey, 0) except: pass if ctrl_name == 'check_password': print mytime.displayTime(), 'User entered password:', ctrl.get_value(), key one_unit.app.check_password = ctrl.get_value() pwok = False for i in range(0, 6): preset_pwkey = data_model.Key(protocol.STRUCT_ID_PRESET_GLOBAL, protocol.MEMBER_ID_SET_PASSWORD, i, 0) presetPassword = self.parent.model.get(preset_pwkey) try: if presetPassword != None and presetPassword.strip() != '' and presetPassword.strip() == ctrl.get_value().strip(): userkey = data_model.Key(protocol.STRUCT_ID_GLOBAL, protocol.MEMBER_ID_CURRENT_USER, 0, 0) self.set_value(key, ctrl.get_value()) self.parent.progress = one_unit.ProgressScreen(self.parent, -1, 'Progress', 'Applying...') self.parent.progress.Show(True) self.parent.progress.Update(1) pr = 1 try: while self.parent.model.synced(key) == False: mytime.sleep(0.1) if pr < 99: pr += 1 self.parent.progress.Update(pr) self.parent.model.set_to_unit(userkey, i) except: pass try: self.parent.progress.Destroy() except: pass return if presetPassword != None and presetPassword.strip() != '': continue except: pass pwkey = data_model.Key(protocol.STRUCT_ID_GLOBAL, protocol.MEMBER_ID_SET_PASSWORD, i, 0) globalPassword = self.parent.model.get(pwkey) try: if globalPassword != None and globalPassword.strip() == ctrl.get_value().strip(): userkey = data_model.Key(protocol.STRUCT_ID_GLOBAL, protocol.MEMBER_ID_CURRENT_USER, 0, 0) self.set_value(key, ctrl.get_value()) self.parent.progress = one_unit.ProgressScreen(self.parent, -1, 'Progress', 'Applying...') self.parent.progress.Show(True) self.parent.progress.Update(1) pr = 1 try: while self.parent.model.synced(key) == False: mytime.sleep(0.1) if pr < 99: pr += 1 self.parent.progress.Update(pr) self.parent.model.set_to_unit(userkey, i) except: pass try: self.parent.progress.Destroy() except: pass return except: pass self.parent.set_value(key, one_unit.app.check_password) wx.MessageBox('Invalid Password.', 'Error', wx.OK | wx.ICON_ERROR) return if ctrl_name == 'delay_unit': self.delay_unit = ctrl.get_value() for ctrl_name in self.controls: (c, key, var_name) = self.controls[ctrl_name] if key == None: continue if key.struct_id == protocol.STRUCT_ID_DELAY: c.set_value(0) self.update_all_controls_counter = 20000 return if ctrl_name == 'available_units': mac = ctrl.get_value() self.switchActiveUnitTo(mac) return if hasattr(ctrl, 'get_values') and callable(ctrl.get_values): vals = ctrl.get_values(changed_only=True) for (key, val) in vals.items(): channel_key = self.key_with_current_channel(key) if self.is_locked_slave(channel_key.channel): channel_key = data_model.Key(channel_key.struct_id, channel_key.member_id, channel_key.channel - 1, channel_key.num) if self.access_granted(key, showMessage) == False: return if key.struct_id == protocol.STRUCT_ID_PEQ and key.member_id == protocol.MEMBER_ID_GAIN and val != self.parent.model.get(channel_key): temp_key = data_model.Key(key.struct_id, protocol.MEMBER_ID_ON, channel_key.channel, key.num) if math.fabs(val) > 0.05: on_val = 1 else: on_val = 0 try: self.set_value(temp_key, on_val) except: pass if (key.struct_id == protocol.STRUCT_ID_LPF or key.struct_id == protocol.STRUCT_ID_HPF) and key.member_id == protocol.MEMBER_ID_FREQ: temp_key = data_model.Key(key.struct_id, protocol.MEMBER_ID_ON, key.channel, key.num) if self.parent.model.get(temp_key) != None and val != self.parent.model.get(key): self.parent.model.changed = True if val > ctrl.lower_limit and val < ctrl.higher_limit: self.set_value(temp_key, 1) else: self.set_value(temp_key, 0) self.set_value(channel_key, val) else: val = ctrl.get_value() key = self.key_with_current_channel(key) try: if ctrl.variable_num == True: key = self.key_with_current_index(key) except: pass try: if ctrl.radio == True: self.update_all_controls_counter = 20000 if val == 'on': return mask = ctrl.mask old_val = int(self.parent.model.get(key)) old_val &= 4294967295L ^ mask if val == 'off': if ctrl.mask_val != 0: old_val |= ctrl.mask_val if val == 'on': if ctrl.mask_val == 0: old_val |= ctrl.mask val = old_val except: pass if key == None or self.access_granted(key, showMessage) == False: return if key.struct_id == protocol.STRUCT_ID_CHANNEL and key.member_id == protocol.MEMBER_ID_SHORT_NAME: if self.parent.channel_name_split > 0: val = (val + ' ')[:16 - self.parent.channel_name_split] try: val += self.parent.model.get(key)[16 - self.parent.channel_name_split:] except: print mytime.displayTime() + ' cp.ovc.no value found for channel name' return else: val += ' ' val = val[:16] if key.struct_id == protocol.STRUCT_ID_COMMAND and key.member_id == protocol.MEMBER_ID_COMMAND: if self.parent.active_unit.MAC[:4] in ('DEMO', 'GRPdeactivated'): return loop = 0 while self.parent.model.synced(key) == False and loop < 100: mytime.sleep(0.1) one_unit.tryYield() loop += 1 try: if key.struct_id == protocol.STRUCT_ID_PRESET_GLOBAL and key.member_id == protocol.MEMBER_ID_CONFIGURATION: if val & protocol.confTwoWay == protocol.confTwoWay: for linkkey in self.parent.model.vars: if linkkey.struct_id == protocol.STRUCT_ID_LINK and linkkey.member_id == protocol.MEMBER_ID_LINK and linkkey.channel >= 128: self.set_value(linkkey, 0) except: pass try: if key.struct_id == protocol.STRUCT_ID_PEQ and key.member_id == protocol.MEMBER_ID_TYPE: self.peq_type_changed = True except: traceback.print_exc(file=sys.stdout) if self.control_types[ctrl_name] == 'text': if isinstance(val, basestring): try: if ctrl_name.find('long_name') >= 0: maxLen = 64 else: maxLen = 16 new_val = data_model.getValidName(val)[:maxLen] if val.strip() != new_val.strip(): msg = 'The text "' + val.strip() + '" contains illegal characters, and will be changed to "' + new_val + '".' dial = dialog.Dialog(self, -1, 'Warning', msg) dial.ShowModal() response = dial.response dial.Destroy() if response != 'OK': self.update_controls() return val = new_val val = val.strip() if len(val) > maxLen: msg = 'The text "' + val.strip() + '" is too long, and will be reset to "' + val[:maxLen] + '".' dial = dialog.Dialog(self, -1, 'Warning', msg) dial.ShowModal() response = dial.response dial.Destroy() if response != 'OK': self.update_controls() return val = val[:maxLen] except: traceback.print_exc(file=sys.stdout) print mytime.displayTime() + ' ControlPanel.on_value_change: Failed to set unit name:', val return if ctrl_name == 'preset_name_text': if val != None and val.strip().lower() == 'default': dial = dialog.Dialog(self, -1, 'Preset Name', 'The name ' + val.strip() + ' is not allowed. Please choose a different name.') dial.ShowModal() return if val.startswith(self.parent.spk_lib_id): if self.current_user == protocol.uDeveloper: dial = dialog.Dialog(self, -1, 'Speaker Library', 'The name starting with "' + self.parent.spk_lib_id + '" identifies this preset as a loudspeaker library. Continue?') dial.ShowModal() res = dial.response dial.Destroy() if res != 'OK': return else: dial = dialog.Dialog(self, -1, 'Speaker Library', 'The name starting with "' + self.parent.spk_lib_id + '" is protected and can not be used. Please choose another name.') dial.ShowModal() dial.Destroy() return if val.strip().lower() == 'empty': val = 'Empty' if ctrl_name == 'unit_name_text': if val[:3] == 'GRP' and val.strip() != self.parent.active_unit.name.strip(): dial = dialog.Dialog(self, -1, 'Grouping', 'Grouping via unit name is no longer supported. Please open the network window (Tools - Network Window) and select a group there.') dial.ShowModal() dial.Destroy() if val == 'start test': print mytime.displayTime() + ' Starting Test.....' self.run_test = True self.test_timer.Start(200) self.test_counter = 0 key = data_model.Key(protocol.STRUCT_ID_GLOBAL, protocol.MEMBER_ID_SHORT_NAME, 0, 0) self.parent.model.set_to_unit(key, 'Test Running') return if val == 'stop test': print mytime.displayTime() + ' Stopped Test' self.run_test = False self.test_timer.Stop() return if val == 'ssstart tetrisss': one_unit.start_tetris() return if val == 'list USB': one_unit.ListUSBDevices() return if ctrl_name == 'recall_preset_list' and self.parent.auto_load_preset == True: if self.unsavedChanges() == True and one_unit.areYouSure(getString('aslp')) == False: self.update_control('recall_preset_list') self.needRefreshAfterSync = True return print mytime.displayTime() + ' cp.auto recall preset .2' namekey = data_model.Key(protocol.STRUCT_ID_PRESET_GLOBAL, protocol.MEMBER_ID_SHORT_NAME, val, 0) name = self.parent.model.get(namekey) if name == None: print mytime.displayTime(), 'cp.None name for preset', val return if name.strip().lower() in ('empty preset', 'empty'): return loadKey = data_model.Key(protocol.STRUCT_ID_COMMAND, protocol.MEMBER_ID_COMMAND, 0, protocol.cmdLoadPreset) selectKey = data_model.Key(protocol.STRUCT_ID_PRESET_GLOBAL, protocol.MEMBER_ID_PRESET_NUMBER, 0, 0) for groupID in one_unit.app.groups: if self.parent.MAC not in one_unit.app.groups[groupID]: continue print mytime.displayTime() + ' cp.Lid van group', one_unit.app.group_names[groupID] modelFWkey = data_model.Key(protocol.STRUCT_ID_GLOBAL, protocol.MEMBER_ID_MODEL_FIRMWARE, 0, 0) modelFW = one_unit.app.server.peers.get(modelFWkey, self.parent.MAC) unitType = one_unit.app.server.peers.units[self.parent.MAC].type allIdentical = True print mytime.displayTime() + ' cp.Mijn unit type:', unitType + '_' + str(modelFW) for testMAC in one_unit.app.groups[groupID]: try: if one_unit.app.server.peers.get(modelFWkey, testMAC) != modelFW or one_unit.app.server.peers.units[testMAC].type != unitType: allIdentical = False print mytime.displayTime() + ' cp.Gevonden:', one_unit.app.server.peers.units[testMAC].type + '_' + str(one_unit.app.server.peers.get(modelFWkey, testMAC)) except: allIdentical = False traceback.print_exc(file=sys.stdout) if allIdentical: continue print mytime.displayTime() + ' Verschillende typen in group -> verder controleren' if one_unit.app.group_type[groupID] == 'Carbon Copy': if loadKey in one_unit.app.group_exceptions[groupID] or selectKey in one_unit.app.group_exceptions[groupID]: print mytime.displayTime() + ' Exception in carbon copy group -> OK' continue print mytime.displayTime() + ' Geen exception in carbon copy group -> niet OK!' elif one_unit.app.group_type[groupID] == 'Advanced': if loadKey not in one_unit.app.group_links[groupID] and selectKey not in one_unit.app.group_links[groupID]: print mytime.displayTime() + ' Geen link in advanced group -> OK' continue print mytime.displayTime() + ' Link in advanced group -> Niet OK!' dial = dialog.Dialog(None, -1, 'Load Preset', 'It is not allowed to load a preset or configuration in groups of mixed unit types.', OK_Only=True) dial.ShowModal() dial.Destroy() self.update_control('recall_preset_list') self.needRefreshAfterSync = True return if ctrl_name == 'recall_preset_list': if val == 0: self.update_controls() return if self.parent.auto_load_preset == True: (accessrights, current_user) = self.parent.get_access() if accessrights & protocol.arLoadPreset == 0: dial = dialog.Dialog(None, -1, 'Access Rights', 'You do not have sufficient access rights to open presets.', OK_Only=True) dial.ShowModal() dial.Destroy() return if key.struct_id == protocol.STRUCT_ID_LINK: if val == 1: channel = key.channel if channel >= 128: channel = 'output ' + str(channel - 127) else: channel = 'input ' + str(channel + 1) msg = 'Warning! Setting channel links will copy settings of channel ' + channel channel = key.channel + key.num if channel >= 128: channel = 'output ' + str(channel - 128) else: channel = 'input ' + str(channel) msg += ' to channel ' + channel + '. Continue?' dlgMessage = msg dlgTitle = 'Warning' res = wx.MessageBox(dlgMessage, dlgTitle, wx.OK | wx.CANCEL) if res != wx.OK: self.update_controls() return start_channel = key.channel end_channel = key.channel + key.num for sub_key in self.parent.model.vars.keys(): if sub_key.struct_id == protocol.STRUCT_ID_LINK and sub_key != key and (sub_key.channel >= key.channel and sub_key.channel < key.channel + key.num or key.channel >= sub_key.channel and key.channel < sub_key.channel + sub_key.num): self.set_value(sub_key, 0) if val == 1 and sub_key.channel > key.channel and sub_key.channel < key.channel + key.num: if sub_key.struct_id in (protocol.STRUCT_ID_UI_CONTROL, protocol.STRUCT_ID_GLOBAL, protocol.STRUCT_ID_PRESET_GLOBAL, protocol.STRUCT_ID_MIXER, protocol.STRUCT_ID_LINK) or sub_key.struct_id < 0: continue if sub_key.struct_id == protocol.STRUCT_ID_MUTE and self.parent.link_mute == False: continue if sub_key.member_id in (protocol.MEMBER_ID_SHORT_NAME, protocol.MEMBER_ID_INPUT_SELECT, protocol.MEMBER_ID_CONFIGURATION, protocol.MEMBER_ID_COMMAND): continue master_key = data_model.Key(sub_key.struct_id, sub_key.member_id, start_channel, sub_key.num) master_val = self.parent.model.get(master_key) sub_val = self.parent.model.get(sub_key) if master_val == sub_val: continue self.set_value(sub_key, master_val) if key.struct_id not in (protocol.STRUCT_ID_MIXER, protocol.STRUCT_ID_MUTE, protocol.STRUCT_ID_LINK) and key.member_id not in (protocol.MEMBER_ID_CONNECTOR_NAME, protocol.MEMBER_ID_SHORT_NAME, protocol.MEMBER_ID_INPUT_SELECT) and (key.struct_id not in (protocol.STRUCT_ID_LPF, protocol.STRUCT_ID_HPF) or key.member_id not in (protocol.MEMBER_ID_GAIN, protocol.MEMBER_ID_Q)) and (key.struct_id != protocol.STRUCT_ID_PRESET_GLOBAL or key.member_id != protocol.MEMBER_ID_DELAY) and self.is_locked_slave(key.channel) and key.struct_id != protocol.STRUCT_ID_GLOBAL: key = data_model.Key(key.struct_id, key.member_id, key.channel - 1, key.num) elif key.struct_id == protocol.STRUCT_ID_MUTE and self.parent.link_mute == True and self.is_locked_slave(key.channel): key = data_model.Key(key.struct_id, key.member_id, key.channel - 1, key.num) if key.member_id == protocol.MEMBER_ID_Q: val = self.get_q_or_bw(val, key) if ctrl_name[:12] == 'xv_knob_freq' and self.remote_link.last_xover_key is not None: key = data_model.Key(self.remote_link.last_xover_key.struct_id, key.member_id, key.channel, key.num) if ctrl_name[:8] == 'peq_knob' and self.remote_link.last_peq_key is not None: key = data_model.Key(key.struct_id, key.member_id, key.channel, self.remote_link.last_peq_key.num) if key.struct_id == protocol.STRUCT_ID_PEQ and key.member_id == protocol.MEMBER_ID_GAIN: peq_type = self.parent.model.get(data_model.Key(key.struct_id, protocol.MEMBER_ID_TYPE, key.channel, key.num)) if peq_type in (protocol.fNOTCH, protocol.fAllpass, protocol.fLowPass, protocol.fHighPass): return if key.struct_id == protocol.STRUCT_ID_PEQ and key.member_id == protocol.MEMBER_ID_GAIN: temp_key = data_model.Key(key.struct_id, protocol.MEMBER_ID_ON, key.channel, key.num) on_val = 1 try: if val == 0: on_val = 0 else: on_val = 1 except: pass else: try: self.set_value(temp_key, on_val) except: pass if (key.struct_id == protocol.STRUCT_ID_LPF or key.struct_id == protocol.STRUCT_ID_HPF) and key.member_id == protocol.MEMBER_ID_FREQ: temp_key = data_model.Key(key.struct_id, protocol.MEMBER_ID_ON, key.channel, key.num) if self.parent.model.get(temp_key) != None and val != self.parent.model.get(key): if val > ctrl.lower_limit and val < ctrl.higher_limit: self.set_value(temp_key, 1) else: self.set_value(temp_key, 0) if key.struct_id == protocol.STRUCT_ID_COMMAND and key.member_id == protocol.MEMBER_ID_COMMAND: if self.parent.active_unit.MAC[:4] in ('DEMO', 'GRPdeactivated'): return if key.num == protocol.cmdLoadPreset: if self.unsavedChanges() == True and one_unit.areYouSure(getString('aslp')) == False: self.update_control('recall_preset_list') self.needRefreshAfterSync = True return (accessrights, current_user) = self.parent.get_access() presetnumkey = data_model.Key(protocol.STRUCT_ID_PRESET_GLOBAL, protocol.MEMBER_ID_PRESET_NUMBER, 0, 0) presetnum = self.parent.model.get(presetnumkey) if presetnum in self.preset_names and self.preset_names[presetnum].strip() in ('Empty', 'Empty Preset'): if accessrights & protocol.arLoadEmptyPreset == 0: dial = dialog.Dialog(None, -1, 'Access Rights', 'You do not have sufficient access rights to load empty presets.', OK_Only=True) dial.ShowModal() dial.Destroy() return elif accessrights & protocol.arLoadPreset == 0: dial = dialog.Dialog(None, -1, 'Access Rights', 'You do not have sufficient access rights to load presets.', OK_Only=True) dial.ShowModal() dial.Destroy() return self.needRefreshAfterSync = True if key.num == protocol.cmdSavePreset: (accessrights, current_user) = self.parent.get_access() if accessrights & protocol.arSavePreset == 0: dial = dialog.Dialog(None, -1, 'Access Rights', 'You do not have sufficient access rights to save presets.', OK_Only=True) dial.ShowModal() dial.Destroy() return try: tmpkey = data_model.Key(protocol.STRUCT_ID_PRESET_GLOBAL, protocol.MEMBER_ID_PRESET_NUMBER, 0, 0) pres_num = int(self.parent.model.get(tmpkey)) except: pres_num = 100 namekey = data_model.Key(protocol.STRUCT_ID_PRESET_GLOBAL, protocol.MEMBER_ID_SHORT_NAME, pres_num, 0) current_name = self.parent.model.get(namekey) try: tmpkey = data_model.Key(protocol.STRUCT_ID_GLOBAL, protocol.MEMBER_ID_STARTUP_PRESET, 0, 0) read_only_preset_range = (int(self.parent.model.get(tmpkey)) & 65280) / 256 except: read_only_preset_range = 0 print mytime.displayTime() + ' cp.ovc.Saving Preset to unit, selected preset number:', pres_num, '(read only range:', read_only_preset_range, '), user level:', protocol.get_user_text(current_user) print mytime.displayTime() + ' Current name of selected preset number:', current_name if pres_num <= read_only_preset_range and current_user > protocol.uDeveloper: print mytime.displayTime() + ' Read-only preset! Aborting' if self.custom_write_protected_dialog != None: dial = dialog.Dialog(None, -1, 'Read-Only', self.custom_write_protected_dialog, OK_Only=True) else: dial = dialog.Dialog(None, -1, 'Read-Only', 'Presets 1 to ' + str(read_only_preset_range) + ' are protected. Please save to location ' + str(read_only_preset_range + 1) + ' or above.', OK_Only=True) dial.ShowModal() dial.Destroy() return if current_name != None and current_name.strip() != 'Empty': dial = wx.MessageBox('Warning: This preset is not empty. Continue?', 'Overwrite Preset', wx.OK | wx.CANCEL) if dial != wx.OK: return if self.keepUserPresetName == True and pres_num > read_only_preset_range: userNameKey = data_model.Key(protocol.STRUCT_ID_PRESET_GLOBAL, protocol.MEMBER_ID_SHORT_NAME, 0, 0) self.set_value(userNameKey, current_name) mytime.sleep(0.1) counter = 100 while counter > 0 and self.parent.stopping == False: if self.parent.model.synced(userNameKey) == True: break mytime.sleep(0.1) counter -= 1 self.set_value(key, 1) self.parent.waitForSync('saving preset (1)', key=key) future.Future(0.5, self.set_value, key, 0) self.parent.remote_link.set_get_key(namekey) return if ctrl_name == 'sleep' or ctrl_name == 'standby': val = 1 if key.struct_id == protocol.STRUCT_ID_COMMAND: self.set_value(key, 0) self.parent.waitForSync('cp.cdb.command -> 0', key=key) self.set_value(key, 1) else: self.set_value(key, val) value_set = True if key.struct_id == protocol.STRUCT_ID_PEQ: peq_type = self.parent.model.get(data_model.Key(key.struct_id, protocol.MEMBER_ID_TYPE, key.channel, key.num)) if (peq_type == protocol.fHighShelf or peq_type == protocol.fLowShelf) and self.parent.model.get(data_model.Key(key.struct_id, protocol.MEMBER_ID_Q, key.channel, key.num)) < 3: self.set_value(data_model.Key(key.struct_id, protocol.MEMBER_ID_Q, key.channel, key.num), 3) showMessage = False try: if value_set == True and key.struct_id == protocol.STRUCT_ID_COMMAND: if key.num == protocol.cmdLoadPreset: self.parent.blockSwitchViewWhenNotSynced = True self.cursor_type = 'wait' ctrl.set_state('on') cursor = wx.StockCursor(wx.CURSOR_WAIT) self.SetCursor(cursor) future.Future(1, self.SetCursor, wx.StockCursor(wx.CURSOR_ARROW)) print mytime.displayTime(), 'cp.cdb.l.1' if self.parent.waitForSync('cp.cdb.load preset', key=key) == False: self.parent.blockSwitchViewWhenNotSynced = False return print mytime.displayTime(), 'cp.cdb.l.2' self.set_value(key, 0) print mytime.displayTime(), 'cp.cdb.l.3' self.parent.remote_link.LinkStatus = False self.parent.remote_link.ClearDataBuffer() for testkey in self.parent.remote_link.values.keys(): if testkey.struct_id != protocol.STRUCT_ID_COMMAND and testkey.member_id not in protocol.unit_global_items: if testkey.struct_id == protocol.STRUCT_ID_PRESET_GLOBAL and testkey.member_id == protocol.MEMBER_ID_SHORT_NAME and testkey.channel > 0: continue del self.parent.remote_link.values[testkey] break one_unit.tryYield() mytime.sleep(0.5) one_unit.tryYield() self.parent.refreshAccess() print mytime.displayTime(), 'cp.cdb.l.4' one_unit.tryYield() mytime.sleep(0.5) one_unit.tryYield() self.parent.model.reset_get_list() elif key.num == protocol.cmdLocate: future.Future(10, self.set_value, key, 0) else: future.Future(1, self.set_value, key, 0) except: traceback.print_exc(file=sys.stdout) else: if ctrl_name == 'recall_preset_list' and self.parent.auto_load_preset == True: loadKey = data_model.Key(protocol.STRUCT_ID_COMMAND, protocol.MEMBER_ID_COMMAND, 0, protocol.cmdLoadPreset) if self.last_loaded_preset_no == val and mytime.clock() - self.last_loaded_preset_time < 10: print mytime.displayTime() + ' Skipping reload of same preset', val, 'last loaded', mytime.clock() - self.last_loaded_preset_time, 'seconds ago' else: self.last_loaded_preset_no = val self.last_loaded_preset_time = mytime.clock() print mytime.displayTime() + ' Auto loading preset', val counter = 100 while counter > 0 and self.parent.stopping == False: if self.parent.model.synced(key) == True: break mytime.sleep(0.1) counter -= 1 mytime.sleep(1) self.set_value(loadKey, 1) future.Future(1, self.set_value, loadKey, 0) counter = 100 while counter > 0 and self.parent.stopping == False: if self.parent.model.synced(loadKey) == True: break mytime.sleep(0.1) counter -= 1 mytime.sleep(1) self.parent.remote_link.LinkStatus = False self.parent.remote_link.ClearDataBuffer() for testkey in self.parent.remote_link.values.keys(): if testkey.struct_id != protocol.STRUCT_ID_COMMAND: del self.parent.remote_link.values[testkey] break self.parent.model.reset_get_list() self.check_redirect(key) self.updates = 0 return def update_controls(self, in_ctrl_name=None): self.update_control('link_status') if self.parent.loading_preset == True or self.parent.switching_skin == True or self.parent.init_done == False or self.parent.changing_view == True or one_unit.app.application_stopping == True or self.remote_link.Connected == False and self.parent.MAC[:4] not in ('DEMO', 'GRPdeactivated', 'VN::'): return else: if self.select_skin_to_current_user() == True: return if self.IsShownOnScreen() == False: return if self.full_screen_diagram == True: for ctrl_name in self.controls.keys(): if ctrl_name[-3:] == '_fs': self.update_control(ctrl_name) return if self.parent.MK2 == True: self.parent.refreshUIControls() self.parent.getAllUserBits() (accessrights, current_user) = self.parent.get_access() self.accessrights = accessrights self.current_user = current_user if in_ctrl_name == None: self.showSynchronizingBar() if len(self.controls) == 0: return for ctrl_name in self.controls: self.update_control(ctrl_name) self.peq_type_changed = False else: self.update_control(in_ctrl_name) return def register_gauge(self, client, key): if key == None: print mytime.displayTime() + ' None Key not registered!!' channel = self.key_with_current_channel(key).channel if channel not in self.parent.unit_channels and channel >= 0 and key.struct_id >= 0: print mytime.displayTime() + ' cp.rg.Unused channel:', key.channel return else: if key not in self.gauges.keys(): self.gauges[key] = [] self.gauges[key].append(client) return def update_gauge(self, key, val): if self.parent.mv_panel == True: return if self.IsShownOnScreen() == False: return if self.full_screen_diagram == True: return ignoreRender = int(mytime.clock() * 10) % 10 try: for gauge in self.gauges[key]: gauge.update(val, ignoreRender=ignoreRender) except: try: if key.channel == self.current_channel: mykey = data_model.Key(key.struct_id, key.member_id, -1, key.num) if mykey in self.gauges: for gauge in self.gauges[mykey]: gauge.update(val) else: if key.member_id > protocol.MEMBER_ID_GR_OUT: return mykey2 = data_model.Key(key.struct_id, key.member_id ^ 1, -1, key.num) if mykey2 in self.gauges: self.gauges[mykey] = self.gauges[mykey2] del self.gauges[mykey2] print mytime.displayTime() + ' Reset gauge', mykey2, 'to', mykey except: pass return def update_control_by_key(self, key): try: for ctrl_name in self.ctrl_keys[key]: if self.control_types[ctrl_name][-7:] != 'diagram': self.update_control(ctrl_name) if key.struct_id == protocol.STRUCT_ID_MUTE: for ctrl_name in self.controls: if self.control_types[ctrl_name] == 'gauge': self.update_control(ctrl_name) except: pass return def update_control(self, ctrl_name, force=False): try: (ctrl, key, var_name) = self.controls[ctrl_name] except: return if self.check_redirect(key) or self.parent.loading_preset == True: return else: if self.full_screen_diagram == True: if ctrl_name == 'diagram': print 'cp.refresh diagram' ctrl.Refresh() return section = self.name + '|' + str(self.current_channel) + '|' + ctrl_name if section in self.customElementKeys: if len(self.customElementKeys[section]) == 0: return key = self.customElementKeys[section][0] if self.control_types[ctrl_name] == 'gauge': if key.struct_id in (protocol.STRUCT_ID_VU, protocol.STRUCT_ID_GR): key = self.key_with_current_channel(data_model.Key(protocol.STRUCT_ID_MUTE, protocol.MEMBER_ID_MUTE, key.channel, 0)) val = self.parent.model.get(key) if val is None: return old_val = ctrl.is_muted() if old_val != val: ctrl.set_mute(val) ctrl.Refresh() return if ctrl_name.startswith('select_preset_'): key = data_model.Key(protocol.STRUCT_ID_PRESET_GLOBAL, protocol.MEMBER_ID_PRESET_NUMBER, 0, 0) val = self.parent.model.get(key) try: preset_number = int(ctrl_name.replace('select_preset_', '')) + 1 if preset_number == val: ctrl.set_state('on') else: ctrl.set_state('off') except: traceback.print_exc(file=sys.stdout) return if ctrl_name == 'about_text': val = self.parent.CreateAboutText(log=True) if val != ctrl.get_value(): ctrl.set_value(val) return if ctrl_name == 'check_password': val = ' ' if val != ctrl.get_value(): ctrl.set_value(val) return if self.control_types[ctrl_name] == 'memberList': try: val = {} for member in one_unit.app.groups[self.parent.group]: val[member] = one_unit.app.groups[self.parent.group][member][0] if val != ctrl.get_value(): ctrl.set_value(val) except: traceback.print_exc(file=sys.stdout) return if self.control_types[ctrl_name] == 'groupList': try: activeItemName = str(one_unit.app.group_names[self.parent.group]) except: activeItemName = None try: val = {} for group in one_unit.app.groups: if ctrl.filter != None: if one_unit.app.group_type[group] not in ctrl.filter: continue val[group] = one_unit.app.group_names[group] if val != ctrl.get_value() or activeItemName != ctrl.activeItemName: ctrl.activeItemName = activeItemName ctrl.set_value(val) except: traceback.print_exc(file=sys.stdout) return if ctrl_name == 'sleep' or ctrl_name == 'standby': try: key = data_model.Key(protocol.STRUCT_ID_GLOBAL, protocol.MEMBER_ID_HARDWARE_STATUS_FLAGS, 0, 0) val = self.parent.model.get(key) if val != None: val = int(val) if val & protocol.confStandby > 0: ctrl.set_state('on') else: ctrl.set_state('off') return except: pass if ctrl_name == 'link_status': old_state = ctrl.get_state() if self.remote_link.Connected == True: if self.parent.model.synced() == True and self.parent.model.completion() == 100: state = 'on' else: state = 'sync' else: state = 'off' if old_state != state: ctrl.set_state(state) self.svg_doc.set_element_render(ctrl.name) self.Refresh() return if ctrl_name == 'cs_button': return if ctrl_name == 'available_units': choices = {} for mac in self.parent.peers.units.keys(): if self.parent.peers.units[mac].type.count('_') > 2: continue name = self.parent.peers.units[mac].name if mac[:4] == 'DEMO': display_mac = 'Demo' else: display_mac = mac if mac == 'Startup...': continue name = name.strip() if name[-11:] == 'Development': choices[mac] = name elif name[-7:] == 'Factory': choices[mac] = name else: choices[mac] = name + ' (' + display_mac + ')' if choices != ctrl.get_choices(): ctrl.set_choices(choices) if ctrl.get_value() != self.parent.active_unit.MAC: ctrl.set_value(self.parent.active_unit.MAC) return if ctrl_name == 'recall_preset_list': ctrl_choices = ctrl.get_choices() choices = {} self.preset_names = {} for i in ctrl.sort_list: namekey = data_model.Key(protocol.STRUCT_ID_PRESET_GLOBAL, protocol.MEMBER_ID_SHORT_NAME, i, 0) name = self.parent.model.get(namekey) if name == None: name = 'None' if name.lower().strip() == 'empty preset': name = 'Empty' if name.find(self.parent.spk_lib_id) < 4 and name.find(self.parent.spk_lib_id) >= 0 and self.current_user > protocol.uDeveloper: continue self.preset_names[i] = name if self.parent.list_empty_presets == False and name.lower().find('empty') >= 0: continue if self.accessrights & protocol.arLoadEmptyPreset == 0 and self.accessrights & protocol.arSavePreset == 0 and name.lower().strip() in ('empty', 'empty preset'): continue if self.parent.show_preset_numbers == True: name = str(i) + ': ' + name if i == 0: name = ' ' choices[i] = name if choices != ctrl_choices: value = ctrl.get_value() if value == None: value = 0 ctrl.set_choices(choices) ctrl.set_value(value) if key == None: return val = self.parent.model.get(key) if val == None: return if val != ctrl.get_value(): ctrl.set_value(val) return if key is not None and key.struct_id in (protocol.STRUCT_ID_LPF, protocol.STRUCT_ID_HPF) and key.member_id == protocol.MEMBER_ID_TYPE and (key.channel >= 0 and key.channel < 128 or key.channel == -1 and self.current_channel >= 0 and self.current_channel < 128): try: if 39 in ctrl.choices: print mytime.displayTime(), 'cp.Removing 48dB filter option for input', key, var_name del ctrl.choices[39] except: pass if ctrl_name[:3] == 'cs_': if ctrl_name == self.csbutton: state = 'on' else: state = 'off' if self.csbutton in ('cs_auto_io', 'cs_in', 'cs_out'): if self.current_channel < 128: self.csbutton = 'cs_in' else: self.csbutton = 'cs_out' if self.csbutton[-11:] == '%outchannel' and ctrl_name[:self.csbutton.find('%')] == self.csbutton[:self.csbutton.find('%')] and int(ctrl_name[-1:]) + 127 == self.current_channel: state = 'on' elif self.csbutton[-10:] == '%inchannel' and ctrl_name[:self.csbutton.find('%')] == self.csbutton[:self.csbutton.find('%')] and int(ctrl_name[-1:]) - 1 == self.current_channel: state = 'on' elif self.csbutton.find('%') < 0: while ctrl_name[:5] == self.csbutton[:5]: if ctrl_name[3:5] == 'in' and len(self.csbutton) == 5: if self.current_channel == None: break testval = ord(ctrl_name[5]) - ord('a') - self.current_channel if testval == 0: state = 'on' break testval = ord(ctrl_name[5]) - ord('A') - self.current_channel if testval == 0: state = 'on' break testval = ord(ctrl_name[5]) - ord('1') - self.current_channel if testval == 0: state = 'on' break break if ctrl_name[3:6] == 'out' and len(self.csbutton) == 6: if self.current_channel == None: break testval = ord(ctrl_name[6]) - ord('A') - (self.current_channel - 128) if testval == 0: state = 'on' break testval = ord(ctrl_name[6]) - ord('a') - (self.current_channel - 128) if testval == 0: state = 'on' break testval = ord(ctrl_name[6]) - ord('1') - (self.current_channel - 128) if testval == 0: state = 'on' break break break if state == 'on': self.active_cs_button = ctrl if ctrl.get_state() != state or self.render_me(ctrl_name) == ctrl.hidden: ctrl.set_state(state, force=True) self.svg_doc.set_element_render(ctrl.name) return if hasattr(ctrl, 'set_values') and callable(ctrl.set_values): vals = ctrl.get_values() new_vals = {} for key in vals: new_key = self.key_with_current_channel(key) if new_key.channel not in self.parent.unit_channels: continue val = self.parent.model.get(new_key) if val != vals[key]: self.svg_doc.set_element_render(ctrl.name) new_vals[key] = val self.index = key.num if len(new_vals) > 0: ctrl.set_values(new_vals) ctrl.Refresh() return if key is None: return try: if self.peq_type_changed == True and key.struct_id == protocol.STRUCT_ID_PEQ and key.member_id == protocol.MEMBER_ID_Q: if ctrl.variable_num == True: key = self.key_with_current_index(key) key = self.key_with_current_channel(key) self.show_q_or_bw(1, ctrl, key) except: pass try: if ctrl.variable_num == True: key = self.key_with_current_index(key) for ctrl_name in self.controls: if ctrl_name.find('edit') == 0: num = int(ctrl_name[5:]) (edit_ctrl, edit_key, edit_var) = self.controls[ctrl_name] if num == self.index: self.active_index_button = edit_ctrl if edit_ctrl.get_state() != 'on': edit_ctrl.set_state('on') elif edit_ctrl.get_state() != 'off': edit_ctrl.set_state('off') except: pass if ctrl_name[:12] == 'xv_knob_freq' and self.remote_link.last_xover_key is not None: key = data_model.Key(self.remote_link.last_xover_key.struct_id, key.member_id, key.channel, key.num) if ctrl_name[:8] == 'peq_knob' and self.remote_link.last_peq_key is not None: key = data_model.Key(key.struct_id, key.member_id, key.channel, self.remote_link.last_peq_key.num) key = self.key_with_current_channel(key) if key.channel is None or key.channel < 0: return if key.struct_id == protocol.STRUCT_ID_INTERNAL: val = self.parent.model.get_internal(key) else: val = self.parent.model.get(key) if ctrl_name in fixed_vars_list.keys(): val = eval(fixed_vars_list[ctrl_name]) if key.struct_id == protocol.STRUCT_ID_CHANNEL and key.member_id == protocol.MEMBER_ID_SHORT_NAME: try: val = val[:16 - self.parent.channel_name_split] except: val = None if val is None and var_name is not None: try: val = self.config.get(var_name, 'default_value') except: val = 0 else: try: val = float(val) except: pass else: self.parent.model.set_default(key, val) if val is not None: if key.member_id == protocol.MEMBER_ID_Q: val = self.show_q_or_bw(val, ctrl, key) peq_type = self.parent.model.get(data_model.Key(protocol.STRUCT_ID_PEQ, protocol.MEMBER_ID_TYPE, key.channel, key.num)) if peq_type == protocol.fNOTCH: if self.parent.model.get(data_model.Key(protocol.STRUCT_ID_INTERNAL, protocol.MEMBER_ID_Q_BW, 0, 0)) == 1: if val < 0.01: val = 0.01 if val > 1.0: val = 1.0 else: if val > 80.0: val = 80.0 if val < 10.0: val = 10.0 if peq_type in (protocol.fLowPass, protocol.fHighPass): if self.parent.model.get(data_model.Key(protocol.STRUCT_ID_INTERNAL, protocol.MEMBER_ID_Q_BW, 0, 0)) == 1: if val < 0.71: val = 0.71 if val > 2.54: val = 2.54 else: if val > 2.0: val = 2.0 if val < 0.5: val = 0.5 if key.struct_id == protocol.STRUCT_ID_PEQ and key.member_id == protocol.MEMBER_ID_GAIN: peq_type = self.parent.model.get(data_model.Key(protocol.STRUCT_ID_PEQ, protocol.MEMBER_ID_TYPE, key.channel, key.num)) if peq_type in (protocol.fNOTCH, protocol.fAllpass, protocol.fHighPass, protocol.fLowPass, protocol.fBandPass): try: if val != 0: self.set_value(key, 0) val = '--' except: traceback.print_exc(file=sys.stdout) old_val = ctrl.get_value() try: mask_val = ctrl.mask_val val = int(val) if mask_val == 0: if val == 0: val = 'on' else: val = 'off' elif val & ctrl.mask == mask_val: val = 'on' else: val = 'off' except: pass else: if old_val != val or force == True: ctrl.set_value(val) self.svg_doc.set_element_render(ctrl.name) return def key_with_current_channel(self, key): if key == None: return else: try: if key.channel < 0: key = data_model.Key(key.struct_id, key.member_id, self.current_channel, key.num) return key except: calframe = inspect.getouterframes(inspect.currentframe(), 2) print mytime.displayTime(), 'cp.kwcc.Failed to get key with current channel for panel', self.name, 'key', key, 'called from', calframe[2][3], calframe[1][3], calframe[0][3] return return def key_with_current_index(self, key): key = data_model.Key(key.struct_id, key.member_id, key.channel, self.index) return key def key_with_prototype_channel(self, key): key = data_model.Key(key.struct_id, key.member_id, -1, key.num) return key def update_from_remote_link(self, ctrl): try: val = self.parent.model.get(self.key_with_current_channel(ctrl.key)) return val except: return -1000 return def create_slider(self, config, section, ctrl_name): try: max_name = config.get(section, ctrl_name + '_max_label') except: max_name = ctrl_name + '_max' try: min_name = config.get(section, ctrl_name + '_min_label') except: min_name = ctrl_name + '_min' res = svg_panel.Slider(self, ctrl_name, max_name, min_name) return res def create_knob(self, config, section, ctrl_name): res = svg_panel.Knob(ctrl_name) return res def create_label(self, config, section, ctrl_name): return self.create_text(config, section, ctrl_name, write_protect=True) def create_text(self, config, section, ctrl_name, write_protect=False): units = '' try: var_name = config.get(section, ctrl_name + '_value') units = config.get(var_name, 'units').lower() if units == 'ppm' and var_name.find('delay') >= 0: self.delay_unit = 'ppm' print mytime.displayTime(), 'Set self.delay_unit to ppm' except: pass try: my_unit = config.get(section, ctrl_name + '_unit') my_unit = my_unit.replace('"', '') my_unit = my_unit.replace("'", '') except: my_unit = '' try: member_id = int(config.get(var_name, 'member_id')) if protocol.get_member_format(member_id)[-1:] == 's': my_unit = 'string' except: pass try: struct_id = int(config.get(var_name, 'struct_id')) if struct_id in (protocol.STRUCT_ID_COMPRESSOR, protocol.STRUCT_ID_LIMITER) and member_id in (protocol.MEMBER_ID_ATTACK, protocol.MEMBER_ID_RELEASE, protocol.MEMBER_ID_HOLD): units = 'comp_ms' except: pass try: align = config.get(section, ctrl_name + '_align') except: align = 'centre' try: multiline = eval(config.get(section, ctrl_name + '_multiline')) except: multiline = False my_style = wx.BORDER_NONE | wx.TE_PROCESS_ENTER if align == 'left': my_style |= wx.TE_LEFT if align == 'right': my_style |= wx.TE_RIGHT if align == 'centre': my_style |= wx.TE_CENTRE if multiline == True: autoresize = False my_style |= wx.TE_MULTILINE | wx.TE_NO_VSCROLL else: autoresize = True font_size = self.font_size try: font_size = int(self.font_sizes[ctrl_name]) except: pass text_colour = self.default_text_colour try: text_colour = eval(self.font_colours[ctrl_name]) except: pass val_type = svg_panel.TextValueCtrl.VAL_ANY if units in ('db', 'dB', 'dBu', 'dBV'): val_type = svg_panel.TextValueCtrl.VAL_DB elif units == 'comp_ms': val_type = svg_panel.TextValueCtrl.VAL_COMP_MS my_unit = 'ms' elif units == 'ms': val_type = svg_panel.TextValueCtrl.VAL_DELAY elif units in ('hz', 'Hz'): val_type = svg_panel.TextValueCtrl.VAL_FREQ elif units == 'float': val_type = svg_panel.TextValueCtrl.VAL_FLOAT res = svg_panel.TextValueCtrl(parent=self, name=ctrl_name, value_type=val_type, style=my_style, visible_unit=my_unit, custom_colours=self.custom_colours, default_text_colour=text_colour, write_protect=write_protect, pix=font_size, autoresize=autoresize) return res def create_gauge(self, config, section, ctrl_name): var_name = 'var for ' + ctrl_name try: var_name = config.get(section, ctrl_name + '_value') try: text_location = eval(config.get(section, ctrl_name + '_text_location')) except: text_location = (10, 4) struct_id = config.getint(var_name, 'struct_id') member_id = config.getint(var_name, 'member_id') except: try: for s in var_name.split('_'): v = int(s) except: print mytime.displayTime(), 'Data member definition ', var_name, ' not found or corrupted' traceback.print_exc(file=sys.stdout) try: channel = int(config.get(var_name, 'channel'), 0) except ConfigParser.NoOptionError: channel = -1 num = config.getint(var_name, 'num') key = data_model.Key(struct_id, member_id, channel, num) res = svg_panel.Color_gauge(parent=self, update_func=self.update_from_remote_link, name=ctrl_name) res.key = key led_spacing = self.vu_led_spacing led_size = self.vu_led_size led_shape = self.vu_led_shape if ctrl_name[:5] in ('gr_in', 'gr_ou'): values = self.gr_led_values yellow = self.gr_yellow red = self.gr_red led_spacing = self.gr_led_spacing led_size = self.gr_led_size led_shape = self.gr_led_shape elif ctrl_name[:5] == 'vu_in': values = self.vu_in_led_values yellow = self.vu_in_yellow red = self.vu_in_red elif ctrl_name == 'level_vu': values = None yellow = self.vu_out_yellow red = self.vu_out_red elif ctrl_name == 'level_gr': values = None yellow = 0 red = self.vu_out_red elif ctrl_name == 'level_pwr': values = None yellow = self.vu_pwr_yellow red = self.vu_pwr_red else: values = self.vu_out_led_values yellow = self.vu_out_yellow red = self.vu_out_red res.set_style(style='leds', led_shape=led_shape, led_spacing=led_spacing, led_size=led_size, yellow=yellow, red=red, grey_on_mute=self.vu_grey_on_mute, led_values=values, text_location=text_location, bg_colour=self.vu_bg_colour, default_text_colour=(0, 0, 0)) return res def create_toggle_button(self, config, section, ctrl_name): res = svg_panel.ToggleButton(self, ctrl_name) return res def create_button(self, config, section, ctrl_name): res = svg_panel.Button(self, ctrl_name) return res def create_PEQ_diagram(self, config, section, ctrl_name): try: res = diagram.PEQ_diagram(parent=self, config=config, section=section, name=ctrl_name, max_freq=self.peq_max_freq) return res except: traceback.print_exc(file=sys.stdout) return return def create_XV_diagram(self, config, section, ctrl_name): res = diagram.XV_diagram(parent=self, config=config, section=section, name=ctrl_name) return res def create_choice(self, config, section, ctrl_name): var_name = config.get(section, ctrl_name + '_value') choices = {} if var_name == 'recall_preset': try: min_value = int(config.get(var_name, 'min_value')) except: min_value = 0 else: try: max_value = int(config.get(var_name, 'max_value')) except: max_value = 1 else: choices = {} sort_list = [] for i in range(min_value, max_value + 1): sort_list.append(i) else: values = config.get(var_name, 'values') values = [_[1] for s in values.split(',')] labels = config.get(var_name, 'labels') labels = [_[2] for s in labels.split(',')] try: sort_list = config.get(var_name, 'sort_list') sort_list = [_[3] for s in sort_list.split(',')] except: sort_list = values for i in range(len(values)): choices[values[i]] = labels[i] font_size = self.font_size try: font_size = int(self.font_sizes[ctrl_name]) except: pass text_colour = self.default_text_colour try: text_colour = eval(self.font_colours[ctrl_name]) except: pass res = svg_panel.Choice(parent=self, choices=choices, name=ctrl_name, sort_list=sort_list, pix=font_size, default_text_colour=text_colour, custom_colours=self.custom_colours) return res def create_available_units(self, config, section, ctrl_name): my_choices = {} font_size = self.font_size try: font_size = int(self.font_sizes[ctrl_name]) except: pass text_colour = self.default_text_colour try: text_colour = eval(self.font_colours[ctrl_name]) except: pass for mac in self.parent.peers.units.keys(): my_choices[mac] = self.parent.peers.units[mac].name res = svg_panel.Choice(parent=self, choices=my_choices, name=ctrl_name, pix=font_size, default_text_colour=text_colour, custom_colours=self.custom_colours) return res def create_delay_unit(self, config, section, ctrl_name): try: choices = eval(self.config.get(self.name, 'delay_unit_choices')) except: choices = {'ms': 'ms', 's': 's', 'mm': 'mm', 'm': 'm', 'mil': 'mil', 'inch': 'inch', 'feet': 'feet'} font_size = self.font_size try: font_size = int(self.font_sizes[ctrl_name]) except: pass text_colour = self.default_text_colour try: text_colour = eval(self.font_colours[ctrl_name]) except: pass res = svg_panel.Choice(parent=self, choices=choices, name=ctrl_name, pix=font_size, default_text_colour=text_colour, custom_colours=self.custom_colours) res.set_value('ms') return res def create_indicator(self, config, section, ctrl_name): condition = config.get(section, ctrl_name + '_condition') res = svg_panel.Indicator(ctrl_name, condition, config, section) return res def createItemList(self, config, section, ctrl_name): try: settings = eval(config.get(section, ctrl_name + '_settings')) except: traceback.print_exc(file=sys.stdout) settings = {} try: scroll = settings['scroll'] except: scroll = True my_style = wx.BORDER_NONE | wx.TE_PROCESS_ENTER try: align = settings['align'] except: align = 'left' if align == 'left': my_style |= wx.TE_LEFT if align == 'right': my_style |= wx.TE_RIGHT if align in ('centre', 'center'): my_style |= wx.TE_CENTRE if scroll == True: autoresize = False my_style |= wx.TE_MULTILINE | wx.TE_NO_VSCROLL else: autoresize = True my_style |= wx.TE_MULTILINE | wx.TE_NO_VSCROLL font_size = self.font_size try: font_size = int(self.font_sizes[ctrl_name]) except: pass text_colour = self.default_text_colour try: text_colour = eval(self.font_colours[ctrl_name]) except: pass val_type = svg_panel.TextValueCtrl.VAL_ANY try: res = svg_panel.itemList(parent=self, name=ctrl_name, value_type=val_type, style=my_style, visible_unit='', custom_colours=self.custom_colours, default_text_colour=text_colour, write_protect=True, pix=font_size, autoresize=autoresize, itemList={}, settings=settings) print mytime.displayTime() + ' Created member list:', ctrl_name except: traceback.print_exc(file=sys.stdout) res = None return res def reset_peq(self, num): struct_id = protocol.STRUCT_ID_PEQ member_id = protocol.MEMBER_ID_GAIN channel = self.current_channel key = data_model.Key(struct_id, member_id, channel, num) self.set_value(key, 0) struct_id = protocol.STRUCT_ID_PEQ member_id = protocol.MEMBER_ID_ON channel = self.current_channel key = data_model.Key(struct_id, member_id, channel, num) self.set_value(key, 0) return # okay decompiling pycode/control_panel.pyc