from __future__ import nested_scopes

from Tix import *

from time import sleep

from signal import signal, SIGINT

import sys, cPickle

import io

from uihelpers import *

from panels import *

from Xfader import *

from subediting import Subediting

from Fader import Fader

import stage

import Subs, Patch

class Pickles:

        self.scalelevels = dict([(name, lev.get()) 

            for name, lev in scalelevels.items()])

        self.substate = dict([(name, subobj.get_state())

            for name, subobj in subs])

class Lightboard:

    def __init__(self, master, parportdmx, DUMMY):

        self.master = master

        self.parportdmx = parportdmx

        self.DUMMY = DUMMY

        self.channel_levels = []

        self.scalelevels = {}

        self.xfader = Xfader(self.scalelevels) # doesn't draw any UI yet-- look for self.xfader.setupwidget()

        self.oldlevels = [None] * 68 # never replace this; just clear it

        self.subediting = Subediting(currentoutputlevels=self.oldlevels)

        self.get_data()

        self.buildinterface()

        self.load()

        self.backgroundloop()

        self.updatestagelevels()

    def buildinterface(self):

        for w in self.master.winfo_children():

            w.destroy()

        s = stage.Stage(stage_tl)

        stage.createlights(s)

        s.setsubediting(self.subediting)

        s.pack()

        self.stage = s # save it

        self.subpanels = Subpanels(sub_tl, effect_tl, self, self.scalelevels,

                                   Subs, self.xfader, self.changelevel,

                                   self.subediting, Subs.longestsubname())

        leveldisplay_tl.bind('<Escape>', sys.exit)

        self.leveldisplay = Leveldisplay(leveldisplay_tl, self.channel_levels)

        for i in range(0,len(self.channel_levels)):

            self.channel_levels[i].config(text=self.oldlevels[i])

            colorlabel(self.channel_levels[i])

        Console(self)

        # root frame

        controlpanel = Controlpanel(self.master, self.xfader, self.refresh, self.quit)

        xf=Frame(self.master)

        xf.pack(side='right')

        self.master.bind('<q>', self.quit)

        self.master.bind('<r>', self.refresh)

        leveldisplay_tl.bind('<q>', self.quit)

        leveldisplay_tl.bind('<r>', self.refresh)

        self.xfader.setupwidget(xf)

        controlpanel.pack()

        cuefader = Fader(cuefader_tl, Subs.cues, self.scalelevels)

        cuefader.pack()

    def get_data(self,*args):

        Subs.reload_data(self.DUMMY)

        Patch.reload_data(self.DUMMY)

        print "Patch:", Patch.patch

        print "Subs:", ', '.join(Subs.subs.keys())

    def refresh(self, *args):

        'rebuild interface, reload data'

        self.get_data()

        self.subediting.refresh()

        self.buildinterface()

        bindkeys(self.master,'<Escape>', self.quit)

    def stageassub(self):

        """returns the current onstage lighting as a levels

        dictionary, skipping the zeros, and using names where

        possible"""

        levs=self.oldlevels

        return dict([(Patch.get_channel_name(i),l) for i,l

                     in zip(range(1,len(levs)+1),levs)

                     if l>0])

    def save_sub(self, name, levels):

        if not name:

            print "Enter sub name in console."

            return

        st = ''

        linebuf = 'subs["%s"] = {' % name

        for channame,lev in levels.items():

            if len(linebuf) > 60: 

                st += linebuf + '\n   '

                linebuf = ''

            linebuf += ' "%s" : %d,' % (channame, lev)

        st += linebuf + '}\n'

        if self.DUMMY:

            filename = 'ConfigDummy.py'

        else:

            filename = 'Config.py'

        f = open(filename, 'a')

        f.write(st)

        f.close()

        print 'Added sub:', st

        self.refresh()

    # this is called on a loop, and ALSO by the Scales

    def changelevel(self, *args):

        'Amp trims slider'

        levels = [0] * 68

        for name, s in Subs.subs.items():

            newlevels = s.get_levels(level=self.scalelevels[name].get())

            for (ch, fadelev) in newlevels.items():

                levels[ch-1] = max(levels[ch-1], fadelev)

        levels = [int(l) for l in levels]

        for lev,lab,oldlev,numlab in zip(levels, self.channel_levels, 

                                         self.oldlevels, 

                                         self.leveldisplay.number_labels):

            if lev != oldlev:

                lab.config(text="%d" % lev) # update labels in lev display

                colorlabel(lab)             # recolor labels

                if lev < oldlev:

                    numlab['bg'] = 'blue'

                else:

                    numlab['bg'] = 'red'

            else:

                numlab['bg'] = 'lightPink'

        self.oldlevels[:] = levels[:] # replace the elements in oldlevels - don't make a new list (Subediting is watching it)

        self.parportdmx.sendlevels(levels)

    def updatestagelevels(self):

        self.master.after(100, self.updatestagelevels)

        for lev, idx in zip(self.oldlevels, xrange(0, 68 + 1)):

            self.stage.updatelightlevel(Patch.get_channel_name(idx + 1), lev)

    def load(self):

        try:

            filename = '/tmp/light9.prefs'

            if self.DUMMY:

                filename += '.dummy'

            print "Loading from", filename

            file = open(filename, 'r')

            p = cPickle.load(file)

            for s, v in p.scalelevels.items():

                try:

                    self.scalelevels[s].set(v)

                except Exception,e:

                    print "Couldn't set %s -> %s: %s" % (s, v,e)

            for name, substate in p.substate.items():

                try:

                    Subs.subs[name].set_state(substate)

                except Exception, e:

                    print "Couldn't set sub %s state: %s" % (name,e)

        except IOError, e:

            print "IOError: Couldn't load prefs (%s): %s" % (filename,e)

        except EOFError, e:

            print "EOFrror: Couldn't load prefs (%s): %s" % (filename,e)

        except Exception,e:

            print "Couldn't load prefs (%s): %s" % (filename,e)

    def backgroundloop(self, *args):

        self.master.after(50, self.backgroundloop, ())

        self.changelevel()

    def quit(self, *args):

        self.save()

        self.master.destroy()

        sys.exit()

    def save(self, *args):

        filename = '/tmp/light9.prefs'

        if self.DUMMY:

            filename += '.dummy'

        print "Saving to", filename

        file = open(filename, 'w')

        try:

            cPickle.dump(Pickles(self.scalelevels, Subs.subs.items()), file)

        except cPickle.UnpickleableError:

            print "UnpickleableError!  There's yer problem."

"""some of the panels"""

from __future__ import nested_scopes

from Tix import *

from uihelpers import *

import Patch

from FlyingFader import FlyingFader

import Pmw

stdfont = ('Arial', 8)

monofont = ('Courier', 8)

class Controlpanel(Frame):

    def __init__(self, parent, xfader, refresh_cb, quit_cb):

        Frame.__init__(self,parent)

        controlpanel = self

        for txt,cmd in (

            ('Quit',       quit_cb),

            ('Refresh',    refresh_cb),

            ('Clear all', xfader.clearallbuttons),

            ('On -> X',     lambda: xfader.grab('x')),

            ('Clear X',     lambda: xfader.clearallbuttons('x')),

            ('On -> Y',     lambda: xfader.grab('y')),

            ('Clear Y',     lambda: xfader.clearallbuttons('y'))):

            Button(controlpanel, text=txt, command=cmd).pack(side='top', 

                fill='x')

class Console:

    def __init__(self,lightboard):

        print "Light 8: Everything's under control"

        self.frame = Frame(t)

        self.entry=Entry(self.frame)

        self.entry.pack(expand=1, fill='x')

        self.entry.bind('<Return>',

                        lambda evt: self.execute(evt, self.entry.get()))

        self.frame.pack(fill=BOTH, expand=1)

        self.lightboard=lightboard

    def execute(self, evt, str):

        if str[0] == '*': # make a new sub from the current levels

            self.lightboard.save_sub(str,self.lightboard.stageassub())

        else:

            print '>>>', str

            print eval(str)

            self.frame.focus()

class Leveldisplay:

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

        frames = (make_frame(parent), make_frame(parent))

        channel_levels[:]=[]

        self.number_labels = []

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

            # frame for this channel

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

            # channel number -- will turn yellow when being altered

            num_lab = Label(f, text=str(channel), width=3, bg='lightPink', 

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

            num_lab.pack(side='left')

            self.number_labels.append(num_lab)

            # text description of channel

            Label(f, text=Patch.get_channel_name(channel), width=8, 

                font=stdfont, anchor='w', padx=0, pady=0, bd=0, 

                height=1).pack(side='left')

            # current level of channel, shows intensity with color

            l = Label(f, width=3, bg='lightBlue', font=stdfont, anchor='e', 

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

            l.pack(side='left')

            colorlabel(l)

            channel_levels.append(l)

            f.pack(side='top')

        self.channel_levels = channel_levels

        # channel_levels is an output - changelevel will use it to access 

        # these labels

class Subpanels:

    def __init__(self, scenesparent, effectsparent, lightboard,

                 scalelevels, Subs, xfader,

                 changelevel, subediting, longestname):

        sublist = Subs.subs.items()

        sublist.sort()

        for p in scenesparent,effectsparent:

            sw = ScrolledWindow(p)

            for but,units in ( (4,-4),(5,4) ):

                sw.window.bind("<ButtonPress-%s>"%but,lambda ev,s=sw.vsb,u=units: s.tk.call('tkScrollByUnits',s,'hv',u))

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

            if p==scenesparent:

                scenesparent = sw.window

            else:

                effectsparent = sw.window

        for name, sub in sublist:

            # choose one of the sub panels to add to

            if sub.is_effect:

                parent=effectsparent

                side1='bottom'

                side2='left'

                orient1='vert'

                end1=0

                end2=1

                width1=len(name)

            else:

                parent=scenesparent

                side1='right'

                side2='top'

                orient1='horiz'

                end1=1

                end2=0

                width1=longestname

            # make frame that surrounds the whole submaster

            f=Frame(parent, bd=1, relief='raised')

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

            # make DoubleVar (there might be one left around from

            # before a refresh)

            if name not in scalelevels:

                scalelevels[name]=DoubleVar()

"""all the tiny tk helper functions"""

from __future__ import nested_scopes

from Tkinter import *

from Tix import *

from types import StringType

def make_frame(parent):

    f = Frame(parent, bd=0)

    f.pack(side='left')

    return f

def bindkeys(root,key, func):

    root.bind(key, func)

    for w in root.winfo_children():

        w.bind(key, func)

    tl = Toplevel()

    else:

    return tl

def toggle_slider(s):

    if s.get() == 0:

        s.set(100)

    else:

        s.set(0)

# for lambda callbacks    

def printout(t):

    print t

def printevent(ev):

    for k in dir(ev):

        if not k.startswith('__'):

            print k,getattr(ev,k)

    print ""

def eventtoparent(ev,sequence):

    "passes an event to the parent"

    evdict={}

    for x in ['state', 'time', 'y', 'x', 'serial']:

        evdict[x]=getattr(ev,x)

#    evdict['button']=ev.num

    par=ev.widget.winfo_parent()

    if par!=".":

        ev.widget.nametowidget(par).event_generate(sequence,**evdict)

    #else the event made it all the way to the top, unhandled

def colorlabel(label):

    """color a label based on its own text"""

    txt=label['text'] or "0"

    lev=float(txt)/100

    low=(80,80,180)

    high=(255,55,050)

    out = [int(l+lev*(h-l)) for h,l in zip(high,low)]

    col="#%02X%02X%02X" % tuple(out)

    label.config(bg=col)

# TODO: get everyone to use this

def colorfade(low, high, percent):

    '''not foolproof.  make sure 0 < percent < 1'''

    out = [int(l+percent*(h-l)) for h,l in zip(high,low)]

    col="#%02X%02X%02X" % tuple(out)

    return col

def colortotuple(anytkobj, colorname):

    'pass any tk object and a color name, like "yellow"'

    rgb = anytkobj.winfo_rgb(colorname)

    return [v / 256 for v in rgb]

class Togglebutton(Button):

    """works like a single radiobutton, but it's a button so the

    label's on the button face, not to the side. the optional command

    callback is called on button set, not on unset. takes a variable

    just like a checkbutton"""

    def __init__(self,parent,variable=None,command=None,downcolor='red',**kw):

        self.oldcommand = command

        Button.__init__(self,parent,command=self.invoke,**kw)

        self._origbkg = self.cget('bg')

        self.downcolor = downcolor

        self._variable = variable

        if self._variable:

            self._variable.trace('w',self._varchanged)

            self._setstate(self._variable.get())

        else:

            self._setstate(0)

        self.bind("<Return>",self.invoke)

        self.bind("<1>",self.invoke)

        self.bind("<space>",self.invoke)

    def _varchanged(self,*args):

        self._setstate(self._variable.get())

    def invoke(self,*ev):

        if self._variable:

            self._variable.set(not self.state)

        else:

            self._setstate(not self.state)

        if self.oldcommand and self.state: # call command only when state goes to 1

            self.oldcommand()

        return "break"

    def _setstate(self,newstate):

        self.state = newstate

        if newstate: # set

            self.config(bg=self.downcolor,relief='sunken')

        else: # unset

            self.config(bg=self._origbkg,relief='raised')

        return "break"