Adding debian version 3.2.1-3.debian/3.2.1-3debian

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

5 files changed, 637 insertions, 0 deletions

diff --git a/debian/missing-sources/epoch/src/time/area.coffee b/debian/missing-sources/epoch/src/time/area.coffee
new file mode 100644
index 0000000..22bf9db
--- /dev/null
+++ b/debian/missing-sources/epoch/src/time/area.coffee
@@ -0,0 +1,80 @@
+
+# Real-time stacked area chart implementation.
+class Epoch.Time.Area extends Epoch.Time.Stack
+  constructor: (@options={}) ->
+    @options.type ?= 'time.area'
+    super(@options)
+    @draw()
+
+  # Sets the appropriate styles to the graphics context given a particular layer.
+  # @param [Object] layer Layer for which to set the styles.
+  setStyles: (layer) ->
+    if layer? && layer.className?
+      styles = @getStyles "g.#{layer.className.replace(/\s/g,'.')} path.area"
+    else
+      styles = @getStyles "g path.area"
+    @ctx.fillStyle = styles.fill
+    if styles.stroke?
+      @ctx.strokeStyle = styles.stroke
+    if styles['stroke-width']?
+      @ctx.lineWidth = styles['stroke-width'].replace('px', '')
+
+  # Draws areas for the chart
+  _drawAreas: (delta=0) ->
+    [y, w, layers] = [@y(), @w(), @getVisibleLayers()]
+
+    for i in [layers.length-1..0]
+      continue unless (layer = layers[i])
+
+      @setStyles layer
+      @ctx.beginPath()
+
+      [j, k, trans] = [@options.windowSize, layer.values.length, @inTransition()]
+      firstX = null
+      while (--j >= -2) and (--k >= 0)
+        entry = layer.values[k]
+        args = [(j+1)*w+delta, y(entry.y + entry.y0)]
+        args[0] += w if trans
+        if i == @options.windowSize - 1
+          @ctx.moveTo.apply @ctx, args
+        else
+          @ctx.lineTo.apply @ctx, args
+
+      if trans
+        borderX = (j+3)*w+delta
+      else
+        borderX = (j+2)*w+delta
+
+      @ctx.lineTo(borderX, @innerHeight())
+      @ctx.lineTo(@width*@pixelRatio+w+delta, @innerHeight())
+      @ctx.closePath()
+      @ctx.fill()
+
+  # Draws strokes for the chart
+  _drawStrokes: (delta=0) ->
+    [y, w, layers] = [@y(), @w(), @getVisibleLayers()]
+
+    for i in [layers.length-1..0]
+      continue unless (layer = layers[i])
+      @setStyles layer
+      @ctx.beginPath()
+
+      [i, k, trans] = [@options.windowSize, layer.values.length, @inTransition()]
+      firstX = null
+      while (--i >= -2) and (--k >= 0)
+        entry = layer.values[k]
+        args = [(i+1)*w+delta, y(entry.y + entry.y0)]
+        args[0] += w if trans
+        if i == @options.windowSize - 1
+          @ctx.moveTo.apply @ctx, args
+        else
+          @ctx.lineTo.apply @ctx, args
+
+      @ctx.stroke()
+
+  # Draws the area chart.
+  draw: (delta=0) ->
+    @clear()
+    @_drawAreas(delta)
+    @_drawStrokes(delta)
+    super()
diff --git a/debian/missing-sources/epoch/src/time/bar.coffee b/debian/missing-sources/epoch/src/time/bar.coffee
new file mode 100644
index 0000000..7bcb7be
--- /dev/null
+++ b/debian/missing-sources/epoch/src/time/bar.coffee
@@ -0,0 +1,48 @@
+
+# Real-time Bar Chart implementation.
+class Epoch.Time.Bar extends Epoch.Time.Stack
+  constructor: (@options={}) ->
+    @options.type ?= 'time.bar'
+    super(@options)
+    @draw()
+
+  # @return [Number] An offset used to align the ticks to the center of the rendered bars.
+  _offsetX: ->
+   0.5 * @w() / @pixelRatio
+
+  # Sets the styles for the graphics context given a layer class name.
+  # @param [String] className The class name to use when deriving the styles.
+  setStyles: (className) ->
+    styles = @getStyles "rect.bar.#{className.replace(/\s/g,'.')}"
+    @ctx.fillStyle = styles.fill
+
+    if !styles.stroke? or styles.stroke == 'none'
+      @ctx.strokeStyle = 'transparent'
+    else
+      @ctx.strokeStyle = styles.stroke
+
+    if styles['stroke-width']?
+      @ctx.lineWidth = styles['stroke-width'].replace('px', '')
+
+  # Draws the stacked bar chart.
+  draw: (delta=0) ->
+    @clear()
+    [y, w] = [@y(), @w()]
+
+    for layer in @getVisibleLayers()
+      continue unless Epoch.isNonEmptyArray(layer.values)
+      @setStyles(layer.className)
+
+      [i, k, trans] = [@options.windowSize, layer.values.length, @inTransition()]
+      iBoundry = if trans then -1 else 0
+
+      while (--i >= iBoundry) and (--k >= 0)
+        entry = layer.values[k]
+        [ex, ey, ey0] = [i*w+delta, entry.y, entry.y0]
+        ex += w if trans
+        args = [ex+1, y(ey+ey0), w-2, @innerHeight()-y(ey)+0.5*@pixelRatio]
+
+        @ctx.fillRect.apply(@ctx, args)
+        @ctx.strokeRect.apply(@ctx, args)
+
+    super()
diff --git a/debian/missing-sources/epoch/src/time/gauge.coffee b/debian/missing-sources/epoch/src/time/gauge.coffee
new file mode 100644
index 0000000..8efadb2
--- /dev/null
+++ b/debian/missing-sources/epoch/src/time/gauge.coffee
@@ -0,0 +1,209 @@
+
+# Real-time Gauge Visualization. Note: Looks best with a 4:3 aspect ratio (w:h)
+class Epoch.Time.Gauge extends Epoch.Chart.Canvas
+  defaults =
+    type: 'time.gauge'
+    domain: [0, 1]
+    ticks: 10
+    tickSize: 5
+    tickOffset: 5
+    fps: 34
+    format: Epoch.Formats.percent
+
+  optionListeners =
+    'option:domain': 'domainChanged'
+    'option:ticks': 'ticksChanged'
+    'option:tickSize': 'tickSizeChanged'
+    'option:tickOffset': 'tickOffsetChanged'
+    'option:format': 'formatChanged'
+
+  # Creates the new gauge chart.
+  # @param [Object] options Options for the gauge chart.
+  # @option options [Array] domain The domain to use when rendering values (default: [0, 1]).
+  # @option options [Integer] ticks Number of ticks to render (default: 10).
+  # @option options [Integer] tickSize The length (in pixels) for each tick (default: 5).
+  # @option options [Integer] tickOffset The number of pixels by which to offset ticks from the outer arc (default: 5).
+  # @option options [Integer] fps The number of animation frames to render per second (default: 34).
+  # @option options [Function] format The formatting function to use when rendering the gauge label
+  #   (default: Epoch.Formats.percent).
+  constructor: (@options={}) ->
+    super(@options = Epoch.Util.defaults(@options, defaults))
+    @value = @options.value or 0
+
+    if @options.model
+      @options.model.on 'data:push', => @pushFromModel()
+
+    # SVG Labels Overlay
+    if @el.style('position') != 'absolute' and @el.style('position') != 'relative'
+      @el.style('position', 'relative')
+
+    @svg = @el.insert('svg', ':first-child')
+      .attr('width', @width)
+      .attr('height', @height)
+      .attr('class', 'gauge-labels')
+
+    @svg.style
+      'position': 'absolute'
+      'z-index': '1'
+
+    @svg.append('g')
+      .attr('transform', "translate(#{@textX()}, #{@textY()})")
+      .append('text')
+        .attr('class', 'value')
+        .text(@options.format(@value))
+
+    # Animations
+    @animation =
+      interval: null
+      active: false
+      delta: 0
+      target: 0
+
+    @_animate = =>
+      if Math.abs(@animation.target - @value) < Math.abs(@animation.delta)
+        @value = @animation.target
+        clearInterval @animation.interval
+        @animation.active = false
+      else
+        @value += @animation.delta
+
+      @svg.select('text.value').text(@options.format(@value))
+      @draw()
+
+    @onAll optionListeners
+    @draw()
+
+  # Sets the value for the gauge to display and begins animating the guage.
+  # @param [Number] value Value to set for the gauge.
+  update: (value) ->
+    @animation.target = value
+    @animation.delta = (value - @value) / @options.fps
+    unless @animation.active
+      @animation.interval = setInterval @_animate, (1000/@options.fps)
+      @animation.active = true
+
+  # Alias for the <code>update()</code> method.
+  # @param [Number] value Value to set for the gauge.
+  push: (value) ->
+    @update value
+
+  # Responds to a model's 'data:push' event.
+  pushFromModel: ->
+    next = @options.model.getNext(@options.type, @options.dataFormat)
+    @update next
+
+  # @return [Number] The radius for the gauge.
+  radius: -> @getHeight() / 1.58
+
+  # @return [Number] The center position x-coordinate for the gauge.
+  centerX: -> @getWidth() / 2
+
+  # @return [Number] The center position y-coordinate for the gauge.
+  centerY: -> 0.68 * @getHeight()
+
+  # @return [Number] The x-coordinate for the gauge text display.
+  textX: -> @width / 2
+
+  # @return [Number] The y-coordinate for the gauge text display.
+  textY: -> 0.48 * @height
+
+  # @return [Number] The angle to set for the needle given a value within the domain.
+  # @param [Number] value Value to translate into a needle angle.
+  getAngle: (value) ->
+    [a, b] = @options.domain
+    ((value - a) / (b - a)) * (Math.PI + 2*Math.PI/8) - Math.PI/2 - Math.PI/8
+
+  # Sets context styles given a particular selector.
+  # @param [String] selector The selector to use when setting the styles.
+  setStyles: (selector) ->
+    styles = @getStyles selector
+    @ctx.fillStyle = styles.fill
+    @ctx.strokeStyle = styles.stroke
+    @ctx.lineWidth = styles['stroke-width'].replace('px', '') if styles['stroke-width']?
+
+  # Draws the gauge.
+  draw: ->
+    [cx, cy, r] = [@centerX(), @centerY(), @radius()]
+    [tickOffset, tickSize] = [@options.tickOffset, @options.tickSize]
+
+    @clear()
+
+    # Draw Ticks
+    t = d3.scale.linear()
+      .domain([0, @options.ticks])
+      .range([ -(9/8)*Math.PI, Math.PI/8 ])
+
+    @setStyles '.epoch .gauge .tick'
+    @ctx.beginPath()
+    for i in [0..@options.ticks]
+      a = t(i)
+      [c, s] = [Math.cos(a), Math.sin(a)]
+
+      x1 = c * (r-tickOffset) + cx
+      y1 = s * (r-tickOffset) + cy
+      x2 = c * (r-tickOffset-tickSize) + cx
+      y2 = s * (r-tickOffset-tickSize) + cy
+
+      @ctx.moveTo x1, y1
+      @ctx.lineTo x2, y2
+
+    @ctx.stroke()
+
+    # Outer arc
+    @setStyles '.epoch .gauge .arc.outer'
+    @ctx.beginPath()
+    @ctx.arc cx, cy, r, -(9/8)*Math.PI, (1/8)*Math.PI, false
+    @ctx.stroke()
+
+    # Inner arc
+    @setStyles '.epoch .gauge .arc.inner'
+    @ctx.beginPath()
+    @ctx.arc cx, cy, r-10, -(9/8)*Math.PI, (1/8)*Math.PI, false
+    @ctx.stroke()
+
+    @drawNeedle()
+
+    super()
+
+  # Draws the needle.
+  drawNeedle: ->
+    [cx, cy, r] = [@centerX(), @centerY(), @radius()]
+    ratio = @value / @options.domain[1]
+
+    @setStyles '.epoch .gauge .needle'
+    @ctx.beginPath()
+    @ctx.save()
+    @ctx.translate cx, cy
+    @ctx.rotate @getAngle(@value)
+
+    @ctx.moveTo 4 * @pixelRatio, 0
+    @ctx.lineTo -4 * @pixelRatio, 0
+    @ctx.lineTo -1 * @pixelRatio, 19-r
+    @ctx.lineTo 1, 19-r
+    @ctx.fill()
+
+    @setStyles '.epoch .gauge .needle-base'
+    @ctx.beginPath()
+    @ctx.arc 0, 0, (@getWidth() / 25), 0, 2*Math.PI
+    @ctx.fill()
+
+    @ctx.restore()
+
+  # Correctly responds to an <code>option:</code>
+  domainChanged: -> @draw()
+
+  # Correctly responds to an <code>option:</code>
+  ticksChanged: -> @draw()
+
+  # Correctly responds to an <code>option:</code>
+  tickSizeChanged: -> @draw()
+
+  # Correctly responds to an <code>option:</code>
+  tickOffsetChanged: -> @draw()
+
+  # Correctly responds to an <code>option:</code>
+  formatChanged: -> @svg.select('text.value').text(@options.format(@value))
+
+
+
+# "The mother of a million sons... CIVILIZATION!" -- Justice
diff --git a/debian/missing-sources/epoch/src/time/heatmap.coffee b/debian/missing-sources/epoch/src/time/heatmap.coffee
new file mode 100644
index 0000000..d7f2c50
--- /dev/null
+++ b/debian/missing-sources/epoch/src/time/heatmap.coffee
@@ -0,0 +1,261 @@
+
+# Real-time Heatmap Implementation.
+class Epoch.Time.Heatmap extends Epoch.Time.Plot
+  defaults =
+    type: 'time.heatmap'
+    buckets: 10
+    bucketRange: [0, 100]
+    opacity: 'linear'
+    bucketPadding: 2
+    paintZeroValues: false
+    cutOutliers: false
+
+  # Easy to use "named" color functions
+  colorFunctions =
+    root: (value, max) -> Math.pow(value/max, 0.5)
+    linear: (value, max) -> value / max
+    quadratic: (value, max) -> Math.pow(value/max, 2)
+    cubic: (value, max) -> Math.pow(value/max, 3)
+    quartic: (value, max) -> Math.pow(value/max, 4)
+    quintic: (value, max) -> Math.pow(value/max, 5)
+
+  optionListeners =
+    'option:buckets': 'bucketsChanged'
+    'option:bucketRange': 'bucketRangeChanged'
+    'option:opacity': 'opacityChanged'
+    'option:bucketPadding': 'bucketPaddingChanged'
+    'option:paintZeroValues': 'paintZeroValuesChanged'
+    'option:cutOutliers': 'cutOutliersChanged'
+
+  # Creates a new heatmap.
+  # @param [Object] options Options for the heatmap.
+  # @option options [Integer] buckets Number of vertical buckets to use when normalizing the
+  #   incoming histogram data for visualization in the heatmap (default: 10).
+  # @option options [Array] bucketRange A range of acceptable values to be bucketed (default: [0, 100]).
+  # @option options [String, Function] opacity The opacity coloring function to use when rendering buckets
+  #   in a column. The built-in functions (referenced by string) are: 'root', 'linear', 'quadratic', 'cubic',
+  #   'quartic', and 'quintic'. A custom function can be supplied given it accepts two parameters (value, max)
+  #   and returns a numeric value from 0 to 1. Default: linear.
+  # @option options [Number] bucketPadding Amount of padding to apply around buckets (default: 2).
+  constructor: (@options={}) ->
+    super(@options = Epoch.Util.defaults(@options, defaults))
+    @_setOpacityFunction()
+    @_setupPaintCanvas()
+    @onAll optionListeners
+    @draw()
+
+  _setOpacityFunction: ->
+    if Epoch.isString(@options.opacity)
+      @_opacityFn = colorFunctions[@options.opacity]
+      Epoch.exception "Unknown coloring function provided '#{@options.opacity}'" unless @_opacityFn?
+    else if Epoch.isFunction(@options.opacity)
+      @_opacityFn = @options.opacity
+    else
+      Epoch.exception "Unknown type for provided coloring function."
+
+  # Prepares initially set data for rendering.
+  # @param [Array] data Layered histogram data for the visualization.
+  setData: (data) ->
+    super(data)
+    for layer in @data
+      layer.values = layer.values.map((entry) => @_prepareEntry(entry))
+
+  # Distributes the full histogram in the entry into the defined buckets
+  # for the visualization.
+  # @param [Object] entry Entry to prepare for visualization.
+  _getBuckets: (entry) ->
+    prepared =
+      time: entry.time
+      max: 0
+      buckets: (0 for i in [0...@options.buckets])
+
+    # Bucket size = (Range[1] - Range[0]) / number of buckets
+    bucketSize = (@options.bucketRange[1] - @options.bucketRange[0]) / @options.buckets
+
+    for own value, count of entry.histogram
+      index = parseInt((value - @options.bucketRange[0]) / bucketSize)
+
+      # Remove outliers from the preprared buckets if instructed to do so
+      if @options.cutOutliers and ((index < 0) or (index >= @options.buckets))
+        continue
+
+      # Bound the histogram to the range (aka, handle out of bounds values)
+      if index < 0
+        index = 0
+      else if index >= @options.buckets
+        index = @options.buckets - 1
+
+      prepared.buckets[index] += parseInt count
+
+    for i in [0...prepared.buckets.length]
+      prepared.max = Math.max(prepared.max, prepared.buckets[i])
+
+    return prepared
+
+  # @return [Function] The y scale for the heatmap.
+  y: ->
+    d3.scale.linear()
+      .domain(@options.bucketRange)
+      .range([@innerHeight(), 0])
+
+  # @return [Function] The y scale for the svg portions of the heatmap.
+  ySvg: ->
+    d3.scale.linear()
+      .domain(@options.bucketRange)
+      .range([@innerHeight() / @pixelRatio, 0])
+
+  # @return [Number] The height to render each bucket in a column (disregards padding).
+  h: ->
+    @innerHeight() / @options.buckets
+
+  # @return [Number] The offset needed to center ticks at the middle of each column.
+  _offsetX: ->
+    0.5 * @w() / @pixelRatio
+
+  # Creates the painting canvas which is used to perform all the actual drawing. The contents
+  # of the canvas are then copied into the actual display canvas and through some image copy
+  # trickery at the end of a transition the illusion of motion over time is preserved.
+  #
+  # Using two canvases in this way allows us to render an incredible number of buckets in the
+  # visualization and animate them at high frame rates without smashing the cpu.
+  _setupPaintCanvas: ->
+    # Size the paint canvas to have a couple extra columns so we can perform smooth transitions
+    @paintWidth = (@options.windowSize + 1) * @w()
+    @paintHeight = @height * @pixelRatio
+
+    # Create the "memory only" canvas and nab the drawing context
+    @paint = document.createElement('CANVAS')
+    @paint.width = @paintWidth
+    @paint.height = @paintHeight
+    @p = Epoch.Util.getContext @paint
+
+    # Paint the initial data (rendering backwards from just before the fixed paint position)
+    @redraw()
+
+    # Hook into the events to paint the next row after it's been shifted into the data
+    @on 'after:shift', '_paintEntry'
+
+    # At the end of a transition we must reset the paint canvas by shifting the viewable
+    # buckets to the left (this allows for a fixed cut point and single renders below in @draw)
+    @on 'transition:end', '_shiftPaintCanvas'
+    @on 'transition:end', => @draw(@animation.frame * @animation.delta())
+
+  # Redraws the entire heatmap for the current data.
+  redraw: ->
+    return unless Epoch.isNonEmptyArray(@data) and Epoch.isNonEmptyArray(@data[0].values)
+    entryIndex = @data[0].values.length
+    drawColumn = @options.windowSize
+
+    # This addresses a strange off-by-one issue when the chart is transitioning
+    drawColumn++ if @inTransition()
+
+    while (--entryIndex >= 0) and (--drawColumn >= 0)
+      @_paintEntry(entryIndex, drawColumn)
+    @draw(@animation.frame * @animation.delta())
+
+  # Computes the correct color for a given bucket.
+  # @param [Integer] value Normalized value at the bucket.
+  # @param [Integer] max Normalized maximum for the column.
+  # @param [String] color Computed base color for the bucket.
+  _computeColor: (value, max, color) ->
+    Epoch.Util.toRGBA(color, @_opacityFn(value, max))
+
+  # Paints a single entry column on the paint canvas at the given column.
+  # @param [Integer] entryIndex Index of the entry to paint.
+  # @param [Integer] drawColumn Column on the paint canvas to place the visualized entry.
+  _paintEntry: (entryIndex=null, drawColumn=null) ->
+    [w, h] = [@w(), @h()]
+
+    entryIndex ?= @data[0].values.length - 1
+    drawColumn ?= @options.windowSize
+
+    entries = []
+    bucketTotals = (0 for i in [0...@options.buckets])
+    maxTotal = 0
+
+    for layer in @getVisibleLayers()
+      entry = @_getBuckets( layer.values[entryIndex] )
+      for own bucket, count of entry.buckets
+        bucketTotals[bucket] += count
+      maxTotal += entry.max
+      styles = @getStyles ".#{layer.className.split(' ').join('.')} rect.bucket"
+      entry.color = styles.fill
+      entries.push entry
+
+    xPos = drawColumn * w
+
+    @p.clearRect xPos, 0, w, @paintHeight
+
+    j = @options.buckets
+
+    for own bucket, sum of bucketTotals
+      color = @_avgLab(entries, bucket)
+      max = 0
+      for entry in entries
+        max += (entry.buckets[bucket] / sum) * maxTotal
+      if sum > 0 or @options.paintZeroValues
+        @p.fillStyle = @_computeColor(sum, max, color)
+        @p.fillRect xPos, (j-1) * h, w-@options.bucketPadding, h-@options.bucketPadding
+      j--
+
+  # This shifts the image contents of the paint canvas to the left by 1 column width.
+  # It is called after a transition has ended (yay, slight of hand).
+  _shiftPaintCanvas: ->
+    data = @p.getImageData @w(), 0, @paintWidth-@w(), @paintHeight
+    @p.putImageData data, 0, 0
+
+  # Performs an averaging of the colors for muli-layer heatmaps using the lab color space.
+  # @param [Array] entries The layers for which the colors are to be averaged.
+  # @param [Number] bucket The bucket in the entries that must be averaged.
+  # @return [String] The css color code for the average of all the layer colors.
+  _avgLab: (entries, bucket) ->
+    [l, a, b, total] = [0, 0, 0, 0]
+    for entry in entries
+      continue unless entry.buckets[bucket]?
+      total += entry.buckets[bucket]
+
+    for own i, entry of entries
+      if entry.buckets[bucket]?
+        value = entry.buckets[bucket]|0
+      else
+        value = 0
+      ratio = value / total
+      color = d3.lab(entry.color)
+      l += ratio * color.l
+      a += ratio * color.a
+      b += ratio * color.b
+
+    d3.lab(l, a, b).toString()
+
+  # Copies the paint canvas onto the display canvas, thus rendering the heatmap.
+  draw: (delta=0) ->
+    @clear()
+    @ctx.drawImage @paint, delta, 0
+    super()
+
+  # Changes the number of buckets in response to an <code>option:buckets</code> event.
+  bucketsChanged: -> @redraw()
+
+  # Changes the range of the buckets in response to an <code>option:bucketRange</code> event.
+  bucketRangeChanged: ->
+    @_transitionRangeAxes()
+    @redraw()
+
+  # Changes the opacity function in response to an <code>option:opacity</code> event.
+  opacityChanged: ->
+    @_setOpacityFunction()
+    @redraw()
+
+  # Changes the bucket padding in response to an <code>option:bucketPadding</code> event.
+  bucketPaddingChanged: -> @redraw()
+
+  # Changes whether or not to paint zeros in response to an <code>option:paintZeroValues</code> event.
+  paintZeroValuesChanged: -> @redraw()
+
+  # Changes whether or not to cut outliers when bucketing in response to an
+  # <code>option:cutOutliers</code> event.
+  cutOutliersChanged: -> @redraw()
+
+  layerChanged: -> @redraw()
+
+# "Audio... Audio... Audio... Video Disco..." - Justice
diff --git a/debian/missing-sources/epoch/src/time/line.coffee b/debian/missing-sources/epoch/src/time/line.coffee
new file mode 100644
index 0000000..8a4271b
--- /dev/null
+++ b/debian/missing-sources/epoch/src/time/line.coffee
@@ -0,0 +1,39 @@
+
+# Real-time line chart implementation
+class Epoch.Time.Line extends Epoch.Time.Plot
+  constructor: (@options={}) ->
+    @options.type ?= 'time.line'
+    super(@options)
+    @draw()
+
+  # Sets the graphics context styles based ont he given layer class name.
+  # @param [String] className The class name of the layer for which to set the styles.
+  setStyles: (className) ->
+    styles = @getStyles "g.#{className.replace(/\s/g,'.')} path.line"
+    @ctx.fillStyle = styles.fill
+    @ctx.strokeStyle = styles.stroke
+    @ctx.lineWidth = @pixelRatio * styles['stroke-width'].replace('px', '')
+
+  # Draws the line chart.
+  draw: (delta=0) ->
+    @clear()
+    w = @w()
+    for layer in @getVisibleLayers()
+      continue unless Epoch.isNonEmptyArray(layer.values)
+      @setStyles(layer.className)
+      @ctx.beginPath()
+      y = @y(layer.range)
+      [i, k, trans] = [@options.windowSize, layer.values.length, @inTransition()]
+
+      while (--i >= -2) and (--k >= 0)
+        entry = layer.values[k]
+        args = [(i+1)*w+delta, y(entry.y)]
+        args[0] += w if trans
+        if i == @options.windowSize - 1
+          @ctx.moveTo.apply @ctx, args
+        else
+          @ctx.lineTo.apply @ctx, args
+
+      @ctx.stroke()
+
+    super()