wiki 0.0.1

data/lib/wiki/views/client/js/d3/d3.behavior.js

@@ -0,0 +1,198 @@
+(function(){d3.behavior = {};
+// TODO unbind zoom behavior?
+// TODO unbind listener?
+d3.behavior.zoom = function() {
+  var xyz = [0, 0, 0],
+      event = d3.dispatch("zoom");
+
+  function zoom() {
+    this
+        .on("mousedown.zoom", mousedown)
+        .on("mousewheel.zoom", mousewheel)
+        .on("DOMMouseScroll.zoom", dblclick)
+        .on("dblclick.zoom", dblclick)
+        .on("touchstart.zoom", touchstart);
+
+    d3.select(window)
+        .on("mousemove.zoom", d3_behavior_zoomMousemove)
+        .on("mouseup.zoom", d3_behavior_zoomMouseup)
+        .on("touchmove.zoom", d3_behavior_zoomTouchmove)
+        .on("touchend.zoom", d3_behavior_zoomTouchup);
+  }
+
+  // snapshot the local context for subsequent dispatch
+  function start() {
+    d3_behavior_zoomXyz = xyz;
+    d3_behavior_zoomDispatch = event.zoom.dispatch;
+    d3_behavior_zoomTarget = this;
+    d3_behavior_zoomArguments = arguments;
+  }
+
+  function mousedown() {
+    start.apply(this, arguments);
+    d3_behavior_zoomPanning = d3_behavior_zoomLocation(d3.svg.mouse(d3_behavior_zoomTarget));
+    d3.event.preventDefault();
+    window.focus();
+  }
+
+  // store starting mouse location
+  function mousewheel() {
+    start.apply(this, arguments);
+    if (!d3_behavior_zoomZooming) d3_behavior_zoomZooming = d3_behavior_zoomLocation(d3.svg.mouse(d3_behavior_zoomTarget));
+    d3_behavior_zoomTo(d3_behavior_zoomDelta() + xyz[2], d3.svg.mouse(d3_behavior_zoomTarget), d3_behavior_zoomZooming);
+  }
+
+  function dblclick() {
+    start.apply(this, arguments);
+    var mouse = d3.svg.mouse(d3_behavior_zoomTarget);
+    d3_behavior_zoomTo(d3.event.shiftKey ? Math.ceil(xyz[2] - 1) : Math.floor(xyz[2] + 1), mouse, d3_behavior_zoomLocation(mouse));
+  }
+
+  // doubletap detection
+  function touchstart() {
+    start.apply(this, arguments);
+    var touches = d3_behavior_zoomTouchup(),
+        touch,
+        now = Date.now();
+    if ((touches.length === 1) && (now - d3_behavior_zoomLast < 300)) {
+      d3_behavior_zoomTo(1 + Math.floor(xyz[2]), touch = touches[0], d3_behavior_zoomLocations[touch.identifier]);
+    }
+    d3_behavior_zoomLast = now;
+  }
+
+  zoom.on = function(type, listener) {
+    event[type].add(listener);
+    return zoom;
+  };
+
+  return zoom;
+};
+
+var d3_behavior_zoomDiv,
+    d3_behavior_zoomPanning,
+    d3_behavior_zoomZooming,
+    d3_behavior_zoomLocations = {}, // identifier -> location
+    d3_behavior_zoomLast = 0,
+    d3_behavior_zoomXyz,
+    d3_behavior_zoomDispatch,
+    d3_behavior_zoomTarget,
+    d3_behavior_zoomArguments;
+
+function d3_behavior_zoomLocation(point) {
+  return [
+    point[0] - d3_behavior_zoomXyz[0],
+    point[1] - d3_behavior_zoomXyz[1],
+    d3_behavior_zoomXyz[2]
+  ];
+}
+
+// detect the pixels that would be scrolled by this wheel event
+function d3_behavior_zoomDelta() {
+
+  // mousewheel events are totally broken!
+  // https://bugs.webkit.org/show_bug.cgi?id=40441
+  // not only that, but Chrome and Safari differ in re. to acceleration!
+  if (!d3_behavior_zoomDiv) {
+    d3_behavior_zoomDiv = d3.select("body").append("div")
+        .style("visibility", "hidden")
+        .style("top", 0)
+        .style("height", 0)
+        .style("width", 0)
+        .style("overflow-y", "scroll")
+      .append("div")
+        .style("height", "2000px")
+      .node().parentNode;
+  }
+
+  var e = d3.event, delta;
+  try {
+    d3_behavior_zoomDiv.scrollTop = 1000;
+    d3_behavior_zoomDiv.dispatchEvent(e);
+    delta = 1000 - d3_behavior_zoomDiv.scrollTop;
+  } catch (error) {
+    delta = e.wheelDelta || -e.detail;
+  }
+
+  return delta * .005;
+}
+
+// Note: Since we don't rotate, it's possible for the touches to become
+// slightly detached from their original positions. Thus, we recompute the
+// touch points on touchend as well as touchstart!
+function d3_behavior_zoomTouchup() {
+  var touches = d3.svg.touches(d3_behavior_zoomTarget),
+      i = -1,
+      n = touches.length,
+      touch;
+  while (++i < n) d3_behavior_zoomLocations[(touch = touches[i]).identifier] = d3_behavior_zoomLocation(touch);
+  return touches;
+}
+
+function d3_behavior_zoomTouchmove() {
+  var touches = d3.svg.touches(d3_behavior_zoomTarget);
+  switch (touches.length) {
+
+    // single-touch pan
+    case 1: {
+      var touch = touches[0];
+      d3_behavior_zoomTo(d3_behavior_zoomXyz[2], touch, d3_behavior_zoomLocations[touch.identifier]);
+      break;
+    }
+
+    // double-touch pan + zoom
+    case 2: {
+      var p0 = touches[0],
+          p1 = touches[1],
+          p2 = [(p0[0] + p1[0]) / 2, (p0[1] + p1[1]) / 2],
+          l0 = d3_behavior_zoomLocations[p0.identifier],
+          l1 = d3_behavior_zoomLocations[p1.identifier],
+          l2 = [(l0[0] + l1[0]) / 2, (l0[1] + l1[1]) / 2, l0[2]];
+      d3_behavior_zoomTo(Math.log(d3.event.scale) / Math.LN2 + l0[2], p2, l2);
+      break;
+    }
+  }
+}
+
+function d3_behavior_zoomMousemove() {
+  d3_behavior_zoomZooming = null;
+  if (d3_behavior_zoomPanning) d3_behavior_zoomTo(d3_behavior_zoomXyz[2], d3.svg.mouse(d3_behavior_zoomTarget), d3_behavior_zoomPanning);
+}
+
+function d3_behavior_zoomMouseup() {
+  if (d3_behavior_zoomPanning) {
+    d3_behavior_zoomMousemove();
+    d3_behavior_zoomPanning = null;
+  }
+}
+
+function d3_behavior_zoomTo(z, x0, x1) {
+  var K = Math.pow(2, (d3_behavior_zoomXyz[2] = z) - x1[2]),
+      x = d3_behavior_zoomXyz[0] = x0[0] - K * x1[0],
+      y = d3_behavior_zoomXyz[1] = x0[1] - K * x1[1],
+      o = d3.event, // Events can be reentrant (e.g., focus).
+      k = Math.pow(2, z);
+
+  d3.event = {
+    scale: k,
+    translate: [x, y],
+    transform: function(sx, sy) {
+      if (sx) transform(sx, x);
+      if (sy) transform(sy, y);
+    }
+  };
+
+  function transform(scale, o) {
+    var domain = scale.__domain || (scale.__domain = scale.domain()),
+        range = scale.range().map(function(v) { return (v - o) / k; });
+    scale.domain(domain).domain(range.map(scale.invert));
+  }
+
+  try {
+    d3_behavior_zoomDispatch.apply(d3_behavior_zoomTarget, d3_behavior_zoomArguments);
+  } finally {
+    d3.event = o;
+  }
+
+  o.preventDefault();
+}
+})();

data/lib/wiki/views/client/js/d3/d3.chart.js

@@ -0,0 +1,984 @@
+(function(){d3.chart = {};
+// Inspired by http://informationandvisualization.de/blog/box-plot
+d3.chart.box = function() {
+  var width = 1,
+      height = 1,
+      duration = 0,
+      domain = null,
+      value = Number,
+      whiskers = d3_chart_boxWhiskers,
+      quartiles = d3_chart_boxQuartiles,
+      tickFormat = null;
+
+  // For each small multiple…
+  function box(g) {
+    g.each(function(d, i) {
+      d = d.map(value).sort(d3.ascending);
+      var g = d3.select(this),
+          n = d.length,
+          min = d[0],
+          max = d[n - 1];
+
+      // Compute quartiles. Must return exactly 3 elements.
+      var quartileData = d.quartiles = quartiles(d);
+
+      // Compute whiskers. Must return exactly 2 elements, or null.
+      var whiskerIndices = whiskers && whiskers.call(this, d, i),
+          whiskerData = whiskerIndices && whiskerIndices.map(function(i) { return d[i]; });
+
+      // Compute outliers. If no whiskers are specified, all data are "outliers".
+      // We compute the outliers as indices, so that we can join across transitions!
+      var outlierIndices = whiskerIndices
+          ? d3.range(0, whiskerIndices[0]).concat(d3.range(whiskerIndices[1] + 1, n))
+          : d3.range(n);
+
+      // Compute the new x-scale.
+      var x1 = d3.scale.linear()
+          .domain(domain && domain.call(this, d, i) || [min, max])
+          .range([height, 0]);
+
+      // Retrieve the old x-scale, if this is an update.
+      var x0 = this.__chart__ || d3.scale.linear()
+          .domain([0, Infinity])
+          .range(x1.range());
+
+      // Stash the new scale.
+      this.__chart__ = x1;
+
+      // Note: the box, median, and box tick elements are fixed in number,
+      // so we only have to handle enter and update. In contrast, the outliers
+      // and other elements are variable, so we need to exit them! Variable
+      // elements also fade in and out.
+
+      // Update center line: the vertical line spanning the whiskers.
+      var center = g.selectAll("line.center")
+          .data(whiskerData ? [whiskerData] : []);
+
+      center.enter().insert("svg:line", "rect")
+          .attr("class", "center")
+          .attr("x1", width / 2)
+          .attr("y1", function(d) { return x0(d[0]); })
+          .attr("x2", width / 2)
+          .attr("y2", function(d) { return x0(d[1]); })
+          .style("opacity", 1e-6)
+        .transition()
+          .duration(duration)
+          .style("opacity", 1)
+          .attr("y1", function(d) { return x1(d[0]); })
+          .attr("y2", function(d) { return x1(d[1]); });
+
+      center.transition()
+          .duration(duration)
+          .style("opacity", 1)
+          .attr("y1", function(d) { return x1(d[0]); })
+          .attr("y2", function(d) { return x1(d[1]); });
+
+      center.exit().transition()
+          .duration(duration)
+          .style("opacity", 1e-6)
+          .attr("y1", function(d) { return x1(d[0]); })
+          .attr("y2", function(d) { return x1(d[1]); })
+          .remove();
+
+      // Update innerquartile box.
+      var box = g.selectAll("rect.box")
+          .data([quartileData]);
+
+      box.enter().append("svg:rect")
+          .attr("class", "box")
+          .attr("x", 0)
+          .attr("y", function(d) { return x0(d[2]); })
+          .attr("width", width)
+          .attr("height", function(d) { return x0(d[0]) - x0(d[2]); })
+        .transition()
+          .duration(duration)
+          .attr("y", function(d) { return x1(d[2]); })
+          .attr("height", function(d) { return x1(d[0]) - x1(d[2]); });
+
+      box.transition()
+          .duration(duration)
+          .attr("y", function(d) { return x1(d[2]); })
+          .attr("height", function(d) { return x1(d[0]) - x1(d[2]); });
+
+      // Update median line.
+      var medianLine = g.selectAll("line.median")
+          .data([quartileData[1]]);
+
+      medianLine.enter().append("svg:line")
+          .attr("class", "median")
+          .attr("x1", 0)
+          .attr("y1", x0)
+          .attr("x2", width)
+          .attr("y2", x0)
+        .transition()
+          .duration(duration)
+          .attr("y1", x1)
+          .attr("y2", x1);
+
+      medianLine.transition()
+          .duration(duration)
+          .attr("y1", x1)
+          .attr("y2", x1);
+
+      // Update whiskers.
+      var whisker = g.selectAll("line.whisker")
+          .data(whiskerData || []);
+
+      whisker.enter().insert("svg:line", "circle, text")
+          .attr("class", "whisker")
+          .attr("x1", 0)
+          .attr("y1", x0)
+          .attr("x2", width)
+          .attr("y2", x0)
+          .style("opacity", 1e-6)
+        .transition()
+          .duration(duration)
+          .attr("y1", x1)
+          .attr("y2", x1)
+          .style("opacity", 1);
+
+      whisker.transition()
+          .duration(duration)
+          .attr("y1", x1)
+          .attr("y2", x1)
+          .style("opacity", 1);
+
+      whisker.exit().transition()
+          .duration(duration)
+          .attr("y1", x1)
+          .attr("y2", x1)
+          .style("opacity", 1e-6)
+          .remove();
+
+      // Update outliers.
+      var outlier = g.selectAll("circle.outlier")
+          .data(outlierIndices, Number);
+
+      outlier.enter().insert("svg:circle", "text")
+          .attr("class", "outlier")
+          .attr("r", 5)
+          .attr("cx", width / 2)
+          .attr("cy", function(i) { return x0(d[i]); })
+          .style("opacity", 1e-6)
+        .transition()
+          .duration(duration)
+          .attr("cy", function(i) { return x1(d[i]); })
+          .style("opacity", 1);
+
+      outlier.transition()
+          .duration(duration)
+          .attr("cy", function(i) { return x1(d[i]); })
+          .style("opacity", 1);
+
+      outlier.exit().transition()
+          .duration(duration)
+          .attr("cy", function(i) { return x1(d[i]); })
+          .style("opacity", 1e-6)
+          .remove();
+
+      // Compute the tick format.
+      var format = tickFormat || x1.tickFormat(8);
+
+      // Update box ticks.
+      var boxTick = g.selectAll("text.box")
+          .data(quartileData);
+
+      boxTick.enter().append("svg:text")
+          .attr("class", "box")
+          .attr("dy", ".3em")
+          .attr("dx", function(d, i) { return i & 1 ? 6 : -6 })
+          .attr("x", function(d, i) { return i & 1 ? width : 0 })
+          .attr("y", x0)
+          .attr("text-anchor", function(d, i) { return i & 1 ? "start" : "end"; })
+          .text(format)
+        .transition()
+          .duration(duration)
+          .attr("y", x1);
+
+      boxTick.transition()
+          .duration(duration)
+          .text(format)
+          .attr("y", x1);
+
+      // Update whisker ticks. These are handled separately from the box
+      // ticks because they may or may not exist, and we want don't want
+      // to join box ticks pre-transition with whisker ticks post-.
+      var whiskerTick = g.selectAll("text.whisker")
+          .data(whiskerData || []);
+
+      whiskerTick.enter().append("svg:text")
+          .attr("class", "whisker")
+          .attr("dy", ".3em")
+          .attr("dx", 6)
+          .attr("x", width)
+          .attr("y", x0)
+          .text(format)
+          .style("opacity", 1e-6)
+        .transition()
+          .duration(duration)
+          .attr("y", x1)
+          .style("opacity", 1);
+
+      whiskerTick.transition()
+          .duration(duration)
+          .text(format)
+          .attr("y", x1)
+          .style("opacity", 1);
+
+      whiskerTick.exit().transition()
+          .duration(duration)
+          .attr("y", x1)
+          .style("opacity", 1e-6)
+          .remove();
+    });
+    d3.timer.flush();
+  }
+
+  box.width = function(x) {
+    if (!arguments.length) return width;
+    width = x;
+    return box;
+  };
+
+  box.height = function(x) {
+    if (!arguments.length) return height;
+    height = x;
+    return box;
+  };
+
+  box.tickFormat = function(x) {
+    if (!arguments.length) return tickFormat;
+    tickFormat = x;
+    return box;
+  };
+
+  box.duration = function(x) {
+    if (!arguments.length) return duration;
+    duration = x;
+    return box;
+  };
+
+  box.domain = function(x) {
+    if (!arguments.length) return domain;
+    domain = x == null ? x : d3.functor(x);
+    return box;
+  };
+
+  box.value = function(x) {
+    if (!arguments.length) return value;
+    value = x;
+    return box;
+  };
+
+  box.whiskers = function(x) {
+    if (!arguments.length) return whiskers;
+    whiskers = x;
+    return box;
+  };
+
+  box.quartiles = function(x) {
+    if (!arguments.length) return quartiles;
+    quartiles = x;
+    return box;
+  };
+
+  return box;
+};
+
+function d3_chart_boxWhiskers(d) {
+  return [0, d.length - 1];
+}
+
+function d3_chart_boxQuartiles(d) {
+  return [
+    d3.quantile(d, .25),
+    d3.quantile(d, .5),
+    d3.quantile(d, .75)
+  ];
+}
+// Chart design based on the recommendations of Stephen Few. Implementation
+// based on the work of Clint Ivy, Jamie Love, and Jason Davies.
+// http://projects.instantcognition.com/protovis/bulletchart/
+d3.chart.bullet = function() {
+  var orient = "left", // TODO top & bottom
+      reverse = false,
+      duration = 0,
+      ranges = d3_chart_bulletRanges,
+      markers = d3_chart_bulletMarkers,
+      measures = d3_chart_bulletMeasures,
+      width = 380,
+      height = 30,
+      tickFormat = null;
+
+  // For each small multiple…
+  function bullet(g) {
+    g.each(function(d, i) {
+      var rangez = ranges.call(this, d, i).slice().sort(d3.descending),
+          markerz = markers.call(this, d, i).slice().sort(d3.descending),
+          measurez = measures.call(this, d, i).slice().sort(d3.descending),
+          g = d3.select(this);
+
+      // Compute the new x-scale.
+      var x1 = d3.scale.linear()
+          .domain([0, Math.max(rangez[0], markerz[0], measurez[0])])
+          .range(reverse ? [width, 0] : [0, width]);
+
+      // Retrieve the old x-scale, if this is an update.
+      var x0 = this.__chart__ || d3.scale.linear()
+          .domain([0, Infinity])
+          .range(x1.range());
+
+      // Stash the new scale.
+      this.__chart__ = x1;
+
+      // Derive width-scales from the x-scales.
+      var w0 = d3_chart_bulletWidth(x0),
+          w1 = d3_chart_bulletWidth(x1);
+
+      // Update the range rects.
+      var range = g.selectAll("rect.range")
+          .data(rangez);
+
+      range.enter().append("svg:rect")
+          .attr("class", function(d, i) { return "range s" + i; })
+          .attr("width", w0)
+          .attr("height", height)
+          .attr("x", reverse ? x0 : 0)
+        .transition()
+          .duration(duration)
+          .attr("width", w1)
+          .attr("x", reverse ? x1 : 0);
+
+      range.transition()
+          .duration(duration)
+          .attr("x", reverse ? x1 : 0)
+          .attr("width", w1)
+          .attr("height", height);
+
+      // Update the measure rects.
+      var measure = g.selectAll("rect.measure")
+          .data(measurez);
+
+      measure.enter().append("svg:rect")
+          .attr("class", function(d, i) { return "measure s" + i; })
+          .attr("width", w0)
+          .attr("height", height / 3)
+          .attr("x", reverse ? x0 : 0)
+          .attr("y", height / 3)
+        .transition()
+          .duration(duration)
+          .attr("width", w1)
+          .attr("x", reverse ? x1 : 0);
+
+      measure.transition()
+          .duration(duration)
+          .attr("width", w1)
+          .attr("height", height / 3)
+          .attr("x", reverse ? x1 : 0)
+          .attr("y", height / 3);
+
+      // Update the marker lines.
+      var marker = g.selectAll("line.marker")
+          .data(markerz);
+
+      marker.enter().append("svg:line")
+          .attr("class", "marker")
+          .attr("x1", x0)
+          .attr("x2", x0)
+          .attr("y1", height / 6)
+          .attr("y2", height * 5 / 6)
+        .transition()
+          .duration(duration)
+          .attr("x1", x1)
+          .attr("x2", x1);
+
+      marker.transition()
+          .duration(duration)
+          .attr("x1", x1)
+          .attr("x2", x1)
+          .attr("y1", height / 6)
+          .attr("y2", height * 5 / 6);
+
+      // Compute the tick format.
+      var format = tickFormat || x1.tickFormat(8);
+
+      // Update the tick groups.
+      var tick = g.selectAll("g.tick")
+          .data(x1.ticks(8), function(d) {
+            return this.textContent || format(d);
+          });
+
+      // Initialize the ticks with the old scale, x0.
+      var tickEnter = tick.enter().append("svg:g")
+          .attr("class", "tick")
+          .attr("transform", d3_chart_bulletTranslate(x0))
+          .style("opacity", 1e-6);
+
+      tickEnter.append("svg:line")
+          .attr("y1", height)
+          .attr("y2", height * 7 / 6);
+
+      tickEnter.append("svg:text")
+          .attr("text-anchor", "middle")
+          .attr("dy", "1em")
+          .attr("y", height * 7 / 6)
+          .text(format);
+
+      // Transition the entering ticks to the new scale, x1.
+      tickEnter.transition()
+          .duration(duration)
+          .attr("transform", d3_chart_bulletTranslate(x1))
+          .style("opacity", 1);
+
+      // Transition the updating ticks to the new scale, x1.
+      var tickUpdate = tick.transition()
+          .duration(duration)
+          .attr("transform", d3_chart_bulletTranslate(x1))
+          .style("opacity", 1);
+
+      tickUpdate.select("line")
+          .attr("y1", height)
+          .attr("y2", height * 7 / 6);
+
+      tickUpdate.select("text")
+          .attr("y", height * 7 / 6);
+
+      // Transition the exiting ticks to the new scale, x1.
+      tick.exit().transition()
+          .duration(duration)
+          .attr("transform", d3_chart_bulletTranslate(x1))
+          .style("opacity", 1e-6)
+          .remove();
+    });
+    d3.timer.flush();
+  }
+
+  // left, right, top, bottom
+  bullet.orient = function(x) {
+    if (!arguments.length) return orient;
+    orient = x;
+    reverse = orient == "right" || orient == "bottom";
+    return bullet;
+  };
+
+  // ranges (bad, satisfactory, good)
+  bullet.ranges = function(x) {
+    if (!arguments.length) return ranges;
+    ranges = x;
+    return bullet;
+  };
+
+  // markers (previous, goal)
+  bullet.markers = function(x) {
+    if (!arguments.length) return markers;
+    markers = x;
+    return bullet;
+  };
+
+  // measures (actual, forecast)
+  bullet.measures = function(x) {
+    if (!arguments.length) return measures;
+    measures = x;
+    return bullet;
+  };
+
+  bullet.width = function(x) {
+    if (!arguments.length) return width;
+    width = x;
+    return bullet;
+  };
+
+  bullet.height = function(x) {
+    if (!arguments.length) return height;
+    height = x;
+    return bullet;
+  };
+
+  bullet.tickFormat = function(x) {
+    if (!arguments.length) return tickFormat;
+    tickFormat = x;
+    return bullet;
+  };
+
+  bullet.duration = function(x) {
+    if (!arguments.length) return duration;
+    duration = x;
+    return bullet;
+  };
+
+  return bullet;
+};
+
+function d3_chart_bulletRanges(d) {
+  return d.ranges;
+}
+
+function d3_chart_bulletMarkers(d) {
+  return d.markers;
+}
+
+function d3_chart_bulletMeasures(d) {
+  return d.measures;
+}
+
+function d3_chart_bulletTranslate(x) {
+  return function(d) {
+    return "translate(" + x(d) + ",0)";
+  };
+}
+
+function d3_chart_bulletWidth(x) {
+  var x0 = x(0);
+  return function(d) {
+    return Math.abs(x(d) - x0);
+  };
+}
+// Implements a horizon layout, which is a variation of a single-series
+// area chart where the area is folded into multiple bands. Color is used to
+// encode band, allowing the size of the chart to be reduced significantly
+// without impeding readability. This layout algorithm is based on the work of
+// J. Heer, N. Kong and M. Agrawala in "Sizing the Horizon: The Effects of Chart
+// Size and Layering on the Graphical Perception of Time Series Visualizations",
+// CHI 2009. http://hci.stanford.edu/publications/2009/heer-horizon-chi09.pdf
+d3.chart.horizon = function() {
+  var bands = 1, // between 1 and 5, typically
+      mode = "offset", // or mirror
+      interpolate = "linear", // or basis, monotone, step-before, etc.
+      x = d3_chart_horizonX,
+      y = d3_chart_horizonY,
+      w = 960,
+      h = 40,
+      duration = 0;
+
+  var color = d3.scale.linear()
+      .domain([-1, 0, 1])
+      .range(["#d62728", "#fff", "#1f77b4"]);
+
+  // For each small multiple…
+  function horizon(g) {
+    g.each(function(d, i) {
+      var g = d3.select(this),
+          n = 2 * bands + 1,
+          xMin = Infinity,
+          xMax = -Infinity,
+          yMax = -Infinity,
+          x0, // old x-scale
+          y0, // old y-scale
+          id; // unique id for paths
+
+      // Compute x- and y-values along with extents.
+      var data = d.map(function(d, i) {
+        var xv = x.call(this, d, i),
+            yv = y.call(this, d, i);
+        if (xv < xMin) xMin = xv;
+        if (xv > xMax) xMax = xv;
+        if (-yv > yMax) yMax = -yv;
+        if (yv > yMax) yMax = yv;
+        return [xv, yv];
+      });
+
+      // Compute the new x- and y-scales.
+      var x1 = d3.scale.linear().domain([xMin, xMax]).range([0, w]),
+          y1 = d3.scale.linear().domain([0, yMax]).range([0, h * bands]);
+
+      // Retrieve the old scales, if this is an update.
+      if (this.__chart__) {
+        x0 = this.__chart__.x;
+        y0 = this.__chart__.y;
+        id = this.__chart__.id;
+      } else {
+        x0 = d3.scale.linear().domain([0, Infinity]).range(x1.range());
+        y0 = d3.scale.linear().domain([0, Infinity]).range(y1.range());
+        id = ++d3_chart_horizonId;
+      }
+
+      // We'll use a defs to store the area path and the clip path.
+      var defs = g.selectAll("defs")
+          .data([data]);
+
+      var defsEnter = defs.enter().append("svg:defs");
+
+      // The clip path is a simple rect.
+      defsEnter.append("svg:clipPath")
+          .attr("id", "d3_chart_horizon_clip" + id)
+        .append("svg:rect")
+          .attr("width", w)
+          .attr("height", h);
+
+      defs.select("rect").transition()
+          .duration(duration)
+          .attr("width", w)
+          .attr("height", h);
+
+      // The area path is rendered with our resuable d3.svg.area.
+      defsEnter.append("svg:path")
+          .attr("id", "d3_chart_horizon_path" + id)
+          .attr("d", d3_chart_horizonArea
+          .interpolate(interpolate)
+          .x(function(d) { return x0(d[0]); })
+          .y0(h * bands)
+          .y1(function(d) { return h * bands - y0(d[1]); }))
+        .transition()
+          .duration(duration)
+          .attr("d", d3_chart_horizonArea
+          .x(function(d) { return x1(d[0]); })
+          .y1(function(d) { return h * bands - y1(d[1]); }));
+
+      defs.select("path").transition()
+          .duration(duration)
+          .attr("d", d3_chart_horizonArea);
+
+      // We'll use a container to clip all horizon layers at once.
+      g.selectAll("g")
+          .data([null])
+        .enter().append("svg:g")
+          .attr("clip-path", "url(#d3_chart_horizon_clip" + id + ")");
+
+      // Define the transform function based on the mode.
+      var transform = mode == "offset"
+          ? function(d) { return "translate(0," + (d + (d < 0) - bands) * h + ")"; }
+          : function(d) { return (d < 0 ? "scale(1,-1)" : "") + "translate(0," + (d - bands) * h + ")"; };
+
+      // Instantiate each copy of the path with different transforms.
+      var u = g.select("g").selectAll("use")
+          .data(d3.range(-1, -bands - 1, -1).concat(d3.range(1, bands + 1)), Number);
+
+      // TODO don't fudge the enter transition
+      u.enter().append("svg:use")
+          .attr("xlink:href", "#d3_chart_horizon_path" + id)
+          .attr("transform", function(d) { return transform(d + (d > 0 ? 1 : -1)); })
+          .style("fill", color)
+        .transition()
+          .duration(duration)
+          .attr("transform", transform);
+
+      u.transition()
+          .duration(duration)
+          .attr("transform", transform)
+          .style("fill", color);
+
+      u.exit().transition()
+          .duration(duration)
+          .attr("transform", transform)
+          .remove();
+
+      // Stash the new scales.
+      this.__chart__ = {x: x1, y: y1, id: id};
+    });
+    d3.timer.flush();
+  }
+
+  horizon.duration = function(x) {
+    if (!arguments.length) return duration;
+    duration = +x;
+    return horizon;
+  };
+
+  horizon.bands = function(x) {
+    if (!arguments.length) return bands;
+    bands = +x;
+    color.domain([-bands, 0, bands]);
+    return horizon;
+  };
+
+  horizon.mode = function(x) {
+    if (!arguments.length) return mode;
+    mode = x + "";
+    return horizon;
+  };
+
+  horizon.colors = function(x) {
+    if (!arguments.length) return color.range();
+    color.range(x);
+    return horizon;
+  };
+
+  horizon.interpolate = function(x) {
+    if (!arguments.length) return interpolate;
+    interpolate = x + "";
+    return horizon;
+  };
+
+  horizon.x = function(z) {
+    if (!arguments.length) return x;
+    x = z;
+    return horizon;
+  };
+
+  horizon.y = function(z) {
+    if (!arguments.length) return y;
+    y = z;
+    return horizon;
+  };
+
+  horizon.width = function(x) {
+    if (!arguments.length) return w;
+    w = +x;
+    return horizon;
+  };
+
+  horizon.height = function(x) {
+    if (!arguments.length) return h;
+    h = +x;
+    return horizon;
+  };
+
+  return horizon;
+};
+
+var d3_chart_horizonArea = d3.svg.area(),
+    d3_chart_horizonId = 0;
+
+function d3_chart_horizonX(d) {
+  return d[0];
+}
+
+function d3_chart_horizonY(d) {
+  return d[1];
+}
+// Based on http://vis.stanford.edu/protovis/ex/qqplot.html
+d3.chart.qq = function() {
+  var width = 1,
+      height = 1,
+      duration = 0,
+      domain = null,
+      tickFormat = null,
+      n = 100,
+      x = d3_chart_qqX,
+      y = d3_chart_qqY;
+
+  // For each small multiple…
+  function qq(g) {
+    g.each(function(d, i) {
+      var g = d3.select(this),
+          qx = d3_chart_qqQuantiles(n, x.call(this, d, i)),
+          qy = d3_chart_qqQuantiles(n, y.call(this, d, i)),
+          xd = domain && domain.call(this, d, i) || [d3.min(qx), d3.max(qx)], // new x-domain
+          yd = domain && domain.call(this, d, i) || [d3.min(qy), d3.max(qy)], // new y-domain
+          x0, // old x-scale
+          y0; // old y-scale
+
+      // Compute the new x-scale.
+      var x1 = d3.scale.linear()
+          .domain(xd)
+          .range([0, width]);
+
+      // Compute the new y-scale.
+      var y1 = d3.scale.linear()
+          .domain(yd)
+          .range([height, 0]);
+
+      // Retrieve the old scales, if this is an update.
+      if (this.__chart__) {
+        x0 = this.__chart__.x;
+        y0 = this.__chart__.y;
+      } else {
+        x0 = d3.scale.linear().domain([0, Infinity]).range(x1.range());
+        y0 = d3.scale.linear().domain([0, Infinity]).range(y1.range());
+      }
+
+      // Stash the new scales.
+      this.__chart__ = {x: x1, y: y1};
+
+      // Update diagonal line.
+      var diagonal = g.selectAll("line.diagonal")
+          .data([null]);
+
+      diagonal.enter().append("svg:line")
+          .attr("class", "diagonal")
+          .attr("x1", x1(yd[0]))
+          .attr("y1", y1(xd[0]))
+          .attr("x2", x1(yd[1]))
+          .attr("y2", y1(xd[1]));
+
+      diagonal.transition()
+          .duration(duration)
+          .attr("x1", x1(yd[0]))
+          .attr("y1", y1(xd[0]))
+          .attr("x2", x1(yd[1]))
+          .attr("y2", y1(xd[1]));
+
+      // Update quantile plots.
+      var circle = g.selectAll("circle")
+          .data(d3.range(n).map(function(i) {
+            return {x: qx[i], y: qy[i]};
+          }));
+
+      circle.enter().append("svg:circle")
+          .attr("class", "quantile")
+          .attr("r", 4.5)
+          .attr("cx", function(d) { return x0(d.x); })
+          .attr("cy", function(d) { return y0(d.y); })
+          .style("opacity", 1e-6)
+        .transition()
+          .duration(duration)
+          .attr("cx", function(d) { return x1(d.x); })
+          .attr("cy", function(d) { return y1(d.y); })
+          .style("opacity", 1);
+
+      circle.transition()
+          .duration(duration)
+          .attr("cx", function(d) { return x1(d.x); })
+          .attr("cy", function(d) { return y1(d.y); })
+          .style("opacity", 1);
+
+      circle.exit().transition()
+          .duration(duration)
+          .attr("cx", function(d) { return x1(d.x); })
+          .attr("cy", function(d) { return y1(d.y); })
+          .style("opacity", 1e-6)
+          .remove();
+
+      var xformat = tickFormat || x1.tickFormat(4),
+          yformat = tickFormat || y1.tickFormat(4),
+          tx = function(d) { return "translate(" + x1(d) + "," + height + ")"; },
+          ty = function(d) { return "translate(0," + y1(d) + ")"; };
+
+      // Update x-ticks.
+      var xtick = g.selectAll("g.x.tick")
+          .data(x1.ticks(4), function(d) {
+            return this.textContent || xformat(d);
+          });
+
+      var xtickEnter = xtick.enter().append("svg:g")
+          .attr("class", "x tick")
+          .attr("transform", function(d) { return "translate(" + x0(d) + "," + height + ")"; })
+          .style("opacity", 1e-6);
+
+      xtickEnter.append("svg:line")
+          .attr("y1", 0)
+          .attr("y2", -6);
+
+      xtickEnter.append("svg:text")
+          .attr("text-anchor", "middle")
+          .attr("dy", "1em")
+          .text(xformat);
+
+      // Transition the entering ticks to the new scale, x1.
+      xtickEnter.transition()
+          .duration(duration)
+          .attr("transform", tx)
+          .style("opacity", 1);
+
+      // Transition the updating ticks to the new scale, x1.
+      xtick.transition()
+          .duration(duration)
+          .attr("transform", tx)
+          .style("opacity", 1);
+
+      // Transition the exiting ticks to the new scale, x1.
+      xtick.exit().transition()
+          .duration(duration)
+          .attr("transform", tx)
+          .style("opacity", 1e-6)
+          .remove();
+
+      // Update ticks.
+      var ytick = g.selectAll("g.y.tick")
+          .data(y1.ticks(4), function(d) {
+            return this.textContent || yformat(d);
+          });
+
+      var ytickEnter = ytick.enter().append("svg:g")
+          .attr("class", "y tick")
+          .attr("transform", function(d) { return "translate(0," + y0(d) + ")"; })
+          .style("opacity", 1e-6);
+
+      ytickEnter.append("svg:line")
+          .attr("x1", 0)
+          .attr("x2", 6);
+
+      ytickEnter.append("svg:text")
+          .attr("text-anchor", "end")
+          .attr("dx", "-.5em")
+          .attr("dy", ".3em")
+          .text(yformat);
+
+      // Transition the entering ticks to the new scale, y1.
+      ytickEnter.transition()
+          .duration(duration)
+          .attr("transform", ty)
+          .style("opacity", 1);
+
+      // Transition the updating ticks to the new scale, y1.
+      ytick.transition()
+          .duration(duration)
+          .attr("transform", ty)
+          .style("opacity", 1);
+
+      // Transition the exiting ticks to the new scale, y1.
+      ytick.exit().transition()
+          .duration(duration)
+          .attr("transform", ty)
+          .style("opacity", 1e-6)
+          .remove();
+    });
+  }
+
+  qq.width = function(x) {
+    if (!arguments.length) return width;
+    width = x;
+    return qq;
+  };
+
+  qq.height = function(x) {
+    if (!arguments.length) return height;
+    height = x;
+    return qq;
+  };
+
+  qq.duration = function(x) {
+    if (!arguments.length) return duration;
+    duration = x;
+    return qq;
+  };
+
+  qq.domain = function(x) {
+    if (!arguments.length) return domain;
+    domain = x == null ? x : d3.functor(x);
+    return qq;
+  };
+
+  qq.count = function(z) {
+    if (!arguments.length) return n;
+    n = z;
+    return qq;
+  };
+
+  qq.x = function(z) {
+    if (!arguments.length) return x;
+    x = z;
+    return qq;
+  };
+
+  qq.y = function(z) {
+    if (!arguments.length) return y;
+    y = z;
+    return qq;
+  };
+
+  qq.tickFormat = function(x) {
+    if (!arguments.length) return tickFormat;
+    tickFormat = x;
+    return qq;
+  };
+
+  return qq;
+};
+
+function d3_chart_qqQuantiles(n, values) {
+  var m = values.length - 1;
+  values = values.slice().sort(d3.ascending);
+  return d3.range(n).map(function(i) {
+    return values[~~(i * m / n)];
+  });
+}
+
+function d3_chart_qqX(d) {
+  return d.x;
+}
+
+function d3_chart_qqY(d) {
+  return d.y;
+}
+})();