@amcharts/amcharts5 5.1.14 → 5.2.0

package/.internal/charts/stock/drawing/DrawingSeries.js

@@ -0,0 +1,849 @@
+import { __extends } from "tslib";
+import { LineSeries } from "../../xy/series/LineSeries";
+import { Bullet } from "../../../core/render/Bullet";
+import { Circle } from "../../../core/render/Circle";
+import { Container } from "../../../core/render/Container";
+import { Template } from "../../../core/util/Template";
+import * as $array from "../../../core/util/Array";
+import * as $time from "../../../core/util/Time";
+import * as $type from "../../../core/util/Type";
+import * as $math from "../../../core/util/Math";
+import * as $object from "../../../core/util/Object";
+var DrawingSeries = /** @class */ (function (_super) {
+    __extends(DrawingSeries, _super);
+    function DrawingSeries() {
+        var _this = _super !== null && _super.apply(this, arguments) || this;
+        Object.defineProperty(_this, "_clickDp", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(_this, "_moveDp", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(_this, "_downDp", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(_this, "_upDp", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(_this, "_drawingEnabled", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: false
+        });
+        Object.defineProperty(_this, "_isDragging", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: false
+        });
+        Object.defineProperty(_this, "_clickPointerPoint", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(_this, "_movePointerPoint", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(_this, "_isDrawing", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: false
+        });
+        Object.defineProperty(_this, "_isPointerDown", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: false
+        });
+        Object.defineProperty(_this, "_index", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 0
+        });
+        Object.defineProperty(_this, "_di", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: []
+        });
+        Object.defineProperty(_this, "_dragStartPX", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 0
+        });
+        Object.defineProperty(_this, "_dragStartY", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 0
+        });
+        Object.defineProperty(_this, "_dvpX", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: {}
+        });
+        Object.defineProperty(_this, "_dvY", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: {}
+        });
+        Object.defineProperty(_this, "_isHover", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: false
+        });
+        Object.defineProperty(_this, "_erasingEnabled", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: false
+        });
+        Object.defineProperty(_this, "_tag", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        return _this;
+    }
+    Object.defineProperty(DrawingSeries.prototype, "_afterNew", {
+        enumerable: false,
+        configurable: true,
+        writable: true,
+        value: function () {
+            var _this = this;
+            this.addTag("drawing");
+            if (this._tag) {
+                this.addTag(this._tag);
+            }
+            this.set("valueYField", "valueY");
+            this.set("valueXField", "valueX");
+            _super.prototype._afterNew.call(this);
+            this._di[0] = {};
+            this.set("connect", false);
+            this.set("autoGapCount", Infinity);
+            this.set("ignoreMinMax", true);
+            var strokesTemplate = this.strokes.template;
+            strokesTemplate.set("templateField", "stroke");
+            var fillsTemplate = this.fills.template;
+            fillsTemplate.setAll({ templateField: "fill" });
+            fillsTemplate.events.on("dragstart", function (e) {
+                _this._handleFillDragStart(e, _this._getIndex(e.target));
+                _this._isPointerDown = true;
+            });
+            fillsTemplate.events.on("pointerdown", function (e) {
+                var index = _this._getIndex(e.target);
+                if (_this._erasingEnabled) {
+                    _this._disposeIndex(index);
+                }
+                else {
+                    var originalEvent = e.originalEvent;
+                    if (!originalEvent.button && _this._drawingEnabled) {
+                        _this._handlePointerDown(e);
+                    }
+                }
+                var stroke = _this.strokes.getIndex(_this._getStrokeIndex(index));
+                if (stroke) {
+                    stroke.dragStart(e);
+                }
+            });
+            strokesTemplate.events.on("pointerdown", function (e) {
+                if (_this._erasingEnabled) {
+                    _this._disposeIndex(_this._getIndex(e.target));
+                }
+                else {
+                    var originalEvent = e.originalEvent;
+                    if (!originalEvent.button && _this._drawingEnabled) {
+                        _this._handlePointerDown(e);
+                    }
+                }
+            });
+            fillsTemplate.events.on("dragstop", function (e) {
+                _this._isPointerDown = false;
+                var index = _this._getIndex(e.target);
+                _this._handleFillDragStop(e, index);
+                var stroke = _this.strokes.getIndex(_this._getStrokeIndex(index));
+                if (stroke) {
+                    stroke.dragStop(e);
+                }
+            });
+            fillsTemplate.events.on("pointerover", function (e) {
+                var index = _this._getIndex(e.target);
+                var stroke = _this.strokes.getIndex(_this._getStrokeIndex(index));
+                if (stroke) {
+                    stroke.hover();
+                }
+                _this._isHover = true;
+                _this._showSegmentBullets(index);
+            });
+            fillsTemplate.events.on("pointerout", function () {
+                _this._isHover = false;
+                _this._hideAllBullets();
+            });
+            strokesTemplate.events.on("pointerover", function (e) {
+                _this._isHover = true;
+                _this._showSegmentBullets(_this._getIndex(e.target));
+            });
+            strokesTemplate.events.on("pointerout", function () {
+                _this._isHover = false;
+                _this._hideAllBullets();
+            });
+            strokesTemplate.events.on("dragstop", function (e) {
+                _this._handleFillDragStop(e, _this._getIndex(e.target));
+            });
+            strokesTemplate.events.on("dragstart", function (e) {
+                _this._handleFillDragStart(e, _this._getIndex(e.target));
+            });
+            this.set("groupDataDisabled", true);
+            this.bulletsContainer.states.create("hidden", { visible: true, opacity: 0 });
+            this.bullets.push(function () {
+                var color = _this.get("strokeColor", _this.get("stroke"));
+                var container = Container.new(_this._root, {
+                    themeTags: ["grip"],
+                    setStateOnChildren: true,
+                    draggable: true
+                });
+                container.children.push(Circle.new(_this._root, {
+                    themeTags: ["outline"],
+                    stroke: color
+                }));
+                container.children.push(Circle.new(_this._root, {
+                    stroke: color
+                }));
+                container.events.on("pointerover", function (event) {
+                    var dataItem = event.target.dataItem;
+                    if (dataItem) {
+                        var dataContext = dataItem.dataContext;
+                        _this._showSegmentBullets(dataContext.index);
+                    }
+                });
+                container.events.on("pointerout", function () {
+                    _this._hideAllBullets();
+                });
+                _this._addBulletInteraction(container);
+                _this._tweakBullet(container);
+                return Bullet.new(_this._root, {
+                    locationX: undefined,
+                    sprite: container
+                });
+            });
+            this.events.on("pointerover", function () {
+                _this._handlePointerOver();
+            });
+            this.events.on("pointerout", function () {
+                _this._handlePointerOut();
+            });
+        }
+    });
+    Object.defineProperty(DrawingSeries.prototype, "_disposeIndex", {
+        enumerable: false,
+        configurable: true,
+        writable: true,
+        value: function (index) {
+            var _this = this;
+            var dataItems = this._di[index];
+            if (dataItems) {
+                $object.each(dataItems, function (_key, dataItem) {
+                    _this.disposeDataItem(dataItem);
+                });
+            }
+        }
+    });
+    Object.defineProperty(DrawingSeries.prototype, "clearDrawings", {
+        enumerable: false,
+        configurable: true,
+        writable: true,
+        value: function () {
+            var _this = this;
+            $array.each(this._di, function (_dataItems, index) {
+                _this._disposeIndex(index);
+            });
+        }
+    });
+    Object.defineProperty(DrawingSeries.prototype, "_getIndex", {
+        enumerable: false,
+        configurable: true,
+        writable: true,
+        value: function (sprite) {
+            var userData = sprite.get("userData");
+            if (userData && userData.length > 0) {
+                var dataItem = this.dataItems[userData[0]];
+                if (dataItem) {
+                    var dataContext = dataItem.dataContext;
+                    if (dataContext) {
+                        return dataContext.index;
+                    }
+                }
+            }
+            return 0;
+        }
+    });
+    Object.defineProperty(DrawingSeries.prototype, "_getStrokeIndex", {
+        enumerable: false,
+        configurable: true,
+        writable: true,
+        value: function (index) {
+            var _this = this;
+            var i = 0;
+            var c = index;
+            this.strokes.each(function (stroke) {
+                var strokeIndex = _this._getIndex(stroke);
+                if (strokeIndex == index) {
+                    c = i;
+                }
+                i++;
+            });
+            return c;
+        }
+    });
+    Object.defineProperty(DrawingSeries.prototype, "_showSegmentBullets", {
+        enumerable: false,
+        configurable: true,
+        writable: true,
+        value: function (index) {
+            var dataItems = this._di[index];
+            if (dataItems) {
+                $object.each(dataItems, function (_key, dataItem) {
+                    var bullets = dataItem.bullets;
+                    if (bullets) {
+                        $array.each(bullets, function (bullet) {
+                            var sprite = bullet.get("sprite");
+                            if (sprite) {
+                                sprite.show();
+                            }
+                        });
+                    }
+                });
+            }
+        }
+    });
+    Object.defineProperty(DrawingSeries.prototype, "_hideAllBullets", {
+        enumerable: false,
+        configurable: true,
+        writable: true,
+        value: function () {
+            this.strokes.each(function (stroke) {
+                stroke.unhover();
+            });
+            if (!this._drawingEnabled && !this._isDragging) {
+                var dataItems = this.dataItems;
+                $array.each(dataItems, function (dataItem) {
+                    var bullets = dataItem.bullets;
+                    if (bullets) {
+                        $array.each(bullets, function (bullet) {
+                            var sprite = bullet.get("sprite");
+                            if (sprite) {
+                                sprite.hide();
+                            }
+                        });
+                    }
+                });
+            }
+        }
+    });
+    Object.defineProperty(DrawingSeries.prototype, "_handleFillDragStart", {
+        enumerable: false,
+        configurable: true,
+        writable: true,
+        value: function (event, index) {
+            var _this = this;
+            var chart = this.chart;
+            if (chart) {
+                var xAxis_1 = this.get("xAxis");
+                var yAxis = this.get("yAxis");
+                var point = chart.plotContainer.toLocal(event.point);
+                this._dragStartPX = xAxis_1.coordinateToPosition(point.x);
+                this._dragStartY = this._getYValue(yAxis.positionToValue(yAxis.coordinateToPosition(point.y)));
+                var dataItems = this._di[index];
+                if (dataItems) {
+                    $object.each(dataItems, function (key, dataItem) {
+                        _this._dvpX[key] = xAxis_1.valueToPosition(dataItem.get("valueX", 0));
+                        _this._dvY[key] = dataItem.get("valueY");
+                    });
+                }
+            }
+        }
+    });
+    Object.defineProperty(DrawingSeries.prototype, "_handleFillDragStop", {
+        enumerable: false,
+        configurable: true,
+        writable: true,
+        value: function (event, index) {
+            var _this = this;
+            var chart = this.chart;
+            if (chart) {
+                var point = chart.plotContainer.toLocal(event.point);
+                var xAxis_2 = this.get("xAxis");
+                var yAxis = this.get("yAxis");
+                var posX = xAxis_2.coordinateToPosition(point.x);
+                var valueY = this._getYValue(yAxis.positionToValue(yAxis.coordinateToPosition(point.y)));
+                var dpx_1 = posX - this._dragStartPX;
+                var dy_1 = valueY - this._dragStartY;
+                var dataItems = this._di[index];
+                if (dataItems) {
+                    $object.each(dataItems, function (key, dataItem) {
+                        var dvpx = _this._dvpX[key];
+                        var dvy = _this._dvY[key];
+                        if ($type.isNumber(dvpx) && $type.isNumber(dvy)) {
+                            var vpx = dvpx + dpx_1;
+                            var vy = dvy + dy_1;
+                            var vx = _this._getXValue(xAxis_2.positionToValue(vpx));
+                            dataItem.set("valueX", vx);
+                            _this._setXLocation(dataItem, vx);
+                            dataItem.set("valueY", vy);
+                            dataItem.set("valueYWorking", vy);
+                        }
+                    });
+                }
+            }
+            this._updateSegment(index);
+            this._updateElements();
+        }
+    });
+    Object.defineProperty(DrawingSeries.prototype, "_updateSegment", {
+        enumerable: false,
+        configurable: true,
+        writable: true,
+        value: function (_index) {
+        }
+    });
+    Object.defineProperty(DrawingSeries.prototype, "_updateChildren", {
+        enumerable: false,
+        configurable: true,
+        writable: true,
+        value: function () {
+            if (this.isDirty("strokeColor") || this.isDirty("fillColor") || this.isDirty("strokeOpacity") || this.isDirty("fillOpacity") || this.isDirty("strokeWidth") || this.isDirty("strokeDasharray")) {
+                this.data.push({ stroke: this._getStrokeTemplate(), fill: this._getFillTemplate() });
+            }
+            this._updateElements();
+            _super.prototype._updateChildren.call(this);
+        }
+    });
+    Object.defineProperty(DrawingSeries.prototype, "_getFillTemplate", {
+        enumerable: false,
+        configurable: true,
+        writable: true,
+        value: function () {
+            var fillTemplate = {};
+            var fillColor = this.get("fillColor");
+            if (fillColor != null) {
+                fillTemplate.fill = fillColor;
+            }
+            var fillOpacity = this.get("fillOpacity");
+            if (fillOpacity != null) {
+                fillTemplate.fillOpacity = fillOpacity;
+            }
+            return Template.new(fillTemplate);
+        }
+    });
+    Object.defineProperty(DrawingSeries.prototype, "_getStrokeTemplate", {
+        enumerable: false,
+        configurable: true,
+        writable: true,
+        value: function () {
+            var strokeTemplate = {};
+            var strokeColor = this.get("strokeColor");
+            if (strokeColor != null) {
+                strokeTemplate.stroke = strokeColor;
+            }
+            var strokeOpacity = this.get("strokeOpacity");
+            if (strokeOpacity != null) {
+                strokeTemplate.strokeOpacity = strokeOpacity;
+            }
+            var strokeDasharray = this.get("strokeDasharray");
+            if (strokeDasharray != null) {
+                strokeTemplate.strokeDasharray = strokeDasharray;
+            }
+            var strokeWidth = this.get("strokeWidth");
+            if (strokeWidth != null) {
+                strokeTemplate.strokeWidth = strokeWidth;
+            }
+            return Template.new(strokeTemplate);
+        }
+    });
+    Object.defineProperty(DrawingSeries.prototype, "_updateElements", {
+        enumerable: false,
+        configurable: true,
+        writable: true,
+        value: function () {
+        }
+    });
+    Object.defineProperty(DrawingSeries.prototype, "_tweakBullet", {
+        enumerable: false,
+        configurable: true,
+        writable: true,
+        value: function (_container) {
+        }
+    });
+    Object.defineProperty(DrawingSeries.prototype, "_addBulletInteraction", {
+        enumerable: false,
+        configurable: true,
+        writable: true,
+        value: function (sprite) {
+            var _this = this;
+            sprite.events.on("dragged", function (e) {
+                _this._handleBulletDragged(e);
+                _this._isDragging = true;
+            });
+            sprite.events.on("dragstart", function (e) {
+                _this._handleBulletDragStart(e);
+            });
+            sprite.events.on("dragstop", function (e) {
+                _this._handleBulletDragStop(e);
+                _this.setTimeout(function () {
+                    _this._isDragging = false;
+                }, 100);
+            });
+            sprite.events.on("click", function (e) {
+                if (_this._erasingEnabled) {
+                    var dataItem = e.target.dataItem;
+                    if (dataItem) {
+                        var dataContext = dataItem.dataContext;
+                        if (dataContext) {
+                            _this._disposeIndex(dataContext.index);
+                        }
+                    }
+                }
+                else {
+                    _this._handlePointerClick(e);
+                }
+            });
+        }
+    });
+    Object.defineProperty(DrawingSeries.prototype, "_handlePointerClick", {
+        enumerable: false,
+        configurable: true,
+        writable: true,
+        value: function (event) {
+            var chart = this.chart;
+            if (chart) {
+                this._clickPointerPoint = chart.plotContainer.toLocal(event.point);
+            }
+        }
+    });
+    // need this in order bullets not to be placed to the charts bullets container
+    Object.defineProperty(DrawingSeries.prototype, "_placeBulletsContainer", {
+        enumerable: false,
+        configurable: true,
+        writable: true,
+        value: function () {
+            this.children.moveValue(this.bulletsContainer);
+        }
+    });
+    Object.defineProperty(DrawingSeries.prototype, "_handleBulletDragged", {
+        enumerable: false,
+        configurable: true,
+        writable: true,
+        value: function (event) {
+            var dataItem = event.target.dataItem;
+            var chart = this.chart;
+            if (chart) {
+                var target = event.target;
+                var point = { x: target.x(), y: target.y() };
+                this._handleBulletDraggedReal(dataItem, point);
+            }
+            var dataContext = dataItem.dataContext;
+            if (dataContext) {
+                var index = dataContext.index;
+                this._updateSegment(index);
+                this._updateElements();
+            }
+        }
+    });
+    Object.defineProperty(DrawingSeries.prototype, "_handleBulletDraggedReal", {
+        enumerable: false,
+        configurable: true,
+        writable: true,
+        value: function (dataItem, point) {
+            var xAxis = this.get("xAxis");
+            var yAxis = this.get("yAxis");
+            var valueX = this._getXValue(xAxis.positionToValue(xAxis.coordinateToPosition(point.x)));
+            var valueY = this._getYValue(yAxis.positionToValue(yAxis.coordinateToPosition(point.y)));
+            dataItem.set("valueX", valueX);
+            this._setXLocation(dataItem, valueX);
+            dataItem.set("valueY", valueY);
+            dataItem.set("valueYWorking", valueY);
+            this._positionBullets(dataItem);
+        }
+    });
+    Object.defineProperty(DrawingSeries.prototype, "_handleBulletDragStart", {
+        enumerable: false,
+        configurable: true,
+        writable: true,
+        value: function (_event) {
+        }
+    });
+    Object.defineProperty(DrawingSeries.prototype, "_handleBulletDragStop", {
+        enumerable: false,
+        configurable: true,
+        writable: true,
+        value: function (_event) {
+        }
+    });
+    Object.defineProperty(DrawingSeries.prototype, "_handlePointerOver", {
+        enumerable: false,
+        configurable: true,
+        writable: true,
+        value: function () {
+        }
+    });
+    Object.defineProperty(DrawingSeries.prototype, "_handlePointerOut", {
+        enumerable: false,
+        configurable: true,
+        writable: true,
+        value: function () {
+        }
+    });
+    Object.defineProperty(DrawingSeries.prototype, "_addContextInfo", {
+        enumerable: false,
+        configurable: true,
+        writable: true,
+        value: function (index, corner) {
+            var dataItems = this.dataItems;
+            var len = dataItems.length;
+            var dataItem = dataItems[len - 1];
+            var dataContext = dataItem.dataContext;
+            if (dataContext) {
+                dataContext.index = index;
+                if (corner != null) {
+                    dataContext.corner = corner;
+                }
+            }
+            if (!this._di[index]) {
+                this._di[index] = {};
+            }
+            this._di[index][corner] = dataItem;
+        }
+    });
+    Object.defineProperty(DrawingSeries.prototype, "enableDrawing", {
+        enumerable: false,
+        configurable: true,
+        writable: true,
+        value: function () {
+            var _this = this;
+            var chart = this.chart;
+            this._erasingEnabled = false;
+            this._drawingEnabled = true;
+            if (chart) {
+                if (!this._clickDp) {
+                    this._clickDp = chart.plotContainer.events.on("click", function (e) {
+                        var originalEvent = e.originalEvent;
+                        if (!originalEvent.button && !_this._erasingEnabled) {
+                            _this._handlePointerClick(e);
+                        }
+                    });
+                }
+                if (!this._downDp) {
+                    this._downDp = chart.plotContainer.events.on("pointerdown", function (e) {
+                        var originalEvent = e.originalEvent;
+                        if (!originalEvent.button && !_this._erasingEnabled) {
+                            _this._handlePointerDown(e);
+                        }
+                    });
+                }
+                if (!this._upDp) {
+                    this._upDp = chart.plotContainer.events.on("globalpointerup", function (e) {
+                        var originalEvent = e.originalEvent;
+                        if (!originalEvent.button && !_this._erasingEnabled) {
+                            _this._handlePointerUp(e);
+                        }
+                    });
+                }
+                if (!this._moveDp) {
+                    this._moveDp = chart.plotContainer.events.on("globalpointermove", function (e) {
+                        if (!_this._erasingEnabled) {
+                            _this._handlePointerMove(e);
+                        }
+                    });
+                }
+            }
+        }
+    });
+    Object.defineProperty(DrawingSeries.prototype, "enableErasing", {
+        enumerable: false,
+        configurable: true,
+        writable: true,
+        value: function () {
+            this._erasingEnabled = true;
+        }
+    });
+    Object.defineProperty(DrawingSeries.prototype, "disableErasing", {
+        enumerable: false,
+        configurable: true,
+        writable: true,
+        value: function () {
+            this._erasingEnabled = false;
+        }
+    });
+    Object.defineProperty(DrawingSeries.prototype, "disableDrawing", {
+        enumerable: false,
+        configurable: true,
+        writable: true,
+        value: function () {
+            this._erasingEnabled = false;
+            this._drawingEnabled = false;
+            this._isDrawing = false;
+            if (this._clickDp) {
+                this._clickDp.dispose();
+                this._clickDp = undefined;
+            }
+            if (this._downDp) {
+                this._downDp.dispose();
+                this._downDp = undefined;
+            }
+            if (this._upDp) {
+                this._upDp.dispose();
+                this._upDp = undefined;
+            }
+            this._hideAllBullets();
+        }
+    });
+    Object.defineProperty(DrawingSeries.prototype, "_handlePointerMove", {
+        enumerable: false,
+        configurable: true,
+        writable: true,
+        value: function (event) {
+            var chart = this.chart;
+            if (chart) {
+                this._movePointerPoint = chart.plotContainer.toLocal(event.point);
+            }
+        }
+    });
+    Object.defineProperty(DrawingSeries.prototype, "_handlePointerDown", {
+        enumerable: false,
+        configurable: true,
+        writable: true,
+        value: function (_event) {
+            this._isPointerDown = true;
+        }
+    });
+    Object.defineProperty(DrawingSeries.prototype, "_handlePointerUp", {
+        enumerable: false,
+        configurable: true,
+        writable: true,
+        value: function (_event) {
+            this._isPointerDown = false;
+        }
+    });
+    Object.defineProperty(DrawingSeries.prototype, "startIndex", {
+        enumerable: false,
+        configurable: true,
+        writable: true,
+        value: function () {
+            return 0;
+        }
+    });
+    Object.defineProperty(DrawingSeries.prototype, "endIndex", {
+        enumerable: false,
+        configurable: true,
+        writable: true,
+        value: function () {
+            return this.dataItems.length;
+        }
+    });
+    Object.defineProperty(DrawingSeries.prototype, "_setXLocation", {
+        enumerable: false,
+        configurable: true,
+        writable: true,
+        value: function (dataItem, value) {
+            this._setXLocationReal(dataItem, value);
+        }
+    });
+    Object.defineProperty(DrawingSeries.prototype, "_setXLocationReal", {
+        enumerable: false,
+        configurable: true,
+        writable: true,
+        value: function (dataItem, value) {
+            var xAxis = this.get("xAxis");
+            var baseInterval = xAxis.getPrivate("baseInterval");
+            var open = $time.round(new Date(value), baseInterval.timeUnit, baseInterval.count, this._root.locale.firstDayOfWeek, this._root.utc).getTime();
+            var close = $time.add(new Date(open), baseInterval.timeUnit, baseInterval.count, this._root.utc).getTime();
+            var locationX = (value - open) / (close - open);
+            dataItem.set("locationX", locationX);
+        }
+    });
+    Object.defineProperty(DrawingSeries.prototype, "disposeDataItem", {
+        enumerable: false,
+        configurable: true,
+        writable: true,
+        value: function (dataItem) {
+            var _this = this;
+            var dataContext = dataItem.dataContext;
+            if (dataContext) {
+                var index = dataContext.index;
+                $array.removeFirst(this.dataItems, dataItem);
+                this.markDirtyValues();
+                var dataItems = this._di[index];
+                if (dataItems) {
+                    $object.each(dataItems, function (_key, dataItem) {
+                        _super.prototype.disposeDataItem.call(_this, dataItem);
+                    });
+                }
+            }
+        }
+    });
+    Object.defineProperty(DrawingSeries.prototype, "_getYValue", {
+        enumerable: false,
+        configurable: true,
+        writable: true,
+        value: function (value) {
+            if (this.get("valueYShow") == "valueYChangeSelectionPercent") {
+                var baseValueSeries = this.getPrivate("baseValueSeries");
+                if (baseValueSeries) {
+                    var baseValue = baseValueSeries._getBase("valueY");
+                    value = value / 100 * baseValue + baseValue;
+                }
+            }
+            return value;
+        }
+    });
+    Object.defineProperty(DrawingSeries.prototype, "_getXValue", {
+        enumerable: false,
+        configurable: true,
+        writable: true,
+        value: function (value) {
+            var xAxis = this.get("xAxis");
+            var min = xAxis.getPrivate("min", 0) + 1;
+            var max = xAxis.getPrivate("max", 1) - 1;
+            return $math.fitToRange(value, min, max);
+        }
+    });
+    Object.defineProperty(DrawingSeries, "className", {
+        enumerable: true,
+        configurable: true,
+        writable: true,
+        value: "DrawingSeries"
+    });
+    Object.defineProperty(DrawingSeries, "classNames", {
+        enumerable: true,
+        configurable: true,
+        writable: true,
+        value: LineSeries.classNames.concat([DrawingSeries.className])
+    });
+    return DrawingSeries;
+}(LineSeries));
+export { DrawingSeries };
+//# sourceMappingURL=DrawingSeries.js.map