mainwin.connect("destroy", self.onQuit)

        wtree.connect_signals(self)

        gtk.rc_parse("theme/marble-ice/gtk-2.0/gtkrc")

        gtk.rc_parse_string("""style "default" {font_name = "sans 7"}""")

        if self.opts.reload:

            self.refreshTheme()

        mainwin.show_all()

        mainwin.connect("delete-event", lambda *args: reactor.crash())

        def updateTitle():

            mainwin.set_title("curvecalc - %s" %

                              graph.label(

                                  graph.value(session, L9['currentSong'])))

        graph.addHandler(updateTitle)

        mainwin.parse_geometry("1x1-0+0")

        # this is the only one i found that would set the size right,

        # but it's a minimum size, which i don't really want

        mainwin.set_size_request(1678, 922)

        songChoice = Observable(None) # to be connected with the session song

        def setSong():

            songChoice(graph.value(session, L9['currentSong']))

        graph.addHandler(setSong)

        # next here, watch songChoice and patch the graph

        def songToGraph(newSong):

            graph.patchObject(context=session, subject=session,

                              predicate=L9['currentSong'], newObject=newSong)

        songChoice.subscribe(songToGraph)

        def current_player_song(song):

            # (this is run on every frame)

            ps = wtree.get_object("playerSong")

            if URIRef(ps.get_uri()) != song:

                print "update playerSong"

                def setLabel():

                    ps.set_label(graph.label(song))

                graph.addHandler(setLabel)

                ps.set_uri(song)

            if song != songChoice():

                if wtree.get_object("followPlayerSongChoice").get_active():

                    songChoice(song)

        self.current_player_song = current_player_song

        dispatcher.connect(current_player_song, "current_player_song")

        ec = EditChoice(graph, songChoice, label="Editing song:")

        wtree.get_object("currentSongEditChoice").add(ec)

class Curvesetview(object):

    """

    """

    def __init__(self, curvesVBox, zoomControlBox, curveset):

        self.live = True

        self.curvesVBox = curvesVBox

        self.curveset = curveset

        self.allCurveRows = set()

        import light9.curvecalc.zoomcontrol

        reload(light9.curvecalc.zoomcontrol)

        self.zoomControl = light9.curvecalc.zoomcontrol.ZoomControl()

        zoomControlBox.add(self.zoomControl.widget)

        self.zoomControl.widget.show_all()

        for c in curveset.curveNamesInOrder():

            self.add_curve(c) 

        dispatcher.connect(self.clear_curves, "clear_curves")

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

        dispatcher.connect(self.set_featured_curves, "set_featured_curves")

        self.newcurvename = gtk.EntryBuffer("", 0)

        eventBox = self.curvesVBox.get_parent()

        eventBox.connect("key-press-event", self.onKeyPress)

        eventBox.connect("button-press-event", self.takeFocus)

    def __del__(self):

        print "del curvesetview", id(self) 

    def clear_curves(self):

        """curveset is about to re-add all new curves"""

        while self.allCurveRows:

            self.allCurveRows.pop().destroy()

    def takeFocus(self, *args):

        """the whole curveset's eventbox is what gets the focus, currently, so

        keys like 'c' can work in it"""

        dispatcher.send("all curves lose selection")

        self.curvesVBox.get_parent().grab_focus()

    def curveRow_from_name(self, name):

        for cr in self.allCurveRows:

            if cr.name == name:

                return cr

        raise ValueError("couldn't find curveRow named %r" % name)

    def set_featured_curves(self, curveNames):

        """bring these curves to the top of the stack"""

        for n in curveNames[::-1]:

            self.curvesVBox.reorder_child(self.curveRow_from_name(n).box,

                                          gtk.PACK_START)

    def onKeyPress(self, widget, event):

        if not self.live: # workaround for old instances living past reload()

            return

        if event.string == 'c':