self.refreshCurveView()       

        self.makeStatusLines(wtree.get_object("status"))

        def connect(w):

            w.drag_dest_set(flags=gtk.DEST_DEFAULT_ALL,

                            targets=[('text/uri-list', 0, 0)],

                            actions=gtk.gdk.ACTION_COPY)

            w.connect("drag-data-received", self.onDataReceived)

        #connect(mainwin)

        # this probably isn't rerunning often enough to catch new data

        #connect(wtree.get_object("subterms")) # works for that area

        # may not work

        wtree.get_object("paned1").set_position(600)

    def onDataReceived(self, widget, context, x, y, selection,

                       targetType, time):

        data = selection.data.strip()

        if '?' in data:

            self.handleSubtermDrop(data)

            return

        try:

            self.makeSubterm(subName, withCurve=True)

        except SubtermExists:

            pass

        curveView = self.curvesetView.row(subName).curveView

        t = self.lastSeenInputTime # curveView.current_time() # new curve hasn't heard the time yet. this has gotten too messy- everyone just needs to be able to reach the time source

        curveView.add_points([(t - .5, 0),

                              (t, 1)])

    def onDragDataInNewSubZone(self, widget, context, x, y, selection,

                       targetType, time):

        self.makeSubterm(newname="cx", withCurve=True,

            return current.value(self.session, L9['currentSong'])

    def songSubtermsContext(self):

        return self.currentSong()

    def makeSubterm(self, newname, withCurve=False, expr=None, sub=None):

        with self.graph.currentState() as current:

            song = self.currentSong()

            for i in range(1000):

                uri = song + "/subterm/%d" % i

                if (uri, None, None) not in current:

                    break

        if sub is not None:

            quads.append((uri, L9['sub'], sub, ctx))

        if expr is not None:

            quads.append((uri, L9['expression'], Literal(expr), ctx))

        self.graph.patch(Patch(addQuads=quads))

        return uri

    def set_subterms_from_graph(self):

        """rebuild all the gtktable 'subterms' widgets and the

        self.currentSubterms list"""

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

        newList = []

        # of them may be able to pick this up

        results = dispatcher.send("onPlayPause")

        times = [t for listener, t in results if t is not None]

        self.music.playOrPause(t=times[0] if times else None)

    def onSave(self, *args):

        with self.graph.currentState() as g:

            song = g.value(self.session, L9['currentSong'])

            log.info("saving curves for %r", song)

            self.curveset.save(basename=os.path.join(

                showconfig.curvesDir(),

from __future__ import division

import glob, time, logging, ast

from bisect import bisect_left,bisect

import louie as dispatcher

from bcf2000 import BCF2000

log = logging.getLogger()

# todo: move to config, consolidate with ascoltami, musicPad, etc

introPad = 4

class Curveset(object):

    curves = None # curvename : curve

    def __init__(self, sliders=False):

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

        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)

        self.markers.save("%s.markers" % basename)

    def curveNamesInOrder(self):

        return sorted(self.curves.keys(), key=self.sorter)

    def add_curve(self,name,curve):

        if name in self.curves:

            raise ValueError("can't add a second curve named %r" % name)

        self.curves[name] = curve

        self.curveName[curve] = name

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

    def globalsdict(self):

        return self.curves.copy()

    def get_time_range(self):

        return 0, dispatcher.send("get max time")[0][1]

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

    <property name="upper">100</property>

    <property name="step_increment">1</property>

    <property name="page_increment">10</property>

  </object>

  <object class="GtkTextBuffer" id="help">

    <property name="text">Mousewheel zoom; C-p play/pause music at mouse

Keys in a selected curve: C to collapse; R to rebuild broken canvas widget; 1..5 add point at time cursor; q,w,e,r,t,y set marker at time cursor

Curve point bindings: B1 drag point; C-B1 curve add point; S-B1 sketch points; B1 drag select points

Available in functions: nsin/ncos period=amp=1; within(a,b) bef(x) aft(x) compare to time; smoove(x) cubic smoothstep; chan(name); curvename(t) eval curve</property>

  </object>

  <object class="GtkImage" id="image2">

    <property name="visible">True</property>

from __future__ import division

import math, time, logging

import gtk, goocanvas

import louie as dispatcher

from light9.curvecalc.zoomcontrol import RegionZoom

from light9.curvecalc import cursors

from light9.curvecalc.curve import introPad, postPad

from light9.dmxchanedit import gradient

log = logging.getLogger()

    def new_curve(self, event):

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

        self.newcurvename.set('')

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

        curve = self.curveset.curves[name]

        f = CurveRow(name, curve, self.curveset.markers,

                     slider, knobEnabled, self.zoomControl)

        self.curvesVBox.pack_start(f.box)

        f.box.show_all()

        self.allCurveRows.add(f)

        f.curveView.goLive()

    def row(self, name):

        matches = [r for r in self.allCurveRows if r.name == name]

        if not matches:

        return matches[0]

    def goLive(self):

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

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