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

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

            dmxclient.outputlevels(out.get_dmx_list(),

                                   twisted=1,clientid='curvecalc')

            self.lastsendtime = now

            self.lastsendlevs = levs

    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.pack(side='top',fill='x')

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

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

    subname = graph.label(subUri)

    if expr is None:

        expr = '%s(t)' % subname

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

                   Subexpr(curveset,expr))

    stv=Subtermview(master, graph, term)

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

    return term

    """

    the row that starts with 'reload subs' button

    """

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

    newname = tk.StringVar()

    def add_cmd(evt):

        uri = L9['sub/%s' % newname.get()]

        graph.add((uri, RDF.type, L9.Subterm))

        graph.add((uri, RDFS.label, Literal(newname.get())))

        add_one_subterm(graph, uri,

        if evt.state & 4: # control key modifier

            curveset.new_curve(newname.get())

        newname.set('')

    def reload_subs():

        dispatcher.send('reload all subs')

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

        graph.add((uri, RDFS.label, Literal(subterm.submaster.name)))

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

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

    return graph

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

        try:

        except rdflib.exceptions.UniquenessError:

            print "working around curvecalc save corruption"

            # curvecalc put all the expressions on one subterm, which is wrong

            for expr in graph.objects(st, L9['expression']):

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

def graphPathForSubterms(song):

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

def read_all_subs(graph):

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

                        anchor='w')

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

def main():

    parser = optparse.OptionParser()

    parser.set_usage("%prog [opts] songURI")

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

        song = URIRef(args[0])

    except IndexError:

        raise SystemExit("song URI is required, e.g. 'http://light9.bigasterisk.com/show/dance2008/song3'")

    log.debug("music")

    music=Music()

    curveset = Curveset(sliders=opts.sliders)

    musicfilename = showconfig.songOnDisk(song)

    maxtime = wavelength(musicfilename)

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

                                        showconfig.songFilenameFromURI(song)),

                  skipMusic=opts.skip_music)

    tksupport.install(root,ms=20)

    log.debug("run")

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

main()

    """curve does not know its name. see Curveset"""

    points = None # x-sorted list of (x,y)

    def __init__(self):

        self.points = []

        self._muted = False

    def muted():

        doc = "Whether to currently send levels (boolean, obviously)"

        def fget(self):

            return self._muted

        def fset(self, val):

            self._muted = val

    def current_time(self):

        return self._time

    def screen_from_world(self,p):

        start,end = self.zoom

    def world_from_screen(self,x,y):

        start,end = self.zoom

    def input_time(self, val, forceUpdate=False):

        # i tried various things to make this not update like crazy,

        # but the timeline was always missing at startup, so i got

        # scared that things were getting built in a funny order.        

        #if self._time == val:

                                 pos[0] + 8, pos[1] + 8,

                                 outline='#800000',

                                 tags=('knob',))

                dispatcher.send("knob out", value=prevKey[1], curve=self.curve)

    def update_curve(self,*args):

        self.zoom = dispatcher.send("zoom area")[0][1]

        cp = self.curve.points

        visible_x = (self.world_from_screen(0,0)[0],

        visible_idxs = self.curve.indices_between(visible_x[0], visible_x[1],

                                                  beyond=1)

        visible_points = [cp[i] for i in visible_idxs]

        self.delete('curve')

        if self.curve.muted:

            self['bg'] = 'grey20'

        else:

            self['bg'] = 'black'

            self._draw_gradient()

        else:

            self._draw_markers(visible_x)

            self._draw_line(visible_points)

            self.dots = {} # idx : canvas rectangle

            if len(visible_points)<50:

                self._draw_handle_points(visible_idxs,visible_points)

    def _draw_gradient(self):

        gradient_res = 3

            wx = self.world_from_screen(x,0)[0]

            mag = self.curve.eval(wx, allow_muting=False)

            if self.curve.muted:

                low = (8, 8, 8)

                high = (60, 60, 60)

            else:

            endtime = endtimes[0][1]

            mark(endtime,"end %.1f"%endtime)

            mark(endtime+10,"post %.1f"%(endtime+10))

    def _draw_one_marker(self,t,label):

        x = self.screen_from_world((t,0))[0]

        self.create_line(x,ht,x,ht-20, fill='white',

                         tags=('curve',))

        self.create_text(x,ht-20,text=label,anchor='s', fill='white',

    def _draw_line(self,visible_points):

        linepts=[]

        step=1

        linewidth=2

            self.knobCallback(int(name[4:]), value / 127)

        if name.startswith("button-knob"):

            self.knobButtonCallback(int(name[11:]))

class Curveset:

    curves = None # curvename : curve

    def __init__(self, sliders=False):

        """sliders=True means support the hardware sliders"""

        self.curves = {} # name : Curve

        self.curveName = {} # reverse

        self.sliderCurve = {} # slider number (1 based) : curve name

            self.sliderIgnoreInputUntil = {}

        else:

            self.sliders = None

    def load(self,basename, skipMusic=False):

        """find all files that look like basename-curvename and add

        def sorter(name):

            return not name.endswith('music'), name

        for filename in sorted(glob.glob("%s-*"%basename), key=sorter):

            curvename = filename[filename.rfind('-')+1:]

            if skipMusic and curvename in ['music', 'smooth_music']:

                continue

            c=Curve()

            c.load(filename)

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

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

        except KeyError:

            return

        self.sliders.valueOut("knob%s" % num, value * 127)

class CurveRow(tk.Frame):

    """

    """

    def __init__(self, master, name, curve, slider, knobEnabled):

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

        labelFont = "arial 8"

        leftside = tk.Frame(self)

        leftside.pack(side='left')

        txt = "curve '%s'" % name

        if len(name) > 7:

            txt = name

        curve_name_label.pack(side='left')

        collapsed_cb = tk.Checkbutton(leftside, text="C",

        collapsed_cb.pack(side='left')

        if slider is not None:

            # slider should have a checkbutton, defaults to off for

            # music tracks

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

        self.curves = {} # curvename : Curveview

        self.curveset = curveset

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

        tk.Label(f, text="new curve named: (C-N)").pack(side='left')

        self.newcurvename = tk.StringVar()

        entry = tk.Entry(f, textvariable=self.newcurvename)

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

        def focus_entry():

            entry.focus()

        dispatcher.connect(self.add_curve, "add_curve", sender=self.curveset)

        dispatcher.connect(focus_entry, "focus new curve", weak=False)

    def add_curve(self, name, slider=None, knobEnabled=False):

        curve = self.curveset.curves[name]

            if 0<x<self.winfo_width() and x-lastx>30:

                txt=str(t)

                if lastx==-1000:

                    txt=txt+"sec"

                self.create_line(x,0,x,15,

                                 tags=('tics',))

                lastx = x

class RegionZoom:

    """rigs c-a-b1 to drag out an area to zoom to. also catches other types of drag events, like b1 drag for selecting points