def addClient(self, client):

        self.clients.append([client, {}])

        log.info('added client %s', client)

    def delClient(self, client):

        self.clients = [[c, t] for c, t in self.clients if c != client]

        log.info('delClient %s, %s left', client, len(self.clients))

    def outputAttrsSet(self, dev, attrs, outputMap):

        now = time.time()

        msg = self.makeMsg(dev, attrs, outputMap)

        for client, seen in self.clients:

            for m, t in seen.items():

                if t < now - 5:

                    del seen[m]

            if msg in seen:

                continue

            seen[msg] = now

            client.sendMessage(msg)

    def makeMsg(self, dev, attrs, outputMap):

        attrRows = []

        for attr, val in attrs.items():

_zmqClient=None

class TwistedZmqClient(object):

    def __init__(self, service):

        zf = ZmqFactory()

        e = ZmqEndpoint('connect', 'tcp://%s:%s' % (service.host, service.port))

        self.conn = ZmqPushConnection(zf, e)

    def send(self, msg):

        self.conn.push(msg)

def toCollectorJson(client, session, settings):

                       'client': client,

                       'clientSession': session,

                       'sendTime': time.time(),

                  })

def sendToCollectorZmq(msg):

    global _zmqClient

    if _zmqClient is None:

        _zmqClient = TwistedZmqClient(networking.collectorZmq)

    _zmqClient.send(msg)

    return defer.succeed(0)

    song:  { type: String, notify: true }

    zoomInX: { type: Object, notify: true }

    noteUris: { type: Array, notify: true }

    rowIndex: { type: Object, notify: true }

  observers: [

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

    'update(song, rowIndex)'

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

      if (i % ROW_COUNT) == @rowIndex

        notesForThisRow.push(n)

      i++

    updateChildren @, notesForThisRow, (newUri) =>

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

      child.graph = @graph

      child.dia = @dia

      child.uri = newUri

      child.setAdjuster = @setAdjuster

      child.song = @song # could change, but all the notes will be rebuilt

      child.zoomInX = @zoomInX # missing binding; see onZoom

      return child      

  onZoom: ->

    for e in @children

      e.zoomInX = @zoomInX

getCurvePoints = (graph, curve, xOffset) ->

  worldPts = []

  uris = graph.objects(curve, graph.Uri(':point'))

  for pt in uris

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

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

      else

        adj = makeAdjustable()

        @adjs[adjId] = adj

        adj.id = adjId

    @redraw()

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

  updateAllCoords: ->

    @redraw()

  _layoutCenters: ->

    # push Adjustable centers around to avoid overlaps

    # Todo: also don't overlap inlineattr boxes

    # Todo: don't let their connector lines cross each other

    @qt = d3.quadtree([], ((d)->d.e(1)), ((d)->d.e(2)))

    @qt.extent([[0,0], [8000,8000]])

    for _, adj of @adjs

      desired = adj.getSuggestedCenter()

      output = desired

      for tries in [0...2]

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

        if nearest

            toScreenCenter = $V([500,200]).subtract(output).toUnitVector()

            output = output.add(away.x(60).add(toScreenCenter.x(10)))

      if -50 < output.e(1) < 20 # mostly for zoom-left

        output.setElements([

          Math.max(20, output.e(1)),

          output.e(2)])

      adj.centerOffset = output.subtract(adj.getTarget())

      output.adj = adj

      @qt.add(output)

  _drawConnector: (ctr, target) ->

    @ctx.strokeStyle = '#aaa'

    @ctx.lineWidth = 2

    @ctx.beginPath()

    _line(@ctx, ctr, target)

    @ctx.stroke()

  _drawAdjuster: (label, x1, y1, x2, y2) ->

    radius = 8

    @ctx.shadowColor = 'black'

    @ctx.shadowBlur = 15