添加项目文件。
This commit is contained in:
jl
627
Epost.TestToolsWeb/Content/code/modules/pattern-fill.src.js
Normal file
627
Epost.TestToolsWeb/Content/code/modules/pattern-fill.src.js
Normal file
@ -0,0 +1,627 @@
|
||||
/**
|
||||
* @license Highcharts JS v7.0.0 (2018-12-11)
|
||||
* Module for adding patterns and images as point fills.
|
||||
*
|
||||
* (c) 2010-2018 Highsoft AS
|
||||
* Author: Torstein Hønsi, Øystein Moseng
|
||||
*
|
||||
* License: www.highcharts.com/license
|
||||
*/
|
||||
'use strict';
|
||||
(function (factory) {
|
||||
if (typeof module === 'object' && module.exports) {
|
||||
module.exports = factory;
|
||||
} else if (typeof define === 'function' && define.amd) {
|
||||
define(function () {
|
||||
return factory;
|
||||
});
|
||||
} else {
|
||||
factory(typeof Highcharts !== 'undefined' ? Highcharts : undefined);
|
||||
}
|
||||
}(function (Highcharts) {
|
||||
(function (H) {
|
||||
/* *
|
||||
* Module for using patterns or images as point fills.
|
||||
*
|
||||
* (c) 2010-2018 Highsoft AS
|
||||
* Author: Torstein Hønsi, Øystein Moseng
|
||||
*
|
||||
* License: www.highcharts.com/license
|
||||
*/
|
||||
|
||||
/**
|
||||
* Pattern options
|
||||
*
|
||||
* @interface Highcharts.PatternOptionsObject
|
||||
*//**
|
||||
* URL to an image to use as the pattern.
|
||||
* @name Highcharts.PatternOptionsObject#image
|
||||
* @type {string}
|
||||
*//**
|
||||
* Width of the pattern. For images this is automatically set to the width of
|
||||
* the element bounding box if not supplied. For non-image patterns the default
|
||||
* is 32px. Note that automatic resizing of image patterns to fill a bounding
|
||||
* box dynamically is only supported for patterns with an automatically
|
||||
* calculated ID.
|
||||
* @name Highcharts.PatternOptionsObject#with
|
||||
* @type {number}
|
||||
*//**
|
||||
* Analogous to pattern.width.
|
||||
* @name Highcharts.PatternOptionsObject#height
|
||||
* @type {number}
|
||||
*//**
|
||||
* For automatically calculated width and height on images, it is possible to
|
||||
* set an aspect ratio. The image will be zoomed to fill the bounding box,
|
||||
* maintaining the aspect ratio defined.
|
||||
* @name Highcharts.PatternOptionsObject#aspectRatio
|
||||
* @type {number}
|
||||
*//**
|
||||
* Horizontal offset of the pattern. Defaults to 0.
|
||||
* @name Highcharts.PatternOptionsObject#x
|
||||
* @type {number|undefined}
|
||||
*//**
|
||||
* Vertical offset of the pattern. Defaults to 0.
|
||||
* @name Highcharts.PatternOptionsObject#y
|
||||
* @type {number|undefined}
|
||||
*//**
|
||||
* Either an SVG path as string, or an object. As an object, supply the path
|
||||
* string in the `path.d` property. Other supported properties are standard SVG
|
||||
* attributes like `path.stroke` and `path.fill`. If a path is supplied for the
|
||||
* pattern, the `image` property is ignored.
|
||||
* @name Highcharts.PatternOptionsObject#path
|
||||
* @type {string|Highcharts.SVGAttributes}
|
||||
*//**
|
||||
* Pattern color, used as default path stroke.
|
||||
* @name Highcharts.PatternOptionsObject#color
|
||||
* @type {Highcharts.ColorString}
|
||||
*//**
|
||||
* Opacity of the pattern as a float value from 0 to 1.
|
||||
* @name Highcharts.PatternOptionsObject#opacity
|
||||
* @type {number}
|
||||
*//**
|
||||
* ID to assign to the pattern. This is automatically computed if not added, and
|
||||
* identical patterns are reused. To refer to an existing pattern for a
|
||||
* Highcharts color, use `color: "url(#pattern-id)"`.
|
||||
* @name Highcharts.PatternOptionsObject#id
|
||||
* @type {string}
|
||||
*/
|
||||
|
||||
/**
|
||||
* Holds a pattern definition.
|
||||
*
|
||||
* @sample highcharts/series/pattern-fill-area/
|
||||
* Define a custom path pattern
|
||||
* @sample highcharts/series/pattern-fill-pie/
|
||||
* Default patterns and a custom image pattern
|
||||
* @sample maps/demo/pattern-fill-map/
|
||||
* Custom images on map
|
||||
*
|
||||
* @example
|
||||
* // Pattern used as a color option
|
||||
* color: {
|
||||
* pattern: {
|
||||
* path: {
|
||||
* d: 'M 3 3 L 8 3 L 8 8 Z',
|
||||
* fill: '#102045'
|
||||
* },
|
||||
* width: 12,
|
||||
* height: 12,
|
||||
* color: '#907000',
|
||||
* opacity: 0.5
|
||||
* }
|
||||
* }
|
||||
*
|
||||
* @interface Highcharts.PatternObject
|
||||
*//**
|
||||
* Pattern options
|
||||
* @name Highcharts.PatternObject#pattern
|
||||
* @type {Highcharts.PatternOptionsObject}
|
||||
*//**
|
||||
* Animation options for the image pattern loading.
|
||||
* @name Highcharts.PatternObject#animation
|
||||
* @type {boolean|Highcharts.AnimationOptionsObject|undefined}
|
||||
*/
|
||||
|
||||
|
||||
|
||||
var wrap = H.wrap,
|
||||
merge = H.merge,
|
||||
pick = H.pick;
|
||||
|
||||
|
||||
/**
|
||||
* Utility function to compute a hash value from an object. Modified Java
|
||||
* String.hashCode implementation in JS. Use the preSeed parameter to add an
|
||||
* additional seeding step.
|
||||
*
|
||||
* @private
|
||||
* @function hashFromObject
|
||||
*
|
||||
* @param {object} obj
|
||||
* The javascript object to compute the hash from.
|
||||
*
|
||||
* @param {boolean} [preSeed=false]
|
||||
* Add an optional preSeed stage.
|
||||
*
|
||||
* @return {string}
|
||||
* The computed hash.
|
||||
*/
|
||||
function hashFromObject(obj, preSeed) {
|
||||
var str = JSON.stringify(obj),
|
||||
strLen = str.length || 0,
|
||||
hash = 0,
|
||||
i = 0,
|
||||
char,
|
||||
seedStep;
|
||||
|
||||
if (preSeed) {
|
||||
seedStep = Math.max(Math.floor(strLen / 500), 1);
|
||||
for (var a = 0; a < strLen; a += seedStep) {
|
||||
hash += str.charCodeAt(a);
|
||||
}
|
||||
hash = hash & hash;
|
||||
}
|
||||
|
||||
for (; i < strLen; ++i) {
|
||||
char = str.charCodeAt(i);
|
||||
hash = ((hash << 5) - hash) + char;
|
||||
hash = hash & hash;
|
||||
}
|
||||
|
||||
return hash.toString(16).replace('-', '1');
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Set dimensions on pattern from point. This function will set internal
|
||||
* pattern._width/_height properties if width and height are not both already
|
||||
* set. We only do this on image patterns. The _width/_height properties are set
|
||||
* to the size of the bounding box of the point, optionally taking aspect ratio
|
||||
* into account. If only one of width or height are supplied as options, the
|
||||
* undefined option is calculated as above.
|
||||
*
|
||||
* @private
|
||||
* @function Highcharts.Point#calculatePatternDimensions
|
||||
*
|
||||
* @param {Highcharts.PatternObject} pattern
|
||||
* The pattern to set dimensions on.
|
||||
*/
|
||||
H.Point.prototype.calculatePatternDimensions = function (pattern) {
|
||||
if (pattern.width && pattern.height) {
|
||||
return;
|
||||
}
|
||||
|
||||
var bBox = this.graphic && (
|
||||
this.graphic.getBBox &&
|
||||
this.graphic.getBBox(true) ||
|
||||
this.graphic.element &&
|
||||
this.graphic.element.getBBox()
|
||||
) || {},
|
||||
shapeArgs = this.shapeArgs;
|
||||
|
||||
// Prefer using shapeArgs, as it is animation agnostic
|
||||
if (shapeArgs) {
|
||||
bBox.width = shapeArgs.width || bBox.width;
|
||||
bBox.height = shapeArgs.height || bBox.height;
|
||||
bBox.x = shapeArgs.x || bBox.x;
|
||||
bBox.y = shapeArgs.y || bBox.y;
|
||||
}
|
||||
|
||||
// For images we stretch to bounding box
|
||||
if (pattern.image) {
|
||||
// If we do not have a bounding box at this point, simply add a defer
|
||||
// key and pick this up in the fillSetter handler, where the bounding
|
||||
// box should exist.
|
||||
if (!bBox.width || !bBox.height) {
|
||||
pattern._width = 'defer';
|
||||
pattern._height = 'defer';
|
||||
return;
|
||||
}
|
||||
|
||||
// Handle aspect ratio filling
|
||||
if (pattern.aspectRatio) {
|
||||
bBox.aspectRatio = bBox.width / bBox.height;
|
||||
if (pattern.aspectRatio > bBox.aspectRatio) {
|
||||
// Height of bBox will determine width
|
||||
bBox.aspectWidth = bBox.height * pattern.aspectRatio;
|
||||
} else {
|
||||
// Width of bBox will determine height
|
||||
bBox.aspectHeight = bBox.width / pattern.aspectRatio;
|
||||
}
|
||||
}
|
||||
|
||||
// We set the width/height on internal properties to differentiate
|
||||
// between the options set by a user and by this function.
|
||||
pattern._width = pattern.width ||
|
||||
Math.ceil(bBox.aspectWidth || bBox.width);
|
||||
pattern._height = pattern.height ||
|
||||
Math.ceil(bBox.aspectHeight || bBox.height);
|
||||
}
|
||||
|
||||
// Set x/y accordingly, centering if using aspect ratio, otherwise adjusting
|
||||
// so bounding box corner is 0,0 of pattern.
|
||||
if (!pattern.width) {
|
||||
pattern._x = pattern.x || 0;
|
||||
pattern._x += bBox.x - Math.round(
|
||||
bBox.aspectWidth ?
|
||||
Math.abs(bBox.aspectWidth - bBox.width) / 2 :
|
||||
0
|
||||
);
|
||||
}
|
||||
if (!pattern.height) {
|
||||
pattern._y = pattern.y || 0;
|
||||
pattern._y += bBox.y - Math.round(
|
||||
bBox.aspectHeight ?
|
||||
Math.abs(bBox.aspectHeight - bBox.height) / 2 :
|
||||
0
|
||||
);
|
||||
}
|
||||
};
|
||||
|
||||
/**
|
||||
* Add a pattern to the renderer.
|
||||
*
|
||||
* @private
|
||||
* @function Highcharts.SVGRenderer#addPattern
|
||||
*
|
||||
* @param {Highcharts.PatternObject} options
|
||||
* The pattern options.
|
||||
*
|
||||
* @return {Highcharts.SVGElement|undefined}
|
||||
* The added pattern. Undefined if the pattern already exists.
|
||||
*/
|
||||
H.SVGRenderer.prototype.addPattern = function (options, animation) {
|
||||
var pattern,
|
||||
animate = H.pick(animation, true),
|
||||
animationOptions = H.animObject(animate),
|
||||
path,
|
||||
defaultSize = 32,
|
||||
width = options.width || options._width || defaultSize,
|
||||
height = options.height || options._height || defaultSize,
|
||||
color = options.color || '#343434',
|
||||
id = options.id,
|
||||
ren = this,
|
||||
rect = function (fill) {
|
||||
ren.rect(0, 0, width, height)
|
||||
.attr({
|
||||
fill: fill
|
||||
})
|
||||
.add(pattern);
|
||||
},
|
||||
attribs;
|
||||
|
||||
if (!id) {
|
||||
this.idCounter = this.idCounter || 0;
|
||||
id = 'highcharts-pattern-' + this.idCounter;
|
||||
++this.idCounter;
|
||||
}
|
||||
|
||||
// Do nothing if ID already exists
|
||||
this.defIds = this.defIds || [];
|
||||
if (this.defIds.indexOf(id) > -1) {
|
||||
return;
|
||||
}
|
||||
|
||||
// Store ID in list to avoid duplicates
|
||||
this.defIds.push(id);
|
||||
|
||||
// Create pattern element
|
||||
pattern = this.createElement('pattern').attr({
|
||||
id: id,
|
||||
patternUnits: 'userSpaceOnUse',
|
||||
width: width,
|
||||
height: height,
|
||||
x: options._x || options.x || 0,
|
||||
y: options._y || options.y || 0
|
||||
}).add(this.defs);
|
||||
|
||||
// Set id on the SVGRenderer object
|
||||
pattern.id = id;
|
||||
|
||||
// Use an SVG path for the pattern
|
||||
if (options.path) {
|
||||
path = options.path;
|
||||
|
||||
// The background
|
||||
if (path.fill) {
|
||||
rect(path.fill);
|
||||
}
|
||||
|
||||
// The pattern
|
||||
attribs = {
|
||||
'd': path.d || path
|
||||
};
|
||||
if (!this.styledMode) {
|
||||
attribs.stroke = path.stroke || color;
|
||||
attribs['stroke-width'] = path.strokeWidth || 2;
|
||||
}
|
||||
this.createElement('path').attr(attribs).add(pattern);
|
||||
pattern.color = color;
|
||||
|
||||
// Image pattern
|
||||
} else if (options.image) {
|
||||
if (animate) {
|
||||
this.image(
|
||||
options.image, 0, 0, width, height, function () {
|
||||
// Onload
|
||||
this.animate({
|
||||
opacity: pick(options.opacity, 1)
|
||||
}, animationOptions);
|
||||
H.removeEvent(this.element, 'load');
|
||||
}
|
||||
).attr({ opacity: 0 }).add(pattern);
|
||||
} else {
|
||||
this.image(options.image, 0, 0, width, height).add(pattern);
|
||||
}
|
||||
}
|
||||
|
||||
// For non-animated patterns, set opacity now
|
||||
if (!(options.image && animate) && options.opacity !== undefined) {
|
||||
[].forEach.call(pattern.element.childNodes, function (child) {
|
||||
child.setAttribute('opacity', options.opacity);
|
||||
});
|
||||
}
|
||||
|
||||
// Store for future reference
|
||||
this.patternElements = this.patternElements || {};
|
||||
this.patternElements[id] = pattern;
|
||||
|
||||
return pattern;
|
||||
};
|
||||
|
||||
|
||||
// Make sure we have a series color
|
||||
wrap(H.Series.prototype, 'getColor', function (proceed) {
|
||||
var oldColor = this.options.color;
|
||||
// Temporarely remove color options to get defaults
|
||||
if (oldColor && oldColor.pattern && !oldColor.pattern.color) {
|
||||
delete this.options.color;
|
||||
// Get default
|
||||
proceed.apply(this, Array.prototype.slice.call(arguments, 1));
|
||||
// Replace with old, but add default color
|
||||
oldColor.pattern.color = this.color;
|
||||
this.color = this.options.color = oldColor;
|
||||
} else {
|
||||
// We have a color, no need to do anything special
|
||||
proceed.apply(this, Array.prototype.slice.call(arguments, 1));
|
||||
}
|
||||
});
|
||||
|
||||
|
||||
// Calculate pattern dimensions on points that have their own pattern.
|
||||
wrap(H.Series.prototype, 'render', function (proceed) {
|
||||
var isResizing = this.chart.isResizing;
|
||||
if (this.isDirtyData || isResizing || !this.chart.hasRendered) {
|
||||
(this.points || []).forEach(function (point) {
|
||||
var colorOptions = point.options && point.options.color;
|
||||
if (colorOptions && colorOptions.pattern) {
|
||||
// For most points we want to recalculate the dimensions on
|
||||
// render, where we have the shape args and bbox. But if we
|
||||
// are resizing and don't have the shape args, defer it, since
|
||||
// the bounding box is still not resized.
|
||||
if (
|
||||
isResizing &&
|
||||
!(
|
||||
point.shapeArgs &&
|
||||
point.shapeArgs.width &&
|
||||
point.shapeArgs.height
|
||||
)
|
||||
) {
|
||||
colorOptions.pattern._width = 'defer';
|
||||
colorOptions.pattern._height = 'defer';
|
||||
} else {
|
||||
point.calculatePatternDimensions(colorOptions.pattern);
|
||||
}
|
||||
}
|
||||
});
|
||||
}
|
||||
return proceed.apply(this, Array.prototype.slice.call(arguments, 1));
|
||||
});
|
||||
|
||||
|
||||
// Merge series color options to points
|
||||
wrap(H.Point.prototype, 'applyOptions', function (proceed) {
|
||||
var point = proceed.apply(this, Array.prototype.slice.call(arguments, 1)),
|
||||
colorOptions = point.options.color;
|
||||
|
||||
// Only do this if we have defined a specific color on this point. Otherwise
|
||||
// we will end up trying to re-add the series color for each point.
|
||||
if (colorOptions && colorOptions.pattern) {
|
||||
// Move path definition to object, allows for merge with series path
|
||||
// definition
|
||||
if (typeof colorOptions.pattern.path === 'string') {
|
||||
colorOptions.pattern.path = {
|
||||
d: colorOptions.pattern.path
|
||||
};
|
||||
}
|
||||
// Merge with series options
|
||||
point.color = point.options.color = merge(
|
||||
point.series.options.color, colorOptions
|
||||
);
|
||||
}
|
||||
return point;
|
||||
});
|
||||
|
||||
|
||||
// Add functionality to SVG renderer to handle patterns as complex colors
|
||||
H.addEvent(H.SVGRenderer, 'complexColor', function (args) {
|
||||
var color = args.args[0],
|
||||
prop = args.args[1],
|
||||
element = args.args[2],
|
||||
pattern = color.pattern,
|
||||
value = '#343434',
|
||||
forceHashId;
|
||||
|
||||
// Skip and call default if there is no pattern
|
||||
if (!pattern) {
|
||||
return true;
|
||||
}
|
||||
|
||||
// We have a pattern.
|
||||
if (
|
||||
pattern.image ||
|
||||
typeof pattern.path === 'string' ||
|
||||
pattern.path && pattern.path.d
|
||||
) {
|
||||
// Real pattern. Add it and set the color value to be a reference.
|
||||
|
||||
// Force Hash-based IDs for legend items, as they are drawn before
|
||||
// point render, meaning they are drawn before autocalculated image
|
||||
// width/heights. We don't want them to highjack the width/height for
|
||||
// this ID if it is defined by users.
|
||||
forceHashId = element.parentNode &&
|
||||
element.parentNode.getAttribute('class');
|
||||
forceHashId = forceHashId &&
|
||||
forceHashId.indexOf('highcharts-legend') > -1;
|
||||
|
||||
// If we don't have a width/height yet, handle it. Try faking a point
|
||||
// and running the algorithm again.
|
||||
if (pattern._width === 'defer' || pattern._height === 'defer') {
|
||||
H.Point.prototype.calculatePatternDimensions.call(
|
||||
{ graphic: { element: element } }, pattern
|
||||
);
|
||||
}
|
||||
|
||||
// If we don't have an explicit ID, compute a hash from the
|
||||
// definition and use that as the ID. This ensures that points with
|
||||
// the same pattern definition reuse existing pattern elements by
|
||||
// default. We combine two hashes, the second with an additional
|
||||
// preSeed algorithm, to minimize collision probability.
|
||||
if (forceHashId || !pattern.id) {
|
||||
// Make a copy so we don't accidentally edit options when setting ID
|
||||
pattern = merge({}, pattern);
|
||||
pattern.id = 'highcharts-pattern-' + hashFromObject(pattern) +
|
||||
hashFromObject(pattern, true);
|
||||
}
|
||||
|
||||
// Add it. This function does nothing if an element with this ID
|
||||
// already exists.
|
||||
this.addPattern(pattern, !this.forExport && H.pick(
|
||||
pattern.animation,
|
||||
this.globalAnimation,
|
||||
{ duration: 100 }
|
||||
));
|
||||
|
||||
value = 'url(' + this.url + '#' + pattern.id + ')';
|
||||
|
||||
} else {
|
||||
// Not a full pattern definition, just add color
|
||||
value = pattern.color || value;
|
||||
}
|
||||
|
||||
// Set the fill/stroke prop on the element
|
||||
element.setAttribute(prop, value);
|
||||
|
||||
// Allow the color to be concatenated into tooltips formatters etc.
|
||||
color.toString = function () {
|
||||
return value;
|
||||
};
|
||||
|
||||
// Skip default handler
|
||||
return false;
|
||||
});
|
||||
|
||||
|
||||
// When animation is used, we have to recalculate pattern dimensions after
|
||||
// resize, as the bounding boxes are not available until then.
|
||||
H.addEvent(H.Chart, 'endResize', function () {
|
||||
if (
|
||||
(this.renderer.defIds || []).filter(function (id) {
|
||||
return id && id.indexOf && id.indexOf('highcharts-pattern-') === 0;
|
||||
}).length
|
||||
) {
|
||||
// We have non-default patterns to fix. Find them by looping through
|
||||
// all points.
|
||||
this.series.forEach(function (series) {
|
||||
series.points.forEach(function (point) {
|
||||
var colorOptions = point.options && point.options.color;
|
||||
if (colorOptions && colorOptions.pattern) {
|
||||
colorOptions.pattern._width = 'defer';
|
||||
colorOptions.pattern._height = 'defer';
|
||||
}
|
||||
});
|
||||
});
|
||||
// Redraw without animation
|
||||
this.redraw(false);
|
||||
}
|
||||
});
|
||||
|
||||
|
||||
// Add a garbage collector to delete old patterns with autogenerated hashes that
|
||||
// are no longer being referenced.
|
||||
H.addEvent(H.Chart, 'redraw', function () {
|
||||
var usedIds = [],
|
||||
renderer = this.renderer,
|
||||
// Get the autocomputed patterns - these are the ones we might delete
|
||||
patterns = (renderer.defIds || []).filter(function (pattern) {
|
||||
return pattern.indexOf &&
|
||||
pattern.indexOf('highcharts-pattern-') === 0;
|
||||
});
|
||||
|
||||
if (patterns.length) {
|
||||
// Look through the DOM for usage of the patterns. This can be points,
|
||||
// series, tooltips etc.
|
||||
[].forEach.call(
|
||||
this.renderTo.querySelectorAll(
|
||||
'[color^="url(#"], [fill^="url(#"], [stroke^="url(#"]'
|
||||
),
|
||||
function (node) {
|
||||
var id = node.getAttribute('fill') ||
|
||||
node.getAttribute('color') ||
|
||||
node.getAttribute('stroke');
|
||||
if (id) {
|
||||
usedIds.push(id
|
||||
.substring(id.indexOf('url(#') + 5)
|
||||
.replace(')', '')
|
||||
);
|
||||
}
|
||||
}
|
||||
);
|
||||
|
||||
// Loop through the patterns that exist and see if they are used
|
||||
patterns.forEach(function (id) {
|
||||
if (usedIds.indexOf(id) === -1) {
|
||||
// Remove id from used id list
|
||||
H.erase(renderer.defIds, id);
|
||||
// Remove pattern element
|
||||
if (renderer.patternElements[id]) {
|
||||
renderer.patternElements[id].destroy();
|
||||
delete renderer.patternElements[id];
|
||||
}
|
||||
}
|
||||
});
|
||||
}
|
||||
});
|
||||
|
||||
|
||||
// Add the predefined patterns
|
||||
H.Chart.prototype.callbacks.push(function (chart) {
|
||||
var colors = H.getOptions().colors;
|
||||
[
|
||||
'M 0 0 L 10 10 M 9 -1 L 11 1 M -1 9 L 1 11',
|
||||
'M 0 10 L 10 0 M -1 1 L 1 -1 M 9 11 L 11 9',
|
||||
'M 3 0 L 3 10 M 8 0 L 8 10',
|
||||
'M 0 3 L 10 3 M 0 8 L 10 8',
|
||||
'M 0 3 L 5 3 L 5 0 M 5 10 L 5 7 L 10 7',
|
||||
'M 3 3 L 8 3 L 8 8 L 3 8 Z',
|
||||
'M 5 5 m -4 0 a 4 4 0 1 1 8 0 a 4 4 0 1 1 -8 0',
|
||||
'M 10 3 L 5 3 L 5 0 M 5 10 L 5 7 L 0 7',
|
||||
'M 2 5 L 5 2 L 8 5 L 5 8 Z',
|
||||
'M 0 0 L 5 10 L 10 0'
|
||||
].forEach(function (pattern, i) {
|
||||
chart.renderer.addPattern({
|
||||
id: 'highcharts-default-pattern-' + i,
|
||||
path: pattern,
|
||||
color: colors[i],
|
||||
width: 10,
|
||||
height: 10
|
||||
});
|
||||
});
|
||||
});
|
||||
|
||||
}(Highcharts));
|
||||
return (function () {
|
||||
|
||||
|
||||
}());
|
||||
}));
|
||||
Reference in New Issue
Block a user