From a40fc83fe61edbbd57ee0d69213a7989a3e7ae4a Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=C3=89tienne=20T=C3=A9treault-Pinard?= <etienne@plot.ly>
Date: Mon, 14 Mar 2016 14:52:48 -0400
Subject: [PATCH 01/22] factor out legend helper into separate file + add tests

---
 src/components/legend/helpers.js  | 25 +++++++++++++++++++++
 src/components/legend/index.js    | 16 --------------
 test/jasmine/tests/legend_test.js | 36 +++++++++++++++++++++++++++++++
 3 files changed, 61 insertions(+), 16 deletions(-)
 create mode 100644 src/components/legend/helpers.js

diff --git a/src/components/legend/helpers.js b/src/components/legend/helpers.js
new file mode 100644
index 00000000000..cf300a4a9da
--- /dev/null
+++ b/src/components/legend/helpers.js
@@ -0,0 +1,25 @@
+/**
+* Copyright 2012-2016, Plotly, Inc.
+* All rights reserved.
+*
+* This source code is licensed under the MIT license found in the
+* LICENSE file in the root directory of this source tree.
+*/
+
+
+'use strict';
+
+var Plots = require('../../plots/plots');
+
+
+exports.legendGetsTrace = function legendGetsTrace(trace) {
+    return trace.visible && Plots.traceIs(trace, 'showLegend');
+};
+
+exports.isGrouped = function isGrouped(legendLayout) {
+    return (legendLayout.traceorder || '').indexOf('grouped') !== -1;
+};
+
+exports.isReversed = function isReversed(legendLayout) {
+    return (legendLayout.traceorder || '').indexOf('reversed') !== -1;
+};
diff --git a/src/components/legend/index.js b/src/components/legend/index.js
index 80257f445ef..46ab1255ee4 100644
--- a/src/components/legend/index.js
+++ b/src/components/legend/index.js
@@ -329,22 +329,6 @@ legend.texts = function(context, td, d, i, traces) {
     else text.call(textLayout);
 };
 
-// -----------------------------------------------------
-// legend drawing
-// -----------------------------------------------------
-
-function legendGetsTrace(trace) {
-    return trace.visible && Plots.traceIs(trace, 'showLegend');
-}
-
-function isGrouped(legendLayout) {
-    return (legendLayout.traceorder || '').indexOf('grouped') !== -1;
-}
-
-function isReversed(legendLayout) {
-    return (legendLayout.traceorder || '').indexOf('reversed') !== -1;
-}
-
 legend.getLegendData = function(calcdata, opts) {
 
     // build an { legendgroup: [cd0, cd0], ... } object
diff --git a/test/jasmine/tests/legend_test.js b/test/jasmine/tests/legend_test.js
index 8de626b6c83..c05a18bad35 100644
--- a/test/jasmine/tests/legend_test.js
+++ b/test/jasmine/tests/legend_test.js
@@ -1,6 +1,7 @@
 var Legend = require('@src/components/legend');
 var Plots = require('@src/plots/plots');
 
+var helpers = require('@src/components/legend/helpers');
 describe('Test legend:', function() {
     'use strict';
 
@@ -325,4 +326,39 @@ describe('Test legend:', function() {
         });
     });
 
+    describe('legendGetsTraces helper', function() {
+        var legendGetsTrace = helpers.legendGetsTrace;
+
+        it('should return true when trace is visible and supports legend', function() {
+            expect(legendGetsTrace({ visible: true, type: 'bar' })).toBe(true);
+            expect(legendGetsTrace({ visible: false, type: 'bar' })).toBe(false);
+            expect(legendGetsTrace({ visible: true, type: 'contour' })).toBe(false);
+            expect(legendGetsTrace({ visible: false, type: 'contour' })).toBe(false);
+        });
+    });
+
+    describe('isGrouped helper', function() {
+        var isGrouped = helpers.isGrouped;
+
+        it('should return true when trace is visible and supports legend', function() {
+            expect(isGrouped({ traceorder: 'normal' })).toBe(false);
+            expect(isGrouped({ traceorder: 'grouped' })).toBe(true);
+            expect(isGrouped({ traceorder: 'reversed+grouped' })).toBe(true);
+            expect(isGrouped({ traceorder: 'grouped+reversed' })).toBe(true);
+            expect(isGrouped({ traceorder: 'reversed' })).toBe(false);
+        });
+    });
+
+    describe('isReversed helper', function() {
+        var isReversed = helpers.isReversed;
+
+        it('should return true when trace is visible and supports legend', function() {
+            expect(isReversed({ traceorder: 'normal' })).toBe(false);
+            expect(isReversed({ traceorder: 'grouped' })).toBe(false);
+            expect(isReversed({ traceorder: 'reversed+grouped' })).toBe(true);
+            expect(isReversed({ traceorder: 'grouped+reversed' })).toBe(true);
+            expect(isReversed({ traceorder: 'reversed' })).toBe(true);
+        });
+    });
+
 });

From b3af44533c503b84b503dbf5e207824ba29121ef Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=C3=89tienne=20T=C3=A9treault-Pinard?= <etienne@plot.ly>
Date: Mon, 14 Mar 2016 14:53:59 -0400
Subject: [PATCH 02/22] move auto-anchor logic to own module + add tests

---
 src/components/legend/anchor_utils.js | 47 +++++++++++++++
 test/jasmine/tests/legend_test.js     | 87 +++++++++++++++++++++++++++
 2 files changed, 134 insertions(+)
 create mode 100644 src/components/legend/anchor_utils.js

diff --git a/src/components/legend/anchor_utils.js b/src/components/legend/anchor_utils.js
new file mode 100644
index 00000000000..a4b19262239
--- /dev/null
+++ b/src/components/legend/anchor_utils.js
@@ -0,0 +1,47 @@
+/**
+* Copyright 2012-2016, Plotly, Inc.
+* All rights reserved.
+*
+* This source code is licensed under the MIT license found in the
+* LICENSE file in the root directory of this source tree.
+*/
+
+
+'use strict';
+
+
+/**
+ * Determine the position anchor property of x/y xanchor/yanchor components.
+ *
+ * - values < 1/3 align the low side at that fraction,
+ * - values [1/3, 2/3] align the center at that fraction,
+ * - values > 2/3 align the right at that fraction.
+ */
+
+exports.isRightAnchor = function isRightAnchor(opts) {
+    return (
+        opts.xanchor === 'right' ||
+        (opts.xanchor === 'auto' && opts.x >= 2 / 3)
+    );
+};
+
+exports.isCenterAnchor = function isCenterAnchor(opts) {
+    return (
+        opts.xanchor === 'center' ||
+        (opts.xanchor === 'auto' && opts.x > 1 / 3 && opts.x < 2 / 3)
+    );
+};
+
+exports.isBottomAnchor = function isTopAnchor(opts) {
+    return (
+        opts.yanchor === 'bottom' ||
+        (opts.yanchor === 'auto' && opts.y <= 1 / 3)
+    );
+};
+
+exports.isMiddleAnchor = function isMiddleAnchor(opts) {
+    return (
+        opts.yanchor === 'middle' ||
+        (opts.yanchor === 'auto' && opts.y > 1 / 3 && opts.y < 2 / 3)
+    );
+};
diff --git a/test/jasmine/tests/legend_test.js b/test/jasmine/tests/legend_test.js
index c05a18bad35..b3a474b1625 100644
--- a/test/jasmine/tests/legend_test.js
+++ b/test/jasmine/tests/legend_test.js
@@ -2,6 +2,7 @@ var Legend = require('@src/components/legend');
 var Plots = require('@src/plots/plots');
 
 var helpers = require('@src/components/legend/helpers');
+var anchorUtils = require('@src/components/legend/anchor_utils');
 describe('Test legend:', function() {
     'use strict';
 
@@ -361,4 +362,90 @@ describe('Test legend:', function() {
         });
     });
 
+    describe('isRightAnchor anchor util', function() {
+        var isRightAnchor = anchorUtils.isRightAnchor;
+        var threshold = 2/3;
+
+        it('should return true when \'xanchor\' is set to \'right\'', function() {
+            expect(isRightAnchor({ xanchor: 'left' })).toBe(false);
+            expect(isRightAnchor({ xanchor: 'center' })).toBe(false);
+            expect(isRightAnchor({ xanchor: 'right' })).toBe(true);
+        });
+
+        it('should return true when \'xanchor\' is set to \'auto\' and \'x\' >= 2/3', function() {
+            var opts = { xanchor: 'auto' };
+
+            [0, 0.4, 0.7, 1].forEach(function(v) {
+                opts.x = v;
+                expect(isRightAnchor(opts))
+                    .toBe(v > threshold, 'case ' + v);
+            });
+        });
+    });
+
+    describe('isCenterAnchor anchor util', function() {
+        var isCenterAnchor = anchorUtils.isCenterAnchor;
+        var threshold0 = 1/3;
+        var threshold1 = 2/3;
+
+        it('should return true when \'xanchor\' is set to \'center\'', function() {
+            expect(isCenterAnchor({ xanchor: 'left' })).toBe(false);
+            expect(isCenterAnchor({ xanchor: 'center' })).toBe(true);
+            expect(isCenterAnchor({ xanchor: 'right' })).toBe(false);
+        });
+
+        it('should return true when \'xanchor\' is set to \'auto\' and 1/3 < \'x\' < 2/3', function() {
+            var opts = { xanchor: 'auto' };
+
+            [0, 0.4, 0.7, 1].forEach(function(v) {
+                opts.x = v;
+                expect(isCenterAnchor(opts))
+                    .toBe(v > threshold0 && v < threshold1, 'case ' + v);
+            });
+        });
+    });
+
+    describe('isBottomAnchor anchor util', function() {
+        var isBottomAnchor = anchorUtils.isBottomAnchor;
+        var threshold = 1/3;
+
+        it('should return true when \'yanchor\' is set to \'right\'', function() {
+            expect(isBottomAnchor({ yanchor: 'top' })).toBe(false);
+            expect(isBottomAnchor({ yanchor: 'middle' })).toBe(false);
+            expect(isBottomAnchor({ yanchor: 'bottom' })).toBe(true);
+        });
+
+        it('should return true when \'yanchor\' is set to \'auto\' and \'y\' <= 1/3', function() {
+            var opts = { yanchor: 'auto' };
+
+            [0, 0.4, 0.7, 1].forEach(function(v) {
+                opts.y = v;
+                expect(isBottomAnchor(opts))
+                    .toBe(v < threshold, 'case ' + v);
+            });
+        });
+    });
+
+    describe('isMiddleAnchor anchor util', function() {
+        var isMiddleAnchor = anchorUtils.isMiddleAnchor;
+        var threshold0 = 1/3;
+        var threshold1 = 2/3;
+
+        it('should return true when \'yanchor\' is set to \'center\'', function() {
+            expect(isMiddleAnchor({ yanchor: 'top' })).toBe(false);
+            expect(isMiddleAnchor({ yanchor: 'middle' })).toBe(true);
+            expect(isMiddleAnchor({ yanchor: 'bottom' })).toBe(false);
+        });
+
+        it('should return true when \'yanchor\' is set to \'auto\' and 1/3 < \'y\' < 2/3', function() {
+            var opts = { yanchor: 'auto' };
+
+            [0, 0.4, 0.7, 1].forEach(function(v) {
+                opts.y = v;
+                expect(isMiddleAnchor(opts))
+                    .toBe(v > threshold0 && v < threshold1, 'case ' + v);
+            });
+        });
+    });
+
 });

From 67eda7598526f1ddc04912723ebddb43f23f4167 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=C3=89tienne=20T=C3=A9treault-Pinard?= <etienne@plot.ly>
Date: Mon, 14 Mar 2016 14:54:41 -0400
Subject: [PATCH 03/22] move legend defaults to own module

---
 src/components/legend/defaults.js | 70 +++++++++++++++++++++++++++++++
 src/components/legend/index.js    | 55 +-----------------------
 2 files changed, 71 insertions(+), 54 deletions(-)
 create mode 100644 src/components/legend/defaults.js

diff --git a/src/components/legend/defaults.js b/src/components/legend/defaults.js
new file mode 100644
index 00000000000..f5f8a7ea3be
--- /dev/null
+++ b/src/components/legend/defaults.js
@@ -0,0 +1,70 @@
+/**
+* Copyright 2012-2016, Plotly, Inc.
+* All rights reserved.
+*
+* This source code is licensed under the MIT license found in the
+* LICENSE file in the root directory of this source tree.
+*/
+
+
+'use strict';
+
+var Lib = require('../../lib');
+var Plots = require('../../plots/plots');
+
+var attributes = require('./attributes');
+var helpers = require('./helpers');
+
+
+module.exports = function legendDefaults(layoutIn, layoutOut, fullData) {
+    var containerIn = layoutIn.legend || {},
+        containerOut = layoutOut.legend = {};
+
+    var visibleTraces = 0,
+        defaultOrder = 'normal',
+        trace;
+
+    for(var i = 0; i < fullData.length; i++) {
+        trace = fullData[i];
+
+        if(helpers.legendGetsTrace(trace)) {
+            visibleTraces++;
+            // always show the legend by default if there's a pie
+            if(Plots.traceIs(trace, 'pie')) visibleTraces++;
+        }
+
+        if((Plots.traceIs(trace, 'bar') && layoutOut.barmode==='stack') ||
+                ['tonextx','tonexty'].indexOf(trace.fill)!==-1) {
+            defaultOrder = helpers.isGrouped({traceorder: defaultOrder}) ?
+                'grouped+reversed' : 'reversed';
+        }
+
+        if(trace.legendgroup !== undefined && trace.legendgroup !== '') {
+            defaultOrder = helpers.isReversed({traceorder: defaultOrder}) ?
+                'reversed+grouped' : 'grouped';
+        }
+    }
+
+    function coerce(attr, dflt) {
+        return Lib.coerce(containerIn, containerOut, attributes, attr, dflt);
+    }
+
+    var showLegend = Lib.coerce(layoutIn, layoutOut,
+        Plots.layoutAttributes, 'showlegend', visibleTraces > 1);
+
+    if(showLegend === false) return;
+
+    coerce('bgcolor', layoutOut.paper_bgcolor);
+    coerce('bordercolor');
+    coerce('borderwidth');
+    Lib.coerceFont(coerce, 'font', layoutOut.font);
+
+    coerce('traceorder', defaultOrder);
+    if(helpers.isGrouped(layoutOut.legend)) coerce('tracegroupgap');
+
+    coerce('x');
+    coerce('xanchor');
+    coerce('y');
+    coerce('yanchor');
+    Lib.noneOrAll(containerIn, containerOut, ['x', 'y']);
+};
diff --git a/src/components/legend/index.js b/src/components/legend/index.js
index 46ab1255ee4..ef9022da0b3 100644
--- a/src/components/legend/index.js
+++ b/src/components/legend/index.js
@@ -28,60 +28,7 @@ var legend = module.exports = {};
 var constants = require('./constants');
 legend.layoutAttributes = require('./attributes');
 
-legend.supplyLayoutDefaults = function(layoutIn, layoutOut, fullData) {
-    var containerIn = layoutIn.legend || {},
-        containerOut = layoutOut.legend = {};
-
-    var visibleTraces = 0,
-        defaultOrder = 'normal',
-        trace;
-
-    for(var i = 0; i < fullData.length; i++) {
-        trace = fullData[i];
-
-        if(legendGetsTrace(trace)) {
-            visibleTraces++;
-            // always show the legend by default if there's a pie
-            if(Plots.traceIs(trace, 'pie')) visibleTraces++;
-        }
-
-        if((Plots.traceIs(trace, 'bar') && layoutOut.barmode==='stack') ||
-                ['tonextx','tonexty'].indexOf(trace.fill)!==-1) {
-            defaultOrder = isGrouped({traceorder: defaultOrder}) ?
-                'grouped+reversed' : 'reversed';
-        }
-
-        if(trace.legendgroup !== undefined && trace.legendgroup !== '') {
-            defaultOrder = isReversed({traceorder: defaultOrder}) ?
-                'reversed+grouped' : 'grouped';
-        }
-    }
-
-    function coerce(attr, dflt) {
-        return Lib.coerce(containerIn, containerOut,
-            legend.layoutAttributes, attr, dflt);
-    }
-
-    var showLegend = Lib.coerce(layoutIn, layoutOut,
-        Plots.layoutAttributes, 'showlegend', visibleTraces > 1);
-
-    if(showLegend === false) return;
-
-    coerce('bgcolor', layoutOut.paper_bgcolor);
-    coerce('bordercolor');
-    coerce('borderwidth');
-    Lib.coerceFont(coerce, 'font', layoutOut.font);
-
-    coerce('traceorder', defaultOrder);
-    if(isGrouped(layoutOut.legend)) coerce('tracegroupgap');
-
-    coerce('x');
-    coerce('xanchor');
-    coerce('y');
-    coerce('yanchor');
-    Lib.noneOrAll(containerIn, containerOut, ['x', 'y']);
-};
-
+legend.supplyLayoutDefaults = require('./defaults');
 // -----------------------------------------------------
 // styling functions for traces in legends.
 // same functions for styling traces in the popovers

From 09354bf97df5b8c6eaee1e516ec17b43fa331673 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=C3=89tienne=20T=C3=A9treault-Pinard?= <etienne@plot.ly>
Date: Mon, 14 Mar 2016 14:56:07 -0400
Subject: [PATCH 04/22] move legend style step to own module:

- un-exposed legend.lines, legend.bars, legend.points,
  legend.boxes and legend.pie
---
 src/components/legend/index.js | 202 +-----------------------------
 src/components/legend/style.js | 216 +++++++++++++++++++++++++++++++++
 2 files changed, 217 insertions(+), 201 deletions(-)
 create mode 100644 src/components/legend/style.js

diff --git a/src/components/legend/index.js b/src/components/legend/index.js
index ef9022da0b3..d9a39e8fbee 100644
--- a/src/components/legend/index.js
+++ b/src/components/legend/index.js
@@ -29,207 +29,6 @@ var constants = require('./constants');
 legend.layoutAttributes = require('./attributes');
 
 legend.supplyLayoutDefaults = require('./defaults');
-// -----------------------------------------------------
-// styling functions for traces in legends.
-// same functions for styling traces in the popovers
-// -----------------------------------------------------
-
-legend.lines = function(d) {
-    var trace = d[0].trace,
-        showFill = trace.visible && trace.fill && trace.fill!=='none',
-        showLine = subTypes.hasLines(trace);
-
-    var fill = d3.select(this).select('.legendfill').selectAll('path')
-        .data(showFill ? [d] : []);
-    fill.enter().append('path').classed('js-fill',true);
-    fill.exit().remove();
-    fill.attr('d', 'M5,0h30v6h-30z')
-        .call(Drawing.fillGroupStyle);
-
-    var line = d3.select(this).select('.legendlines').selectAll('path')
-        .data(showLine ? [d] : []);
-    line.enter().append('path').classed('js-line',true)
-        .attr('d', 'M5,0h30');
-    line.exit().remove();
-    line.call(Drawing.lineGroupStyle);
-};
-
-legend.points = function(d) {
-    var d0 = d[0],
-        trace = d0.trace,
-        showMarkers = subTypes.hasMarkers(trace),
-        showText = subTypes.hasText(trace),
-        showLines = subTypes.hasLines(trace);
-
-    var dMod, tMod;
-
-    // 'scatter3d' and 'scattergeo' don't use gd.calcdata yet;
-    // use d0.trace to infer arrayOk attributes
-
-    function boundVal(attrIn, arrayToValFn, bounds) {
-        var valIn = Lib.nestedProperty(trace, attrIn).get(),
-            valToBound = (Array.isArray(valIn) && arrayToValFn) ?
-                arrayToValFn(valIn) : valIn;
-
-        if(bounds) {
-            if(valToBound < bounds[0]) return bounds[0];
-            else if(valToBound > bounds[1]) return bounds[1];
-        }
-        return valToBound;
-    }
-
-    function pickFirst(array) { return array[0]; }
-
-    // constrain text, markers, etc so they'll fit on the legend
-    if(showMarkers || showText || showLines) {
-        var dEdit = {},
-            tEdit = {};
-
-        if(showMarkers) {
-            dEdit.mc = boundVal('marker.color', pickFirst);
-            dEdit.mo = boundVal('marker.opacity', Lib.mean, [0.2, 1]);
-            dEdit.ms = boundVal('marker.size', Lib.mean, [2, 16]);
-            dEdit.mlc = boundVal('marker.line.color', pickFirst);
-            dEdit.mlw = boundVal('marker.line.width', Lib.mean, [0, 5]);
-            tEdit.marker = {
-                sizeref: 1,
-                sizemin: 1,
-                sizemode: 'diameter'
-            };
-        }
-
-        if(showLines) {
-            tEdit.line = {
-                width: boundVal('line.width', pickFirst, [0, 10])
-            };
-        }
-
-        if(showText) {
-            dEdit.tx = 'Aa';
-            dEdit.tp = boundVal('textposition', pickFirst);
-            dEdit.ts = 10;
-            dEdit.tc = boundVal('textfont.color', pickFirst);
-            dEdit.tf = boundVal('textfont.family', pickFirst);
-        }
-
-        dMod = [Lib.minExtend(d0, dEdit)];
-        tMod = Lib.minExtend(trace, tEdit);
-    }
-
-    var ptgroup = d3.select(this).select('g.legendpoints');
-
-    var pts = ptgroup.selectAll('path.scatterpts')
-        .data(showMarkers ? dMod : []);
-    pts.enter().append('path').classed('scatterpts', true)
-        .attr('transform', 'translate(20,0)');
-    pts.exit().remove();
-    pts.call(Drawing.pointStyle, tMod);
-
-    // 'mrc' is set in pointStyle and used in textPointStyle:
-    // constrain it here
-    if(showMarkers) dMod[0].mrc = 3;
-
-    var txt = ptgroup.selectAll('g.pointtext')
-        .data(showText ? dMod : []);
-    txt.enter()
-        .append('g').classed('pointtext',true)
-            .append('text').attr('transform', 'translate(20,0)');
-    txt.exit().remove();
-    txt.selectAll('text').call(Drawing.textPointStyle, tMod);
-
-};
-
-legend.bars = function(d) {
-    var trace = d[0].trace,
-        marker = trace.marker||{},
-        markerLine = marker.line||{},
-        barpath = d3.select(this).select('g.legendpoints')
-            .selectAll('path.legendbar')
-            .data(Plots.traceIs(trace, 'bar') ? [d] : []);
-    barpath.enter().append('path').classed('legendbar',true)
-        .attr('d','M6,6H-6V-6H6Z')
-        .attr('transform','translate(20,0)');
-    barpath.exit().remove();
-    barpath.each(function(d) {
-        var w = (d.mlw+1 || markerLine.width+1) - 1,
-            p = d3.select(this);
-        p.style('stroke-width',w+'px')
-            .call(Color.fill, d.mc || marker.color);
-        if(w) {
-            p.call(Color.stroke, d.mlc || markerLine.color);
-        }
-    });
-};
-
-legend.boxes = function(d) {
-    var trace = d[0].trace,
-        pts = d3.select(this).select('g.legendpoints')
-            .selectAll('path.legendbox')
-            .data(Plots.traceIs(trace, 'box') && trace.visible ? [d] : []);
-    pts.enter().append('path').classed('legendbox', true)
-        // if we want the median bar, prepend M6,0H-6
-        .attr('d', 'M6,6H-6V-6H6Z')
-        .attr('transform', 'translate(20,0)');
-    pts.exit().remove();
-    pts.each(function(d) {
-        var w = (d.lw+1 || trace.line.width+1) - 1,
-            p = d3.select(this);
-        p.style('stroke-width', w+'px')
-            .call(Color.fill, d.fc || trace.fillcolor);
-        if(w) {
-            p.call(Color.stroke, d.lc || trace.line.color);
-        }
-    });
-};
-
-legend.pie = function(d) {
-    var trace = d[0].trace,
-        pts = d3.select(this).select('g.legendpoints')
-            .selectAll('path.legendpie')
-            .data(Plots.traceIs(trace, 'pie') && trace.visible ? [d] : []);
-    pts.enter().append('path').classed('legendpie', true)
-        .attr('d', 'M6,6H-6V-6H6Z')
-        .attr('transform', 'translate(20,0)');
-    pts.exit().remove();
-
-    if(pts.size()) pts.call(styleOne, d[0], trace);
-};
-
-legend.style = function(s) {
-    s.each(function(d) {
-        var traceGroup = d3.select(this);
-
-        var fill = traceGroup
-            .selectAll('g.legendfill')
-                .data([d]);
-        fill.enter().append('g')
-            .classed('legendfill',true);
-
-        var line = traceGroup
-            .selectAll('g.legendlines')
-                .data([d]);
-        line.enter().append('g')
-            .classed('legendlines',true);
-
-        var symbol = traceGroup
-            .selectAll('g.legendsymbols')
-                .data([d]);
-        symbol.enter().append('g')
-            .classed('legendsymbols',true);
-        symbol.style('opacity', d[0].trace.opacity);
-
-        symbol.selectAll('g.legendpoints')
-            .data([d])
-          .enter().append('g')
-            .classed('legendpoints',true);
-    })
-    .each(legend.bars)
-    .each(legend.boxes)
-    .each(legend.pie)
-    .each(legend.lines)
-    .each(legend.points);
-};
-
 legend.texts = function(context, td, d, i, traces) {
     var fullLayout = td._fullLayout,
         trace = d[0].trace,
@@ -724,6 +523,7 @@ legend.repositionLegend = function(td, traces) {
     lx = Math.round(lx);
     ly = Math.round(ly);
 
+legend.style = require('./style');
     // lastly check if the margin auto-expand has changed
     Plots.autoMargin(td,'legend',{
         x: opts.x,
diff --git a/src/components/legend/style.js b/src/components/legend/style.js
new file mode 100644
index 00000000000..a7e9f6a8fc9
--- /dev/null
+++ b/src/components/legend/style.js
@@ -0,0 +1,216 @@
+/**
+* Copyright 2012-2016, Plotly, Inc.
+* All rights reserved.
+*
+* This source code is licensed under the MIT license found in the
+* LICENSE file in the root directory of this source tree.
+*/
+
+
+'use strict';
+
+var d3 = require('d3');
+
+var Lib = require('../../lib');
+var Plots = require('../../plots/plots');
+var Drawing = require('../drawing');
+var Color = require('../color');
+
+var subTypes = require('../../traces/scatter/subtypes');
+var stylePie = require('../../traces/pie/style_one');
+
+
+module.exports = function style(s) {
+    s.each(function(d) {
+        var traceGroup = d3.select(this);
+
+        var fill = traceGroup
+            .selectAll('g.legendfill')
+                .data([d]);
+        fill.enter().append('g')
+            .classed('legendfill',true);
+
+        var line = traceGroup
+            .selectAll('g.legendlines')
+                .data([d]);
+        line.enter().append('g')
+            .classed('legendlines',true);
+
+        var symbol = traceGroup
+            .selectAll('g.legendsymbols')
+                .data([d]);
+        symbol.enter().append('g')
+            .classed('legendsymbols',true);
+        symbol.style('opacity', d[0].trace.opacity);
+
+        symbol.selectAll('g.legendpoints')
+            .data([d])
+          .enter().append('g')
+            .classed('legendpoints',true);
+    })
+    .each(styleBars)
+    .each(styleBoxes)
+    .each(stylePies)
+    .each(styleLines)
+    .each(stylePoints);
+};
+
+function styleLines(d) {
+    var trace = d[0].trace,
+        showFill = trace.visible && trace.fill && trace.fill!=='none',
+        showLine = subTypes.hasLines(trace);
+
+    var fill = d3.select(this).select('.legendfill').selectAll('path')
+        .data(showFill ? [d] : []);
+    fill.enter().append('path').classed('js-fill',true);
+    fill.exit().remove();
+    fill.attr('d', 'M5,0h30v6h-30z')
+        .call(Drawing.fillGroupStyle);
+
+    var line = d3.select(this).select('.legendlines').selectAll('path')
+        .data(showLine ? [d] : []);
+    line.enter().append('path').classed('js-line',true)
+        .attr('d', 'M5,0h30');
+    line.exit().remove();
+    line.call(Drawing.lineGroupStyle);
+}
+
+function stylePoints(d) {
+    var d0 = d[0],
+        trace = d0.trace,
+        showMarkers = subTypes.hasMarkers(trace),
+        showText = subTypes.hasText(trace),
+        showLines = subTypes.hasLines(trace);
+
+    var dMod, tMod;
+
+    // 'scatter3d' and 'scattergeo' don't use gd.calcdata yet;
+    // use d0.trace to infer arrayOk attributes
+
+    function boundVal(attrIn, arrayToValFn, bounds) {
+        var valIn = Lib.nestedProperty(trace, attrIn).get(),
+            valToBound = (Array.isArray(valIn) && arrayToValFn) ?
+                arrayToValFn(valIn) : valIn;
+
+        if(bounds) {
+            if(valToBound < bounds[0]) return bounds[0];
+            else if(valToBound > bounds[1]) return bounds[1];
+        }
+        return valToBound;
+    }
+
+    function pickFirst(array) { return array[0]; }
+
+    // constrain text, markers, etc so they'll fit on the legend
+    if(showMarkers || showText || showLines) {
+        var dEdit = {},
+            tEdit = {};
+
+        if(showMarkers) {
+            dEdit.mc = boundVal('marker.color', pickFirst);
+            dEdit.mo = boundVal('marker.opacity', Lib.mean, [0.2, 1]);
+            dEdit.ms = boundVal('marker.size', Lib.mean, [2, 16]);
+            dEdit.mlc = boundVal('marker.line.color', pickFirst);
+            dEdit.mlw = boundVal('marker.line.width', Lib.mean, [0, 5]);
+            tEdit.marker = {
+                sizeref: 1,
+                sizemin: 1,
+                sizemode: 'diameter'
+            };
+        }
+
+        if(showLines) {
+            tEdit.line = {
+                width: boundVal('line.width', pickFirst, [0, 10])
+            };
+        }
+
+        if(showText) {
+            dEdit.tx = 'Aa';
+            dEdit.tp = boundVal('textposition', pickFirst);
+            dEdit.ts = 10;
+            dEdit.tc = boundVal('textfont.color', pickFirst);
+            dEdit.tf = boundVal('textfont.family', pickFirst);
+        }
+
+        dMod = [Lib.minExtend(d0, dEdit)];
+        tMod = Lib.minExtend(trace, tEdit);
+    }
+
+    var ptgroup = d3.select(this).select('g.legendpoints');
+
+    var pts = ptgroup.selectAll('path.scatterpts')
+        .data(showMarkers ? dMod : []);
+    pts.enter().append('path').classed('scatterpts', true)
+        .attr('transform', 'translate(20,0)');
+    pts.exit().remove();
+    pts.call(Drawing.pointStyle, tMod);
+
+    // 'mrc' is set in pointStyle and used in textPointStyle:
+    // constrain it here
+    if(showMarkers) dMod[0].mrc = 3;
+
+    var txt = ptgroup.selectAll('g.pointtext')
+        .data(showText ? dMod : []);
+    txt.enter()
+        .append('g').classed('pointtext',true)
+            .append('text').attr('transform', 'translate(20,0)');
+    txt.exit().remove();
+    txt.selectAll('text').call(Drawing.textPointStyle, tMod);
+}
+
+function styleBars(d) {
+    var trace = d[0].trace,
+        marker = trace.marker||{},
+        markerLine = marker.line||{},
+        barpath = d3.select(this).select('g.legendpoints')
+            .selectAll('path.legendbar')
+            .data(Plots.traceIs(trace, 'bar') ? [d] : []);
+    barpath.enter().append('path').classed('legendbar',true)
+        .attr('d','M6,6H-6V-6H6Z')
+        .attr('transform','translate(20,0)');
+    barpath.exit().remove();
+    barpath.each(function(d) {
+        var w = (d.mlw+1 || markerLine.width+1) - 1,
+            p = d3.select(this);
+        p.style('stroke-width',w+'px')
+            .call(Color.fill, d.mc || marker.color);
+        if(w) {
+            p.call(Color.stroke, d.mlc || markerLine.color);
+        }
+    });
+}
+
+function styleBoxes(d) {
+    var trace = d[0].trace,
+        pts = d3.select(this).select('g.legendpoints')
+            .selectAll('path.legendbox')
+            .data(Plots.traceIs(trace, 'box') && trace.visible ? [d] : []);
+    pts.enter().append('path').classed('legendbox', true)
+        // if we want the median bar, prepend M6,0H-6
+        .attr('d', 'M6,6H-6V-6H6Z')
+        .attr('transform', 'translate(20,0)');
+    pts.exit().remove();
+    pts.each(function(d) {
+        var w = (d.lw+1 || trace.line.width+1) - 1,
+            p = d3.select(this);
+        p.style('stroke-width', w+'px')
+            .call(Color.fill, d.fc || trace.fillcolor);
+        if(w) {
+            p.call(Color.stroke, d.lc || trace.line.color);
+        }
+    });
+}
+
+function stylePies(d) {
+    var trace = d[0].trace,
+        pts = d3.select(this).select('g.legendpoints')
+            .selectAll('path.legendpie')
+            .data(Plots.traceIs(trace, 'pie') && trace.visible ? [d] : []);
+    pts.enter().append('path').classed('legendpie', true)
+        .attr('d', 'M6,6H-6V-6H6Z')
+        .attr('transform', 'translate(20,0)');
+    pts.exit().remove();
+
+    if(pts.size()) pts.call(stylePie, d[0], trace);
+}

From 1b69395916e8434d69e9005b338888ace37ee609 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=C3=89tienne=20T=C3=A9treault-Pinard?= <etienne@plot.ly>
Date: Mon, 14 Mar 2016 14:56:46 -0400
Subject: [PATCH 05/22] move legend-data logic to own module

---
 src/components/legend/get_legend_data.js | 104 +++++++++++++++++++++++
 src/components/legend/index.js           |  85 ------------------
 test/jasmine/tests/legend_test.js        |   3 +-
 3 files changed, 105 insertions(+), 87 deletions(-)
 create mode 100644 src/components/legend/get_legend_data.js

diff --git a/src/components/legend/get_legend_data.js b/src/components/legend/get_legend_data.js
new file mode 100644
index 00000000000..a8698f140fe
--- /dev/null
+++ b/src/components/legend/get_legend_data.js
@@ -0,0 +1,104 @@
+/**
+* Copyright 2012-2016, Plotly, Inc.
+* All rights reserved.
+*
+* This source code is licensed under the MIT license found in the
+* LICENSE file in the root directory of this source tree.
+*/
+
+
+'use strict';
+
+var Plots = require('../../plots/plots');
+
+var helpers = require('./helpers');
+
+
+module.exports = function getLegendData(calcdata, opts) {
+    var lgroupToTraces = {},
+        lgroups = [],
+        hasOneNonBlankGroup = false,
+        slicesShown = {},
+        lgroupi = 0;
+
+    var i, j;
+
+    function addOneItem(legendGroup, legendItem) {
+        // each '' legend group is treated as a separate group
+        if(legendGroup === '' || !helpers.isGrouped(opts)) {
+            var uniqueGroup = '~~i' + lgroupi; // TODO: check this against fullData legendgroups?
+
+            lgroups.push(uniqueGroup);
+            lgroupToTraces[uniqueGroup] = [[legendItem]];
+            lgroupi++;
+        }
+        else if(lgroups.indexOf(legendGroup) === -1) {
+            lgroups.push(legendGroup);
+            hasOneNonBlankGroup = true;
+            lgroupToTraces[legendGroup] = [[legendItem]];
+        }
+        else lgroupToTraces[legendGroup].push([legendItem]);
+    }
+
+    // build an { legendgroup: [cd0, cd0], ... } object
+    for(i = 0; i < calcdata.length; i++) {
+        var cd = calcdata[i],
+            cd0 = cd[0],
+            trace = cd0.trace,
+            lgroup = trace.legendgroup;
+
+        if(!helpers.legendGetsTrace(trace) || !trace.showlegend) continue;
+
+        if(Plots.traceIs(trace, 'pie')) {
+            if(!slicesShown[lgroup]) slicesShown[lgroup] = {};
+
+            for(j = 0; j < cd.length; j++) {
+                var labelj = cd[j].label;
+
+                if(!slicesShown[lgroup][labelj]) {
+                    addOneItem(lgroup, {
+                        label: labelj,
+                        color: cd[j].color,
+                        i: cd[j].i,
+                        trace: trace
+                    });
+
+                    slicesShown[lgroup][labelj] = true;
+                }
+            }
+        }
+
+        else addOneItem(lgroup, cd0);
+    }
+
+    // won't draw a legend in this case
+    if(!lgroups.length) return [];
+
+    // rearrange lgroupToTraces into a d3-friendly array of arrays
+    var lgroupsLength = lgroups.length,
+        ltraces,
+        legendData;
+
+    if(hasOneNonBlankGroup && helpers.isGrouped(opts)) {
+        legendData = new Array(lgroupsLength);
+
+        for(i = 0; i < lgroupsLength; i++) {
+            ltraces = lgroupToTraces[lgroups[i]];
+            legendData[i] = helpers.isReversed(opts) ? ltraces.reverse() : ltraces;
+        }
+    }
+    else {
+        // collapse all groups into one if all groups are blank
+        legendData = [new Array(lgroupsLength)];
+
+        for(i = 0; i < lgroupsLength; i++) {
+            ltraces = lgroupToTraces[lgroups[i]][0];
+            legendData[0][helpers.isReversed(opts) ? lgroupsLength-i-1 : i] = ltraces;
+        }
+        lgroupsLength = 1;
+    }
+
+    // needed in repositionLegend
+    opts._lgroupsLength = lgroupsLength;
+    return legendData;
+};
diff --git a/src/components/legend/index.js b/src/components/legend/index.js
index d9a39e8fbee..de18db52c5d 100644
--- a/src/components/legend/index.js
+++ b/src/components/legend/index.js
@@ -75,91 +75,6 @@ legend.texts = function(context, td, d, i, traces) {
     else text.call(textLayout);
 };
 
-legend.getLegendData = function(calcdata, opts) {
-
-    // build an { legendgroup: [cd0, cd0], ... } object
-    var lgroupToTraces = {},
-        lgroups = [],
-        hasOneNonBlankGroup = false,
-        slicesShown = {},
-        lgroupi = 0;
-
-    var cd, cd0, trace, lgroup, i, j, labelj;
-
-    function addOneItem(legendGroup, legendItem) {
-        // each '' legend group is treated as a separate group
-        if(legendGroup==='' || !isGrouped(opts)) {
-            var uniqueGroup = '~~i' + lgroupi; // TODO: check this against fullData legendgroups?
-            lgroups.push(uniqueGroup);
-            lgroupToTraces[uniqueGroup] = [[legendItem]];
-            lgroupi++;
-        }
-        else if(lgroups.indexOf(legendGroup) === -1) {
-            lgroups.push(legendGroup);
-            hasOneNonBlankGroup = true;
-            lgroupToTraces[legendGroup] = [[legendItem]];
-        }
-        else lgroupToTraces[legendGroup].push([legendItem]);
-    }
-
-    for(i = 0; i < calcdata.length; i++) {
-        cd = calcdata[i];
-        cd0 = cd[0];
-        trace = cd0.trace;
-        lgroup = trace.legendgroup;
-
-        if(!legendGetsTrace(trace) || !trace.showlegend) continue;
-
-        if(Plots.traceIs(trace, 'pie')) {
-            if(!slicesShown[lgroup]) slicesShown[lgroup] = {};
-            for(j = 0; j < cd.length; j++) {
-                labelj = cd[j].label;
-                if(!slicesShown[lgroup][labelj]) {
-                    addOneItem(lgroup, {
-                        label: labelj,
-                        color: cd[j].color,
-                        i: cd[j].i,
-                        trace: trace
-                    });
-
-                    slicesShown[lgroup][labelj] = true;
-                }
-            }
-        }
-
-        else addOneItem(lgroup, cd0);
-    }
-
-    // won't draw a legend in this case
-    if(!lgroups.length) return [];
-
-    // rearrange lgroupToTraces into a d3-friendly array of arrays
-    var lgroupsLength = lgroups.length,
-        ltraces,
-        legendData;
-
-    if(hasOneNonBlankGroup && isGrouped(opts)) {
-        legendData = new Array(lgroupsLength);
-        for(i = 0; i < lgroupsLength; i++) {
-            ltraces = lgroupToTraces[lgroups[i]];
-            legendData[i] = isReversed(opts) ? ltraces.reverse() : ltraces;
-        }
-    }
-    else {
-        // collapse all groups into one if all groups are blank
-        legendData = [new Array(lgroupsLength)];
-        for(i = 0; i < lgroupsLength; i++) {
-            ltraces = lgroupToTraces[lgroups[i]][0];
-            legendData[0][isReversed(opts) ? lgroupsLength-i-1 : i] = ltraces;
-        }
-        lgroupsLength = 1;
-    }
-
-    // needed in repositionLegend
-    opts._lgroupsLength = lgroupsLength;
-    return legendData;
-};
-
 legend.draw = function(td) {
     var fullLayout = td._fullLayout;
 
diff --git a/test/jasmine/tests/legend_test.js b/test/jasmine/tests/legend_test.js
index b3a474b1625..58f10776d7e 100644
--- a/test/jasmine/tests/legend_test.js
+++ b/test/jasmine/tests/legend_test.js
@@ -1,6 +1,7 @@
 var Legend = require('@src/components/legend');
 var Plots = require('@src/plots/plots');
 
+var getLegendData = require('@src/components/legend/get_legend_data');
 var helpers = require('@src/components/legend/helpers');
 var anchorUtils = require('@src/components/legend/anchor_utils');
 describe('Test legend:', function() {
@@ -65,8 +66,6 @@ describe('Test legend:', function() {
     });
 
     describe('getLegendData', function() {
-        var getLegendData = Legend.getLegendData;
-
         var calcdata, opts, legendData, expected;
 
         it('should group legendgroup traces', function() {

From 0b6dfcf962c7d8f231b12a928238e5ea237bc39a Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=C3=89tienne=20T=C3=A9treault-Pinard?= <etienne@plot.ly>
Date: Mon, 14 Mar 2016 14:59:23 -0400
Subject: [PATCH 06/22] move legend draw step to own module:

- un-expose legend.repositionText and legend.texts
- use anchor utils
---
 src/components/legend/draw.js  | 448 +++++++++++++++++++++++++++++++++
 src/components/legend/index.js | 418 +-----------------------------
 2 files changed, 449 insertions(+), 417 deletions(-)
 create mode 100644 src/components/legend/draw.js

diff --git a/src/components/legend/draw.js b/src/components/legend/draw.js
new file mode 100644
index 00000000000..b6db5c8188f
--- /dev/null
+++ b/src/components/legend/draw.js
@@ -0,0 +1,448 @@
+/**
+* Copyright 2012-2016, Plotly, Inc.
+* All rights reserved.
+*
+* This source code is licensed under the MIT license found in the
+* LICENSE file in the root directory of this source tree.
+*/
+
+
+'use strict';
+
+var d3 = require('d3');
+
+var Plotly = require('../../plotly');
+var Lib = require('../../lib');
+var Plots = require('../../plots/plots');
+var Fx = require('../../plots/cartesian/graph_interact');
+var Drawing = require('../drawing');
+var Color = require('../color');
+
+var constants = require('./constants');
+var getLegendData = require('./get_legend_data');
+var style = require('./style');
+var helpers = require('./helpers');
+var anchorUtils = require('./anchor_utils');
+
+
+module.exports = function draw(gd) {
+    var fullLayout = gd._fullLayout;
+
+    if(!fullLayout._infolayer || !gd.calcdata) return;
+
+    var opts = fullLayout.legend,
+        legendData = fullLayout.showlegend && getLegendData(gd.calcdata, opts),
+        hiddenSlices = fullLayout.hiddenlabels || [];
+
+    if(!fullLayout.showlegend || !legendData.length) {
+        fullLayout._infolayer.selectAll('.legend').remove();
+        Plots.autoMargin(gd, 'legend');
+        return;
+    }
+
+    if(typeof gd.firstRender === 'undefined') gd.firstRender = true;
+    else if(gd.firstRender) gd.firstRender = false;
+
+    var legendsvg = fullLayout._infolayer.selectAll('svg.legend')
+        .data([0]);
+    legendsvg.enter().append('svg')
+        .attr({
+            'class': 'legend',
+            'pointer-events': 'all'
+        });
+
+    var bg = legendsvg.selectAll('rect.bg')
+        .data([0]);
+    bg.enter().append('rect')
+        .attr({
+            'class': 'bg',
+            'shape-rendering': 'crispEdges'
+        })
+        .call(Color.stroke, opts.bordercolor)
+        .call(Color.fill, opts.bgcolor)
+        .style('stroke-width', opts.borderwidth + 'px');
+
+    var scrollBox = legendsvg.selectAll('g.scrollbox')
+        .data([0]);
+    scrollBox.enter().append('g')
+        .attr('class', 'scrollbox');
+    scrollBox.exit().remove();
+
+    var scrollBar = legendsvg.selectAll('rect.scrollbar')
+        .data([0]);
+    scrollBar.enter().append('rect')
+        .attr({
+            'class': 'scrollbar',
+            'rx': 20,
+            'ry': 2,
+            'width': 0,
+            'height': 0
+        })
+        .call(Color.fill, '#808BA4');
+
+    var groups = scrollBox.selectAll('g.groups')
+        .data(legendData);
+    groups.enter().append('g')
+        .attr('class', 'groups');
+    groups.exit().remove();
+
+    if(helpers.isGrouped(opts)) {
+        groups.attr('transform', function(d, i) {
+            return 'translate(0,' + i * opts.tracegroupgap + ')';
+        });
+    }
+
+    var traces = groups.selectAll('g.traces')
+        .data(Lib.identity);
+
+    traces.enter().append('g').attr('class', 'traces');
+    traces.exit().remove();
+
+    traces.call(style)
+        .style('opacity', function(d) {
+            var trace = d[0].trace;
+            if(Plots.traceIs(trace, 'pie')) {
+                return hiddenSlices.indexOf(d[0].label) !== -1 ? 0.5 : 1;
+            } else {
+                return trace.visible === 'legendonly' ? 0.5 : 1;
+            }
+        })
+        .each(function(d, i) {
+            drawTexts(this, gd, d, i, traces);
+
+            var traceToggle = d3.select(this).selectAll('rect')
+                .data([0]);
+            traceToggle.enter().append('rect')
+                .classed('legendtoggle', true)
+                .style('cursor', 'pointer')
+                .attr('pointer-events', 'all')
+                .call(Color.fill, 'rgba(0,0,0,0)');
+            traceToggle.on('click', function() {
+                if(gd._dragged) return;
+
+                var fullData = gd._fullData,
+                    trace = d[0].trace,
+                    legendgroup = trace.legendgroup,
+                    traceIndicesInGroup = [],
+                    tracei,
+                    newVisible;
+
+                if(Plots.traceIs(trace, 'pie')) {
+                    var thisLabel = d[0].label,
+                        newHiddenSlices = hiddenSlices.slice(),
+                        thisLabelIndex = newHiddenSlices.indexOf(thisLabel);
+
+                    if(thisLabelIndex === -1) newHiddenSlices.push(thisLabel);
+                    else newHiddenSlices.splice(thisLabelIndex, 1);
+
+                    Plotly.relayout(gd, 'hiddenlabels', newHiddenSlices);
+                } else {
+                    if(legendgroup === '') {
+                        traceIndicesInGroup = [trace.index];
+                    } else {
+                        for(var i = 0; i < fullData.length; i++) {
+                            tracei = fullData[i];
+                            if(tracei.legendgroup === legendgroup) {
+                                traceIndicesInGroup.push(tracei.index);
+                            }
+                        }
+                    }
+
+                    newVisible = trace.visible === true ? 'legendonly' : true;
+                    Plotly.restyle(gd, 'visible', newVisible, traceIndicesInGroup);
+                }
+            });
+        });
+
+    // Position and size the legend
+    repositionLegend(gd, traces);
+
+    // Scroll section must be executed after repositionLegend.
+    // It requires the legend width, height, x and y to position the scrollbox
+    // and these values are mutated in repositionLegend.
+    var gs = fullLayout._size,
+        lx = gs.l + gs.w * opts.x,
+        ly = gs.t + gs.h * (1-opts.y);
+
+    if(anchorUtils.isRightAnchor(opts)) {
+        lx -= opts.width;
+    }
+    if(anchorUtils.isCenterAnchor(opts)) {
+        lx -= opts.width / 2;
+    }
+
+    if(anchorUtils.isBottomAnchor(opts)) {
+        ly -= opts.height;
+    }
+    if(anchorUtils.isMiddleAnchor(opts)) {
+        ly -= opts.height / 2;
+    }
+
+    // Deal with scrolling
+    var plotHeight = fullLayout.height - fullLayout.margin.b,
+        scrollheight = Math.min(plotHeight - ly, opts.height),
+        scrollPosition = scrollBox.attr('data-scroll') ? scrollBox.attr('data-scroll') : 0;
+
+    scrollBox.attr('transform', 'translate(0, ' + scrollPosition + ')');
+    bg.attr({
+        width: opts.width - 2 * opts.borderwidth,
+        height: scrollheight - 2 * opts.borderwidth,
+        x: opts.borderwidth,
+        y: opts.borderwidth
+    });
+
+    legendsvg.call(Drawing.setRect, lx, ly, opts.width, scrollheight);
+
+    // If scrollbar should be shown.
+    if(gd.firstRender && opts.height - scrollheight > 0 && !gd._context.staticPlot) {
+
+        bg.attr({ width: opts.width - 2 * opts.borderwidth + constants.scrollBarWidth });
+
+        legendsvg.node().addEventListener('wheel', function(e) {
+            e.preventDefault();
+            scrollHandler(e.deltaY / 20);
+        });
+
+        scrollBar.node().addEventListener('mousedown', function(e) {
+            e.preventDefault();
+
+            function mMove(e) {
+                if(e.buttons === 1) {
+                    scrollHandler(e.movementY);
+                }
+            }
+
+            function mUp() {
+                scrollBar.node().removeEventListener('mousemove', mMove);
+                window.removeEventListener('mouseup', mUp);
+            }
+
+            window.addEventListener('mousemove', mMove);
+            window.addEventListener('mouseup', mUp);
+        });
+
+        // Move scrollbar to starting position on the first render
+        scrollBar.call(
+            Drawing.setRect,
+            opts.width - (constants.scrollBarWidth + constants.scrollBarMargin),
+            constants.scrollBarMargin,
+            constants.scrollBarWidth,
+            constants.scrollBarHeight
+        );
+    }
+
+    function scrollHandler(delta) {
+
+        var scrollBarTrack = scrollheight - constants.scrollBarHeight - 2 * constants.scrollBarMargin,
+            translateY = scrollBox.attr('data-scroll'),
+            scrollBoxY = Lib.constrain(translateY - delta, Math.min(scrollheight - opts.height, 0), 0),
+            scrollBarY = -scrollBoxY / (opts.height - scrollheight) * scrollBarTrack + constants.scrollBarMargin;
+
+        scrollBox.attr('data-scroll', scrollBoxY);
+        scrollBox.attr('transform', 'translate(0, ' + scrollBoxY + ')');
+        scrollBar.call(
+            Drawing.setRect,
+            opts.width - (constants.scrollBarWidth + constants.scrollBarMargin),
+            scrollBarY,
+            constants.scrollBarWidth,
+            constants.scrollBarHeight
+        );
+    }
+
+    if(gd._context.editable) {
+        var xf,
+            yf,
+            x0,
+            y0,
+            lw,
+            lh;
+
+        Fx.dragElement({
+            element: legendsvg.node(),
+            prepFn: function() {
+                x0 = Number(legendsvg.attr('x'));
+                y0 = Number(legendsvg.attr('y'));
+                lw = Number(legendsvg.attr('width'));
+                lh = Number(legendsvg.attr('height'));
+                Fx.setCursor(legendsvg);
+            },
+            moveFn: function(dx, dy) {
+                var gs = gd._fullLayout._size;
+
+                legendsvg.call(Drawing.setPosition, x0+dx, y0+dy);
+
+                xf = Fx.dragAlign(x0+dx, lw, gs.l, gs.l+gs.w,
+                    opts.xanchor);
+                yf = Fx.dragAlign(y0+dy+lh, -lh, gs.t+gs.h, gs.t,
+                    opts.yanchor);
+
+                var csr = Fx.dragCursors(xf, yf,
+                    opts.xanchor, opts.yanchor);
+                Fx.setCursor(legendsvg, csr);
+            },
+            doneFn: function(dragged) {
+                Fx.setCursor(legendsvg);
+                if(dragged && xf !== undefined && yf !== undefined) {
+                    Plotly.relayout(gd, {'legend.x': xf, 'legend.y': yf});
+                }
+            }
+        });
+    }
+};
+
+function drawTexts(context, gd, d, i, traces) {
+    var fullLayout = gd._fullLayout,
+        trace = d[0].trace,
+        isPie = Plots.traceIs(trace, 'pie'),
+        traceIndex = trace.index,
+        name = isPie ? d[0].label : trace.name;
+
+    var text = d3.select(context).selectAll('text.legendtext')
+        .data([0]);
+    text.enter().append('text').classed('legendtext', true);
+    text.attr({
+        x: 40,
+        y: 0,
+        'data-unformatted': name
+    })
+    .style({
+        'text-anchor': 'start',
+        '-webkit-user-select': 'none',
+        '-moz-user-select': 'none',
+        '-ms-user-select': 'none',
+        'user-select': 'none'
+    })
+    .call(Drawing.font, fullLayout.legend.font)
+    .text(name);
+
+    function textLayout(s) {
+        Plotly.util.convertToTspans(s, function() {
+            if(gd.firstRender) repositionLegend(gd, traces);
+        });
+        s.selectAll('tspan.line').attr({x: s.attr('x')});
+    }
+
+    if(gd._context.editable && !isPie) {
+        text.call(Plotly.util.makeEditable)
+            .call(textLayout)
+            .on('edit', function(text) {
+                this.attr({'data-unformatted': text});
+                this.text(text)
+                    .call(textLayout);
+                if(!this.text()) text = ' \u0020\u0020 ';
+                Plotly.restyle(gd, 'name', text, traceIndex);
+            });
+    }
+    else text.call(textLayout);
+}
+
+function repositionLegend(gd, traces) {
+    var fullLayout = gd._fullLayout,
+        gs = fullLayout._size,
+        opts = fullLayout.legend,
+        borderwidth = opts.borderwidth;
+
+    opts.width = 0;
+    opts.height = 0;
+
+    traces.each(function(d) {
+        var trace = d[0].trace,
+            g = d3.select(this),
+            bg = g.selectAll('.legendtoggle'),
+            text = g.selectAll('.legendtext'),
+            tspans = g.selectAll('.legendtext>tspan'),
+            tHeight = opts.font.size * 1.3,
+            tLines = tspans[0].length || 1,
+            tWidth = text.node() && Drawing.bBox(text.node()).width,
+            mathjaxGroup = g.select('g[class*=math-group]'),
+            textY,
+            tHeightFull;
+
+        if(!trace.showlegend) {
+            g.remove();
+            return;
+        }
+
+        if(mathjaxGroup.node()) {
+            var mathjaxBB = Drawing.bBox(mathjaxGroup.node());
+            tHeight = mathjaxBB.height;
+            tWidth = mathjaxBB.width;
+            mathjaxGroup.attr('transform','translate(0,' + (tHeight / 4) + ')');
+        }
+        else {
+            // approximation to height offset to center the font
+            // to avoid getBoundingClientRect
+            textY = tHeight * (0.3 + (1-tLines) / 2);
+            text.attr('y',textY);
+            tspans.attr('y',textY);
+        }
+
+        tHeightFull = Math.max(tHeight*tLines, 16) + 3;
+
+        g.attr('transform',
+            'translate(' + borderwidth + ',' +
+                (5 + borderwidth + opts.height + tHeightFull / 2) +
+            ')'
+        );
+        bg.attr({x: 0, y: -tHeightFull / 2, height: tHeightFull});
+
+        opts.height += tHeightFull;
+        opts.width = Math.max(opts.width, tWidth || 0);
+    });
+
+
+    opts.width += 45 + borderwidth * 2;
+    opts.height += 10 + borderwidth * 2;
+
+    if(helpers.isGrouped(opts)) {
+        opts.height += (opts._lgroupsLength-1) * opts.tracegroupgap;
+    }
+
+    traces.selectAll('.legendtoggle')
+        .attr('width', (gd._context.editable ? 0 : opts.width) + 40);
+
+    // now position the legend. for both x,y the positions are recorded as
+    // fractions of the plot area (left, bottom = 0,0). Outside the plot
+    // area is allowed but position will be clipped to the page.
+    // values <1/3 align the low side at that fraction, 1/3-2/3 align the
+    // center at that fraction, >2/3 align the right at that fraction
+
+    var lx = gs.l + gs.w * opts.x,
+        ly = gs.t + gs.h * (1-opts.y);
+
+    var xanchor = 'left';
+    if(anchorUtils.isRightAnchor(opts)) {
+        lx -= opts.width;
+        xanchor = 'right';
+    }
+    if(anchorUtils.isCenterAnchor(opts)) {
+        lx -= opts.width / 2;
+        xanchor = 'center';
+    }
+
+    var yanchor = 'top';
+    if(anchorUtils.isBottomAnchor(opts)) {
+        ly -= opts.height;
+        yanchor = 'bottom';
+    }
+    if(anchorUtils.isMiddleAnchor(opts)) {
+        ly -= opts.height / 2;
+        yanchor = 'middle';
+    }
+
+    // make sure we're only getting full pixels
+    opts.width = Math.ceil(opts.width);
+    opts.height = Math.ceil(opts.height);
+    lx = Math.round(lx);
+    ly = Math.round(ly);
+
+    // lastly check if the margin auto-expand has changed
+    Plots.autoMargin(gd, 'legend', {
+        x: opts.x,
+        y: opts.y,
+        l: opts.width * ({right: 1, center: 0.5}[xanchor] || 0),
+        r: opts.width * ({left: 1, center: 0.5}[xanchor] || 0),
+        b: opts.height * ({top: 1, middle: 0.5}[yanchor] || 0),
+        t: opts.height * ({bottom: 1, middle: 0.5}[yanchor] || 0)
+    });
+}
diff --git a/src/components/legend/index.js b/src/components/legend/index.js
index de18db52c5d..91f19c4086b 100644
--- a/src/components/legend/index.js
+++ b/src/components/legend/index.js
@@ -29,423 +29,7 @@ var constants = require('./constants');
 legend.layoutAttributes = require('./attributes');
 
 legend.supplyLayoutDefaults = require('./defaults');
-legend.texts = function(context, td, d, i, traces) {
-    var fullLayout = td._fullLayout,
-        trace = d[0].trace,
-        isPie = Plots.traceIs(trace, 'pie'),
-        traceIndex = trace.index,
-        name = isPie ? d[0].label : trace.name;
 
-    var text = d3.select(context).selectAll('text.legendtext')
-        .data([0]);
-    text.enter().append('text').classed('legendtext', true);
-    text.attr({
-        x: 40,
-        y: 0,
-        'data-unformatted': name
-    })
-    .style({
-        'text-anchor': 'start',
-        '-webkit-user-select': 'none',
-        '-moz-user-select': 'none',
-        '-ms-user-select': 'none',
-        'user-select': 'none'
-    })
-    .call(Drawing.font, fullLayout.legend.font)
-    .text(name);
-
-    function textLayout(s) {
-        Plotly.util.convertToTspans(s, function() {
-            if(td.firstRender) legend.repositionLegend(td, traces);
-        });
-        s.selectAll('tspan.line').attr({x: s.attr('x')});
-    }
-
-    if(td._context.editable && !isPie) {
-        text.call(Plotly.util.makeEditable)
-            .call(textLayout)
-            .on('edit', function(text) {
-                this.attr({'data-unformatted': text});
-                this.text(text)
-                    .call(textLayout);
-                if(!this.text()) text = ' \u0020\u0020 ';
-                Plotly.restyle(td, 'name', text, traceIndex);
-            });
-    }
-    else text.call(textLayout);
-};
-
-legend.draw = function(td) {
-    var fullLayout = td._fullLayout;
-
-    if(!fullLayout._infolayer || !td.calcdata) return;
-
-    var opts = fullLayout.legend,
-        legendData = fullLayout.showlegend && legend.getLegendData(td.calcdata, opts),
-        hiddenSlices = fullLayout.hiddenlabels || [];
-
-    if(!fullLayout.showlegend || !legendData.length) {
-        fullLayout._infolayer.selectAll('.legend').remove();
-        Plots.autoMargin(td, 'legend');
-        return;
-    }
-
-    if(typeof td.firstRender === 'undefined') td.firstRender = true;
-    else if(td.firstRender) td.firstRender = false;
-
-    var legendsvg = fullLayout._infolayer.selectAll('svg.legend')
-        .data([0]);
-    legendsvg.enter().append('svg')
-        .attr({
-            'class': 'legend',
-            'pointer-events': 'all'
-        });
-
-    var bg = legendsvg.selectAll('rect.bg')
-        .data([0]);
-    bg.enter().append('rect')
-        .attr({
-            'class': 'bg',
-            'shape-rendering': 'crispEdges'
-        })
-        .call(Color.stroke, opts.bordercolor)
-        .call(Color.fill, opts.bgcolor)
-        .style('stroke-width', opts.borderwidth + 'px');
-
-    var scrollBox = legendsvg.selectAll('g.scrollbox')
-        .data([0]);
-    scrollBox.enter().append('g')
-        .attr('class', 'scrollbox');
-    scrollBox.exit().remove();
-
-    var scrollBar = legendsvg.selectAll('rect.scrollbar')
-        .data([0]);
-    scrollBar.enter().append('rect')
-        .attr({
-            'class': 'scrollbar',
-            'rx': 20,
-            'ry': 2,
-            'width': 0,
-            'height': 0
-        })
-        .call(Color.fill, '#808BA4');
-
-    var groups = scrollBox.selectAll('g.groups')
-        .data(legendData);
-    groups.enter().append('g')
-        .attr('class', 'groups');
-    groups.exit().remove();
-
-    if(isGrouped(opts)) {
-        groups.attr('transform', function(d, i) {
-            return 'translate(0,' + i * opts.tracegroupgap + ')';
-        });
-    }
-
-    var traces = groups.selectAll('g.traces')
-        .data(Lib.identity);
-
-    traces.enter().append('g').attr('class', 'traces');
-    traces.exit().remove();
-
-    traces.call(legend.style)
-        .style('opacity', function(d) {
-            var trace = d[0].trace;
-            if(Plots.traceIs(trace, 'pie')) {
-                return hiddenSlices.indexOf(d[0].label) !== -1 ? 0.5 : 1;
-            } else {
-                return trace.visible === 'legendonly' ? 0.5 : 1;
-            }
-        })
-        .each(function(d, i) {
-            legend.texts(this, td, d, i, traces);
-
-            var traceToggle = d3.select(this).selectAll('rect')
-                .data([0]);
-            traceToggle.enter().append('rect')
-                .classed('legendtoggle', true)
-                .style('cursor', 'pointer')
-                .attr('pointer-events', 'all')
-                .call(Color.fill, 'rgba(0,0,0,0)');
-            traceToggle.on('click', function() {
-                if(td._dragged) return;
-
-                var fullData = td._fullData,
-                    trace = d[0].trace,
-                    legendgroup = trace.legendgroup,
-                    traceIndicesInGroup = [],
-                    tracei,
-                    newVisible;
-
-                if(Plots.traceIs(trace, 'pie')) {
-                    var thisLabel = d[0].label,
-                        newHiddenSlices = hiddenSlices.slice(),
-                        thisLabelIndex = newHiddenSlices.indexOf(thisLabel);
-
-                    if(thisLabelIndex === -1) newHiddenSlices.push(thisLabel);
-                    else newHiddenSlices.splice(thisLabelIndex, 1);
-
-                    Plotly.relayout(td, 'hiddenlabels', newHiddenSlices);
-                } else {
-                    if(legendgroup === '') {
-                        traceIndicesInGroup = [trace.index];
-                    } else {
-                        for(var i = 0; i < fullData.length; i++) {
-                            tracei = fullData[i];
-                            if(tracei.legendgroup === legendgroup) {
-                                traceIndicesInGroup.push(tracei.index);
-                            }
-                        }
-                    }
-
-                    newVisible = trace.visible === true ? 'legendonly' : true;
-                    Plotly.restyle(td, 'visible', newVisible, traceIndicesInGroup);
-                }
-            });
-        });
-
-    // Position and size the legend
-    legend.repositionLegend(td, traces);
-
-    // Scroll section must be executed after repositionLegend.
-    // It requires the legend width, height, x and y to position the scrollbox
-    // and these values are mutated in repositionLegend.
-    var gs = fullLayout._size,
-        lx = gs.l + gs.w * opts.x,
-        ly = gs.t + gs.h * (1-opts.y);
-
-    if(opts.xanchor === 'right' || (opts.xanchor === 'auto' && opts.x >= 2 / 3)) {
-        lx -= opts.width;
-    }
-    else if(opts.xanchor === 'center' || (opts.xanchor === 'auto' && opts.x > 1 / 3)) {
-        lx -= opts.width / 2;
-    }
-
-    if(opts.yanchor === 'bottom' || (opts.yanchor === 'auto' && opts.y <= 1 / 3)) {
-        ly -= opts.height;
-    }
-    else if(opts.yanchor === 'middle' || (opts.yanchor === 'auto' && opts.y < 2 / 3)) {
-        ly -= opts.height / 2;
-    }
-
-    // Deal with scrolling
-    var plotHeight = fullLayout.height - fullLayout.margin.b,
-        scrollheight = Math.min(plotHeight - ly, opts.height),
-        scrollPosition = scrollBox.attr('data-scroll') ? scrollBox.attr('data-scroll') : 0;
-
-    scrollBox.attr('transform', 'translate(0, ' + scrollPosition + ')');
-    bg.attr({
-        width: opts.width - 2 * opts.borderwidth,
-        height: scrollheight - 2 * opts.borderwidth,
-        x: opts.borderwidth,
-        y: opts.borderwidth
-    });
-
-    legendsvg.call(Drawing.setRect, lx, ly, opts.width, scrollheight);
-
-    // If scrollbar should be shown.
-    if(td.firstRender && opts.height - scrollheight > 0 && !td._context.staticPlot) {
-
-        bg.attr({ width: opts.width - 2 * opts.borderwidth + constants.scrollBarWidth });
-
-        legendsvg.node().addEventListener('wheel', function(e) {
-            e.preventDefault();
-            scrollHandler(e.deltaY / 20);
-        });
-
-        scrollBar.node().addEventListener('mousedown', function(e) {
-            e.preventDefault();
-
-            function mMove(e) {
-                if(e.buttons === 1) {
-                    scrollHandler(e.movementY);
-                }
-            }
-
-            function mUp() {
-                scrollBar.node().removeEventListener('mousemove', mMove);
-                window.removeEventListener('mouseup', mUp);
-            }
-
-            window.addEventListener('mousemove', mMove);
-            window.addEventListener('mouseup', mUp);
-        });
-
-        // Move scrollbar to starting position on the first render
-        scrollBar.call(
-            Drawing.setRect,
-            opts.width - (constants.scrollBarWidth + constants.scrollBarMargin),
-            constants.scrollBarMargin,
-            constants.scrollBarWidth,
-            constants.scrollBarHeight
-        );
-    }
-
-    function scrollHandler(delta) {
-
-        var scrollBarTrack = scrollheight - constants.scrollBarHeight - 2 * constants.scrollBarMargin,
-            translateY = scrollBox.attr('data-scroll'),
-            scrollBoxY = Lib.constrain(translateY - delta, Math.min(scrollheight - opts.height, 0), 0),
-            scrollBarY = -scrollBoxY / (opts.height - scrollheight) * scrollBarTrack + constants.scrollBarMargin;
-
-        scrollBox.attr('data-scroll', scrollBoxY);
-        scrollBox.attr('transform', 'translate(0, ' + scrollBoxY + ')');
-        scrollBar.call(
-            Drawing.setRect,
-            opts.width - (constants.scrollBarWidth + constants.scrollBarMargin),
-            scrollBarY,
-            constants.scrollBarWidth,
-            constants.scrollBarHeight
-        );
-    }
-
-    if(td._context.editable) {
-        var xf,
-            yf,
-            x0,
-            y0,
-            lw,
-            lh;
-
-        Fx.dragElement({
-            element: legendsvg.node(),
-            prepFn: function() {
-                x0 = Number(legendsvg.attr('x'));
-                y0 = Number(legendsvg.attr('y'));
-                lw = Number(legendsvg.attr('width'));
-                lh = Number(legendsvg.attr('height'));
-                Fx.setCursor(legendsvg);
-            },
-            moveFn: function(dx, dy) {
-                var gs = td._fullLayout._size;
-
-                legendsvg.call(Drawing.setPosition, x0+dx, y0+dy);
-
-                xf = Fx.dragAlign(x0+dx, lw, gs.l, gs.l+gs.w,
-                    opts.xanchor);
-                yf = Fx.dragAlign(y0+dy+lh, -lh, gs.t+gs.h, gs.t,
-                    opts.yanchor);
-
-                var csr = Fx.dragCursors(xf, yf,
-                    opts.xanchor, opts.yanchor);
-                Fx.setCursor(legendsvg, csr);
-            },
-            doneFn: function(dragged) {
-                Fx.setCursor(legendsvg);
-                if(dragged && xf !== undefined && yf !== undefined) {
-                    Plotly.relayout(td, {'legend.x': xf, 'legend.y': yf});
-                }
-            }
-        });
-    }
-};
-
-legend.repositionLegend = function(td, traces) {
-    var fullLayout = td._fullLayout,
-        gs = fullLayout._size,
-        opts = fullLayout.legend,
-        borderwidth = opts.borderwidth;
-
-    opts.width = 0,
-    opts.height = 0,
-
-    traces.each(function(d) {
-        var trace = d[0].trace,
-            g = d3.select(this),
-            bg = g.selectAll('.legendtoggle'),
-            text = g.selectAll('.legendtext'),
-            tspans = g.selectAll('.legendtext>tspan'),
-            tHeight = opts.font.size * 1.3,
-            tLines = tspans[0].length || 1,
-            tWidth = text.node() && Drawing.bBox(text.node()).width,
-            mathjaxGroup = g.select('g[class*=math-group]'),
-            textY,
-            tHeightFull;
-
-        if(!trace.showlegend) {
-            g.remove();
-            return;
-        }
-
-        if(mathjaxGroup.node()) {
-            var mathjaxBB = Drawing.bBox(mathjaxGroup.node());
-            tHeight = mathjaxBB.height;
-            tWidth = mathjaxBB.width;
-            mathjaxGroup.attr('transform','translate(0,' + (tHeight / 4) + ')');
-        }
-        else {
-            // approximation to height offset to center the font
-            // to avoid getBoundingClientRect
-            textY = tHeight * (0.3 + (1-tLines) / 2);
-            text.attr('y',textY);
-            tspans.attr('y',textY);
-        }
-
-        tHeightFull = Math.max(tHeight*tLines, 16) + 3;
-
-        g.attr('transform',
-            'translate(' + borderwidth + ',' +
-                (5 + borderwidth + opts.height + tHeightFull / 2) +
-            ')'
-        );
-        bg.attr({x: 0, y: -tHeightFull / 2, height: tHeightFull});
-
-        opts.height += tHeightFull;
-        opts.width = Math.max(opts.width, tWidth || 0);
-    });
-
-
-    opts.width += 45 + borderwidth * 2;
-    opts.height += 10 + borderwidth * 2;
-
-    if(isGrouped(opts)) opts.height += (opts._lgroupsLength-1) * opts.tracegroupgap;
-
-    traces.selectAll('.legendtoggle')
-        .attr('width', (td._context.editable ? 0 : opts.width) + 40);
-
-    // now position the legend. for both x,y the positions are recorded as
-    // fractions of the plot area (left, bottom = 0,0). Outside the plot
-    // area is allowed but position will be clipped to the page.
-    // values <1/3 align the low side at that fraction, 1/3-2/3 align the
-    // center at that fraction, >2/3 align the right at that fraction
-
-    var lx = gs.l + gs.w * opts.x,
-        ly = gs.t + gs.h * (1-opts.y);
-
-    var xanchor = 'left';
-    if(opts.xanchor === 'right' || (opts.xanchor === 'auto' && opts.x >= 2 / 3)) {
-        lx -= opts.width;
-        xanchor = 'right';
-    }
-    else if(opts.xanchor === 'center' || (opts.xanchor === 'auto' && opts.x > 1 / 3)) {
-        lx -= opts.width / 2;
-        xanchor = 'center';
-    }
-
-    var yanchor = 'top';
-    if(opts.yanchor === 'bottom' || (opts.yanchor === 'auto' && opts.y <= 1 / 3)) {
-        ly -= opts.height;
-        yanchor = 'bottom';
-    }
-    else if(opts.yanchor === 'middle' || (opts.yanchor === 'auto' && opts.y < 2 / 3)) {
-        ly -= opts.height / 2;
-        yanchor = 'middle';
-    }
-
-    // make sure we're only getting full pixels
-    opts.width = Math.ceil(opts.width);
-    opts.height = Math.ceil(opts.height);
-    lx = Math.round(lx);
-    ly = Math.round(ly);
+legend.draw = require('./draw');
 
 legend.style = require('./style');
-    // lastly check if the margin auto-expand has changed
-    Plots.autoMargin(td,'legend',{
-        x: opts.x,
-        y: opts.y,
-        l: opts.width * ({right: 1, center: 0.5}[xanchor] || 0),
-        r: opts.width * ({left: 1, center: 0.5}[xanchor] || 0),
-        b: opts.height * ({top: 1, middle: 0.5}[yanchor] || 0),
-        t: opts.height * ({bottom: 1, middle: 0.5}[yanchor] || 0)
-    });
-};

From aa13bfb5ed0417a2dd791c2548a0032275431cdb Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=C3=89tienne=20T=C3=A9treault-Pinard?= <etienne@plot.ly>
Date: Mon, 14 Mar 2016 14:59:28 -0400
Subject: [PATCH 07/22] lint

---
 src/components/legend/index.js    | 14 --------------
 src/plots/plots.js                | 11 +++++++----
 test/jasmine/tests/legend_test.js |  4 +++-
 3 files changed, 10 insertions(+), 19 deletions(-)

diff --git a/src/components/legend/index.js b/src/components/legend/index.js
index 91f19c4086b..4b033d1bad9 100644
--- a/src/components/legend/index.js
+++ b/src/components/legend/index.js
@@ -9,23 +9,9 @@
 
 'use strict';
 
-var Plotly = require('../../plotly');
-var d3 = require('d3');
-
-var Lib = require('../../lib');
-
-var Plots = require('../../plots/plots');
-var Fx = require('../../plots/cartesian/graph_interact');
-
-var Color = require('../color');
-var Drawing = require('../drawing');
-
-var subTypes = require('../../traces/scatter/subtypes');
-var styleOne = require('../../traces/pie/style_one');
 
 var legend = module.exports = {};
 
-var constants = require('./constants');
 legend.layoutAttributes = require('./attributes');
 
 legend.supplyLayoutDefaults = require('./defaults');
diff --git a/src/plots/plots.js b/src/plots/plots.js
index 6d3693b754c..990b715edc6 100644
--- a/src/plots/plots.js
+++ b/src/plots/plots.js
@@ -840,6 +840,7 @@ plots.sanitizeMargins = function(fullLayout) {
         margin.b = Math.floor(correction * margin.b);
     }
 };
+
 // called by legend and colorbar routines to see if we need to
 // expand the margins to show them
 // o is {x,l,r,y,t,b} where x and y are plot fractions,
@@ -874,17 +875,19 @@ plots.doAutoMargin = function(gd) {
     var fullLayout = gd._fullLayout;
     if(!fullLayout._size) fullLayout._size = {};
     if(!fullLayout._pushmargin) fullLayout._pushmargin = {};
+
     var gs = fullLayout._size,
         oldmargins = JSON.stringify(gs);
 
     // adjust margins for outside legends and colorbars
     // fullLayout.margin is the requested margin,
     // fullLayout._size has margins and plotsize after adjustment
-    var ml = Math.max(fullLayout.margin.l||0,0),
-        mr = Math.max(fullLayout.margin.r||0,0),
-        mt = Math.max(fullLayout.margin.t||0,0),
-        mb = Math.max(fullLayout.margin.b||0,0),
+    var ml = Math.max(fullLayout.margin.l || 0, 0),
+        mr = Math.max(fullLayout.margin.r || 0, 0),
+        mt = Math.max(fullLayout.margin.t || 0, 0),
+        mb = Math.max(fullLayout.margin.b || 0, 0),
         pm = fullLayout._pushmargin;
+
     if(fullLayout.margin.autoexpand!==false) {
         // fill in the requested margins
         pm.base = {
diff --git a/test/jasmine/tests/legend_test.js b/test/jasmine/tests/legend_test.js
index 58f10776d7e..34ef1e618a2 100644
--- a/test/jasmine/tests/legend_test.js
+++ b/test/jasmine/tests/legend_test.js
@@ -1,9 +1,11 @@
-var Legend = require('@src/components/legend');
 var Plots = require('@src/plots/plots');
 
+var Legend = require('@src/components/legend');
 var getLegendData = require('@src/components/legend/get_legend_data');
 var helpers = require('@src/components/legend/helpers');
 var anchorUtils = require('@src/components/legend/anchor_utils');
+
+
 describe('Test legend:', function() {
     'use strict';
 

From dcea0dd9a8ed4c1b616ecec0a5921db723a21d69 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=C3=89tienne=20T=C3=A9treault-Pinard?= <etienne@plot.ly>
Date: Tue, 15 Mar 2016 12:41:26 -0400
Subject: [PATCH 08/22] fix typo (function name)

---
 src/components/legend/anchor_utils.js | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/components/legend/anchor_utils.js b/src/components/legend/anchor_utils.js
index a4b19262239..7b5bde268f7 100644
--- a/src/components/legend/anchor_utils.js
+++ b/src/components/legend/anchor_utils.js
@@ -32,7 +32,7 @@ exports.isCenterAnchor = function isCenterAnchor(opts) {
     );
 };
 
-exports.isBottomAnchor = function isTopAnchor(opts) {
+exports.isBottomAnchor = function isBottomAnchor(opts) {
     return (
         opts.yanchor === 'bottom' ||
         (opts.yanchor === 'auto' && opts.y <= 1 / 3)

From a11e69890ed6e4688ba1cc70bd7ee401b4b7023a Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=C3=89tienne=20T=C3=A9treault-Pinard?= <etienne@plot.ly>
Date: Tue, 15 Mar 2016 12:42:07 -0400
Subject: [PATCH 09/22] lint (mostly infix spacing)

---
 src/components/legend/style.js | 28 ++++++++++++++++------------
 1 file changed, 16 insertions(+), 12 deletions(-)

diff --git a/src/components/legend/style.js b/src/components/legend/style.js
index a7e9f6a8fc9..8ff88fe3e2a 100644
--- a/src/components/legend/style.js
+++ b/src/components/legend/style.js
@@ -28,25 +28,25 @@ module.exports = function style(s) {
             .selectAll('g.legendfill')
                 .data([d]);
         fill.enter().append('g')
-            .classed('legendfill',true);
+            .classed('legendfill', true);
 
         var line = traceGroup
             .selectAll('g.legendlines')
                 .data([d]);
         line.enter().append('g')
-            .classed('legendlines',true);
+            .classed('legendlines', true);
 
         var symbol = traceGroup
             .selectAll('g.legendsymbols')
                 .data([d]);
         symbol.enter().append('g')
-            .classed('legendsymbols',true);
+            .classed('legendsymbols', true);
         symbol.style('opacity', d[0].trace.opacity);
 
         symbol.selectAll('g.legendpoints')
             .data([d])
           .enter().append('g')
-            .classed('legendpoints',true);
+            .classed('legendpoints', true);
     })
     .each(styleBars)
     .each(styleBoxes)
@@ -62,14 +62,14 @@ function styleLines(d) {
 
     var fill = d3.select(this).select('.legendfill').selectAll('path')
         .data(showFill ? [d] : []);
-    fill.enter().append('path').classed('js-fill',true);
+    fill.enter().append('path').classed('js-fill', true);
     fill.exit().remove();
     fill.attr('d', 'M5,0h30v6h-30z')
         .call(Drawing.fillGroupStyle);
 
     var line = d3.select(this).select('.legendlines').selectAll('path')
         .data(showLine ? [d] : []);
-    line.enter().append('path').classed('js-line',true)
+    line.enter().append('path').classed('js-line', true)
         .attr('d', 'M5,0h30');
     line.exit().remove();
     line.call(Drawing.lineGroupStyle);
@@ -161,20 +161,22 @@ function stylePoints(d) {
 
 function styleBars(d) {
     var trace = d[0].trace,
-        marker = trace.marker||{},
-        markerLine = marker.line||{},
+        marker = trace.marker || {},
+        markerLine = marker.line || {},
         barpath = d3.select(this).select('g.legendpoints')
             .selectAll('path.legendbar')
             .data(Plots.traceIs(trace, 'bar') ? [d] : []);
-    barpath.enter().append('path').classed('legendbar',true)
+    barpath.enter().append('path').classed('legendbar', true)
         .attr('d','M6,6H-6V-6H6Z')
-        .attr('transform','translate(20,0)');
+        .attr('transform', 'translate(20,0)');
     barpath.exit().remove();
     barpath.each(function(d) {
-        var w = (d.mlw+1 || markerLine.width+1) - 1,
+        var w = (d.mlw + 1 || markerLine.width + 1) - 1,
             p = d3.select(this);
+
         p.style('stroke-width',w+'px')
             .call(Color.fill, d.mc || marker.color);
+
         if(w) {
             p.call(Color.stroke, d.mlc || markerLine.color);
         }
@@ -192,10 +194,12 @@ function styleBoxes(d) {
         .attr('transform', 'translate(20,0)');
     pts.exit().remove();
     pts.each(function(d) {
-        var w = (d.lw+1 || trace.line.width+1) - 1,
+        var w = (d.lw + 1 || trace.line.width + 1) - 1,
             p = d3.select(this);
+
         p.style('stroke-width', w+'px')
             .call(Color.fill, d.fc || trace.fillcolor);
+
         if(w) {
             p.call(Color.stroke, d.lc || trace.line.color);
         }

From cdd7240ba26c372edc4f09349101786a39808d00 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=C3=89tienne=20T=C3=A9treault-Pinard?= <etienne@plot.ly>
Date: Tue, 15 Mar 2016 12:43:38 -0400
Subject: [PATCH 10/22] make legend element a <g> instead of nestead <svg>

---
 src/components/legend/draw.js | 36 +++++++++++++++++++----------------
 1 file changed, 20 insertions(+), 16 deletions(-)

diff --git a/src/components/legend/draw.js b/src/components/legend/draw.js
index b6db5c8188f..4ddd714a216 100644
--- a/src/components/legend/draw.js
+++ b/src/components/legend/draw.js
@@ -43,16 +43,18 @@ module.exports = function draw(gd) {
     if(typeof gd.firstRender === 'undefined') gd.firstRender = true;
     else if(gd.firstRender) gd.firstRender = false;
 
-    var legendsvg = fullLayout._infolayer.selectAll('svg.legend')
+    var legend = fullLayout._infolayer.selectAll('g.legend')
         .data([0]);
-    legendsvg.enter().append('svg')
+
+    legend.enter().append('g')
         .attr({
             'class': 'legend',
             'pointer-events': 'all'
         });
 
-    var bg = legendsvg.selectAll('rect.bg')
+    var bg = legend.selectAll('rect.bg')
         .data([0]);
+
     bg.enter().append('rect')
         .attr({
             'class': 'bg',
@@ -62,14 +64,16 @@ module.exports = function draw(gd) {
         .call(Color.fill, opts.bgcolor)
         .style('stroke-width', opts.borderwidth + 'px');
 
-    var scrollBox = legendsvg.selectAll('g.scrollbox')
+    var scrollBox = legend.selectAll('g.scrollbox')
         .data([0]);
+
     scrollBox.enter().append('g')
         .attr('class', 'scrollbox');
     scrollBox.exit().remove();
 
-    var scrollBar = legendsvg.selectAll('rect.scrollbar')
+    var scrollBar = legend.selectAll('rect.scrollbar')
         .data([0]);
+
     scrollBar.enter().append('rect')
         .attr({
             'class': 'scrollbar',
@@ -191,14 +195,14 @@ module.exports = function draw(gd) {
         y: opts.borderwidth
     });
 
-    legendsvg.call(Drawing.setRect, lx, ly, opts.width, scrollheight);
+    legend.attr('transform', 'translate(' + lx + ',' + ly + ')');
 
     // If scrollbar should be shown.
     if(gd.firstRender && opts.height - scrollheight > 0 && !gd._context.staticPlot) {
 
         bg.attr({ width: opts.width - 2 * opts.borderwidth + constants.scrollBarWidth });
 
-        legendsvg.node().addEventListener('wheel', function(e) {
+        legend.node().addEventListener('wheel', function(e) {
             e.preventDefault();
             scrollHandler(e.deltaY / 20);
         });
@@ -258,18 +262,18 @@ module.exports = function draw(gd) {
             lh;
 
         Fx.dragElement({
-            element: legendsvg.node(),
+            element: legend.node(),
             prepFn: function() {
-                x0 = Number(legendsvg.attr('x'));
-                y0 = Number(legendsvg.attr('y'));
-                lw = Number(legendsvg.attr('width'));
-                lh = Number(legendsvg.attr('height'));
-                Fx.setCursor(legendsvg);
+                x0 = Number(legend.attr('x'));
+                y0 = Number(legend.attr('y'));
+                lw = Number(legend.attr('width'));
+                lh = Number(legend.attr('height'));
+                Fx.setCursor(legend);
             },
             moveFn: function(dx, dy) {
                 var gs = gd._fullLayout._size;
 
-                legendsvg.call(Drawing.setPosition, x0+dx, y0+dy);
+                legend.call(Drawing.setPosition, x0+dx, y0+dy);
 
                 xf = Fx.dragAlign(x0+dx, lw, gs.l, gs.l+gs.w,
                     opts.xanchor);
@@ -278,10 +282,10 @@ module.exports = function draw(gd) {
 
                 var csr = Fx.dragCursors(xf, yf,
                     opts.xanchor, opts.yanchor);
-                Fx.setCursor(legendsvg, csr);
+                Fx.setCursor(legend, csr);
             },
             doneFn: function(dragged) {
-                Fx.setCursor(legendsvg);
+                Fx.setCursor(legend);
                 if(dragged && xf !== undefined && yf !== undefined) {
                     Plotly.relayout(gd, {'legend.x': xf, 'legend.y': yf});
                 }

From 7b393d43987dab29556ac204ffd2a670bea02f06 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=C3=89tienne=20T=C3=A9treault-Pinard?= <etienne@plot.ly>
Date: Tue, 15 Mar 2016 12:46:05 -0400
Subject: [PATCH 11/22] cropped legend element using clip-path on legend <g>

---
 src/components/legend/constants.js |  4 +++-
 src/components/legend/draw.js      | 36 +++++++++++++++++++++++++++++-
 2 files changed, 38 insertions(+), 2 deletions(-)

diff --git a/src/components/legend/constants.js b/src/components/legend/constants.js
index 346c5f34433..7aeca1e5099 100644
--- a/src/components/legend/constants.js
+++ b/src/components/legend/constants.js
@@ -12,5 +12,7 @@ module.exports = {
     scrollBarWidth: 4,
     scrollBarHeight: 20,
     scrollBarColor: '#808BA4',
-    scrollBarMargin: 4
+    scrollBarMargin: 4,
+
+    clipId: 'legend'
 };
diff --git a/src/components/legend/draw.js b/src/components/legend/draw.js
index 4ddd714a216..c021fcb21f5 100644
--- a/src/components/legend/draw.js
+++ b/src/components/legend/draw.js
@@ -197,10 +197,26 @@ module.exports = function draw(gd) {
 
     legend.attr('transform', 'translate(' + lx + ',' + ly + ')');
 
+    var clipPath = selectClipPath(gd);
+
+    clipPath.attr({
+        width: opts.width,
+        height: scrollheight,
+        x: 0,
+        y: 0
+    });
+
+    legend.call(Drawing.setClipUrl, constants.clipId);
+
     // If scrollbar should be shown.
     if(gd.firstRender && opts.height - scrollheight > 0 && !gd._context.staticPlot) {
+        bg.attr({
+            width: opts.width - 2 * opts.borderwidth + constants.scrollBarWidth
+        });
 
-        bg.attr({ width: opts.width - 2 * opts.borderwidth + constants.scrollBarWidth });
+        clipPath.attr({
+            width: opts.width + constants.scrollBarWidth
+        });
 
         legend.node().addEventListener('wheel', function(e) {
             e.preventDefault();
@@ -450,3 +466,21 @@ function repositionLegend(gd, traces) {
         t: opts.height * ({bottom: 1, middle: 0.5}[yanchor] || 0)
     });
 }
+
+function selectClipPath(gd) {
+    var container = gd._fullLayout._infolayer.node().parentNode;
+
+    var defs = d3.select(container).selectAll('defs')
+        .data([0]);
+
+    defs.enter().append('defs');
+
+    var clipPath = defs.selectAll('#' + constants.clipId)
+        .data([0]);
+
+    var path = clipPath.enter().append('clipPath')
+        .attr('id', constants.clipId)
+        .append('rect');
+
+    return path;
+}

From a7829cf902fad66431f29cddba1a4103928338df Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=C3=89tienne=20T=C3=A9treault-Pinard?= <etienne@plot.ly>
Date: Tue, 15 Mar 2016 12:46:59 -0400
Subject: [PATCH 12/22] rm useless .exit().remove() :

- the exit selection will always be empty
  as the joined data is always [0].
---
 src/components/legend/draw.js | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/src/components/legend/draw.js b/src/components/legend/draw.js
index c021fcb21f5..eff48cb9605 100644
--- a/src/components/legend/draw.js
+++ b/src/components/legend/draw.js
@@ -69,7 +69,6 @@ module.exports = function draw(gd) {
 
     scrollBox.enter().append('g')
         .attr('class', 'scrollbox');
-    scrollBox.exit().remove();
 
     var scrollBar = legend.selectAll('rect.scrollbar')
         .data([0]);
@@ -86,8 +85,10 @@ module.exports = function draw(gd) {
 
     var groups = scrollBox.selectAll('g.groups')
         .data(legendData);
+
     groups.enter().append('g')
         .attr('class', 'groups');
+
     groups.exit().remove();
 
     if(helpers.isGrouped(opts)) {
@@ -116,11 +117,13 @@ module.exports = function draw(gd) {
 
             var traceToggle = d3.select(this).selectAll('rect')
                 .data([0]);
+
             traceToggle.enter().append('rect')
                 .classed('legendtoggle', true)
                 .style('cursor', 'pointer')
                 .attr('pointer-events', 'all')
                 .call(Color.fill, 'rgba(0,0,0,0)');
+
             traceToggle.on('click', function() {
                 if(gd._dragged) return;
 
@@ -188,6 +191,7 @@ module.exports = function draw(gd) {
         scrollPosition = scrollBox.attr('data-scroll') ? scrollBox.attr('data-scroll') : 0;
 
     scrollBox.attr('transform', 'translate(0, ' + scrollPosition + ')');
+
     bg.attr({
         width: opts.width - 2 * opts.borderwidth,
         height: scrollheight - 2 * opts.borderwidth,

From 59b0c52972324fb76be44336f6d615138b18e1b8 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=C3=89tienne=20T=C3=A9treault-Pinard?= <etienne@plot.ly>
Date: Tue, 15 Mar 2016 16:31:33 -0400
Subject: [PATCH 13/22] robustify top-paper <defs>:

- append <defs> to toppaper in make-framework step
- use fullLayout._uid in legend <clipPath> id to avoid
  conflict on DOM queries.
---
 src/components/legend/constants.js |  4 +---
 src/components/legend/draw.js      | 31 ++++++++++--------------------
 src/plot_api/plot_api.js           |  3 +++
 3 files changed, 14 insertions(+), 24 deletions(-)

diff --git a/src/components/legend/constants.js b/src/components/legend/constants.js
index 7aeca1e5099..346c5f34433 100644
--- a/src/components/legend/constants.js
+++ b/src/components/legend/constants.js
@@ -12,7 +12,5 @@ module.exports = {
     scrollBarWidth: 4,
     scrollBarHeight: 20,
     scrollBarColor: '#808BA4',
-    scrollBarMargin: 4,
-
-    clipId: 'legend'
+    scrollBarMargin: 4
 };
diff --git a/src/components/legend/draw.js b/src/components/legend/draw.js
index eff48cb9605..8849829f9e9 100644
--- a/src/components/legend/draw.js
+++ b/src/components/legend/draw.js
@@ -27,6 +27,7 @@ var anchorUtils = require('./anchor_utils');
 
 module.exports = function draw(gd) {
     var fullLayout = gd._fullLayout;
+    var clipId = 'legend' + fullLayout._uid;
 
     if(!fullLayout._infolayer || !gd.calcdata) return;
 
@@ -36,6 +37,8 @@ module.exports = function draw(gd) {
 
     if(!fullLayout.showlegend || !legendData.length) {
         fullLayout._infolayer.selectAll('.legend').remove();
+        fullLayout._topdefs.select('#' + clipId).remove();
+
         Plots.autoMargin(gd, 'legend');
         return;
     }
@@ -52,6 +55,12 @@ module.exports = function draw(gd) {
             'pointer-events': 'all'
         });
 
+    var clipPath = fullLayout._topdefs.selectAll('#' + clipId)
+        .data([0])
+      .enter().append('clipPath')
+        .attr('id', clipId)
+        .append('rect');
+
     var bg = legend.selectAll('rect.bg')
         .data([0]);
 
@@ -201,8 +210,6 @@ module.exports = function draw(gd) {
 
     legend.attr('transform', 'translate(' + lx + ',' + ly + ')');
 
-    var clipPath = selectClipPath(gd);
-
     clipPath.attr({
         width: opts.width,
         height: scrollheight,
@@ -210,7 +217,7 @@ module.exports = function draw(gd) {
         y: 0
     });
 
-    legend.call(Drawing.setClipUrl, constants.clipId);
+    legend.call(Drawing.setClipUrl, clipId);
 
     // If scrollbar should be shown.
     if(gd.firstRender && opts.height - scrollheight > 0 && !gd._context.staticPlot) {
@@ -470,21 +477,3 @@ function repositionLegend(gd, traces) {
         t: opts.height * ({bottom: 1, middle: 0.5}[yanchor] || 0)
     });
 }
-
-function selectClipPath(gd) {
-    var container = gd._fullLayout._infolayer.node().parentNode;
-
-    var defs = d3.select(container).selectAll('defs')
-        .data([0]);
-
-    defs.enter().append('defs');
-
-    var clipPath = defs.selectAll('#' + constants.clipId)
-        .data([0]);
-
-    var path = clipPath.enter().append('clipPath')
-        .attr('id', constants.clipId)
-        .append('rect');
-
-    return path;
-}
diff --git a/src/plot_api/plot_api.js b/src/plot_api/plot_api.js
index 1753264abf2..38ee77db540 100644
--- a/src/plot_api/plot_api.js
+++ b/src/plot_api/plot_api.js
@@ -2585,6 +2585,9 @@ function makePlotFramework(gd) {
     fullLayout._defs = fullLayout._paper.append('defs')
         .attr('id', 'defs-' + fullLayout._uid);
 
+    fullLayout._topdefs = fullLayout._toppaper.append('defs')
+        .attr('id', 'defs-' + fullLayout._uid);
+
     fullLayout._draggers = fullLayout._paper.append('g')
         .classed('draglayer', true);
 

From 00078079be6c7f6a8cdcdd96722c2c9d63e84ad9 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=C3=89tienne=20T=C3=A9treault-Pinard?= <etienne@plot.ly>
Date: Tue, 15 Mar 2016 16:33:00 -0400
Subject: [PATCH 14/22] merge top-paper <defs> into main svg on to-svg step

---
 src/snapshot/tosvg.js | 17 ++++++++++++++---
 1 file changed, 14 insertions(+), 3 deletions(-)

diff --git a/src/snapshot/tosvg.js b/src/snapshot/tosvg.js
index 8f312bdf870..cf6fe17b1c7 100644
--- a/src/snapshot/tosvg.js
+++ b/src/snapshot/tosvg.js
@@ -89,10 +89,21 @@ module.exports = function toSVG(gd, format) {
     // assumes everything in toppaper is a group, and if it's empty (like hoverlayer)
     // we can ignore it
     if(fullLayout._toppaper) {
-        var topGroups = fullLayout._toppaper.node().childNodes,
-            topGroup;
+        var topDefs = fullLayout._topdefs.node().childNodes;
+
+        for(i = 0; i < topDefs.length; i++) {
+            var topDef = topDefs[i];
+
+            fullLayout._defs.node().appendChild(topDef);
+        }
+
+        fullLayout._topdefs.remove();
+
+        var topGroups = fullLayout._toppaper.node().childNodes;
+
         for(i = 0; i < topGroups.length; i++) {
-            topGroup = topGroups[i];
+            var topGroup = topGroups[i];
+
             if(topGroup.childNodes.length) svg.node().appendChild(topGroup);
         }
     }

From 335bb4021339a56f03c84fd50911765f03c3b162 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=C3=89tienne=20T=C3=A9treault-Pinard?= <etienne@plot.ly>
Date: Tue, 15 Mar 2016 16:34:28 -0400
Subject: [PATCH 15/22] add in-house getBBox test asset:

- needed to determine bounding box of clipped element,
  as the stock SVG getBBox method does not take clip path
  into consideration
- use it legend scroll test to determine the height of the legend
---
 test/jasmine/assets/get_bbox.js          | 35 ++++++++++++++++++++++++
 test/jasmine/tests/legend_scroll_test.js | 11 +++++---
 2 files changed, 42 insertions(+), 4 deletions(-)
 create mode 100644 test/jasmine/assets/get_bbox.js

diff --git a/test/jasmine/assets/get_bbox.js b/test/jasmine/assets/get_bbox.js
new file mode 100644
index 00000000000..f1df4dd660d
--- /dev/null
+++ b/test/jasmine/assets/get_bbox.js
@@ -0,0 +1,35 @@
+'use strict';
+
+var d3 = require('d3');
+
+
+// In-house implementation of SVG getBBox that takes clip paths into account
+module.exports = function getBBox(element) {
+    var elementBBox = element.getBBox();
+
+    var s = d3.select(element);
+    var clipPathAttr = s.attr('clip-path');
+
+    if(!clipPathAttr) return elementBBox;
+
+    // only supports 'url(#<id>)' at the moment
+    var clipPathId = clipPathAttr.substring(5, clipPathAttr.length-1);
+    var clipPath = d3.select('#' + clipPathId).node();
+
+    return minBBox(elementBBox, clipPath.getBBox());
+};
+
+function minBBox(bbox1, bbox2) {
+    var keys = ['x', 'y', 'width', 'height'];
+    var out = {};
+
+    function min(attr) {
+        return Math.min(bbox1[attr], bbox2[attr]);
+    }
+
+    keys.forEach(function(key) {
+        out[key] = min(key);
+    });
+
+    return out;
+}
diff --git a/test/jasmine/tests/legend_scroll_test.js b/test/jasmine/tests/legend_scroll_test.js
index e8f02a1661e..ccc818bf0b7 100644
--- a/test/jasmine/tests/legend_scroll_test.js
+++ b/test/jasmine/tests/legend_scroll_test.js
@@ -1,11 +1,14 @@
 var Plotly = require('@lib/index');
 var createGraph = require('../assets/create_graph_div');
 var destroyGraph = require('../assets/destroy_graph_div');
+var getBBox = require('../assets/get_bbox');
 var mock = require('../../image/mocks/legend_scroll.json');
 
+
 describe('The legend', function() {
-    var gd,
-        legend;
+    'use strict';
+
+    var gd, legend;
 
     describe('when plotted with many traces', function() {
         beforeEach(function() {
@@ -17,7 +20,7 @@ describe('The legend', function() {
         afterEach(destroyGraph);
 
         it('should not exceed plot height', function() {
-            var legendHeight = legend.getAttribute('height'),
+            var legendHeight = getBBox(legend).height,
                 plotHeight = gd._fullLayout.height - gd._fullLayout.margin.t - gd._fullLayout.margin.b;
 
             expect(+legendHeight).toBe(plotHeight);
@@ -53,7 +56,7 @@ describe('The legend', function() {
 
         it('should scale the scrollbar movement from top to bottom', function() {
             var scrollBar = legend.getElementsByClassName('scrollbar')[0],
-                legendHeight = legend.getAttribute('height');
+                legendHeight = getBBox(legend).height;
 
             // The scrollbar is 20px tall and has 4px margins
 

From 857878b78794e6ef5015eaed2644769ace0eceb3 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=C3=89tienne=20T=C3=A9treault-Pinard?= <etienne@plot.ly>
Date: Tue, 15 Mar 2016 16:35:21 -0400
Subject: [PATCH 16/22] add legend and clip path count test,

- to ensure that they are properly removed when
  'showlegend' is relayout'ed to false.
---
 test/jasmine/tests/legend_scroll_test.js | 43 ++++++++++++++++++++++--
 1 file changed, 41 insertions(+), 2 deletions(-)

diff --git a/test/jasmine/tests/legend_scroll_test.js b/test/jasmine/tests/legend_scroll_test.js
index ccc818bf0b7..5bdf05d8e62 100644
--- a/test/jasmine/tests/legend_scroll_test.js
+++ b/test/jasmine/tests/legend_scroll_test.js
@@ -10,6 +10,16 @@ describe('The legend', function() {
 
     var gd, legend;
 
+    function countLegendGroups(gd) {
+        return gd._fullLayout._toppaper.selectAll('g.legend').size();
+    }
+
+    function countLegendClipPaths(gd) {
+        var uid = gd._fullLayout._uid;
+
+        return gd._fullLayout._topdefs.selectAll('#legend' + uid).size();
+    }
+
     describe('when plotted with many traces', function() {
         beforeEach(function() {
             gd = createGraph();
@@ -66,6 +76,18 @@ describe('The legend', function() {
             legend.dispatchEvent(scrollTo(10000));
             expect(+scrollBar.getAttribute('y')).toBe(legendHeight - 4 - 20);
         });
+
+        it('should be removed from DOM when \'showlegend\' is relayout\'ed to false', function(done) {
+            expect(countLegendGroups(gd)).toBe(1);
+            expect(countLegendClipPaths(gd)).toBe(1);
+
+            Plotly.relayout(gd, 'showlegend', false).then(function() {
+                expect(countLegendGroups(gd)).toBe(0);
+                expect(countLegendClipPaths(gd)).toBe(0);
+
+                done();
+            });
+        });
     });
 
     describe('when plotted with few traces', function() {
@@ -73,7 +95,11 @@ describe('The legend', function() {
 
         beforeEach(function() {
             gd = createGraph();
-            Plotly.plot(gd, [{ x: [1,2,3], y: [2,3,4], name: 'Test' }], {});
+
+            var data = [{ x: [1,2,3], y: [2,3,4], name: 'Test' }];
+            var layout = { showlegend: true };
+
+            Plotly.plot(gd, data, layout);
         });
 
         afterEach(destroyGraph);
@@ -81,7 +107,20 @@ describe('The legend', function() {
         it('should not display the scrollbar', function() {
             var scrollBar = document.getElementsByClassName('scrollbar')[0];
 
-            expect(scrollBar).toBeUndefined();
+            expect(+scrollBar.getAttribute('width')).toBe(0);
+            expect(+scrollBar.getAttribute('height')).toBe(0);
+        });
+
+        it('should be removed from DOM when \'showlegend\' is relayout\'ed to false', function(done) {
+            expect(countLegendGroups(gd)).toBe(1);
+            expect(countLegendClipPaths(gd)).toBe(1);
+
+            Plotly.relayout(gd, 'showlegend', false).then(function() {
+                expect(countLegendGroups(gd)).toBe(0);
+                expect(countLegendClipPaths(gd)).toBe(0);
+
+                done();
+            });
         });
     });
 });

From dcd0cb578a109d4975fdf21a2acba61abe4af028 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=C3=89tienne=20T=C3=A9treault-Pinard?= <etienne@plot.ly>
Date: Tue, 15 Mar 2016 16:36:32 -0400
Subject: [PATCH 17/22] update baseline:

- sub-pixel diff due to legend clipping
---
 .../baselines/gl3d_projection-traces.png      | Bin 40573 -> 40578 bytes
 1 file changed, 0 insertions(+), 0 deletions(-)

diff --git a/test/image/baselines/gl3d_projection-traces.png b/test/image/baselines/gl3d_projection-traces.png
index 49470a45b2599b5eacd71705f4a54ee11c24d5bc..1de40e957a82af8abb9bc455c894763eda160937 100644
GIT binary patch
literal 40578
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
PJm6=GIc8O9;T`)AC!FJ2

literal 40573
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
TEg>sd0DR2xR>svQykh?bkeNsa


From 8440ef1135862fc3e15128d293697771a1a3a3ad Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=C3=89tienne=20T=C3=A9treault-Pinard?= <etienne@plot.ly>
Date: Tue, 15 Mar 2016 17:22:08 -0400
Subject: [PATCH 18/22] add fallback for FF in getBBox test asset:

- getBBox fails when call on a clipPath node in FF
- use DOM attributes as fallback to grab the bounding box
---
 test/jasmine/assets/get_bbox.js | 33 ++++++++++++++++++++++++++++-----
 1 file changed, 28 insertions(+), 5 deletions(-)

diff --git a/test/jasmine/assets/get_bbox.js b/test/jasmine/assets/get_bbox.js
index f1df4dd660d..e651f414dd9 100644
--- a/test/jasmine/assets/get_bbox.js
+++ b/test/jasmine/assets/get_bbox.js
@@ -2,6 +2,8 @@
 
 var d3 = require('d3');
 
+var ATTRS = ['x', 'y', 'width', 'height'];
+
 
 // In-house implementation of SVG getBBox that takes clip paths into account
 module.exports = function getBBox(element) {
@@ -14,21 +16,42 @@ module.exports = function getBBox(element) {
 
     // only supports 'url(#<id>)' at the moment
     var clipPathId = clipPathAttr.substring(5, clipPathAttr.length-1);
-    var clipPath = d3.select('#' + clipPathId).node();
+    var clipBBox = getClipBBox(clipPathId);
 
-    return minBBox(elementBBox, clipPath.getBBox());
+    return minBBox(elementBBox, clipBBox);
 };
 
+function getClipBBox(clipPathId) {
+    var clipPath = d3.select('#' + clipPathId);
+    var clipBBox;
+
+    try {
+        // this line throws an error in FF (38 and 45 at least)
+        clipBBox = clipPath.node().getBBox();
+    }
+    catch(e) {
+        // use DOM attributes as fallback
+        var path = d3.select(clipPath.node().firstChild);
+
+        clipBBox = {};
+
+        ATTRS.forEach(function(attr) {
+            clipBBox[attr] = path.attr(attr);
+        });
+    }
+
+    return clipBBox;
+}
+
 function minBBox(bbox1, bbox2) {
-    var keys = ['x', 'y', 'width', 'height'];
     var out = {};
 
     function min(attr) {
         return Math.min(bbox1[attr], bbox2[attr]);
     }
 
-    keys.forEach(function(key) {
-        out[key] = min(key);
+    ATTRS.forEach(function(attr) {
+        out[attr] = min(attr);
     });
 
     return out;

From 757ffdf95040bd2611acf9c068efdd7a2e59644c Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=C3=89tienne=20T=C3=A9treault-Pinard?= <etienne@plot.ly>
Date: Wed, 16 Mar 2016 13:41:20 -0400
Subject: [PATCH 19/22] lint (define variable in block)

---
 src/components/legend/defaults.js | 5 ++---
 1 file changed, 2 insertions(+), 3 deletions(-)

diff --git a/src/components/legend/defaults.js b/src/components/legend/defaults.js
index f5f8a7ea3be..eb95148ce13 100644
--- a/src/components/legend/defaults.js
+++ b/src/components/legend/defaults.js
@@ -21,11 +21,10 @@ module.exports = function legendDefaults(layoutIn, layoutOut, fullData) {
         containerOut = layoutOut.legend = {};
 
     var visibleTraces = 0,
-        defaultOrder = 'normal',
-        trace;
+        defaultOrder = 'normal';
 
     for(var i = 0; i < fullData.length; i++) {
-        trace = fullData[i];
+        var trace = fullData[i];
 
         if(helpers.legendGetsTrace(trace)) {
             visibleTraces++;

From 196d7dc27543b64d716f196d646a7296cf71471b Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=C3=89tienne=20T=C3=A9treault-Pinard?= <etienne@plot.ly>
Date: Wed, 16 Mar 2016 13:43:24 -0400
Subject: [PATCH 20/22] change top-paper <defs> id to 'topdefs' + uid:

- that way ids remain unique on page
- rm special <defs> merge block in to-svg step
---
 src/plot_api/plot_api.js | 2 +-
 src/snapshot/tosvg.js    | 8 --------
 2 files changed, 1 insertion(+), 9 deletions(-)

diff --git a/src/plot_api/plot_api.js b/src/plot_api/plot_api.js
index 38ee77db540..eeea7c0c1f5 100644
--- a/src/plot_api/plot_api.js
+++ b/src/plot_api/plot_api.js
@@ -2586,7 +2586,7 @@ function makePlotFramework(gd) {
         .attr('id', 'defs-' + fullLayout._uid);
 
     fullLayout._topdefs = fullLayout._toppaper.append('defs')
-        .attr('id', 'defs-' + fullLayout._uid);
+        .attr('id', 'topdefs-' + fullLayout._uid);
 
     fullLayout._draggers = fullLayout._paper.append('g')
         .classed('draglayer', true);
diff --git a/src/snapshot/tosvg.js b/src/snapshot/tosvg.js
index cf6fe17b1c7..7cf715abc18 100644
--- a/src/snapshot/tosvg.js
+++ b/src/snapshot/tosvg.js
@@ -89,15 +89,7 @@ module.exports = function toSVG(gd, format) {
     // assumes everything in toppaper is a group, and if it's empty (like hoverlayer)
     // we can ignore it
     if(fullLayout._toppaper) {
-        var topDefs = fullLayout._topdefs.node().childNodes;
 
-        for(i = 0; i < topDefs.length; i++) {
-            var topDef = topDefs[i];
-
-            fullLayout._defs.node().appendChild(topDef);
-        }
-
-        fullLayout._topdefs.remove();
 
         var topGroups = fullLayout._toppaper.node().childNodes;
 

From 860e6471f223a9611e28575a8854d334f7613393 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=C3=89tienne=20T=C3=A9treault-Pinard?= <etienne@plot.ly>
Date: Wed, 16 Mar 2016 13:45:00 -0400
Subject: [PATCH 21/22] make copy of top-paper childNodes array-like:

- as childNodes prop gets mutated in top-group loop
---
 src/snapshot/tosvg.js | 11 ++++++-----
 1 file changed, 6 insertions(+), 5 deletions(-)

diff --git a/src/snapshot/tosvg.js b/src/snapshot/tosvg.js
index 7cf715abc18..ec8801fc1d7 100644
--- a/src/snapshot/tosvg.js
+++ b/src/snapshot/tosvg.js
@@ -85,13 +85,14 @@ module.exports = function toSVG(gd, format) {
             .appendChild(geoFramework.node());
     }
 
-    // now that we've got the 3d images in the right layer, add top items above them
-    // assumes everything in toppaper is a group, and if it's empty (like hoverlayer)
-    // we can ignore it
+    // now that we've got the 3d images in the right layer,
+    // add top items above them assumes everything in toppaper is either
+    // a group or a defs, and if it's empty (like hoverlayer) we can ignore it.
     if(fullLayout._toppaper) {
+        var nodes = fullLayout._toppaper.node().childNodes;
 
-
-        var topGroups = fullLayout._toppaper.node().childNodes;
+        // make copy of nodes as childNodes prop gets mutated in loop below
+        var topGroups = Array.prototype.slice.call(nodes);
 
         for(i = 0; i < topGroups.length; i++) {
             var topGroup = topGroups[i];

From dbaf34076f3bd23e7ba0ed4a73ff8d92501b5a09 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=C3=89tienne=20T=C3=A9treault-Pinard?= <etienne@plot.ly>
Date: Wed, 16 Mar 2016 14:31:06 -0400
Subject: [PATCH 22/22] make user-select-none CSS class:

- use it in legend text
- rm now useless user-select purge step in to-svg
---
 build/plotcss.js              | 1 +
 src/components/legend/draw.js | 9 ++-------
 src/css/_base.scss            | 4 ++++
 src/snapshot/tosvg.js         | 7 +------
 4 files changed, 8 insertions(+), 13 deletions(-)

diff --git a/build/plotcss.js b/build/plotcss.js
index 4b412c9eee6..169edfce295 100644
--- a/build/plotcss.js
+++ b/build/plotcss.js
@@ -8,6 +8,7 @@ var rules = {
     "X a": "text-decoration:none;",
     "X a:hover": "text-decoration:none;",
     "X .crisp": "shape-rendering:crispEdges;",
+    "X .user-select-none": "-webkit-user-select:none;-moz-user-select:none;-ms-user-select:none;-o-user-select:none;user-select:none;",
     "X svg": "overflow:hidden;",
     "X svg a": "fill:#447adb;",
     "X svg a:hover": "fill:#3c6dc5;",
diff --git a/src/components/legend/draw.js b/src/components/legend/draw.js
index 8849829f9e9..8fe9f62d35f 100644
--- a/src/components/legend/draw.js
+++ b/src/components/legend/draw.js
@@ -336,13 +336,8 @@ function drawTexts(context, gd, d, i, traces) {
         y: 0,
         'data-unformatted': name
     })
-    .style({
-        'text-anchor': 'start',
-        '-webkit-user-select': 'none',
-        '-moz-user-select': 'none',
-        '-ms-user-select': 'none',
-        'user-select': 'none'
-    })
+    .style('text-anchor', 'start')
+    .classed('user-select-none', true)
     .call(Drawing.font, fullLayout.legend.font)
     .text(name);
 
diff --git a/src/css/_base.scss b/src/css/_base.scss
index b7c2b66aeaf..3551948be0a 100644
--- a/src/css/_base.scss
+++ b/src/css/_base.scss
@@ -22,6 +22,10 @@ a {
 
 .crisp { shape-rendering: crispEdges; }
 
+.user-select-none {
+    @include vendor('user-select', none);
+}
+
 //Required for IE11. Other browsers set this by default.
 svg { overflow: hidden; }
 
diff --git a/src/snapshot/tosvg.js b/src/snapshot/tosvg.js
index ec8801fc1d7..14c36df1ce3 100644
--- a/src/snapshot/tosvg.js
+++ b/src/snapshot/tosvg.js
@@ -107,12 +107,7 @@ module.exports = function toSVG(gd, format) {
     svg.node().style.background = '';
 
     svg.selectAll('text')
-        .attr({'data-unformatted': null})
-        .style({
-            '-webkit-user-select': null,
-            '-moz-user-select': null,
-            '-ms-user-select': null
-        })
+        .attr('data-unformatted', null)
         .each(function() {
             // hidden text is pre-formatting mathjax, the browser ignores it but it can still confuse batik
             var txt = d3.select(this);