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)

    def cleanup(self):

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

    def slider_changed(self, *args):

        self.scale.draw_indicator_colors()

            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.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.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')

    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()

            b.cleanup()

        self.subbox.clear()

        self.slider_table.clear()

        self.tk_focusFollowsMouse()

        rowcount = -1

        # 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")

            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:

            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

                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)]

    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

        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)

        row['bg'] = 'black'

    def get_levels(self):

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

    def get_levels_as_sub(self):

    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(

    graph = SyncedGraph("keyboardcomposer")

    root = Tk()

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

            log.warn(e)

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

    tksupport.install(root,ms=10)

        self.sendPatch(Patch(

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

            delQuads=[]))

    def sendPatch(self, p):

        return syncedgraph.sendPatch(self.updateUri, p)

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

        finally:

            self.initialLoad = False

        self.summarizeToLog()

    def uriFromFile(self, filename):

            # 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)

        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

                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 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]

    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)

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

    def get(self):

        pass

    def post(self):

        upd = self.get_argument("clientUpdate")

        try:

        c.sendMessage(j)

class Live(cyclone.websocket.WebSocketHandler):

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

        log.info("websocket opened")

        liveClients.add(self)

        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),

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.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 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):

        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())

            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 = {}

        xfaded_sub = Submaster("xfade", {})

        for k in all_keys:

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

                                             otherlevels.get(k, 0),

                                             amount))

    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()

        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,

    def __init__(self, graph):

        self.submasters = {}

        self.graph = graph

        graph.addHandler(self.findSubs)

    def findSubs(self):

        # 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)

                               width=14,

                               font=stdfont,

                               anchor='w',

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

        self.graph.addHandler(self.updateLabel)

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

    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')

                           ('<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"

             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?

    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

        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')

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

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

        self.assertEqual(quads, [stmt1])

    def testPerfectAddRejectsExistingStmt(self):

        g = ConjunctiveGraph()

        patchQuads(g, [], [stmt1])

    def testPerfectDeleteRejectsAbsentStmt(self):

        g = ConjunctiveGraph()

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

    def testPerfectDeleteAllowsRemovalOfStmtInMultipleContexts(self):

        g = ConjunctiveGraph()

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

        g = ConjunctiveGraph()

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

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

                                [(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)

        log.info("whocares:")

        from pprint import pprint

        pprint(self._handlersSp)

class PatchSender(object):

    """

                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,

        log.error("_sendPatchErr")

        log.error(e)

        self._continueSending()

class SyncedGraph(object):

    """

        """

        _graph = self._graph = ConjunctiveGraph()

        self._watchers = GraphWatchers()

        def onPatch(p):

            """

            central server has sent us a patch

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

                    g.add(s)

                return g

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

                return

    # 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:

        func = self._getCurrentFunc()

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

        return self._graph.objects(subject, predicate)

    def label(self, uri):

        return self.value(uri, RDFS.label)

                                  onDropLeave=hover.restore,

                                  onDropPosition=onDropPosition,

                                  onDrop=wrappedDrop)

    if typeList is None:

        typeList = ['*']

    widget.tk.call(*(['tkdnd::drop_target', 'register', widget._w]+typeList))

    def savePos():

        geo = tl.geometry()

        # todo: need a way to filter out the startup window sizes that

        # weren't set by the user

        if geo.startswith("1x1") or geo.startswith(("378x85", "378x86")):

    x = int(x) % screenWidth

    y = int(y) % screenHeight

    return "%s+%s+%s" % (size, x, y)

def toggle_slider(s):

    if s.get() == 0:

    else:

        s.set(0)

def printout(t):

    print t

        if not k.startswith('__'):

            print k,getattr(ev,k)

    print ""

def eventtoparent(ev,sequence):

    "passes an event to the parent, screws up TixComboBoxes"

    def _varchanged(self,*args):

        self._setstate(self._variable.get())

    def invoke(self,*ev):

        if self._variable:

            self._variable.set(not self.state)

        else:

            self._setstate(not self.state)

        if self.oldcommand and self.state: # call command only when state goes to 1

            self.oldcommand()

        return "break"

        """

        cbname = self._master._register(callback)

        self._tk.call("trace", "variable", self._name, mode, cbname)

        # we build a list of the trace callbacks (the py functrions and the tcl functionnames)

        self.callbacklist[cbname] = mode

#        print "added trace:",callback,cbname

        return cbname

    trace=trace_variable

    def disable_traces(self):

#            DoubleVar.trace_vdelete(self,v[0],k)

            self._tk.call("trace", "vdelete", self._name, mode,cb)

            # but no master delete!

    def recreate_traces(self):

        for cb,mode in self.callbacklist.items():

#            self.trace_variable(v[0],v[1])

            self.delete_named(name)

        cbname = self.trace_variable('w',callback) # this will register in self.callbacklist too

        self.namedtraces[name] = cbname

        return cbname

    def delete_named(self, name):

        if name in self.namedtraces:

            cbname = self.namedtraces[name]

            self.trace_vdelete('w',cbname)

	    #self._tk.call("trace","vdelete",self._name,'w',cbname)

            print "FancyDoubleVar: successfully deleted trace named %s" % name