from light9.rdfdb.syncedgraph import SyncedGraph

from light9 import networking, showconfig

from greplin import scales

import optparse, sys, logging

import cyclone.web

from rdflib import URIRef

from light9.rdfdb import clientsession

class App(object):

    def __init__(self, show, session):

        self.show = show

        self.session = session

                                       scales.PmfStat('evals'),

                                       scales.PmfStat('sendOutput'),

                                       scales.IntStat('errors'),

                                       )

    def launch(self, *args):

        print 'launch'

        self.cycloneApp = cyclone.web.Application(handlers=[

            (r'/stats', StatsForCyclone),

        ],

                                                  debug=True,

                                                  graph=self.graph,

from run_local import log

import cgi, time, logging

from optparse import OptionParser

import webcolors, colorsys

from louie import dispatcher

from twisted.internet import reactor, tksupport

from rdflib import URIRef, Literal

import Tix as tk

from light9.Fadable import Fadable

from light9.subclient import SubClient

from light9 import showconfig, networking, prof

from light9.uihelpers import toplevelat

from light9.namespaces import L9

from light9.tkdnd import initTkdnd, dragSourceRegister, dropTargetRegister

from light9.rdfdb import clientsession

from light9.rdfdb.syncedgraph import SyncedGraph

from bcf2000 import BCF2000

nudge_keys = {

    'up'   : list('qwertyui'),

    'down' : list('asdfghjk')

class SubmasterBox(tk.Frame):

    """

    this object owns the level of the submaster (the rdf graph is the

    real authority)

    """

        self.sub = sub

        self.session = session

        self.col, self.row = col, row

        rgb = webcolors.hex_to_rgb(bg)

        hsv = colorsys.rgb_to_hsv(*[x/255 for x in rgb])

        darkBg = webcolors.rgb_to_hex(tuple([x * 255 for x in colorsys.hsv_to_rgb(

            hsv[0], hsv[1], .2)]))

        tk.Frame.__init__(self, master, bd=1, relief='raised', bg=bg)

        self.slider_var = tk.DoubleVar()

        self.pauseTrace = False

        self.scale = SubScale(self, variable=self.slider_var, width=20)

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

            fg='white', pady=0)

        self.namelabel.pack(side=tk.TOP)

        levellabel = tk.Label(self, textvariable=self.slider_var, font="Arial 6",

            bg='black', fg='white', pady=0)

        levellabel.pack(side=tk.TOP)

        self.scale.pack(side=tk.BOTTOM, expand=1, fill=tk.BOTH)

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

        self._slider_var_trace = self.slider_var.trace('w', self.slider_changed)

        # initial position

        # stil need? dispatcher.send("send_to_hw", sub=sub.uri, hwCol=col + 1)

    def cleanup(self):

        self.slider_var.trace_vdelete('w', self._slider_var_trace)

    def slider_changed(self, *args):

        self.scale.draw_indicator_colors()

        if self.pauseTrace:

            return

        # needs fixing: plan is to use dispatcher or a method call to tell a hardware-mapping object who changed, and then it can make io if that's a current hw slider

                        boxRow=self.row)

    def updateGraphWithLevel(self, uri, level):

        """in our per-session graph, we maintain SubSetting objects like this:

           ?session :subSetting [a :SubSetting; :sub ?s; :level ?l]

        """

        # move to syncedgraph patchMapping

    def updateLevelFromGraph(self):

        """read rdf level, write it to subbox.slider_var"""

        # move this to syncedgraph readMapping

        for setting in graph.objects(self.session, L9['subSetting']):

                self.pauseTrace = True # don't bounce this update back to server

                try:

                    self.slider_var.set(graph.value(setting, L9['level']))

                finally:

                    self.pauseTrace = False

    def updateName(self):

        def shortUri(u):

            return '.../' + u.split('/')[-1]

class KeyboardComposer(tk.Frame, SubClient):

    def __init__(self, root, graph, session,

                 hw_sliders=True):

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

        SubClient.__init__(self)

        self.graph = graph

        self.session = session

        self.subbox = {} # sub uri : SubmasterBox

        self.slider_table = {} # coords : SubmasterBox

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

        self.current_row = 0 # should come from session graph

            b.cleanup()

        self.subbox.clear()

        self.slider_table.clear()

        self.tk_focusFollowsMouse()

        rowcount = -1

        col = 0

        last_group = None

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

            if col == 0 or group != last_group:

                row = self.make_row(group)

                rowcount += 1

                col = 0

            subbox.place(relx=col / 8, rely=0, relwidth=1 / 8, relheight=1)

            self.setup_key_nudgers(subbox.scale)

            col = (col + 1) % 8

            last_group = group

    def toggle_slider_connectedness(self):

        self.use_hw_sliders = not self.use_hw_sliders

        if self.use_hw_sliders:

            except KeyError:

                # unfilled bottom row has holes (plus rows with incomplete

                # groups

                self.sliders.valueOut("button-upper%d" % col, False)

                self.sliders.valueOut("slider%d" % col, 0)

                continue

                            boxRow=self.current_row)

    def got_nudger(self, number, direction, full=0):

        try:

            subbox = self.slider_table[(self.current_row, number)]

        except KeyError:

        this sub displays in this row"""

        group = row.subGroup

        self.graph.patchObject(

            context=self.session,

            subject=sub, predicate=L9['group'], newObject=group)

    def highlight_row(self, row):

        row = self.rows[row]

        row['bg'] = 'red'

    def unhighlight_row(self, row):

        row = self.rows[row]

        row['bg'] = 'black'

    def get_levels(self):

        return dict([(uri, box.slider_var.get())

            for uri, box in self.subbox.items()])

        for setting in graph.objects(self.session, L9['subSetting']):

    def save_current_stage(self, subname):

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

        with self.graph.currentState() as current:

            sub = self.get_levels_as_sub(graph=current)

        log.debug("new sub for reference: %r", sub)

    session = clientsession.getUri('keyboardcomposer', opts)

    graph.initiallySynced.addCallback(

        lambda _: launch(opts, root, graph, session))

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

    tksupport.install(root,ms=10)

    prof.run(reactor.run, profile=None)

copies from effectloop.py, which this should replace

'''

from __future__ import division

from rdflib import URIRef, Literal

from twisted.internet import reactor

from light9.vidref.musictime import MusicTime

log = logging.getLogger('sequencer')

class Note(object):

    def __init__(self, graph, uri):

        g = self.graph = graph

        self.uri = uri

        floatVal = lambda s, p: float(g.value(s, p).toPython())

        originTime = floatVal(uri, L9['originTime'])

        self.points = []

        for curve in g.objects(uri, L9['curve']):

            if g.value(curve, L9['attr']) != L9['strength']:

                continue

            for point in g.objects(curve, L9['point']):

                self.points.append((

                    originTime + floatVal(point, L9['time']),

                    floatVal(point, L9['value'])))

            self.points.sort()

    def activeAt(self, t):

        return self.points[0][0] <= t <= self.points[-1][0]

    def evalCurve(self, t):

        i = bisect.bisect_left(self.points, (t, None)) - 1

        p1, p2 = self.points[i], self.points[i + 1]

        frac = (t - p1[0]) / (p2[0] - p1[0])

        y = p1[1] + (p2[1] - p1[1]) * frac

        return y

    def outputSettings(self, t):

        color = [0, 0, 0]

            color[0] = c

            color[2] = c

        return [

            # device, attr, lev

             URIRef("http://light9.bigasterisk.com/color"),

             Literal(rgb_to_hex(color)))

            ]

class Sequencer(object):

    def __init__(self, graph, sendToCollector):

        self.graph = graph

        self.sendToCollector = sendToCollector

        self.music = MusicTime(period=.2, pollCurvecalc=False)

                self.notes[song].append(Note(g, note))

    def update(self):

        reactor.callLater(1/30, self.update)

        musicState = self.music.getLatest()

        if 't' not in musicState:

            return

        t = musicState['t']

        settings = []

class SubClient:

    def __init__(self):

        """assumed that your init saves self.graph"""

        pass # we may later need init code for network setup

        """This function assumes that we are an instance of a Tk object

        (or at least that we have an 'after' method)"""

        self.graph.addHandler(self.send_levels)

        self.after(delay, self.send_levels_loop, delay)

    def _send_sub(self):