Mercurial > code > home > repos > light9
annotate light8/Lightboard.py @ 116:9ddea0c614ee
much prettier stdout, including a clock (so you can tell the server's running)
much prettier stdout, including a clock (so you can tell the server's running)
and channel updates only when the levels change, and throttled to every 100 updates
even then.
| author | drewp |
|---|---|
| date | Fri, 13 Jun 2003 06:15:28 +0000 |
| parents | afbdae5e1359 |
| children | 6f9898f00c9c |
| rev | line source |
|---|---|
|
112
afbdae5e1359
dmx light output is now via a separate process which light8 talks to.
drewp
parents:
107
diff
changeset
|
1 from __future__ import nested_scopes,division |
| 0 | 2 |
| 3 from Tix import * | |
| 4 from signal import signal, SIGINT | |
|
103
ddd3c8f04640
more untested code, ready for production: colors for slider mapping
dmcc
parents:
102
diff
changeset
|
5 from time import time |
|
112
afbdae5e1359
dmx light output is now via a separate process which light8 talks to.
drewp
parents:
107
diff
changeset
|
6 import xmlrpclib |
|
78
0969d8a6729d
support for external sliders. fill in ExternalInput with real IO
dmcc
parents:
74
diff
changeset
|
7 import sys, cPickle, random |
| 0 | 8 |
| 9 from uihelpers import * | |
| 10 from panels import * | |
| 11 from Xfader import * | |
| 12 from subediting import Subediting | |
| 13 from Fader import Fader | |
| 79 | 14 from ExternalInput import ExternalSliders |
| 15 import io, stage, Subs, Patch, ExtSliderMapper | |
| 0 | 16 |
| 17 class Pickles: | |
| 67 | 18 def __init__(self, scalelevels, subs=None, windowpos=None): |
| 0 | 19 self.scalelevels = dict([(name, lev.get()) |
| 20 for name, lev in scalelevels.items()]) | |
| 21 self.substate = dict([(name, subobj.get_state()) | |
| 22 for name, subobj in subs]) | |
| 67 | 23 self.windowpos = windowpos |
| 0 | 24 |
| 25 class Lightboard: | |
|
112
afbdae5e1359
dmx light output is now via a separate process which light8 talks to.
drewp
parents:
107
diff
changeset
|
26 def __init__(self, master, DUMMY): |
| 0 | 27 self.master = master |
|
112
afbdae5e1359
dmx light output is now via a separate process which light8 talks to.
drewp
parents:
107
diff
changeset
|
28 |
| 0 | 29 self.DUMMY = DUMMY |
| 74 | 30 self.jostle_mode = 0 |
|
104
15ead14b4dd1
result of 7.13 performance, some ExtSliderMapper fixes
dmcc
parents:
103
diff
changeset
|
31 self.lastline = None |
| 0 | 32 |
| 107 | 33 self.channel_levels = [] # these are actually the labels for the |
| 34 # channel levels, and should probably be moved | |
| 35 # to panels.Leveldisplay | |
| 0 | 36 self.scalelevels = {} |
| 107 | 37 |
| 38 self.lastsublevels = {} # to determine which subs changed | |
| 39 self.unchangedeffect = {} # dict of levels for lights that didn't | |
| 40 # change last time | |
| 41 self.lastunchangedgroup = {} | |
| 42 | |
|
78
0969d8a6729d
support for external sliders. fill in ExternalInput with real IO
dmcc
parents:
74
diff
changeset
|
43 # doesn't draw any UI yet-- look for self.xfader.setupwidget() |
|
0969d8a6729d
support for external sliders. fill in ExternalInput with real IO
dmcc
parents:
74
diff
changeset
|
44 self.xfader = Xfader(self.scalelevels) |
| 0 | 45 self.oldlevels = [None] * 68 # never replace this; just clear it |
| 46 self.subediting = Subediting(currentoutputlevels=self.oldlevels) | |
| 47 | |
| 68 | 48 self.windowpos = 0 |
| 0 | 49 self.get_data() |
| 50 self.buildinterface() | |
| 51 self.load() | |
|
112
afbdae5e1359
dmx light output is now via a separate process which light8 talks to.
drewp
parents:
107
diff
changeset
|
52 |
|
afbdae5e1359
dmx light output is now via a separate process which light8 talks to.
drewp
parents:
107
diff
changeset
|
53 # get a connection to the dmx server |
|
afbdae5e1359
dmx light output is now via a separate process which light8 talks to.
drewp
parents:
107
diff
changeset
|
54 self.dmxserver=xmlrpclib.Server("http://localhost:8030") |
|
afbdae5e1359
dmx light output is now via a separate process which light8 talks to.
drewp
parents:
107
diff
changeset
|
55 |
|
afbdae5e1359
dmx light output is now via a separate process which light8 talks to.
drewp
parents:
107
diff
changeset
|
56 print "Light 8.8: Entering backgroundloop" |
| 0 | 57 self.backgroundloop() |
|
62
2f2eb802e93d
stage shows levels now. aims have blue halo for easy recognition.
dmcc
parents:
61
diff
changeset
|
58 self.updatestagelevels() |
|
103
ddd3c8f04640
more untested code, ready for production: colors for slider mapping
dmcc
parents:
102
diff
changeset
|
59 self.rec_file = open('light9.log', 'a') |
|
ddd3c8f04640
more untested code, ready for production: colors for slider mapping
dmcc
parents:
102
diff
changeset
|
60 self.record_start() |
| 0 | 61 |
| 62 def buildinterface(self): | |
| 102 | 63 print "Light 8.8: Constructing interface..." |
| 0 | 64 for w in self.master.winfo_children(): |
| 65 w.destroy() | |
| 66 | |
| 102 | 67 print "\tstage" |
|
78
0969d8a6729d
support for external sliders. fill in ExternalInput with real IO
dmcc
parents:
74
diff
changeset
|
68 stage_tl = toplevelat('stage') |
| 0 | 69 s = stage.Stage(stage_tl) |
| 70 stage.createlights(s) | |
| 71 s.setsubediting(self.subediting) | |
| 72 s.pack() | |
|
62
2f2eb802e93d
stage shows levels now. aims have blue halo for easy recognition.
dmcc
parents:
61
diff
changeset
|
73 self.stage = s # save it |
| 0 | 74 |
|
78
0969d8a6729d
support for external sliders. fill in ExternalInput with real IO
dmcc
parents:
74
diff
changeset
|
75 sub_tl = toplevelat('sub') |
|
0969d8a6729d
support for external sliders. fill in ExternalInput with real IO
dmcc
parents:
74
diff
changeset
|
76 scene_tl = toplevelat('scenes') |
|
0969d8a6729d
support for external sliders. fill in ExternalInput with real IO
dmcc
parents:
74
diff
changeset
|
77 effect_tl = toplevelat('effect') |
|
0969d8a6729d
support for external sliders. fill in ExternalInput with real IO
dmcc
parents:
74
diff
changeset
|
78 |
| 102 | 79 print "\tslider patching" |
|
78
0969d8a6729d
support for external sliders. fill in ExternalInput with real IO
dmcc
parents:
74
diff
changeset
|
80 mapping_tl = toplevelat('mapping') |
| 79 | 81 self.slidermapper = ExtSliderMapper.ExtSliderMapper(mapping_tl, |
| 82 self.scalelevels, | |
|
103
ddd3c8f04640
more untested code, ready for production: colors for slider mapping
dmcc
parents:
102
diff
changeset
|
83 ExternalSliders(), |
|
ddd3c8f04640
more untested code, ready for production: colors for slider mapping
dmcc
parents:
102
diff
changeset
|
84 self) |
|
78
0969d8a6729d
support for external sliders. fill in ExternalInput with real IO
dmcc
parents:
74
diff
changeset
|
85 self.slidermapper.pack() |
| 0 | 86 |
| 102 | 87 print "\tsubmaster control" |
| 107 | 88 self.subpanels = Subpanels(sub_tl, effect_tl, scene_tl, self, |
| 89 self.scalelevels, Subs, self.xfader, | |
| 90 self.changelevel, self.subediting, | |
| 91 Subs.longestsubname()) | |
| 92 | |
| 93 for n, lev in self.scalelevels.items(): | |
| 94 self.lastsublevels[n] = lev.get() | |
| 0 | 95 |
| 102 | 96 print "\tlevel display" |
|
78
0969d8a6729d
support for external sliders. fill in ExternalInput with real IO
dmcc
parents:
74
diff
changeset
|
97 leveldisplay_tl = toplevelat('leveldisplay') |
| 0 | 98 leveldisplay_tl.bind('<Escape>', sys.exit) |
| 99 | |
| 100 self.leveldisplay = Leveldisplay(leveldisplay_tl, self.channel_levels) | |
| 107 | 101 # I don't think we need this |
| 102 # for i in range(0,len(self.channel_levels)): | |
| 103 # self.channel_levels[i].config(text=self.oldlevels[i]) | |
| 104 # colorlabel(self.channel_levels[i]) | |
| 0 | 105 |
| 102 | 106 print "\tconsole" |
| 0 | 107 Console(self) |
| 108 | |
| 109 # root frame | |
| 102 | 110 print "\tcontrol panel" |
| 111 self.master.configure(bg='black') | |
| 74 | 112 controlpanel = Controlpanel(self.master, self.xfader, self.refresh, |
| 107 | 113 self.quit, self.toggle_jostle, self.nonzerosubs) |
| 0 | 114 |
| 102 | 115 print "\tcrossfader" |
| 0 | 116 xf=Frame(self.master) |
| 117 xf.pack(side='right') | |
| 118 | |
| 119 self.master.bind('<q>', self.quit) | |
| 120 self.master.bind('<r>', self.refresh) | |
| 121 leveldisplay_tl.bind('<q>', self.quit) | |
| 122 leveldisplay_tl.bind('<r>', self.refresh) | |
| 123 | |
| 124 self.xfader.setupwidget(xf) | |
| 125 controlpanel.pack() | |
| 126 | |
| 102 | 127 print "\tcue fader (skipped)" |
| 128 # cuefader_tl = toplevelat('cuefader') | |
| 129 # cuefader = Fader(cuefader_tl, Subs.cues, self.scalelevels) | |
| 130 # cuefader.pack() | |
| 131 print "Light 8.8: Everything's under control" | |
| 132 | |
| 0 | 133 |
| 134 def get_data(self,*args): | |
| 135 Subs.reload_data(self.DUMMY) | |
| 136 Patch.reload_data(self.DUMMY) | |
| 102 | 137 print "Light 8.8:", len(Patch.patch), "dimmers patched" |
| 138 print "Light 8.8:", len(Subs.subs), "submasters loaded" | |
| 0 | 139 |
| 140 def refresh(self, *args): | |
| 141 'rebuild interface, reload data' | |
|
103
ddd3c8f04640
more untested code, ready for production: colors for slider mapping
dmcc
parents:
102
diff
changeset
|
142 print "Light 8.8: Refresh initiated. Cross your fingers." |
| 0 | 143 self.get_data() |
|
103
ddd3c8f04640
more untested code, ready for production: colors for slider mapping
dmcc
parents:
102
diff
changeset
|
144 print "Light 8.8: Subediting refreshed" |
| 0 | 145 self.subediting.refresh() |
|
103
ddd3c8f04640
more untested code, ready for production: colors for slider mapping
dmcc
parents:
102
diff
changeset
|
146 print "Light 8.8: Rebuilding interface..." |
| 0 | 147 self.buildinterface() |
| 148 bindkeys(self.master,'<Escape>', self.quit) | |
|
103
ddd3c8f04640
more untested code, ready for production: colors for slider mapping
dmcc
parents:
102
diff
changeset
|
149 print "Light 8.8: Setting up slider patching..." |
| 101 | 150 self.slidermapper.setup() |
| 151 # self.master.tk_setPalette('gray40') | |
|
103
ddd3c8f04640
more untested code, ready for production: colors for slider mapping
dmcc
parents:
102
diff
changeset
|
152 print "Light 8.8: Now back to your regularly scheduled Light 8" |
| 0 | 153 |
| 154 def stageassub(self): | |
| 155 """returns the current onstage lighting as a levels | |
| 156 dictionary, skipping the zeros, and using names where | |
| 157 possible""" | |
| 158 levs=self.oldlevels | |
| 159 | |
| 160 return dict([(Patch.get_channel_name(i),l) for i,l | |
| 161 in zip(range(1,len(levs)+1),levs) | |
| 162 if l>0]) | |
| 68 | 163 def save_sub(self, name, levels, refresh=1): |
| 0 | 164 if not name: |
| 165 print "Enter sub name in console." | |
| 166 return | |
| 167 | |
| 168 st = '' | |
| 169 linebuf = 'subs["%s"] = {' % name | |
| 170 for channame,lev in levels.items(): | |
| 171 if len(linebuf) > 60: | |
| 172 st += linebuf + '\n ' | |
| 173 linebuf = '' | |
| 174 | |
| 175 linebuf += ' "%s" : %d,' % (channame, lev) | |
| 176 st += linebuf + '}\n' | |
| 177 if self.DUMMY: | |
| 178 filename = 'ConfigDummy.py' | |
| 179 else: | |
| 180 filename = 'Config.py' | |
| 181 f = open(filename, 'a') | |
| 182 f.write(st) | |
| 183 f.close() | |
| 184 print 'Added sub:', st | |
| 68 | 185 if refresh: |
| 186 self.refresh() | |
| 0 | 187 |
| 188 # this is called on a loop, and ALSO by the Scales | |
| 189 def changelevel(self, *args): | |
| 190 'Amp trims slider' | |
| 191 | |
|
78
0969d8a6729d
support for external sliders. fill in ExternalInput with real IO
dmcc
parents:
74
diff
changeset
|
192 # load levels from external sliders |
|
0969d8a6729d
support for external sliders. fill in ExternalInput with real IO
dmcc
parents:
74
diff
changeset
|
193 extlevels = self.slidermapper.get_levels() |
|
0969d8a6729d
support for external sliders. fill in ExternalInput with real IO
dmcc
parents:
74
diff
changeset
|
194 for name, val in extlevels.items(): |
| 79 | 195 if name in self.scalelevels: |
|
95
d5deeed83228
FancyDoubleVar is a DoubleVar where you can temporarily disable the callbacks
drewp
parents:
79
diff
changeset
|
196 sl = self.scalelevels[name] |
|
d5deeed83228
FancyDoubleVar is a DoubleVar where you can temporarily disable the callbacks
drewp
parents:
79
diff
changeset
|
197 sl.set(val) |
| 107 | 198 |
| 199 # newstart = time() | |
| 200 | |
| 201 # learn what changed | |
| 202 unchangedgroup = {} | |
| 203 changedgroup = {} | |
| 204 for name, lastlevel in self.lastsublevels.items(): | |
| 205 newlevel = self.scalelevels[name].get() | |
| 206 if lastlevel != newlevel: | |
| 207 changedgroup[name] = newlevel | |
| 208 else: | |
| 209 unchangedgroup[name] = newlevel | |
| 210 | |
| 211 changedeffect = {} | |
| 212 if not changedgroup: | |
| 213 # should load levels from last time | |
| 214 pass | |
| 215 else: | |
| 216 # calculate effect of new group. this should take no time if | |
| 217 # nothing changed | |
| 218 for name, level in changedgroup.items(): | |
| 219 newlevels = Subs.subs[name].get_levels(level=level) | |
| 220 for (ch, fadelev) in newlevels.items(): | |
| 221 changedeffect[ch-1] = \ | |
| 222 max(changedeffect.get(ch-1, 0), fadelev) | |
| 223 | |
| 224 if unchangedgroup != self.lastunchangedgroup: | |
| 225 # unchanged group changed! (confusing, huh?) | |
| 226 # this means: the static subs from the last time are not the same | |
| 227 # as they are this time, so we recalculate effect of unchanged group | |
| 228 self.unchangedeffect = {} | |
| 229 for name, level in unchangedgroup.items(): | |
| 230 newlevels = Subs.subs[name].get_levels(level=level) | |
| 231 for (ch, fadelev) in newlevels.items(): | |
| 232 self.unchangedeffect[ch-1] = \ | |
| 233 max(self.unchangedeffect.get(ch-1, 0), fadelev) | |
| 234 self.lastunchangedgroup = unchangedgroup | |
| 235 | |
| 236 # record sublevels for future generations (iterations, that is) | |
| 237 for name in self.lastsublevels: | |
| 238 self.lastsublevels[name] = self.scalelevels[name] | |
| 239 | |
| 240 # merge effects together | |
| 241 levels = [0] * 68 | |
| 242 if changedeffect: | |
| 243 levels = [int(max(changedeffect.get(ch, 0), | |
| 244 self.unchangedeffect.get(ch, 0))) | |
| 245 for ch in range(0, 68)] | |
| 246 else: | |
| 247 levels = [int(self.unchangedeffect.get(ch, 0)) | |
| 248 for ch in range(0, 68)] | |
| 249 | |
| 250 ''' | |
| 251 newend = time() | |
| 252 | |
| 253 levels_opt = levels | |
| 254 | |
| 255 oldstart = time() | |
| 256 # i tried to optimize this to a dictionary, but there was no speed | |
| 257 # improvement | |
| 258 levels = [0] * 68 | |
| 259 for name, s in Subs.subs.items(): | |
| 260 sublevel = self.scalelevels[name].get() | |
| 261 newlevels = s.get_levels(level=sublevel) | |
| 262 self.lastsublevels[name] = sublevel # XXX remove | |
| 263 for (ch, fadelev) in newlevels.items(): | |
| 264 levels[ch-1] = max(levels[ch-1], fadelev) | |
| 265 levels = [int(l) for l in levels] | |
| 266 oldend = time() | |
| 267 | |
| 268 newtime = newend - newstart | |
| 269 oldtime = oldend - oldstart | |
| 270 print "new", newtime, 'old', (oldend - oldstart), 'sup', \ | |
| 271 oldtime / newtime | |
| 272 | |
| 273 if levels != levels_opt: | |
| 274 raise "not equal" | |
| 275 # for l, lo in zip(levels, levels_opt): | |
| 276 # print l, lo | |
| 277 ''' | |
| 74 | 278 |
| 72 | 279 for lev,lab,oldlev,numlab in zip(levels, self.channel_levels, |
| 0 | 280 self.oldlevels, |
| 72 | 281 self.leveldisplay.number_labels): |
| 0 | 282 if lev != oldlev: |
|
62
2f2eb802e93d
stage shows levels now. aims have blue halo for easy recognition.
dmcc
parents:
61
diff
changeset
|
283 lab.config(text="%d" % lev) # update labels in lev display |
|
2f2eb802e93d
stage shows levels now. aims have blue halo for easy recognition.
dmcc
parents:
61
diff
changeset
|
284 colorlabel(lab) # recolor labels |
| 0 | 285 if lev < oldlev: |
| 286 numlab['bg'] = 'blue' | |
| 287 else: | |
| 288 numlab['bg'] = 'red' | |
| 289 else: | |
| 102 | 290 numlab['bg'] = 'grey40' |
| 0 | 291 |
| 107 | 292 # replace the elements in oldlevels - don't make a new list |
| 293 # (Subediting is watching it) | |
| 294 self.oldlevels[:] = levels[:] | |
| 0 | 295 |
| 74 | 296 if self.jostle_mode: |
| 297 delta = random.randrange(-1, 2, 1) # (-1, 0, or 1) | |
| 298 # print "delta", delta | |
| 299 levels = [min(100, max(x + delta, 0)) for x in levels] | |
| 300 # print "jostled", levels | |
| 301 | |
|
112
afbdae5e1359
dmx light output is now via a separate process which light8 talks to.
drewp
parents:
107
diff
changeset
|
302 self.dmxserver.outputlevels("light8-%s" %os.getpid(),[l/100 for l in levels]) |
|
afbdae5e1359
dmx light output is now via a separate process which light8 talks to.
drewp
parents:
107
diff
changeset
|
303 # self.parportdmx.sendlevels(levels) |
| 0 | 304 |
|
62
2f2eb802e93d
stage shows levels now. aims have blue halo for easy recognition.
dmcc
parents:
61
diff
changeset
|
305 def updatestagelevels(self): |
|
2f2eb802e93d
stage shows levels now. aims have blue halo for easy recognition.
dmcc
parents:
61
diff
changeset
|
306 self.master.after(100, self.updatestagelevels) |
|
2f2eb802e93d
stage shows levels now. aims have blue halo for easy recognition.
dmcc
parents:
61
diff
changeset
|
307 for lev, idx in zip(self.oldlevels, xrange(0, 68 + 1)): |
|
2f2eb802e93d
stage shows levels now. aims have blue halo for easy recognition.
dmcc
parents:
61
diff
changeset
|
308 self.stage.updatelightlevel(Patch.get_channel_name(idx + 1), lev) |
|
2f2eb802e93d
stage shows levels now. aims have blue halo for easy recognition.
dmcc
parents:
61
diff
changeset
|
309 |
| 0 | 310 def load(self): |
| 311 try: | |
| 312 filename = '/tmp/light9.prefs' | |
| 313 if self.DUMMY: | |
| 314 filename += '.dummy' | |
| 102 | 315 print "Light 8.8: Loading from", filename |
| 0 | 316 file = open(filename, 'r') |
| 317 p = cPickle.load(file) | |
| 318 for s, v in p.scalelevels.items(): | |
| 319 try: | |
| 320 self.scalelevels[s].set(v) | |
| 321 except Exception,e: | |
| 322 print "Couldn't set %s -> %s: %s" % (s, v,e) | |
| 323 for name, substate in p.substate.items(): | |
| 324 try: | |
| 325 Subs.subs[name].set_state(substate) | |
| 326 except Exception, e: | |
| 327 print "Couldn't set sub %s state: %s" % (name,e) | |
| 328 except IOError, e: | |
| 329 print "IOError: Couldn't load prefs (%s): %s" % (filename,e) | |
| 330 except EOFError, e: | |
| 331 print "EOFrror: Couldn't load prefs (%s): %s" % (filename,e) | |
| 332 except Exception,e: | |
| 333 print "Couldn't load prefs (%s): %s" % (filename,e) | |
|
78
0969d8a6729d
support for external sliders. fill in ExternalInput with real IO
dmcc
parents:
74
diff
changeset
|
334 self.slidermapper.setup() |
| 0 | 335 |
| 336 def backgroundloop(self, *args): | |
|
56
2af6698b0566
pulled Lightboard out of rsn.py (and fixed all the dependency problems i could find)
drewp
parents:
0
diff
changeset
|
337 self.master.after(50, self.backgroundloop, ()) |
| 0 | 338 self.changelevel() |
| 339 def quit(self, *args): | |
|
103
ddd3c8f04640
more untested code, ready for production: colors for slider mapping
dmcc
parents:
102
diff
changeset
|
340 print "Light 8.8: And that's my cue to exit..." |
| 0 | 341 self.save() |
|
103
ddd3c8f04640
more untested code, ready for production: colors for slider mapping
dmcc
parents:
102
diff
changeset
|
342 self.record_end() |
| 0 | 343 self.master.destroy() |
| 344 sys.exit() | |
| 345 def save(self, *args): | |
| 346 filename = '/tmp/light9.prefs' | |
| 347 if self.DUMMY: | |
| 348 filename += '.dummy' | |
|
103
ddd3c8f04640
more untested code, ready for production: colors for slider mapping
dmcc
parents:
102
diff
changeset
|
349 print "Light 8.8: Saving to", filename |
| 0 | 350 file = open(filename, 'w') |
| 67 | 351 |
| 0 | 352 try: |
| 353 cPickle.dump(Pickles(self.scalelevels, Subs.subs.items()), file) | |
| 354 except cPickle.UnpickleableError: | |
| 355 print "UnpickleableError! There's yer problem." | |
| 74 | 356 def toggle_jostle(self, *args): |
| 357 self.jostle_mode = not self.jostle_mode | |
| 107 | 358 if self.jostle_mode: |
| 359 print 'Light 8.8: Perhaps we can jost-le your memory?' | |
| 360 else: | |
| 361 print 'Light 8.8: He remembers! (jostle off)' | |
| 362 def nonzerosubs(self, *args): | |
| 363 print "Light 8.8: Active subs:" | |
| 364 for n, dv in self.scalelevels.items(): | |
| 365 if dv.get() > 0: | |
| 366 print "%-.4f: %s" % (dv.get(), n) | |
|
103
ddd3c8f04640
more untested code, ready for production: colors for slider mapping
dmcc
parents:
102
diff
changeset
|
367 def record_start(self): |
|
ddd3c8f04640
more untested code, ready for production: colors for slider mapping
dmcc
parents:
102
diff
changeset
|
368 print "Light 8.8: Recorder started" |
|
ddd3c8f04640
more untested code, ready for production: colors for slider mapping
dmcc
parents:
102
diff
changeset
|
369 self.rec_file.write("%s:\t%s\n" % (time(), "--- Start ---")) |
|
ddd3c8f04640
more untested code, ready for production: colors for slider mapping
dmcc
parents:
102
diff
changeset
|
370 self.record_stamp() |
|
ddd3c8f04640
more untested code, ready for production: colors for slider mapping
dmcc
parents:
102
diff
changeset
|
371 def record_end(self): |
|
ddd3c8f04640
more untested code, ready for production: colors for slider mapping
dmcc
parents:
102
diff
changeset
|
372 print "Light 8.8: Recorder shutdown" |
|
ddd3c8f04640
more untested code, ready for production: colors for slider mapping
dmcc
parents:
102
diff
changeset
|
373 self.rec_file.write("%s:\t%s\n" % (time(), "--- End ---")) |
|
ddd3c8f04640
more untested code, ready for production: colors for slider mapping
dmcc
parents:
102
diff
changeset
|
374 def record_stamp(self): |
|
ddd3c8f04640
more untested code, ready for production: colors for slider mapping
dmcc
parents:
102
diff
changeset
|
375 'Record the current submaster levels, continue this loop' |
|
ddd3c8f04640
more untested code, ready for production: colors for slider mapping
dmcc
parents:
102
diff
changeset
|
376 levels = [] |
|
ddd3c8f04640
more untested code, ready for production: colors for slider mapping
dmcc
parents:
102
diff
changeset
|
377 for n, v in self.scalelevels.items(): |
|
ddd3c8f04640
more untested code, ready for production: colors for slider mapping
dmcc
parents:
102
diff
changeset
|
378 lev = v.get() |
|
ddd3c8f04640
more untested code, ready for production: colors for slider mapping
dmcc
parents:
102
diff
changeset
|
379 if lev: |
|
ddd3c8f04640
more untested code, ready for production: colors for slider mapping
dmcc
parents:
102
diff
changeset
|
380 levels.append('%s\t%s' % (n, lev)) |
|
ddd3c8f04640
more untested code, ready for production: colors for slider mapping
dmcc
parents:
102
diff
changeset
|
381 |
|
104
15ead14b4dd1
result of 7.13 performance, some ExtSliderMapper fixes
dmcc
parents:
103
diff
changeset
|
382 |
|
15ead14b4dd1
result of 7.13 performance, some ExtSliderMapper fixes
dmcc
parents:
103
diff
changeset
|
383 newdata = '\t'.join(levels) |
|
15ead14b4dd1
result of 7.13 performance, some ExtSliderMapper fixes
dmcc
parents:
103
diff
changeset
|
384 if newdata!=self.lastline: |
|
15ead14b4dd1
result of 7.13 performance, some ExtSliderMapper fixes
dmcc
parents:
103
diff
changeset
|
385 template = "%s:\t%s\n" % (time(), newdata) |
|
15ead14b4dd1
result of 7.13 performance, some ExtSliderMapper fixes
dmcc
parents:
103
diff
changeset
|
386 self.rec_file.write(template) |
|
15ead14b4dd1
result of 7.13 performance, some ExtSliderMapper fixes
dmcc
parents:
103
diff
changeset
|
387 self.lastline = newdata |
|
103
ddd3c8f04640
more untested code, ready for production: colors for slider mapping
dmcc
parents:
102
diff
changeset
|
388 self.master.after(100, self.record_stamp) |
|
ddd3c8f04640
more untested code, ready for production: colors for slider mapping
dmcc
parents:
102
diff
changeset
|
389 def highlight_sub(self, name, color): |
|
ddd3c8f04640
more untested code, ready for production: colors for slider mapping
dmcc
parents:
102
diff
changeset
|
390 self.subediting.colorsub(name, color) |