From 9c6fd09153b4bac9f6b95e2584a3776a0d91ba42 Mon Sep 17 00:00:00 2001
From: Dan McGee <dan@archlinux.org>
Date: Mon, 5 Dec 2011 16:49:45 -0600
Subject: Update d3 resources

Signed-off-by: Dan McGee <dan@archlinux.org>
---
 media/d3.layout.js | 61 +++++++++++++++++++++++++++---------------------------
 1 file changed, 31 insertions(+), 30 deletions(-)

(limited to 'media/d3.layout.js')

diff --git a/media/d3.layout.js b/media/d3.layout.js
index 2bfb9d32..30ba7918 100644
--- a/media/d3.layout.js
+++ b/media/d3.layout.js
@@ -113,16 +113,19 @@ d3.layout.chord = function() {
     k = (2 * Math.PI - padding * n) / k;
 
     // Compute the start and end angle for each group and subgroup.
+    // Note: Opera has a bug reordering object literal properties!
     x = 0, i = -1; while (++i < n) {
       x0 = x, j = -1; while (++j < n) {
         var di = groupIndex[i],
-            dj = subgroupIndex[i][j],
-            v = matrix[di][dj];
+            dj = subgroupIndex[di][j],
+            v = matrix[di][dj],
+            a0 = x,
+            a1 = x += v * k;
         subgroups[di + "-" + dj] = {
           index: di,
           subindex: dj,
-          startAngle: x,
-          endAngle: x += v * k,
+          startAngle: a0,
+          endAngle: a1,
           value: v
         };
       }
@@ -153,7 +156,9 @@ d3.layout.chord = function() {
 
   function resort() {
     chords.sort(function(a, b) {
-      return sortChords(a.target.value, b.target.value);
+      return sortChords(
+          (a.source.value + a.target.value) / 2,
+          (b.source.value + b.target.value) / 2);
     });
   }
 
@@ -313,17 +318,12 @@ d3.layout.force = function() {
       }
     }
 
-    event.tick.dispatch({type: "tick", alpha: alpha});
+    event.tick({type: "tick", alpha: alpha});
 
     // simulated annealing, basically
     return (alpha *= .99) < .005;
   }
 
-  force.on = function(type, listener) {
-    event[type].add(listener);
-    return force;
-  };
-
   force.nodes = function(x) {
     if (!arguments.length) return nodes;
     nodes = x;
@@ -470,6 +470,7 @@ d3.layout.force = function() {
   // use `node.call(force.drag)` to make nodes draggable
   force.drag = function() {
     if (!drag) drag = d3.behavior.drag()
+        .origin(Object)
         .on("dragstart", dragstart)
         .on("drag", d3_layout_forceDrag)
         .on("dragend", d3_layout_forceDragEnd);
@@ -484,7 +485,7 @@ d3.layout.force = function() {
     d3_layout_forceDragForce = force;
   }
 
-  return force;
+  return d3.rebind(force, event, "on");
 };
 
 var d3_layout_forceDragForce,
@@ -505,8 +506,8 @@ function d3_layout_forceDragEnd() {
 }
 
 function d3_layout_forceDrag() {
-  d3_layout_forceDragNode.px += d3.event.dx;
-  d3_layout_forceDragNode.py += d3.event.dy;
+  d3_layout_forceDragNode.px = d3.event.x;
+  d3_layout_forceDragNode.py = d3.event.y;
   d3_layout_forceDragForce.resume(); // restart annealing
 }
 
@@ -600,33 +601,31 @@ d3.layout.partition = function() {
 };
 d3.layout.pie = function() {
   var value = Number,
-      sort = null,
+      sort = d3_layout_pieSortByValue,
       startAngle = 0,
       endAngle = 2 * Math.PI;
 
   function pie(data, i) {
 
+    // Compute the numeric values for each data element.
+    var values = data.map(function(d, i) { return +value.call(pie, d, i); });
+
     // Compute the start angle.
     var a = +(typeof startAngle === "function"
         ? startAngle.apply(this, arguments)
         : startAngle);
 
-    // Compute the angular range (end - start).
-    var k = (typeof endAngle === "function"
+    // Compute the angular scale factor: from value to radians.
+    var k = ((typeof endAngle === "function"
         ? endAngle.apply(this, arguments)
-        : endAngle) - startAngle;
+        : endAngle) - startAngle)
+        / d3.sum(values);
 
     // Optionally sort the data.
     var index = d3.range(data.length);
-    if (sort != null) index.sort(function(i, j) {
-      return sort(data[i], data[j]);
-    });
-
-    // Compute the numeric values for each data element.
-    var values = data.map(value);
-
-    // Convert k into a scale factor from value to angle, using the sum.
-    k /= values.reduce(function(p, d) { return p + d; }, 0);
+    if (sort != null) index.sort(sort === d3_layout_pieSortByValue
+        ? function(i, j) { return values[j] - values[i]; }
+        : function(i, j) { return sort(data[i], data[j]); });
 
     // Compute the arcs!
     var arcs = index.map(function(i) {
@@ -693,6 +692,8 @@ d3.layout.pie = function() {
 
   return pie;
 };
+
+var d3_layout_pieSortByValue = {};
 // data is two-dimensional array of x,y; we populate y0
 d3.layout.stack = function() {
   var values = Object,
@@ -1115,10 +1116,10 @@ d3.layout.hierarchy = function() {
 
 // A method assignment helper for hierarchy subclasses.
 function d3_layout_hierarchyRebind(object, hierarchy) {
-  object.sort = d3.rebind(object, hierarchy.sort);
-  object.children = d3.rebind(object, hierarchy.children);
+  d3.rebind(object, hierarchy, "sort", "children", "value");
+
+  // Add an alias for links, for convenience.
   object.links = d3_layout_hierarchyLinks;
-  object.value = d3.rebind(object, hierarchy.value);
 
   // If the new API is used, enabling inlining.
   object.nodes = function(d) {
-- 
cgit v1.2.3-2-g168b