Mercurial > code > home > repos > light9

comparison light8/Subs.py @ 0:45b12307c695

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Initial revision
author drewp
date Wed, 03 Jul 2002 09:37:57 +0000
parents
children f974a462133f
comparison
equal deleted inserted replaced
-1:000000000000 0:45b12307c695
1 from Patch import *
2 from time import time
3 from Tix import *
4 from types import TupleType
5
6 stdfont = ('Arial', 8)
7
8 class Param: # abstract
9 def get_value(self):
10 pass
11 def set_value(self, v):
12 pass
13 def draw_tk(self, frame):
14 pass
15 def __getstate__(self):
16 return {'value' : self.get_value()}
17 def __setstate__(self, dict):
18 self.value = StringVar()
19 self.set_value(dict['value'])
20
21 class CheckboxParam(Param):
22 def __init__(self, initial=0):
23 self.value = IntVar()
24 self.value.set(initial)
25 def get_value(self):
26 return self.value.get()
27 def draw_tk(self, frame):
28 self.c = Checkbutton(frame, variable=self.value)
29 self.c.pack()
30
31 class SliderParam(Param):
32 def __init__(self, range=(0, 1), res=0.01, initial=0, orient='v',
33 **options):
34 self.value = DoubleVar()
35 self.value.set(initial)
36 self.options = {'res' : res, 'to' : range[0], 'from' : range[1],
37 'orient' : orient,
38 'font' : stdfont, 'length' : 50, 'sliderlength' : 10,
39 'width' : 10}
40 self.options.update(options)
41 def get_value(self):
42 return self.value.get()
43 def draw_tk(self, frame):
44 s = Scale(frame, variable=self.value, **self.options)
45 s.pack()
46
47 class TextParam(Param):
48 def __init__(self, initial=''):
49 self.value = StringVar()
50 self.value.set(initial)
51 def get_value(self):
52 return self.value.get()
53 def select_all(self, evt):
54 self.e.select_range(0, END)
55 def unfocus(self, evt):
56 self.frame.focus()
57 def draw_tk(self, frame):
58 self.frame = frame
59 self.e = Entry(frame, textvariable=self.value)
60 self.e.bind("<Return>", self.unfocus)
61 self.e.pack()
62
63 class ListParam(Param):
64 def __init__(self, options=(), multiple=0, initial=''):
65 self.value = StringVar()
66 self.value.set(initial)
67 self.options = options
68 if multiple:
69 self.selectmode = 'MULTIPLE'
70 else:
71 self.selectmode = 'SINGLE'
72 def get_value(self):
73 try:
74 return self.l.get(self.l.curselection())
75 except:
76 return ''
77 def draw_tk(self, frame):
78 self.l = Listbox(frame, selectmode=self.selectmode, font=stdfont,
79 width=max([len(o) for o in self.options]),
80 height=len(self.options), exportselection=0)
81 for o in self.options:
82 self.l.insert(END, o)
83 self.l.pack()
84
85 class LabelParam(Param):
86 def __init__(self, initial=''):
87 self.value = StringVar()
88 self.value.set(initial)
89 def get_value(self):
90 return self.value.get()
91 def set_value(self, v):
92 if 'value' not in self.__dict__:
93 self.value = StringVar()
94 self.value.set(v)
95 def draw_tk(self, frame):
96 l = Label(frame, textvariable=self.value, font=stdfont)
97 l.pack()
98
99 class ButtonParam(Param):
100 def __init__(self, text, **options):
101 self.options = {'text' : text}
102 self.options.update(options)
103 self.pressed = 0
104 self.unread = 0 # unread button presses
105 def draw_tk(self, frame):
106 b = Button(frame, **self.options)
107 b.pack()
108 b.bind('<ButtonPress>', self.activate)
109 b.bind('<ButtonRelease>', self.deactivate)
110 def get_value(self):
111 if self.unread:
112 self.unread = 0
113 return 1
114
115 return self.pressed
116 def activate(self, evt):
117 self.pressed = 1
118 self.unread = 1
119 def deactivate(self, evt):
120 self.pressed = 0
121
122 class Params:
123 def __init__(self):
124 self.params = {}
125 def add_param(self, name, param):
126 self.params[name] = param
127 def get_param_value(self, name):
128 return self.params[name].get_value()
129 def __getitem__(self, name):
130 return self.params[name].get_value()
131 def __setitem__(self, name, value):
132 self.params[name].set_value(value)
133 def draw_tk(self, frame):
134 for name,param in self.params.items():
135 f = Frame(frame)
136 l = Label(f, text=name, font=stdfont)
137 l.pack(side='left')
138 pframe = Frame(f)
139 param.draw_tk(pframe)
140 pframe.pack(side='right')
141 f.pack()
142
143 class SliderAdjuster:
144 def __init__(self):
145 self.var = None
146 self.atzero = 0
147 def set(self, level):
148 if self.var is not None:
149 self.var.set(level)
150 def get(self, level):
151 if self.var is not None:
152 return self.var.get()
153 return None
154 def justturnedon(self):
155 return self.atzero
156 def __getstate__(self):
157 state = self.__dict__.copy()
158 # remove var (non-pickleable)
159 try:
160 del state['var']
161 except KeyError:
162 pass
163 return state
164 # no setstate needed
165
166 class Sub:
167 def __init__(self, name, levels, dimmers=68, color=None):
168 self.name = name # keep this consistent please
169 self.levels = levels
170 self.dimmers = dimmers # needed?
171 self.is_effect = callable(self.levels)
172 self.slideradjuster = SliderAdjuster()
173 self.namecache = {}
174 if self.is_effect:
175 self.params = Params()
176 self.generator = self.levels(self.params, self.slideradjuster)
177 self.generator.next()
178 self.color = color
179 def resolve_name(self, ch_name):
180 if ch_name in self.namecache:
181 return self.namecache[ch_name]
182 else:
183 resolved = get_dmx_channel(ch_name)
184 self.namecache[ch_name] = resolved
185 return resolved
186 def set_slider_var(self, slidervar):
187 if self.is_effect:
188 self.slideradjuster.var = slidervar
189 def draw_tk(self, frame):
190 if self.is_effect:
191 self.params.draw_tk(frame)
192 def get_state(self):
193 state = self.__dict__.copy()
194 if self.is_effect:
195 del state['levels']
196 del state['generator']
197
198 return state
199 def set_state(self, statedict):
200 self.__dict__.update(statedict)
201 def get_levels(self, level):
202 """returns a scaled version of the levels in the sub; channel names
203 are resolved to numbers"""
204 d = {}
205 if level == 0:
206 self.slideradjuster.atzero = 1
207 return d
208 if self.is_effect: # effect
209 d = self.generator.next()
210 self.slideradjuster.atzero = 0
211 return dict([(get_dmx_channel(ch), float(lev) * float(level))
212 for ch, lev in d.items()])
213 else: # dictionary (standard)
214 d = self.levels
215 return dict([(self.resolve_name(ch), float(lev) * float(level))
216 for ch, lev in d.items()])
217
218 #
219 # methods for Subediting to use
220 #
221 def getlevels(self):
222 return self.levels.copy()
223 def reviselevels(self,levels):
224 # we can accept these new levels; subediting has done all the work
225 self.levels.update(levels)
226
227
228
229 def reload_data(dummy):
230 global subs, cues
231 if dummy:
232 import ConfigDummy as Config
233 else:
234 import Config
235
236 reload(Config)
237
238 subs = {}
239 for name, levels in Config.subs.items():
240 if type(name) == TupleType:
241 name, color = name
242 else:
243 color = None
244
245 subs[name] = Sub(name, levels, color=color)
246
247 # subs = dict([(name, Sub(levels)) for name, levels in Config.subs.items()])
248
249 cues = Config.cues
250
251 def longestsubname():
252 return max([len(x) for x in subs.keys()])