self.sub = sub

        self.session = session

        bg = sub.graph.value(sub.uri, L9.color, default='#000000')

        rgb = webcolors.hex_to_rgb(bg)

        hsv = colorsys.rgb_to_hsv(*[x/255 for x in rgb])

        darkBg = webcolors.rgb_to_hex(tuple([x * 255 for x in colorsys.hsv_to_rgb(

            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)

        for w in [self, self.namelabel, levellabel]:

            dragSourceRegister(w, 'copy', 'text/uri-list', sub.uri)

        self._slider_var_trace = self.slider_var.trace('w', self.slider_changed)

        sub.graph.addHandler(self.updateLevelFromGraph)

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

        """in our per-session graph, we maintain SubSetting objects like this:

           ?session :subSetting [a :SubSetting; :sub ?s; :level ?l]

        """

        # move to syncedgraph patchMapping

        with self.sub.graph.currentState() as graph:

class KeyboardComposer(Frame, SubClient):

    def __init__(self, root, graph, session,

                 hw_sliders=True):

        Frame.__init__(self, root, bg='black')

        SubClient.__init__(self)

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

        self.make_buttons()

        self.graph.addHandler(self.redraw_sliders)

        self.send_levels_loop()

        self.graph.addHandler(self.rowFromGraph)

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

        self.graph.addHandler(self.draw_sliders)

        if len(self.rows):

            self.change_row(self.current_row)

            self.rows[self.current_row].focus()

        self.stop_frequent_update_time = 0

    def onNewSub(self, sub):

        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)

        for group, order, sub in withgroups:

            group = self.graph.value(sub.uri, L9['group'])

            if col == 0 or group != last_group:

                row = self.make_row()

                rowcount += 1

                col = 0

            subbox = SubmasterBox(row, sub, self.session)

            subbox.place(relx=col / 8, rely=0, relwidth=1 / 8, relheight=1)

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

        self.change_row(self.current_row)

        self.rows[self.current_row].focus()

    def connect_to_hw(self, hw_sliders):

        if hw_sliders:

            try:

    def make_key_hints(self):

        keyhintrow = Frame(self)

        col = 0

        for upkey, downkey in zip(nudge_keys['up'],

                                  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

    def setup_key_nudgers(self, tkobject):

        for d, keys in nudge_keys.items():

            for key in keys:

                # lowercase makes full=0

                keysym = "<KeyPress-%s>" % key

        for col in range(1, 9):

            try:

                subbox = self.slider_table[(self.current_row, col - 1)]

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

            except KeyError:

                # 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

        if direction == 'up':

            if full:

                subbox.scale.fade(1)

            else:

                subbox.scale.increase()

        else:

    def hw_slider_moved(self, col, value):

        value = int(value * 100) / 100

        try:

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

        except KeyError:

            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 highlight_row(self, row):

        row = self.rows[row]

        row['bg'] = 'red'

    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)

        return maxes

    def save_current_stage(self, subname):

        log.info("saving current levels as %s", subname)

        sub = self.get_levels_as_sub()

        sub.name = subname

        except KeyError:

            return fields[n].value

    return getArg

class LevelServerHttp(resource.Resource):

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

        else:

            raise NotImplementedError(repr(request))

class Sliders(BCF2000):

    def __init__(self, kc):

        devices = ['/dev/snd/midiC1D0', '/dev/snd/midiC2D0', '/dev/snd/midiC3D0']

    parser = OptionParser()

    parser.add_option('--no-sliders', action='store_true',

                      help="don't attach to hardware sliders")

    clientsession.add_option(parser)

    parser.add_option('-v', action='store_true', help="log info level")

    opts, args = parser.parse_args()

    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,

                    existingtoplevel=root, graph=graph, session=session)

    kc = KeyboardComposer(tl, graph, session,

                          hw_sliders=not opts.no_sliders)

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

                 anchor='w').pack(side='top',fill='x')

    if 0: # needs fixing, or maybe it's obsolete because other progs can just patch the rdf graph

        import twisted.internet

        try:

            reactor.listenTCP(networking.keyboardComposer.port,

                              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)

        self.sendAll()

    def __repr__(self):

        return "<%s client at %s>" % (self.label, self.updateUri)

    def sendAll(self):

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

    """

    def __init__(self):

        # files from cwd become uris starting with this. *should* be

        # building uris from the show uri in $LIGHT9_SHOW/URI

        # instead. Who wants to keep their data in the same dir tree

        # as the source code?!

                ]

            for topdir in dirs:

                for dirpath, dirnames, filenames in os.walk(topdir):

                    for base in filenames:

                        self.watchFile(os.path.join(dirpath, base))

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

        if p has a senderUpdateUri attribute, we won't send this patch

        back to the sender with that updateUri

        """

        ctx = p.getContext()

        log.info("patching graph %s -%d +%d" % (

        for a new file we have to create, or it might be for a

        transient context that we're not going to save

        if it's a ctx with no file, error

        """

        for ctx in ctxs:

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

    def getSubgraph(self, uri):

        """

        this is meant to return a live view of the given subgraph, but

        if i'm still working around an rdflib bug, it might return a

        copy

        and it's returning triples, but I think quads would be better

        """

        # this is returning an empty Graph :(

        #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

            traceback.print_exc()

            raise

liveClients = set()

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.info("websocket closed")

        liveClients.remove(self)

    def messageReceived(self, message):

        log.info("got message %s" % message)

        self.sendMessage(message)

        help='show URI, like http://light9.bigasterisk.com/show/dance2008',

                      default=showconfig.showUri())

    parser.add_option("-v", "--verbose", action="store_true",

                      help="logging.DEBUG")

    (options, args) = parser.parse_args()

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

        (r'/(.*)', NoExts,

         {"path" : "light9/rdfdb/web",

          "default_filename" : "index.xhtml"}),

        ], debug=True, db=db))

import os, logging, time

from rdflib import Graph, RDF

from rdflib import RDFS, Literal, BNode

from light9.namespaces import L9, XSD

from light9.TLUtility import dict_scale, dict_max

from light9 import Patch, showconfig

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

        return self.max(other)

    def ident(self):

        return (self.name, tuple(sorted(self.levels.items())))

    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

        levels = []

        for k, v in leveldict.items():

            if v == 0:

                continue

            try:

                dmxchan = Patch.get_dmx_channel(k) - 1

            except ValueError:

                log.error("error trying to compute dmx levels for submaster %s" % self.name)

                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

class PersistentSubmaster(Submaster):

    def __init__(self, graph, uri):

        self.graph, self.uri = graph, uri

        self.graph.addHandler(self.setName)

        self.graph.addHandler(self.setLevels)

        Submaster.__init__(self, self.name, self.levels)

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

            chan = self.graph.value(lev, L9['channel'])

            name = self.graph.label(chan)

            if not name:

                log.error("sub %r has channel %r with no name- leaving out that channel" % (self.name, chan))

                continue

                chanUri = Patch.get_channel_uri(chan)

            except KeyError:

                log.error("saving dmx channels with no :Channel node is not supported yet. Give channel %s a URI for it to be saved. Omitting this channel from the sub." % chan)

                continue

            lev = BNode()

            graph.add((subUri, L9['lightLevel'], lev))

            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

def sub_maxes(*subs):

    nonzero_subs = [s for s in subs if not s.no_nonzero()]

    name = "max(%s)" % ", ".join([repr(s) for s in nonzero_subs])

    return Submaster(name,

                     levels=dict_max(*[sub.levels for sub in nonzero_subs]))

    if name:

        maxes.name = name

    if permanent:

        maxes.temporary = False

    return maxes

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

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

            if s not in self.submasters:

                sub = self.submasters[s] = PersistentSubmaster(self.graph, s)

                dispatcher.send("new submaster", sub=sub)

                current.add(s)

        for s in set(self.submasters.keys()) - current:

        self.graph = graph

        self.uri = channelUri

        self.currentlevel = 0 # the level we're displaying, 0..1

        # no statement yet

        self.channelnum = int(

             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,