getTarget: () => $V([@viewState.fullZoomX(panObs()), yMid()])

      getSuggestedTargetOffset: () => $V([0, 0])

      getValueForPos: valForPos

    }))

)

# plan: in here, turn all the notes into simple js objects with all

# their timing data and whatever's needed for adjusters. From that, do

# the brick layout. update only changing adjusters.

coffeeElementSetup(class TimeZoomed extends Polymer.mixinBehaviors([Polymer.IronResizableBehavior], Polymer.Element)

  @is: 'light9-timeline-time-zoomed'

    song: { type: String, notify: true }

    viewState: { type: Object, notify: true }

    inlineAttrConfigs: { type: Array, value: [] } # only for inlineattrs that should be displayed

  @getter_observers: [

    '_onGraph(graph, setAdjuster, song, viewState, project)',

    'onZoom(viewState)',

  ]

  constructor: ->

    super()

    @numRows = 6

    @noteByUriStr = new Map()

    @stage = new PIXI.Container()

    @dirty()

  _onGraph: (graph, setAdjuster, song, viewState, project)->

    return unless @song # polymer will call again

    @graph.runHandler(@gatherNotes.bind(@), 'zoom notes')

  noteDirty: -> @dirty()

  onZoom: ->

    updateZoomFlattened = ->

      log('updateZoomFlattened')

      @zoomFlattened = ko.toJS(@viewState.zoomSpec)

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

    return unless @song?

    songNotes = @graph.objects(U(@song), U(':note'))

    toRemove = new Set(@noteByUriStr.keys())

    for uri in _.sortBy(songNotes, 'id')

      had = toRemove.delete(uri.value)

      if not had

    toRemove.forEach @_delNote.bind(@)

    @dirty()

  isActiveNote: (note) -> @noteByUriStr.has(note.value)

    @bg.removeChildren()

    gfx = new PIXI.Graphics()

    @bg.addChild(gfx)

    gfx.lineStyle(1, 0x222222, 1)

    for row in [0...@numRows]

      gfx.moveTo(0, y)

      gfx.lineTo(@clientWidth, y)

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

    con = new PIXI.Container()

    con.interactive=true

    @stage.addChild(con)

    # this must come before the first Note.draw

    @noteByUriStr.set(uri.value, note)

    note.initWatchers()

  _delNote: (uriStr) ->

    n = @noteByUriStr.get(uriStr)

    @stage.removeChild(n.container)

    n.destroy()

    @noteByUriStr.delete(uriStr)

  onDrop: (effect, pos) ->

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

          return

        index += 1

      @push('inlineAttrConfigs', config)

)

coffeeElementSetup(class TimeAxis extends Polymer.Element

  @is: "light9-timeline-time-axis",

  @getter_properties:

    viewState: { type: Object, notify: true, observer: "onViewState" }

  onViewState: ->

    ko.computed =>

)

# Maintains a pixi object, some adjusters, and inlineattrs corresponding to a note

# in the graph.

class Note

    @adjusterIds = new Set() # id string

  initWatchers: ->

  destroy: ->

    log('destroy', @uri.value)

    @isDetached = true

    @clearAdjusters()

    @parentElem.updateInlineAttrs(@uri, null)

  midPoint: (i0, i1) ->

    p0 = @worldPts[i0]

    p1 = @worldPts[i1]

    p0.x(.5).add(p1.x(.5))

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

    effect = @graph.uriValue(@uri, U(':effectClass'))

    @container.removeChildren()

    @graphics = new PIXI.Graphics({nativeLines: false})

    @graphics.interactive = true

    @container.addChild(@graphics)

    if @uri.equals(@selection.hover())

    @selection.selected().forEach (s) =>

      if s.equals(@uri)

    @graphics.drawShape(shape)

    @graphics.endFill()

    @_addMouseBindings()

    curveWidthCalc = () => @project.curveWidth(@worldPts)

    @parentElem.noteDirty()

  _traceBorder: (screenPts, thick, color) ->

    @graphics.lineStyle(thick, color, 1)

    @graphics.moveTo(screenPts[0].x, screenPts[0].y)

    for p in screenPts.slice(1)

        if (add.predicate.equals(del.predicate) and del.predicate.equals(@graph.Uri(':time')) and add.subject.equals(del.subject))

          timeEditFor = add.subject

          if @worldPts and timeEditFor not in @pointUris

            return false

    return true

    # update our note DOM and SVG elements based on the graph

    if not @patchCouldAffectMe(patch)

      # as autodep still fires all handlers on all patches, we just

      # need any single dep to cause another callback. (without this,

      # we would no longer be registered at all)

      @graph.subjects(@uri, @uri, @uri)

      @clearAdjusters()

    else

      @_makeOffsetAdjuster(yForV, curveWidthCalc, ctx)

      @_makeCurvePointAdjusters(yForV, worldPts, ctx)

      @_makeFadeAdjusters(yForV, zoomInX, ctx, worldPts)

    w = 280

    leftX = Math.max(2, screenPts[Math.min(1, screenPts.length - 1)].x + 5)

    rightX = screenPts[Math.min(2, screenPts.length - 1)].x - 5

    if screenPts.length < 3

      rightX = leftX + w

      @parentElem.updateInlineAttrs(@uri, null)

      return

    config = {

      uri: @uri,

      left: leftX,

      width: w,

      }

    @parentElem.updateInlineAttrs(@uri, config)

  _makeCurvePointAdjusters: (yForV, worldPts, ctx) ->

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