x = (t * speed) % len(self._smooth_random_items)

            x1 = int(x)

            y1 = self._smooth_random_items[x1]

            return y1

        glo['noise'] = smooth_random

        glo['notch'] = notch_random

        try:

            self.lasteval = eval(self.expr,glo)

        except Exception,e:

            dispatcher.send("expr_error",sender=self,exc=e)

        else:

            dispatcher.send("expr_error",sender=self,exc="ok")

        return self.lasteval

    def expr():

        doc = "python expression for level as a function of t, using curves"

        def fget(self):

            return self._expr

        def fset(self, value):

            self._expr = value

            dispatcher("expr_changed",sender=self)

        return locals()

    expr = property(**expr())

class Subexprview(tk.Frame):

    def __init__(self,master,se,**kw):

        self.subexpr=se

        tk.Frame.__init__(self,master,**kw)

        self.evar = tk.StringVar()

        e = self.ent = tk.Entry(self,textvariable=self.evar)

        e.pack(side='left',fill='x',exp=1)

        self.expr_changed()

        self.evar.trace_variable('w',self.evar_changed)

        dispatcher.connect(self.expr_changed,"expr_changed",

                           sender=self.subexpr)

        self.error = tk.Label(self)

        self.error.pack(side='left')

        dispatcher.connect(lambda exc: self.error.config(text=str(exc)),

                           "expr_error",sender=self.subexpr,weak=0)

    def expr_changed(self):

        if self.subexpr.expr!=self.evar.get():

            self.evar.set(self.subexpr.expr)

    def evar_changed(self,*args):

        self.subexpr.expr = self.evar.get()

class Subterm:

    """one Submaster and its Subexpr"""

    def __init__(self, submaster, subexpr):

        make_attributes_from_args('submaster', 'subexpr')

    def scaled(self, t):

        subexpr_eval = self.subexpr.eval(t)

        # we prevent any exceptions from escaping, since they cause us to

        # stop sending levels

        try:

            if isinstance(subexpr_eval, Submaster.Submaster):

                # if the expression returns a submaster, just return it

                return subexpr_eval

            else:

                # otherwise, return our submaster multiplied by the value 

                # returned

                return self.submaster * subexpr_eval

        except Exception, e:

            dispatcher.send("expr_error", sender=self.subexpr, exc=str(e))

            return Submaster.Submaster('Error: %s' % str(e), temporary=True)

class Subtermview(tk.Frame):

    def __init__(self, master, graph, st, **kw):

        self.subterm = st

        tk.Frame.__init__(self,master,bd=1,relief='raised',**kw)

        l = tk.Label(self,

                     text="sub %s" % graph.label(self.subterm.submaster.uri))

        l.pack(side='left')

        sev=Subexprview(self,self.subterm.subexpr)

        sev.pack(side='left',fill='both',exp=1)

class Output:

    lastsendtime=0

    lastsendlevs=None

    def __init__(self,subterms,music):

        make_attributes_from_args('subterms','music')

        self.recent_t=[]

        self.later = None

        self.update()

    def update(self):

        d = music.current_time()

        d.addCallback(self.update2)

        d.addErrback(self.updateerr)

    def updateerr(self,e):

        print e.getTraceback()

        dispatcher.send("update status",val=e.getErrorMessage())

        if self.later and not self.later.cancelled and not self.later.called:

            self.later.cancel()

        self.later = reactor.callLater(1,self.update)

    def update2(self,t):

        # spot alsa soundcard offset is always 0, we get times about a

        # second ahead of what's really getting played

        #t = t - .7

        dispatcher.send("update status",

                        val="ok: receiving time from music player")

        if self.later and not self.later.cancelled and not self.later.called:

            self.later.cancel()

        self.later = reactor.callLater(.05, self.update)

        self.recent_t = self.recent_t[-50:]+[t]

        period = (self.recent_t[-1] - self.recent_t[0]) / len(self.recent_t)

        dispatcher.send("update period", val=period)

        self.send_dmx(t)

    def send_dmx(self,t):

        dispatcher.send("curves to sliders", t=t)

        scaledsubs=[]

        for st in self.subterms:

            scl = st.scaled(t)

            scaledsubs.append(scl)

        out = Submaster.sub_maxes(*scaledsubs)

        levs = out.get_levels()

        now=time.time()

        if now-self.lastsendtime>5 or levs!=self.lastsendlevs:

            dispatcher.send("output levels",val=levs)

            dmxclient.outputlevels(out.get_dmx_list(),

                                   twisted=1,clientid='curvecalc')

            self.lastsendtime = now

            self.lastsendlevs = levs

def create_status_lines(master):

    for signame,textfilter in [

        ('input time',lambda t: "%.2fs"%t),

        ('output levels',

         lambda levels: textwrap.fill("; ".join(["%s:%.2f"%(n,v)

                                                 for n,v in

                                                 levels.items()[:5]

                                                 if v>0]),70)),

        ('update period',lambda t: "%.1fms"%(t*1000)),

        ('update status',lambda t: str(t)),

        ]:

        l = tk.Label(master,anchor='w',justify='left')

        l.pack(side='top',fill='x')

        dispatcher.connect(lambda val,l=l,sn=signame,tf=textfilter:

                           l.config(text=sn+": "+tf(val)),

                           signame,weak=0)

class SubtermSetView(tk.Frame):

    def __init__(self, master, *args, **kw):

        tk.Frame.__init__(self, master, *args, **kw)

        self.cur_row = 0

        self.cur_col = 0

        self.ncols = 2

    def add_subtermview(self, stv):

        stv.grid(row=self.cur_row, column=self.cur_col, sticky='news')

        self.columnconfigure(self.cur_col, weight=1)

        self.cur_col += 1

        self.cur_col %= self.ncols

        if self.cur_col == 0:

            self.cur_row += 1

def add_one_subterm(graph, subUri, curveset, subterms, root, ssv, expr=None):

    subname = graph.label(subUri)

    if expr is None:

        expr = '%s(t)' % subname

    print "req to add %r" % subUri

    for s in graph.triples((subUri, None, None)):

        print s

    term = Subterm(Submaster.Submaster(graph=graph, sub=subUri),

                   Subexpr(curveset,expr))

    subterms.append(term)

    stv=Subtermview(ssv, graph, term)

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

    ssv.add_subtermview(stv)

    return term

def sub_commands_tk(master, curveset, subterms, root, ssv, graph):

    f=tk.Frame(master,relief='raised',bd=1)

    newname = tk.StringVar()

    def add_cmd():

        add_one_subterm(graph, L9['sub/%s' % newname.get()],

        newname.set('')

    def reload_subs():

        dispatcher.send('reload all subs')

    tk.Button(f, text="reload subs (C-r)", 

        command=reload_subs).pack(side='left')

    tk.Label(f, text="new subterm named:").pack(side='left')

    entry = tk.Entry(f, textvariable=newname)

    entry.pack(side='left', fill='x', exp=1)

    entry.bind("<Key-Return>", lambda evt: add_cmd())

    return f

def savesubterms(filename,subterms):

    raise NotImplementedError

    s=""

    for st in subterms:

        s=s+"%s %s\n" % (st.submaster.name, st.subexpr.expr)

    file(filename,'w').write(s)

def createSubtermGraph(song, subterms):

    """rdf graph describing the subterms, readable by add_subterms_for_song"""

    graph = Graph()

    for subterm in subterms:

        uri = URIRef(song + "/subterm/" + subterm.submaster.name)

        graph.add((song, L9['subterm'], uri))

        graph.add((uri, RDF.type, L9['Subterm']))

        graph.add((uri, L9['sub'], L9['sub/%s' % subterm.submaster.name]))

        graph.add((uri, L9['expression'], Literal(subterm.subexpr.expr)))

    return graph

def add_subterms_for_song(graph, song, curveset, subterms, root, ssv):

    for st in graph.objects(song, L9['subterm']):

        add_one_subterm(graph, graph.value(st, L9['sub']), curveset, subterms,

                        root, ssv, graph.value(st, L9['expression']))

def graphPathForSubterms(song):

    return showconfig.subtermsForSong(showconfig.songFilenameFromURI(song)) + ".n3"

def read_all_subs(graph):

    """read all sub files into this graph so when add_one_subterm tries

    to add, the sub will be available"""

    subsDir = showconfig.subsDir()

    for filename in os.listdir(subsDir):

        graph.parse(os.path.join(subsDir, filename), format="n3")

#######################################################################

root=tk.Tk()

root.tk_setPalette("gray50")

toplevelat("curvecalc",root)

root.tk_focusFollowsMouse()

parser = optparse.OptionParser()

parser.add_option("--sliders", action='store_true',

                  help='use hardware sliders')

parser.add_option("--skip-music", action='store_true',

                  help="ignore music and smooth_music curve files")

opts, args = parser.parse_args()

try:

    song = URIRef(args[0])

except IndexError:

    raise SystemExit("song name is required, e.g. '05-mix'")

log.debug("music")

music=Music()

zc = Zoomcontrol(root)

zc.pack(side='top',fill='x')

curveset = Curveset(sliders=opts.sliders)

csv = Curvesetview(root, curveset)

csv.pack(side='top',fill='both',exp=1)

ssv = SubtermSetView(root)

ssv.pack(side='top', fill='x')

graphOrig = showconfig.getGraph()

graph = Graph() # a copy, since we're going to add subs into it

for s in graphOrig:

    graph.add(s)

read_all_subs(graph)

root.title("Curvemaster 3000MX - %s" % graph.label(song))

musicfilename = showconfig.songOnDisk(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(),

                                    showconfig.songFilenameFromURI(song)),

              skipMusic=opts.skip_music)

subterms = []

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

try:

    graph.parse(graphPathForSubterms(song), format='n3')

    add_subterms_for_song(graph, song, curveset, subterms, root, ssv)

except OSError, e:

    print e

log.debug("output")

out = Output(subterms, music)

def savekey(*args):

    print "saving",song

    g = createSubtermGraph(song, subterms)

    g.serialize(graphPathForSubterms(song), format="nt")

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

    print "saved"

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

root.bind("<Control-Key-r>", lambda evt: dispatcher.send('reload all subs'))

create_status_lines(root)

for helpline in ["Bindings: C-s save subterms;  Esc see current time; S-Esc see curtime to end; Mousewheel zoom; C-p play/pause music at mouse",

                 "Curve point bindings: B1 drag point; C-B1 curve add point; S-B1 sketch points; Del selected points; 1..5 add point at time; B1 drag select points",

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

#def logprint(msg):

#    print "log",msg

#twisted.python.log.addObserver(logprint)

root.bind("<Control-Key-q>",lambda ev: reactor.stop)

root.bind("<Destroy>",lambda ev: reactor.stop)

root.protocol('WM_DELETE_WINDOW', reactor.stop)

tksupport.install(root,ms=20)

log.debug("run")

prof.run(reactor.run, profile=False)