// Value for the tooltip
value: string,
- // X Value of the tooltip
- // (deprecated) use `value` or `label` instead
- xLabel: number | string,
-
- // Y value of the tooltip
- // (deprecated) use `value` or `label` instead
- yLabel: number | string,
-
// Index of the dataset the item comes from
datasetIndex: number,
updateElement: function(rectangle, index, reset) {
var me = this;
- var meta = me.getMeta();
var dataset = me.getDataset();
var options = me._resolveDataElementOptions(index);
- rectangle._xScale = me.getScaleForId(meta.xAxisID);
- rectangle._yScale = me.getScaleForId(meta.yAxisID);
rectangle._datasetIndex = me.index;
rectangle._index = index;
rectangle._model = {
label: function(item, data) {
var datasetLabel = data.datasets[item.datasetIndex].label || '';
var dataPoint = data.datasets[item.datasetIndex].data[item.index];
- return datasetLabel + ': (' + item.xLabel + ', ' + item.yLabel + ', ' + dataPoint.r + ')';
+ return datasetLabel + ': (' + item.label + ', ' + item.value + ', ' + dataPoint.r + ')';
}
}
}
var x = reset ? xScale.getPixelForDecimal(0.5) : xScale.getPixelForValue(typeof data === 'object' ? data : NaN, index, dsIndex);
var y = reset ? yScale.getBasePixel() : yScale.getPixelForValue(data, index, dsIndex);
- point._xScale = xScale;
- point._yScale = yScale;
point._options = options;
point._datasetIndex = dsIndex;
point._index = index;
}
// Utility
- line._scale = me._yScale;
line._datasetIndex = me.index;
// Data
line._children = points;
var dataset = me.getDataset();
var datasetIndex = me.index;
var value = dataset.data[index];
- var xScale = me._xScale;
- var yScale = me._yScale;
var lineModel = meta.dataset._model;
var x, y;
var options = me._resolveDataElementOptions(index);
- x = xScale.getPixelForValue(typeof value === 'object' ? value : NaN, index, datasetIndex);
- y = reset ? yScale.getBasePixel() : me.calculatePointY(value, index, datasetIndex);
+ x = me._xScale.getPixelForValue(typeof value === 'object' ? value : NaN, index, datasetIndex);
+ y = reset ? me._yScale.getBasePixel() : me.calculatePointY(value, index, datasetIndex);
// Utility
- point._xScale = xScale;
- point._yScale = yScale;
point._options = options;
point._datasetIndex = datasetIndex;
point._index = index;
return '';
},
label: function(item, data) {
- return data.labels[item.index] + ': ' + item.yLabel;
+ return data.labels[item.index] + ': ' + item.value;
}
}
}
// Utility
_datasetIndex: me.index,
_index: index,
- _scale: scale,
// Desired view properties
_model: {
var meta = me.getMeta();
var line = meta.dataset;
var points = meta.data || [];
- var scale = me.chart.scale;
var config = me._config;
var i, ilen;
}
// Utility
- line._scale = scale;
line._datasetIndex = me.index;
// Data
line._children = points;
var y = reset ? scale.yCenter : pointPosition.y;
// Utility
- point._scale = scale;
point._options = options;
point._datasetIndex = me.index;
point._index = index;
return ''; // doesn't make sense for scatter since data are formatted as a point
},
label: function(item) {
- return '(' + item.xLabel + ', ' + item.yLabel + ')';
+ return '(' + item.label + ', ' + item.value + ')';
}
}
}
var me = this;
me.tooltip = new Tooltip({
_chart: me,
- _chartInstance: me, // deprecated, backward compatibility
_data: me.data,
_options: me.options.tooltips
}, me);
var me = this;
var type = me.datasetElementType;
return type && new type({
- _chart: me.chart,
+ _ctx: me.chart.ctx,
_datasetIndex: me.index
});
},
var me = this;
var type = me.dataElementType;
return type && new type({
- _chart: me.chart,
+ _ctx: me.chart.ctx,
_datasetIndex: me.index,
_index: index
});
var item = tooltipItems[0];
if (item.label) {
title = item.label;
- } else if (item.xLabel) {
- title = item.xLabel;
} else if (labelCount > 0 && item.index < labelCount) {
title = labels[item.index];
}
}
if (!helpers.isNullOrUndef(tooltipItem.value)) {
label += tooltipItem.value;
- } else {
- label += tooltipItem.yLabel;
}
return label;
},
* @param element - the chart element (point, arc, bar) to create the tooltip item for
* @return new tooltip item
*/
-function createTooltipItem(element) {
- var xScale = element._xScale;
- var yScale = element._yScale || element._scale; // handle radar || polarArea charts
- var index = element._index;
+function createTooltipItem(chart, element) {
var datasetIndex = element._datasetIndex;
- var controller = element._chart.getDatasetMeta(datasetIndex).controller;
+ var index = element._index;
+ var controller = chart.getDatasetMeta(datasetIndex).controller;
var indexScale = controller._getIndexScale();
var valueScale = controller._getValueScale();
return {
- xLabel: xScale ? xScale.getLabelForIndex(index, datasetIndex) : '',
- yLabel: yScale ? yScale.getLabelForIndex(index, datasetIndex) : '',
label: indexScale ? '' + indexScale.getLabelForIndex(index, datasetIndex) : '',
value: valueScale ? '' + valueScale.getLabelForIndex(index, datasetIndex) : '',
index: index,
function determineAlignment(tooltip, size) {
var model = tooltip._model;
var chart = tooltip._chart;
- var chartArea = tooltip._chart.chartArea;
+ var chartArea = chart.chartArea;
var xAlign = 'center';
var yAlign = 'center';
var tooltipItems = [];
for (i = 0, len = active.length; i < len; ++i) {
- tooltipItems.push(createTooltipItem(active[i]));
+ tooltipItems.push(createTooltipItem(me._chart, active[i]));
}
// If the user provided a filter function, use it to modify the tooltip items
},
draw: function() {
- var ctx = this._chart.ctx;
+ var ctx = this._ctx;
var vm = this._view;
var pixelMargin = (vm.borderAlign === 'inner') ? 0.33 : 0;
var arc = {
draw: function() {
var me = this;
var vm = me._view;
- var ctx = me._chart.ctx;
+ var ctx = me._ctx;
var spanGaps = vm.spanGaps;
var points = me._children.slice(); // clone array
var globalDefaults = defaults.global;
draw: function(chartArea) {
var vm = this._view;
- var ctx = this._chart.ctx;
+ var ctx = this._ctx;
var pointStyle = vm.pointStyle;
var rotation = vm.rotation;
var radius = vm.radius;
_type: 'rectangle',
draw: function() {
- var ctx = this._chart.ctx;
+ var ctx = this._ctx;
var vm = this._view;
var rects = boundingRects(vm);
var outer = rects.outer;
function computeLinearBoundary(source) {
var model = source.el._model || {};
- var scale = source.el._scale || {};
+ var scale = source.scale || {};
var fill = source.fill;
var target = null;
var horizontal;
}
function computeCircularBoundary(source) {
- var scale = source.el._scale;
+ var scale = source.scale;
var options = scale.options;
var length = scale.chart.data.labels.length;
var fill = source.fill;
}
function computeBoundary(source) {
- var scale = source.el._scale || {};
+ var scale = source.scale || {};
if (scale.getPointPositionForValue) {
return computeCircularBoundary(source);
visible: chart.isDatasetVisible(i),
fill: decodeFill(el, i, count),
chart: chart,
+ scale: meta.controller.getScaleForId(meta.yAxisID) || chart.scale,
el: el
};
}
].forEach(function(expected, i) {
expect(meta.data[i]._datasetIndex).toBe(1);
expect(meta.data[i]._index).toBe(i);
- expect(meta.data[i]._xScale).toBe(chart.scales.firstXScaleID);
- expect(meta.data[i]._yScale).toBe(chart.scales.firstYScaleID);
expect(meta.data[i]._model.x).toBeCloseToPixel(expected.x);
expect(meta.data[i]._model.y).toBeCloseToPixel(expected.y);
expect(meta.data[i]._model.base).toBeCloseToPixel(1024);
].forEach(function(expected, i) {
expect(meta.data[i]._datasetIndex).toBe(0);
expect(meta.data[i]._index).toBe(i);
- expect(meta.data[i]._xScale).toBe(chart.scales.firstXScaleID);
- expect(meta.data[i]._yScale).toBe(chart.scales.firstYScaleID);
expect(meta.data[i]._model.x).toBeCloseToPixel(expected.x);
expect(meta.data[i]._model.y).toBeCloseToPixel(expected.y);
expect(meta.data[i]._model).toEqual(jasmine.objectContaining({
var tooltipItem = {
index: 1,
datasetIndex: 0,
- xLabel: 'Point 2',
- yLabel: '20'
+ label: 'Point 2',
+ value: '20'
};
var label = Chart.defaults.global.tooltips.callbacks.label(tooltipItem, data);
expect(tooltipItem.index).toBe(pointIndex);
expect(tooltipItem.datasetIndex).toBe(datasetIndex);
- var indexLabel = type !== 'horizontalBar' ? 'xLabel' : 'yLabel';
- expect(typeof tooltipItem[indexLabel]).toBe('string');
- expect(tooltipItem[indexLabel]).toBe(chart.data.labels[pointIndex]);
- var valueLabel = type !== 'horizontalBar' ? 'yLabel' : 'xLabel';
- expect(typeof tooltipItem[valueLabel]).toBe('number');
- expect(tooltipItem[valueLabel]).toBe(chart.data.datasets[datasetIndex].data[pointIndex]);
expect(typeof tooltipItem.label).toBe('string');
expect(tooltipItem.label).toBe(chart.data.labels[pointIndex]);
expect(typeof tooltipItem.value).toBe('string');
var line = new Chart.elements.Line({
_datasetindex: 2,
- _chart: {
- ctx: mockContext,
- },
+ _ctx: mockContext,
_children: points,
// Need to provide some settings
_view: {
var line = new Chart.elements.Line({
_datasetindex: 2,
- _chart: {
- ctx: mockContext,
- },
+ _ctx: mockContext,
_children: points,
// Need to provide some settings
_view: {
var line = new Chart.elements.Line({
_datasetindex: 2,
- _chart: {
- ctx: mockContext,
- },
+ _ctx: mockContext,
_children: points,
// Need to provide some settings
_view: {
var line = new Chart.elements.Line({
_datasetindex: 2,
- _chart: {
- ctx: mockContext,
- },
+ _ctx: mockContext,
_children: points,
// Need to provide some settings
_view: {
var line = new Chart.elements.Line({
_datasetindex: 2,
- _chart: {
- ctx: mockContext,
- },
+ _ctx: mockContext,
_children: points,
// Need to provide some settings
_view: {
var line = new Chart.elements.Line({
_datasetindex: 2,
- _chart: {
- ctx: mockContext,
- },
+ _ctx: mockContext,
_children: points,
// Need to provide some settings
_view: {
var line = new Chart.elements.Line({
_datasetindex: 2,
- _chart: {
- ctx: mockContext,
- },
+ _ctx: mockContext,
_children: points,
// Need to provide some settings
_view: {
var line = new Chart.elements.Line({
_datasetindex: 2,
- _chart: {
- ctx: mockContext,
- },
+ _ctx: mockContext,
_children: points,
// Need to provide some settings
_view: {
var line = new Chart.elements.Line({
_datasetindex: 2,
- _chart: {
- ctx: mockContext,
- },
+ _ctx: mockContext,
_children: points,
// Need to provide some settings
_view: {
var line = new Chart.elements.Line({
_datasetindex: 2,
- _chart: {
- ctx: mockContext,
- },
+ _ctx: mockContext,
_children: points,
// Need to provide some settings
_view: {
var line = new Chart.elements.Line({
_datasetindex: 2,
- _chart: {
- ctx: mockContext,
- },
+ _ctx: mockContext,
_children: points,
// Need to provide some settings
_view: {
var line = new Chart.elements.Line({
_datasetindex: 2,
- _chart: {
- ctx: mockContext,
- },
+ _ctx: mockContext,
_children: points,
// Need to provide some settings
_view: {
var line = new Chart.elements.Line({
_datasetindex: 2,
- _chart: {
- ctx: mockContext,
- },
+ _ctx: mockContext,
_children: points,
// Need to provide some settings
_view: {
var point = new Chart.elements.Point({
_datasetIndex: 2,
_index: 1,
- _chart: {
- ctx: mockContext,
- }
+ _ctx: mockContext
});
// Attach a view object as if we were the controller
var point = new Chart.elements.Point({
_datasetIndex: 2,
_index: 1,
- _chart: {
- ctx: mockContext,
- }
+ _ctx: mockContext
});
// Attach a view object as if we were the controller