dataType: dataType

      showColorPicker: dataType.equals(U(':color'))

      attrClasses: if @selectedAttrs.has(devAttr.value) then 'selected' else ''

      }

    if dataType.equals(U(':color'))

      daRow.useColor = true

    else if dataType.equals(U(':choice'))

      daRow.useChoice = true

      choiceUris = @graph.sortedUris(@graph.objects(devAttr, U(':choice')))

      daRow.choices = ({uri: x.value, label: @graph.labelOrTail(x)} for x in choiceUris)

      daRow.choiceSize = Math.min(choiceUris.length + 1, 10)

    else

      daRow.useSlider = true

      daRow.max = 1

      if dataType.equals(U(':angle'))

        # varies

        daRow.max = 1

    return daRow

  clear: ->

    for lc in @shadowRoot.querySelectorAll("light9-live-control")

      lc.clear()

  onClick: (ev) ->

    log('click', @uri)

    # select, etc

  onAttrClick: (ev) ->

    log('attr click', @uri, ev.model.dattr.uri)

    # select

)

class ActiveSettings

  constructor: (@graph) ->

    # The settings we're showing (or would like to but the widget

    # isn't registered yet):

    # dev+attr : {setting: Uri, onChangeFunc: f, jsValue: str_or_float}

    @settings = new Map()

    @keyForSetting = new Map() # setting uri str -> dev+attr

    # Registered graphValueChanged funcs, by dev+attr. Kept even when

    # settings are deleted.

    @onChanged = new Map()

  addSettingsRow: (device, deviceAttr, setting, value) ->

    key = device.value + " " + deviceAttr.value

    if @settings.has(key)

      throw new Error("repeated setting on "+key)

    if @keyForSetting.has(setting.value)

      throw new Error("repeated keyForSetting on "+setting.value)

    @settings.set(key, {

      setting: setting,

      onChangeFunc: @onChanged[key],

      jsValue: value

    })

    @keyForSetting.set(setting.value, key)

    if @onChanged[key]?

      @onChanged[key](value)

  has: (setting) ->

    @keyForSetting.has(setting.value)

  setValue: (setting, value) ->

    row = @settings.get(@keyForSetting.get(setting.value))

    row.jsValue = value

    row.onChangeFunc(value) if row.onChangeFunc?

  registerWidget: (device, deviceAttr, graphValueChanged) ->

    key = device.value + " " + deviceAttr.value

    @onChanged[key] = graphValueChanged

    if @settings.has(key)

      row = @settings.get(key)

      row.onChangeFunc = graphValueChanged

      row.onChangeFunc(row.jsValue)

  effectSettingLookup: (device, attr) ->

    key = device.value + " " + attr.value

    if @settings.has(key)

      return @settings.get(key).setting

    return null

  deleteSetting: (setting) ->

    log('deleteSetting ' + setting.value)

    key = @keyForSetting.get(setting.value)

    row = @settings.get(key)

    if row? and not row.setting.equals(setting)

      throw new Error('corrupt row for ' + setting.value)

    row.onChangeFunc(null) if row?.onChangeFunc?

    @settings.delete(key)

    @keyForSetting.delete(setting)

  clear: ->

    new Map(@settings).forEach (row, key) ->

    @settings.clear()

    @keyForSetting.clear()

  forAll: (cb) ->

    all = Array.from(@keyForSetting.keys())

    for s in all

      cb(@graph.Uri(s))

  allSettingsStr: ->

    @keyForSetting.keys()

class GraphToControls

  # More efficient bridge between liveControl widgets and graph edits,

  # as opposed to letting each widget scan the graph and push lots of

  # tiny patches to it.

  constructor: (@graph) ->

    @activeSettings = new ActiveSettings(@graph)

    @effect = null

  ctxForEffect: (effect) ->

    @graph.Uri(effect.value.replace(

      "light9.bigasterisk.com/effect",

      "light9.bigasterisk.com/show/dance2018/effect"))

  setEffect: (effect) ->

    @clearSettings()

    @effect = effect

    @ctx = @ctxForEffect(@effect)

    # are these going to pile up? consider @graph.triggerHandler('GTC sync')

    @graph.runHandler(@syncFromGraph.bind(@), 'GraphToControls sync')

  newEffect: ->

    # wrong- this should be our editor's scratch effect, promoted to a

    # real one when you name it.

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

    effect = @graph.nextNumberedResource(U('http://light9.bigasterisk.com/effect/effect'))

    ctx = @ctxForEffect(effect)

    quad = (s, p, o) => @graph.Quad(s, p, o, ctx)

    addQuads = [

      quad(effect, U('rdf:type'), U(':Effect'))

      quad(effect, U('rdfs:label'), @graph.Literal(effect.value.replace(/.*\//, "")))

      quad(effect, U(':publishAttr'), U(':strength'))

    ]

    patch = {addQuads: addQuads, delQuads: []}

    log('init new effect', patch)

    @graph.applyAndSendPatch(patch)

    return effect

  syncFromGraph: ->

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

    return if not @effect

    toClear = new Set(@activeSettings.allSettingsStr())

    for setting in @graph.objects(@effect, U(':setting'))

      dev = @graph.uriValue(setting, U(':device'))

      devAttr = @graph.uriValue(setting, U(':deviceAttr'))

      pred = valuePred(@graph, devAttr)

      try

        value = @graph.uriValue(setting, pred)

        if not value.id.match(/^http/)

          throw new Error("not uri")

      catch

        try

          value = @graph.floatValue(setting, pred)

        catch

          value = @graph.stringValue(setting, pred)

      log('change: graph contains', devAttr, value)

      if @activeSettings.has(setting)

        @activeSettings.setValue(setting, value)

        toClear.delete(setting.value)

      else

        @activeSettings.addSettingsRow(dev, devAttr, setting, value)

    for settingStr in Array.from(toClear)

      @activeSettings.deleteSetting(U(settingStr))

  clearSettings: ->

    @activeSettings.clear()

  register: (device, deviceAttr, graphValueChanged) ->

    @activeSettings.registerWidget(device, deviceAttr, graphValueChanged)

  shouldBeStored: (deviceAttr, value) ->

    # this is a bug for zoom=0, since collector will default it to

    # stick at the last setting if we don't explicitly send the

    # 0. rx/ry similar though not the exact same deal because of

    # their remap.

    return value? and value != 0 and value != '#000000'

  emptyEffect: ->

    @activeSettings.forAll(@_removeEffectSetting.bind(@))