from random import randrange

from time import time

from __future__ import generators,division

from Subs import *

patch = {

    'side l' : 45, # posts

    'side r' : 46,

    ('patio1','main 1',) : 1,

    ('main 2',) : 2,

    ('main 3',) : 3,

    ('main 4',) : 4,

    ('main 5',) : 5,

    ('god','main 6') : 6,

    ('scp more', '#AAAA00'):{18:FL,14:FL},

    ('scp all', '#AAAA00'):fulls((13,16,18,19,39)),

    ('col oran', '#EEEE99'):fulls('oran1 oran2 oran3 oran4'.split()),

    ('col red', 'red'):fulls('red1 red2 red3 red4'.split()),

    ('col blue', 'blue'):fulls('blue1 blue2 blue3 blue4'.split()),

    ('col gree', 'green'):fulls('gree1 gree2 gree3 gree4'.split()),

    'sidepost':fulls((45,46)),

    'edges':fulls((55,60,49,54,61,66)),

    'bank1ctr':fulls(('b22','b23','b24','b25')),

    'god' : fulls((6,)),

    ('strobe', 'grey'):strobe,

    'chase' : chase,

    'chase2' : chase,

}

subs["ba outrs"] = fulls("b11 b12 b13 b14 b15 b16 b31 b32 b33 b34 b35 b36".split())

subs["ba some"] = {'b12':40,'b13':FL,'b14':FL,'b15':40,

                   'b32':40,'b33':FL,'b34':FL,'b35':40,}

subs['*curtain'] = subs['ba some'].copy()

from random import randrange

from time import time

from __future__ import generators,division

from Subs import *

patch = {

    'side l' : 45, # posts

    'side r' : 46,

    ('patio1','main 1',) : 1,

    ('main 2',) : 2,

    ('main 3',) : 3,

    ('main 4',) : 4,

    ('main 5',) : 5,

    ('god','main 6') : 6,

    params.add_param('magic', CheckboxParam())

    params.add_param('cheese', TextParam())

    params.add_param('stuff', ListParam(('a', 'b', 'c')))

    curtime = time()

    dim = 1

    while 4:

        if time() - curtime > 1:

            dim = randrange(1, 64)

            curtime = time()

        yield {dim : 100, 20 : params.get_param_value('magic')}

subs = {

    'over pit sm' : levs(range(1, 13),(100,0,0,91,77,79,86,55,92,77,59,0)),

    'over pit lg' : fulls(range(1, 13)),

    ('house', 'black') : { 68:100 },

    ('cyc', 'lightBlue'):{42:FL,43:FL},

    ('scp hot ctr', 'yellow'):{18:FL},

    ('scp more', '#AAAA00'):{18:FL,14:FL},

    ('scp all', '#AAAA00'):fulls((13,16,18,19,39)),

    ('col oran', '#EEEE99'):fulls('oran1 oran2 oran3 oran4'.split()),

    ('col red', 'red'):fulls('red1 red2 red3 red4'.split()),

    ('col blue', 'blue'):fulls('blue1 blue2 blue3 blue4'.split()),

    ('col gree', 'green'):fulls('gree1 gree2 gree3 gree4'.split()),

    'sidepost':fulls((45,46)),

    'edges':fulls((55,60,49,54,61,66)),

    'bank1ctr':fulls(('b22','b23','b24','b25')),

    'god' : fulls((6,)),

    ('strobe', 'grey'):strobe,

#    'midstage' : dict([(r, 100) for r in range(11, 21)]),

#    'backstage' : dict([(r, 100) for r in range(21, 31)]),

#    'frontchase' : mr_effect,

    'chase' : chase,

#    'random' : randomdimmer,

}

subs["ba outrs"] = fulls("b11 b12 b13 b14 b15 b16 b31 b32 b33 b34 b35 b36".split())

subs["ba some"] = {'b12':40,'b13':FL,'b14':FL,'b15':40,

                   'b32':40,'b33':FL,'b34':FL,'b35':40,}

subs['*curtain'] = subs['ba some'].copy()

"""And that's my cue to exit(0)..."""

from time import time

from util import subsetdict

class Cue:

    """Cues are groups of fades.  They can tell you the current levels at a 

    given time.  They contain Fades, which are actually children of Cue,

    meaning that Cues can contain Cues.  This is similar to the Light9 concept

    of Cues and Fades, but without all the Nodes."""

        'Create a cue'

        self.name = name

        self.starttime = starttime

        self.endtime = endtime

        self.fades = fades

        self.cuestart = None

        self.init_levels = None

    def channels_involved(self):

        'Return which channels are involved.  This is important for marking.'

        c = {}

        for fade in self.fades:

            for f_chan in fade.channels_involved():

                c[f_chan] = 1

        return c.keys()

    def start(self, levels, time):

        for fade in self.fades:

            subdict = subsetdict(levels, fade.channels_involved())

            fade.start(subdict, time)

    def get_levels(self, curtime):

        'Returns the current levels'

        d = {}

        for fade in self.fades:

            fade_d = fade.get_levels(curtime)

            for ch, lev in fade_d.items():

                d[ch] = max(lev, d.get(ch, 0))

        return d

class Fade(Cue):

    'See Cue.__doc__'

    def __init__(self, channel, starttime, endtime=None, endlevel=0, dur=None,

                 param=None):

        self.channel = channel

        self.endlevel = endlevel

        self.dur = dur

        self.param = param

    def start(self, levels, time):

        'Mark the beginning of the fade'

        self.init_levels = levels

        self.init_level = levels[self.channel]

        self.init_time = time

    def channels_involved(self):

        'Speaks for itself, I hope'

        return [self.channel]

    def get_levels(self, curtime):

        elapsed = curtime - self.init_time

        if elapsed <= self.starttime:

            return self.init_levels

        elif elapsed >= self.endtime:

            return {self.channel : self.endlevel}

        else:

            percent = float(elapsed) / self.dur

            return {self.channel : self.init_level + 

                percent * (self.endlevel - self.init_level)}

if __name__ == '__main__':

    f1 = Fade('red', 0, 2, 100)

    f2 = Fade('green', 1, 3, 50)

    f3 = Fade('blue', 0, 4, 0)

    f4 = Fade('clear', 0, 8, 75) 

    c = Cue("Color shift", 0, 10, f1, f2, f3, f4)

    tstart = time()

    # note how green is not mentioned -- it goes to 0

    c.start({'red' : 0, 'blue' : 100, 'clear' : 25}, tstart)

    while time() - tstart < 15:

        curtime = time()

from Tix import *

stdfont = ('Arial', 10)

class Fader(Frame):

    'User interface for cue fader'

    def __init__(self, master, cues, scalelevels):

        self.master = master

        self.cues = cues

        self.scalelevels = scalelevels

        self.init_layout()

    def init_layout(self):

        Frame.__init__(self, self.master)

        self.cuename = StringVar()

        self.cuelength = DoubleVar()

        buttonframe = Frame(self)

        for c in self.cues:

            self.listbox.listbox.insert(END, c.name)

        Label(infoframe, textvariable=self.cuename, 

        Label(infoframe, text="Length", font=stdfont, 

            bg='lightPink').grid(row=1, sticky=NE+SW)

        Label(infoframe, textvariable=self.cuelength, 

        Label(infoframe, text="Target", font=stdfont,

            bg='lightPink').grid(row=2, sticky=NE+SW)

        infoframe.pack(side=RIGHT, fill=BOTH, expand=1)

        self.listbox.listbox.select_set(0)

        self.update_selection()

        self.current = self.cues[selection]

        self.cuename.set(self.current.name)

        self.cuelength.set(self.current.dur)

    def go(self):

from Patch import *

from time import time

from types import TupleType

stdfont = ('Arial', 8)

class Param: # abstract

    def get_value(self):

        pass

    def set_value(self, v):

        pass

    def draw_tk(self, frame):

        pass

    def __getstate__(self):

    #

    # methods for Subediting to use

    #

    def getlevels(self):

        return self.levels.copy()

    def reviselevels(self,levels):

        # we can accept these new levels; subediting has done all the work

        self.levels.update(levels)

def reload_data(dummy):

    if dummy:

        import ConfigDummy as Config

    else:

        import Config

    reload(Config)

    subs = {}

    for name, levels in Config.subs.items():

        if type(name) == TupleType:

            name, color = name

        else:

            color = None

        subs[name] = Sub(name, levels, color=color)

    # subs = dict([(name, Sub(levels)) for name, levels in Config.subs.items()])

def longestsubname():

    return max([len(x) for x in subs.keys()])

from __future__ import division

class Xfader(Canvas):

    def __init__(self, scalelevelsIn):

        global scalelevels

        scalelevels=scalelevelsIn

        self.checkbuttons={}

        self.startcoord=None

    def sub2(self,a,b):

        return ( (a[0]-b[0]), (a[1]-b[1]))

    def down(self,ev):

        global scalelevels

"""some of the panels"""

from __future__ import nested_scopes

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

#!/usr/bin/env python

from __future__ import nested_scopes

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

import stage

if len(sys.argv) >= 2:

    DUMMY = 0

    print "This is the real thing, baby"

    window_title = "Light 8.8 (On Air)"

else:

    DUMMY = 1

    print "Dummy mode"

    window_title = "Light 8.8 (Bogus)"

root = Tk()

root.wm_title(window_title)

root.wm_geometry('+462+470')

            w.destroy()

        stage_tl = toplevelat(44,723)

        s = stage.Stage(stage_tl)

        stage.createlights(s)

        s.setsubediting(self.subediting)

        s.pack()

        sub_tl = toplevelat(0,0)

        effect_tl = toplevelat(462,4)

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

        leveldisplay_tl = toplevelat(873,400)

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

        if DUMMY:

            filename = 'ConfigDummy.py'

        else:

            filename = 'Config.py'

        xf=Frame(root)

        xf.pack(side='right')

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

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

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

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

        self.xfader.setupwidget(xf)

        controlpanel.pack()

    def refresh(self, *args):

        'rebuild interface, reload data'

        get_data()

        self.buildinterface()

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

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

def printevent(ev):

    for k in dir(ev):

        if not k.startswith('__'):

            print k,getattr(ev,k)

    print ""

textstyle={'font':'arial 7','fill':'white'}

class Stage(Canvas):

    """a fancy widget that shows light locations (and optionally their

    aim locations on an image of the stage. you can select or

    multiselect lights and drag them up or down to change their

    brightness.

    ctrl-a is select all,

    ctrl-shift-a or clicking on no light deselects all,

    re-clicking a light with shift key down toggles whether it's in the selection.

    ctrl-drag-rectangle deselects the lights in the rectangle,

    shift-drag-rectangle selects the lights in the rectangle,

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

from __future__ import nested_scopes

from Tkinter 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)

def toplevelat(x,y,w=None,h=None):

    if w and h:

    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

    for d in dicts:

        for k,v in d.items():

            newdict[k] = max(v, newdict.get(k, 0))

    return newdict

def scaledict(d,scl):

    # scales all values in dict and returns a new dict

    return dict([(k,v*scl) for k,v in d.items()])

# class Setting that scales, maxes        

def subsetdict(d, dkeys, default=0):

    newd = {} # dirty variables!

    for k in dkeys:

        newd[k] = d.get(k, default)

    return newd