song = sys.argv[1]

root.title("Curemaster 2000MX - %s" % song)

musicfilename = showconfig.songFilename(song)

maxtime = wavelength(musicfilename)

dispatcher.send("max time",maxtime=maxtime)

dispatcher.connect(lambda: maxtime, "get max time",weak=0)

curveset.load(basename=os.path.join(showconfig.curvesDir(),song))

subterms = []

subterm_adder(root, curveset, subterms, root, ssv).pack(side='top',fill='x')

for line in file(showconfig.subtermsForSong(song)):

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

    term = add_one_subterm(subname, curveset, subterms, root, ssv, expr)

    # stv=Subtermview(root,term)

    # stv.pack(side='top',fill='x')

out = Output(subterms)

def savekey(*args):

    print "saving",song

    savesubterms(showconfig.subtermsForSong(song),subterms)

    print "saved"

root.bind("<Control-Key-s>",savekey)

create_status_lines(root)

for helpline in ["Bindings: C-s save subterms; B1 drag point; C-B1 curve add point; 1..5 add point at time; Esc see current time; Mousewheel zoom",

                 "Available in functions: nsin/ncos period=amp=1; within(a,b) bef(x) aft(x) compare to time; smoove(x) cubic smoothstep; curvename(t) eval curve"]:

    tk.Label(root,text=helpline, font="Helvetica -12 italic",

             anchor='w').pack(side='top',fill='x')

recent_t=[]

later = None

def update():

    global later

    d = music.current_time()

    d.addCallback(update2)

    d.addErrback(updateerr)

def updateerr(e):

    global later

    if later and not later.cancelled and not later.called: later.cancel()

    later = reactor.callLater(1,update)

def update2(t):

    global recent_t,later

    if later and not later.cancelled and not later.called: later.cancel()

    later = reactor.callLater(.01,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)

            subfile.write("%s : %s\n" % (name, val))

    def set_level(self, channelname, level, save=1):

        self.levels[Patch.resolve_name(channelname)] = level

        if save:

            self.save()

    def set_all_levels(self, leveldict):

        self.levels.clear()

        for k, v in leveldict.items():

            self.set_level(k, v, save=0)

        self.save()

    def get_levels(self):

        return self.levels

    def __mul__(self, scalar):

        return Submaster("%s*%s" % (self.name, scalar), 

            dict_scale(self.levels, scalar), temporary=1)

    __rmul__ = __mul__

    def max(self, *othersubs):

        return sub_maxes(self, *othersubs)

    def __repr__(self):

        levels = ' '.join(["%s:%.2f" % item for item in self.levels.items()])

        return "<'%s': [%s]>" % (self.name, levels)

    def get_dmx_list(self):

        leveldict = self.get_levels() # gets levels of sub contents

                                             amount))

        return xfaded_sub

def linear_fade(start, end, amount):

    """Fades between two floats by an amount.  amount is a float between

    0 and 1.  If amount is 0, it will return the start value.  If it is 1,

    the end value will be returned."""

    level = start + (amount * (end - start))

    return level

def sub_maxes(*subs):

    name = "max(%s)" % ", ".join([repr(s) for s in nonzero_subs])

    return Submaster(name,

                     dict_max(*[sub.levels for sub in nonzero_subs]),

                     temporary=1)

class Submasters:

    "Collection o' Submaster objects"

    def __init__(self):

        self.submasters = {}

        files = os.listdir(showconfig.subsDir())

    def dotrelease(self,ev,dotidx):

        self.unselect()

class Curveset:

    curves = None # curvename : curve

    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)

            curvename = curvename.replace('-','_')

            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)