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

        self.subterm = st

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

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

    if expr is None:

        expr = '%s(t)' % subname

    subterms.append(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():

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

        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"

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

root=tk.Tk()

root.tk_setPalette("gray50")

toplevelat("curvecalc",root)

root.tk_focusFollowsMouse()

parser = optparse.OptionParser()

options,args = parser.parse_args()

try:

    song = URIRef(args[0])

except IndexError:

music=Music()

zc = Zoomcontrol(root)

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

curveset = Curveset()

csv = Curvesetview(root,curveset)

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

ssv = SubtermSetView(root)

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

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)

subterms = []

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

try:

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

          sub - n

          name, sub - new 

        """

        if name is sub is leveldict is None:

            raise TypeError("more args are needed")

        if sub is not None:

            name = graph.label(sub)

        if graph is not None:

            # old code was passing leveldict as second positional arg

            assert isinstance(graph, Graph)

        self.name = name

        self.temporary = temporary

        if leveldict:

            self.levels = leveldict

        else:

            self.levels = {}

        if not self.temporary:

            dispatcher.connect(self.reload, 'reload all subs')

        if self.temporary:

            return

        try:

            oldlevels = self.levels.copy()

            self.levels.clear()

            patchGraph = showconfig.getGraph()

            subUri = L9['sub/%s' % self.name]

            for lev in graph.objects(subUri, L9['lightLevel']):

                chan = graph.value(lev, L9['channel'])

                val = graph.value(lev, L9['level'])

                name = patchGraph.label(chan)

                self.levels[name] = float(val)

            if (not quiet) and (oldlevels != self.levels):

                print "sub %s changed" % self.name

    def save(self):

        if self.temporary:

            print "not saving temporary sub named",self.name

            return

        graph = Graph()

        subUri = L9['sub/%s' % self.name]

        graph.add((subUri, RDFS.label, Literal(self.name)))

        for chan in self.levels.keys():

            try:

                chanUri = Patch.get_channel_uri(chan)

            except KeyError: