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

    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.

  # 

  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

    #   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

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

  _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