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