/*

* Copyright 2012 the original author or authors.

* Licensed under the Apache License, Version 2.0 (the "License");

* You may obtain a copy of the License at

*

* http://www.apache.org/licenses/LICENSE-2.0

*

* Unless required by applicable law or agreed to in writing, software

* distributed under the License is distributed on an "AS IS" BASIS,

* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

* See the License for the specific language governing permissions and

* limitations under the License.

*/

dc = {

version: "1.0.0",

constants : {

CHART_CLASS: "dc-chart",

DEBUG_GROUP_CLASS: "debug",

STACK_CLASS: "stack",

DESELECTED_CLASS: "deselected",

SELECTED_CLASS: "selected",

NODE_INDEX_NAME: "__index__",

GROUP_INDEX_NAME: "__group_index__",

DEFAULT_CHART_GROUP: "__default_chart_group__",

EVENT_DELAY: 40

},

_renderlet : null

};

dc.chartRegistry = function() {

// chartGroup:string => charts:array

var _chartMap = {};

this.has = function(chart) {

for (var e in _chartMap) {

if (_chartMap[e].indexOf(chart) >= 0)

return true;

}

return false;

};

function initializeChartGroup(group) {

if (!group)

group = dc.constants.DEFAULT_CHART_GROUP;

if (!_chartMap[group])

_chartMap[group] = [];

return group;

}

this.register = function(chart, group) {

group = initializeChartGroup(group);

_chartMap[group].push(chart);

};

this.clear = function() {

_chartMap = {};

};

this.list = function(group) {

group = initializeChartGroup(group);

return _chartMap[group];

};

return this;

}();

dc.registerChart = function(chart, group) {

dc.chartRegistry.register(chart, group);

};

dc.hasChart = function(chart) {

return dc.chartRegistry.has(chart);

};

dc.deregisterAllCharts = function() {

dc.chartRegistry.clear();

};

dc.filterAll = function(group) {

var charts = dc.chartRegistry.list(group);

for (var i = 0; i < charts.length; ++i) {

charts[i].filterAll();

}

};

dc.renderAll = function(group) {

var charts = dc.chartRegistry.list(group);

for (var i = 0; i < charts.length; ++i) {

charts[i].render();

}

if(dc._renderlet !== null)

dc._renderlet(group);

};

dc.redrawAll = function(group) {

var charts = dc.chartRegistry.list(group);

for (var i = 0; i < charts.length; ++i) {

charts[i].redraw();

}

if(dc._renderlet !== null)

dc._renderlet(group);

};

dc.transition = function(selections, duration, callback) {

if (duration <= 0 || duration === undefined)

return selections;

var s = selections

.transition()

.duration(duration);

if (callback instanceof Function) {

callback(s);

}

return s;

};

dc.units = {};

dc.units.integers = function(s, e) {

return new Array(Math.abs(e - s));

};

dc.round = {};

dc.round.floor = function(n) {

return Math.floor(n);

};

dc.round.ceil = function(n) {

return Math.ceil(n);

};

dc.round.round = function(n) {

return Math.round(n);

};

dc.override = function(obj, functionName, newFunction) {

var existingFunction = obj[functionName];

obj[functionName] = function() {

var expression = "newFunction(";

for (var i = 0; i < arguments.length; ++i)

expression += "argument[" + i + "],";

expression += "existingFunction);";

return eval(expression);

};

};

dc.renderlet = function(_){

if(!arguments.length) return dc._renderlet;

dc._renderlet = _;

return dc;

};

dc.instanceOfChart = function (o) {

return o instanceof Object && o.__dc_flag__;

};

dc.errors = {};

dc.errors.Exception = function(msg) {

var _msg = msg != null ? msg : "Unexpected internal error";

this.message = _msg;

this.toString = function(){

return _msg;

};

};

dc.errors.InvalidStateException = function() {

dc.errors.Exception.apply(this, arguments);

};dc.dateFormat = d3.time.format("%m/%d/%Y");

dc.printers = {};

dc.printers.filter = function(filter) {

var s = "";

if (filter) {

if (filter instanceof Array) {

if (filter.length >= 2)

s = "[" + printSingleValue(filter[0]) + " -> " + printSingleValue(filter[1]) + "]";

else if (filter.length >= 1)

s = printSingleValue(filter[0]);

} else {

s = printSingleValue(filter)

}

}

return s;

};

function printSingleValue(filter) {

var s = "" + filter;

if (filter instanceof Date)

s = dc.dateFormat(filter);

else if (typeof(filter) == "string")

s = filter;

else if (typeof(filter) == "number")

s = Math.round(filter);

return s;

}

dc.utils = {};

dc.utils.add = function(l, r) {

if (l instanceof Date) {

var d = new Date();

d.setTime(l.getTime());

d.setDate(l.getDate() + r);

return d;

} else {

return l + r;

}

};

dc.utils.subtract = function(l, r) {

if (l instanceof Date) {

var d = new Date();

d.setTime(l.getTime());

d.setDate(l.getDate() - r);

return d;

} else {

return l - r;

}

};

dc.utils.GroupStack = function() {

var _dataPointMatrix = [];

var _groups = [];

var _defaultAccessor;

function initializeDataPointRow(x) {

if (!_dataPointMatrix[x])

_dataPointMatrix[x] = [];

}

this.setDataPoint = function(x, y, data) {

initializeDataPointRow(x);

_dataPointMatrix[x][y] = data;

};

this.getDataPoint = function(x, y) {

initializeDataPointRow(x);

var dataPoint = _dataPointMatrix[x][y];

if (dataPoint == undefined)

dataPoint = 0;

return dataPoint;

};

this.addGroup = function(group, retriever) {

if (!retriever)

retriever = _defaultAccessor;

_groups.push([group, retriever]);

return _groups.length - 1;

};

this.getGroupByIndex = function(index) {

return _groups[index][0];

};

this.getAccessorByIndex = function(index) {

return _groups[index][1];

};

this.size = function() {

return _groups.length;

};

this.clear = function() {

_dataPointMatrix = [];

_groups = [];

};

this.setDefaultAccessor = function(retriever) {

_defaultAccessor = retriever;

};

};

dc.utils.groupMax = function(group, accessor) {

return d3.max(group.all(), function(e) {

return accessor(e);

});

};

dc.utils.groupMin = function(group, accessor) {

return d3.min(group.all(), function(e) {

return accessor(e);

});

};

dc.utils.nameToId = function(name){

return name.toLowerCase().replace(/[\s]/g, "_").replace(/[\.']/g, "");

};

dc.events = {

current: null

};

dc.events.trigger = function(closure, delay) {

if (!delay){

closure();

return;

}

dc.events.current = closure;

setTimeout(function() {

if (closure == dc.events.current)

closure();

}, delay);

};

dc.cumulative = {};

dc.cumulative.Base = function() {

this._keyIndex = [];

this._map = {};

this.sanitizeKey = function(key) {

key = key + "";

return key;

};

this.clear = function() {

this._keyIndex = [];

this._map = {};

};

this.size = function() {

return this._keyIndex.length;

};

this.getValueByKey = function(key) {

key = this.sanitizeKey(key);

var value = this._map[key];

return value;

};

this.setValueByKey = function(key, value) {

key = this.sanitizeKey(key);

return this._map[key] = value;

};

this.indexOfKey = function(key) {

key = this.sanitizeKey(key);

return this._keyIndex.indexOf(key);

};

this.addToIndex = function(key) {

key = this.sanitizeKey(key);

this._keyIndex.push(key);

};

this.getKeyByIndex = function(index) {

return this._keyIndex[index];

};

};

dc.cumulative.Sum = function() {

dc.cumulative.Base.apply(this, arguments);

this.add = function(key, value) {

if (value == null)

value = 0;

if (this.getValueByKey(key) == null) {

this.addToIndex(key);

this.setValueByKey(key, value);

} else {

this.setValueByKey(key, this.getValueByKey(key) + value);

}

};

this.minus = function(key, value) {

this.setValueByKey(key, this.getValueByKey(key) - value);

};

this.cumulativeSum = function(key) {

var keyIndex = this.indexOfKey(key);

if (keyIndex < 0) return 0;

var cumulativeValue = 0;

for (var i = 0; i <= keyIndex; ++i) {

var k = this.getKeyByIndex(i);

cumulativeValue += this.getValueByKey(k);

}

return cumulativeValue;

};

};

dc.cumulative.Sum.prototype = new dc.cumulative.Base();

dc.cumulative.CountUnique = function() {

dc.cumulative.Base.apply(this, arguments);

function hashSize(hash) {

var size = 0, key;

for (key in hash) {

if (hash.hasOwnProperty(key)) size++;

}

return size;

}

this.add = function(key, e) {

if (this.getValueByKey(key) == null) {

this.setValueByKey(key, {});

this.addToIndex(key);

}

if (e != null) {

if (this.getValueByKey(key)[e] == null)

this.getValueByKey(key)[e] = 0;

this.getValueByKey(key)[e] += 1;

}

};

this.minus = function(key, e) {

this.getValueByKey(key)[e] -= 1;

if (this.getValueByKey(key)[e] <= 0)

delete this.getValueByKey(key)[e];

};

this.count = function(key) {

return hashSize(this.getValueByKey(key));

};

this.cumulativeCount = function(key) {

var keyIndex = this.indexOfKey(key);

if (keyIndex < 0) return 0;

var cumulativeCount = 0;

for (var i = 0; i <= keyIndex; ++i) {

var k = this.getKeyByIndex(i);

cumulativeCount += this.count(k);

}

return cumulativeCount;

};

};

dc.cumulative.CountUnique.prototype = new dc.cumulative.Base();

dc.baseChart = function(_chart) {

_chart.__dc_flag__ = true;

var _dimension;

var _group;

var _anchor;

var _root;

var _svg;

var _width = 200, _height = 200;

var _keyAccessor = function(d) {

return d.key;

};

var _valueAccessor = function(d) {

return d.value;

};

var _label = function(d) {

return d.key;

};

var _renderLabel = false;

var _title = function(d) {

return d.key + ": " + d.value;

};

var _renderTitle = false;

var _transitionDuration = 750;

var _filterPrinter = dc.printers.filter;

var _renderlets = [];

var _chartGroup = dc.constants.DEFAULT_CHART_GROUP;

_chart.width = function(w) {

if (!arguments.length) return _width;

_width = w;

return _chart;

};

_chart.height = function(h) {

if (!arguments.length) return _height;

_height = h;

return _chart;

};

_chart.dimension = function(d) {

if (!arguments.length) return _dimension;

_dimension = d;

return _chart;

};

_chart.group = function(g) {

if (!arguments.length) return _group;

_group = g;

return _chart;

};

_chart.orderedGroup = function() {

return _group.order(function(p) {

return p.key;

});

};

_chart.filterAll = function() {

return _chart.filter(null);

};

_chart.dataAreSet = function() {

return _dimension != undefined && _group != undefined;

};

_chart.select = function(s) {

return _root.select(s);

};

_chart.selectAll = function(s) {

return _root.selectAll(s);

};

_chart.anchor = function(a, chartGroup) {

if (!arguments.length) return _anchor;

if (dc.instanceOfChart(a)) {

_anchor = a.anchor();

_root = a.root();

} else {

_anchor = a;

_root = d3.select(_anchor);

_root.classed(dc.constants.CHART_CLASS, true);

dc.registerChart(_chart, chartGroup);

}

_chartGroup = chartGroup;

return _chart;

};

_chart.root = function(r) {

if (!arguments.length) return _root;

_root = r;

return _chart;

};

_chart.svg = function(_) {

if (!arguments.length) return _svg;

_svg = _;

return _chart;

};

_chart.resetSvg = function() {

_chart.select("svg").remove();

return _chart.generateSvg();

};

_chart.generateSvg = function() {

_svg = _chart.root().append("svg")

.attr("width", _chart.width())

.attr("height", _chart.height());

return _svg;

};

_chart.filterPrinter = function(_) {

if (!arguments.length) return _filterPrinter;

_filterPrinter = _;

return _chart;

};

_chart.turnOnControls = function() {

_chart.selectAll(".reset").style("display", null);

_chart.selectAll(".filter").text(_filterPrinter(_chart.filter())).style("display", null);

return _chart;

};

_chart.turnOffControls = function() {

_chart.selectAll(".reset").style("display", "none");

_chart.selectAll(".filter").style("display", "none").text(_chart.filter());

return _chart;

};

_chart.transitionDuration = function(d) {

if (!arguments.length) return _transitionDuration;

_transitionDuration = d;

return _chart;

};

_chart.render = function() {

if(_dimension == null)

throw new dc.errors.InvalidStateException("Mandatory attribute chart.dimension is missing on chart["

+ _chart.anchor() + "]");

if (_group == null)

throw new dc.errors.InvalidStateException("Mandatory attribute chart.group is missing on chart["

+ _chart.anchor() + "]");

var result = _chart.doRender();

_chart.invokeRenderlet(_chart);

return result;

};

_chart.redraw = function() {

var result = _chart.doRedraw();

_chart.invokeRenderlet(_chart);

return result;

};

// abstract function stub

_chart.filter = function(f) {

// do nothing in base, should be overridden by sub-function

return _chart;

};

_chart.doRender = function() {

// do nothing in base, should be overridden by sub-function

return _chart;

};

_chart.doRedraw = function() {

// do nothing in base, should be overridden by sub-function

return _chart;

};

_chart.keyAccessor = function(_) {

if (!arguments.length) return _keyAccessor;

_keyAccessor = _;

return _chart;

};

_chart.valueAccessor = function(_) {

if (!arguments.length) return _valueAccessor;

_valueAccessor = _;

return _chart;

};

_chart.label = function(_) {

if (!arguments.length) return _label;

_label = _;

_renderLabel = true;

return _chart;

};

_chart.renderLabel = function(_) {

if (!arguments.length) return _renderLabel;

_renderLabel = _;

return _chart;

};

_chart.title = function(_) {

if (!arguments.length) return _title;

_title = _;

_renderTitle = true;

return _chart;

};

_chart.renderTitle = function(_) {

if (!arguments.length) return _renderTitle;

_renderTitle = _;

return _chart;

};

_chart.renderlet = function(_) {

_renderlets.push(_);

return _chart;

};

_chart.invokeRenderlet = function(chart) {

for (var i = 0; i < _renderlets.length; ++i) {

_renderlets[i](chart);

}

};

_chart.chartGroup = function(_) {

if (!arguments.length) return _chartGroup;

_chartGroup = _;

return _chart;

};

return _chart;

};

dc.coordinateGridChart = function(_chart) {

var DEFAULT_Y_AXIS_TICKS = 5;

var GRID_LINE_CLASS = "grid-line";

var HORIZONTAL_CLASS = "horizontal";

var VERTICAL_CLASS = "vertical";

_chart = dc.baseChart(_chart);

var _margin = {top: 10, right: 50, bottom: 30, left: 30};

var _g;

var _x;

var _xAxis = d3.svg.axis();

var _xUnits = dc.units.integers;

var _xAxisPadding = 0;

var _xElasticity = false;

var _y;

var _yAxis = d3.svg.axis();

var _yAxisPadding = 0;

var _yElasticity = false;

var _filter;

var _brush = d3.svg.brush();

var _brushOn = true;

var _round;

var _renderHorizontalGridLine = false;

var _renderVerticalGridLine = false;

_chart.generateG = function(parent) {

if (parent == null)

parent = _chart.svg();

_g = parent.append("g");

return _g;

};

_chart.g = function(_) {

if (!arguments.length) return _g;

_g = _;

return _chart;

};

_chart.margins = function(m) {

if (!arguments.length) return _margin;

_margin = m;

return _chart;

};

_chart.x = function(_) {

if (!arguments.length) return _x;

_x = _;

return _chart;

};

_chart.xUnits = function(_) {

if (!arguments.length) return _xUnits;

_xUnits = _;

return _chart;

};

_chart.xAxis = function(_) {

if (!arguments.length) return _xAxis;

_xAxis = _;

return _chart;

};

_chart.elasticX = function(_) {

if (!arguments.length) return _xElasticity;

_xElasticity = _;

return _chart;

};

_chart.xAxisPadding = function(_) {

if (!arguments.length) return _xAxisPadding;

_xAxisPadding = _;

return _chart;

};

function prepareXAxis(g) {

if (_chart.elasticX()) {

_x.domain([_chart.xAxisMin(), _chart.xAxisMax()]);

}

_x.range([0, _chart.xAxisLength()]);

_xAxis = _xAxis.scale(_chart.x()).orient("bottom");

renderVerticalGridLines(g);

}

_chart.renderXAxis = function(g) {

var axisXG = g.selectAll("g.x");

if (axisXG.empty())

axisXG = g.append("g")

.attr("class", "axis x")

.attr("transform", "translate(" + _chart.margins().left + "," + _chart.xAxisY() + ")");

dc.transition(axisXG, _chart.transitionDuration())

.call(_xAxis);

};

function renderVerticalGridLines(g) {

if (_renderVerticalGridLine) {

var gridLineG = g.selectAll("g." + VERTICAL_CLASS);

if (gridLineG.empty())

gridLineG = g.insert("g", ":first-child")

.attr("class", GRID_LINE_CLASS + " " + VERTICAL_CLASS)

.attr("transform", "translate(" + _chart.yAxisX() + "," + _chart.margins().top + ")");

var ticks = _xAxis.tickValues() ? _xAxis.tickValues() : _x.ticks(_xAxis.ticks()[0]);

var lines = gridLineG.selectAll("line")

.data(ticks);

// enter

var linesGEnter = lines.enter()

.append("line")

.attr("x1", function(d) {

return _x(d);

})

.attr("y1", _chart.xAxisY() - _chart.margins().top)

.attr("x2", function(d) {

return _x(d);

})

.attr("y2", 0)

.attr("opacity", 0);

dc.transition(linesGEnter, _chart.transitionDuration())

.attr("opacity", 1);

// update

dc.transition(lines, _chart.transitionDuration())

.attr("x1", function(d) {

return _x(d);

})

.attr("y1", _chart.xAxisY() - _chart.margins().top)

.attr("x2", function(d) {

return _x(d);

})

.attr("y2", 0);

// exit

lines.exit().remove();

}

}

_chart.xAxisY = function() {

return (_chart.height() - _chart.margins().bottom);

};

_chart.xAxisLength = function() {

return _chart.width() - _chart.margins().left - _chart.margins().right;

};

function prepareYAxis(g) {

if (_y == null || _chart.elasticY()) {

_y = d3.scale.linear();

_y.domain([_chart.yAxisMin(), _chart.yAxisMax()]).rangeRound([_chart.yAxisHeight(), 0]);

}

_y.range([_chart.yAxisHeight(), 0]);

_yAxis = _yAxis.scale(_y).orient("left").ticks(DEFAULT_Y_AXIS_TICKS);

renderHorizontalGridLines(g);

}

_chart.renderYAxis = function(g) {

var axisYG = g.selectAll("g.y");

if (axisYG.empty())

axisYG = g.append("g")

.attr("class", "axis y")

.attr("transform", "translate(" + _chart.yAxisX() + "," + _chart.margins().top + ")");

dc.transition(axisYG, _chart.transitionDuration())

.call(_yAxis);

};

function renderHorizontalGridLines(g) {

if (_renderHorizontalGridLine) {

var gridLineG = g.selectAll("g." + HORIZONTAL_CLASS);

var ticks = _yAxis.tickValues() ? _yAxis.tickValues() : _y.ticks(_yAxis.ticks()[0]);

if (gridLineG.empty())

gridLineG = g.insert("g", ":first-child")

.attr("class", GRID_LINE_CLASS + " " + HORIZONTAL_CLASS)

.attr("transform", "translate(" + _chart.yAxisX() + "," + _chart.margins().top + ")");

var lines = gridLineG.selectAll("line")

.data(ticks);

// enter

var linesGEnter = lines.enter()

.append("line")

.attr("x1", 1)

.attr("y1", function(d) {

return _y(d);

})

.attr("x2", _chart.xAxisLength())

.attr("y2", function(d) {

return _y(d);

})

.attr("opacity", 0);

dc.transition(linesGEnter, _chart.transitionDuration())

.attr("opacity", 1);

// update

dc.transition(lines, _chart.transitionDuration())

.attr("x1", 1)

.attr("y1", function(d) {

return _y(d);

})

.attr("x2", _chart.xAxisLength())

.attr("y2", function(d) {

return _y(d);

});

// exit

lines.exit().remove();

}

}

_chart.yAxisX = function() {

return _chart.margins().left;

};

_chart.y = function(_) {

if (!arguments.length) return _y;

_y = _;

return _chart;

};

_chart.yAxis = function(y) {

if (!arguments.length) return _yAxis;

_yAxis = y;

return _chart;

};

_chart.elasticY = function(_) {

if (!arguments.length) return _yElasticity;

_yElasticity = _;

return _chart;

};

_chart.renderHorizontalGridLines = function(_) {

if (!arguments.length) return _renderHorizontalGridLine;

_renderHorizontalGridLine = _;

return _chart;

};

_chart.renderVerticalGridLines = function(_) {

if (!arguments.length) return _renderVerticalGridLine;

_renderVerticalGridLine = _;

return _chart;

};

_chart.xAxisMin = function() {

var min = d3.min(_chart.group().all(), function(e) {

return _chart.keyAccessor()(e);

});

return dc.utils.subtract(min, _xAxisPadding);

};

_chart.xAxisMax = function() {

var max = d3.max(_chart.group().all(), function(e) {

return _chart.keyAccessor()(e);

});

return dc.utils.add(max, _xAxisPadding);

};

_chart.yAxisMin = function() {

var min = d3.min(_chart.group().all(), function(e) {

return _chart.valueAccessor()(e);

}) - _yAxisPadding;

return min;

};

_chart.yAxisMax = function() {

var max = d3.max(_chart.group().all(), function(e) {

return _chart.valueAccessor()(e);

});

return dc.utils.add(max, _yAxisPadding);

};

_chart.yAxisPadding = function(_) {

if (!arguments.length) return _yAxisPadding;

_yAxisPadding = _;

return _chart;

};

_chart.yAxisHeight = function() {

return _chart.height() - _chart.margins().top - _chart.margins().bottom;

};

_chart.round = function(_) {

if (!arguments.length) return _round;

_round = _;

return _chart;

};

_chart.filter = function(_) {

if (!arguments.length) return _filter;

if (_) {

_filter = _;

_chart.brush().extent(_);

_chart.dimension().filterRange(_);

_chart.turnOnControls();

} else {

_filter = null;

_chart.brush().clear();

_chart.dimension().filterAll();

_chart.turnOffControls();

}

return _chart;