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

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

                                  t=self.current_time()))

        self.bind("<Shift-Escape>", lambda ev:

                  dispatcher.send("see time until end",

                                  t=self.current_time()))

        self.bind("<Control-p>", lambda ev:

                  dispatcher.send("music seek",

                                  t=self.world_from_screen(ev.x,0)[0]))

        self.bind("<Motion>",

                  self.dotmotion, add=True)

        self.bind("<ButtonRelease-1>",

                  self.dotrelease, add=True)

        # this binds on c-a-b1, etc

        self.regionzoom = RegionZoom(self, self.world_from_screen,

                                     self.screen_from_world)

        self.sketch = None # an in-progress sketch

        self.bind("<Shift-ButtonPress-1>", self.sketch_press)

        self.bind("<Shift-B1-Motion>", self.sketch_motion)

        self.bind("<Shift-ButtonRelease-1>", self.sketch_release)

        self.selecting = False

        self.bind("<Motion>", self.select_motion, add=True)

        self.bind("<ButtonPress-1>", self.check_deselect, add=True)

    def check_deselect(self,ev):

        try:

            self.find_index_near(ev.x, ev.y)

        except ValueError:

            self.selected_points[:] = []

            self.highlight_selected_dots()

    def select_press(self,ev):

        if not self.selecting:

            self.selecting = True

            self.select_start = self.world_from_screen(ev.x,0)[0]

            cursors.push(self,"gumby")

    def select_motion(self,ev):

        if not self.selecting:

            return

    def select_release(self,ev):

        if not self.selecting:

            return

        cursors.pop(self)

        self.selecting = False

    def sketch_press(self,ev):

        self.sketch = Sketch(self,ev)

    def sketch_motion(self,ev):

        if self.sketch:

            self.sketch.motion(ev)

    def sketch_release(self,ev):

        if self.sketch:

            self.sketch.release(ev)

            self.sketch = None

    def current_time(self):

        return self._time

    def screen_from_world(self,p):

        start,end = self.zoom

        ht = self.winfo_height()

        return (p[0]-start)/(end-start)*self.winfo_width(), (ht-5)-p[1]*(ht-10)

    def world_from_screen(self,x,y):

        start,end = self.zoom

        ht = self.winfo_height()

                sp = self.selected_points[si]

                if sp == i:

                    continue

                if sp > i:

                    sp -= 1

                newsel.append(sp)

            for ii in range(len(idxs)):

                if ii > i:

                    ii -= 1

                newidxs.append(idxs[ii])

            self.selected_points[:] = newsel

            idxs[:] = newidxs

        self.update_curve()

    def highlight_selected_dots(self):

        for i,d in self.dots.items():

            if i in self.selected_points:

                self.itemconfigure(d,fill='red')

            else:

                self.itemconfigure(d,fill='blue')

    def dotpress(self,ev,dotidx):

        if dotidx not in self.selected_points:

            self.selected_points=[dotidx]

        self.highlight_selected_dots()

        self.last_mouse_world = self.world_from_screen(ev.x, ev.y)

    def select_between(self,start,end):

        self.selected_points = self.curve.indices_between(start,end)

        self.highlight_selected_dots()

    def dotmotion(self,ev):

        if not ev.state & 256:

            return # not lmb-down

        cp = self.curve.points

        moved=0

        cur = self.world_from_screen(ev.x, ev.y)

        if self.last_mouse_world:

            delta = (cur[0] - self.last_mouse_world[0],

                     cur[1] - self.last_mouse_world[1])

        else:

            delta = 0,0

        self.last_mouse_world = cur

        for idx in self.selected_points:

            newp = [cp[idx][0] + delta[0], cp[idx][1] + delta[1]]

            newp[1] = max(0,min(1,newp[1]))

            if idx>0 and newp[0] <= cp[idx-1][0]:

                continue

            if idx<len(cp)-1 and newp[0] >= cp[idx+1][0]:

                continue

            moved=1

            cp[idx] = tuple(newp)

        if moved:

            self.update_curve()

    def unselect(self):

        self.selected_points=[]

        self.highlight_selected_dots()

    def dotrelease(self,ev):

        self.last_mouse_world = None

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

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

            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)