else:

                break

        self.kc = kc

    def valueIn(self, name, value):

        kc = self.kc

        if name.startswith("slider"):

            kc.hw_slider_moved(int(name[6:]) - 1, value / 127)

        elif name.startswith("button-upper"):

            kc.change_row(kc.current_row)

        elif name.startswith("button-lower"):

            col = int(name[12:]) - 1

            self.valueOut(name, 0)

            try:

                tkslider = kc.slider_table[(kc.current_row, col)]

            except KeyError:

                return

            slider_var = tkslider.slider_var

            if slider_var.get() == 1:

                slider_var.set(0)

            else:

                slider_var.set(1)

        elif name.startswith("button-corner"):

            button_num = int(name[13:]) - 1

            if button_num == 1:

                diff = -1

            elif button_num == 3:

                diff = 1

            else:

                return

            kc.change_row(kc.current_row + diff)

            self.valueOut(name, 0)

if __name__ == "__main__":

    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)

    for helpline in ["Bindings: B3 mute; C-l edit levels in subcomposer"]:

        tk.Label(root,text=helpline, font="Helvetica -12 italic",

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

        self.sendClientsToAllLivePages()        

    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)

            for c in self.clients]})        

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)

class NoExts(cyclone.web.StaticFileHandler):

    # .xhtml pages can be get() without .xhtml on them

    def get(self, path, *args, **kw):

        if path and '.' not in path:

    'sub' : '425x738+00+00',

    'console' : '168x24+848+000',

    'leveldisplay' : '144x340+870+400',

    'cuefader' : '314x212+546+741',

    'effect' : '24x24+0963+338',

    'stage' : '823x683+37+030',

    'scenes' : '504x198+462+12',

}

def bindkeys(root,key, func):

    root.bind(key, func)

    for w in root.winfo_children():

        w.bind(key, func)

def toplevel_savegeometry(tl,name):

    try:

        geo = tl.geometry()

        if not geo.startswith("1x1"):

            f=open(".light9-window-geometry-%s" % name.replace(' ','_'),'w')

            f.write(tl.geometry())

        # else the window never got mapped

    except Exception, e:

        # it's ok if there's no saved geometry

        pass

def toplevelat(name, existingtoplevel=None, graph=None, session=None):

    tl = existingtoplevel or Toplevel()

    tl.title(name)

    lastSaved = [None]

    setOnce = [False]

    def setPosFromGraphOnce():

        """

        the graph is probably initially empty, but as soon as it gives

        us one window position, we stop reading them

        """

        if setOnce[0]:

            return

        geo = graph.value(session, L9.windowGeometry)

        if geo is not None and geo != lastSaved[0]:

            setOnce[0] = True

            tl.geometry(geo)

            lastSaved[0] = geo

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

            return

        if geo == lastSaved[0]:

            return

        lastSaved[0] = geo

        graph.patchObject(session, session, L9.windowGeometry, Literal(geo))

    if graph is not None and session is not None:

        graph.addHandler(setPosFromGraphOnce)

    if name in windowlocations:

        tl.geometry(positionOnCurrentDesktop(windowlocations[name]))

    if graph is not None:

        tl._toplevelat_funcid = tl.bind("<Configure>",lambda ev,tl=tl,name=name: savePos())

    return tl

def positionOnCurrentDesktop(xform, screenWidth=1920, screenHeight=1440):

    size, x, y = xform.split('+')

    x = int(x) % screenWidth

    y = int(y) % screenHeight

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

def toggle_slider(s):

    if s.get() == 0:

        s.set(100)

    else:

        s.set(0)

# for lambda callbacks    

def printout(t):

    print t

def printevent(ev):

    for k in dir(ev):

        if not k.startswith('__'):

            print k,getattr(ev,k)

    print ""

def eventtoparent(ev,sequence):

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

    wid_class = str(ev.widget.__class__)

    if wid_class == 'Tix.ComboBox' or wid_class == 'Tix.TixSubWidget':