#!/usr/bin/python

"""

todo: curveview should preserve more objects, for speed maybe

"""

from __future__ import division

from bisect import bisect_left,bisect,bisect_right

import Tkinter as tk

from dispatch import dispatcher

from twisted.internet import reactor,tksupport

import twisted

from twisted.web.xmlrpc import Proxy

sys.path.append("../../semprini")

class Curve:

    """curve does not know its name. see Curveset"""

    points = None # x-sorted list of (x,y)

    def __init__(self):

        self.points = [(0,0),(10,0)]

    def load(self,filename):

        self.points[:]=[]

        for line in file(filename):

            self.points.append(tuple([float(a) for a in line.split()]))

        self.points.sort()

        self.cur_row = 0

        self.cur_col = 0

        self.ncols = 2

    def add_subtermview(self, stv):

        stv.grid(row=self.cur_row, column=self.cur_col, sticky='news')

        self.columnconfigure(self.cur_col, weight=1)

        self.cur_col += 1

        self.cur_col %= self.ncols

        if self.cur_col == 0:

            self.cur_row += 1

    term = Subterm(Submaster.Submaster(subname), Subexpr(curveset,expr))

    subterms.append(term)

    stv=Subtermview(ssv,term)

    # stv.pack(side='top',fill='x')

    ssv.add_subtermview(stv)

    return term

    f=tk.Frame(master,relief='raised',bd=1)

    newname = tk.StringVar()

    def add_cmd():

    tk.Button(f,text="new subterm named:", command=add_cmd).pack(side='left')

    tk.Entry(f,textvariable=newname).pack(side='left',fill='x',exp=1)

    return f

#######################################################################

root=tk.Tk()

root.tk_setPalette("gray50")

root.wm_geometry("1120x850")

root.tk_focusFollowsMouse()

music=Music()

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

curveset = Curveset()

csv = Curvesetview(root,curveset)

csv.pack(side='top',fill='both',exp=1)

ssv = SubtermSetView(root)

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

song = sys.argv[1]

root.title("Curemaster 2000MX - %s" % song)

maxtime = wavelength(musicfilename)

dispatcher.send("max time",maxtime=maxtime)

dispatcher.connect(lambda: maxtime, "get max time",weak=0)

subterms = []

    subname,expr = line.strip().split(" ",1)

    # stv=Subtermview(root,term)

    # stv.pack(side='top',fill='x')

out = Output(subterms)

def savekey(*args):

    print "saving",song

    curveset.save(basename="curves/"+song)

    print "saved"

root.bind("<Control-Key-s>",savekey)

create_status_lines(root)

recent_t=[]

later = None

def update():

    global later

  save dmx on quit and restore on restart

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

"""

from __future__ import division

from twisted.internet import reactor

from twisted.web import xmlrpc, server

import sys,time,os

from optparse import OptionParser

import run_local

from light9.io import ParportDMX

from light9.updatefreq import Updatefreq

class XMLRPCServe(xmlrpc.XMLRPC):

    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?

        return "ok"

parser=OptionParser()

parser.add_option("-f","--fast-updates",action='store_true',

                  help=('display all dmx output to stdout instead '

                        'of the usual reduced output'))

parser.add_option("-r","--updates-per-sec",type='float',default=20,

                  help=('dmx output frequency'))

(options,songfiles)=parser.parse_args()

print options

reactor.run()

        return i

    except ValueError:

        raise ValueError("Invalid channel name: %s" % name)

def get_channel_name(dmxnum):

    try:

        return reverse_patch[dmxnum]

    except KeyError:

        return str(dmxnum)

def reload_data():

    global patch, reverse_patch

    patch = {}

    reverse_patch = {}

    for k, v in loadedpatch.items():

        if type(k) is tuple:

            for name in k:

                patch[name] = v

            reverse_patch[v] = k[0]

        else:

            patch[k] = v

            reverse_patch[v] = k

# importing patch will load initial data

from __future__ import division

from light9.TLUtility import dict_scale, dict_max

from light9 import Patch

class Submaster:

    "Contain a dictionary of levels, but you didn't need to know that"

    def __init__(self, name, leveldict=None, temporary=0):

        self.name = name

        self.temporary = temporary

        if leveldict:

            self.levels = leveldict

        else:

            self.levels = {}

            self.reload()

    def reload(self):

        if self.temporary:

            return

        try:

            self.levels.clear()

            for line in subfile.readlines():

                if not line.strip(): # if line is only whitespace

                    continue # "did i say newspace?"

                try:

                    name, val = line.split(':')

                    name = name.strip()

                    self.levels[name] = float(val)

                except ValueError:

                    print "(%s) Error with this line: %s" % (self.name, 

                        line[:-1])

        except IOError:

            print "Can't read file for sub: %s" % self.name

    def save(self):

        if self.temporary:

            print "not saving temporary sub named",self.name

            return

        names = self.levels.keys()

        names.sort()

        for name in names:

            val = self.levels[name]

            subfile.write("%s : %s\n" % (name, val))

    def set_level(self, channelname, level, save=1):

        self.levels[Patch.resolve_name(channelname)] = level

        if save:

            self.save()

    def set_all_levels(self, leveldict):

        self.levels.clear()

        for k, v in leveldict.items():

"""

widget to show all dmx channel levels and allow editing. levels might

not actually match what dmxserver is outputting.

"""

from __future__ import nested_scopes,division

import Tkinter as tk

from dispatch import dispatcher

stdfont = ('Arial', 12)

class Onelevel(tk.Frame):

    """a name/level pair"""

    def __init__(self, parent, channelnum):

        """channelnum is 1..68, like the real dmx"""

        tk.Frame.__init__(self,parent)

        self.channelnum=channelnum

        self.currentlevel=0 # the level we're displaying, 0..1

        # 3 widgets, left-to-right:

        # channel number -- will turn yellow when being altered

        self.num_lab = tk.Label(self, text=str(channelnum),

                                width=3, bg='grey40', 

                                fg='white', font=stdfont,

                                padx=0, pady=0, bd=0, height=1)

        self.num_lab.pack(side='left')

        # text description of channel

        self.desc_lab=tk.Label(self, text=Patch.get_channel_name(channelnum),

                               padx=0, pady=0, bd=0, 

                 height=1, bg='black', fg='white')

        self.desc_lab.pack(side='left')

        # current level of channel, shows intensity with color

        self.level_lab = tk.Label(self, width=3, bg='lightBlue',

                                  padx=1, pady=0, bd=0, height=1)

        self.level_lab.pack(side='left')

        self.setlevel(0)

        self.setupmousebindings()

    def setupmousebindings(self):

        def b1down(ev):

            self.desc_lab.config(bg='cyan')

            self._start_y=ev.y

            self._start_lev=self.currentlevel

        def b1motion(ev):

    def changelevel(self,newlev):

        """the user is adjusting the level on this widget.  the main

        program needs to hear about it. then the main program will

        call setlevel()"""

        dispatcher.send("levelchanged",channel=self.channelnum,newlevel=newlev)

class Levelbox(tk.Frame):

    def __init__(self, parent, num_channels=68):

        tk.Frame.__init__(self,parent)

        self.levels = [] # Onelevel objects

        frames = (make_frame(self), make_frame(self))

        for channel in range(1, num_channels+1):

            # frame for this channel

            f = Onelevel(frames[channel > (num_channels/2)],channel)

            self.levels.append(f)

            f.pack(side='top')

        #dispatcher.connect(setalevel,"setlevel")

    def setlevels(self,newlevels):

        """sets levels to the new list of dmx levels (0..1). list can

        be any length"""

        for l,newlev in zip(self.levels,newlevels):

            l.setlevel(newlev)

""" module for clients to use for easy talking to the dmx

server. sending levels is now a simple call to

dmxclient.outputlevels(..)

client id is formed from sys.argv[0] and the PID.  """

import xmlrpclib,os,sys,socket,time

from twisted.web.xmlrpc import Proxy

_dmx=None

_id="%s-%s" % (sys.argv[0].replace('.py','').replace('./',''),os.getpid())

def outputlevels(levellist,twisted=0,clientid=_id):

    """present a list of dmx channel levels, each scaled from

    0..1. list can be any length- it will apply to the first len() dmx

    channels.

    if the server is not found, outputlevels will block for a

    second."""

    global _dmx,_id

    if _dmx is None:

        if not twisted:

            _dmx=xmlrpclib.Server(url)

        else:

            _dmx = Proxy(url)

    if not twisted:

        try:

            _dmx.outputlevels(clientid,levellist)

        except socket.error,e:

            print "dmx server error %s, waiting"%e

            time.sleep(1)

        except xmlrpclib.Fault,e: