self.curveview.update_curve()

class Curveview(tk.Canvas):

    def __init__(self, master, curve, knobEnabled=False, **kw):

        """knobEnabled=True highlights the previous key and ties it to a

        hardware knob"""

        self.curve=curve

        self.knobEnabled = knobEnabled

        self._time = 0

        self.last_mouse_world = None

        tk.Canvas.__init__(self,master,width=10,height=10,

                           relief='sunken',bd=1,

                           closeenough=5,takefocus=1, **kw)

        self.selected_points=[] # idx of points being dragged

        self.update_curve()

        # self.bind("<Enter>",self.focus)

        dispatcher.connect(self.input_time,"input time")

        dispatcher.connect(self.update_curve,"zoom changed")

        dispatcher.connect(self.update_curve,"points changed",

                           sender=self.curve)

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

        if self.knobEnabled:

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

        self.bind("<Configure>",self.update_curve)

        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)

        for butnum,factor in (5, 1.5),(4, 1/1.5):

            self.bind("<ButtonPress-%s>"%butnum,

                      lambda ev,factor=factor:

                      dispatcher.send("zoom about mouse",

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

                                      factor=factor))

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

                  dispatcher.send("see time",

                                  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("<Shift-ButtonRelease-1>", self.sketch_release)

        self.dragging_dots = False

        self.selecting = False

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

                  self.select_press)

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

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

                  self.select_release)

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

    def knob_in(self, curve, value):

        """user turned a hardware knob, which edits the point to the

        left of the current time"""

        if curve != self.curve:

            return

        idx = self.curve.index_before(self.current_time())

        if idx is not None:

            pos = self.curve.points[idx]

            self.curve.points[idx] = (pos[0], value)

            self.update_curve()

        if curve != self.curve:

            return

        self.curve.insert_pt((self.current_time(), value))

        self.update_curve()

    def print_state(self, msg=""):

        if 0:

            print "%s: dragging_dots=%s selecting=%s" % (

                msg, self.dragging_dots, self.selecting)

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

        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]

            cursors.push(self,"gumby")

            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.print_state("dotrelease")

        if not self.dragging_dots:

            return

        self.last_mouse_world = None

        self.dragging_dots = False

class Sliders(BCF2000):

        BCF2000.__init__(self)

        self.cb = cb

        self.knobCallback = knobCallback

    def valueIn(self, name, value):

        if name.startswith("slider"):

            self.cb(int(name[6:]), value / 127)

        if name.startswith("knob"):

            self.knobCallback(int(name[4:]), value / 127)

class Curveset:

    curves = None # curvename : curve

    def __init__(self, sliders=False):

        """sliders=True means support the hardware sliders"""

        self.curves = {} # name : Curve

        self.curveName = {} # reverse

        self.sliderCurve = {} # slider number (1 based) : curve name

        self.sliderNum = {} # reverse

        if sliders:

            dispatcher.connect(self.curvesToSliders, "curves to sliders")

            dispatcher.connect(self.knobOut, "knob out")

            self.lastSliderTime = {} # num : time

            self.sliderSuppressOutputUntil = {} # num : time

            self.sliderIgnoreInputUntil = {}

        else:

            self.sliders = None

    def load(self,basename, skipMusic=False):

        """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:]

            if skipMusic and curvename in ['music', 'smooth_music']:

                continue

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

        c = Curve()

        s,e = self.get_time_range()

        c.points.extend([(s,0), (e,0)])

        self.add_curve(name,c)

    def hw_slider_in(self, num, value):

        try:

            curve = self.curves[self.sliderCurve[num]]

        except KeyError:

            return

        now = time.time()

        if now < self.sliderIgnoreInputUntil.get(num):

            return

        # don't make points too fast. This is the minimum spacing

        # between slider-generated points.

        self.sliderIgnoreInputUntil[num] = now + .1

        # don't push back on the slider for a little while, since the

        # user might be trying to slowly move it. This should be

        # bigger than the ignore time above.

        self.sliderSuppressOutputUntil[num] = now + .2

    def hw_knob_in(self, num, value):

        try:

            curve = self.curves[self.sliderCurve[num]]

        except KeyError:

            return

        dispatcher.send("knob in", curve=curve, value=value)

    def curvesToSliders(self, t):

        now = time.time()

        for num, name in self.sliderCurve.items():

            if now < self.sliderSuppressOutputUntil.get(num):

                continue

#            self.lastSliderTime[num] = now

            value = self.curves[name].eval(t)

            self.sliders.valueOut("slider%s" % num, value * 127)

    def knobOut(self, curve, value):

        try:

            num = self.sliderNum[self.curveName[curve]]

        except KeyError:

            return

        self.sliders.valueOut("knob%s" % num, value * 127)

class Curvesetview(tk.Frame):

    curves = None # curvename : Curveview

    def __init__(self, master, curveset, **kw):

        self.curves = {}

        self.curveset = curveset

        tk.Frame.__init__(self,master,**kw)