/*!

* dc 2.0.0-dev

* http://dc-js.github.io/dc.js/

* Copyright 2012 Nick Zhu and other contributors

*

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

* you may not use this file except in compliance with 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.

*/

(function() { function _dc(d3) {

'use strict';

/**

#### Version 2.0.0-dev

The entire dc.js library is scoped under **dc** name space. It does not introduce anything else into the global

name space.

#### Function Chain

Majority of dc functions are designed to allow function chaining, meaning it will return the current chart instance

whenever it is appropriate. Therefore configuration of a chart can be written in the following style.

```js

chart.width(300)

.height(300)

.filter("sunday")

```

The API references will highlight the fact if a particular function is not chainable.

**/

var dc = {

version: "2.0.0-dev",

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,

NEGLIGIBLE_NUMBER: 1e-10

},

_renderlet: null

};

dc.chartRegistry = function() {

// chartGroup:string => charts:array

var _chartMap = {};

function initializeChartGroup(group) {

if (!group)

group = dc.constants.DEFAULT_CHART_GROUP;

if (!_chartMap[group])

_chartMap[group] = [];

return group;

}

return {

has: function(chart) {

for (var e in _chartMap) {

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

return true;

}

return false;

},

register: function(chart, group) {

group = initializeChartGroup(group);

_chartMap[group].push(chart);

},

deregister: function (chart, group) {

group = initializeChartGroup(group);

for (var i = 0; i < _chartMap[group].length; i++) {

if (_chartMap[group][i].anchorName() === chart.anchorName()) {

_chartMap[group].splice(i, 1);

break;

}

}

},

clear: function(group) {

if (group) {

delete _chartMap[group];

} else {

_chartMap = {};

}

},

list: function(group) {

group = initializeChartGroup(group);

return _chartMap[group];

}

};

}();

dc.registerChart = function(chart, group) {

dc.chartRegistry.register(chart, group);

};

dc.deregisterChart = function (chart, group) {

dc.chartRegistry.deregister(chart, group);

};

dc.hasChart = function(chart) {

return dc.chartRegistry.has(chart);

};

dc.deregisterAllCharts = function(group) {

dc.chartRegistry.clear(group);

};

/**

## Utilities

**/

/**

#### dc.filterAll([chartGroup])

Clear all filters on every chart within the given chart group. If the chart group is not given then only charts that

belong to the default chart group will be reset.

**/

dc.filterAll = function(group) {

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

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

charts[i].filterAll();

}

};

/**

#### dc.refocusAll([chartGroup])

Reset zoom level / focus on all charts that belong to the given chart group. If the chart group is not given then only charts that belong to

the default chart group will be reset.

**/

dc.refocusAll = function(group) {

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

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

if (charts[i].focus) charts[i].focus();

}

};

/**

#### dc.renderAll([chartGroup])

Re-render all charts belong to the given chart group. If the chart group is not given then only charts that belong to

the default chart group will be re-rendered.

**/

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([chartGroup])

Redraw all charts belong to the given chart group. If the chart group is not given then only charts that belong to the

default chart group will be re-drawn. Redraw is different from re-render since when redrawing dc charts try to update

the graphic incrementally instead of starting from scratch.

**/

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.disableTransitions = false;

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

if (duration <= 0 || duration === undefined || dc.disableTransitions)

return selections;

var s = selections

.transition()

.duration(duration);

if (typeof(callback) === 'function') {

callback(s);

}

return s;

};

dc.units = {};

/**

#### dc.units.integers

This function can be used to in [Coordinate Grid Chart](#coordinate-grid-chart) to define units on x axis.

dc.units.integers is the default x unit scale used by [Coordinate Grid Chart](#coordinate-grid-chart) and should be

used when x range is a sequential of integers.

**/

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

return Math.abs(e - s);

};

/**

#### dc.units.ordinal

This function can be used to in [Coordinate Grid Chart](#coordinate-grid-chart) to define ordinal units on x axis.

Usually this function is used in combination with d3.scale.ordinal() on x axis.

**/

dc.units.ordinal = function(s, e, domain){

return domain;

};

/**

#### dc.units.fp.precision(precision)

This function generates xunit function in floating-point numbers with the given precision. For example if the function

is invoked with 0.001 precision then the function created will divide a range [0.5, 1.0] with 500 units.

**/

dc.units.fp = {};

dc.units.fp.precision = function(precision){

var _f = function(s, e){

var d = Math.abs((e-s)/_f.resolution);

if(dc.utils.isNegligible(d - Math.floor(d)))

return Math.floor(d);

else

return Math.ceil(d);

};

_f.resolution = precision;

return _f;

};

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] = existingFunction;

obj[functionName] = newFunction;

};

dc.renderlet = function(_){

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

dc._renderlet = _;

return dc;

};

dc.instanceOfChart = function (o) {

return o instanceof Object && o.__dc_flag__ && true;

};

dc.errors = {};

dc.errors.Exception = function(msg) {

var _msg = 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.filters = function (filters) {

var s = "";

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

if (i > 0) s += ", ";

s += dc.printers.filter(filters[i]);

}

return s;

};

dc.printers.filter = function (filter) {

var s = "";

if (filter) {

if (filter instanceof Array) {

if (filter.length >= 2)

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

else if (filter.length >= 1)

s = dc.utils.printSingleValue(filter[0]);

} else {

s = dc.utils.printSingleValue(filter);

}

}

return s;

};

dc.pluck = function(n,f) {

if (!f) return function(d) { return d[n]; };

return function(d,i) { return f.call(d,d[n],i); };

};

dc.utils = {};

dc.utils.printSingleValue = function (filter) {

var s = "" + filter;

if (filter instanceof Date)

s = dc.dateFormat(filter);

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

s = filter;

else if (dc.utils.isFloat(filter))

s = dc.utils.printSingleValue.fformat(filter);

else if (dc.utils.isInteger(filter))

s = Math.round(filter);

return s;

};

dc.utils.printSingleValue.fformat = d3.format(".2f");

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

if (typeof r === "string")

r = r.replace("%", "");

if (l instanceof Date) {

if (typeof r === "string") r = +r;

var d = new Date();

d.setTime(l.getTime());

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

return d;

} else if (typeof r === "string") {

var percentage = (+r / 100);

return l > 0 ? l * (1 + percentage) : l * (1 - percentage);

} else {

return l + r;

}

};

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

if (typeof r === "string")

r = r.replace("%", "");

if (l instanceof Date) {

if (typeof r === "string") r = +r;

var d = new Date();

d.setTime(l.getTime());

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

return d;

} else if (typeof r === "string") {

var percentage = (+r / 100);

return l < 0 ? l * (1 + percentage) : l * (1 - percentage);

} else {

return l - r;

}

};

dc.utils.isNumber = function(n) {

return n===+n;

};

dc.utils.isFloat = function (n) {

return n===+n && n!==(n|0);

};

dc.utils.isInteger = function (n) {

return n===+n && n===(n|0);

};

dc.utils.isNegligible = function (n) {

return !dc.utils.isNumber(n) || (n < dc.constants.NEGLIGIBLE_NUMBER && n > -dc.constants.NEGLIGIBLE_NUMBER);

};

dc.utils.clamp = function (val, min, max) {

return val < min ? min : (val > max ? max : val);

};

var _idCounter = 0;

dc.utils.uniqueId = function () {

return ++_idCounter;

};

dc.utils.nameToId = function (name) {

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

};

dc.utils.appendOrSelect = function (parent, name) {

var element = parent.select(name);

if (element.empty()) element = parent.append(name);

return element;

};

dc.utils.safeNumber = function(n){return dc.utils.isNumber(+n)?+n:0;};

dc.logger = {};

dc.logger.enableDebugLog = false;

dc.logger.warn = function (msg) {

if (console) {

if (console.warn) {

console.warn(msg);

} else if (console.log) {

console.log(msg);

}

}

return dc.logger;

};

dc.logger.debug = function (msg) {

if (dc.logger.enableDebugLog && console) {

if (console.debug) {

console.debug(msg);

} else if (console.log) {

console.log(msg);

}

}

return dc.logger;

};

dc.events = {

current: null

};

/**

#### dc.events.trigger(function[, delay])

This function is design to trigger throttled event function optionally with certain amount of delay(in milli-seconds).

Events that are triggered repetitively due to user interaction such as the dragging of the brush might over flood

library and cause too much rendering being scheduled. In this case, using this function to wrap your event function

allows the library to smooth out the rendering by throttling event flood and only respond to the most recent event.

```js

chart.renderlet(function(chart){

// smooth the rendering through event throttling

dc.events.trigger(function(){

// focus some other chart to the range selected by user on this chart

someOtherChart.focus(chart.filter());

});

})

```

**/

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

if (!delay){

closure();

return;

}

dc.events.current = closure;

setTimeout(function() {

if (closure == dc.events.current)

closure();

}, delay);

};

dc.filters = {};

dc.filters.RangedFilter = function(low, high) {

var range = Array(low, high);

range.isFiltered = function(value) {

return value >= this[0] && value < this[1];

};

return range;

};

dc.filters.TwoDimensionalFilter = function(array) {

if (array === null) { return null; }

var filter = array;

filter.isFiltered = function(value) {

return value.length && value.length == filter.length &&

value[0] == filter[0] && value[1] == filter[1];

};

return filter;

};

/**

* @param array in the form [[x1,y1],[x2,y2]]

*/

dc.filters.RangedTwoDimensionalFilter = function(array){

if (array === null) { return null; }

var filter = array;

var fromBottomLeft;

if (filter[0] instanceof Array) {

fromBottomLeft = [[Math.min(array[0][0], array[1][0]),

Math.min(array[0][1], array[1][1])],

[Math.max(array[0][0], array[1][0]),

Math.max(array[0][1], array[1][1])]];

} else {

fromBottomLeft = [[array[0], -Infinity],

[array[1], Infinity]];

}

filter.isFiltered = function(value) {

var x, y;

if (value instanceof Array) {

if (value.length != 2) return false;

x = value[0];

y = value[1];

} else {

x = value;

y = fromBottomLeft[0][1];

}

return x >= fromBottomLeft[0][0] && x < fromBottomLeft[1][0] &&

y >= fromBottomLeft[0][1] && y < fromBottomLeft[1][1];

};

return filter;

};

/**

## Base Mixin

Base Mixin is an abstract functional object representing a basic dc chart object

for all chart and widget implementations. Methods from the Base Mixin are inherited

and available on all chart implementation in the DC library.

**/

dc.baseMixin = function (_chart) {

_chart.__dc_flag__ = dc.utils.uniqueId();

var _dimension;

var _group;

var _anchor;

var _root;

var _svg;

var _minWidth = 200;

var _default_width = function (element) {

var width = element && element.getBoundingClientRect && element.getBoundingClientRect().width;

return (width && width > _minWidth) ? width : _minWidth;

};

var _width = _default_width;

var _minHeight = 200;

var _default_height = function (element) {

var height = element && element.getBoundingClientRect && element.getBoundingClientRect().height;

return (height && height > _minHeight) ? height : _minHeight;

};

var _height = _default_height;

var _keyAccessor = dc.pluck('key');

var _valueAccessor = dc.pluck('value');

var _label = dc.pluck('key');

var _ordering = dc.pluck('key');

var _orderSort;

var _renderLabel = false;

var _title = function (d) {

return _chart.keyAccessor()(d) + ": " + _chart.valueAccessor()(d);

};

var _renderTitle = false;

var _transitionDuration = 750;

var _filterPrinter = dc.printers.filters;

var _renderlets = [];

var _mandatoryAttributes = ['dimension', 'group'];

var _chartGroup = dc.constants.DEFAULT_CHART_GROUP;

var NULL_LISTENER = function () {};

var _listeners = {

preRender: NULL_LISTENER,

postRender: NULL_LISTENER,

preRedraw: NULL_LISTENER,

postRedraw: NULL_LISTENER,

filtered: NULL_LISTENER,

zoomed: NULL_LISTENER

};

var _legend;

var _filters = [];

var _filterHandler = function (dimension, filters) {

dimension.filter(null);

if (filters.length === 0)

dimension.filter(null);

else

dimension.filterFunction(function (d) {

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

var filter = filters[i];

if (filter.isFiltered && filter.isFiltered(d)) {

return true;

} else if (filter == d) {

return true;

}

}

return false;

});

return filters;

};

var _data = function (group) {

return group.all();

};

/**

#### .width([value])

Set or get width attribute of a chart. See `.height` below for further description of the behavior.

**/

_chart.width = function (w) {

if (!arguments.length) return _width(_root.node());

_width = d3.functor(w || _default_width);

return _chart;

};

/**

#### .height([value])

Set or get height attribute of a chart. The height is applied to the SVG element

generated by the chart when rendered (or rerendered). If a value is given, then it

will be used to calculate the new height and the chart returned for method chaining.

The value can either be a numeric, a function, or falsy. If no value specified then

value of the current height attribute will be returned.

By default, without an explicit height being given, the chart will select the width

of its anchor element. If that isn't possible it defaults to 200;

Examples:

```js

chart.height(250); // Set the chart's height to 250px;

chart.height(function(anchor) { return doSomethingWith(anchor); }); // set the chart's height with a function

chart.height(null); // reset the height to the default auto calculation

```

**/

_chart.height = function (h) {

if (!arguments.length) return _height(_root.node());

_height = d3.functor(h || _default_height);

return _chart;

};

/**

#### .minWidth([value])

Set or get minimum width attribute of a chart. This only applicable if the width is calculated by DC.

**/

_chart.minWidth = function (w) {

if (!arguments.length) return _minWidth;

_minWidth = w;

return _chart;

};

/**

#### .minHeight([value])

Set or get minimum height attribute of a chart. This only applicable if the height is calculated by DC.

**/

_chart.minHeight = function (w) {

if (!arguments.length) return _minHeight;

_minHeight = w;

return _chart;

};

/**

#### .dimension([value]) - **mandatory**

Set or get dimension attribute of a chart. In dc a dimension can be any valid

[crossfilter dimension](https://github.com/square/crossfilter/wiki/API-Reference#wiki-dimension). If the value is given,

then it will be used as the new dimension.

If no value specified then the current dimension will be returned.

**/

_chart.dimension = function (d) {

if (!arguments.length) return _dimension;

_dimension = d;

_chart.expireCache();

return _chart;

};

/**

#### .data([callback])

Get the data callback or retreive the charts data set. The data callback is passed the chart's group and by default

will return `group.all()`. This behavior may be modified to, for instance, return only the top 5 groups:

```

chart.data(function(group) {

return group.top(5);

});

```

**/

_chart.data = function(d) {

if (!arguments.length) return _data.call(_chart,_group);

_data = d3.functor(d);

_chart.expireCache();

return _chart;

};

/**

#### .group([value, [name]]) - **mandatory**

Set or get group attribute of a chart. In dc a group is a

[crossfilter group](https://github.com/square/crossfilter/wiki/API-Reference#wiki-group). Usually the group should be

created from the particular dimension associated with the same chart. If the value is given, then it will be used as

the new group.

If no value specified then the current group will be returned.

If name is specified then it will be used to generate legend label.

**/

_chart.group = function (g, name) {

if (!arguments.length) return _group;

_group = g;

_chart._groupName = name;

_chart.expireCache();

return _chart;

};

/**

#### .ordering([orderFunction])

Get or set an accessor to order ordinal charts

**/

_chart.ordering = function(o) {

if (!arguments.length) return _ordering;

_ordering = o;

_orderSort = crossfilter.quicksort.by(_ordering);

_chart.expireCache();

return _chart;

};

_chart._computeOrderedGroups = function(data) {

var dataCopy = data.slice(0);

if (dataCopy.length <= 1)

return dataCopy;

if (!_orderSort)

_orderSort = crossfilter.quicksort.by(_ordering);

return _orderSort(dataCopy, 0, dataCopy.length);

};

/**

#### .filterAll()

Clear all filters associated with this chart.

**/

_chart.filterAll = function () {

return _chart.filter(null);

};

/**

#### .select(selector)

Execute in scope d3 single selection using the given selector and return d3 selection result. Roughly the same as:

```js

d3.select("#chart-id").select(selector);

```

This function is **not chainable** since it does not return a chart instance; however the d3 selection result is chainable

from d3's perspective.

**/

_chart.select = function (s) {

return _root.select(s);

};

/**

#### .selectAll(selector)

Execute in scope d3 selectAll using the given selector and return d3 selection result. Roughly the same as:

```js

d3.select("#chart-id").selectAll(selector);

```

This function is **not chainable** since it does not return a chart instance; however the d3 selection result is

chainable from d3's perspective.

**/

_chart.selectAll = function (s) {

return _root ? _root.selectAll(s) : null;

};

/**

#### .anchor([anchorChart/anchorSelector], [chartGroup])

Set the svg root to either be an existing chart's root or the first element returned from a d3 css string selector. Optionally registers the chart within the chartGroup. This class is called internally on chart initialization, but be called again to relocate the chart. However, it will orphan any previously created SVG elements.

**/

_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;

};

/**

#### .anchorName()

Return the dom ID for chart's anchored location

**/

_chart.anchorName = function () {

var a = _chart.anchor();

if (a && a.id) return a.id;

if (a && a.replace) return a.replace('#','');

return "" + _chart.chartID();

};

/**

#### .root([rootElement])

Returns the root element where a chart resides. Usually it will be the parent div element where svg was created. You

can also pass in a new root element however this is usually handled as part of the dc internal. Resetting root element

on a chart outside of dc internal might have unexpected consequences.

**/

_chart.root = function (r) {

if (!arguments.length) return _root;

_root = r;

return _chart;

};

/**

#### .svg([svgElement])

Returns the top svg element for this specific chart. You can also pass in a new svg element however this is usually

handled as part of the dc internal. Resetting svg element on a chart outside of dc internal might have unexpected

consequences.

**/

_chart.svg = function (_) {

if (!arguments.length) return _svg;

_svg = _;

return _chart;

};

/**

#### .resetSvg()

Remove the chart's SVG elements from the dom and recreate the container SVG element.

**/

_chart.resetSvg = function () {

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

return generateSvg();

};

function generateSvg() {

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

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

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

return _svg;

}

/**

#### .filterPrinter([filterPrinterFunction])

Set or get filter printer function. Filter printer function is used to generate human friendly text for filter value(s)

associated with the chart instance. By default dc charts shipped with a default filter printer implementation dc.printers.filter

that provides simple printing support for both single value and ranged filters.

**/

_chart.filterPrinter = function (_) {

if (!arguments.length) return _filterPrinter;

_filterPrinter = _;

return _chart;

};

/**

#### .turnOnControls() & .turnOffControls()

Turn on/off optional control elements within the root element. dc.js currently support the following html control elements.

* root.selectAll(".reset") elements are turned on if the chart has an active filter. This type of control elements are usually used to store reset link to allow user to reset filter on a certain chart. This element will be turned off automatically if the filter is cleared.

* root.selectAll(".filter") elements are turned on if the chart has an active filter. The text content of this element is then replaced with the current filter value using the filter printer function. This type of element will be turned off automatically if the filter is cleared.

**/

_chart.turnOnControls = function () {

if (_root) {

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

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

}

return _chart;

};

_chart.turnOffControls = function () {

if (_root) {

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

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

}

return _chart;

};

/**

#### .transitionDuration([duration])

Set or get animation transition duration(in milliseconds) for specific chart instance. Default duration is 750ms.

**/

_chart.transitionDuration = function (d) {

if (!arguments.length) return _transitionDuration;

_transitionDuration = d;

return _chart;

};

_chart._mandatoryAttributes = function (_) {

if (!arguments.length) return _mandatoryAttributes;

_mandatoryAttributes = _;

return _chart;

};

function checkForMandatoryAttributes(a) {

if (!_chart[a] || !_chart[a]())

throw new dc.errors.InvalidStateException("Mandatory attribute chart." + a +

" is missing on chart[#" + _chart.anchorName() + "]");

}

/**

#### .render()

Invoke this method will force the chart to re-render everything from scratch. Generally it should be only used to

render the chart for the first time on the page or if you want to make sure everything is redrawn from scratch instead

of relying on the default incremental redrawing behaviour.

**/

_chart.render = function () {

_listeners.preRender(_chart);

if (_mandatoryAttributes)

_mandatoryAttributes.forEach(checkForMandatoryAttributes);

var result = _chart._doRender();

if (_legend) _legend.render();

_chart._activateRenderlets("postRender");

return result;

};

_chart._activateRenderlets = function (event) {

if (_chart.transitionDuration() > 0 && _svg) {

_svg.transition().duration(_chart.transitionDuration())

.each("end", function () {

runAllRenderlets();

if (event) _listeners[event](_chart);

});

} else {

runAllRenderlets();

if (event) _listeners[event](_chart);

}

};

/**

#### .redraw()

Calling redraw will cause the chart to re-render delta in data change incrementally. If there is no change in the

underlying data dimension then calling this method will have no effect on the chart. Most of the chart interaction in

dc library will automatically trigger this method through its internal event engine, therefore you only need to manually

invoke this function if data is manipulated outside of dc's control; for example if data is loaded on a periodic basis

in the background using crossfilter.add().

**/

_chart.redraw = function () {

_listeners.preRedraw(_chart);

var result = _chart._doRedraw();

if (_legend) _legend.render();

_chart._activateRenderlets("postRedraw");

return result;

};

_chart.redrawGroup = function () {

dc.redrawAll(_chart.chartGroup());

};

_chart._invokeFilteredListener = function (f) {

if (f !== undefined) _listeners.filtered(_chart, f);

};

_chart._invokeZoomedListener = function () {

_listeners.zoomed(_chart);

};