callbacks=[self.dirChange])

        finally:

            self.initialLoad = False

    def dirChange(self, watch, path, mask):

        if mask & IN_CREATE:

            self.watchFile(path.path)

    def watchFile(self, inFile):

        """

        consider adding a GraphFile to self.graphFiles

            return

        ctx = self.uriFromFile(inFile)

        gf = GraphFile(self.notifier, inFile, ctx,

                       self.patch, self.getSubgraph)

        self.graphFiles[ctx] = gf

        gf.reread()

    def dirtyFiles(self, ctxs):

        """mark dirty the files that we watch in these contexts.

        the ctx might not be a file that we already read; it might be

        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)

            self.graphFiles[ctx].dirty(g)

    def uriFromFile(self, filename):

        assert filename.endswith('.n3'), filename

        if not any(filename.startswith(t) for t in self.topDirsToWatch):

            raise ValueError("filename %s doesn't start with any of %s" %

        back to the sender with that updateUri

        """

        ctx = p.getContext()

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

            ctx, len(p.delQuads), len(p.addQuads)))

        patchQuads(self.graph, p.delQuads, p.addQuads, perfect=True)

        senderUpdateUri = getattr(p, 'senderUpdateUri', None)

        for c in self.clients:

            if c.updateUri == senderUpdateUri:

                # this client has self-applied the patch already

"""

from __future__ import division, nested_scopes

import time, logging

from optparse import OptionParser

import Tkinter as tk

import louie as dispatcher

from twisted.internet import reactor, tksupport, task

from run_local import log

log.setLevel(logging.DEBUG)

from light9.dmxchanedit import Levelbox

from light9.Patch import get_channel_name

from light9.uihelpers import toplevelat

from light9.rdfdb.syncedgraph import SyncedGraph

from light9.rdfdb import clientsession

from light9.tkdnd import initTkdnd

from light9.namespaces import L9

    """

    def __init__(self, master, graph, session):

        tk.Frame.__init__(self, master, bg='black')

        self.graph = graph

        self.session = session

        self._currentChoice = Observable(Local)

        # this is a PersistentSubmaster (even for local)

        self.currentSub = Observable(Submaster.PersistentSubmaster(

                    graph, self.makeLocal()))

        def pc(val):

            log.info("change viewed sub to %s", val)

        self._currentChoice.subscribe(pc)

        self.setupSubChoiceLinks()

        self.setupLevelboxUi()

    def setupSubChoiceLinks(self):

        graph = self.graph

        def ann():

            print "currently: session=%s currentSub=%r _currentChoice=%r" % (

                self.session, self.currentSub(), self._currentChoice())

    def levelsChanged(self, sub):

        if sub == self.currentSub():

            self.sendupdate()

    def makeLocal(self):

        # todo: where will these get stored, or are they local to this

        # subcomposer process and don't use PersistentSubmaster at all?

        new = URIRef("http://local/%s" % time.time())

        self.graph.patch(Patch(addQuads=[

            (new, RDF.type, L9['Submaster'], self.session),

    def _saveContext(self):

        """the context in which we should save all the lightLevel triples for

        this sub"""

        typeStmt = (self.uri, RDF.type, L9['Submaster'])

        with self.graph.currentState(tripleFilter=typeStmt) as current:

            try:

                ctx = current.contextsForStatement(typeStmt)[0]

            except IndexError:

                log.info("declaring %s to be a submaster" % self.uri)

                ctx = self.uri

                self.graph.patch(Patch(addQuads=[

                    (self.uri, RDF.type, L9['Submaster'], ctx),

        """set all levels to 0"""

        with self.graph.currentState() as g:

            levs = list(g.objects(self.uri, L9['lightLevel']))

        for lev in levs:

            self.graph.removeMappingNode(self._saveContext(), lev)

    def save(self):

        raise NotImplementedError("obsolete?")

        if self.temporary:

            log.info("not saving temporary sub named %s",self.name)

            return

class Local(object):

    """placeholder for the local uri that EditChoice does not

    manage. Set resourceObservable to Local to indicate that you're

    unlinked"""

    """

    Observable <-> linker UI

    widget for tying some UI to a shared resource for editing, or

    unlinking it (which means associating it with a local resource

    that's not named or shared). This object does not own the choice

        """

        this does not include an initial reread() call

        """

        self.path, self.uri = path, uri

        self.patch, self.getSubgraph = patch, getSubgraph

        if not os.path.exists(path):

            # can't start notify until file exists

            try:

                os.makedirs(os.path.dirname(path))

            except OSError:

                pass

            f = open(path, "w")

            f.close()

        self.flushDelay = 2 # seconds until we have to call flush() when dirty

        self.writeCall = None # or DelayedCall

        # emacs save comes in as IN_MOVE_SELF, maybe

        # I was hoping not to watch IN_CHANGED and get lots of

        # half-written files, but emacs doesn't close its files after

        # a write, so there's no other event. I could try to sleep

        from twisted.internet.inotify import IN_CLOSE_WRITE, IN_MOVED_FROM, IN_MODIFY, IN_DELETE, IN_DELETE_SELF, IN_CHANGED

        notifier.watch(FilePath(path), callbacks=[self.notify])

    def notify(self, notifier, filepath, mask):

        maskNames = humanReadableMask(mask)

            return

        try:

            if filepath.getModificationTime() == self.lastWriteTimestamp:

                return

        except OSError as e:

            return

        try:

            self.reread()

        except Exception:

            traceback.print_exc()

    def reread(self):

        new = Graph()

        try:

            new.parse(location=self.path, format='n3')

        except SyntaxError as e:

            print e

            traceback.print_exc()

            return

        except IOError as e:

            return

        old = inContext(old, self.uri)

        new = inContext(new, self.uri)

        p = Patch.fromDiff(old, new)

        if p:

            self.patch(p, dueToFileChange=True)

    def dirty(self, graph):

        """

        graph is the rdflib.Graph that contains the contents of the

        file. It is allowed to change. Note that dirty() will probably

        do the save later when the graph might be different.

        after a timer has passed, write it out. Any scheduling issues

        huge, and then we might want to take a hint from a client that

        it's a good time to save the files that it was editing, like

        when the mouse moves out of the client's window and might be

        going towards a text file editor

        """

        self.graphToWrite = graph

        if self.writeCall:

            self.writeCall.reset(self.flushDelay)

        else:

            self.writeCall = reactor.callLater(self.flushDelay, self.flush)

        t1 = time.time()

        self.graphToWrite.serialize(destination=f, format='n3')

        serializeTime = time.time() - t1

        f.close()

        self.lastWriteTimestamp = os.path.getmtime(tmpOut)

        os.rename(tmpOut, self.path)