import sys, time

sys.path.append('..')

from Widgets.Fadable import Fadable

from Tix import *

import math, atexit, pickle

from Submaster import Submasters, sub_maxes

import dmxclient

from uihelpers import toplevelat

class SubmasterTk(Frame):

    def __init__(self, master, name, current_level):

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

        self.slider_var = DoubleVar()

        self.slider_var.set(current_level)

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

            fg='white')

        namelabel.pack(side=TOP)

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

        levellabel.pack(side=TOP)

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

class KeyboardComposer(Frame):

    def __init__(self, root, submasters, current_sub_levels=None, dmxdummy=0):

        self.draw_ui()

        self.send_levels_loop()

    def draw_ui(self):

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

        self.slider_vars = {} # this holds subname:sub Tk vars

        self.slider_table = {} # this holds coords:sub Tk vars

        self.current_row = 0

        self.make_key_hints()

        self.draw_sliders()

        self.highlight_row(self.current_row)

        self.rows[self.current_row].focus()

                keysym = "<KeyPress-%s>" % key.upper()

                keysym = keysym.replace('SEMICOLON', 'colon')

                tkobject.bind(keysym, \

                    lambda evt, num=keys.index(key), d=d: \

                        self.got_nudger(num, d, full=1))

            tkobject.bind(key, self.change_row)

    def change_row(self, event):

        diff = 1

            diff = -1

        old_row = self.current_row

        self.current_row += diff

        self.current_row = max(0, self.current_row)

        self.current_row = min(len(self.rows) - 1, self.current_row)

        self.unhighlight_row(old_row)

            if col == 0: # make new row

                row = self.make_row()

                rowcount += 1

            current_level = self.current_sub_levels.get(sub.name, 0)

            subtk = self.draw_sub_slider(row, col, sub.name, current_level)

            self.slider_table[(rowcount, col)] = subtk

            col += 1

            col %= 10

            def slider_changed(x, y, z, subtk=subtk):

                subtk.scale.draw_indicator_colors()

                self.send_levels()

        maxes = sub_maxes(*scaledsubs)

        return maxes

    def save_current_stage(self, subname):

        print "saving current levels as", subname

        sub = self.get_levels_as_sub()

        sub.name = subname

        sub.save()

    def save(self):

        pickle.dump(self.get_levels(), 

                    file('.keyboardcomposer.savedlevels', 'w'))

    def send_frequent_updates(self):

        for r in self.rows:

            r.destroy()

        self.keyhints.destroy()

        self.buttonframe.destroy()

        self.draw_ui()

if __name__ == "__main__":

    s = Submasters()

    root = Tk()

    tl = toplevelat("Keyboard Composer", existingtoplevel=root)

    kc = KeyboardComposer(tl, s, dmxdummy=0)

    kc.pack(fill=BOTH, expand=1)

        self.update_time()

    def update_time(self):

        self.timevar.set(self.get_music_time())

        self.after(100, self.update_time)

if __name__ == "__main__":

    parser = OptionParser()

    parser.add_option("-s", "--server", default='dash')

    parser.add_option("-p", "--port", default=8040, type='int')

    options, args = parser.parse_args()

    root = tk.Tk()

                    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:

            return

        subfile = file("subs/%s" % self.name, 'w')

        names = self.levels.keys()

        names.sort()

        for name in names:

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

        self.tl_list.pack()

    def set_timeline(self, tlname):

        print "TimelineDMX: set timeline to", tlname

        self.show.set_timeline(tlname)

    def find_player(self):

    def send_levels(self):

        levels = self.show.calc_active_submaster().get_dmx_list()

        dmxclient.outputlevels(levels)

    def sync_times(self):

        try:

"""

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

from twisted.web.xmlrpc import Proxy

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

import dmxclient

import Submaster

from TLUtility import make_attributes_from_args

from zoomcontrol import Zoomcontrol

class Curve:

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

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

    def __init__(self):

    def load(self,filename):

        for line in file(filename):

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

        self.points.sort()

        dispatcher.send("points changed",sender=self)

    def save(self,filename):

        f = file(filename,'w')

        for p in self.points:

            f.write("%s %s\n" % p)

        f.close()

    def eval(self,t):

        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

    __call__=eval

class Curveview(tk.Canvas):

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

        self.curve=curve

        tk.Canvas.__init__(self,master,width=10,height=10,

                           relief='sunken',bd=1,

        self.selected_points=[] # idx of points being dragged

        self.update()

        dispatcher.connect(self.input_time,"input time")

        dispatcher.connect(self.update,"zoom changed")

        dispatcher.connect(self.update,"points changed",sender=self.curve)

        self.bind("<Configure>",self.update)

    def screen_from_world(self,p):

        start,end = self.zoom

        ht = self.winfo_height()

        return (p[0]-start)/(end-start)*self.winfo_width(), (ht-5)-p[1]*(ht-10)

    def world_from_screen(self,x,y):

        start,end = self.zoom

    def input_time(self,val):

        t=val

        pts = self.screen_from_world((val,0))+self.screen_from_world((val,1))

        self.delete('timecursor')

        self.create_line(*pts,**dict(width=2,fill='red',tags=('timecursor',)))

    def update(self,*args):

        self.zoom = dispatcher.send("zoom area")[0][1]

        cp = self.curve.points

        visible_x = (self.world_from_screen(0,0)[0],

                     self.world_from_screen(self.winfo_width(),0)[0])

        visleftidx = max(0,bisect_left(cp,(visible_x[0],None))-1)

        visrightidx = min(len(cp)-1,bisect_left(cp,(visible_x[1],None))+1)

        visible_points = cp[visleftidx:visrightidx+1]

        self.delete('curve')

        linepts=[]

            linepts.extend(self.screen_from_world(p))

            return

        # canvas doesnt have keyboard focus, so i can't easily change the

        # cursor when ctrl is pressed

        #        def curs(ev):

        #            print ev.state

        #        self.bind("<KeyPress>",curs)

        #        self.bind("<KeyRelease-Control_L>",lambda ev: curs(0))

        self.unselect()

        self.update()

    def highlight_selected_dots(self):

        for i,d in self.dots.items():

            if i in self.selected_points:

                self.itemconfigure(d,fill='red')

    def dotpress(self,ev,dotidx):

        self.selected_points=[dotidx]

        self.highlight_selected_dots()

    def dotmotion(self,ev,dotidx):

        cp = self.curve.points

        moved=0

        for idx in self.selected_points:

            x,y = self.world_from_screen(ev.x,ev.y)

            y = max(0,min(1,y))

            if idx>0 and x<=cp[idx-1][0]:

                continue

    def __init__(self):

        self.curves = {}

    def load(self,basename):

        """find all files that look like basename-curvename and add

        curves with their contents"""

        for filename in glob.glob("%s-*"%basename):

            c=Curve()

            c.load(filename)

            self.add_curve(curvename,c)            

    def save(self,basename):

        """writes a file for each curve with a name

        like basename-curvename"""

        for name,cur in self.curves.items():

            cur.save("%s-%s" % (basename,name))

    def add_curve(self,name,curve):

        self.curves[name] = curve

        dispatcher.send("add_curve",sender=self,name=name)

    def globalsdict(self):

        return self.curves.copy()

class Curvesetview(tk.Frame):

    curves = None # curvename : Curveview

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

        self.curves = {}

        self.curveset = curveset

        tk.Frame.__init__(self,master,**kw)

        dispatcher.connect(self.add_curve,"add_curve",sender=self.curveset)

    def add_curve(self,name):

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

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

        cv = Curveview(f,self.curveset.curves[name])

        cv.pack(side='right',fill='both',exp=1)

        self.curves[name] = cv

class Music:

    def __init__(self):

        self.player=None # xmlrpc Proxy to player

        self.recenttime=0

    def current_time(self):

        """return deferred which gets called with the current time"""

        if self.player is None:

        d = self.player.callRemote('gettime')

        def sendtime(t):

            dispatcher.send("input time",val=t)

            return t # pass along to the real receiver

        def error(e):

            pass#self.player=None

        d.addCallback(sendtime)

        return d

class Subexpr:

    curveset = None

        self.curveset = curveset

        self.lasteval = None

    def eval(self,t):

        if self.expr=="":

            dispatcher.send("expr_error",sender=self,exc="no expr, using 0")

            return 0

        glo = self.curveset.globalsdict()

        glo['t'] = t

        try:

            self.lasteval = eval(self.expr,glo)

        except Exception,e:

            dispatcher.send("expr_error",sender=self,exc=e)

        else:

        return self.lasteval

    def expr():

        doc = "python expression for level as a function of t, using curves"

        def fget(self):

            return self._expr

            self.evar.set(self.subexpr.expr)

    def evar_changed(self,*args):

        self.subexpr.expr = self.evar.get()

class Subterm:

    """one Submaster and its Subexpr"""

    def scaled(self,t):

class Subtermview(tk.Frame):

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

        self.subterm = st

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

        sev=Subexprview(self,self.subterm.subexpr)

        sev.pack(side='left',fill='both',exp=1)

class Output:

    def __init__(self,subterms):

        make_attributes_from_args('subterms')

    def send_dmx(self,t):

        scaledsubs=[]

        for st in self.subterms:

            scl = st.scaled(t)

            scaledsubs.append(scl)

        out = Submaster.sub_maxes(*scaledsubs)

def create_status_lines(master):

    for signame,textfilter in [

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

        ('output levels',

         lambda levels: textwrap.fill("; ".join(["%s:%.2f"%(n,v)

                                                 for n,v in

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

        ]:

        l = tk.Label(master,anchor='w',justify='left')

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

        dispatcher.connect(lambda val,l=l,sn=signame,tf=textfilter:

                           l.config(text=sn+": "+tf(val)),

                           signame,weak=0)

def savesubterms(filename,subterms):

    for st in subterms:

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

root=tk.Tk()

music=Music()

zc = Zoomcontrol(root)

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

curveset = Curveset()

csv = Curvesetview(root,curveset)

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

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

subterms = []

for line in file("subterms/"+song):

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

out = Output(subterms)

create_status_lines(root)

recent_t=[]

later = None

def update():

    recent_t = recent_t[-50:]+[t]

    period = (recent_t[-1]-recent_t[0])/len(recent_t)

    dispatcher.send("update period",val=period)

    out.send_dmx(t)

update()

tksupport.install(root,ms=10)

if 0:

    sys.path.append("/home/drewp/projects/editor/pour")

    from utils import runstats

    runstats("reactor.run()")

else:

import sys

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

import Patch

from uihelpers import make_frame, colorlabel, eventtoparent

from dispatch import dispatcher

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)

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

            delta=self._start_y-ev.y

            self.changelevel(self._start_lev+delta*.005)

        def b1up(ev):

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