mdarray-sol 0.1.0-java

data/node_modules/dc/src/heatmap.js

@@ -0,0 +1,378 @@
+/**
+ * A heat map is matrix that represents the values of two dimensions of data using colors.
+ * @class heatMap
+ * @memberof dc
+ * @mixes dc.colorMixin
+ * @mixes dc.marginMixin
+ * @mixes dc.baseMixin
+ * @example
+ * // create a heat map under #chart-container1 element using the default global chart group
+ * var heatMap1 = dc.heatMap('#chart-container1');
+ * // create a heat map under #chart-container2 element using chart group A
+ * var heatMap2 = dc.heatMap('#chart-container2', 'chartGroupA');
+ * @param {String|node|d3.selection} parent - Any valid
+ * {@link https://github.com/mbostock/d3/wiki/Selections#selecting-elements d3 single selector} specifying
+ * a dom block element such as a div; or a dom element or d3 selection.
+ * @param {String} [chartGroup] - The name of the chart group this chart instance should be placed in.
+ * Interaction with a chart will only trigger events and redraws within the chart's group.
+ * @return {dc.heatMap}
+ */
+dc.heatMap = function (parent, chartGroup) {
+
+    var DEFAULT_BORDER_RADIUS = 6.75;
+
+    var _chartBody;
+
+    var _cols;
+    var _rows;
+    var _xBorderRadius = DEFAULT_BORDER_RADIUS;
+    var _yBorderRadius = DEFAULT_BORDER_RADIUS;
+
+    var _chart = dc.colorMixin(dc.marginMixin(dc.baseMixin({})));
+    _chart._mandatoryAttributes(['group']);
+    _chart.title(_chart.colorAccessor());
+
+    var _colsLabel = function (d) {
+        return d;
+    };
+    var _rowsLabel = function (d) {
+        return d;
+    };
+
+    /**
+     * Set or get the column label function. The chart class uses this function to render
+     * column labels on the X axis. It is passed the column name.
+     * @method colsLabel
+     * @memberof dc.heatMap
+     * @instance
+     * @example
+     * // the default label function just returns the name
+     * chart.colsLabel(function(d) { return d; });
+     * @param  {Function} [labelFunction=function(d) { return d; }]
+     * @return {Function}
+     * @return {dc.heatMap}
+     */
+    _chart.colsLabel = function (labelFunction) {
+        if (!arguments.length) {
+            return _colsLabel;
+        }
+        _colsLabel = labelFunction;
+        return _chart;
+    };
+
+    /**
+     * Set or get the row label function. The chart class uses this function to render
+     * row labels on the Y axis. It is passed the row name.
+     * @method rowsLabel
+     * @memberof dc.heatMap
+     * @instance
+     * @example
+     * // the default label function just returns the name
+     * chart.rowsLabel(function(d) { return d; });
+     * @param  {Function} [labelFunction=function(d) { return d; }]
+     * @return {Function}
+     * @return {dc.heatMap}
+     */
+    _chart.rowsLabel = function (labelFunction) {
+        if (!arguments.length) {
+            return _rowsLabel;
+        }
+        _rowsLabel = labelFunction;
+        return _chart;
+    };
+
+    var _xAxisOnClick = function (d) { filterAxis(0, d); };
+    var _yAxisOnClick = function (d) { filterAxis(1, d); };
+    var _boxOnClick = function (d) {
+        var filter = d.key;
+        dc.events.trigger(function () {
+            _chart.filter(filter);
+            _chart.redrawGroup();
+        });
+    };
+
+    function filterAxis (axis, value) {
+        var cellsOnAxis = _chart.selectAll('.box-group').filter(function (d) {
+            return d.key[axis] === value;
+        });
+        var unfilteredCellsOnAxis = cellsOnAxis.filter(function (d) {
+            return !_chart.hasFilter(d.key);
+        });
+        dc.events.trigger(function () {
+            if (unfilteredCellsOnAxis.empty()) {
+                cellsOnAxis.each(function (d) {
+                    _chart.filter(d.key);
+                });
+            } else {
+                unfilteredCellsOnAxis.each(function (d) {
+                    _chart.filter(d.key);
+                });
+            }
+            _chart.redrawGroup();
+        });
+    }
+
+    dc.override(_chart, 'filter', function (filter) {
+        if (!arguments.length) {
+            return _chart._filter();
+        }
+
+        return _chart._filter(dc.filters.TwoDimensionalFilter(filter));
+    });
+
+    function uniq (d, i, a) {
+        return !i || a[i - 1] !== d;
+    }
+
+    /**
+     * Gets or sets the values used to create the rows of the heatmap, as an array. By default, all
+     * the values will be fetched from the data using the value accessor, and they will be sorted in
+     * ascending order.
+     * @method rows
+     * @memberof dc.heatMap
+     * @instance
+     * @param  {Array<String|Number>} [rows]
+     * @return {Array<String|Number>}
+     * @return {dc.heatMap}
+     */
+    _chart.rows = function (rows) {
+        if (arguments.length) {
+            _rows = rows;
+            return _chart;
+        }
+        if (_rows) {
+            return _rows;
+        }
+        var rowValues = _chart.data().map(_chart.valueAccessor());
+        rowValues.sort(d3.ascending);
+        return d3.scale.ordinal().domain(rowValues.filter(uniq));
+    };
+
+    /**
+     * Gets or sets the keys used to create the columns of the heatmap, as an array. By default, all
+     * the values will be fetched from the data using the key accessor, and they will be sorted in
+     * ascending order.
+     * @method cols
+     * @memberof dc.heatMap
+     * @instance
+     * @param  {Array<String|Number>} [cols]
+     * @return {Array<String|Number>}
+     * @return {dc.heatMap}
+     */
+    _chart.cols = function (cols) {
+        if (arguments.length) {
+            _cols = cols;
+            return _chart;
+        }
+        if (_cols) {
+            return _cols;
+        }
+        var colValues = _chart.data().map(_chart.keyAccessor());
+        colValues.sort(d3.ascending);
+        return d3.scale.ordinal().domain(colValues.filter(uniq));
+    };
+
+    _chart._doRender = function () {
+        _chart.resetSvg();
+
+        _chartBody = _chart.svg()
+            .append('g')
+            .attr('class', 'heatmap')
+            .attr('transform', 'translate(' + _chart.margins().left + ',' + _chart.margins().top + ')');
+
+        return _chart._doRedraw();
+    };
+
+    _chart._doRedraw = function () {
+        var rows = _chart.rows(),
+            cols = _chart.cols(),
+            rowCount = rows.domain().length,
+            colCount = cols.domain().length,
+            boxWidth = Math.floor(_chart.effectiveWidth() / colCount),
+            boxHeight = Math.floor(_chart.effectiveHeight() / rowCount);
+
+        cols.rangeRoundBands([0, _chart.effectiveWidth()]);
+        rows.rangeRoundBands([_chart.effectiveHeight(), 0]);
+
+        var boxes = _chartBody.selectAll('g.box-group').data(_chart.data(), function (d, i) {
+            return _chart.keyAccessor()(d, i) + '\0' + _chart.valueAccessor()(d, i);
+        });
+        var gEnter = boxes.enter().append('g')
+            .attr('class', 'box-group');
+
+        gEnter.append('rect')
+            .attr('class', 'heat-box')
+            .attr('fill', 'white')
+            .on('click', _chart.boxOnClick());
+
+        if (_chart.renderTitle()) {
+            gEnter.append('title');
+            boxes.selectAll('title').text(_chart.title());
+        }
+
+        dc.transition(boxes.selectAll('rect'), _chart.transitionDuration())
+            .attr('x', function (d, i) { return cols(_chart.keyAccessor()(d, i)); })
+            .attr('y', function (d, i) { return rows(_chart.valueAccessor()(d, i)); })
+            .attr('rx', _xBorderRadius)
+            .attr('ry', _yBorderRadius)
+            .attr('fill', _chart.getColor)
+            .attr('width', boxWidth)
+            .attr('height', boxHeight);
+
+        boxes.exit().remove();
+
+        var gCols = _chartBody.selectAll('g.cols');
+        if (gCols.empty()) {
+            gCols = _chartBody.append('g').attr('class', 'cols axis');
+        }
+        var gColsText = gCols.selectAll('text').data(cols.domain());
+        gColsText.enter().append('text')
+              .attr('x', function (d) { return cols(d) + boxWidth / 2; })
+              .style('text-anchor', 'middle')
+              .attr('y', _chart.effectiveHeight())
+              .attr('dy', 12)
+              .on('click', _chart.xAxisOnClick())
+              .text(_chart.colsLabel());
+        dc.transition(gColsText, _chart.transitionDuration())
+               .text(_chart.colsLabel())
+               .attr('x', function (d) { return cols(d) + boxWidth / 2; })
+               .attr('y', _chart.effectiveHeight());
+        gColsText.exit().remove();
+        var gRows = _chartBody.selectAll('g.rows');
+        if (gRows.empty()) {
+            gRows = _chartBody.append('g').attr('class', 'rows axis');
+        }
+        var gRowsText = gRows.selectAll('text').data(rows.domain());
+        gRowsText.enter().append('text')
+              .attr('dy', 6)
+              .style('text-anchor', 'end')
+              .attr('x', 0)
+              .attr('dx', -2)
+              .on('click', _chart.yAxisOnClick())
+              .text(_chart.rowsLabel());
+        dc.transition(gRowsText, _chart.transitionDuration())
+              .text(_chart.rowsLabel())
+              .attr('y', function (d) { return rows(d) + boxHeight / 2; });
+        gRowsText.exit().remove();
+
+        if (_chart.hasFilter()) {
+            _chart.selectAll('g.box-group').each(function (d) {
+                if (_chart.isSelectedNode(d)) {
+                    _chart.highlightSelected(this);
+                } else {
+                    _chart.fadeDeselected(this);
+                }
+            });
+        } else {
+            _chart.selectAll('g.box-group').each(function () {
+                _chart.resetHighlight(this);
+            });
+        }
+        return _chart;
+    };
+
+    /**
+     * Gets or sets the handler that fires when an individual cell is clicked in the heatmap.
+     * By default, filtering of the cell will be toggled.
+     * @method boxOnClick
+     * @memberof dc.heatMap
+     * @instance
+     * @example
+     * // default box on click handler
+     * chart.boxOnClick(function (d) {
+     *     var filter = d.key;
+     *     dc.events.trigger(function () {
+     *         _chart.filter(filter);
+     *         _chart.redrawGroup();
+     *     });
+     * });
+     * @param  {Function} [handler]
+     * @return {Function}
+     * @return {dc.heatMap}
+     */
+    _chart.boxOnClick = function (handler) {
+        if (!arguments.length) {
+            return _boxOnClick;
+        }
+        _boxOnClick = handler;
+        return _chart;
+    };
+
+    /**
+     * Gets or sets the handler that fires when a column tick is clicked in the x axis.
+     * By default, if any cells in the column are unselected, the whole column will be selected,
+     * otherwise the whole column will be unselected.
+     * @method xAxisOnClick
+     * @memberof dc.heatMap
+     * @instance
+     * @param  {Function} [handler]
+     * @return {Function}
+     * @return {dc.heatMap}
+     */
+    _chart.xAxisOnClick = function (handler) {
+        if (!arguments.length) {
+            return _xAxisOnClick;
+        }
+        _xAxisOnClick = handler;
+        return _chart;
+    };
+
+    /**
+     * Gets or sets the handler that fires when a row tick is clicked in the y axis.
+     * By default, if any cells in the row are unselected, the whole row will be selected,
+     * otherwise the whole row will be unselected.
+     * @method yAxisOnClick
+     * @memberof dc.heatMap
+     * @instance
+     * @param  {Function} [handler]
+     * @return {Function}
+     * @return {dc.heatMap}
+     */
+    _chart.yAxisOnClick = function (handler) {
+        if (!arguments.length) {
+            return _yAxisOnClick;
+        }
+        _yAxisOnClick = handler;
+        return _chart;
+    };
+
+    /**
+     * Gets or sets the X border radius.  Set to 0 to get full rectangles.
+     * @method xBorderRadius
+     * @memberof dc.heatMap
+     * @instance
+     * @param  {Number} [xBorderRadius=6.75]
+     * @return {Number}
+     * @return {dc.heatMap}
+     */
+    _chart.xBorderRadius = function (xBorderRadius) {
+        if (!arguments.length) {
+            return _xBorderRadius;
+        }
+        _xBorderRadius = xBorderRadius;
+        return _chart;
+    };
+
+    /**
+     * Gets or sets the Y border radius.  Set to 0 to get full rectangles.
+     * @method yBorderRadius
+     * @memberof dc.heatMap
+     * @instance
+     * @param  {Number} [yBorderRadius=6.75]
+     * @return {Number}
+     * @return {dc.heatMap}
+     */
+    _chart.yBorderRadius = function (yBorderRadius) {
+        if (!arguments.length) {
+            return _yBorderRadius;
+        }
+        _yBorderRadius = yBorderRadius;
+        return _chart;
+    };
+
+    _chart.isSelectedNode = function (d) {
+        return _chart.hasFilter(d.key);
+    };
+
+    return _chart.anchor(parent, chartGroup);
+};

data/node_modules/dc/src/legend.js

@@ -0,0 +1,277 @@
+/**
+ * Legend is a attachable widget that can be added to other dc charts to render horizontal legend
+ * labels.
+ *
+ * Examples:
+ * - {@link http://dc-js.github.com/dc.js/ Nasdaq 100 Index}
+ * - {@link http://dc-js.github.com/dc.js/crime/index.html Canadian City Crime Stats}
+ * @class legend
+ * @memberof dc
+ * @example
+ * chart.legend(dc.legend().x(400).y(10).itemHeight(13).gap(5))
+ * @return {dc.legend}
+ */
+dc.legend = function () {
+    var LABEL_GAP = 2;
+
+    var _legend = {},
+        _parent,
+        _x = 0,
+        _y = 0,
+        _itemHeight = 12,
+        _gap = 5,
+        _horizontal = false,
+        _legendWidth = 560,
+        _itemWidth = 70,
+        _autoItemWidth = false,
+        _legendText = dc.pluck('name');
+
+    var _g;
+
+    _legend.parent = function (p) {
+        if (!arguments.length) {
+            return _parent;
+        }
+        _parent = p;
+        return _legend;
+    };
+
+    _legend.render = function () {
+        _parent.svg().select('g.dc-legend').remove();
+        _g = _parent.svg().append('g')
+            .attr('class', 'dc-legend')
+            .attr('transform', 'translate(' + _x + ',' + _y + ')');
+        var legendables = _parent.legendables();
+
+        var itemEnter = _g.selectAll('g.dc-legend-item')
+            .data(legendables)
+            .enter()
+            .append('g')
+            .attr('class', 'dc-legend-item')
+            .on('mouseover', function (d) {
+                _parent.legendHighlight(d);
+            })
+            .on('mouseout', function (d) {
+                _parent.legendReset(d);
+            })
+            .on('click', function (d) {
+                d.chart.legendToggle(d);
+            });
+
+        _g.selectAll('g.dc-legend-item')
+            .classed('fadeout', function (d) {
+                return d.chart.isLegendableHidden(d);
+            });
+
+        if (legendables.some(dc.pluck('dashstyle'))) {
+            itemEnter
+                .append('line')
+                .attr('x1', 0)
+                .attr('y1', _itemHeight / 2)
+                .attr('x2', _itemHeight)
+                .attr('y2', _itemHeight / 2)
+                .attr('stroke-width', 2)
+                .attr('stroke-dasharray', dc.pluck('dashstyle'))
+                .attr('stroke', dc.pluck('color'));
+        } else {
+            itemEnter
+                .append('rect')
+                .attr('width', _itemHeight)
+                .attr('height', _itemHeight)
+                .attr('fill', function (d) {return d ? d.color : 'blue';});
+        }
+
+        itemEnter.append('text')
+                .text(_legendText)
+                .attr('x', _itemHeight + LABEL_GAP)
+                .attr('y', function () {
+                    return _itemHeight / 2 + (this.clientHeight ? this.clientHeight : 13) / 2 - 2;
+                });
+
+        var _cumulativeLegendTextWidth = 0;
+        var row = 0;
+        itemEnter.attr('transform', function (d, i) {
+            if (_horizontal) {
+                var translateBy = 'translate(' + _cumulativeLegendTextWidth + ',' + row * legendItemHeight() + ')';
+                var itemWidth   = _autoItemWidth === true ? this.getBBox().width + _gap : _itemWidth;
+
+                if ((_cumulativeLegendTextWidth + itemWidth) >= _legendWidth) {
+                    ++row ;
+                    _cumulativeLegendTextWidth = 0 ;
+                } else {
+                    _cumulativeLegendTextWidth += itemWidth;
+                }
+                return translateBy;
+            } else {
+                return 'translate(0,' + i * legendItemHeight() + ')';
+            }
+        });
+    };
+
+    function legendItemHeight () {
+        return _gap + _itemHeight;
+    }
+
+    /**
+     * Set or get x coordinate for legend widget.
+     * @method x
+     * @memberof dc.legend
+     * @instance
+     * @param  {Number} [x=0]
+     * @return {Number}
+     * @return {dc.legend}
+     */
+    _legend.x = function (x) {
+        if (!arguments.length) {
+            return _x;
+        }
+        _x = x;
+        return _legend;
+    };
+
+    /**
+     * Set or get y coordinate for legend widget.
+     * @method y
+     * @memberof dc.legend
+     * @instance
+     * @param  {Number} [y=0]
+     * @return {Number}
+     * @return {dc.legend}
+     */
+    _legend.y = function (y) {
+        if (!arguments.length) {
+            return _y;
+        }
+        _y = y;
+        return _legend;
+    };
+
+    /**
+     * Set or get gap between legend items.
+     * @method gap
+     * @memberof dc.legend
+     * @instance
+     * @param  {Number} [gap=5]
+     * @return {Number}
+     * @return {dc.legend}
+     */
+    _legend.gap = function (gap) {
+        if (!arguments.length) {
+            return _gap;
+        }
+        _gap = gap;
+        return _legend;
+    };
+
+    /**
+     * Set or get legend item height.
+     * @method itemHeight
+     * @memberof dc.legend
+     * @instance
+     * @param  {Number} [itemHeight=12]
+     * @return {Number}
+     * @return {dc.legend}
+     */
+    _legend.itemHeight = function (itemHeight) {
+        if (!arguments.length) {
+            return _itemHeight;
+        }
+        _itemHeight = itemHeight;
+        return _legend;
+    };
+
+    /**
+     * Position legend horizontally instead of vertically.
+     * @method horizontal
+     * @memberof dc.legend
+     * @instance
+     * @param  {Boolean} [horizontal=false]
+     * @return {Boolean}
+     * @return {dc.legend}
+     */
+    _legend.horizontal = function (horizontal) {
+        if (!arguments.length) {
+            return _horizontal;
+        }
+        _horizontal = horizontal;
+        return _legend;
+    };
+
+    /**
+     * Maximum width for horizontal legend.
+     * @method legendWidth
+     * @memberof dc.legend
+     * @instance
+     * @param  {Number} [legendWidth=500]
+     * @return {Number}
+     * @return {dc.legend}
+     */
+    _legend.legendWidth = function (legendWidth) {
+        if (!arguments.length) {
+            return _legendWidth;
+        }
+        _legendWidth = legendWidth;
+        return _legend;
+    };
+
+    /**
+     * legendItem width for horizontal legend.
+     * @method itemWidth
+     * @memberof dc.legend
+     * @instance
+     * @param  {Number} [itemWidth=70]
+     * @return {Number}
+     * @return {dc.legend}
+     */
+    _legend.itemWidth = function (itemWidth) {
+        if (!arguments.length) {
+            return _itemWidth;
+        }
+        _itemWidth = itemWidth;
+        return _legend;
+    };
+
+    /**
+     * Turn automatic width for legend items on or off. If true, {@link dc.legend#itemWidth itemWidth} is ignored.
+     * This setting takes into account {@link dc.legend#gap gap}.
+     * @method autoItemWidth
+     * @memberof dc.legend
+     * @instance
+     * @param  {Boolean} [autoItemWidth=false]
+     * @return {Boolean}
+     * @return {dc.legend}
+     */
+    _legend.autoItemWidth = function (autoItemWidth) {
+        if (!arguments.length) {
+            return _autoItemWidth;
+        }
+        _autoItemWidth = autoItemWidth;
+        return _legend;
+    };
+
+    /**
+    #### .legendText([legendTextFunction])
+    Set or get the legend text function. The legend widget uses this function to render
+    the legend text on each item. If no function is specified the legend widget will display
+    the names associated with each group.
+
+    Default: dc.pluck('name')
+
+    ```js
+    // create numbered legend items
+    chart.legend(dc.legend().legendText(function(d, i) { return i + '. ' + d.name; }))
+
+    // create legend displaying group counts
+    chart.legend(dc.legend().legendText(function(d) { return d.name + ': ' d.data; }))
+    ```
+    **/
+    _legend.legendText = function (_) {
+        if (!arguments.length) {
+            return _legendText;
+        }
+        _legendText = _;
+        return _legend;
+    };
+
+    return _legend;
+};