@progress/kendo-ui/js/dataviz/gauge/kendo-gauges.js

This package is part of the [Kendo UI for jQuery](http://www.telerik.com/kendo-ui) suite.

module.exports =
/******/ (function(modules) { // webpackBootstrap
/******/ 	// The module cache
/******/ 	var installedModules = {};

/******/ 	// The require function
/******/ 	function __webpack_require__(moduleId) {

/******/ 		// Check if module is in cache
/******/ 		if(installedModules[moduleId])
/******/ 			return installedModules[moduleId].exports;

/******/ 		// Create a new module (and put it into the cache)
/******/ 		var module = installedModules[moduleId] = {
/******/ 			exports: {},
/******/ 			id: moduleId,
/******/ 			loaded: false
/******/ 		};

/******/ 		// Execute the module function
/******/ 		modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);

/******/ 		// Flag the module as loaded
/******/ 		module.loaded = true;

/******/ 		// Return the exports of the module
/******/ 		return module.exports;
/******/ 	}


/******/ 	// expose the modules object (__webpack_modules__)
/******/ 	__webpack_require__.m = modules;

/******/ 	// expose the module cache
/******/ 	__webpack_require__.c = installedModules;

/******/ 	// __webpack_public_path__
/******/ 	__webpack_require__.p = "";

/******/ 	// Load entry module and return exports
/******/ 	return __webpack_require__(0);
/******/ })
/************************************************************************/
/******/ ({

/***/ 0:
/***/ (function(module, exports, __webpack_require__) {

	module.exports = __webpack_require__(883);


/***/ }),

/***/ 3:
/***/ (function(module, exports) {

	module.exports = function() { throw new Error("define cannot be used indirect"); };


/***/ }),

/***/ 857:
/***/ (function(module, exports) {

	module.exports = require("../../kendo.dataviz.core");

/***/ }),

/***/ 859:
/***/ (function(module, exports) {

	module.exports = require("../../kendo.drawing");

/***/ }),

/***/ 862:
/***/ (function(module, exports) {

	module.exports = require("../../kendo.core");

/***/ }),

/***/ 863:
/***/ (function(module, exports) {

	module.exports = require("../../kendo.color");

/***/ }),

/***/ 883:
/***/ (function(module, exports, __webpack_require__) {

	var __WEBPACK_AMD_DEFINE_FACTORY__, __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;/***********************************************************************
	 * WARNING: this file is auto-generated.  If you change it directly,
	 * your modifications will eventually be lost.  The source code is in
	 * `kendo-charts` repository, you should make your changes there and
	 * run `src-modules/sync.sh` in this repository.
	 */
	(function(f, define){
	    !(__WEBPACK_AMD_DEFINE_ARRAY__ = [
	        __webpack_require__(862),
	        __webpack_require__(863),
	        __webpack_require__(859),
	        __webpack_require__(857)
	    ], __WEBPACK_AMD_DEFINE_FACTORY__ = (f), __WEBPACK_AMD_DEFINE_RESULT__ = (typeof __WEBPACK_AMD_DEFINE_FACTORY__ === 'function' ? (__WEBPACK_AMD_DEFINE_FACTORY__.apply(exports, __WEBPACK_AMD_DEFINE_ARRAY__)) : __WEBPACK_AMD_DEFINE_FACTORY__), __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__));
	})(function(){

	(function ($) {

	window.kendo.dataviz = window.kendo.dataviz || {};
	var dataviz = kendo.dataviz;
	var getSpacing = dataviz.getSpacing;
	var defined = dataviz.defined;
	var constants = dataviz.constants;
	var BLACK = constants.BLACK;
	var COORD_PRECISION = constants.COORD_PRECISION;
	var services = dataviz.services;
	var deepExtend = dataviz.deepExtend;
	var isArray = dataviz.isArray;
	var setDefaultOptions = dataviz.setDefaultOptions;
	var NumericAxis = dataviz.NumericAxis;
	var limitValue = dataviz.limitValue;
	var Box = dataviz.Box;
	var interpolateValue = dataviz.interpolateValue;
	var round = dataviz.round;
	var drawing = kendo.drawing;
	var DrawingGroup = drawing.Group;
	var DrawingPath = drawing.Path;
	var Animation = drawing.Animation;
	var AnimationFactory = drawing.AnimationFactory;
	var geometry = kendo.geometry;
	var Rect = geometry.Rect;
	var GeometryPoint = geometry.Point;
	var transform = geometry.transform;

	var ANGULAR_SPEED = 150;
	var LINEAR_SPEED = 250;
	var ARROW = "arrow";
	var ARROW_POINTER = "arrowPointer";
	var BAR_POINTER = "barPointer";
	var DEFAULT_HEIGHT = 200;
	var DEFAULT_LINE_WIDTH = 0.5;
	var DEFAULT_WIDTH = 200;
	var DEGREE = Math.PI / 180;
	var INSIDE = "inside";
	var LINEAR = "linear";
	var OUTSIDE = "outside";
	var RADIAL_POINTER = "radialPointer";
	var RADIAL_RANGE_POINTER = "radialRangePointer";

	function pad(bbox, value) {
	    var origin = bbox.getOrigin();
	    var size = bbox.getSize();
	    var spacing = getSpacing(value);

	    bbox.setOrigin([ origin.x - spacing.left, origin.y - spacing.top ]);
	    bbox.setSize([ size.width + (spacing.left + spacing.right), size.height + (spacing.top + spacing.bottom) ]);

	    return bbox;
	}

	var Group = DrawingGroup;
	var Path$1 = DrawingPath;
	var Text = drawing.Text;

	function buildLabelElement(label, options) {
	    var labelBox = label.box;
	    var textBox = label.children[0].box;
	    var border = options.border || {};
	    var background = options.background || "";

	    var wrapper = Path$1.fromRect(new Rect([ labelBox.x1, labelBox.y1 ], [ labelBox.width(), labelBox.height() ]), {
	        stroke: {}
	    });

	    var text = new Text(label.text, new GeometryPoint(textBox.x1, textBox.y1), {
	        font: options.font,
	        fill: { color: options.color }
	    });

	    var styleGeometry = pad(text.bbox().clone(), options.padding);

	    var styleBox = Path$1.fromRect(styleGeometry, {
	        stroke: {
	            color: border.width ? border.color : "",
	            width: border.width,
	            dashType: border.dashType,
	            lineJoin: "round",
	            lineCap: "round"
	        },
	        fill: {
	            color: background
	        }
	    });

	    var elements = new Group();
	    elements.append(wrapper);
	    elements.append(styleBox);
	    elements.append(text);

	    return elements;
	}

	function getRange(range, min, max) {
	    var from = defined(range.from) ? range.from : constants.MIN_VALUE;
	    var to = defined(range.to) ? range.to : constants.MAX_VALUE;

	    range.from = Math.max(Math.min(to, from), min);
	    range.to = Math.min(Math.max(to, from), max);

	    return range;
	}

	function unpad(bbox, value) {
	    var spacing = getSpacing(value);

	    spacing.left = -spacing.left; spacing.top = -spacing.top;
	    spacing.right = -spacing.right; spacing.bottom = -spacing.bottom;

	    return pad(bbox, spacing);
	}

	var DEFAULT_MARGIN = 5;
	var Path = DrawingPath;
	var Surface = drawing.Surface;

	var Gauge = dataviz.Class.extend({
	    init: function(element, userOptions, theme, context) {
	        if (context === void 0) { context = {}; }

	        this.element = element;
	        this.theme = theme;
	        this.contextService = new services.ChartService(this, context);
	        this._originalOptions = deepExtend({}, this.options, userOptions);
	        this.options = deepExtend({}, this._originalOptions);
	        this._initTheme(theme);

	        this.redraw();
	    },

	    destroy: function() {
	        if (this.surface) {
	            this.surface.destroy();
	            this.surface = null;
	        }

	        delete this.element;
	        delete this.surfaceElement;
	    },

	    value: function(pointerValue) {
	        var pointer = this.pointers[0];

	        if (arguments.length === 0) {
	            return pointer.value();
	        }

	        pointer.value(pointerValue);
	        this._setValueOptions(pointerValue);
	    },

	    _draw: function() {
	        var surface = this.surface;

	        surface.clear();
	        surface.draw(this._visuals);
	    },

	    exportVisual: function() {
	        return this._visuals;
	    },

	    allValues: function(values) {
	        var pointers = this.pointers;
	        var allValues = [];

	        if (arguments.length === 0) {
	            for (var i = 0; i < pointers.length; i++) {
	                allValues.push(pointers[i].value());
	            }

	            return allValues;
	        }

	        if (isArray(values)) {
	            for (var i$1 = 0; i$1 < values.length; i$1++) {
	                if (dataviz.isNumber(values[i$1])) {
	                    pointers[i$1].value(values[i$1]);
	                }
	            }
	        }

	        this._setValueOptions(values);
	    },

	    _setValueOptions: function(values) {
	        var pointers = [].concat(this.options.pointer);
	        var arrayValues = [].concat(values);

	        for (var i = 0; i < arrayValues.length; i++) {
	            pointers[i].value = arrayValues[i];
	        }
	    },

	    resize: function() {
	        this.noTransitionsRedraw();
	    },

	    noTransitionsRedraw: function() {
	        var transitions = this.options.transitions;

	        this._toggleTransitions(false);

	        this.redraw();

	        this._toggleTransitions(transitions);
	    },

	    redraw: function() {
	        var size = this._surfaceSize();
	        var wrapper = new Rect([ 0, 0 ], [ size.width, size.height ]);

	        this._initSurface();

	        this.gaugeArea = this._createGaugeArea();

	        this._createModel();

	        var bbox = unpad(wrapper.bbox(), this._gaugeAreaMargin);
	        this.reflow(bbox);
	    },

	    setOptions: function(options, theme) {
	        this._originalOptions = deepExtend(this._originalOptions, options);
	        this.options = deepExtend({}, this._originalOptions);

	        this._initTheme(theme);

	        this.redraw();
	    },

	    setDirection: function(rtl) {
	        this.contextService.rtl = Boolean(rtl);
	        if (this.surface && this.surface.type === 'svg') {
	            this.surface.destroy();
	            this.surface = null;
	        }
	    },

	    setIntlService: function(intl) {
	        this.contextService.intl = intl;
	    },

	    _initTheme: function(theme) {
	        var currentTheme = theme || this.theme || {};
	        this.theme = currentTheme;

	        this.options = deepExtend({}, currentTheme, this.options);
	        var options = this.options;
	        var pointer = options.pointer;

	        if (isArray(pointer)) {
	            var pointers = [];
	            for (var i = 0; i < pointer.length; i++) {
	                pointers.push(deepExtend({}, currentTheme.pointer, pointer[i]));
	            }
	            options.pointer = pointers;
	        }
	    },

	    _createGaugeArea: function() {
	        var options = this.options.gaugeArea;
	        var size = this.surface.size();
	        var border = options.border || {};
	        var areaGeometry = new Rect([ 0, 0 ], [ size.width, size.height ]);

	        this._gaugeAreaMargin = options.margin || DEFAULT_MARGIN;

	        if (border.width > 0) {
	            areaGeometry = unpad(areaGeometry, border.width);
	        }

	        var gaugeArea = Path.fromRect(areaGeometry, {
	            stroke: {
	                color: border.width ? border.color : "",
	                width: border.width,
	                dashType: border.dashType,
	                lineJoin: "round",
	                lineCap: "round"
	            },
	            fill: {
	                color: options.background
	            }
	        });

	        return gaugeArea;
	    },

	    _initSurface: function() {
	        var ref = this;
	        var options = ref.options;
	        var surface = ref.surface;
	        var element = this._surfaceElement();
	        var size = this._surfaceSize();

	        dataviz.elementSize(element, size);

	        if (!surface || surface.options.type !== options.renderAs) {
	            if (surface) {
	                surface.destroy();
	            }

	            this.surface = Surface.create(element, {
	                type: options.renderAs
	            });
	        } else {
	            this.surface.clear();
	            this.surface.resize();
	        }
	    },

	    _surfaceSize: function() {
	        var options = this.options;
	        var size = this._getSize();

	        if (options.gaugeArea) {
	            deepExtend(size, options.gaugeArea);
	        }

	        return size;
	    },

	    _surfaceElement: function() {
	        if (!this.surfaceElement) {
	            this.surfaceElement = document.createElement('div');
	            this.element.appendChild(this.surfaceElement);
	        }

	        return this.surfaceElement;
	    },

	    getSize: function() {
	        return this._getSize();
	    },

	    _getSize: function() {
	        var element = this.element;
	        var defaultSize = this._defaultSize();
	        var width = element.offsetWidth;
	        var height = element.offsetHeight;

	        if (!width) {
	            width = defaultSize.width;
	        }

	        if (!height) {
	            height = defaultSize.height;
	        }

	        return { width: width, height: height };
	    },

	    _defaultSize: function() {
	        return {
	            width: DEFAULT_WIDTH,
	            height: DEFAULT_HEIGHT
	        };
	    },

	    _toggleTransitions: function(value) {
	        var this$1 = this;

	        this.options.transitions = value;
	        for (var i = 0; i < this.pointers.length; i++) {
	            this$1.pointers[i].options.animation.transitions = value;
	        }
	    }
	});

	setDefaultOptions(Gauge, {
	    plotArea: {},
	    theme: "default",
	    renderAs: "",
	    pointer: {},
	    scale: {},
	    gaugeArea: {}
	});

	var Path$2 = DrawingPath;
	var Group$2 = DrawingGroup;
	var Point = GeometryPoint;

	function renderAxisTick(tickRenderOptions, tickOptions) {
	    var position = tickRenderOptions.position;
	    var tickX = tickRenderOptions.tickX;
	    var tickY = tickRenderOptions.tickY;
	    var start, end;

	    if (tickRenderOptions.vertical) {
	        start = new Point(tickX, position);
	        end = new Point(tickX + tickOptions.size, position);
	    } else {
	        start = new Point(position, tickY);
	        end = new Point(position, tickY + tickOptions.size);
	    }

	    var tickPath = new Path$2({
	        stroke: {
	            color: tickOptions.color,
	            width: tickOptions.width
	        }
	    }).moveTo(start).lineTo(end);

	    return tickPath;
	}

	function renderTicks(tickGroup, tickPositions, tickRenderOptions, tickOptions) {
	    var count = tickPositions.length;

	    if (tickOptions.visible) {
	        var mirror = tickRenderOptions.mirror;
	        var lineBox = tickRenderOptions.lineBox;
	        for (var i = tickOptions.skip; i < count; i += tickOptions.step) {
	            if (i % tickOptions.skipUnit === 0) {
	                continue;
	            }

	            tickRenderOptions.tickX = mirror ? lineBox.x2 : lineBox.x2 - tickOptions.size;
	            tickRenderOptions.tickY = mirror ? lineBox.y1 - tickOptions.size : lineBox.y1;
	            tickRenderOptions.position = tickPositions[i];

	            tickGroup.append(renderAxisTick(tickRenderOptions, tickOptions));
	        }
	    }
	}

	var LinearScale = NumericAxis.extend({
	    init: function(options, service) {
	        var scaleOptions = options || {};
	        if (!defined(scaleOptions.reverse) && scaleOptions.vertical === false && (service || {}).rtl) {
	            scaleOptions = $.extend({}, scaleOptions, {
	                reverse: true
	            });
	        }

	        NumericAxis.fn.init.call(this, 0, 1, scaleOptions, service);

	        this.options.minorUnit = this.options.minorUnit || this.options.majorUnit / 10;
	    },

	    initUserOptions: function(options) {
	        var scaleOptions = deepExtend({}, this.options, options);
	        scaleOptions = deepExtend({}, scaleOptions , { labels: { mirror: scaleOptions.mirror } });
	        scaleOptions.majorUnit = scaleOptions.majorUnit || dataviz.autoMajorUnit(scaleOptions.min, scaleOptions.max);

	        return scaleOptions;
	    },

	    initFields: function() {
	    },

	    render: function() {
	        var elements = this.elements = new Group$2();
	        var labels = this.renderLabels();
	        var scaleLine = this.renderLine();
	        var scaleTicks = this.renderTicks();
	        var ranges = this.renderRanges();

	        elements.append(scaleLine, labels, scaleTicks, ranges);

	        return elements;
	    },

	    renderRanges: function() {
	        var this$1 = this;

	        var options = this.options;
	        var min = options.min;
	        var max = options.max;
	        var vertical = options.vertical;
	        var mirror = options.labels.mirror;
	        var ranges = options.ranges || [];
	        var elements = new Group$2();
	        var count = ranges.length;
	        var rangeSize = options.rangeSize || options.minorTicks.size / 2;

	        for (var i = 0; i < count; i++) {
	            var range = getRange(ranges[i], min, max);
	            var slot = this$1.getSlot(range.from, range.to);
	            var slotX = vertical ? this$1.lineBox() : slot;
	            var slotY = vertical ? slot : this$1.lineBox();
	            if (vertical) {
	                slotX.x1 -= rangeSize * (mirror ? -1 : 1);
	            } else {
	                slotY.y2 += rangeSize * (mirror ? -1 : 1);
	            }

	            elements.append(Path$2.fromRect(new Rect([ slotX.x1, slotY.y1 ], [ slotX.x2 - slotX.x1, slotY.y2 - slotY.y1 ]), {
	                fill: { color: range.color, opacity: range.opacity },
	                stroke: { }
	            }));
	        }

	        return elements;
	    },

	    renderLabels: function() {
	        var ref = this;
	        var labels = ref.labels;
	        var options = ref.options;
	        var elements = new Group$2();

	        for (var i = 0; i < labels.length; i++) {
	            elements.append(buildLabelElement(labels[i], options.labels));
	        }

	        return elements;
	    },

	    renderLine: function() {
	        var line = this.options.line;
	        var lineBox = this.lineBox();
	        var elements = new Group$2();

	        if (line.width > 0 && line.visible) {
	            var linePath = new Path$2({
	                stroke: {
	                    color: line.color,
	                    dashType: line.dashType,
	                    width: line.width
	                }
	            });

	            linePath.moveTo(lineBox.x1, lineBox.y1).lineTo(lineBox.x2, lineBox.y2);
	            elements.append(linePath);
	        }

	        return elements;
	    },

	    renderTicks: function() {
	        var ticks = new Group$2();
	        var options = this.options;
	        var majorUnit = options.majorTicks.visible ? options.majorUnit : 0;
	        var tickRenderOptions = {
	            vertical: options.vertical,
	            mirror: options.labels.mirror,
	            lineBox: this.lineBox()
	        };

	        renderTicks(ticks, this.getMajorTickPositions(), tickRenderOptions, options.majorTicks);
	        renderTicks(ticks, this.getMinorTickPositions(), tickRenderOptions, deepExtend({}, {
	            skipUnit: majorUnit / options.minorUnit
	        }, options.minorTicks));

	        return ticks;
	    }
	});

	setDefaultOptions(LinearScale, {
	    min: 0,
	    max: 50,

	    majorTicks: {
	        size: 15,
	        align: INSIDE,
	        color: BLACK,
	        width: DEFAULT_LINE_WIDTH,
	        visible: true
	    },

	    minorTicks: {
	        size: 10,
	        align: INSIDE,
	        color: BLACK,
	        width: DEFAULT_LINE_WIDTH,
	        visible: true
	    },

	    line: {
	        width: DEFAULT_LINE_WIDTH
	    },

	    labels: {
	        position: INSIDE,
	        padding: 2
	    },
	    mirror: false,
	    _alignLines: false
	});

	var Pointer = dataviz.Class.extend({
	    init: function(scale, userOptions) {

	        var ref = scale.options;
	        var min = ref.min;
	        var max = ref.max;
	        var options = this.options = deepExtend({}, this.options, userOptions);

	        options.fill = options.color;

	        this.scale = scale;

	        if (defined(options.value)) {
	            options.value = limitValue(options.value, min, max);
	        } else {
	            options.value = min;
	        }
	    },

	    value: function(newValue) {
	        var options = this.options;
	        var value = options.value;

	        if (arguments.length === 0) {
	            return value;
	        }

	        var ref = this.scale.options;
	        var min = ref.min;
	        var max = ref.max;

	        options._oldValue = defined(options._oldValue) ? options.value : min;
	        options.value = limitValue(newValue, min, max);

	        if (this.elements) {
	            this.repaint();
	        }
	    }
	});

	setDefaultOptions(Pointer, {
	    color: BLACK
	});

	var LinearPointer = Pointer.extend({
	    init: function(scale, options) {
	        Pointer.fn.init.call(this, scale, options);

	        this.options = deepExtend({
	            track: {
	                visible: defined(options.track)
	            }
	        }, this.options);
	    },

	    reflow: function() {
	        var ref = this;
	        var options = ref.options;
	        var scale = ref.scale;
	        var ref$1 = scale.options;
	        var mirror = ref$1.mirror;
	        var vertical = ref$1.vertical;
	        var scaleLine = scale.lineBox();
	        var trackSize = options.track.size || options.size;
	        var pointerHalfSize = options.size / 2;
	        var margin = getSpacing(options.margin);
	        var space = vertical ?
	                 margin[mirror ? "left" : "right"] :
	                 margin[mirror ? "bottom" : "top"];
	        var pointerBox, pointerRangeBox, trackBox;

	        space = mirror ? -space : space;

	        if (vertical) {
	            trackBox = new Box(
	                scaleLine.x1 + space, scaleLine.y1,
	                scaleLine.x1 + space, scaleLine.y2);

	            if (mirror) {
	                trackBox.x1 -= trackSize;
	            } else {
	                trackBox.x2 += trackSize;
	            }

	            if (options.shape !== BAR_POINTER) {
	                pointerRangeBox = new Box(
	                    scaleLine.x2 + space, scaleLine.y1 - pointerHalfSize,
	                    scaleLine.x2 + space, scaleLine.y2 + pointerHalfSize
	                );
	                pointerBox = pointerRangeBox;
	            }
	        } else {
	            trackBox = new Box(
	                scaleLine.x1, scaleLine.y1 - space,
	                scaleLine.x2, scaleLine.y1 - space);

	            if (mirror) {
	                trackBox.y2 += trackSize;
	            } else {
	                trackBox.y1 -= trackSize;
	            }

	            if (options.shape !== BAR_POINTER) {
	                pointerRangeBox = new Box(
	                    scaleLine.x1 - pointerHalfSize, scaleLine.y1 - space,
	                    scaleLine.x2 + pointerHalfSize, scaleLine.y1 - space
	                );
	                pointerBox = pointerRangeBox;
	            }
	        }

	        this.trackBox = trackBox;
	        this.pointerRangeBox = pointerRangeBox;
	        this.box = pointerBox || trackBox.clone().pad(options.border.width);
	    },

	    getElementOptions: function() {
	        var options = this.options;

	        return {
	            fill: {
	                color: options.color,
	                opacity: options.opacity
	            },
	            stroke: defined(options.border) ? {
	                color: options.border.width ? options.border.color || options.color : "",
	                width: options.border.width,
	                dashType: options.border.dashType,
	                opacity: options.opacity
	            } : null
	        };
	    },

	    _margin: function() {
	        var ref = this;
	        var scale = ref.scale;
	        var options = ref.options;
	        var ref$1 = scale.options;
	        var mirror = ref$1.mirror;
	        var vertical = ref$1.vertical;
	        var margin = getSpacing(options.margin);

	        var space = vertical ?
	            margin[mirror ? "left" : "right"] :
	            margin[mirror ? "bottom" : "top"];

	        return space;
	    }
	});

	setDefaultOptions(LinearPointer, {
	    shape: BAR_POINTER,

	    track: {
	        border: {
	            width: 1
	        }
	    },

	    color: BLACK,
	    border: {
	        width: 1
	    },
	    opacity: 1,

	    margin: getSpacing(3),
	    animation: {
	        type: BAR_POINTER
	    },
	    visible: true
	});

	var ArrowLinearPointerAnimation = Animation.extend({
	    setup: function() {
	        var options = this.options;
	        var margin = options.margin;
	        var from = options.from;
	        var to = options.to;
	        var vertical = options.vertical;
	        var axis = vertical ? "x1" : "y1";

	        if (options.mirror === vertical) {
	            from[axis] -= margin; to[axis] -= margin;
	        } else {
	            from[axis] += margin; to[axis] += margin;
	        }

	        var fromScale = this.fromScale = new GeometryPoint(from.x1, from.y1);
	        var toScale = this.toScale = new GeometryPoint(to.x1, to.y1);

	        if (options.duration !== 0) {
	            options.duration = Math.max((fromScale.distanceTo(toScale) / options.duration) * 1000, 1);
	        }
	    },

	    step: function(pos) {
	        var translateX = interpolateValue(this.fromScale.x, this.toScale.x, pos);
	        var translateY = interpolateValue(this.fromScale.y, this.toScale.y, pos);

	        this.element.transform(transform().translate(translateX, translateY));
	    }
	});

	setDefaultOptions(ArrowLinearPointerAnimation, {
	    easing: LINEAR,
	    duration: LINEAR_SPEED
	});

	AnimationFactory.current.register(ARROW_POINTER, ArrowLinearPointerAnimation);

	var Point$1 = GeometryPoint;
	var Path$3 = DrawingPath;

	var ArrowLinearPointer = LinearPointer.extend({
	    init: function(scale, options) {
	        LinearPointer.fn.init.call(this, scale, options);

	        if (!defined(this.options.size)) {
	            this.options.size = this.scale.options.majorTicks.size * 0.6;
	        }
	    },

	    pointerShape: function() {
	        var ref = this;
	        var scale = ref.scale;
	        var size = ref.options.size;
	        var halfSize = size / 2;
	        var sign = (scale.options.mirror ? -1 : 1);
	        var shape;

	        if (scale.options.vertical) {
	            shape = [
	                new Point$1(0, 0 - halfSize), new Point$1(0 - sign * size, 0), new Point$1(0, 0 + halfSize)
	            ];
	        } else {
	            shape = [
	                new Point$1(0 - halfSize, 0), new Point$1(0, 0 + sign * size), new Point$1(0 + halfSize, 0)
	            ];
	        }

	        return shape;
	    },

	    repaint: function() {
	        var ref = this;
	        var scale = ref.scale;
	        var options = ref.options;
	        var animation = new ArrowLinearPointerAnimation(this.elements, deepExtend(options.animation, {
	            vertical: scale.options.vertical,
	            mirror: scale.options.mirror,
	            margin: this._margin(options.margin),
	            from: scale.getSlot(options._oldValue),
	            to: scale.getSlot(options.value)
	        }));

	        if (options.animation.transitions === false) {
	            animation.options.duration = 0;
	        }

	        animation.setup();
	        animation.play();
	    },

	    render: function() {
	        var ref = this;
	        var scale = ref.scale;
	        var options = ref.options;
	        var elementOptions = this.getElementOptions();
	        var shape = this.pointerShape(options.value);

	        options.animation.type = ARROW_POINTER;

	        var elements = new Path$3({
	            stroke: elementOptions.stroke,
	            fill: elementOptions.fill
	        }).moveTo(shape[0]).lineTo(shape[1]).lineTo(shape[2]).close();

	        var slot = scale.getSlot(options.value);
	        elements.transform(transform().translate(slot.x1, slot.y1));

	        this.elements = elements;

	        return elements;
	    }
	});

	var BarLinearPointerAnimation = Animation.extend({
	    setup: function() {
	        var options = this.options;
	        var axis = this.axis = options.vertical ? constants.Y : constants.X;
	        var to = this.to = options.newPoints[0][axis];
	        var from = this.from = options.oldPoints[0][axis];

	        if (options.duration !== 0) {
	            options.duration = Math.max((Math.abs(to - from) / options.speed) * 1000, 1);
	        }

	        this._set(from);
	    },

	    step: function(pos) {
	        var value = interpolateValue(this.from, this.to, pos);
	        this._set(value);
	    },

	    _set: function(value) {
	        var setter = "set" + this.axis.toUpperCase();
	        var points = this.options.newPoints;

	        points[0][setter](value);
	        points[1][setter](value);
	    }
	});

	setDefaultOptions(BarLinearPointerAnimation, {
	    easing: LINEAR,
	    speed: LINEAR_SPEED
	});

	AnimationFactory.current.register(BAR_POINTER, BarLinearPointerAnimation);

	var Group$3 = DrawingGroup;
	var Path$4 = DrawingPath;

	var BarLinearPointer = LinearPointer.extend({
	    init: function(scale, options) {
	        LinearPointer.fn.init.call(this, scale, options);

	        if (!defined(this.options.size)) {
	            this.options.size = this.scale.options.majorTicks.size * 0.3;
	        }
	    },

	    pointerShape: function(value) {
	        var ref = this;
	        var scale = ref.scale;
	        var options = ref.options;
	        var ref$1 = scale.options;
	        var mirror = ref$1.mirror;
	        var vertical = ref$1.vertical;
	        var dir = mirror === vertical ? -1 : 1;
	        var size = options.size * dir;
	        var minSlot = scale.getSlot(scale.options.min);
	        var slot = scale.getSlot(value);
	        var axis = vertical ? constants.Y : constants.X;
	        var sizeAxis = vertical ? constants.X : constants.Y;
	        var margin = this._margin() * dir;

	        var p1 = new GeometryPoint();
	        p1[axis] = minSlot[axis + "1"];
	        p1[sizeAxis] = minSlot[sizeAxis + "1"];

	        var p2 = new GeometryPoint();
	        p2[axis] = slot[axis + "1"];
	        p2[sizeAxis] = slot[sizeAxis + "1"];

	        if (vertical) {
	            p1.translate(margin, 0);
	            p2.translate(margin, 0);
	        } else {
	            p1.translate(0, margin);
	            p2.translate(0, margin);
	        }

	        var p3 = p2.clone();
	        var p4 = p1.clone();

	        if (vertical) {
	            p3.translate(size, 0);
	            p4.translate(size, 0);
	        } else {
	            p3.translate(0, size);
	            p4.translate(0, size);
	        }

	        return [ p1, p2, p3, p4 ];
	    },

	    repaint: function() {
	        var ref = this;
	        var scale = ref.scale;
	        var options = ref.options;
	        var shape = this.pointerShape(options.value);
	        var pointerPath = this.pointerPath;
	        var oldShape = this.pointerShape(options._oldValue);

	        pointerPath.moveTo(shape[0]).lineTo(shape[1]).lineTo(shape[2]).lineTo(shape[3]).close();

	        var animation = new BarLinearPointerAnimation(pointerPath, deepExtend(options.animation, {
	            reverse: scale.options.reverse,
	            vertical: scale.options.vertical,
	            oldPoints: [ oldShape[1], oldShape[2] ],
	            newPoints: [ shape[1], shape[2] ]
	        }));

	        if (options.animation.transitions === false) {
	            animation.options.duration = 0;
	        }

	        animation.setup();
	        animation.play();
	    },

	    render: function() {
	        var group = new Group$3();
	        var elementOptions = this.getElementOptions();

	        if (this.options.track.visible) {
	            group.append(this.renderTrack());
	        }

	        var pointer = this.pointerPath = new Path$4({
	            stroke: elementOptions.stroke,
	            fill: elementOptions.fill
	        });

	        group.append(pointer);

	        this.elements = group;

	        return group;
	    },

	    renderTrack: function() {
	        var trackOptions = this.options.track;
	        var border = trackOptions.border || {};
	        var trackBox = this.trackBox.clone().pad(border.width || 0);

	        return new Path$4.fromRect(trackBox.toRect(), {
	            fill: {
	                color: trackOptions.color,
	                opacity: trackOptions.opacity
	            },
	            stroke: {
	                color: border.width ? border.color || trackOptions.color : "",
	                width: border.width,
	                dashType: border.dashType
	            }
	        });
	    }
	});

	var DEFAULT_MIN_WIDTH = 60;
	var DEFAULT_MIN_HEIGHT = 60;

	var Group$1 = DrawingGroup;

	var LinearGauge = Gauge.extend({
	    reflow: function(bbox) {
	        var pointers = this.pointers;
	        var bboxX = bbox.origin.x;
	        var bboxY = bbox.origin.y;

	        var box = new Box(bboxX, bboxY, bboxX + bbox.width(), bboxY + bbox.height());

	        this.scale.reflow(box);
	        this._shrinkScaleWidth(box);

	        for (var i = 0; i < pointers.length; i++) {
	            pointers[i].reflow();
	        }

	        this.bbox = this._getBox(box);
	        this._alignElements();
	        this._shrinkElements();
	        this._buildVisual();
	        this._draw();
	    },

	    _buildVisual: function() {
	        var visuals = new Group$1();
	        var scaleElements = this.scale.render();
	        var pointers = this.pointers;

	        visuals.append(this.gaugeArea);
	        visuals.append(scaleElements);

	        for (var i = 0; i < pointers.length; i++) {
	            var current = pointers[i];
	            visuals.append(current.render());
	            current.value(current.options.value);
	        }

	        this._visuals = visuals;
	    },

	    _createModel: function() {
	        var this$1 = this;

	        var options = this.options;
	        var scale = this.scale = new LinearScale(options.scale, this.contextService);

	        this.pointers = [];

	        var pointers = options.pointer;
	        pointers = isArray(pointers) ? pointers : [ pointers ];

	        for (var i = 0; i < pointers.length; i++) {
	            var currentOptions = deepExtend({}, pointers[i], {
	                animation: {
	                    transitions: options.transitions
	                }
	            });
	            var pointerType = currentOptions.shape === ARROW ? ArrowLinearPointer : BarLinearPointer;

	            this$1.pointers.push(new pointerType(scale, currentOptions));
	        }
	    },

	    _defaultSize: function() {
	        var vertical = this.options.scale.vertical;

	        return {
	            width: vertical ? DEFAULT_MIN_WIDTH : DEFAULT_WIDTH,
	            height: vertical ? DEFAULT_HEIGHT : DEFAULT_MIN_HEIGHT
	        };
	    },

	    _getBox: function(box) {
	        var ref = this;
	        var scale = ref.scale;
	        var pointers = ref.pointers;
	        var boxCenter = box.center();
	        var plotAreaBox = pointers[0].box.clone().wrap(scale.box);

	        for (var i = 0; i < pointers.length; i++) {
	            plotAreaBox.wrap(pointers[i].box.clone());
	        }

	        var size;
	        if (scale.options.vertical) {
	            size = plotAreaBox.width() / 2;
	            plotAreaBox = new Box(
	                boxCenter.x - size, box.y1,
	                boxCenter.x + size, box.y2
	            );
	        } else {
	            size = plotAreaBox.height() / 2;
	            plotAreaBox = new Box(
	                box.x1, boxCenter.y - size,
	                box.x2, boxCenter.y + size
	            );
	        }

	        return plotAreaBox;
	    },

	    _alignElements: function() {
	        var this$1 = this;

	        var ref = this;
	        var scale = ref.scale;
	        var pointers = ref.pointers;
	        var scaleBox = scale.box;
	        var box = pointers[0].box.clone().wrap(scale.box);
	        var plotAreaBox = this.bbox;

	        for (var i = 0; i < pointers.length; i++) {
	            box.wrap(pointers[i].box.clone());
	        }

	        var diff;
	        if (scale.options.vertical) {
	            diff = plotAreaBox.center().x - box.center().x;
	            scale.reflow(new Box(
	                scaleBox.x1 + diff, plotAreaBox.y1,
	                scaleBox.x2 + diff, plotAreaBox.y2
	            ));
	        } else {
	            diff = plotAreaBox.center().y - box.center().y;
	            scale.reflow(new Box(
	                scaleBox.x1, scaleBox.y1 + diff,
	                scaleBox.x2, scaleBox.y2 + diff
	            ));
	        }

	        for (var i$1 = 0; i$1 < pointers.length; i$1++) {
	            pointers[i$1].reflow(this$1.bbox);
	        }
	    },

	    _shrinkScaleWidth: function(bbox) {
	        var ref = this;
	        var scale = ref.scale;
	        if (!scale.options.vertical) {
	            var overflow = scale.contentBox().width() - bbox.width();
	            if (overflow > 0) {
	                scale.box.shrink(overflow, 0);
	                scale.box.alignTo(bbox, 'center');
	                scale.reflow(scale.box);
	            }
	        }
	    },

	    _shrinkElements: function() {
	        var this$1 = this;

	        var ref = this;
	        var scale = ref.scale;
	        var pointers = ref.pointers;
	        var scaleBox = scale.box.clone();
	        var pos = scale.options.vertical ? "y" : "x";
	        var pointerBox = pointers[0].box;

	        for (var i = 0; i < pointers.length; i++) {
	            pointerBox.wrap(pointers[i].box.clone());
	        }

	        scaleBox[pos + 1] += Math.max(scaleBox[pos + 1] - pointerBox[pos + 1], 0);
	        scaleBox[pos + 2] -= Math.max(pointerBox[pos + 2] - scaleBox[pos + 2], 0);

	        scale.reflow(scaleBox);

	        for (var i$1 = 0; i$1 < pointers.length; i$1++) {
	            pointers[i$1].reflow(this$1.bbox);
	        }
	    }
	});

	setDefaultOptions(LinearGauge, {
	    transitions: true,
	    gaugeArea: {
	        background: ""
	    },
	    scale: {
	        vertical: true
	    }
	});

	var GEO_ARC_ADJUST_ANGLE = 180;

	var Arc = drawing.Arc;
	var Path$5 = DrawingPath;
	var Group$5 = DrawingGroup;

	function drawTicks(arc, tickAngles, unit, tickOptions) {
	    var ticks = new Group$5();
	    var center = arc.center;
	    var radius = arc.getRadiusX();

	    if (tickOptions.visible) {
	        for (var i = 0; i < tickAngles.length; i++) {
	            var tickStart = arc.pointAt(tickAngles[i]);
	            var tickEnd = new GeometryPoint(center.x + radius - tickOptions.size, center.y).rotate(tickAngles[i], center);

	            ticks.append(new Path$5({
	                stroke: {
	                    color: tickOptions.color,
	                    width: tickOptions.width
	                }
	            }).moveTo(tickStart).lineTo(tickEnd));
	        }
	    }

	    return ticks;
	}

	function rangeSegment(from, to, color, opacity) {
	    return { from: from, to: to, color: color, opacity: opacity };
	}

	var RadialScale = NumericAxis.extend({
	    init: function(options, service) {
	        NumericAxis.fn.init.call(this, 0, 1, options, service);
	    },

	    initUserOptions: function(options) {
	        var scaleOptions = deepExtend({}, this.options, options);
	        scaleOptions.majorUnit = scaleOptions.majorUnit || dataviz.autoMajorUnit(scaleOptions.min, scaleOptions.max);
	        scaleOptions.minorUnit = scaleOptions.minorUnit || scaleOptions.majorUnit / 10;

	        return scaleOptions;
	    },

	    initFields: function() {
	    },

	    render: function(center, radius) {
	        var arc = this.renderArc(center, radius);

	        this.bbox = arc.bbox();
	        this.labelElements = this.renderLabels();
	        this.ticks = this.renderTicks();
	        this.ranges = this.renderRanges();
	    },

	    reflow: function(bbox) {
	        var center = bbox.center();
	        var radius = Math.min(bbox.height(), bbox.width()) / 2;

	        if (defined(this.bbox)) {
	            this.bbox = this.arc.bbox();
	            this.radius(this.arc.getRadiusX());
	            this.repositionRanges();
	            this.renderLabels();
	        } else {
	            return this.render(center, radius);
	        }
	    },

	    slotAngle: function(value) {
	        var ref = this.options;
	        var min = ref.min;
	        var max = ref.max;
	        var reverse = ref.reverse;
	        var startAngle = ref.startAngle;
	        var endAngle = ref.endAngle;
	        var angle = endAngle - startAngle;
	        var result;

	        if (reverse) {
	            result = endAngle - (value - min) / (max - min) * angle;
	        } else {
	            result = ((value - min) / (max - min) * angle) + startAngle;
	        }

	        return result + GEO_ARC_ADJUST_ANGLE;
	    },

	    hasRanges: function() {
	        var ranges = this.options.ranges;

	        return ranges && ranges.length;
	    },

	    ticksSize: function() {
	        var ref = this.options;
	        var majorTicks = ref.majorTicks;
	        var minorTicks = ref.minorTicks;
	        var size = 0;
	        if (majorTicks.visible) {
	            size = majorTicks.size;
	        }

	        if (minorTicks.visible) {
	            size = Math.max(minorTicks.size, size);
	        }

	        return size;
	    },

	    renderLabels: function() {
	        var this$1 = this;

	        var options = this.options;
	        var arc = this.arc.clone();
	        var radius = arc.getRadiusX();
	        var tickAngles = this.tickAngles(arc, options.majorUnit);
	        var rangeSize = options.rangeSize = options.rangeSize || radius * 0.1;
	        var labelsGroup = new Group$5();

	        var rangeDistance = radius * 0.05;
	        if (defined(options.rangeDistance)) {
	            rangeDistance = options.rangeDistance;
	        } else {
	            options.rangeDistance = rangeDistance;
	        }

	        var labelsOptions = options.labels;
	        var isInside = labelsOptions.position === INSIDE;
	        var hasLabelElements = defined(this.labelElements);

	        if (isInside) {
	            radius -= this.ticksSize();

	            if (this.hasRanges() && !hasLabelElements) {
	                radius -= rangeSize + rangeDistance;
	            }
	            arc.setRadiusX(radius).setRadiusY(radius);
	        }

	        var labels = this.labels;
	        var count = labels.length;
	        var padding = labelsOptions.padding;

	        for (var i = 0; i < count; i++) {
	            var label = labels[i];
	            var halfWidth = label.box.width() / 2;
	            var halfHeight = label.box.height() / 2;
	            var angle = tickAngles[i];
	            var labelAngle = (angle - GEO_ARC_ADJUST_ANGLE) * DEGREE;

	            var lp = arc.pointAt(angle);
	            var cx = lp.x + (Math.cos(labelAngle) * (halfWidth + padding) * (isInside ? 1 : -1));
	            var cy = lp.y + (Math.sin(labelAngle) * (halfHeight + padding) * (isInside ? 1 : -1));

	            label.reflow(new Box(cx - halfWidth, cy - halfHeight, cx + halfWidth, cy + halfHeight));
	            var labelPos = new GeometryPoint(label.box.x1, label.box.y1);

	            var labelElement = (void 0);
	            if (!hasLabelElements) {
	                labelElement = buildLabelElement(label, options.labels);
	                labelsGroup.append(labelElement);
	            } else {
	                labelElement = this$1.labelElements.children[i];
	                var prevLabelPos = labelElement.bbox().origin;

	                var labelTransform = labelElement.transform() || transform();
	                labelTransform.translate(labelPos.x - prevLabelPos.x, labelPos.y - prevLabelPos.y);
	                labelElement.transform(labelTransform);
	            }

	            this$1.bbox = Rect.union(this$1.bbox, labelElement.bbox());
	        }

	        return labelsGroup;
	    },

	    repositionRanges: function() {
	        var ranges = this.ranges.children;

	        if (ranges.length > 0) {
	            var ref = this.options;
	            var rangeDistance = ref.rangeDistance;
	            var rangeSize = ref.rangeSize;
	            var rangeRadius = this.getRangeRadius();

	            if (this.options.labels.position === INSIDE) {
	                rangeRadius += rangeSize + rangeDistance;
	            }

	            var newRadius = rangeRadius + (rangeSize / 2);

	            for (var i = 0; i < ranges.length; i++) {
	                ranges[i]._geometry.setRadiusX(newRadius).setRadiusY(newRadius);
	            }

	            this.bbox = Rect.union(this.bbox, this.ranges.bbox());
	        }
	    },

	    renderRanges: function() {
	        var this$1 = this;

	        var segments = this.rangeSegments();
	        var segmentsCount = segments.length;
	        var result = new Group$5();

	        if (segmentsCount) {
	            var ref = this.options;
	            var rangeSize = ref.rangeSize;
	            var reverse = ref.reverse;
	            var rangeDistance = ref.rangeDistance;
	            var rangeRadius = this.getRangeRadius();

	            // move the ticks with a range distance and a range size
	            this.radius(this.radius() - rangeSize - rangeDistance);

	            for (var i = 0; i < segmentsCount; i++) {
	                var segment = segments[i];
	                var from = this$1.slotAngle(segment[reverse ? "to" : "from"]);
	                var to = this$1.slotAngle(segment[!reverse ? "to" : "from"]);

	                if (to - from !== 0) {
	                    result.append(this$1.createRange(from, to, rangeRadius, segment));
	                }
	            }
	        }

	        return result;
	    },

	    createRange: function(startAngle, endAngle, rangeRadius, options) {
	        var rangeSize = this.options.rangeSize;
	        var rangeGeom = new geometry.Arc(this.arc.center, {
	            radiusX: rangeRadius + (rangeSize / 2),
	            radiusY: rangeRadius + (rangeSize / 2),
	            startAngle: startAngle,
	            endAngle: endAngle
	        });

	        return new Arc(rangeGeom, {
	            stroke: {
	                width: rangeSize,
	                color: options.color,
	                opacity: options.opacity,
	                lineCap: options.lineCap
	            }
	        });
	    },

	    rangeSegments: function() {
	        var options = this.options;
	        var ranges = options.ranges || [];
	        var count = ranges.length;
	        var segments = [];

	        if (count) {
	            var min = options.min;
	            var max = options.max;
	            var defaultColor = options.rangePlaceholderColor;
	            segments.push(rangeSegment(min, max, defaultColor));

	            for (var i = 0; i < count; i++) {
	                var range = getRange(ranges[i], min, max);
	                var segmentsCount = segments.length;

	                for (var j = 0; j < segmentsCount; j++) {
	                    var segment = segments[j];

	                    if (segment.from <= range.from && range.from <= segment.to) {
	                        segments.push(rangeSegment(range.from, range.to, range.color, range.opacity));

	                        if (segment.from <= range.to && range.to <= segment.to) {
	                            segments.push(rangeSegment(range.to, segment.to, defaultColor, range.opacity));
	                        }

	                        segment.to = range.from;

	                        break;
	                    }
	                }
	            }
	        }

	        return segments;
	    },

	    getRangeRadius: function() {
	        var ref = this;
	        var arc = ref.arc;
	        var options = ref.options;
	        var rangeSize = options.rangeSize;
	        var rangeDistance = options.rangeDistance;
	        var majorTickSize = options.majorTicks.size;
	        var radius;

	        if (options.labels.position === OUTSIDE) {
	            radius = arc.getRadiusX() - majorTickSize - rangeDistance - rangeSize;
	        } else {
	            radius = arc.getRadiusX() - rangeSize;
	        }

	        return radius;
	    },

	    renderArc: function(center, radius) {
	        var options = this.options;

	        var arc = this.arc = new geometry.Arc(center, {
	            radiusX: radius,
	            radiusY: radius,
	            startAngle: options.startAngle + GEO_ARC_ADJUST_ANGLE,
	            endAngle: options.endAngle + GEO_ARC_ADJUST_ANGLE
	        });

	        return arc;
	    },

	    renderTicks: function() {
	        var ref = this;
	        var arc = ref.arc;
	        var options = ref.options;
	        var tickArc = arc.clone();

	        this.majorTickAngles = this.tickAngles(arc, options.majorUnit);
	        this.majorTicks = drawTicks(tickArc, this.majorTickAngles, options.majorUnit, options.majorTicks);

	        var allTicks = new Group$5();
	        allTicks.append(this.majorTicks);

	        var majorTickSize = options.majorTicks.size;
	        var minorTickSize = options.minorTicks.size;

	        this._tickDifference = majorTickSize - minorTickSize;

	        if (options.labels.position === OUTSIDE) {
	            var radius = tickArc.getRadiusX();
	            tickArc.setRadiusX(radius - majorTickSize + minorTickSize)
	                   .setRadiusY(radius - majorTickSize + minorTickSize);
	        }

	        this.minorTickAngles = this.normalizeTickAngles(this.tickAngles(arc, options.minorUnit));
	        this.minorTicks = drawTicks(tickArc, this.minorTickAngles, options.minorUnit, options.minorTicks);
	        allTicks.append(this.minorTicks);

	        return allTicks;
	    },

	    normalizeTickAngles: function(angles) {
	        var options = this.options;
	        var skip = options.majorUnit / options.minorUnit;

	        for (var i = angles.length - 1; i >= 0; i--) {
	            if (i % skip === 0) {
	                angles.splice(i, 1);
	            }
	        }

	        return angles;
	    },

	    tickAngles: fun