cids = self.lastseen.keys()

            if lastseen < now - purge_age:

                try:

                    del self.clientlevels[cid]

                except KeyError:

                    pass

        self.trackClientFreq(cid)

        return "ok"

    def xmlrpc_currentlevels(self, cid):

        """get a list of levels we're currently sending out. All

        channels beyond the list you get back, they're at zero."""

        # if this is still too slow, it might help to return a single

        # pickled string

        self.trackClientFreq(cid)

        trunc = self.combinedlevels[:]

        i = len(trunc) - 1

        if i < 0:

            return []

        while trunc[i] == 0 and i >= 0:

            i -= 1

        if i < 0:

            return []

        trunc = trunc[:i+1]

        return trunc

    def trackClientFreq(self, cid):

        if cid not in self.lastseen:

            print "hello new client %s" % cid

            self.clientfreq[cid]=Updatefreq()

from light9 import networking, Patch, showconfig, dmxclient, updatefreq

from louie import dispatcher

def poll(graph, serv, pollFreq):

    pollFreq.update()

    dispatcher.send("status", key="pollFreq", value=str(pollFreq))

    d = serv.callRemote("currentlevels", dmxclient._id)

    def received(dmxLevels):

        level = {} # filename : level

        for i, lev in enumerate(dmxLevels):

            if lev == 0:

                continue

            try:

                chan = Patch.get_channel_uri(Patch.get_channel_name(i + 1))

            except KeyError:

                continue

            for lyr in graph.objects(chan, L9['previewLayer']):

                for imgPath in graph.objects(lyr, L9['path']):

                    level[str(imgPath)] = lev

        ogl.newLevels(levels=level)

    d.addCallback(received)

    return d

class StatusKeys(tk.Frame):

    # watch out- this might be an accidental redo of what curvecalc

    # has. Or, maybe CC should use this obj

    def __init__(self, master):

        tk.Frame.__init__(self, master)

        dispatcher.connect(self.status, "status")

        self.row = {} # key name : (Frame, value Label)

    def status(self, key, value):

        if key not in self.row:

            f = tk.Frame(self)

            f.pack(side='top')

            tk.Label(f, text=key, font="arial 8").pack(side='left')

            l = tk.Label(f, text=value, font="arial 8")

            l.pack(side='left')

            self.row[key] = (f, l)

        else:

            row, lab = self.row[key]

            lab.config(text=value)

pollFreq = updatefreq.Updatefreq(samples=5)

graph = showconfig.getGraph()

filenames = []

for lyr in graph.objects(None, L9['previewLayer']):

    for p in graph.objects(lyr, L9['path']):

        filenames.append(str(p))

ogl = Surface(root, filenames, width=120, height=80, imgRescaleTo=128)

sk = StatusKeys(root)

sk.pack(side='top', fill='x')

serv = Proxy(networking.dmxServerUrl())

LoopingCall(poll, graph, serv, pollFreq).start(.1)

top = root.winfo_toplevel()

top.wm_title(dmxclient._id)

top.bind("<Control-Key-q>",lambda ev: reactor.stop)

top.bind("<Destroy>",lambda ev: reactor.stop)

top.protocol('WM_DELETE_WINDOW', reactor.stop)

if 0:

    import hotshot, hotshot.stats

    p = hotshot.Profile("/tmp/pro")

    p.runcall(reactor.run)

    p.close()

    hotshot.stats.load("/tmp/pro").sort_stats('time').print_stats()

else:

    reactor.run()

from louie import dispatcher

    """widget that adds multiple image files together with adjustable scales"""

    def __init__(self, master, filenames, width=512, height=270,

                 imgRescaleTo=None):

        """

        imgRescaleTo can be a length of pixels to reduce all the input

        images into. Try 64 for a low res drawing.

        """

        Togl.Opengl.__init__(self, master=master, width=width,

                             height=height, double=True, depth=0)

        self.width, self.height = width, height

            if imgRescaleTo:

                im.thumbnail((imgRescaleTo, imgRescaleTo))

    def redraw(self, event=None):

        """you set self.levels to dict and call tkRedraw"""

        assert 'GL_ARB_imaging' in glGetString(GL_EXTENSIONS).split()

        start = time.time()

        glClearColor(0.0, 0.0, 0.0, 0)

        glClear( GL_COLOR_BUFFER_BIT |GL_ACCUM_BUFFER_BIT)

        glEnable(GL_BLEND)

        glBlendFunc(GL_SRC_ALPHA, GL_ONE) # add

#        l=glGenLists(1)

#        glNewList(l,GL_COMPILE)

#        glEndList()

        # drawing to glAccum might be good

        layerTimes = []

        for filename, mag in self.levels.items():

            #print "pic %s at %f" % (filename, mag)

            t = time.time()

            self.drawWithAlpha(self.image[filename],

                               self.imageWidth, self.imageHeight, mag)

            layerTimes.append(time.time() - t)

        dispatcher.send("status", key="redraw",

                        value="%.1fms" % ((time.time() - start) * 1000))

        # this might be a good way to scale the color channels too,

        # but the blend might take two steps. Anyway,

        # GL_CONSTANT_COLOR seems not to work, so i'm not exploring

        # this right now.

        #glBlendFunc(GL_CONSTANT_COLOR, GL_ONE)

        #glBlendColor(.8, .5, .5, .5)

        if levels != self.levels:

            self.levels = levels

            self.tkRedraw()