1003 lines
25 KiB
JavaScript
1003 lines
25 KiB
JavaScript
/**
|
|
* @license Map plugin v0.1 for Highcharts
|
|
*
|
|
* (c) 2011-2013 Torstein Hønsi
|
|
*
|
|
* License: www.highcharts.com/license
|
|
*/
|
|
|
|
/*
|
|
* See www.highcharts.com/studies/world-map.htm for use case.
|
|
*
|
|
* To do:
|
|
* - Optimize long variable names and alias adapter methods and Highcharts namespace variables
|
|
* - Zoom and pan GUI
|
|
*/
|
|
(function (Highcharts) {
|
|
var UNDEFINED,
|
|
Axis = Highcharts.Axis,
|
|
Chart = Highcharts.Chart,
|
|
Point = Highcharts.Point,
|
|
Pointer = Highcharts.Pointer,
|
|
each = Highcharts.each,
|
|
extend = Highcharts.extend,
|
|
merge = Highcharts.merge,
|
|
pick = Highcharts.pick,
|
|
numberFormat = Highcharts.numberFormat,
|
|
defaultOptions = Highcharts.getOptions(),
|
|
seriesTypes = Highcharts.seriesTypes,
|
|
plotOptions = defaultOptions.plotOptions,
|
|
wrap = Highcharts.wrap,
|
|
Color = Highcharts.Color,
|
|
noop = function () {};
|
|
|
|
|
|
|
|
/*
|
|
* Return an intermediate color between two colors, according to pos where 0
|
|
* is the from color and 1 is the to color
|
|
*/
|
|
function tweenColors(from, to, pos) {
|
|
var i = 4,
|
|
rgba = [];
|
|
|
|
while (i--) {
|
|
rgba[i] = Math.round(
|
|
to.rgba[i] + (from.rgba[i] - to.rgba[i]) * (1 - pos)
|
|
);
|
|
}
|
|
return 'rgba(' + rgba.join(',') + ')';
|
|
}
|
|
|
|
// Set the default map navigation options
|
|
defaultOptions.mapNavigation = {
|
|
buttonOptions: {
|
|
align: 'right',
|
|
verticalAlign: 'bottom',
|
|
x: 0,
|
|
width: 18,
|
|
height: 18,
|
|
style: {
|
|
fontSize: '15px',
|
|
fontWeight: 'bold',
|
|
textAlign: 'center'
|
|
}
|
|
},
|
|
buttons: {
|
|
zoomIn: {
|
|
onclick: function () {
|
|
this.mapZoom(0.5);
|
|
},
|
|
text: '+',
|
|
y: -32
|
|
},
|
|
zoomOut: {
|
|
onclick: function () {
|
|
this.mapZoom(2);
|
|
},
|
|
text: '-',
|
|
y: 0
|
|
}
|
|
}
|
|
// enableButtons: false,
|
|
// enableTouchZoom: false,
|
|
// zoomOnDoubleClick: false,
|
|
// zoomOnMouseWheel: false
|
|
|
|
};
|
|
|
|
/**
|
|
* Utility for reading SVG paths directly.
|
|
*/
|
|
Highcharts.splitPath = function (path) {
|
|
var i;
|
|
|
|
// Move letters apart
|
|
path = path.replace(/([A-Za-z])/g, ' $1 ');
|
|
// Trim
|
|
path = path.replace(/^\s*/, "").replace(/\s*$/, "");
|
|
|
|
// Split on spaces and commas
|
|
path = path.split(/[ ,]+/);
|
|
|
|
// Parse numbers
|
|
for (i = 0; i < path.length; i++) {
|
|
if (!/[a-zA-Z]/.test(path[i])) {
|
|
path[i] = parseFloat(path[i]);
|
|
}
|
|
}
|
|
return path;
|
|
};
|
|
|
|
// A placeholder for map definitions
|
|
Highcharts.maps = {};
|
|
|
|
/**
|
|
* Override to use the extreme coordinates from the SVG shape, not the
|
|
* data values
|
|
*/
|
|
wrap(Axis.prototype, 'getSeriesExtremes', function (proceed) {
|
|
var isXAxis = this.isXAxis,
|
|
dataMin,
|
|
dataMax,
|
|
xData = [];
|
|
|
|
// Remove the xData array and cache it locally so that the proceed method doesn't use it
|
|
each(this.series, function (series, i) {
|
|
if (series.useMapGeometry) {
|
|
xData[i] = series.xData;
|
|
series.xData = [];
|
|
}
|
|
});
|
|
|
|
// Call base to reach normal cartesian series (like mappoint)
|
|
proceed.call(this);
|
|
|
|
// Run extremes logic for map and mapline
|
|
dataMin = pick(this.dataMin, Number.MAX_VALUE);
|
|
dataMax = pick(this.dataMax, Number.MIN_VALUE);
|
|
each(this.series, function (series, i) {
|
|
if (series.useMapGeometry) {
|
|
dataMin = Math.min(dataMin, series[isXAxis ? 'minX' : 'minY']);
|
|
dataMax = Math.max(dataMax, series[isXAxis ? 'maxX' : 'maxY']);
|
|
series.xData = xData[i]; // Reset xData array
|
|
}
|
|
});
|
|
|
|
this.dataMin = dataMin;
|
|
this.dataMax = dataMax;
|
|
});
|
|
|
|
/**
|
|
* Override axis translation to make sure the aspect ratio is always kept
|
|
*/
|
|
wrap(Axis.prototype, 'setAxisTranslation', function (proceed) {
|
|
var chart = this.chart,
|
|
mapRatio,
|
|
plotRatio = chart.plotWidth / chart.plotHeight,
|
|
isXAxis = this.isXAxis,
|
|
adjustedAxisLength,
|
|
xAxis = chart.xAxis[0],
|
|
padAxis;
|
|
|
|
// Run the parent method
|
|
proceed.call(this);
|
|
|
|
// On Y axis, handle both
|
|
if (chart.options.chart.type === 'map' && !isXAxis && xAxis.transA !== UNDEFINED) {
|
|
|
|
// Use the same translation for both axes
|
|
this.transA = xAxis.transA = Math.min(this.transA, xAxis.transA);
|
|
|
|
mapRatio = (xAxis.max - xAxis.min) / (this.max - this.min);
|
|
|
|
// What axis to pad to put the map in the middle
|
|
padAxis = mapRatio > plotRatio ? this : xAxis;
|
|
|
|
// Pad it
|
|
adjustedAxisLength = (padAxis.max - padAxis.min) * padAxis.transA;
|
|
padAxis.minPixelPadding = (padAxis.len - adjustedAxisLength) / 2;
|
|
}
|
|
});
|
|
|
|
|
|
//--- Start zooming and panning features
|
|
|
|
wrap(Chart.prototype, 'render', function (proceed) {
|
|
var chart = this,
|
|
mapNavigation = chart.options.mapNavigation;
|
|
|
|
proceed.call(chart);
|
|
|
|
// Render the plus and minus buttons
|
|
chart.renderMapNavigation();
|
|
|
|
// Add the double click event
|
|
if (mapNavigation.zoomOnDoubleClick) {
|
|
Highcharts.addEvent(chart.container, 'dblclick', function (e) {
|
|
chart.pointer.onContainerDblClick(e);
|
|
});
|
|
}
|
|
|
|
// Add the mousewheel event
|
|
if (mapNavigation.zoomOnMouseWheel) {
|
|
Highcharts.addEvent(chart.container, document.onmousewheel === undefined ? 'DOMMouseScroll' : 'mousewheel', function (e) {
|
|
chart.pointer.onContainerMouseWheel(e);
|
|
});
|
|
}
|
|
});
|
|
|
|
// Extend the Pointer
|
|
extend(Pointer.prototype, {
|
|
|
|
/**
|
|
* The event handler for the doubleclick event
|
|
*/
|
|
onContainerDblClick: function (e) {
|
|
var chart = this.chart;
|
|
|
|
e = this.normalize(e);
|
|
|
|
if (chart.isInsidePlot(e.chartX - chart.plotLeft, e.chartY - chart.plotTop)) {
|
|
chart.mapZoom(
|
|
0.5,
|
|
chart.xAxis[0].toValue(e.chartX),
|
|
chart.yAxis[0].toValue(e.chartY)
|
|
);
|
|
}
|
|
},
|
|
|
|
/**
|
|
* The event handler for the mouse scroll event
|
|
*/
|
|
onContainerMouseWheel: function (e) {
|
|
var chart = this.chart,
|
|
delta;
|
|
|
|
e = this.normalize(e);
|
|
|
|
// Firefox uses e.detail, WebKit and IE uses wheelDelta
|
|
delta = e.detail || -(e.wheelDelta / 120);
|
|
if (chart.isInsidePlot(e.chartX - chart.plotLeft, e.chartY - chart.plotTop)) {
|
|
chart.mapZoom(
|
|
delta > 0 ? 2 : 0.5,
|
|
chart.xAxis[0].toValue(e.chartX),
|
|
chart.yAxis[0].toValue(e.chartY)
|
|
);
|
|
}
|
|
}
|
|
});
|
|
// Implement the pinchType option
|
|
wrap(Pointer.prototype, 'init', function (proceed, chart, options) {
|
|
|
|
proceed.call(this, chart, options);
|
|
|
|
// Pinch status
|
|
if (options.mapNavigation.enableTouchZoom) {
|
|
this.pinchX = this.pinchHor =
|
|
this.pinchY = this.pinchVert = true;
|
|
}
|
|
});
|
|
|
|
// Add events to the Chart object itself
|
|
extend(Chart.prototype, {
|
|
renderMapNavigation: function () {
|
|
var chart = this,
|
|
options = this.options.mapNavigation,
|
|
buttons = options.buttons,
|
|
n,
|
|
button,
|
|
buttonOptions,
|
|
outerHandler = function () {
|
|
this.handler.call(chart);
|
|
};
|
|
|
|
if (options.enableButtons) {
|
|
for (n in buttons) {
|
|
if (buttons.hasOwnProperty(n)) {
|
|
buttonOptions = merge(options.buttonOptions, buttons[n]);
|
|
|
|
button = chart.renderer.button(buttonOptions.text, 0, 0, outerHandler)
|
|
.attr({
|
|
width: buttonOptions.width,
|
|
height: buttonOptions.height
|
|
})
|
|
.css(buttonOptions.style)
|
|
.add();
|
|
button.handler = buttonOptions.onclick;
|
|
button.align(extend(buttonOptions, { width: button.width, height: button.height }), null, 'spacingBox');
|
|
}
|
|
}
|
|
}
|
|
},
|
|
|
|
/**
|
|
* Fit an inner box to an outer. If the inner box overflows left or right, align it to the sides of the
|
|
* outer. If it overflows both sides, fit it within the outer. This is a pattern that occurs more places
|
|
* in Highcharts, perhaps it should be elevated to a common utility function.
|
|
*/
|
|
fitToBox: function (inner, outer) {
|
|
each([['x', 'width'], ['y', 'height']], function (dim) {
|
|
var pos = dim[0],
|
|
size = dim[1];
|
|
if (inner[pos] + inner[size] > outer[pos] + outer[size]) { // right overflow
|
|
if (inner[size] > outer[size]) { // the general size is greater, fit fully to outer
|
|
inner[size] = outer[size];
|
|
inner[pos] = outer[pos];
|
|
} else { // align right
|
|
inner[pos] = outer[pos] + outer[size] - inner[size];
|
|
}
|
|
}
|
|
if (inner[size] > outer[size]) {
|
|
inner[size] = outer[size];
|
|
}
|
|
if (inner[pos] < outer[pos]) {
|
|
inner[pos] = outer[pos];
|
|
}
|
|
|
|
});
|
|
|
|
return inner;
|
|
},
|
|
|
|
/**
|
|
* Zoom the map in or out by a certain amount. Less than 1 zooms in, greater than 1 zooms out.
|
|
*/
|
|
mapZoom: function (howMuch, centerXArg, centerYArg) {
|
|
|
|
if (this.isMapZooming) {
|
|
return;
|
|
}
|
|
|
|
var chart = this,
|
|
xAxis = chart.xAxis[0],
|
|
xRange = xAxis.max - xAxis.min,
|
|
centerX = pick(centerXArg, xAxis.min + xRange / 2),
|
|
newXRange = xRange * howMuch,
|
|
yAxis = chart.yAxis[0],
|
|
yRange = yAxis.max - yAxis.min,
|
|
centerY = pick(centerYArg, yAxis.min + yRange / 2),
|
|
newYRange = yRange * howMuch,
|
|
newXMin = centerX - newXRange / 2,
|
|
newYMin = centerY - newYRange / 2,
|
|
animation = pick(chart.options.chart.animation, true),
|
|
delay,
|
|
newExt = chart.fitToBox({
|
|
x: newXMin,
|
|
y: newYMin,
|
|
width: newXRange,
|
|
height: newYRange
|
|
}, {
|
|
x: xAxis.dataMin,
|
|
y: yAxis.dataMin,
|
|
width: xAxis.dataMax - xAxis.dataMin,
|
|
height: yAxis.dataMax - yAxis.dataMin
|
|
});
|
|
|
|
xAxis.setExtremes(newExt.x, newExt.x + newExt.width, false);
|
|
yAxis.setExtremes(newExt.y, newExt.y + newExt.height, false);
|
|
|
|
// Prevent zooming until this one is finished animating
|
|
delay = animation ? animation.duration || 500 : 0;
|
|
if (delay) {
|
|
chart.isMapZooming = true;
|
|
setTimeout(function () {
|
|
chart.isMapZooming = false;
|
|
}, delay);
|
|
}
|
|
|
|
chart.redraw();
|
|
}
|
|
});
|
|
|
|
/**
|
|
* Extend the default options with map options
|
|
*/
|
|
plotOptions.map = merge(plotOptions.scatter, {
|
|
animation: false, // makes the complex shapes slow
|
|
nullColor: '#F8F8F8',
|
|
borderColor: 'silver',
|
|
borderWidth: 1,
|
|
marker: null,
|
|
stickyTracking: false,
|
|
dataLabels: {
|
|
verticalAlign: 'middle'
|
|
},
|
|
turboThreshold: 0,
|
|
tooltip: {
|
|
followPointer: true,
|
|
pointFormat: '{point.name}: {point.y}<br/>'
|
|
},
|
|
states: {
|
|
normal: {
|
|
animation: true
|
|
}
|
|
}
|
|
});
|
|
|
|
var MapAreaPoint = Highcharts.extendClass(Point, {
|
|
/**
|
|
* Extend the Point object to split paths
|
|
*/
|
|
applyOptions: function (options, x) {
|
|
|
|
var point = Point.prototype.applyOptions.call(this, options, x);
|
|
|
|
if (point.path && typeof point.path === 'string') {
|
|
point.path = point.options.path = Highcharts.splitPath(point.path);
|
|
}
|
|
|
|
return point;
|
|
},
|
|
/**
|
|
* Stop the fade-out
|
|
*/
|
|
onMouseOver: function () {
|
|
clearTimeout(this.colorInterval);
|
|
Point.prototype.onMouseOver.call(this);
|
|
},
|
|
/**
|
|
* Custom animation for tweening out the colors. Animation reduces blinking when hovering
|
|
* over islands and coast lines. We run a custom implementation of animation becuase we
|
|
* need to be able to run this independently from other animations like zoom redraw. Also,
|
|
* adding color animation to the adapters would introduce almost the same amount of code.
|
|
*/
|
|
onMouseOut: function () {
|
|
var point = this,
|
|
start = +new Date(),
|
|
normalColor = Color(point.options.color),
|
|
hoverColor = Color(point.pointAttr.hover.fill),
|
|
animation = point.series.options.states.normal.animation,
|
|
duration = animation && (animation.duration || 500);
|
|
|
|
if (duration && normalColor.rgba.length === 4 && hoverColor.rgba.length === 4) {
|
|
delete point.pointAttr[''].fill; // avoid resetting it in Point.setState
|
|
|
|
clearTimeout(point.colorInterval);
|
|
point.colorInterval = setInterval(function () {
|
|
var pos = (new Date() - start) / duration,
|
|
graphic = point.graphic;
|
|
if (pos > 1) {
|
|
pos = 1;
|
|
}
|
|
if (graphic) {
|
|
graphic.attr('fill', tweenColors(hoverColor, normalColor, pos));
|
|
}
|
|
if (pos >= 1) {
|
|
clearTimeout(point.colorInterval);
|
|
}
|
|
}, 13);
|
|
}
|
|
Point.prototype.onMouseOut.call(point);
|
|
}
|
|
});
|
|
|
|
/**
|
|
* Add the series type
|
|
*/
|
|
seriesTypes.map = Highcharts.extendClass(seriesTypes.scatter, {
|
|
type: 'map',
|
|
pointAttrToOptions: { // mapping between SVG attributes and the corresponding options
|
|
stroke: 'borderColor',
|
|
'stroke-width': 'borderWidth',
|
|
fill: 'color'
|
|
},
|
|
colorKey: 'y',
|
|
pointClass: MapAreaPoint,
|
|
trackerGroups: ['group', 'markerGroup', 'dataLabelsGroup'],
|
|
getSymbol: noop,
|
|
supportsDrilldown: true,
|
|
getExtremesFromAll: true,
|
|
useMapGeometry: true, // get axis extremes from paths, not values
|
|
init: function (chart) {
|
|
var series = this,
|
|
valueDecimals = chart.options.legend.valueDecimals,
|
|
legendItems = [],
|
|
name,
|
|
from,
|
|
to,
|
|
fromLabel,
|
|
toLabel,
|
|
colorRange,
|
|
valueRanges,
|
|
gradientColor,
|
|
grad,
|
|
tmpLabel,
|
|
horizontal = chart.options.legend.layout === 'horizontal';
|
|
|
|
|
|
Highcharts.Series.prototype.init.apply(this, arguments);
|
|
colorRange = series.options.colorRange;
|
|
valueRanges = series.options.valueRanges;
|
|
|
|
if (valueRanges) {
|
|
each(valueRanges, function (range) {
|
|
from = range.from;
|
|
to = range.to;
|
|
|
|
// Assemble the default name. This can be overridden by legend.options.labelFormatter
|
|
name = '';
|
|
if (from === UNDEFINED) {
|
|
name = '< ';
|
|
} else if (to === UNDEFINED) {
|
|
name = '> ';
|
|
}
|
|
if (from !== UNDEFINED) {
|
|
name += numberFormat(from, valueDecimals);
|
|
}
|
|
if (from !== UNDEFINED && to !== UNDEFINED) {
|
|
name += ' - ';
|
|
}
|
|
if (to !== UNDEFINED) {
|
|
name += numberFormat(to, valueDecimals);
|
|
}
|
|
|
|
// Add a mock object to the legend items
|
|
legendItems.push(Highcharts.extend({
|
|
chart: series.chart,
|
|
name: name,
|
|
options: {},
|
|
drawLegendSymbol: seriesTypes.area.prototype.drawLegendSymbol,
|
|
visible: true,
|
|
setState: function () {},
|
|
setVisible: function () {}
|
|
}, range));
|
|
});
|
|
series.legendItems = legendItems;
|
|
|
|
} else if (colorRange) {
|
|
|
|
from = colorRange.from;
|
|
to = colorRange.to;
|
|
fromLabel = colorRange.fromLabel;
|
|
toLabel = colorRange.toLabel;
|
|
|
|
// Flips linearGradient variables and label text.
|
|
grad = horizontal ? [0, 0, 1, 0] : [0, 1, 0, 0];
|
|
if (!horizontal) {
|
|
tmpLabel = fromLabel;
|
|
fromLabel = toLabel;
|
|
toLabel = tmpLabel;
|
|
}
|
|
|
|
// Creates color gradient.
|
|
gradientColor = {
|
|
linearGradient: { x1: grad[0], y1: grad[1], x2: grad[2], y2: grad[3] },
|
|
stops:
|
|
[
|
|
[0, from],
|
|
[1, to]
|
|
]
|
|
};
|
|
|
|
// Add a mock object to the legend items.
|
|
legendItems = [{
|
|
chart: series.chart,
|
|
options: {},
|
|
fromLabel: fromLabel,
|
|
toLabel: toLabel,
|
|
color: gradientColor,
|
|
drawLegendSymbol: this.drawLegendSymbolGradient,
|
|
visible: true,
|
|
setState: function () {},
|
|
setVisible: function () {}
|
|
}];
|
|
|
|
series.legendItems = legendItems;
|
|
}
|
|
},
|
|
|
|
/**
|
|
* If neither valueRanges nor colorRanges are defined, use basic area symbol.
|
|
*/
|
|
drawLegendSymbol: seriesTypes.area.prototype.drawLegendSymbol,
|
|
|
|
/**
|
|
* Gets the series' symbol in the legend and extended legend with more information.
|
|
*
|
|
* @param {Object} legend The legend object
|
|
* @param {Object} item The series (this) or point
|
|
*/
|
|
drawLegendSymbolGradient: function (legend, item) {
|
|
var spacing = legend.options.symbolPadding,
|
|
padding = pick(legend.options.padding, 8),
|
|
positionY,
|
|
positionX,
|
|
gradientSize = this.chart.renderer.fontMetrics(legend.options.itemStyle.fontSize).h,
|
|
horizontal = legend.options.layout === 'horizontal',
|
|
box1,
|
|
box2,
|
|
box3,
|
|
rectangleLength = pick(legend.options.rectangleLength, 200);
|
|
|
|
// Set local variables based on option.
|
|
if (horizontal) {
|
|
positionY = -(spacing / 2);
|
|
positionX = 0;
|
|
} else {
|
|
positionY = -rectangleLength + legend.baseline - (spacing / 2);
|
|
positionX = padding + gradientSize;
|
|
}
|
|
|
|
// Creates the from text.
|
|
item.fromText = this.chart.renderer.text(
|
|
item.fromLabel, // Text.
|
|
positionX, // Lower left x.
|
|
positionY // Lower left y.
|
|
).attr({
|
|
zIndex: 2
|
|
}).add(item.legendGroup);
|
|
box1 = item.fromText.getBBox();
|
|
|
|
// Creates legend symbol.
|
|
// Ternary changes variables based on option.
|
|
item.legendSymbol = this.chart.renderer.rect(
|
|
horizontal ? box1.x + box1.width + spacing : box1.x - gradientSize - spacing, // Upper left x.
|
|
box1.y, // Upper left y.
|
|
horizontal ? rectangleLength : gradientSize, // Width.
|
|
horizontal ? gradientSize : rectangleLength, // Height.
|
|
2 // Corner radius.
|
|
).attr({
|
|
zIndex: 1
|
|
}).add(item.legendGroup);
|
|
box2 = item.legendSymbol.getBBox();
|
|
|
|
// Creates the to text.
|
|
// Vertical coordinate changed based on option.
|
|
item.toText = this.chart.renderer.text(
|
|
item.toLabel,
|
|
box2.x + box2.width + spacing,
|
|
horizontal ? positionY : box2.y + box2.height - spacing
|
|
).attr({
|
|
zIndex: 2
|
|
}).add(item.legendGroup);
|
|
box3 = item.toText.getBBox();
|
|
|
|
// Changes legend box settings based on option.
|
|
if (horizontal) {
|
|
legend.offsetWidth = box1.width + box2.width + box3.width + (spacing * 2) + padding;
|
|
legend.itemY = gradientSize + padding;
|
|
} else {
|
|
legend.offsetWidth = Math.max(box1.width, box3.width) + (spacing) + box2.width + padding;
|
|
legend.itemY = box2.height + padding;
|
|
legend.itemX = spacing;
|
|
}
|
|
},
|
|
|
|
/**
|
|
* Get the bounding box of all paths in the map combined.
|
|
*/
|
|
getBox: function (paths) {
|
|
var maxX = Number.MIN_VALUE,
|
|
minX = Number.MAX_VALUE,
|
|
maxY = Number.MIN_VALUE,
|
|
minY = Number.MAX_VALUE;
|
|
|
|
|
|
// Find the bounding box
|
|
each(paths || this.options.data, function (point) {
|
|
var path = point.path,
|
|
i = path.length,
|
|
even = false, // while loop reads from the end
|
|
pointMaxX = Number.MIN_VALUE,
|
|
pointMinX = Number.MAX_VALUE,
|
|
pointMaxY = Number.MIN_VALUE,
|
|
pointMinY = Number.MAX_VALUE;
|
|
|
|
while (i--) {
|
|
if (typeof path[i] === 'number' && !isNaN(path[i])) {
|
|
if (even) { // even = x
|
|
pointMaxX = Math.max(pointMaxX, path[i]);
|
|
pointMinX = Math.min(pointMinX, path[i]);
|
|
} else { // odd = Y
|
|
pointMaxY = Math.max(pointMaxY, path[i]);
|
|
pointMinY = Math.min(pointMinY, path[i]);
|
|
}
|
|
even = !even;
|
|
}
|
|
}
|
|
// Cache point bounding box for use to position data labels
|
|
point._maxX = pointMaxX;
|
|
point._minX = pointMinX;
|
|
point._maxY = pointMaxY;
|
|
point._minY = pointMinY;
|
|
|
|
maxX = Math.max(maxX, pointMaxX);
|
|
minX = Math.min(minX, pointMinX);
|
|
maxY = Math.max(maxY, pointMaxY);
|
|
minY = Math.min(minY, pointMinY);
|
|
});
|
|
this.minY = minY;
|
|
this.maxY = maxY;
|
|
this.minX = minX;
|
|
this.maxX = maxX;
|
|
|
|
},
|
|
|
|
|
|
|
|
/**
|
|
* Translate the path so that it automatically fits into the plot area box
|
|
* @param {Object} path
|
|
*/
|
|
translatePath: function (path) {
|
|
|
|
var series = this,
|
|
even = false, // while loop reads from the end
|
|
xAxis = series.xAxis,
|
|
yAxis = series.yAxis,
|
|
i;
|
|
|
|
// Preserve the original
|
|
path = [].concat(path);
|
|
|
|
// Do the translation
|
|
i = path.length;
|
|
while (i--) {
|
|
if (typeof path[i] === 'number') {
|
|
if (even) { // even = x
|
|
path[i] = Math.round(xAxis.translate(path[i]));
|
|
} else { // odd = Y
|
|
path[i] = Math.round(yAxis.len - yAxis.translate(path[i]));
|
|
}
|
|
even = !even;
|
|
}
|
|
}
|
|
return path;
|
|
},
|
|
|
|
setData: function () {
|
|
Highcharts.Series.prototype.setData.apply(this, arguments);
|
|
this.getBox();
|
|
},
|
|
|
|
/**
|
|
* Add the path option for data points. Find the max value for color calculation.
|
|
*/
|
|
translate: function () {
|
|
var series = this,
|
|
dataMin = Number.MAX_VALUE,
|
|
dataMax = Number.MIN_VALUE;
|
|
|
|
series.generatePoints();
|
|
|
|
each(series.data, function (point) {
|
|
|
|
point.shapeType = 'path';
|
|
point.shapeArgs = {
|
|
d: series.translatePath(point.path)
|
|
};
|
|
|
|
// TODO: do point colors in drawPoints instead of point.init
|
|
if (typeof point.y === 'number') {
|
|
if (point.y > dataMax) {
|
|
dataMax = point.y;
|
|
} else if (point.y < dataMin) {
|
|
dataMin = point.y;
|
|
}
|
|
}
|
|
});
|
|
|
|
series.translateColors(dataMin, dataMax);
|
|
},
|
|
|
|
/**
|
|
* In choropleth maps, the color is a result of the value, so this needs translation too
|
|
*/
|
|
translateColors: function (dataMin, dataMax) {
|
|
|
|
var seriesOptions = this.options,
|
|
valueRanges = seriesOptions.valueRanges,
|
|
colorRange = seriesOptions.colorRange,
|
|
colorKey = this.colorKey,
|
|
from,
|
|
to;
|
|
|
|
if (colorRange) {
|
|
from = Color(colorRange.from);
|
|
to = Color(colorRange.to);
|
|
}
|
|
|
|
each(this.data, function (point) {
|
|
var value = point[colorKey],
|
|
range,
|
|
color,
|
|
i,
|
|
pos;
|
|
|
|
if (valueRanges) {
|
|
i = valueRanges.length;
|
|
while (i--) {
|
|
range = valueRanges[i];
|
|
from = range.from;
|
|
to = range.to;
|
|
if ((from === UNDEFINED || value >= from) && (to === UNDEFINED || value <= to)) {
|
|
color = range.color;
|
|
break;
|
|
}
|
|
|
|
}
|
|
} else if (colorRange && value !== undefined) {
|
|
|
|
pos = 1 - ((dataMax - value) / (dataMax - dataMin));
|
|
color = value === null ? seriesOptions.nullColor : tweenColors(from, to, pos);
|
|
}
|
|
|
|
if (color) {
|
|
point.color = null; // reset from previous drilldowns, use of the same data options
|
|
point.options.color = color;
|
|
}
|
|
});
|
|
},
|
|
|
|
drawGraph: noop,
|
|
|
|
/**
|
|
* We need the points' bounding boxes in order to draw the data labels, so
|
|
* we skip it now and call if from drawPoints instead.
|
|
*/
|
|
drawDataLabels: noop,
|
|
|
|
/**
|
|
* Use the drawPoints method of column, that is able to handle simple shapeArgs.
|
|
* Extend it by assigning the tooltip position.
|
|
*/
|
|
drawPoints: function () {
|
|
var series = this,
|
|
xAxis = series.xAxis,
|
|
yAxis = series.yAxis,
|
|
colorKey = series.colorKey;
|
|
|
|
// Make points pass test in drawing
|
|
each(series.data, function (point) {
|
|
point.plotY = 1; // pass null test in column.drawPoints
|
|
if (point[colorKey] === null) {
|
|
point[colorKey] = 0;
|
|
point.isNull = true;
|
|
}
|
|
});
|
|
|
|
// Draw them
|
|
seriesTypes.column.prototype.drawPoints.apply(series);
|
|
|
|
each(series.data, function (point) {
|
|
|
|
var dataLabels = point.dataLabels,
|
|
minX = xAxis.toPixels(point._minX, true),
|
|
maxX = xAxis.toPixels(point._maxX, true),
|
|
minY = yAxis.toPixels(point._minY, true),
|
|
maxY = yAxis.toPixels(point._maxY, true);
|
|
|
|
point.plotX = Math.round(minX + (maxX - minX) * pick(dataLabels && dataLabels.anchorX, 0.5));
|
|
point.plotY = Math.round(minY + (maxY - minY) * pick(dataLabels && dataLabels.anchorY, 0.5));
|
|
|
|
|
|
// Reset escaped null points
|
|
if (point.isNull) {
|
|
point[colorKey] = null;
|
|
}
|
|
});
|
|
|
|
// Now draw the data labels
|
|
Highcharts.Series.prototype.drawDataLabels.call(series);
|
|
|
|
},
|
|
|
|
/**
|
|
* Animate in the new series from the clicked point in the old series.
|
|
* Depends on the drilldown.js module
|
|
*/
|
|
animateDrilldown: function (init) {
|
|
var toBox = this.chart.plotBox,
|
|
level = this.chart.drilldownLevels[this.chart.drilldownLevels.length - 1],
|
|
fromBox = level.bBox,
|
|
animationOptions = this.chart.options.drilldown.animation,
|
|
scale;
|
|
|
|
if (!init) {
|
|
|
|
scale = Math.min(fromBox.width / toBox.width, fromBox.height / toBox.height);
|
|
level.shapeArgs = {
|
|
scaleX: scale,
|
|
scaleY: scale,
|
|
translateX: fromBox.x,
|
|
translateY: fromBox.y
|
|
};
|
|
|
|
// TODO: Animate this.group instead
|
|
each(this.points, function (point) {
|
|
|
|
point.graphic
|
|
.attr(level.shapeArgs)
|
|
.animate({
|
|
scaleX: 1,
|
|
scaleY: 1,
|
|
translateX: 0,
|
|
translateY: 0
|
|
}, animationOptions);
|
|
|
|
});
|
|
|
|
delete this.animate;
|
|
}
|
|
|
|
},
|
|
|
|
/**
|
|
* When drilling up, pull out the individual point graphics from the lower series
|
|
* and animate them into the origin point in the upper series.
|
|
*/
|
|
animateDrillupFrom: function (level) {
|
|
seriesTypes.column.prototype.animateDrillupFrom.call(this, level);
|
|
},
|
|
|
|
|
|
/**
|
|
* When drilling up, keep the upper series invisible until the lower series has
|
|
* moved into place
|
|
*/
|
|
animateDrillupTo: function (init) {
|
|
seriesTypes.column.prototype.animateDrillupTo.call(this, init);
|
|
}
|
|
});
|
|
|
|
|
|
// The mapline series type
|
|
plotOptions.mapline = merge(plotOptions.map, {
|
|
lineWidth: 1,
|
|
backgroundColor: 'none'
|
|
});
|
|
seriesTypes.mapline = Highcharts.extendClass(seriesTypes.map, {
|
|
type: 'mapline',
|
|
pointAttrToOptions: { // mapping between SVG attributes and the corresponding options
|
|
stroke: 'color',
|
|
'stroke-width': 'lineWidth',
|
|
fill: 'backgroundColor'
|
|
},
|
|
drawLegendSymbol: seriesTypes.line.prototype.drawLegendSymbol
|
|
});
|
|
|
|
// The mappoint series type
|
|
plotOptions.mappoint = merge(plotOptions.scatter, {
|
|
dataLabels: {
|
|
enabled: true,
|
|
format: '{point.name}',
|
|
color: 'black',
|
|
style: {
|
|
textShadow: '0 0 5px white'
|
|
}
|
|
}
|
|
});
|
|
seriesTypes.mappoint = Highcharts.extendClass(seriesTypes.scatter, {
|
|
type: 'mappoint'
|
|
});
|
|
|
|
|
|
|
|
/**
|
|
* A wrapper for Chart with all the default values for a Map
|
|
*/
|
|
Highcharts.Map = function (options, callback) {
|
|
|
|
var hiddenAxis = {
|
|
endOnTick: false,
|
|
gridLineWidth: 0,
|
|
labels: {
|
|
enabled: false
|
|
},
|
|
lineWidth: 0,
|
|
minPadding: 0,
|
|
maxPadding: 0,
|
|
startOnTick: false,
|
|
tickWidth: 0,
|
|
title: null
|
|
},
|
|
seriesOptions;
|
|
|
|
// Don't merge the data
|
|
seriesOptions = options.series;
|
|
options.series = null;
|
|
|
|
options = merge({
|
|
chart: {
|
|
type: 'map',
|
|
panning: 'xy'
|
|
},
|
|
xAxis: hiddenAxis,
|
|
yAxis: merge(hiddenAxis, { reversed: true })
|
|
},
|
|
options, // user's options
|
|
|
|
{ // forced options
|
|
chart: {
|
|
inverted: false
|
|
}
|
|
});
|
|
|
|
options.series = seriesOptions;
|
|
|
|
|
|
return new Highcharts.Chart(options, callback);
|
|
};
|
|
}(Highcharts));
|