split up bars index

Author: etpinard

src/traces/bars/arrays_to_calcdata.js

@@ -0,0 +1,26 @@
+/**
+* Copyright 2012-2015, 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 mergeArray = require('../../lib').mergeArray;
+
+
+// arrayOk attributes, merge them into calcdata array
+module.exports = function arraysToCalcdata(cd) {
+    var trace = cd[0].trace,
+        marker = trace.marker,
+        markerLine = marker.line;
+
+    mergeArray(trace.text, cd, 'tx');
+    mergeArray(marker.opacity, cd, 'mo');
+    mergeArray(marker.color, cd, 'mc');
+    mergeArray(markerLine.color, cd, 'mlc');
+    mergeArray(markerLine.width, cd, 'mlw');
+};

src/traces/bars/calc.js

@@ -0,0 +1,55 @@
+/**
+* Copyright 2012-2015, 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 isNumeric = require('fast-isnumeric');
+
+var Plotly = require('../../plotly');
+
+
+module.exports = function calc(gd, trace) {
+    // depending on bar direction, set position and size axes
+    // and data ranges
+    // note: this logic for choosing orientation is
+    // duplicated in graph_obj->setstyles
+
+    var xa = Plotly.Axes.getFromId(gd, trace.xaxis||'x'),
+        ya = Plotly.Axes.getFromId(gd, trace.yaxis||'y'),
+        orientation = trace.orientation || ((trace.x && !trace.y) ? 'h' : 'v'),
+        pos, size, i;
+
+    if(orientation==='h') {
+        size = xa.makeCalcdata(trace, 'x');
+        pos = ya.makeCalcdata(trace, 'y');
+    }
+    else {
+        size = ya.makeCalcdata(trace, 'y');
+        pos = xa.makeCalcdata(trace, 'x');
+    }
+
+    // create the "calculated data" to plot
+    var serieslen = Math.min(pos.length, size.length),
+        cd = [];
+    for(i=0; i<serieslen; i++) {
+        if((isNumeric(pos[i]) && isNumeric(size[i]))) {
+            cd.push({p: pos[i], s: size[i], b: 0});
+        }
+    }
+
+    // auto-z and autocolorscale if applicable
+    if(Plotly.Colorscale.hasColorscale(trace, 'marker')) {
+        Plotly.Colorscale.calc(trace, trace.marker.color, 'marker', 'c');
+    }
+    if(Plotly.Colorscale.hasColorscale(trace, 'marker.line')) {
+        Plotly.Colorscale.calc(trace, trace.marker.line.color, 'marker.line', 'c');
+    }
+
+    return cd;
+};

src/traces/bars/defaults.js

@@ -0,0 +1,64 @@
+/**
+* Copyright 2012-2015, 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 Plotly = require('../../plotly');
+var Lib = require('../../lib');
+var Color = require('../../components/color');
+
+var histogramSupplyDefaults = require('../histogram/defaults');
+var handleXYDefaults = require('../scatter/xy_defaults');
+var errorBarsSupplyDefaults = require('../../components/errorbars/defaults');
+
+var attributes = require('./attributes');
+
+
+module.exports = function(traceIn, traceOut, defaultColor, layout) {
+    function coerce(attr, dflt) {
+        return Lib.coerce(traceIn, traceOut, attributes, attr, dflt);
+    }
+
+    if(traceOut.type === 'histogram') {
+        // x, y, and orientation are coerced in the histogram supplyDefaults
+        // (along with histogram-specific attributes)
+        histogramSupplyDefaults(traceIn, traceOut);
+        if(!traceOut.visible) return;
+    }
+    else {
+        var len = handleXYDefaults(traceIn, traceOut, coerce);
+        if(!len) {
+            traceOut.visible = false;
+            return;
+        }
+
+        coerce('orientation', (traceOut.x && !traceOut.y) ? 'h' : 'v');
+    }
+
+    coerce('marker.color', defaultColor);
+    if(Plotly.Colorscale.hasColorscale(traceIn, 'marker')) {
+        Plotly.Colorscale.handleDefaults(
+            traceIn, traceOut, layout, coerce, {prefix: 'marker.', cLetter: 'c'}
+        );
+    }
+
+    coerce('marker.line.color', Plotly.Color.defaultLine);
+    if(Plotly.Colorscale.hasColorscale(traceIn, 'marker.line')) {
+        Plotly.Colorscale.handleDefaults(
+            traceIn, traceOut, layout, coerce, {prefix: 'marker.line.', cLetter: 'c'}
+        );
+    }
+
+    coerce('marker.line.width', 0);
+    coerce('text');
+
+    // override defaultColor for error bars with defaultLine
+    errorBarsSupplyDefaults(traceIn, traceOut, Color.defaultLine, {axis: 'y'});
+    errorBarsSupplyDefaults(traceIn, traceOut, Color.defaultLine, {axis: 'x', inherit: 'y'});
+};

src/traces/bars/hover.js

@@ -0,0 +1,88 @@
+/**
+* Copyright 2012-2015, 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 Plotly = require('../../plotly');
+var Color = require('../../components/color');
+
+
+module.exports = function hoverPoints(pointData, xval, yval, hovermode) {
+    var cd = pointData.cd,
+        trace = cd[0].trace,
+        t = cd[0].t,
+        xa = pointData.xa,
+        ya = pointData.ya,
+        barDelta = (hovermode==='closest') ?
+            t.barwidth/2 : t.dbar*(1-xa._td._fullLayout.bargap)/2,
+        barPos;
+
+    if(hovermode!=='closest') barPos = function(di) { return di.p; };
+    else if(trace.orientation==='h') barPos = function(di) { return di.y; };
+    else barPos = function(di) { return di.x; };
+
+    var dx, dy;
+    if(trace.orientation==='h') {
+        dx = function(di){
+            // add a gradient so hovering near the end of a
+            // bar makes it a little closer match
+            return Plotly.Fx.inbox(di.b-xval, di.x-xval) + (di.x-xval)/(di.x-di.b);
+        };
+        dy = function(di){
+            var centerPos = barPos(di) - yval;
+            return Plotly.Fx.inbox(centerPos - barDelta, centerPos + barDelta);
+        };
+    }
+    else {
+        dy = function(di){
+            return Plotly.Fx.inbox(di.b-yval, di.y-yval) + (di.y-yval)/(di.y-di.b);
+        };
+        dx = function(di){
+            var centerPos = barPos(di) - xval;
+            return Plotly.Fx.inbox(centerPos - barDelta, centerPos + barDelta);
+        };
+    }
+
+    var distfn = Plotly.Fx.getDistanceFunction(hovermode, dx, dy);
+    Plotly.Fx.getClosest(cd, distfn, pointData);
+
+    // skip the rest (for this trace) if we didn't find a close point
+    if(pointData.index===false) return;
+
+    // the closest data point
+    var di = cd[pointData.index],
+        mc = di.mcc || trace.marker.color,
+        mlc = di.mlcc || trace.marker.line.color,
+        mlw = di.mlw || trace.marker.line.width;
+    if(Color.opacity(mc)) pointData.color = mc;
+    else if(Color.opacity(mlc) && mlw) pointData.color = mlc;
+
+    if(trace.orientation==='h') {
+        pointData.x0 = pointData.x1 = xa.c2p(di.x, true);
+        pointData.xLabelVal = di.s;
+
+        pointData.y0 = ya.c2p(barPos(di) - barDelta, true);
+        pointData.y1 = ya.c2p(barPos(di) + barDelta, true);
+        pointData.yLabelVal = di.p;
+    }
+    else {
+        pointData.y0 = pointData.y1 = ya.c2p(di.y,true);
+        pointData.yLabelVal = di.s;
+
+        pointData.x0 = xa.c2p(barPos(di) - barDelta, true);
+        pointData.x1 = xa.c2p(barPos(di) + barDelta, true);
+        pointData.xLabelVal = di.p;
+    }
+
+    if(di.tx) pointData.text = di.tx;
+
+    Plotly.ErrorBars.hoverInfo(di, trace, pointData);
+
+    return [pointData];
+};