|
0
|
1 from Patch import *
|
|
|
2 from time import time
|
|
4
|
3 from Tkinter import *
|
|
0
|
4 from types import TupleType
|
|
|
5
|
|
|
6 stdfont = ('Arial', 8)
|
|
|
7
|
|
|
8 class Param: # abstract
|
|
|
9 def get_value(self):
|
|
|
10 pass
|
|
28
|
11 def set_value(self, v):
|
|
0
|
12 pass
|
|
|
13 def draw_tk(self, frame):
|
|
|
14 pass
|
|
28
|
15 def __getstate__(self):
|
|
|
16 print "get_state:", self.get_value()
|
|
|
17 return {'value' : self.get_value()}
|
|
|
18 def __setstate__(self, dict):
|
|
|
19 print "set_state to", dict
|
|
|
20 self.value = StringVar()
|
|
|
21 self.set_value(dict['value'])
|
|
0
|
22
|
|
|
23 class CheckboxParam(Param):
|
|
|
24 def __init__(self, initial=0):
|
|
|
25 self.value = IntVar()
|
|
|
26 self.value.set(initial)
|
|
|
27 def get_value(self):
|
|
|
28 return self.value.get()
|
|
|
29 def draw_tk(self, frame):
|
|
|
30 self.c = Checkbutton(frame, variable=self.value)
|
|
|
31 self.c.pack()
|
|
|
32
|
|
|
33 class SliderParam(Param):
|
|
|
34 def __init__(self, range=(0, 1), res=0.01, initial=0, orient='v',
|
|
|
35 **options):
|
|
|
36 self.value = DoubleVar()
|
|
|
37 self.value.set(initial)
|
|
|
38 self.options = {'res' : res, 'to' : range[0], 'from' : range[1],
|
|
|
39 'orient' : orient,
|
|
|
40 'font' : stdfont, 'length' : 50, 'sliderlength' : 10,
|
|
|
41 'width' : 10}
|
|
|
42 self.options.update(options)
|
|
|
43 def get_value(self):
|
|
|
44 return self.value.get()
|
|
|
45 def draw_tk(self, frame):
|
|
|
46 s = Scale(frame, variable=self.value, **self.options)
|
|
|
47 s.pack()
|
|
|
48
|
|
|
49 class TextParam(Param):
|
|
|
50 def __init__(self, initial=''):
|
|
|
51 self.value = StringVar()
|
|
|
52 self.value.set(initial)
|
|
|
53 def get_value(self):
|
|
|
54 return self.value.get()
|
|
|
55 def select_all(self, evt):
|
|
|
56 self.e.select_range(0, END)
|
|
|
57 def unfocus(self, evt):
|
|
|
58 self.frame.focus()
|
|
|
59 def draw_tk(self, frame):
|
|
|
60 self.frame = frame
|
|
|
61 self.e = Entry(frame, textvariable=self.value)
|
|
|
62 self.e.bind("<Return>", self.unfocus)
|
|
|
63 self.e.pack()
|
|
|
64
|
|
|
65 class ListParam(Param):
|
|
|
66 def __init__(self, options=(), multiple=0, initial=''):
|
|
|
67 self.value = StringVar()
|
|
|
68 self.value.set(initial)
|
|
|
69 self.options = options
|
|
|
70 if multiple:
|
|
|
71 self.selectmode = 'MULTIPLE'
|
|
|
72 else:
|
|
|
73 self.selectmode = 'SINGLE'
|
|
|
74 def get_value(self):
|
|
|
75 try:
|
|
|
76 return self.l.get(self.l.curselection())
|
|
|
77 except:
|
|
|
78 return ''
|
|
|
79 def draw_tk(self, frame):
|
|
|
80 self.l = Listbox(frame, selectmode=self.selectmode, font=stdfont,
|
|
|
81 width=max([len(o) for o in self.options]),
|
|
21
|
82 height=len(self.options), exportselection=0)
|
|
0
|
83 for o in self.options:
|
|
|
84 self.l.insert(END, o)
|
|
|
85 self.l.pack()
|
|
|
86
|
|
|
87 class LabelParam(Param):
|
|
|
88 def __init__(self, initial=''):
|
|
|
89 self.value = StringVar()
|
|
|
90 self.value.set(initial)
|
|
|
91 def get_value(self):
|
|
|
92 return self.value.get()
|
|
|
93 def set_value(self, v):
|
|
28
|
94 if 'value' not in self.__dict__:
|
|
|
95 self.value = StringVar()
|
|
0
|
96 self.value.set(v)
|
|
|
97 def draw_tk(self, frame):
|
|
|
98 l = Label(frame, textvariable=self.value, font=stdfont)
|
|
|
99 l.pack()
|
|
|
100
|
|
|
101 class ButtonParam(Param):
|
|
|
102 def __init__(self, text, **options):
|
|
|
103 self.options = {'text' : text}
|
|
|
104 self.options.update(options)
|
|
|
105 self.pressed = 0
|
|
|
106 self.unread = 0 # unread button presses
|
|
|
107 def draw_tk(self, frame):
|
|
|
108 b = Button(frame, **self.options)
|
|
|
109 b.pack()
|
|
|
110 b.bind('<ButtonPress>', self.activate)
|
|
|
111 b.bind('<ButtonRelease>', self.deactivate)
|
|
|
112 def get_value(self):
|
|
|
113 if self.unread:
|
|
|
114 self.unread = 0
|
|
|
115 return 1
|
|
|
116
|
|
|
117 return self.pressed
|
|
|
118 def activate(self, evt):
|
|
|
119 self.pressed = 1
|
|
|
120 self.unread = 1
|
|
|
121 def deactivate(self, evt):
|
|
|
122 self.pressed = 0
|
|
|
123
|
|
|
124 class Params:
|
|
|
125 def __init__(self):
|
|
|
126 self.params = {}
|
|
|
127 def add_param(self, name, param):
|
|
|
128 self.params[name] = param
|
|
|
129 def get_param_value(self, name):
|
|
|
130 return self.params[name].get_value()
|
|
|
131 def __getitem__(self, name):
|
|
|
132 return self.params[name].get_value()
|
|
|
133 def __setitem__(self, name, value):
|
|
|
134 self.params[name].set_value(value)
|
|
|
135 def draw_tk(self, frame):
|
|
|
136 for name,param in self.params.items():
|
|
|
137 f = Frame(frame)
|
|
|
138 l = Label(f, text=name, font=stdfont)
|
|
|
139 l.pack(side='left')
|
|
|
140 pframe = Frame(f)
|
|
|
141 param.draw_tk(pframe)
|
|
|
142 pframe.pack(side='right')
|
|
|
143 f.pack()
|
|
|
144
|
|
|
145 class SliderAdjuster:
|
|
|
146 def __init__(self):
|
|
|
147 self.var = None
|
|
|
148 self.atzero = 0
|
|
|
149 def set(self, level):
|
|
|
150 if self.var is not None:
|
|
|
151 self.var.set(level)
|
|
|
152 def get(self, level):
|
|
|
153 if self.var is not None:
|
|
|
154 return self.var.get()
|
|
|
155 return None
|
|
|
156 def justturnedon(self):
|
|
|
157 return self.atzero
|
|
28
|
158 def __getstate__(self):
|
|
|
159 state = self.__dict__.copy()
|
|
|
160 # remove var (non-pickleable)
|
|
|
161 try:
|
|
|
162 del state['var']
|
|
|
163 except KeyError:
|
|
|
164 pass
|
|
|
165 return state
|
|
|
166 # no setstate needed
|
|
0
|
167
|
|
|
168 class Sub:
|
|
4
|
169 def __init__(self, levels, dimmers=68, color=None):
|
|
0
|
170 self.levels = levels
|
|
28
|
171 self.dimmers = dimmers # needed?
|
|
0
|
172 self.is_effect = callable(self.levels)
|
|
|
173 self.slideradjuster = SliderAdjuster()
|
|
|
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 set_slider_var(self, slidervar):
|
|
|
180 if self.is_effect:
|
|
|
181 self.slideradjuster.var = slidervar
|
|
|
182 def draw_tk(self, frame):
|
|
|
183 if self.is_effect:
|
|
|
184 self.params.draw_tk(frame)
|
|
|
185 def get_state(self):
|
|
28
|
186 state = self.__dict__.copy()
|
|
|
187 if self.is_effect:
|
|
|
188 del state['levels']
|
|
|
189 del state['generator']
|
|
|
190
|
|
|
191 return state
|
|
|
192 def set_state(self, statedict):
|
|
|
193 self.__dict__.update(statedict)
|
|
0
|
194 def get_levels(self, level):
|
|
|
195 d = {}
|
|
|
196 if level == 0:
|
|
|
197 self.slideradjuster.atzero = 1
|
|
|
198 return d
|
|
4
|
199 if self.is_effect:
|
|
0
|
200 d = self.generator.next()
|
|
|
201 self.slideradjuster.atzero = 0
|
|
|
202 else: # dictionary (standard)
|
|
|
203 d = self.levels
|
|
4
|
204 return dict([(get_dmx_channel(ch), float(lev) * float(level))
|
|
|
205 for ch, lev in d.items()])
|
|
0
|
206
|
|
|
207 def reload_data(dummy):
|
|
4
|
208 global subs
|
|
0
|
209 if dummy:
|
|
|
210 import ConfigDummy as Config
|
|
|
211 else:
|
|
|
212 import Config
|
|
|
213
|
|
|
214 reload(Config)
|
|
|
215
|
|
|
216 subs = {}
|
|
|
217 for name, levels in Config.subs.items():
|
|
|
218 if type(name) == TupleType:
|
|
|
219 name, color = name
|
|
|
220 else:
|
|
28
|
221 color = None
|
|
0
|
222
|
|
4
|
223 subs[name] = Sub(levels, color=color)
|
|
0
|
224
|
|
|
225 # subs = dict([(name, Sub(levels)) for name, levels in Config.subs.items()])
|
