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 event.state & gtk.gdk.SHIFT_MASK and 1: # and B1

            self.sketch_motion(event)

            return

        self.select_motion(event)

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

        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.select_indices([])

    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 event.state & gtk.gdk.SHIFT_MASK: # relese-B1

            self.sketch_release(event)

            return

        self.select_release(event)

        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)

    i wish these were in a list-style TreeView so i could set_reorderable on it

    please pack self.box

    """

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

        self.name = name

        self.box = gtk.VBox()

        self.box.set_border_width(1)

        self.cols = gtk.HBox()

        self.box.add(self.cols)

        controls = gtk.Frame()

        controls.set_size_request(115, -1)

        controls.set_shadow_type(gtk.SHADOW_OUT)

        self.cols.pack_start(controls, expand=False)

        self.setupControls(controls, name, curve, slider)

        self.curveView = Curveview(curve, markers, knobEnabled=knobEnabled,

                                   isMusic=name in ['music', 'smooth_music'],

                                   zoomControl=zoomControl)

        self.initCurveView()

        dispatcher.connect(self.rebuild, "all curves rebuild")

    def rebuild(self):

        self.curveView.rebuild()

        self.initCurveView()

        self.update_ui_to_collapsed_state()

    def initCurveView(self):

        self.curveView.widget.show()

        self.curveView.widget.set_size_request(-1, 100)

        self.cols.pack_start(self.curveView.widget, expand=True)       

    def setupControls(self, controls, name, curve, slider):

        box = gtk.VBox()

        controls.add(box)

        txt = "curve '%s'" % name

        if len(name) > 7:

            txt = name

        curve_name_label = gtk.Label(txt)

        box.pack_start(curve_name_label)

        bools = gtk.HBox()

        box.pack_start(bools)

        self.collapsed = gtk.CheckButton("C")

        bools.pack_start(self.collapsed)

        self.collapsed.connect("toggled", self.update_ui_to_collapsed_state)

        self.hideWhenCollapsed = [bools]

        self.muted = gtk.CheckButton("M")

        bools.pack_start(self.muted)

        self.muted.connect("toggled", self.sync_mute_to_curve)

        dispatcher.connect(self.mute_changed, 'mute changed', sender=curve)

        self.sliderLabel = None

        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, self.collapsed, self.muted,

        #                curve_name_label, self]

        #if self.sliderLabel:

        #    self.widgets.append(self.sliderLabel)

    def onDelete(self):

        self.curveView.onDelete()

    def update_ui_to_collapsed_state(self, *args):

        if self.collapsed.get_active():

            self.curveView.widget.set_size_request(-1, 25)

            [w.hide() for w in self.hideWhenCollapsed]

        else:

            self.curveView.widget.set_size_request(-1, 100)

            [w.show() for w in self.hideWhenCollapsed]

    def sync_mute_to_curve(self, *args):

        """send value from CheckButton to the master attribute inside Curve"""

        new_mute = self.muted.get_active()

        self.curveView.curve.muted = new_mute

    def update_mute_look(self):

        """set colors on the widgets in the row according to self.muted.get()"""

        # not yet ported for gtk

        return

        if self.curveView.curve.muted:

            new_bg = 'grey20'

        else:

            new_bg = 'normal'

        for widget in self.widgets:

            widget['bg'] = new_bg

    def mute_changed(self):

        """call this if curve.muted changed"""

        self.muted.set_active(self.curveView.curve.muted)

        #self.update_mute_look()

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