import optparse, sys, logging

import cyclone.web

from rdflib import URIRef

from light9.rdfdb import clientsession

class App(object):

                                       )

    def launch(self, *args):

        print 'launch'

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

            (r'/stats', StatsForCyclone),

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.tkdnd import initTkdnd, dragSourceRegister, dropTargetRegister

from light9.rdfdb import clientsession

from light9.rdfdb.syncedgraph import SyncedGraph

from bcf2000 import BCF2000

    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",

        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)

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

        """

        # 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']))

    def updateName(self):

        def shortUri(u):

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

class KeyboardComposer(tk.Frame, SubClient):

    def __init__(self, root, graph, session,

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

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

            context=self.session,

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

    def highlight_row(self, row):

        row = self.rows[row]

        row['bg'] = 'red'

        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)

    graph.initiallySynced.addCallback(

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

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

    tksupport.install(root,ms=10)

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 = []

                    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]

        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

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

        musicState = self.music.getLatest()

        if 't' not in musicState:

            return

        t = musicState['t']

class SubClient:

    def __init__(self):

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

    def _send_sub(self):