|
0
|
1 from __future__ import nested_scopes
|
|
136
|
2 import sys, time
|
|
0
|
3 sys.path.append('..')
|
|
|
4 from Widgets.Fadable import Fadable
|
|
|
5
|
|
|
6 from Tix import *
|
|
136
|
7 import math, atexit, pickle
|
|
|
8 from Submaster import Submasters, sub_maxes
|
|
|
9 import dmxclient
|
|
|
10 from uihelpers import toplevelat
|
|
0
|
11
|
|
|
12 nudge_keys = {
|
|
|
13 'up' : list('qwertyuiop'),
|
|
|
14 'down' : list('asdfghjkl')
|
|
|
15 }
|
|
|
16 nudge_keys['down'].append('semicolon')
|
|
|
17
|
|
|
18 class SubScale(Scale, Fadable):
|
|
|
19 def __init__(self, master, *args, **kw):
|
|
|
20 self.scale_var = kw.get('variable') or DoubleVar()
|
|
|
21 kw.update({'variable' : self.scale_var,
|
|
136
|
22 'from' : 1, 'to' : 0, 'showvalue' : 0,
|
|
|
23 'sliderlength' : 30, 'res' : 0.01,
|
|
|
24 'width' : 50})
|
|
0
|
25 Scale.__init__(self, master, *args, **kw)
|
|
136
|
26 Fadable.__init__(self, var=self.scale_var, wheel_step=0.05)
|
|
0
|
27
|
|
|
28 class SubmasterTk(Frame):
|
|
|
29 def __init__(self, master, name, current_level):
|
|
136
|
30 Frame.__init__(self, master, bd=1, relief='raised')
|
|
0
|
31 self.slider_var = DoubleVar()
|
|
|
32 self.slider_var.set(current_level)
|
|
|
33 self.scale = SubScale(self, variable=self.slider_var, width=20)
|
|
111
|
34 textlabel = Label(self, text=name)
|
|
|
35 textlabel.pack(side=TOP)
|
|
0
|
36 self.scale.pack(side=BOTTOM, expand=1, fill=BOTH)
|
|
|
37
|
|
|
38 class KeyboardComposer(Frame):
|
|
111
|
39 def __init__(self, root, submasters, current_sub_levels=None):
|
|
|
40 Frame.__init__(self, root)
|
|
0
|
41 self.submasters = submasters
|
|
136
|
42 self.current_sub_levels = {}
|
|
|
43 if current_sub_levels:
|
|
|
44 self.current_sub_levels = current_sub_levels
|
|
|
45 else:
|
|
|
46 try:
|
|
|
47 self.current_sub_levels = \
|
|
|
48 pickle.load(file('.keyboardcomposer.savedlevels'))
|
|
|
49 except IOError:
|
|
|
50 pass
|
|
0
|
51
|
|
136
|
52 self.draw_ui()
|
|
|
53 self.send_levels_loop()
|
|
|
54 def draw_ui(self):
|
|
0
|
55 self.rows = [] # this holds Tk Frames for each row
|
|
|
56 self.slider_vars = {} # this holds subname:sub Tk vars
|
|
|
57 self.slider_table = {} # this holds coords:sub Tk vars
|
|
|
58 self.current_row = 0
|
|
|
59
|
|
|
60 self.make_key_hints()
|
|
|
61 self.draw_sliders()
|
|
|
62 self.highlight_row(self.current_row)
|
|
|
63 self.rows[self.current_row].focus()
|
|
136
|
64
|
|
|
65 self.refreshbutton = Button(self, text="Refresh", command=self.refresh)
|
|
|
66 self.refreshbutton.pack(side=BOTTOM)
|
|
|
67 self.stop_frequent_update_time = 0
|
|
0
|
68 def make_key_hints(self):
|
|
|
69 keyhintrow = Frame(self)
|
|
|
70
|
|
|
71 col = 0
|
|
|
72 for upkey, downkey in zip(nudge_keys['up'],
|
|
|
73 nudge_keys['down']):
|
|
|
74 # what a hack!
|
|
|
75 downkey = downkey.replace('semicolon', ';')
|
|
136
|
76 upkey, downkey = (upkey.upper(), downkey.upper())
|
|
0
|
77
|
|
|
78 # another what a hack!
|
|
|
79 keylabel = Label(keyhintrow, text='%s\n%s' % (upkey, downkey),
|
|
136
|
80 width=8, font=('Arial', 12), bg='red', fg='white', anchor='c')
|
|
0
|
81 keylabel.pack(side=LEFT, expand=1, fill=X)
|
|
|
82 col += 1
|
|
|
83
|
|
|
84 keyhintrow.pack(fill=X, expand=0)
|
|
|
85 self.keyhints = keyhintrow
|
|
|
86 def setup_key_nudgers(self, tkobject):
|
|
|
87 for d, keys in nudge_keys.items():
|
|
|
88 for key in keys:
|
|
|
89 # lowercase makes full=0
|
|
|
90 keysym = "<KeyPress-%s>" % key
|
|
|
91 tkobject.bind(keysym, \
|
|
|
92 lambda evt, num=keys.index(key), d=d: \
|
|
|
93 self.got_nudger(num, d))
|
|
|
94
|
|
|
95 # uppercase makes full=1
|
|
|
96 keysym = "<KeyPress-%s>" % key.upper()
|
|
|
97 keysym = keysym.replace('SEMICOLON', 'colon')
|
|
|
98 tkobject.bind(keysym, \
|
|
|
99 lambda evt, num=keys.index(key), d=d: \
|
|
|
100 self.got_nudger(num, d, full=1))
|
|
|
101
|
|
|
102 # page up and page down change the row
|
|
|
103 for key in '<Prior> <Next> <Control-n> <Control-p>'.split():
|
|
|
104 tkobject.bind(key, self.change_row)
|
|
|
105
|
|
|
106 def change_row(self, event):
|
|
|
107 diff = 1
|
|
111
|
108 if event.keysym in ('Prior', '<Control-p>'):
|
|
0
|
109 diff = -1
|
|
|
110 old_row = self.current_row
|
|
|
111 self.current_row += diff
|
|
|
112 self.current_row = max(0, self.current_row)
|
|
|
113 self.current_row = min(len(self.rows) - 1, self.current_row)
|
|
|
114 self.unhighlight_row(old_row)
|
|
|
115 self.highlight_row(self.current_row)
|
|
|
116 row = self.rows[self.current_row]
|
|
|
117 self.keyhints.pack_configure(before=row)
|
|
|
118 def got_nudger(self, number, direction, full=0):
|
|
|
119 subtk = self.slider_table[(self.current_row, number)]
|
|
|
120 if direction == 'up':
|
|
|
121 if full:
|
|
136
|
122 subtk.scale.fade(1)
|
|
0
|
123 else:
|
|
|
124 subtk.scale.increase()
|
|
|
125 else:
|
|
|
126 if full:
|
|
|
127 subtk.scale.fade(0)
|
|
|
128 else:
|
|
|
129 subtk.scale.decrease()
|
|
136
|
130 # self.maybe_update()
|
|
|
131 def maybe_update(self, dur=1.05):
|
|
|
132 now = time.time()
|
|
|
133 if now > self.stop_frequent_update_time:
|
|
|
134 self.stop_frequent_update_time = now + dur
|
|
|
135 self.send_frequent_updates()
|
|
|
136 else:
|
|
|
137 self.stop_frequent_update_time = now + dur
|
|
0
|
138 def draw_sliders(self):
|
|
|
139 self.tk_focusFollowsMouse()
|
|
|
140
|
|
|
141 rowcount = -1
|
|
|
142 col = 0
|
|
136
|
143 for sub in self.submasters.get_all_subs():
|
|
0
|
144 if col == 0: # make new row
|
|
|
145 row = self.make_row()
|
|
|
146 rowcount += 1
|
|
|
147 current_level = self.current_sub_levels.get(sub.name, 0)
|
|
|
148 subtk = self.draw_sub_slider(row, col, sub.name, current_level)
|
|
|
149 self.slider_table[(rowcount, col)] = subtk
|
|
|
150 col += 1
|
|
|
151 col %= 10
|
|
136
|
152
|
|
|
153 subtk.slider_var.trace('w', lambda x, y, z: self.send_levels())
|
|
0
|
154 def make_row(self):
|
|
111
|
155 row = Frame(self, bd=2)
|
|
0
|
156 row.pack(expand=1, fill=BOTH)
|
|
|
157 self.setup_key_nudgers(row)
|
|
|
158 self.rows.append(row)
|
|
|
159 return row
|
|
|
160 def draw_sub_slider(self, row, col, name, current_level):
|
|
|
161 subtk = SubmasterTk(row, name, current_level)
|
|
|
162 subtk.place(relx=col * 0.1, rely=0, relwidth=0.1, relheight=1)
|
|
|
163 self.setup_key_nudgers(subtk.scale)
|
|
|
164
|
|
|
165 self.slider_vars[name] = subtk.slider_var
|
|
|
166 return subtk
|
|
|
167 def highlight_row(self, row):
|
|
|
168 row = self.rows[row]
|
|
|
169 row['bg'] = 'red'
|
|
|
170 def unhighlight_row(self, row):
|
|
|
171 row = self.rows[row]
|
|
111
|
172 row['bg'] = '#d9d9d9'
|
|
0
|
173 def get_levels(self):
|
|
|
174 return dict([(name, slidervar.get())
|
|
|
175 for name, slidervar in self.slider_vars.items()])
|
|
136
|
176 def get_dmx_list(self):
|
|
|
177 scaledsubs = [self.submasters.get_sub_by_name(sub) * level \
|
|
|
178 for sub, level in self.get_levels().items()]
|
|
|
179
|
|
|
180 maxes = sub_maxes(*scaledsubs)
|
|
|
181 return maxes.get_dmx_list()
|
|
|
182 def save(self):
|
|
|
183 pickle.dump(self.get_levels(),
|
|
|
184 file('.keyboardcomposer.savedlevels', 'w'))
|
|
|
185 def send_frequent_updates(self):
|
|
|
186 """called when we get a fade -- send events as quickly as possible"""
|
|
|
187 if time.time() <= self.stop_frequent_update_time:
|
|
|
188 self.send_levels()
|
|
|
189 self.after(10, self.send_frequent_updates)
|
|
|
190 def send_levels(self):
|
|
|
191 print self.submasters.get_sub_by_name('frontwhite')
|
|
|
192 levels = self.get_dmx_list()
|
|
|
193 dmxclient.outputlevels(levels)
|
|
|
194 def send_levels_loop(self):
|
|
|
195 self.send_levels()
|
|
|
196 self.after(1000, self.send_levels_loop)
|
|
|
197 def refresh(self):
|
|
|
198 self.save()
|
|
|
199 self.submasters = Submasters()
|
|
|
200 self.current_sub_levels = \
|
|
|
201 pickle.load(file('.keyboardcomposer.savedlevels'))
|
|
|
202 for r in self.rows:
|
|
|
203 r.destroy()
|
|
|
204 self.keyhints.destroy()
|
|
|
205 self.refreshbutton.destroy()
|
|
|
206 self.draw_ui()
|
|
0
|
207
|
|
|
208 if __name__ == "__main__":
|
|
136
|
209 s = Submasters()
|
|
0
|
210
|
|
|
211 root = Tk()
|
|
136
|
212 tl = toplevelat("Keyboard Composer", existingtoplevel=root)
|
|
|
213 kc = KeyboardComposer(tl, s)
|
|
0
|
214 kc.pack(fill=BOTH, expand=1)
|
|
136
|
215 atexit.register(kc.save)
|
|
|
216 try:
|
|
|
217 mainloop()
|
|
|
218 except KeyboardInterrupt:
|
|
|
219 tl.destroy()
|
|
|
220 sys.exit()
|
