ec = EditChoice(graph, songChoice, label="Editing song:")

        wtree.get_object("currentSongEditChoice").add(ec)

        ec.show()

        wtree.get_object("subterms").connect("add", self.onSubtermChildAdded)

        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)

        # that's not enough- deeper windows don't accept the

        # event. 

        #mainwin.forall(connect) # not very effective

        wtree.get_object("newSubZone").drag_dest_set(flags=gtk.DEST_DEFAULT_ALL,

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

                            actions=gtk.gdk.ACTION_COPY)

        # 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

        uri = URIRef(data)

        subName = self.graph.label(uri)

        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,

                         sub=URIRef(selection.data.strip()))

    def handleSubtermDrop(self, data):

        params = parse_qsl(data.split('?')[1])

        flattened = dict(params)

        self.makeSubterm(flattened['subtermName'],

    def currentSong(self):

        with self.graph.currentState(

                tripleFilter=(self.session, L9['currentSong'], None)

        ) as current:

            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

            else:

                raise ValueError("can't pick a name for the new subterm")

        ctx = self.songSubtermsContext()

        quads = [

            (uri, RDF.type, L9.Subterm, ctx),

            (uri, RDFS.label, Literal(newname), ctx),

            (self.currentSong(), L9['subterm'], uri, ctx),

            ]

        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 = []

        for st in set(self.graph.objects(song, L9['subterm'])):

            log.debug("song %s has subterm %s", song, st)

            term = Subterm(self.graph, st, self.songSubtermsContext(),

                               self.curveset)

            newList.append(term)

        self.currentSubterms[:] = newList

    def onZoomAll(self, item):

        dispatcher.send("show all")

    def onPlayPause(self, item):

        # since the X coord in a curveview affects the handling, one

        # 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(),

                showconfig.songFilenameFromURI(song)))

            log.info("saved")

    def makeStatusLines(self, master):

        """various labels that listen for dispatcher signals"""

        for row, (signame, textfilter) in enumerate([

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

postPad = 4

class Curve(object):

    """curve does not know its name. see Curveset"""

    def __init__(self):

        self.points = [] # x-sorted list of (x,y)

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

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

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

            self.lastSliderTime = {} # num : time

            self.sliderSuppressOutputUntil = {} # num : time

            self.sliderIgnoreInputUntil = {}

        else:

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

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

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

        self.add_curve(name,c)

    def hw_slider_in(self, num, value):

        try:

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

        except KeyError:

        </child>

      </object>

    </child>

  </object>

  <object class="GtkAccelGroup" id="accelgroup1"/>

  <object class="GtkAdjustment" id="adjustment1">

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

    <property name="can_focus">False</property>

    <property name="stock">gtk-refresh</property>

  </object>

  <object class="GtkListStore" id="liststore1"/>

  <object class="GtkDialog" id="newCurve">

    <property name="can_focus">False</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()

print "curveview.py toplevel"

def vlen(v):

    return math.sqrt(v[0]*v[0] + v[1]*v[1])

def angle_between(base, p0, p1):

    p0 = p0[0] - base[0], p0[1] - base[1]

            if 0 <= inRowX < w and 0 <= inRowY < h:

                return r

        raise ValueError("no curveRow is under the mouse")

    def focus_entry(self):

        self.entry.focus()

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

        for cr in self.allCurveRows:

            cr.curveView.goLive()

    def onDelete(self):

        for r in self.allCurveRows:

            r.onDelete()