from random import randrange

from time import time

from __future__ import generators,division

from Subs import *

patch = {

    'side l' : 45, # posts

    'side r' : 46,

    '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,

    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},

    ('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,}

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

        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'

        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) 

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

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

        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

"""some of the panels"""

from __future__ import nested_scopes

from uihelpers import *

import Patch

from FlyingFader import FlyingFader

import Pmw

stdfont = ('Arial', 8)

#!/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

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

        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)

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.

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

    # 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