dialog.hide()

    def refreshTheme(self):

        gtk.rc_reparse_all()

        reactor.callLater(1, self.refreshTheme)

    def onQuit(self, *args):

        reactor.crash()

        # there's a hang after this, maybe in sem_wait in two

        # threads. I don't know whose they are.

        os.kill(os.getpid(), signal.SIGKILL)

    def onPythonConsole(self, item):

        togglePyConsole(self, item, self.__dict__)

    def onSeeCurrentTime(self, item):

        dispatcher.send("see time")

    def onSeeTimeUntilEnd(self, item):

        dispatcher.send("see time until end")

    def onZoomAll(self, item):

        dispatcher.send("show all")

        dispatcher.connect(self.select_between, "select between")

        if self.knobEnabled:

            dispatcher.connect(self.knob_in, "knob in")

            dispatcher.connect(self.slider_in, "set key")

        self.widget.connect("size-allocate", self.update_curve)

        self.widget.connect("leave-notify-event", self.onLeave)

        self.widget.connect("enter-notify-event", self.onEnter)

        self.widget.connect("motion-notify-event", self.onMotion)

        self.widget.connect("scroll-event", self.onScroll)

        self.widget.connect("button-release-event", self.onRelease)

        if 0:

            for x in range(1, 6):

                def add_kb_marker_point(evt, x=x):

                    self.add_point((self.current_time(), (x - 1) / 4.0))

                self.bind("<Key-%s>" % x, add_kb_marker_point)

        # this binds on c-a-b1, etc

        if 0:

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

                                         self.screen_from_world)

        self.sketch = None # an in-progress sketch

        self.dragging_dots = False

        self.selecting = False

        if 0:

            self.bind("<ButtonPress-1>",#"<Alt-Key>",

                      self.select_press, add=True)

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

            self.bind("<ButtonRelease-1>", #"<Alt-KeyRelease>",

                      self.select_release, add=True)

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

            self.bind("<Key-m>", lambda *args: self.curve.toggleMute())

            self.bind("<Key-c>", lambda *args: dispatcher.send('toggle collapse',

                                                               sender=self.curve))

    def playPause(self):

        """

        user has pressed ctrl-p over a curve view, possibly this

        one. Returns the time under the mouse if we know it, or else

        None

        todo: there should be a faint timecursor line under the mouse

        so it's more obvious that we use that time for some

        events. Rt-click should include Ctrl+P as 'play/pause from

        here'

        """

        # maybe self.widget.get_pointer would be ok for this? i didn't try it

            self.highlight_selected_dots()

    def select_press(self,ev):

        # todo: these select_ handlers are getting called on c-a-drag

        # zooms too. the dispatching should be more selective than

        # just calling both handlers all the time

        self.print_state("select_press")

        if self.dragging_dots:

            return

        if not self.selecting:

            self.selecting = True

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

    def select_motion(self,ev):

        if not self.selecting:

            return

        start = self.select_start

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

        self.select_between(start, cur)

    def select_release(self,ev):

        self.print_state("select_release")

        # dotrelease never gets called, but I can clear that state here

        self.dragging_dots = False

        if not self.selecting:

            return

        self.selecting = False

        self.select_between(self.select_start,

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

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

        cp = self.curve.points

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

                     self.world_from_screen(self.size.width, 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]

        if getattr(self, 'curveGroup', None):

            self.curveGroup.remove()

        self.curveGroup = goocanvas.Group(parent=self.root)

        if self.size.height < .40:

            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)

                       x=x+3, y=ht-20,

                       text=label)

    def _draw_line(self,visible_points):

        linepts=[]

        step=1

        linewidth = 1.5

        maxPointsToDraw = self.size.width / 2

        if len(visible_points) > maxPointsToDraw:

            step = int(len(visible_points) / maxPointsToDraw)

            linewidth = .8

        for p in visible_points[::step]:

        if self.curve.muted:

            fill = 'grey34'

        else:

            fill = 'white'

        self.pl = goocanvas.Polyline(parent=self.curveGroup,

                                     points=goocanvas.Points(linepts),

                                     line_width=linewidth,

                                     stroke_color=fill,

                                     )

    def _draw_handle_points(self,visible_idxs,visible_points):

        for i,p in zip(visible_idxs,visible_points):

            rad=3

            worldp = p

            p = self.screen_from_world(p)

            dot = goocanvas.Rect(parent=self.curveGroup,

                                 width=rad * 2, height=rad * 2,

                                 stroke_color='gray90',

                                 fill_color='blue',

                                 line_width=1,

                                 #tags=('curve','point', 'handle%d' % i)

                                 )

            if worldp[1] == 0:

                rad += 3

                goocanvas.Ellipse(parent=self.curveGroup,

                                  center_x=p[0],

                                  center_y=p[1],

                                  radius_x=rad,

                                  radius_y=rad,

                                  line_width=2,

                                  stroke_color='#00a000',

                                  #tags=('curve','point', 'handle%d' % i)

                                  )

            dot.connect("button-press-event", self.dotpress, i)

            #self.tag_bind('handle%d' % i,"<ButtonPress-1>",

            #              lambda ev,i=i: self.dotpress(ev,i))

            #self.tag_bind('handle%d' % i, "<Key-d>",

            #              lambda ev, i=i: self.remove_point_idx(i))

            self.dots[i]=dot

        self.highlight_selected_dots()

    def find_index_near(self,x,y):

        tags = self.gettags(self.find_closest(x, y))

        try:

            handletags = [t for t in tags if t.startswith('handle')]

            return int(handletags[0][6:])

        except IndexError:

            raise ValueError("no point found")

    def new_point_at_mouse(self, ev):

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

                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:

            else:

    def dotpress(self, r1, r2, ev, dotidx):

        self.print_state("dotpress")

        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)

        self.dragging_dots = True

    def select_between(self,start,end):

        if start > end:

            start, end = end, start

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

        self.highlight_selected_dots()

    def onEnter(self, widget, event):

        self.entered = True

    def onLeave(self, widget, event):

        self.entered = False

    def onMotion(self, widget, event):

        self.lastMouseX = event.x

        if not self.dragging_dots:

            return

        if not event.state & 256:

            return # not lmb-down

        cp = self.curve.points

        moved=0

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

        if self.last_mouse_world:

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

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

    def unselect(self):

        self.selected_points=[]

        self.highlight_selected_dots()

    def onScroll(self, widget, event):

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

        self.zoomControl.zoom_about_mouse(

            t, factor=1.5 if event.direction == gtk.gdk.SCROLL_DOWN else 1/1.5)

    def onRelease(self, widget, event):

        self.print_state("dotrelease")

        if not self.dragging_dots:

            return

        self.last_mouse_world = None

        self.dragging_dots = False

class CurveRow(object):

    """

    one of the repeating curve rows (including widgets on the left)

    please pack self.box

    """

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

        if slider is not None:

            # slider should have a checkbutton, defaults to off for

            # music tracks

            self.sliderLabel = gtk.Label("Slider %s" % slider)

            box.pack_start(self.sliderLabel)

        # widgets that need recoloring when we tint the row:

        #self.widgets = [leftside, collapsed_cb, muted_cb,

        #                curve_name_label, self]

        #if self.sliderLabel:

        #    self.widgets.append(self.sliderLabel)

    def toggleCollapsed(self):

        self.collapsed.set(not self.collapsed.get())

    def update_ui_to_collapsed_state(self, *args):

        if self.collapsed.get():

            if self.sliderLabel:

                self.sliderLabel.pack_forget()

            self.curveView.config(height=25)

        else:

            if self.sliderLabel:

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

            self.curveView.config(height=100)

        f.curveView.goLive()

    def row(self, name):

        return [r for r in self.allCurveRows if r.name == name][0]

    def goLive(self):

        """for startup performance, none of the curves redraw

        themselves until this is called once (and then they're normal)"""

        for cr in self.allCurveRows:

            cr.curveView.goLive()