super(pos)

    epos = @_editorCoordinates()

    newValue = @config.getValueForPos(epos)

    @config.observable(newValue)

  subscribe: (onChange) ->

    log('AdjustableFloatObservable subscribe', @config)

    ko.computed =>

      @config.observable()

      onChange()

class window.AdjustableFloatObject extends Adjustable

  constructor: (@config) ->

    # config also has:

    #   graph

    #   subj

    #   pred

    #   ctx

    #   getTargetPosForValue(value) -> getTarget result for value

    #   getValueForPos

    super()

    @ctor2()

    if not @config.ctx?

      throw new Error("missing ctx")

    @config.graph.runHandler(@_syncValue.bind(@),

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

    @config.getTargetPosForValue(@_getValue())

  subscribe: (onChange) ->

    # only works on one subscription at a time

    throw new Error('multi subscribe not implemented') if @_onChange

    @_onChange = onChange

  continueDrag: (pos) ->

    # pos is vec2 of pixels relative to the drag start

    super(pos)

    newValue = @config.getValueForPos(@_editorCoordinates())

    @config.graph.patchObject(@config.subj, @config.pred,

                              @config.graph.LiteralRoundedFloat(newValue),

                              @config.ctx)

class window.AdjustableFade extends Adjustable

  constructor: (@yForV, @zoomInX, @i0, @i1, @note, offset, ctx) ->

    super()

    @config = {

      getSuggestedTargetOffset: -> offset

      getTarget: @getTarget.bind(@)

      ctx: ctx

    }

    @ctor2()

  getTarget: ->

    mid = @note.midPoint(@i0, @i1)

    $V([@zoomInX(mid.e(1)), @yForV(mid.e(2))])

  _getValue: ->

    @note.midPoint(@i0, @i1).e(1)

  continueDrag: (pos) ->

    # pos is vec2 of pixels relative to the drag start

    super(pos)

    graph = @note.graph

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

    # These don't fire; TimelineEditor calls the handlers for us.

    @addEventListener('mousedown', @onDown.bind(@))

    @addEventListener('mousemove', @onMove.bind(@))

    @addEventListener('mouseup', @onUp.bind(@))

  _mousePos: (ev) ->

    $V([ev.clientX, ev.clientY - @offsetParent.offsetTop])

  onDown: (ev) ->

    if ev.buttons == 1

      start = @_mousePos(ev)

      adj = @_adjAtPoint(start)

      if adj

        ev.stopPropagation()

        @currentDrag = {start: start, adj: adj}

        adj.startDrag()

  onMove: (ev) ->

    pos = @_mousePos(ev)

    if @currentDrag

      @hoveringNear = null

      @currentDrag.cur = pos

      @currentDrag.adj.continueDrag(

        @currentDrag.cur.subtract(@currentDrag.start))

    else

      near = @_adjAtPoint(pos)

      if @hoveringNear != near

        @hoveringNear = near

        @redraw()

  onUp: (ev) ->

    return unless @currentDrag

    @currentDrag.adj.endDrag()

    @currentDrag = null

  _setAdjuster: (adjId, makeAdjustable) ->

    # callers register/unregister the Adjustables they want us to make

    # adjuster elements for. Caller invents adjId.  makeAdjustable is

    # a function returning the Adjustable or it is null to clear any

    # adjusters with this id.

        delete @adjs[adjId]

    @redraw()

    window.debug_adjsCount = Object.keys(@adjs).length

  updateAllCoords: ->

    @redraw()

  _adjAtPoint: (pt) ->

    nearest = @qt.find(pt.e(1), pt.e(2))

    if not nearest? or nearest.distanceFrom(pt) > maxDist

      return null

    return nearest?.adj

  resizeUpdate: (ev) ->

    @$.canvas.width = ev.target.offsetWidth

    @$.canvas.height = ev.target.offsetHeight

    @canvasCenter = $V([@$.canvas.width / 2, @$.canvas.height / 2])

    @redraw()

  _throttledRedraw: () ->

    return unless @ctx?

    console.time('adjs redraw')

    @_layoutCenters()

  onRowChange: ->

    @clearAdjusters()

    @updateSoon()

  redraw: (params) ->

    # no observable or graph deps in here

    @container.removeChildren()

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

    @graphics.interactive = true

    @container.addChild(@graphics)

    if params.hover

      @_traceBorder(params.screenPts, 12, 0x888888)

    if params.selected

      @_traceBorder(params.screenPts, 6, 0xff2900)

    shape = new PIXI.Polygon(params.screenPts)

    @graphics.beginFill(@_noteColor(params.effect), .313)

    @graphics.drawShape(shape)

    @graphics.endFill()

    @_traceBorder(params.screenPts, 2, 0xffd900)

    @_addMouseBindings()

  update: ->

    if not @parentElem.isActiveNote(@uri)

      # stale redraw call

      return

    if @worldPts

      @brickLayout.setNoteSpan(@, @worldPts[0].e(1),

                               @worldPts[@worldPts.length - 1].e(1))

    params = @_planDrawing()

    @worldPts = params.worldPts

    @redraw(params)

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

    @_updateAdjusters(params.screenPts, @worldPts, curveWidthCalc,

                      params.yForV, @viewState.zoomInX, @song)

    @_updateInlineAttrs(params.screenPts, params.yForV)

    @parentElem.noteDirty()

  _traceBorder: (screenPts, thick, color) ->

    @graphics.lineStyle(thick, color, 1)

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