.=< { Star Gans Tq } >=.
/**
* @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));