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)

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

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

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