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

    tl = toplevelat("Keyboard Composer - %s" % opts.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:

of adds.

later we PUT them back with patches (del/add lists) when there are

changes.

If we fail to reach a registered caller, we forget about it for future

calls. We could PUT empty diffs as a heartbeat to notice disappearing

callers faster.

A caller can submit a patch which we'll persist and broadcast to every

other client.

Maybe some subgraphs are for transient data (e.g. current timecode,

mouse position in curvecalc) that only some listeners want to hear about.

Deletes are graph-specific, so callers may be surprised to delete a

stmt from one graph but then find that statement is still true.

Alternate plan: would it help to insist that every patch is within

only one subgraph? I think it's ok for them to span multiple ones.

Inserts can be made on any subgraphs, and each subgraph is saved in

its own file. The file might not be in a format that can express

from rdflib import ConjunctiveGraph, RDFS, RDF, Graph

import logging, cyclone.httpclient, traceback, urllib

log = logging.getLogger('syncedgraph')

from light9.rdfdb.patch import Patch, ALLSTMTS

from light9.rdfdb.rdflibpatch import patchQuads

def sendPatch(putUri, patch, **kw):

    """

    kwargs will become extra attributes in the toplevel json object

    """

    body = patch.makeJsonRepr(kw)

    log.debug("send body: %r", body)

    def ok(done):

        if not str(done.code).startswith('2'):

    """

    SyncedGraph may generate patches faster than we can send

    them. This object buffers and may even collapse patches before

    they go the server

    """

    def __init__(self, target, myUpdateResource):

        self.target = target

        self.myUpdateResource = myUpdateResource

        self._patchesToSend = []

        self._currentSendPatchRequest = None

    def sendPatch(self, p):

        self._continueSending()

    def _continueSending(self):

        if not self._patchesToSend or self._currentSendPatchRequest:

            return

        if len(self._patchesToSend) > 1:

            log.info("%s patches left to send", len(self._patchesToSend))

            # this is where we could concatenate little patches into a

            # bigger one. Often, many statements will cancel each

            # other out. not working yet:

            if 0:

                p = self._patchesToSend[0].concat(self._patchesToSend[1:])

                print "concat down to"

                print 'dels'

                for q in p.delQuads: print q

                print 'adds'

                for q in p.addQuads: print q

                print "----"

            else:

        else:

        self._currentSendPatchRequest = sendPatch(

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

        self._currentSendPatchRequest.addCallbacks(self._sendPatchDone,

                                                   self._sendPatchErr)

    def _sendPatchDone(self, result):

        self._currentSendPatchRequest = None

        self._continueSending()

    def _sendPatchErr(self, e):

        self._currentSendPatchRequest = None

        # we're probably out of sync with the master now, since

        # SyncedGraph.patch optimistically applied the patch to our

        # local graph already. What happens to this patch? What

        # happens to further pending patches? Some of the further

        # patches, especially, may be commutable with the bad one and

    <fieldset>

      <legend>Messages</legend>

      <div id="out"></div>

    </fieldset>

    <script type="text/javascript" src="lib/jquery-1.7.2.min.js"></script>

    <script type="text/javascript" src="websocket.js"></script>

    <script type="text/javascript">

      // <![CDATA[

      $(function(){

          function onMessage(d) {

              if (d.clients !== undefined) {

                  $("#clients").empty().text(JSON.stringify(d.clients));

              }

              if (d.patch !== undefined) {

                  $("#patches").prepend(

                      $("<fieldset>").addClass("patch")

                          .append($("<legend>").text("Patch"))

                  );

              }

              $('#out').append($('<div>').text(JSON.stringify(d)));

          }

          reconnectingWebSocket("ws://localhost:8051/live", onMessage);

      });

      // ]]>

    </script>

  </body>

</html>

"""all the tiny tk helper functions"""

from __future__ import nested_scopes

windowlocations = {

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

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

    tl = existingtoplevel or Toplevel()

    tl.title(name)

    if name in windowlocations:

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

    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: