from Patch import * from time import time from Tix import * from types import TupleType stdfont = ('Arial', 8) class Param: # abstract def get_value(self): pass def set_value(self, v): pass def draw_tk(self, frame): pass def __getstate__(self): return {'value' : self.get_value()} def __setstate__(self, dict): self.value = StringVar() self.set_value(dict['value']) class CheckboxParam(Param): def __init__(self, initial=0): self.value = IntVar() self.value.set(initial) def get_value(self): return self.value.get() def draw_tk(self, frame): self.c = Checkbutton(frame, variable=self.value) self.c.pack() class SliderParam(Param): def __init__(self, range=(0, 1), res=0.01, initial=0, orient='v', **options): self.value = DoubleVar() self.value.set(initial) self.options = {'res' : res, 'to' : range[0], 'from' : range[1], 'orient' : orient, 'font' : stdfont, 'length' : 50, 'sliderlength' : 10, 'width' : 10} self.options.update(options) def get_value(self): return self.value.get() def draw_tk(self, frame): s = Scale(frame, variable=self.value, **self.options) s.pack() class TextParam(Param): def __init__(self, initial=''): self.value = StringVar() self.value.set(initial) def get_value(self): return self.value.get() def select_all(self, evt): self.e.select_range(0, END) def unfocus(self, evt): self.frame.focus() def draw_tk(self, frame): self.frame = frame self.e = Entry(frame, textvariable=self.value) self.e.bind("", self.unfocus) self.e.pack() class ListParam(Param): def __init__(self, options=(), multiple=0, initial=''): self.value = StringVar() self.value.set(initial) self.options = options if multiple: self.selectmode = 'MULTIPLE' else: self.selectmode = 'SINGLE' def get_value(self): try: return self.l.get(self.l.curselection()) except: return '' def draw_tk(self, frame): self.l = Listbox(frame, selectmode=self.selectmode, font=stdfont, width=max([len(o) for o in self.options]), height=len(self.options), exportselection=0) for o in self.options: self.l.insert(END, o) self.l.pack() class LabelParam(Param): def __init__(self, initial=''): self.value = StringVar() self.value.set(initial) def get_value(self): return self.value.get() def set_value(self, v): if 'value' not in self.__dict__: self.value = StringVar() self.value.set(v) def draw_tk(self, frame): l = Label(frame, textvariable=self.value, font=stdfont) l.pack() class ButtonParam(Param): def __init__(self, text, **options): self.options = {'text' : text} self.options.update(options) self.pressed = 0 self.unread = 0 # unread button presses def draw_tk(self, frame): b = Button(frame, **self.options) b.pack() b.bind('', self.activate) b.bind('', self.deactivate) def get_value(self): if self.unread: self.unread = 0 return 1 return self.pressed def activate(self, evt): self.pressed = 1 self.unread = 1 def deactivate(self, evt): self.pressed = 0 class Params: def __init__(self): self.params = {} def add_param(self, name, param): self.params[name] = param def get_param_value(self, name): return self.params[name].get_value() def __getitem__(self, name): return self.params[name].get_value() def __setitem__(self, name, value): self.params[name].set_value(value) def draw_tk(self, frame): for name,param in self.params.items(): f = Frame(frame) l = Label(f, text=name, font=stdfont) l.pack(side='left') pframe = Frame(f) param.draw_tk(pframe) pframe.pack(side='right') f.pack() class SliderAdjuster: def __init__(self): self.var = None self.atzero = 0 def set(self, level): if self.var is not None: self.var.set(level) def get(self, level): if self.var is not None: return self.var.get() return None def justturnedon(self): return self.atzero def __getstate__(self): state = self.__dict__.copy() # remove var (non-pickleable) try: del state['var'] except KeyError: pass return state # no setstate needed class Sub: def __init__(self, name, levels, dimmers=68, color=None): self.name = name # keep this consistent please self.levels = levels self.dimmers = dimmers # needed? self.is_effect = callable(self.levels) self.slideradjuster = SliderAdjuster() self.namecache = {} if self.is_effect: self.params = Params() self.generator = self.levels(self.params, self.slideradjuster) self.generator.next() self.color = color def resolve_name(self, ch_name): if ch_name in self.namecache: return self.namecache[ch_name] else: resolved = get_dmx_channel(ch_name) self.namecache[ch_name] = resolved return resolved def set_slider_var(self, slidervar): if self.is_effect: self.slideradjuster.var = slidervar def draw_tk(self, frame): if self.is_effect: self.params.draw_tk(frame) def get_state(self): state = self.__dict__.copy() if self.is_effect: del state['levels'] del state['generator'] return state def set_state(self, statedict): self.__dict__.update(statedict) def get_levels(self, level): """returns a scaled version of the levels in the sub; channel names are resolved to numbers""" d = {} if level == 0: self.slideradjuster.atzero = 1 return d if self.is_effect: # effect d = self.generator.next() self.slideradjuster.atzero = 0 return dict([(get_dmx_channel(ch), float(lev) * float(level)) for ch, lev in d.items()]) else: # dictionary (standard) d = self.levels return dict([(self.resolve_name(ch), float(lev) * float(level)) for ch, lev in d.items()]) # # methods for Subediting to use # def getlevels(self): return self.levels.copy() def reviselevels(self,levels): # we can accept these new levels; subediting has done all the work self.levels.update(levels) def reload_data(dummy): global subs, cues if dummy: import ConfigDummy as Config else: import Config reload(Config) subs = {} for name, levels in Config.subs.items(): if type(name) == TupleType: name, color = name else: color = None subs[name] = Sub(name, levels, color=color) # subs = dict([(name, Sub(levels)) for name, levels in Config.subs.items()]) cues = Config.cues def longestsubname(): return max([len(x) for x in subs.keys()])