hsv[0], hsv[1], .3)]))

        Frame.__init__(self, master, bd=1, relief='raised', bg=bg)

        self.name = sub.name

        self.slider_var = DoubleVar()

        self.pauseTrace = False

        self.scale = SubScale(self, variable=self.slider_var, width=20)

        self.namelabel = Label(self, font="Arial 7", bg=darkBg,

            fg='white', pady=0)

        self.sub.graph.addHandler(self.updateName)

        self.namelabel.pack(side=TOP)

        levellabel = Label(self, textvariable=self.slider_var, font="Arial 7",

            bg='black', fg='white', pady=0)

        levellabel.pack(side=TOP)

        self.scale.pack(side=BOTTOM, expand=1, fill=BOTH)

        bindkeys(self, "<Control-Key-l>", self.launch_subcomposer)

        # initial position

#        self.send_to_hw(sub.name, col + 1) # needs fix

    def cleanup(self):

        self.slider_var.trace_vdelete('w', self._slider_var_trace)

    def slider_changed(self, *args):

        self.scale.draw_indicator_colors()

        if self.pauseTrace:

            return

        self.updateGraphWithLevel(self.sub.uri, self.slider_var.get())

        # dispatcher.send("level changed") # in progress

        # needs fixing: plan is to use dispatcher or a method call to tell a hardware-mapping object who changed, and then it can make io if that's a current hw slider

        #if rowcount == self.current_row:

        #    self.send_to_hw(sub.name, col + 1)

    def updateGraphWithLevel(self, uri, level):

        self.graph = graph

        self.session = session

        self.submasters = Submasters(graph)

        self.subbox = {} # sub uri : SubmasterBox

        self.slider_table = {} # coords : SubmasterBox

        self.rows = [] # this holds Tk Frames for each row

        self.current_row = 0 # should come from session graph

        self.use_hw_sliders = hw_sliders

        self.connect_to_hw(hw_sliders)

        self.make_key_hints()

    def make_buttons(self):

        self.buttonframe = Frame(self, bg='black')

        self.buttonframe.pack(side=BOTTOM)

        self.sliders_status_var = IntVar()

        self.sliders_status_var.set(self.use_hw_sliders)

            text="Sliders", variable=self.sliders_status_var,

            command=lambda: self.toggle_slider_connectedness(),

            bg='black', fg='white')

        self.sliders_checkbutton.pack(side=LEFT)

            command=self.alltozero, bg='black', fg='white')

        self.alltozerobutton.pack(side='left')

            bg='black', fg='white')

        self.save_stage_button.pack(side=LEFT)

        self.sub_name = Entry(self.buttonframe, bg='black', fg='white')

        self.sub_name.pack(side=LEFT)

    def redraw_sliders(self):

        log.info("new %s", sub)

        self.graph.addHandler(self.draw_sliders)

    def onLostSub(self, subUri):

        log.info("lost %s", subUri)

        self.graph.addHandler(self.draw_sliders)

    def draw_sliders(self):

        for r in self.rows:

            r.destroy()

        self.rows = []

        for b in self.subbox.values():

            b.cleanup()

        self.subbox.clear()

        self.slider_table.clear()

        self.tk_focusFollowsMouse()

        rowcount = -1

        col = 0

        last_group = None

        # there are unlikely to be any subs at startup because we

        # probably haven't been called back with the graph data yet

                             sub)

            for sub in self.submasters.get_all_subs())

        dispatcher.connect(self.onNewSub, "new submaster")

        dispatcher.connect(self.onLostSub, "lost submaster")

        log.info("withgroups %s", withgroups)

            self.subbox[sub.uri] = self.slider_table[(rowcount, col)] = subbox

            self.setup_key_nudgers(subbox.scale)

            col = (col + 1) % 8

            last_group = group

    def toggle_slider_connectedness(self):

        self.use_hw_sliders = not self.use_hw_sliders

        if self.use_hw_sliders:

            self.sliders.reopen()

        else:

            self.sliders.close()

                                  nudge_keys['down']):

            # what a hack!

            downkey = downkey.replace('semicolon', ';')

            upkey, downkey = (upkey.upper(), downkey.upper())

            # another what a hack!

                width=1, font=('Arial', 10), bg='red', fg='white', anchor='c')

            keylabel.pack(side=LEFT, expand=1, fill=X)

            col += 1

        keyhintrow.pack(fill=X, expand=0)

        self.keyhints = keyhintrow

                # unfilled bottom row has holes (plus rows with incomplete

                # groups

                self.sliders.valueOut("button-upper%d" % col, False)

                self.sliders.valueOut("slider%d" % col, 0)

                continue

            self.send_to_hw(subbox.name, col)

    def got_nudger(self, number, direction, full=0):

        try:

            subbox = self.slider_table[(self.current_row, number)]

        except KeyError:

            return

            return # no slider assigned at that column

        subbox.scale.set(value)

    def send_to_hw(self, subUri, hwNum):

        if isinstance(self.sliders, DummySliders):

            return

        v = round(127 * self.slider_vars[subUri].get())

        chan = "slider%s" % hwNum

        # workaround for some rounding issue, where we receive one

        # value and then decide to send back a value that's one step

        # lower.  -5 is a fallback for having no last value.  hopefully

        # we won't really see it

        if abs(v - self.sliders.lastValue.get(chan, -5)) <= 1:

            return

        self.sliders.valueOut(chan, v)

    def make_row(self):

        row = Frame(self, bd=2, bg='black')

        row.pack(expand=1, fill=BOTH)

        self.setup_key_nudgers(row)

        self.rows.append(row)

        return row

    def unhighlight_row(self, row):

        row = self.rows[row]

        row['bg'] = 'black'

    def get_levels(self):

            for uri, box in self.subbox.items()])

    def get_levels_as_sub(self):

        scaledsubs = [self.submasters.get_sub_by_uri(sub) * level

            for sub, level in self.get_levels().items() if level > 0.0]

        maxes = sub_maxes(*scaledsubs)

    isLeaf = True

    def __init__(self,name_to_subbox):

        self.name_to_subbox = name_to_subbox

    def render_POST(self, request):

        arg = postArgGetter(request)

        if request.path == '/fadesub':

            # fadesub?subname=scoop&level=0&secs=.2

            self.name_to_subbox[arg('subname')].scale.fade(

                float(arg('level')),

                float(arg('secs')))

            return "set %s to %s" % (arg('subname'), arg('level'))

    logging.basicConfig(level=logging.INFO if opts.v else logging.WARN)

    log = logging.getLogger('keyboardcomposer')

    graph = SyncedGraph("keyboardcomposer")

    root = Tk()

    initTkdnd(root.tk, 'tkdnd/trunk/')

    session = clientsession.getUri('keyboardcomposer', opts)

    tl = toplevelat("Keyboard Composer - %s" % opts.session,

                              server.Site(LevelServerHttp(kc.name_to_subbox)))

        except twisted.internet.error.CannotListenError, e:

            log.warn("Can't (and won't!) start level server:")

            log.warn(e)

    root.protocol('WM_DELETE_WINDOW', reactor.stop)

    tksupport.install(root,ms=10)

#    prof.watchPoint("/usr/lib/python2.4/site-packages/rdflib-2.3.3-py2.4-linux-i686.egg/rdflib/Graph.py", 615)

    prof.run(reactor.run, profile=False)

        """send the client the whole graph contents"""

        log.info("sending all graphs to %s at %s" %

                 (self.label, self.updateUri))

        self.sendPatch(Patch(

            addQuads=self.db.graph.quads(ALLSTMTS),

            delQuads=[]))

    def sendPatch(self, p):

        return syncedgraph.sendPatch(self.updateUri, p)

class Db(object):

    """

    the master graph, all the connected clients, all the files we're watching

                # todo: also notice new files in this dir

            self.watchFile("show/dance2012/config.n3")

            self.watchFile("show/dance2012/patch.n3")

        finally:

            self.initialLoad = False

        self.summarizeToLog()

    def uriFromFile(self, filename):

        if filename.endswith('.n3'):

            # some legacy files don't end with n3. when we write them

            # back this might not go so well

            filename = filename[:-len('.n3')]

        return URIRef(self.topUri + filename)

    def fileForUri(self, ctx):

        if not ctx.startswith(self.topUri):

            raise ValueError("don't know what filename to use for %s" % ctx)

        return ctx[len(self.topUri):] + ".n3"

    def watchFile(self, inFile):

        ctx = self.uriFromFile(inFile)

        gf = GraphFile(self.notifier, inFile, ctx, self.patch, self.getSubgraph)

        self.graphFiles[ctx] = gf

        gf.reread()

    def patch(self, p, dueToFileChange=False):

        """

        apply this patch to the master graph then notify everyone about it

        dueToFileChange if this is a patch describing an edit we read

        *from* the file (such that we shouldn't write it back to the file)

            g = self.getSubgraph(ctx)

            if ctx not in self.graphFiles:

                outFile = self.fileForUri(ctx)

                self.graphFiles[ctx] = GraphFile(self.notifier, outFile, ctx,

                                                 self.patch, self.getSubgraph)

            self.graphFiles[ctx].dirty(g)

    def clientErrored(self, err, c):

        err.trap(twisted.internet.error.ConnectError)

        log.info("connection error- dropping client %r" % c)

        self.clients.remove(c)

    def summarizeToLog(self):

        log.info("contexts in graph (%s total stmts):" % len(self.graph))

        for c in self.graph.contexts():

            log.info("  %s: %s statements" %

                     (c.identifier, len(self.getSubgraph(c.identifier))))

        #return self.graph.get_context(uri)

        g = Graph()

        for s in self.graph.triples(ALLSTMTS, uri):

            g.add(s)

        return g

    def addClient(self, updateUri, label):

        [self.clients.remove(c)

         for c in self.clients if c.updateUri == updateUri]

        log.info("new client %s at %s" % (label, updateUri))

        self.clients.append(Client(updateUri, label, self))

        self.sendClientsToAllLivePages()

    def sendClientsToAllLivePages(self):

        sendToLiveClients({"clients":[

            dict(updateUri=c.updateUri, label=c.label)

class GraphResource(PrettyErrorHandler, cyclone.web.RequestHandler):

    def get(self):

class Patches(PrettyErrorHandler, cyclone.web.RequestHandler):

    def __init__(self, *args, **kw):

        cyclone.web.RequestHandler.__init__(self, *args, **kw)

        p = syncedgraph.makePatchEndpointPutMethod(self.settings.db.patch)

        self.put = lambda: p(self)

    def get(self):

        pass

class GraphClients(PrettyErrorHandler, cyclone.web.RequestHandler):

    def get(self):

        pass

    def post(self):

        upd = self.get_argument("clientUpdate")

        try:

            self.settings.db.addClient(upd, self.get_argument("label"))

        except:

            import traceback

def sendToLiveClients(d=None, asJson=None):

    j = asJson or json.dumps(d)

    for c in liveClients:

        c.sendMessage(j)

class Live(cyclone.websocket.WebSocketHandler):

    def connectionMade(self, *args, **kwargs):

        log.info("websocket opened")

        liveClients.add(self)

        self.settings.db.sendClientsToAllLivePages()

    def connectionLost(self, reason):

    log.setLevel(logging.DEBUG if options.verbose else logging.INFO)

    if not options.show:

        raise ValueError("missing --show http://...")

    db = Db()

    from twisted.python import log as twlog

    twlog.startLogging(sys.stdout)

    port = 8051

    reactor.listenTCP(port, cyclone.web.Application(handlers=[

        (r'/live', Live),

        (r'/graph', GraphResource),

        (r'/patches', Patches),

        (r'/graphClients', GraphClients),

from louie import dispatcher

log = logging.getLogger('submaster')

class Submaster(object):

    "Contain a dictionary of levels, but you didn't need to know that"

    def __init__(self, name, levels):

        See PersistentSubmaster.

        levels is a dict

        """

        self.name = name

        self.levels = levels

        self.temporary = True

        if not self.temporary:

            # obsolete

            dispatcher.connect(log.error, 'reload all subs')

        log.debug("%s initial levels %s", self.name, self.levels)

    def _editedLevels(self):

        pass

    def set_level(self, channelname, level, save=True):

        self.levels[Patch.resolve_name(channelname)] = level

        self._editedLevels()

    def set_all_levels(self, leveldict):

        self.levels.clear()

        for k, v in leveldict.items():

            # this may call _editedLevels too many times

            self.set_level(k, v, save=0)

    def get_levels(self):

        return self.levels

    def no_nonzero(self):

        return (not self.levels.values()) or not (max(self.levels.values()) > 0)

    def __mul__(self, scalar):

                         levels=dict_scale(self.levels, scalar))

    __rmul__ = __mul__

    def max(self, *othersubs):

        return sub_maxes(self, *othersubs)

    def __add__(self, other):

    def __repr__(self):

        items = getattr(self, 'levels', {}).items()

        items.sort()

        levels = ' '.join(["%s:%.2f" % item for item in items])

        return "<'%s': [%s]>" % (getattr(self, 'name', 'no name yet'), levels)

    def __cmp__(self, other):

        # not sure how useful this is

        return cmp(self.ident(), other.ident())

    def __hash__(self):

        return hash(self.ident())

    def get_dmx_list(self):

        leveldict = self.get_levels() # gets levels of sub contents

                raise

            if dmxchan >= len(levels):

                levels.extend([0] * (dmxchan - len(levels) + 1))

            levels[dmxchan] = max(v, levels[dmxchan])

        return levels

    def normalize_patch_names(self):

        """Use only the primary patch names."""

        # possibly busted -- don't use unless you know what you're doing

        self.set_all_levels(self.levels.copy())

    def get_normalized_copy(self):

        names.  The levels will be the same."""

        newsub = Submaster("%s (normalized)" % self.name, {})

        newsub.set_all_levels(self.levels)

        return newsub

    def crossfade(self, othersub, amount):

        """Returns a new sub that is a crossfade between this sub and

        NOTE: You should only crossfade between normalized submasters."""

        otherlevels = othersub.get_levels()

        keys_set = {}

        for k in self.levels.keys() + otherlevels.keys():

            keys_set[k] = 1

        all_keys = keys_set.keys()

        xfaded_sub = Submaster("xfade", {})

        for k in all_keys:

                                 linear_fade(self.levels.get(k, 0),

                                             otherlevels.get(k, 0),

                                             amount))

        return xfaded_sub

        self.graph = graph

        self.uri = uri

        self.temporary = False

    def ident(self):

        return self.uri

    def _editedLevels(self):

        self.save()

    def setName(self):

        log.info("sub update name %s %s", self.uri, self.graph.label(self.uri))

        self.name = self.graph.label(self.uri)

    def setLevels(self):

        log.info("sub update levels")

        oldLevels = getattr(self, 'levels', {}).copy()

        self.setLevelsFromGraph()

        if oldLevels != self.levels:

            log.info("sub %s changed" % self.name)

    def setLevelsFromGraph(self):

        if hasattr(self, 'levels'):

            self.levels.clear()

        else:

            self.levels = {}

        for lev in self.graph.objects(self.uri, L9['lightLevel']):

            graph.add((lev, L9['channel'], chanUri))

            graph.add((lev, L9['level'],

                       Literal(self.levels[chan], datatype=XSD['decimal'])))

        graph.serialize(showconfig.subFile(self.name), format="nt")

def linear_fade(start, end, amount):

    """Fades between two floats by an amount.  amount is a float between

    0 and 1.  If amount is 0, it will return the start value.  If it is 1,

    the end value will be returned."""

    level = start + (amount * (end - start))

    return level

class Submasters:

    "Collection o' Submaster objects"

    def __init__(self, graph):

        self.submasters = {}

        self.graph = graph

        graph.addHandler(self.findSubs)

    def findSubs(self):

        current = set()

        for s in self.graph.subjects(RDF.type, L9['Submaster']):

             self.graph.value(self.uri, L9['output']).rsplit('/c')[-1])

        # 3 widgets, left-to-right:

        # channel number -- will turn yellow when being altered

        self.num_lab = tk.Label(self, text=str(self.channelnum),

                                fg='white',

                                font=stdfont,

                                padx=0, pady=0, bd=0, height=1)

        self.num_lab.pack(side='left')

        # text description of channel

        self.desc_lab=tk.Label(self,

                               width=14,

                               font=stdfont,

                               anchor='w',

                 height=1, bg='black', fg='white')

        self.graph.addHandler(self.updateLabel)

        self.desc_lab.pack(side='left')

        # current level of channel, shows intensity with color

        self.level_lab = tk.Label(self, width=3, bg='lightBlue',

        self.setlevel(0)

        self.setupmousebindings()

    def updateLabel(self):

         self.desc_lab.config(text=self.graph.label(self.uri))

    def setupmousebindings(self):

        def b1down(ev):

            self.desc_lab.config(bg='cyan')

            self._start_y=ev.y

            self._start_lev=self.currentlevel

        def b1motion(ev):

                           ('<ButtonRelease-1>',b1up),

                           ('<ButtonPress-2>', b2down),

                           ('<ButtonRelease-3>', b3up),

                           ('<ButtonPress-3>', b3down)):

                w.bind(e,func)

    def colorlabel(self):

        """color the level label based on its own text (which is 0..100)"""

        txt=self.level_lab['text'] or "0"

        lev=float(txt)/100

        self.level_lab.config(bg=gradient(lev))

        rows = len(chans) // cols

        def make_frame(parent):

             f = tk.Frame(parent, bd=0, bg='black')

             f.pack(side='left')

             return f

        columnFrames = [make_frame(self) for x in range(cols)]

        for i, channel in enumerate(chans): # sort?

            # frame for this channel

            f = Onelevel(columnFrames[i // rows], self.graph, channel)

def serializeQuad(g):

    """replacement for graph.serialize(format='nquads')"""

    out = ""

    for s,p,o,c in g.quads((None,None,None)):

        out += u"%s %s %s %s .\n" % (s.n3(),

                                p.n3(),

                                c.n3())

    return out

def inContext(graph, newContext):

    """

    make a ConjunctiveGraph where all the triples in the given graph

    def testNquadParserSerializes(self):

        g = graphFromNQuad(self.nqOut)

        self.assertEqual(len(g), 1)

        out = serializeQuad(g)

        self.assertEqual(out.strip(), self.nqOut.strip())

stmt1 = U('http://a'), U('http://b'), U('http://c'), U('http://ctx1')

stmt2 = U('http://a'), U('http://b'), U('http://c'), U('http://ctx2')

class TestPatchQuads(unittest.TestCase):

    def testAddsToNewContext(self):

        g = ConjunctiveGraph()

    def testDeleteRunsBeforeAdd(self):

        g = ConjunctiveGraph()

        patchQuads(g, [stmt1], [stmt1])

        quads = list(g.quads((None,None,None)))

        self.assertEqual(quads, [stmt1])

    def testPerfectAddRejectsExistingStmt(self):

        g = ConjunctiveGraph()

        patchQuads(g, [], [stmt1])

        self.assertRaises(ValueError, patchQuads, g, [], [stmt1], perfect=True)

    def testPerfectAddAllowsExistingStmtInNewContext(self):

        patchQuads(g, [], [stmt2], perfect=True)

        self.assertEqual(len(list(g.quads((None,None,None)))), 2)

    def testPerfectDeleteRejectsAbsentStmt(self):

        g = ConjunctiveGraph()

        self.assertRaises(ValueError, patchQuads, g, [stmt1], [], perfect=True)

    def testPerfectDeleteAllowsRemovalOfStmtInMultipleContexts(self):

        g = ConjunctiveGraph()

        patchQuads(g, [], [stmt1, stmt2])

        patchQuads(g, [stmt1], [], perfect=True)

    def testRedundantStmtOkForAddOrDelete(self):

        g = ConjunctiveGraph()

        patchQuads(g, [], [stmt1, stmt1], perfect=True)

        patchQuads(g, [stmt1, stmt1], [], perfect=True)

        """

        #self.dependencies()

        affectedSubjPreds = set([(s, p) for s, p, o, c in patch.addQuads]+

                                [(s, p) for s, p, o, c in patch.delQuads])

        affectedPredObjs = set([(p, o) for s, p, o, c in patch.addQuads]+

                                [(p, o) for s, p, o, c in patch.delQuads])

        ret = set()

        for (s, p), funcs in self._handlersSp.iteritems():

            if (s, p) in affectedSubjPreds:

                ret.update(funcs)

                funcs.clear()

        for (p, o), funcs in self._handlersPo.iteritems():

            if (p, o) in affectedPredObjs:

                ret.update(funcs)

                funcs.clear()

        return ret

        data they depend on. This is meant for showing on the web ui

        for browsing.

        """

        log.info("whocares:")

        from pprint import pprint

        pprint(self._handlersSp)

class PatchSender(object):

    """

    SyncedGraph may generate patches faster than we can send

    them. This object buffers and may even collapse patches before

    they go the server

                for q in p.addQuads: print q

                print "----"

            else:

                p, sendResult = self._patchesToSend.pop(0)

        else:

            p, sendResult = self._patchesToSend.pop(0)

        self._currentSendPatchRequest = sendPatch(

            self.target, p, senderUpdateUri=self.myUpdateResource)

        self._currentSendPatchRequest.addCallbacks(self._sendPatchDone,

                                                   self._sendPatchErr)

        self._currentSendPatchRequest.chainDeferred(sendResult)

        # screen for only that type

        # this code is going away; we're going to raise an exception that contains all the pending patches

        log.error("_sendPatchErr")

        log.error(e)

        self._continueSending()

class SyncedGraph(object):

    """

    graph for clients to use. Changes are synced with the master graph

    in the rdfdb process.

        """

        label is a string that the server will display in association

        with your connection

        """

        _graph = self._graph = ConjunctiveGraph()

        self._watchers = GraphWatchers()

        def onPatch(p):

            """

            central server has sent us a patch

            """

            patchQuads(_graph, p.delQuads, p.addQuads, perfect=True)

            log.info("graph now has %s statements" % len(_graph))

            def __enter__(self2):

                # this should be a readonly view of the existing graph

                g = Graph()

                for s in self._graph.triples((None, None, None), context):

                    g.add(s)

                return g

            def __exit__(self, type, val, tb):

                return

        return Mgr()

    def _getCurrentFunc(self):

    # if you get a bnode in your response, maybe the answer to

    # dependency tracking is to say that you depended on the triple

    # that got you that bnode, since it is likely to change to another

    # bnode later. This won't work if the receiver stores bnodes

    # between calls, but probably most of them don't do that (they

    # work from a starting uri)

    def value(self, subject=None, predicate=RDF.value, object=None,

              default=None, any=True):

        if object is not None:

            raise NotImplementedError()

        func = self._getCurrentFunc()

        self._watchers.addSubjPredWatcher(func, subject, predicate)

                                 default=default, any=any)