light9: bin/subcomposer comparison

comparison bin/subcomposer @ 838:321fc6150ee3

subcomposer's nice currently-editing DnD box Ignore-this: f2a8542a4ab38dbe61b26c864da3bace

author	drewp@bigasterisk.com
date	Tue, 26 Mar 2013 07:04:22 +0000
parents	ae359590eb8a
children	f987eb9c3672

comparison

equal deleted inserted replaced

-:f3364e9f5c03
+:321fc6150ee3
 #!bin/python
+"""
+subcomposer
+session
+observable(currentSub), a Submaster which tracks the graph
+EditChoice widget
+can change currentSub to another sub
+Levelbox widget
+watch observable(currentSub) for a new sub, and also watch currentSub for edits to push to the OneLevel widgets
+OneLevel widget
+UI edits are caught here and go all the way back to currentSub
+"""
 from __future__ import division, nested_scopes
+import time, logging
 from optparse import OptionParser
 import logging
 import Tkinter as tk
 import louie as dispatcher
 from twisted.internet import reactor, tksupport, task
 from rdflib import URIRef
 from run_local import log
 from light9.dmxchanedit import Levelbox
-from light9 import dmxclient, Patch, Submaster, showconfig, prof
+from light9 import dmxclient, Patch, Submaster, prof
 from light9.uihelpers import toplevelat
 from light9.rdfdb.syncedgraph import SyncedGraph
 from light9.rdfdb import clientsession
 from light9.tkdnd import initTkdnd, dragSourceRegister, dropTargetRegister
-log.setLevel(logging.DEBUG)
 class _NoNewVal(object):
 pass
 class Observable(object):
 b=tk.Button(text="unlink", command=self.switchToLocalSub)
 b.pack()
 def uriChanged(self, newUri):
+print "chg", newUri
 # i guess i show the label and icon for this
 if newUri is Local:
 self.subIcon.config(text="(local)")
 else:
 self.subIcon.config(text=newUri)
 """
 <session> l9:currentSub ?sub is the URI of the sub we're tied to for displaying and
 editing. If we don't have a currentSub, then we're actually
 editing a session-local sub called <session> l9:currentSub <sessionLocalSub>
+I'm not sure that Locals should even be PersistentSubmaster with
+uri and graph storage, but I think that way is making fewer
+special cases.
 Contains an EditChoice widget
-UI actions:
+Dependencies:
-- drag a sub uri on here to make it the one we're editing
+graph (?session :currentSub ?s) -> self.currentSub
-- button to clear the currentSub (putting it back to
+self.currentSub -> graph
-sessionLocalSub, and also resetting sessionLocalSub to be empty
+self.currentSub -> self._currentChoice (which might be Local)
-again)
+self._currentChoice (which might be Local) -> self.currentSub
-- drag the sub uri off of here to send it to another receiver, but
+inside the current sub:
-session local sub is not easily addressable elsewhere
+graph -> Submaster levels (handled in Submaster)
+Submaster levels -> OneLevel widget
-- make a new sub: transfers the current data (from a shared sub or
+OneLevel widget -> Submaster.editLevel
-from the local one) to the new sub. If you're on a local sub,
+Submaster.editLevel -> graph (handled in Submaster)
-the new sub is named automatically, ideally something brief,
-pretty distinct, readable, and based on the lights that are
-on. If you're on a named sub, the new one starts with a
-'namedsub 2' style name. The uri can also be with a '2' suffix,
-although maybe that will be stupid. If you change the name
-before anyone knows about this uri, we could update the current
-sub's uri to a slug of the new label.
-- rename this sub: not available if you're on a local sub. Sets
-the label of a named sub. Might update the uri of the named sub
-if it's new enough that no one else would have that uri. Not
-sure where we measure that 'new enough' value. Maybe track if
-the sub has 'never been dragged out of this subcomposer
-session'? But subs will also show up in other viewers and
-finders.
 """
 def __init__(self, master, graph, session):
 tk.Frame.__init__(self, master, bg='black')
 self.graph = graph
 self.session = session
-self.currentSub = Submaster.PersistentSubmaster(graph, URIRef('http://hello'))
+# this is a PersistentSubmaster (even for local) or None if we're not initialized
-self.levelbox = Levelbox(self, graph)
+self.currentSub = Observable(None)
+currentUri = Observable("http://curr")
+def pc(val):
+print "change viewed sub to", val
+currentUri.subscribe(pc)
+EditChoice(self, self.graph, self._currentChoice).frame.pack(side='top')
+def setupSubChoiceLinks(self):
+def ann():
+print "currently: session=%s currentSub=%r _currentChoice=%r" % (
+self.session, self.currentSub(), self._currentChoice())
+@graph.addHandler
+def graphChanged():
+s = graph.value(self.session, L9['currentSub'])
+if s is None:
+s = self.makeLocal()
+self.currentSub(Submaster.PersistentSubmaster(graph, s))
+@self.currentSub.subscribe
+def subChanged(newSub):
+if newSub is None:
+graph.patchObject(self.session,
+self.session, L9['currentSub'], None)
+return
+self.sendupdate()
+graph.patchObject(self.session,
+self.session, L9['currentSub'], newSub.uri)
+if newSub and 'local' in newSub.uri: # wrong- use rdf:type or something?
+self._currentChoice(Local)
+else:
+# i think right here is the point that the last local
+# becomes garbage, and we could clean it up.
+self._currentChoice(newSub.uri)
+dispatcher.connect(self.levelsChanged, "sub levels changed")
+@self._currentChoice.subscribe
+def choiceChanged(newChoice):
+if newChoice is Local:
+newChoice = self.makeLocal()
+if newChoice is not None:
+self.currentSub(Submaster.PersistentSubmaster(
+graph, newChoice))
+def levelsChanged(self, sub):
+if sub == self.currentSub():
+self.sendupdate()
+def makeLocal(self):
+# todo: put a type on this, so subChanged can identify it right
+# todo: where will these get stored, or are they local to this
+# subcomposer process and don't use PersistentSubmaster at all?
+return URIRef("http://local/%s" % time.time())
+def setupLevelboxUi(self):
+self.levelbox = Levelbox(self, graph, self.currentSub)
 self.levelbox.pack(side='top')
-currentUri = Observable(Local)
+tk.Button(self, text="All to zero",
+command=lambda *args: self.currentSub().clear()).pack(side='top')
-def pc(val):
-log.info("change viewed sub to %s", val)
-currentUri.subscribe(pc)
-EditChoice(self, self.graph, currentUri).frame.pack(side='top')
-def alltozero():
-for lev in self.levelbox.levels:
-lev.setlevel(0)
-tk.Button(self, text="all to zero", command=alltozero).pack(side='top')
-dispatcher.connect(self.sendupdate, "levelchanged")
-def switchToLocalSub(self, *args):
-"""
-stop editing a shared sub and go back to our local sub
-"""
-def fill_both_boxes(self, subname):
-for box in [self.savebox, self.loadbox]:
-box.set(subname)
 def savenewsub(self, subname):
 leveldict={}
 for i,lev in zip(range(len(self.levels)),self.levels):
 if lev!=0:
 leveldict[Patch.get_channel_name(i+1)]=lev
 s=Submaster.Submaster(subname,leveldict=leveldict)
 s.save()
-# this is going to be more like 'tie to sub' and 'untied'
-def loadsub(self, subname):
-"""puts a sub into the levels, replacing old level values"""
-s=Submaster.Submasters(showconfig.getGraph()).get_sub_by_name(subname)
-self.set_levels(s.get_dmx_list())
-dispatcher.send("levelchanged")
-def toDmxLevels(self):
-# the dmx levels we edit and output, range is 0..1 (dmx chan 1 is
-# the 0 element)
-out = {}
-for lev in self.levelbox.levels:
-out[lev.channelnum] = lev.currentlevel
-if not out:
-return []
-return [out.get(i, 0) for i in range(max(out.keys()) + 1)]
 def sendupdate(self):
-dmxclient.outputlevels(self.toDmxLevels(), twisted=True)
+d = self.currentSub().get_dmx_list()
+dmxclient.outputlevels(d, twisted=True)
-class EntryCommand(tk.Frame):
-def __init__(self, master, verb="Save", cmd=None):
+def launch(opts, args, root, graph, session):
-tk.Frame.__init__(self, master, bd=2, relief='raised')
+if not opts.no_geometry:
-tk.Label(self, text="Sub name:").pack(side='left')
+toplevelat("subcomposer - %s" % opts.session, root, graph, session)
-self.cmd = cmd
-self.entry = tk.Entry(self)
+sc = Subcomposer(root, graph, session)
-self.entry.pack(side='left', expand=True, fill='x')
+sc.pack()
-self.entry.bind("<Return>", self.action)
+tk.Label(root,text="Bindings: B1 adjust level; B2 set full; B3 instant bump",
-tk.Button(self, text=verb, command=self.action).pack(side='left')
+font="Helvetica -12 italic",anchor='w').pack(side='top',fill='x')
+if len(args) == 1:
+# it might be a little too weird that cmdline arg to this
+# process changes anything else in the same session. But also
+# I'm not sure who would ever make 2 subcomposers of the same
+# session (except when quitting and restarting, to get the
+# same window pos), so maybe it doesn't matter. But still,
+# this tool should probably default to making new sessions
+# usually instead of loading the same one
 def action(self, *args):
 subname = self.entry.get()
 self.cmd(subname)
-log.info("command %s %s", self.cmd, subname)
+print "sub", self.cmd, subname
-def set(self, text):
+task.LoopingCall(sc.sendupdate).start(10)
-self.entry.delete(0, 'end')
-self.entry.insert(0, text)
 #############################
 if __name__ == "__main__":
-parser = OptionParser(usage="%prog [subname]")
+parser = OptionParser(usage="%prog [suburi]")
 parser.add_option('--no-geometry', action='store_true',
 help="don't save/restore window geometry")
 clientsession.add_option(parser)
 opts, args = parser.parse_args()
+logging.basicConfig(level=logging.DEBUG)
 root=tk.Tk()
 root.config(bg='black')
 root.tk_setPalette("#004633")
 initTkdnd(root.tk, 'tkdnd/trunk/')
 graph = SyncedGraph("subcomposer")
 session = clientsession.getUri('subcomposer', opts)
-if not opts.no_geometry:
+graph.initiallySynced.addCallback(lambda _: launch(opts, args, root, graph, session))
-toplevelat("subcomposer - %s" % opts.session, root, graph, session)
-sc = Subcomposer(root, graph, session)
-sc.pack()
-tk.Label(root,text="Bindings: B1 adjust level; B2 set full; B3 instant bump",
-font="Helvetica -12 italic",anchor='w').pack(side='top',fill='x')
-if len(args) == 1:
-root.config(bg='green') # trying to make these look distinctive
-sc.loadsub(args[0])
-sc.fill_both_boxes(args[0])
-task.LoopingCall(sc.sendupdate).start(1)
 root.protocol('WM_DELETE_WINDOW', reactor.stop)
 tksupport.install(root,ms=10)
 prof.run(reactor.run, profile=False)

Mercurial > code > home > repos > light9

comparison bin/subcomposer @ 838:321fc6150ee3