from light9.Submaster import Submaster, sub_maxes

class pad(tk.Frame):

    levs = None  # Submaster : level

    def __init__(self, master, root, mag):

        make_attributes_from_args('master', 'mag')

        tk.Frame.__init__(self, master)

        self.levs = {}

        for xy, key, subname in [

            ((1, 1), 'KP_Up', 'centered'),

            ((1, 3), "KP_Down", 'third-c'),

            ((0, 2), 'KP_Left', 'scoop-l'),

            ((2, 2), 'KP_Right', 'scoop-r'),

            ((1, 0), 'KP_Divide', 'cyc'),

            ((0, 3), "KP_End", 'hottest'),

            ((2, 3), 'KP_Next', 'deepblues'),

            ((0, 4), 'KP_Insert', "zip_red"),

            ((2, 4), 'KP_Delete', "zip_orange"),

            ((3, 1), 'KP_Add', 'strobedim'),

            ((3, 3), 'KP_Enter', 'zip_blue'),

            ((1, 2), 'KP_Begin', 'scoop-c'),

        ]:

            sub = Submaster(subname)

            self.levs[sub] = 0

            l = tk.Label(self,

                         font="arial 12 bold",

                         anchor='w',

                         height=2,

                         relief='groove',

                         bd=5,

                         text="%s\n%s" % (key.replace('KP_', ''), sub.name))

            l.grid(column=xy[0], row=xy[1], sticky='news')

            root.bind(

                "<KeyPress-%s>" % key, lambda ev, sub=sub: self.bumpto(sub, 1))

            root.bind("<KeyRelease-%s>" % key,

                      lambda ev, sub=sub: self.bumpto(sub, 0))

    def bumpto(self, sub, lev):

        now = time.time()

        self.levs[sub] = lev * self.mag.get()

        self.master.after_idle(self.output)

    def output(self):

        dmxclient.outputlevels(dmx, clientid="bumppad")

root = tk.Tk()

root.tk_setPalette("maroon4")

root.wm_title("bumppad")

mag = tk.DoubleVar()

tk.Label(root,

         text="Keypad press/release activate sub; 1..5 set mag",

         font="Helvetica -12 italic",

         anchor='w').pack(side='bottom', fill='x')

pad(root, root, mag).pack(side='left', fill='both', exp=1)

magscl = tk.Scale(root,

                  orient='vertical',

                  from_=1,

                  to=0,

                  res=.01,

                  showval=1,

                  variable=mag,

                  label='mag',

                  relief='raised',

                  bd=1)

for i in range(1, 6):

    root.bind("<Key-%s>" % i, lambda ev, i=i: mag.set(math.sqrt((i) / 5)))

magscl.pack(side='left', fill='y')

root.mainloop()

#!bin/python

"""

Collector receives device attrs from multiple senders, combines

them, and sends output attrs to hardware. The combining part has

custom code for some attributes.

Input can be over http or zmq.

"""

from run_local import log

from rdflib import URIRef, Literal

from twisted.internet import reactor, utils

from txzmq import ZmqEndpoint, ZmqFactory, ZmqPullConnection

import json

import logging

import optparse

import time

import traceback

import cyclone.web, cyclone.websocket

from greplin import scales

from lib.cycloneerr import PrettyErrorHandler

from light9.collector.output import EnttecDmx, Udmx, DummyOutput

from light9.collector.collector import Collector

from light9.namespaces import L9

from light9 import networking

from rdfdb.syncedgraph import SyncedGraph

from light9.greplin_cyclone import StatsForCyclone

def parseJsonMessage(msg):

    body = json.loads(msg)

    settings = []

    for device, attr, value in body['settings']:

        if isinstance(value, str) and value.startswith('http'):

            value = URIRef(value)

        else:

            value = Literal(value)

        settings.append((URIRef(device), URIRef(attr), value))

    return body['client'], body['clientSession'], settings, body['sendTime']

def startZmq(port, collector):

    stats = scales.collection('/zmqServer', scales.PmfStat('setAttr'))

    zf = ZmqFactory()

    addr = 'tcp://*:%s' % port

    log.info('creating zmq endpoint at %r', addr)

    e = ZmqEndpoint('bind', addr)

    class Pull(ZmqPullConnection):

        #highWaterMark = 3

        def onPull(self, message):

            with stats.setAttr.time():

                # todo: new compressed protocol where you send all URIs up

                # front and then use small ints to refer to devices and

#!bin/python

"""

now launches like this:

% bin/curvecalc http://light9.bigasterisk.com/show/dance2007/song1

todo: curveview should preserve more objects, for speed maybe

"""

import sys

import imp

sys.path.append('/usr/lib/python2.7/dist-packages')  # For gtk

from twisted.internet import gtk3reactor

gtk3reactor.install()

from twisted.internet import reactor

import time, textwrap, os, optparse, linecache, signal, traceback, json

import gi

from gi.repository import Gtk

from gi.repository import GObject

from gi.repository import Gdk

from urllib.parse import parse_qsl

import louie as dispatcher

from rdflib import URIRef, Literal, RDF, RDFS

import logging

from run_local import log

from light9 import showconfig, networking

from light9.curvecalc import curveview

from light9.curvecalc.curve import Curveset

from light9.curvecalc.curveedit import serveCurveEdit

from light9.curvecalc.musicaccess import Music

from light9.curvecalc.output import Output

from light9.curvecalc.subterm import Subterm

from light9.curvecalc.subtermview import add_one_subterm

from light9.editchoicegtk import EditChoice, Local

from light9.gtkpyconsole import togglePyConsole

from light9.namespaces import L9

from light9.observable import Observable

from light9 import clientsession

from rdfdb.patch import Patch

from rdfdb.syncedgraph import SyncedGraph

from light9.wavelength import wavelength

class SubtermExists(ValueError):

    pass

class Main(object):

    def __init__(self, graph, opts, session, curveset, music):

        self.graph, self.opts, self.session = graph, opts, session

        self.curveset, self.music = curveset, music

        self.lastSeenInputTime = 0

        self.currentSubterms = [

        # there's a hang after this, maybe in sem_wait in two

        # threads. I don't know whose they are.

        # This fix affects profilers who want to write output at the end.

        os.kill(os.getpid(), signal.SIGKILL)

    def onCollapseAll(self, *args):

        self.curvesetView.collapseAll()

    def onCollapseNone(self, *args):

        self.curvesetView.collapseNone()

    def onDelete(self, *args):

        self.curvesetView.onDelete()

    def onPythonConsole(self, item):

        ns = dict()

        ns.update(globals())

        ns.update(self.__dict__)

        togglePyConsole(self, item, ns)

    def onSeeCurrentTime(self, item):

        dispatcher.send("see time")

    def onSeeTimeUntilEnd(self, item):

        dispatcher.send("see time until end")

    def onZoomAll(self, item):

        dispatcher.send("show all")

    def onPlayPause(self, item):

        # since the X coord in a curveview affects the handling, one

        # of them may be able to pick this up

        results = dispatcher.send("onPlayPause")

        times = [t for listener, t in results if t is not None]

        self.music.playOrPause(t=times[0] if times else None)

    def onSave(self, *args):

        # only doing curves still. I hope to eliminate all this.

        log.info("saving curves")

        self.curveset.save()

        log.info("saved")

    def makeStatusLines(self, master):

        """various labels that listen for dispatcher signals"""

        for row, (signame, textfilter) in enumerate([

            ('input time', lambda t: "%.2fs" % t),

            ('output levels', lambda levels: textwrap.fill(

                "; ".join([

                ]), 70)),

            ('update period', lambda t: "%.1fms" % (t * 1000)),

            ('update status', lambda x: str(x)),

        ]):

            key = Gtk.Label("%s:" % signame)

            value = Gtk.Label("")

            master.resize(row + 1, 2)

            master.attach(key, 0, 1, row, row + 1)

            master.attach(value, 1, 2, row, row + 1)

            key.set_alignment(1, 0)

            value.set_alignment(0, 0)

            dispatcher.connect(lambda val, value=value, tf=textfilter: value.

                               set_text(tf(val)),

                               signame,

                               weak=False)

        dispatcher.connect(lambda val: setattr(self, 'lastSeenInputTime', val),

                           'input time',

                           weak=False)

        master.show_all()

    def refreshCurveView(self):

        wtree = self.wtree

        mtimes = [

            os.path.getmtime(f) for f in [

                'light9/curvecalc/curveview.py',

                'light9/curvecalc/zoomcontrol.py',

            ]

        ]

        if (not hasattr(self, 'curvesetView') or

                self.curvesetView._mtimes != mtimes):

            print("reload curveview.py")

            curvesVBox = wtree.get_object("curves")

            zoomControlBox = wtree.get_object("zoomControlBox")

            [curvesVBox.remove(c) for c in curvesVBox.get_children()]

            [zoomControlBox.remove(c) for c in zoomControlBox.get_children()]

            try:

                linecache.clearcache()

                imp.reload(curveview)

                # old ones are not getting deleted right

                if hasattr(self, 'curvesetView'):

                    self.curvesetView.live = False

                # mem problem somewhere; need to hold a ref to this

                self.curvesetView = curveview.Curvesetview(

                    self.graph, curvesVBox, zoomControlBox, self.curveset)

#!bin/python

"""

Replaced by bin/collector

this is the only process to talk to the dmx hardware. other clients

can connect to this server and present dmx output, and this server

will max ('pile-on') all the client requests.

this server has a level display which is the final set of values that

goes to the hardware.

clients shall connect to the xmlrpc server and send:

  their PID (or some other cookie)

  a length-n list of 0..1 levels which will represent the channel

    values for the n first dmx channels.

server is port 8030; xmlrpc method is called outputlevels(pid,levellist).

todo:

  save dmx on quit and restore on restart

  if parport fails, run in dummy mode (and make an option for that too)

"""

from twisted.internet import reactor

from twisted.web import xmlrpc, server

import sys, time, os

from optparse import OptionParser

import run_local

import txosc.dispatch, txosc. async

from light9.io import ParportDMX, UsbDMX

from light9.updatefreq import Updatefreq

from light9 import networking

from txzmq import ZmqEndpoint, ZmqFactory, ZmqPullConnection, ZmqRequestTimeoutError

import json

def startZmq(port, outputlevels):

    zf = ZmqFactory()

    e = ZmqEndpoint('bind', 'tcp://*:%s' % port)

    s = ZmqPullConnection(zf, e)

    def onPull(message):

        msg = json.loads(message[0])

        outputlevels(msg['clientid'], msg['levellist'])

    s.onPull = onPull

class ReceiverApplication(object):

    """

    receive UDP OSC messages. address is /dmx/1 for dmx channel 1,

    arguments are 0-1 floats for that channel and any number of

    following channels.

    """

    def __init__(self, port, lightServer):

        self.port = port

        self.lightServer = lightServer

        self.receiver = txosc.dispatch.Receiver()

        self.receiver.addCallback("/dmx/*", self.pixel_handler)

        self._server_port = reactor.listenUDP(

            self.port,

            txosc. async .DatagramServerProtocol(self.receiver),

            interface='0.0.0.0')

        print("Listening OSC on udp port %s" % (self.port))

    def pixel_handler(self, message, address):

        # this is already 1-based though I don't know why

        startChannel = int(message.address.split('/')[2])

    def __init__(self, options):

        xmlrpc.XMLRPC.__init__(self)

        self.clientlevels = {}  # clientID : list of levels

        self.lastseen = {}  # clientID : time last seen

        self.clientfreq = {}  # clientID : updatefreq

        self.combinedlevels = []  # list of levels, after max'ing the clients

        self.clientschanged = 1  # have clients sent anything since the last send?

        self.options = options

        self.lastupdate = 0  # time of last dmx send

        self.laststatsprint = 0  # time

        # desired seconds between sendlevels() calls

        self.calldelay = 1 / options.updates_per_sec

        print("starting parport connection")

        self.parportdmx = UsbDMX(dimmers=90, port=options.dmx_device)

        if os.environ.get('DMXDUMMY', 0):

            self.parportdmx.godummy()

        else:

            self.parportdmx.golive()

        self.updatefreq = Updatefreq()  # freq of actual dmx sends

        self.num_unshown_updates = None

        self.lastshownlevels = None

        # start the loop

        self.sendlevels()

        # the other loop

        self.purgeclients()

    def purgeclients(self):

        """forget about any clients who haven't sent levels in a while.

        this runs in a loop"""

        purge_age = 10  # seconds

        reactor.callLater(1, self.purgeclients)

        now = time.time()

        cids = list(self.lastseen.keys())

        for cid in cids:

            lastseen = self.lastseen[cid]

            if lastseen < now - purge_age:

                print(("forgetting client %s (no activity for %s sec)" %

                try:

                    del self.clientlevels[cid]

                except KeyError:

                    pass

                del self.clientfreq[cid]

                del self.lastseen[cid]

    def sendlevels(self):

        """sends to dmx if levels have changed, or if we havent sent

        in a while"""

        reactor.callLater(self.calldelay, self.sendlevels)

        if self.clientschanged:

            # recalc levels

            self.calclevels()

            if (self.num_unshown_updates is None or  # first time

                    self.options.fast_updates or  # show always

                (

                    self.combinedlevels != self.lastshownlevels and  # changed

                    self.num_unshown_updates > 5)):  # not too frequent

                self.num_unshown_updates = 0

                self.printlevels()

                self.lastshownlevels = self.combinedlevels[:]

            else:

                self.num_unshown_updates += 1

        if time.time() > self.laststatsprint + 2:

            self.laststatsprint = time.time()

            self.printstats()

        # used to be a fixed 1 in here, for the max delay between

        # calls, instead of calldelay

        if self.clientschanged or time.time(

        ) > self.lastupdate + self.calldelay:

            self.lastupdate = time.time()

            self.sendlevels_dmx()

        self.clientschanged = 0  # clear the flag

    def calclevels(self):

        """combine all the known client levels into self.combinedlevels"""

        self.combinedlevels = []

        for chan in range(0, self.parportdmx.dimmers):

            x = 0

            for clientlist in list(self.clientlevels.values()):

                if len(clientlist) > chan:

                    # clamp client levels to 0..1

                    cl = max(0, min(1, clientlist[chan]))

                    x = max(x, cl)

            self.combinedlevels.append(x)

    def printlevels(self):

        """write all the levels to stdout"""

    def printstats(self):

        """print the clock, freq, etc, with a \r at the end"""

        sys.stdout.write("dmxserver up at %s, [polls %s] " % (

            time.strftime("%H:%M:%S"),

            str(self.updatefreq),

        ))

        for cid, freq in list(self.clientfreq.items()):

            sys.stdout.write("[%s %s] " % (cid, str(freq)))

        sys.stdout.write("\r")

        sys.stdout.flush()

    def sendlevels_dmx(self):

        """output self.combinedlevels to dmx, and keep the updates/sec stats"""

        # they'll get divided by 100

        if self.parportdmx:

            self.parportdmx.sendlevels([l * 100 for l in self.combinedlevels])

        self.updatefreq.update()

    def xmlrpc_echo(self, x):

        return x

    def xmlrpc_outputlevels(self, cid, levellist):

        """send a unique id for your client (name+pid maybe), then

        the variable-length dmx levellist (scaled 0..1)"""

        if levellist != self.clientlevels.get(cid, None):

            self.clientlevels[cid] = levellist

            self.clientschanged = 1

        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

#!bin/python

from run_local import log

from twisted.internet import reactor

from twisted.internet.defer import inlineCallbacks, returnValue

import cyclone.web, cyclone.websocket, cyclone.httpclient

import sys, optparse, logging, subprocess, json, itertools

from rdflib import URIRef, Literal

sys.path.append('/usr/lib/pymodules/python2.7/')  # for numpy, on rpi

sys.path.append('/usr/lib/python2.7/dist-packages')  # For numpy

from light9 import networking, showconfig

from light9.effecteval.effect import EffectNode

from light9.effect.edit import getMusicStatus, songNotePatch

from light9.effecteval.effectloop import makeEffectLoop

from light9.greplin_cyclone import StatsForCyclone

from light9.namespaces import L9

from rdfdb.patch import Patch

from rdfdb.syncedgraph import SyncedGraph

from greplin import scales

from lib.cycloneerr import PrettyErrorHandler

class EffectEdit(PrettyErrorHandler, cyclone.web.RequestHandler):

    def get(self):

        self.set_header('Content-Type', 'text/html')

        self.write(open("light9/effecteval/effect.html").read())

    def delete(self):

        graph = self.settings.graph

        uri = URIRef(self.get_argument('uri'))

        with graph.currentState(tripleFilter=(None, L9['effect'], uri)) as g:

            song = ctx = list(g.subjects(L9['effect'], uri))[0]

        self.settings.graph.patch(

            Patch(delQuads=[

                (song, L9['effect'], uri, ctx),

            ]))

@inlineCallbacks

def currentSong():

    s = (yield getMusicStatus())['song']

    if s is None:

        raise ValueError("no current song")

    returnValue(URIRef(s))

class SongEffects(PrettyErrorHandler, cyclone.web.RequestHandler):

#!bin/python

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 twisted.web import resource

from rdflib import URIRef, Literal

import tkinter.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, RDF, RDFS

from light9.tkdnd import initTkdnd, dragSourceRegister, dropTargetRegister

from light9 import clientsession

from rdfdb.syncedgraph import SyncedGraph

from light9.effect.sequencer import CodeWatcher

import light9.effect.effecteval

from light9.effect.settings import DeviceSettings

from rdfdb.patch import Patch

from light9.effect.simple_outputs import SimpleOutputs

from bcf2000 import BCF2000

import imp

nudge_keys = {'up': list('qwertyui'), 'down': list('asdfghjk')}

class DummySliders:

    def valueOut(self, name, value):

        pass

    def close(self):

        pass

    def reopen(self):

        pass

class SubScale(tk.Scale, Fadable):

    def __init__(self, master, *args, **kw):

        self.scale_var = kw.get('variable') or tk.DoubleVar()

        kw.update({

            'variable': self.scale_var,

        v = round(127 * level)

        chan = "slider%s" % hwCol

        # workaround for some rounding issue, where we receive one

        # value and then decide to send back a value that's one step

        # lower.  -5 is a fallback for having no last value.  hopefully

        # we won't really see it

        if abs(v - self.sliders.lastValue.get(chan, -5)) <= 1:

            return

        self.sliders.valueOut(chan, v)

    def make_row(self, group):

        """group is a URI or None"""

        row = tk.Frame(self, bd=2, bg='black')

        row.subGroup = group

        def onDrop(ev):

            self.change_group(sub=URIRef(ev.data), row=row)

            return "link"

        dropTargetRegister(row,

                           onDrop=onDrop,

                           typeList=['*'],

                           hoverStyle=dict(background="#555500"))

        row.pack(expand=1, fill=tk.BOTH)

        self.setup_key_nudgers(row)

        self.rows.append(row)

        return row

    def change_group(self, sub, row):

        """update this sub's group, and maybe other sub groups as needed, so

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

    def get_output_settings(self, _graph=None):

        _graph = _graph or self.graph

        outputSettings = []

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

            effect = _graph.value(setting, L9['sub'])

            strength = _graph.value(setting, L9['level'])

            if strength:

                now = time.time()

                out, report = self.effectEval[effect].outputFromEffect(

                    [(L9['strength'], strength)],

                    songTime=now,

                    # should be counting from when you bumped up from 0

                    noteTime=now)

                outputSettings.append(out)

        return DeviceSettings.fromList(_graph, outputSettings)

    def save_current_stage(self, subname):

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

        with self.graph.currentState() as g:

            ds = self.get_output_settings(_graph=g)

        effect = L9['effect/%s' % subname]

        ctx = URIRef(showconfig.showUri() + '/effect/' + subname)

        stmts = ds.statements(effect, ctx, effect + '/', set())

        stmts.extend([

            (effect, RDF.type, L9['Effect'], ctx),

            (effect, RDFS.label, Literal(subname), ctx),

            (effect, L9['publishAttr'], L9['strength'], ctx),

        ])

        self.graph.suggestPrefixes(ctx, {'eff': effect + '/'})

        self.graph.patch(Patch(addQuads=stmts, delQuads=[]))

        self.sub_name.delete(0, tk.END)

    def alltozero(self):

        for uri, subbox in list(self.subbox.items()):

            if subbox.scale.scale_var.get() != 0:

                subbox.scale.fade(value=0.0, length=0)

# move to web lib

def postArgGetter(request):

    """return a function that takes arg names and returns string

    values. Supports args encoded in the url or in postdata. No

    support for repeated args."""

    # this is something nevow normally does for me

#!bin/python

import run_local

import sys, logging

sys.path.append("lib")

import qt4reactor

qt4reactor.install()

from twisted.internet import reactor

from twisted.internet.task import LoopingCall

from twisted.web.xmlrpc import Proxy

from louie import dispatcher

from PyQt4.QtGui import QWidget, QLabel, QVBoxLayout, QHBoxLayout, QMainWindow

from OpenGL.GL import *

from OpenGL.GLU import *

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

from light9.namespaces import L9

from lightsim.openglsim import Surface

log = logging.getLogger()

logging.basicConfig(

    format=

    "%(asctime)s %(levelname)-5s %(name)s %(filename)s:%(lineno)d: %(message)s")

log.setLevel(logging.DEBUG)

def filenamesForChan(graph, chan):

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

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

            yield imgPath

_lastLevels = None

def poll(graph, serv, pollFreq, oglSurface):

    pollFreq.update()

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

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

    def received(dmxLevels):

        global _lastLevels

        if dmxLevels == _lastLevels:

            return

        _lastLevels = dmxLevels

        level = {}  # filename : level

        for i, lev in enumerate(dmxLevels):

#!bin/python

from run_local import log

import json

from twisted.internet import reactor

from light9.greplin_cyclone import StatsForCyclone

from 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 import clientsession

import light9.paint.solve

from lib.cycloneerr import PrettyErrorHandler

from light9.namespaces import RDF, L9, DEV

import imp

class Solve(PrettyErrorHandler, cyclone.web.RequestHandler):

    def post(self):

        painting = json.loads(self.request.body)

        with self.settings.stats.solve.time():

            img = self.settings.solver.draw(painting)

            sample, sampleDist = self.settings.solver.bestMatch(

                img, device=DEV['aura2'])

            with self.settings.graph.currentState() as g:

                bestPath = g.value(sample, L9['imagePath']).replace(L9[''], '')

            #out = solver.solve(painting)

            #layers = solver.simulationLayers(out)

        self.write(

            json.dumps({

                'bestMatch': {

                    'uri': sample,

                    'path': bestPath,

                    'dist': sampleDist

                },

                #    'layers': layers,

                #    'out': out,

            }))