if not label?

      throw new Error("missing label")

    h = new Handler(func, label)

    tailChildren = @handlerStack[@handlerStack.length - 1].innerHandlers

    matchingLabel = _.filter(tailChildren, ((c) -> c.label == label)).length

    # ohno, something depends on some handlers getting run twice :(

    if matchingLabel < 2

      tailChildren.push(h)

    console.time("handler #{label}")

    @_rerunHandler(h, null)

    console.timeEnd("handler #{label}")

  _rerunHandler: (handler, patch) ->

    handler.patterns = []

    @handlerStack.push(handler)

    try

      handler.func(patch)

    catch e

      log('error running handler: ', e)

      # assuming here it didn't get to do all its queries, we could

      # add a *,*,*,* handler to call for sure the next time?

    finally

      #log('done. got: ', handler.patterns)

    if not child.patterns.length

      return false

    for stmt in child.patterns

      if _.contains(allPatchSubjs, stmt[0])

        return true

    return false

  graphChanged: (patch) ->

    # SyncedGraph is telling us this patch just got applied to the graph.

    rerunInners = (cur) =>

      toRun = cur.innerHandlers.slice()

      for child in toRun

        #child.innerHandlers = [] # let all children get called again

        @_rerunHandler(child, patch)

        rerunInners(child)

    rerunInners(@handlers)

  askedFor: (s, p, o, g) ->

    # SyncedGraph is telling us someone did a query that depended on

    # quads in the given pattern.

    current = @handlerStack[@handlerStack.length - 1]

    if current? and current != @handlers

      current.patterns.push([s, p, o, g])

      #log('push', s,p,o,g)

class window.SyncedGraph

  # Main graph object for a browser to use. Syncs both ways with

  # rdfdb. Meant to hide the choice of RDF lib, so we can change it

  # later.

  # 

  # Note that _applyPatch is the only method to write to the graph, so

  # it can fire subscriptions.

  constructor: (@patchSenderUrl, @prefixes, @setStatus) ->

    # patchSenderUrl is the /syncedGraph path of an rdfdb server.

    # prefixes can be used in Uri(curie) calls.

                    @_applyPatch(patch)

                    @_addPrefixes(prefixes)

                    cb() if cb

  quads: () -> # for debugging

    [q.subject, q.predicate, q.object, q.graph] for q in @graph.find()

  applyAndSendPatch: (patch) ->

    console.time('applyAndSendPatch')

    if !Array.isArray(patch.addQuads) || !Array.isArray(patch.delQuads)

      throw new Error("corrupt patch: #{JSON.stringify(patch)}")

    for qs in [patch.addQuads, patch.delQuads]

      for q in qs

        if not q.graph?

          throw new Error("corrupt patch: #{JSON.stringify(q)}")

  _applyPatch: (patch) ->

    # In most cases you want applyAndSendPatch.

    # 

    # This is the only method that writes to @graph!

    @cachedFloatValues.clear()

    for quad in patch.delQuads

      @graph.removeTriple(quad)

    for quad in patch.addQuads

      @graph.addTriple(quad)

    #log('applied patch locally', patchSizeSummary(patch))

    @_autoDeps.graphChanged(patch)

class window.AdjustableFloatObject extends Adjustable

  constructor: (@config) ->

    # config also has:

    #   graph

    #   subj

    #   pred

    #   ctx

    #   getTargetPosForValue(value) -> getTarget result for value

    #   getValueForPos

    super(@config)

    @config.graph.runHandler(@_syncValue.bind(@), "adj sync #{@config.subj}")

  _syncValue: () ->

    @_currentValue = @config.graph.floatValue(@config.subj, @config.pred)

    @_onChange() if @_onChange

  _getValue: () ->

    # this is a big speedup- callers use _getValue about 4x as much as

    # the graph changes and graph.floatValue is slow

    @_currentValue

  getTarget: () ->

  is: 'light9-timeline-graph-row'

  behaviors: [ Polymer.IronResizableBehavior ]

  properties:

    graph: { type: Object, notify: true }

    dia: { type: Object, notify: true }

    song:  { type: String, notify: true }

    zoomInX: { type: Object, notify: true }

    noteUris: { type: Array, notify: true }

    rowIndex: { type: Object, notify: true }

    selection: { type: Object, notify: true }

  observers: [

    'onGraph(graph, dia, setAdjuster, song, zoomInX)'

    'onZoom(zoomInX)'

    ]

  onGraph: ->

    @graph.runHandler(@update.bind(@), "row notes #{@rowIndex}")

  update: (patch) ->

    U = (x) => @graph.Uri(x)

    notesForThisRow = []

    i = 0

    for n in _.sortBy(@graph.objects(@song, U(':note')), 'uri')

      if (i % ROW_COUNT) == @rowIndex

        notesForThisRow.push(n)

      i++

    updateChildren @, notesForThisRow, (newUri) =>

      child = document.createElement('light9-timeline-note')

      v = $V([xOffset + @graph.floatValue(pt, @graph.Uri(':time')),

              @graph.floatValue(pt, @graph.Uri(':value'))])

      v.uri = pt

      worldPts.push(v)

    worldPts.sort((a,b) -> a.e(1) > b.e(1))

    return [uris, worldPts]

  _curveWidth: (worldPts) ->

    tMin = @graph.floatValue(worldPts[0].uri, @graph.Uri(':time'))

    tMax = @graph.floatValue(worldPts[3].uri, @graph.Uri(':time'))

    tMax - tMin

    for pointNum in [0...worldPts.length]

  _makePointAdjuster: (yForV, worldPts, pointNum, ctx) ->

    U = (x) => @graph.Uri(x)

    adjId = @uri + '/p' + pointNum

    @adjusterIds[adjId] = true

    @setAdjuster adjId, =>

      adj = new AdjustableFloatObject({

        graph: @graph

        subj: worldPts[pointNum].uri

        pred: U(':time')

        ctx: ctx