"use strict";
module.exports = function(Chart) {
var helpers = Chart.helpers;
var defaultConfig = {
position: "left",
ticks: {
callback: function(tickValue, index, ticks) {
// If we have lots of ticks, don't use the ones
var delta = ticks.length > 3 ? ticks[2] - ticks[1] : ticks[1] - ticks[0];
// If we have a number like 2.5 as the delta, figure out how many decimal places we need
if (Math.abs(delta) > 1) {
if (tickValue !== Math.floor(tickValue)) {
// not an integer
delta = tickValue - Math.floor(tickValue);
}
}
var logDelta = helpers.log10(Math.abs(delta));
var tickString = '';
if (tickValue !== 0) {
var numDecimal = -1 * Math.floor(logDelta);
numDecimal = Math.max(Math.min(numDecimal, 20), 0); // toFixed has a max of 20 decimal places
tickString = tickValue.toFixed(numDecimal);
} else {
tickString = '0'; // never show decimal places for 0
}
return tickString;
}
}
};
var LinearScale = Chart.Scale.extend({
determineDataLimits: function() {
var _this = this;
var opts = _this.options;
var tickOpts = opts.ticks;
var chart = _this.chart;
var data = chart.data;
var datasets = data.datasets;
var isHorizontal = _this.isHorizontal();
function IDMatches(meta) {
return isHorizontal ? meta.xAxisID === _this.id : meta.yAxisID === _this.id;
}
// First Calculate the range
_this.min = null;
_this.max = null;
if (opts.stacked) {
var valuesPerType = {};
var hasPositiveValues = false;
var hasNegativeValues = false;
helpers.each(datasets, function(dataset, datasetIndex) {
var meta = chart.getDatasetMeta(datasetIndex);
if (valuesPerType[meta.type] === undefined) {
valuesPerType[meta.type] = {
positiveValues: [],
negativeValues: []
};
}
// Store these per type
var positiveValues = valuesPerType[meta.type].positiveValues;
var negativeValues = valuesPerType[meta.type].negativeValues;
if (chart.isDatasetVisible(datasetIndex) && IDMatches(meta)) {
helpers.each(dataset.data, function(rawValue, index) {
var value = +_this.getRightValue(rawValue);
if (isNaN(value) || meta.data[index].hidden) {
return;
}
positiveValues[index] = positiveValues[index] || 0;
negativeValues[index] = negativeValues[index] || 0;
if (opts.relativePoints) {
positiveValues[index] = 100;
} else {
if (value < 0) {
hasNegativeValues = true;
negativeValues[index] += value;
} else {
hasPositiveValues = true;
positiveValues[index] += value;
}
}
});
}
});
helpers.each(valuesPerType, function(valuesForType) {
var values = valuesForType.positiveValues.concat(valuesForType.negativeValues);
var minVal = helpers.min(values);
var maxVal = helpers.max(values);
_this.min = _this.min === null ? minVal : Math.min(_this.min, minVal);
_this.max = _this.max === null ? maxVal : Math.max(_this.max, maxVal);
});
} else {
helpers.each(datasets, function(dataset, datasetIndex) {
var meta = chart.getDatasetMeta(datasetIndex);
if (chart.isDatasetVisible(datasetIndex) && IDMatches(meta)) {
helpers.each(dataset.data, function(rawValue, index) {
var value = +_this.getRightValue(rawValue);
if (isNaN(value) || meta.data[index].hidden) {
return;
}
if (_this.min === null) {
_this.min = value;
} else if (value < _this.min) {
_this.min = value;
}
if (_this.max === null) {
_this.max = value;
} else if (value > _this.max) {
_this.max = value;
}
});
}
});
}
// If we are forcing it to begin at 0, but 0 will already be rendered on the chart,
// do nothing since that would make the chart weird. If the user really wants a weird chart
// axis, they can manually override it
if (tickOpts.beginAtZero) {
var minSign = helpers.sign(_this.min);
var maxSign = helpers.sign(_this.max);
if (minSign < 0 && maxSign < 0) {
// move the top up to 0
_this.max = 0;
} else if (minSign > 0 && maxSign > 0) {
// move the botttom down to 0
_this.min = 0;
}
}
if (tickOpts.min !== undefined) {
_this.min = tickOpts.min;
} else if (tickOpts.suggestedMin !== undefined) {
_this.min = Math.min(_this.min, tickOpts.suggestedMin);
}
if (tickOpts.max !== undefined) {
_this.max = tickOpts.max;
} else if (tickOpts.suggestedMax !== undefined) {
_this.max = Math.max(_this.max, tickOpts.suggestedMax);
}
if (_this.min === _this.max) {
_this.max++;
if (!tickOpts.beginAtZero) {
_this.min--;
}
}
},
buildTicks: function() {
var _this = this;
var opts = _this.options;
var tickOpts = opts.ticks;
var getValueOrDefault = helpers.getValueOrDefault;
var isHorizontal = _this.isHorizontal();
var ticks = _this.ticks = [];
// Figure out what the max number of ticks we can support it is based on the size of
// the axis area. For now, we say that the minimum tick spacing in pixels must be 50
// We also limit the maximum number of ticks to 11 which gives a nice 10 squares on
// the graph
var maxTicks;
if (isHorizontal) {
maxTicks = Math.min(tickOpts.maxTicksLimit ? tickOpts.maxTicksLimit : 11, Math.ceil(_this.width / 50));
} else {
// The factor of 2 used to scale the font size has been experimentally determined.
var tickFontSize = getValueOrDefault(tickOpts.fontSize, Chart.defaults.global.defaultFontSize);
maxTicks = Math.min(tickOpts.maxTicksLimit ? tickOpts.maxTicksLimit : 11, Math.ceil(_this.height / (2 * tickFontSize)));
}
// Make sure we always have at least 2 ticks
maxTicks = Math.max(2, maxTicks);
// To get a "nice" value for the tick spacing, we will use the appropriately named
// "nice number" algorithm. See http://stackoverflow.com/questions/8506881/nice-label-algorithm-for-charts-with-minimum-ticks
// for details.
var spacing;
var fixedStepSizeSet = (tickOpts.fixedStepSize && tickOpts.fixedStepSize > 0) || (tickOpts.stepSize && tickOpts.stepSize > 0);
if (fixedStepSizeSet) {
spacing = getValueOrDefault(tickOpts.fixedStepSize, tickOpts.stepSize);
} else {
var niceRange = helpers.niceNum(_this.max - _this.min, false);
spacing = helpers.niceNum(niceRange / (maxTicks - 1), true);
}
var niceMin = Math.floor(_this.min / spacing) * spacing;
var niceMax = Math.ceil(_this.max / spacing) * spacing;
var numSpaces = (niceMax - niceMin) / spacing;
// If very close to our rounded value, use it.
if (helpers.almostEquals(numSpaces, Math.round(numSpaces), spacing / 1000)) {
numSpaces = Math.round(numSpaces);
} else {
numSpaces = Math.ceil(numSpaces);
}
// Put the values into the ticks array
ticks.push(tickOpts.min !== undefined ? tickOpts.min : niceMin);
for (var j = 1; j < numSpaces; ++j) {
ticks.push(niceMin + (j * spacing));
}
ticks.push(tickOpts.max !== undefined ? tickOpts.max : niceMax);
if (!isHorizontal) {
// We are in a vertical orientation. The top value is the highest. So reverse the array
ticks.reverse();
}
// At this point, we need to update our max and min given the tick values since we have expanded the
// range of the scale
_this.max = helpers.max(ticks);
_this.min = helpers.min(ticks);
if (tickOpts.reverse) {
ticks.reverse();
_this.start = _this.max;
_this.end = _this.min;
} else {
_this.start = _this.min;
_this.end = _this.max;
}
},
getLabelForIndex: function(index, datasetIndex) {
return +this.getRightValue(this.chart.data.datasets[datasetIndex].data[index]);
},
convertTicksToLabels: function() {
var _this = this;
_this.ticksAsNumbers = _this.ticks.slice();
_this.zeroLineIndex = _this.ticks.indexOf(0);
Chart.Scale.prototype.convertTicksToLabels.call(_this);
},
// Utils
getPixelForValue: function(value, index, datasetIndex, includeOffset) {
// This must be called after fit has been run so that
// this.left, this.top, this.right, and this.bottom have been defined
var _this = this;
var paddingLeft = _this.paddingLeft;
var paddingBottom = _this.paddingBottom;
var start = _this.start;
var rightValue = +_this.getRightValue(value);
var pixel;
var innerDimension;
var range = _this.end - start;
if (_this.isHorizontal()) {
innerDimension = _this.width - (paddingLeft + _this.paddingRight);
pixel = _this.left + (innerDimension / range * (rightValue - start));
return Math.round(pixel + paddingLeft);
} else {
innerDimension = _this.height - (_this.paddingTop + paddingBottom);
pixel = (_this.bottom - paddingBottom) - (innerDimension / range * (rightValue - start));
return Math.round(pixel);
}
},
getValueForPixel: function(pixel) {
var _this = this;
var isHorizontal = _this.isHorizontal();
var paddingLeft = _this.paddingLeft;
var paddingBottom = _this.paddingBottom;
var innerDimension = isHorizontal ? _this.width - (paddingLeft + _this.paddingRight) : _this.height - (_this.paddingTop + paddingBottom);
var offset = (isHorizontal ? pixel - _this.left - paddingLeft : _this.bottom - paddingBottom - pixel) / innerDimension;
return _this.start + ((_this.end - _this.start) * offset);
},
getPixelForTick: function(index, includeOffset) {
return this.getPixelForValue(this.ticksAsNumbers[index], null, null, includeOffset);
}
});
Chart.scaleService.registerScaleType("linear", LinearScale, defaultConfig);
}; |