--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/light8/Subs.py	Wed Jul 03 09:37:57 2002 +0000
@@ -0,0 +1,252 @@
+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("<Return>", 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('<ButtonPress>', self.activate)
+        b.bind('<ButtonRelease>', 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()])