self.dots = {} # idx : canvas rectangle

            if len(visible_points)<50:

                self._draw_handle_points(visible_idxs,visible_points)

    def _draw_gradient(self):

        gradient_res = 3

        for x in range(0,self.winfo_width(),gradient_res):

            wx = self.world_from_screen(x,0)[0]

            mag = self.curve.eval(wx)

            self.create_line(x,0, x,40,

                             fill=gradient(mag,

                                           low=(20,10,50),

                                           high=(255,187,255)),

                             width=gradient_res, tags='curve')

    def _draw_markers(self,visible_x):

        mark = self._draw_one_marker

        mark(0,"0")

        t1,t2=visible_x

        if t2-t1<30:

            for t in range(int(t1),int(t2)+1):

                mark(t,str(t))

        mark(-4,"-4")

        endtimes = dispatcher.send("get max time")

        if endtimes:

            endtime = endtimes[0][1]

            mark(endtime,"end %.1f"%endtime)

            mark(endtime+10,"post %.1f"%(endtime+10))

    def _draw_one_marker(self,t,label):

        x = self.screen_from_world((t,0))[0]

        ht = self.winfo_height()

        self.create_line(x,ht,x,ht-20,

                         tags=('curve',))

        self.create_text(x,ht-20,text=label,anchor='s',

                         tags=('curve',))

    def _draw_line(self,visible_points):

        linepts=[]

        step=1

        linewidth=2

        if len(visible_points)>800:

            step = int(len(visible_points)/800)

            linewidth=1

        for p in visible_points[::step]:

            linepts.extend(self.screen_from_world(p))

        if len(linepts)<4:

            return

        line = self.create_line(*linepts,**dict(width=linewidth,tags='curve'))

        # canvas doesnt have keyboard focus, so i can't easily change the

        # cursor when ctrl is pressed

        #        def curs(ev):

        #            print ev.state

        #        self.bind("<KeyPress>",curs)

        #        self.bind("<KeyRelease-Control_L>",lambda ev: curs(0))

        self.tag_bind(line,"<Control-ButtonPress-1>",self.new_point_at_mouse)

    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 = self.create_rectangle(p[0]-rad,p[1]-rad,p[0]+rad,p[1]+rad,

                                        outline='black',fill='blue',

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

            if worldp[1] == 0:

                rad += 3

                dot2 = self.create_oval(p[0]-rad,p[1]-rad,

                                             p[0]+rad,p[1]+rad,

                                             outline='darkgreen',

                                       tags=('curve','point', 'handle%d' % 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

        def delpoint(ev):

            # had a hard time tag_binding to the points, so i trap at

            # the widget level (which might be nice anyway when there

            # are multiple pts selected)

            if self.selected_points:

                self.remove_point_idx(*self.selected_points)

        self.bind("<Key-Delete>", delpoint)

        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)

        x, y = p

        y = max(0, y)

        y = min(1, y)

        p = x, y

        self.add_point(p)

    def add_point(self, p):

        self.unselect()

        self.curve.insert_pt(p)

        self.update_curve()

    def remove_point_idx(self, *idxs):

        idxs = list(idxs)

        while idxs:

            i = idxs.pop()

            self.curve.points.pop(i)

            newsel = []

            newidxs = []

            for si in range(len(self.selected_points)):

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

        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 dotmotion(self,ev):

        if not self.dragging_dots:

            return

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

        if not self.dragging_dots:

            return

        self.last_mouse_world = None

        self.dragging_dots = False

class Sliders(BCF2000):

    def __init__(self, cb, knobCallback, knobButtonCallback):

        BCF2000.__init__(self)

        self.cb = cb

        self.knobCallback = knobCallback

        self.knobButtonCallback = knobButtonCallback

    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)

        if name.startswith("button-knob"):

            self.knobButtonCallback(int(name[11:]))

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:

            self.sliders = Sliders(self.hw_slider_in, self.hw_knob_in, 

                                   self.hw_knob_button)

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

        def sorter(name):

            return not name.endswith('music'), name

        for filename in sorted(glob.glob("%s-*"%basename), key=sorter):

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

    def add_curve(self,name,curve):

        self.curves[name] = curve

        self.curveName[curve] = name

        if self.sliders and name not in ['smooth_music', 'music']:

            num = len(self.sliderCurve) + 1

            if num <= 8:

                self.sliderCurve[num] = name

                self.sliderNum[name] = num

            else:

                num = None

        else:

            num = None

        dispatcher.send("add_curve", slider=num, knobEnabled=num is not None,

                        sender=self,name=name)

    def globalsdict(self):

        return self.curves.copy()

    def get_time_range(self):

        return -4, dispatcher.send("get max time")[0][1]+15

    def new_curve(self,name):

        if name=="":

            print "no name given"

            return

        while name in self.curves:

           name=name+"-1"

        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

        dispatcher.send("set key", curve=curve, value=value)

    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 hw_knob_button(self, num):

        try:

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

        except KeyError:

            return

        dispatcher.send("set key", curve=curve)

    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)

        f = tk.Frame(self,relief='raised',bd=1)

        f.pack(side='top',fill='x')

        tk.Label(f, text="new curve named: (C-N)").pack(side='left')

        self.newcurvename = tk.StringVar()

        def new_curve(event):

            self.curveset.new_curve(self.newcurvename.get())

            self.newcurvename.set('')

        entry = tk.Entry(f, textvariable=self.newcurvename)

        entry.pack(side='left', fill='x',exp=1)        

        entry.bind("<Key-Return>", new_curve)

        def focus_entry():

            entry.focus()

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

        dispatcher.connect(focus_entry, "focus new curve", weak=False)

    def add_curve(self,name, slider=None, knobEnabled=False):

        f = tk.Frame(self,relief='raised',bd=1)

        f.pack(side='top',fill='both',exp=1)

        leftside = tk.Frame(f)

        leftside.pack(side='left')

        collapsed = tk.IntVar()

        txt = "curve '%s'" % name

        if len(name) > 7:

            txt = name

                 width=15).pack(side='top')

        sliderLabel = None

        def cmd():

            if collapsed.get():

                if sliderLabel:

                    sliderLabel.pack_forget()

                f.pack(exp=0)

            else:

                if sliderLabel:

                    sliderLabel.pack(side='top')

                f.pack(exp=1)

                       variable=collapsed, command=cmd).pack(side='top')

        if slider is not None:

            # slider should have a checkbutton, defaults to off for

            # music tracks

            sliderLabel = tk.Label(leftside, text="Slider %s" % slider,

            sliderLabel.pack(side='top')

        cv = Curveview(f, self.curveset.curves[name],

                       knobEnabled=knobEnabled)

        cv.pack(side='left',fill='both',exp=1)

        self.curves[name] = cv