from louie import dispatcher

from light9.rdfdb.syncedgraph import SyncedGraph

        self.sub = sub

        self.namelabel = Label(self, font="Arial 7", bg=darkBg,

        self.sub.graph.addHandler(self.updateName)

        self.namelabel.pack(side=TOP)

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

    def updateName(self):

        self.namelabel.config(text=self.sub.graph.label(self.sub.uri))

    def __init__(self, root, graph, current_sub_levels=None,

        self.submasters = Submasters(graph)

        self.make_key_hints()

        self.make_buttons()

        self.graph.addHandler(self.redraw_sliders)

    def make_buttons(self):

    def redraw_sliders(self):

        self.slider_vars = {} # this holds subname:sub Tk vars

        self.slider_table = {} # this holds coords:sub Tk vars

        self.name_to_subtk.clear() # subname : SubmasterTk instance

        self.graph.addHandler(self.draw_sliders)

        if len(self.rows):

            self.change_row(self.current_row)

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

    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)

        if hasattr(self, 'rows'):

            for r in self.rows:

                r.destroy()

        self.rows = [] # this holds Tk Frames for each row

        # there are unlikely to be any subs at startup because we

        # probably haven't been called back with the graph data yet

        #read get_all_subs then watch 'new submaster' 'lost submaster' signals

        dispatcher.connect(self.onNewSub, "new submaster")

        dispatcher.connect(self.onLostSub, "lost submaster")

        log.info("withgroups %s", withgroups)

                log.info("no hardware sliders")

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

    log = logging.getLogger('keyboardcomposer')

    graph = SyncedGraph("keyboardcomposer")

    kc = KeyboardComposer(tl, graph, startLevels,

        log.warn("Can't (and won't!) start level server:")

        log.warn(e)

them here. We should be able to take patches that are close in time

and keep updating the same data (e.g. a stream of changes as the user

drags a slider) and collapse them into a single edit for clarity.

                       "show/dance2012/subs/bwarm",

                       "show/dance2012/subs/house",

                       "demo.n3",

from rdflib import Graph, RDF

log = logging.getLogger('submaster')

class Submaster(object):

    def __init__(self, name, levels):

        """this sub has a name just for debugging. It doesn't get persisted. 

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

        return Submaster("%s*%s" % (self.name, 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):

        """Get a copy of this sumbaster that only uses the primary patch 

        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

        another submaster.  

        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:

            xfaded_sub.set_level(k, 

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

        patchGraph = showconfig.getGraph() # going away

        if hasattr(self, 'levels'):

            self.levels.clear()

        for lev in self.graph.objects(self.uri, L9['lightLevel']):

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

            val = self.graph.value(lev, L9['level'])

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

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

        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:

            del self.submasters[s]

            dispatcher.send("lost submaster", subUri=s)

        log.info("findSubs finished %s", self.submasters)

            if s.name and s.name.startswith('song'):

import logging, traceback

        try:

        except Exception:

            traceback.print_exc()

from rdflib import ConjunctiveGraph, RDFS, RDF

log = logging.getLogger('syncedgraph')

        self._handlersPo = {} # (p,o): set(handlers)

            log.error("with key %r and func %r" % (key, func))

    def addPredObjWatcher(self, func, p, o):

        self._handlersPo.setdefault((p, o), set()).add(func)

        """what handler functions would care about the changes in this patch?

        this removes the handlers that it gives you

        """

        affectedPredObjs = set([(p, o) for s, p, o, c in patch.addQuads]+

                                [(p, o) for s, p, o, c in patch.delQuads])

        for (s, p), funcs in self._handlersSp.iteritems():

                ret.update(funcs)

                funcs.clear()

        for (p, o), funcs in self._handlersPo.iteritems():

            if (p, o) in affectedPredObjs:

                ret.update(funcs)

                funcs.clear()

        log.info("whocares:")

        self.currentFuncs = [] # stack of addHandler callers

            log.debug("registered with rdfdb")

        self.currentFuncs.append(func)

            self.currentFuncs.pop()

            # todo: forget the old handlers for this func

    def _getCurrentFunc(self):

        if not self.currentFuncs:

        # we add the watcher to the deepest function, since that

        # should be the cheapest way to update when this part of the

        # data changes

        return self.currentFuncs[-1]

    # watch just that one.

    # if you get a bnode in your response, maybe the answer to

    # dependency tracking is to say that you depended on the triple

    # that got you that bnode, since it is likely to change to another

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

            raise NotImplementedError()

        func = self._getCurrentFunc()

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

        return self._graph.value(subject, predicate, object=object,

                                 default=default, any=any)

        func = self._getCurrentFunc()

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

    def subjects(self, predicate=None, object=None):

        func = self._getCurrentFunc()

        self._watchers.addPredObjWatcher(func, predicate, object)

        return self._graph.subjects(predicate, object)

    # i find myself wanting 'patch' versions of these calls that tell

    # you only what results have just appeared or disappeared. I think

    # I'm going to be repeating that logic a lot. Maybe just for the

    # subjects(RDF.type, t) call