igniteui-webcomponents-charts 5.4.0 → 5.5.0-beta.0

package/esm5/lib/DataAnnotationShapeLayer_combined.js

@@ -0,0 +1,1212 @@
+/*
+THIS INFRAGISTICS ULTIMATE SOFTWARE LICENSE  AGREEMENT ("AGREEMENT") LOCATED HERE:
+https://www.infragistics.com/legal/license/igultimate-la
+https://www.infragistics.com/legal/license/igultimate-eula
+GOVERNS THE LICENSING, INSTALLATION AND USE OF INFRAGISTICS SOFTWARE. BY DOWNLOADING AND/OR INSTALLING AND USING INFRAGISTICS SOFTWARE:  you are indicating that you have read and understand this Agreement, and agree to be legally bound by it on behalf of the yourself and your company.
+*/
+import { __extends, __values } from "tslib";
+import { DataAnnotationAxisLayer } from "./DataAnnotationAxisLayer";
+import { DependencyProperty } from "igniteui-webcomponents-core";
+import { OverlayTextLocation_$type } from "./OverlayTextLocation";
+import { Brush } from "igniteui-webcomponents-core";
+import { enumGetBox, Number_$type, typeCast, fromEnum, Point_$type, markType, markDep, getInstanceType, runOn } from "igniteui-webcomponents-core";
+import { AnnotationAppearanceMode_$type } from "./AnnotationAppearanceMode";
+import { OverlayTextUtil } from "./OverlayTextUtil";
+import { OverlayTextUpdatingEventArgs } from "./OverlayTextUpdatingEventArgs";
+import { DataAnnotationItem } from "./DataAnnotationItem";
+import { DataAnnotationInfo } from "./DataAnnotationInfo";
+import { DataAnnotationShapeLayerFrame } from "./DataAnnotationShapeLayerFrame";
+import { Dictionary$2 } from "igniteui-webcomponents-core";
+import { Axis } from "./Axis";
+import { Pool$1 } from "igniteui-webcomponents-core";
+import { AxisAnnotation } from "./AxisAnnotation";
+import { IFastItemsSource_$type } from "igniteui-webcomponents-core";
+import { List$1 } from "igniteui-webcomponents-core";
+import { ScalerParams } from "./ScalerParams";
+import { Defaults } from "./Defaults";
+import { DataAnnotationShapeFrameManager } from "./DataAnnotationShapeFrameManager";
+import { XamDataChart } from "./XamDataChart";
+import { CategoryAxisBase } from "./CategoryAxisBase";
+import { Size } from "igniteui-webcomponents-core";
+import { BrushUtil } from "igniteui-webcomponents-core";
+import { TextBlock } from "igniteui-webcomponents-core";
+import { Rectangle } from "igniteui-webcomponents-core";
+import { Extensions } from "igniteui-webcomponents-core";
+import { NumberFormatSpecifier } from "igniteui-webcomponents-core";
+import { BindingFormatter } from "igniteui-webcomponents-core";
+import { Path } from "igniteui-webcomponents-core";
+import { Tuple$2 } from "igniteui-webcomponents-core";
+import { PathFigure } from "igniteui-webcomponents-core";
+import { PathGeometry } from "igniteui-webcomponents-core";
+import { LineSegment } from "igniteui-webcomponents-core";
+import { OverlayTextInfo } from "./OverlayTextInfo";
+import { DoubleCollection } from "igniteui-webcomponents-core";
+import { DeviceUtils } from "igniteui-webcomponents-core";
+import { PropertyMetadata } from "igniteui-webcomponents-core";
+import { truncate, isNaN_, log10, isInfinity } from "igniteui-webcomponents-core";
+import { stringIsNullOrEmpty } from "igniteui-webcomponents-core";
+import { round10N } from "igniteui-webcomponents-core";
+import { AnnotationLayerView } from "./AnnotationLayerView";
+import { TranslateTransform } from "igniteui-webcomponents-core";
+import { LineGeometry } from "igniteui-webcomponents-core";
+/**
+ * @hidden
+ */
+var DataAnnotationShapeLayer = /** @class */ /*@__PURE__*/ (function (_super) {
+    __extends(DataAnnotationShapeLayer, _super);
+    function DataAnnotationShapeLayer() {
+        var _this = _super.call(this) || this;
+        _this.stylingOverlayText = null;
+        _this.stylingShapeAnnotation = null;
+        _this.stylingAxisAnnotation = null;
+        _this.acj = null;
+        _this.ach = null;
+        _this.acw = null;
+        _this.acv = null;
+        _this.acx = new List$1(DataAnnotationItem.$, 0);
+        _this.afe = null;
+        _this.adf = 0;
+        _this.acm = false;
+        _this.ab8 = null;
+        _this.ab9 = null;
+        _this.acf = null;
+        _this.acg = null;
+        var a = new DataAnnotationShapeLayerFrame();
+        var b = new DataAnnotationShapeLayerFrame();
+        var c = new DataAnnotationShapeLayerFrame();
+        var d = _this.ke / 1000;
+        _this.xh = a;
+        _this.xg = b;
+        _this.xi = c;
+        _this.ab = DataAnnotationShapeLayer.$;
+        return _this;
+    }
+    DataAnnotationShapeLayer.prototype.get_acu = function () {
+        return true;
+    };
+    Object.defineProperty(DataAnnotationShapeLayer.prototype, "acu", {
+        get: function () {
+            return this.get_acu();
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(DataAnnotationShapeLayer.prototype, "ack", {
+        get: function () {
+            return this.acj;
+        },
+        set: function (a) {
+            if (this.acj != a) {
+                var b = this.acj;
+                this.acj = a;
+                this.raisePropertyChanged("OverlayTextColumn", b, this.acj);
+            }
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(DataAnnotationShapeLayer.prototype, "aci", {
+        get: function () {
+            return this.ach;
+        },
+        set: function (a) {
+            var b = this.ach;
+            if (OverlayTextUtil.q(a)) {
+                a = OverlayTextUtil.c();
+            }
+            this.ach = a;
+            if (b != this.ach) {
+                this.raisePropertyChanged("OverlayTextStyle", b, this.ach);
+            }
+        },
+        enumerable: false,
+        configurable: true
+    });
+    DataAnnotationShapeLayer.prototype.rc = function (a, b, c, d) {
+        if (b == "CrosshairPoint") {
+            return;
+        }
+        _super.prototype.rc.call(this, a, b, c, d);
+        switch (b) {
+            case "SeriesViewer":
+                if (d == null) {
+                    if (this.acv != null && this.acv.count > 0) {
+                        var e = void 0;
+                        if (this.d4()) {
+                            e = this.xi;
+                        }
+                        else {
+                            e = this.xg;
+                        }
+                        e.a3();
+                        this.aek(e, true, true);
+                    }
+                }
+                break;
+            case DataAnnotationShapeLayer.$$p[0]:
+            case "AreaFillOpacity":
+                this.ru(true);
+                break;
+            case DataAnnotationShapeLayer.$$p[1]:
+            case "OverlayTextColumn":
+            case DataAnnotationShapeLayer.$$p[24]:
+            case DataAnnotationShapeLayer.$$p[19]:
+            case DataAnnotationShapeLayer.$$p[2]:
+            case DataAnnotationShapeLayer.$$p[13]:
+            case DataAnnotationShapeLayer.$$p[14]:
+            case DataAnnotationShapeLayer.$$p[16]:
+            case DataAnnotationShapeLayer.$$p[15]:
+            case DataAnnotationShapeLayer.$$p[3]:
+            case DataAnnotationShapeLayer.$$p[4]:
+            case DataAnnotationShapeLayer.$$p[6]:
+            case DataAnnotationShapeLayer.$$p[5]:
+            case DataAnnotationShapeLayer.$$p[8]:
+            case DataAnnotationShapeLayer.$$p[9]:
+            case DataAnnotationShapeLayer.$$p[11]:
+            case DataAnnotationShapeLayer.$$p[7]:
+            case DataAnnotationShapeLayer.$$p[10]:
+            case DataAnnotationShapeLayer.$$p[12]:
+            case DataAnnotationShapeLayer.$$p[17]:
+            case DataAnnotationShapeLayer.$$p[18]:
+            case DataAnnotationShapeLayer.$$p[23]:
+            case DataAnnotationShapeLayer.$$p[22]:
+                this.abe();
+                break;
+            case "FastItemsSource":
+                this.aeh(c, d);
+                this.abe();
+                break;
+            case DataAnnotationShapeLayer.$$p[21]:
+            case DataAnnotationShapeLayer.$$p[20]:
+                if (this.dp != null) {
+                    this.dp.deregisterColumn(this.ack);
+                    this.ack = this.dn(this.ad5);
+                }
+                break;
+        }
+    };
+    DataAnnotationShapeLayer.prototype.aco = function (a) {
+        return !stringIsNullOrEmpty(a);
+    };
+    DataAnnotationShapeLayer.prototype.dl = function (a) {
+        if (this.dp == null) {
+            return null;
+        }
+        if (!this.aco(a)) {
+            return null;
+        }
+        return _super.prototype.dl.call(this, a);
+    };
+    DataAnnotationShapeLayer.prototype.dn = function (a) {
+        if (this.dp == null) {
+            return null;
+        }
+        if (!this.aco(a)) {
+            return null;
+        }
+        return _super.prototype.dn.call(this, a);
+    };
+    DataAnnotationShapeLayer.prototype.aed = function (a) {
+        if (this.dp != null) {
+            this.dp.deregisterColumn(a);
+        }
+    };
+    DataAnnotationShapeLayer.prototype.aeh = function (a, b) {
+        this.acx.clear();
+        if (typeCast(IFastItemsSource_$type, a) != null) {
+            a.deregisterColumn(this.ack);
+            this.ack = null;
+        }
+        if (typeCast(IFastItemsSource_$type, b) != null) {
+            this.ack = this.dn(this.ad5);
+        }
+    };
+    DataAnnotationShapeLayer.prototype.pd = function (a, b, c, d) {
+        _super.prototype.pd.call(this, a, b, c, d);
+        switch (a) {
+            case 3:
+                this.aef(b);
+                break;
+            case 1:
+                for (var e = b; e < b + c; e++) {
+                    var f = new DataAnnotationItem();
+                    this.acx.insert(e, f);
+                    this.aef(e);
+                }
+                break;
+            case 0:
+                this.acx.v(b, c);
+                break;
+            case 2:
+                for (var g = b; g < b + c; g++) {
+                    this.aef(g);
+                }
+                break;
+            case 4:
+                this.aee();
+                break;
+        }
+        this.ru(true);
+    };
+    DataAnnotationShapeLayer.prototype.ct = function () {
+        return new DataAnnotationShapeLayerView(this);
+    };
+    DataAnnotationShapeLayer.prototype.q3 = function (a) {
+        _super.prototype.q3.call(this, a);
+        this.acb = a;
+    };
+    DataAnnotationShapeLayer.prototype.aeg = function () {
+        this.jq = Defaults.dataAnnotationShapeThickness;
+        this.im = Defaults.dataAnnotationShapeThickness;
+        this.ig = Defaults.dataAnnotationShapeThickness;
+        this.il = Defaults.dataAnnotationShapeFillOpacity;
+        this.aap = Defaults.dataAnnotationLabelThickness;
+        this.ach = OverlayTextUtil.c();
+    };
+    DataAnnotationShapeLayer.prototype.qr = function () {
+        _super.prototype.qr.call(this);
+        if (!this.a1.c && !this.d4()) {
+            return;
+        }
+        if (this.aag) {
+            this.aag = false;
+            this.aee();
+        }
+        if (this.d4()) {
+            this.ael(this.xi, false);
+        }
+        else {
+            this.ael(this.xg, false);
+        }
+    };
+    DataAnnotationShapeLayer.prototype.aee = function () {
+        this.acx.clear();
+        if (this.dp == null || this.dp.count == 0) {
+            return;
+        }
+        for (var a = 0; a < this.dp.count; a++) {
+            var b = new DataAnnotationItem();
+            this.acx.add(b);
+            this.aef(a);
+        }
+    };
+    DataAnnotationShapeLayer.prototype.aef = function (a) {
+    };
+    DataAnnotationShapeLayer.prototype.ael = function (a, b) {
+        var c = false;
+        if (this.acv == null) {
+            c = true;
+            this.acw = new List$1(Axis.$, 0);
+            this.acv = new Dictionary$2(Axis.$, Pool$1.$.specialize(AxisAnnotation.$), 0);
+        }
+        this.aek(a, c, b);
+    };
+    DataAnnotationShapeLayer.prototype.aek = function (a, b, c) {
+        DataAnnotationShapeFrameManager.c(this, a, b, this.acv, this.acw, c, this.aas, this.aar);
+    };
+    DataAnnotationShapeLayer.prototype.yy = function (a, b) {
+        var e_1, _a, e_2, _b;
+        _super.prototype.yy.call(this, a, b);
+        var c = a;
+        var d = true;
+        c.a3();
+        this.adf = 0;
+        if (this.aad != null) {
+            if (this.aal(this.aad)) {
+                this.aej(this.aad, c, d);
+            }
+        }
+        else {
+            if (typeCast(XamDataChart.$, this.dc) !== null) {
+                var e = this.dc;
+                var f = true;
+                try {
+                    for (var _c = __values(fromEnum(e.axes)), _d = _c.next(); !_d.done; _d = _c.next()) {
+                        var g = _d.value;
+                        if (!this.aal(g)) {
+                            continue;
+                        }
+                        if (!g.cj) {
+                            f = false;
+                        }
+                    }
+                }
+                catch (e_1_1) {
+                    e_1 = { error: e_1_1 };
+                }
+                finally {
+                    try {
+                        if (_d && !_d.done && (_a = _c.return))
+                            _a.call(_c);
+                    }
+                    finally {
+                        if (e_1)
+                            throw e_1.error;
+                    }
+                }
+                try {
+                    for (var _e = __values(fromEnum(e.axes)), _f = _e.next(); !_f.done; _f = _e.next()) {
+                        var h = _f.value;
+                        if (!this.aal(h)) {
+                            continue;
+                        }
+                        if (this.aaf == 0) {
+                            if (typeCast(CategoryAxisBase.$, h) !== null) {
+                                this.aej(h, c, d);
+                            }
+                            else if (h.cj && !h.cp && f) {
+                                this.aej(h, c, d);
+                            }
+                        }
+                        else if (this.aaf == 1 && (h.cb || h.ce)) {
+                            this.aej(h, c, d);
+                        }
+                        else if (this.aaf == 4 && h.cb) {
+                            this.aej(h, c, d);
+                        }
+                        else if (this.aaf == 5 && h.ce) {
+                            this.aej(h, c, d);
+                        }
+                        else if (this.aaf == 6 && h.cj && !h.cp) {
+                            this.aej(h, c, d);
+                        }
+                        else if (this.aaf == 7 && h.cj && h.cp) {
+                            this.aej(h, c, d);
+                        }
+                        else if (this.aaf == 3 && h.cp) {
+                            this.aej(h, c, d);
+                        }
+                        else if (this.aaf == 2 && !h.cp) {
+                            this.aej(h, c, d);
+                        }
+                    }
+                }
+                catch (e_2_1) {
+                    e_2 = { error: e_2_1 };
+                }
+                finally {
+                    try {
+                        if (_f && !_f.done && (_b = _e.return))
+                            _b.call(_e);
+                    }
+                    finally {
+                        if (e_2)
+                            throw e_2.error;
+                    }
+                }
+            }
+        }
+    };
+    DataAnnotationShapeLayer.prototype.aej = function (a, b, c) {
+        var e_3, _a;
+        this.ab8 = null;
+        this.ab9 = null;
+        this.acf = null;
+        this.acg = null;
+        var d = this.getEffectiveViewport();
+        var e = this.dc.wh;
+        if (a.cp) {
+            this.ab9 = a;
+            if (this.ab9.aj != null) {
+                this.ab8 = this.ab9.aj;
+            }
+            else {
+                this.ab8 = this.ab7(a);
+            }
+            this.acm = false;
+        }
+        else {
+            this.ab8 = a;
+            if (this.ab8.aj != null) {
+                this.ab9 = this.ab8.aj;
+            }
+            else {
+                this.ab9 = this.ab7(a);
+            }
+            this.acm = true;
+        }
+        if (this.ab8 == null) {
+            return;
+        }
+        if (this.ab9 == null) {
+            return;
+        }
+        this.acg = new ScalerParams(1, e, this.ab9.kh, this.ab9.ch);
+        this.acf = new ScalerParams(1, e, this.ab8.kh, this.ab8.ch);
+        this.acf.c = d;
+        this.acg.c = d;
+        var f = this.ig;
+        var g = this.zt();
+        if (g == null) {
+            g = BrushUtil.j(255, 0, 0, 0);
+        }
+        var h = this.acu ? this.zu() : g;
+        if (h == null) {
+            h = BrushUtil.j(255, 0, 0, 0);
+        }
+        g = OverlayTextUtil.ah(g, this.xs, this.w3);
+        h = OverlayTextUtil.ah(h, this.xs, this.w3);
+        var i = this.acm;
+        this.aee();
+        this.acb.cu();
+        this.aei();
+        var j = this.aci;
+        var k = OverlayTextUtil.o(j, this.act);
+        var l = this.acd;
+        if (l == 18) {
+            k = false;
+        }
+        if (k) {
+            this.acb.cq.count = this.acx.count;
+            this.acb.cp.count = this.acx.count;
+        }
+        for (var m = 0; m < this.acx.count; m++) {
+            var n = this.acx._inner[m];
+            n.dataIndex = m;
+            n.shapeBrush = n.shapeBrush != null ? n.shapeBrush : g;
+            n.shapeOutline = n.shapeOutline != null ? n.shapeOutline : h;
+            if (this.acu) {
+                n.shapeBrush = BrushUtil.s(n.shapeBrush, this.il);
+            }
+            n.shapeThickness = !isNaN_(n.shapeThickness) ? n.shapeThickness : f;
+            n.h = 1.7976931348623157E+308;
+            n.f = 1.7976931348623157E+308;
+            n.g = -1.7976931348623157E+308;
+            n.d = -1.7976931348623157E+308;
+            var o = new List$1(Point_$type, 0);
+            for (var p = 0; p < n.c.count; p++) {
+                var q = n.c._inner[p];
+                var r = this.afh(q.y, false);
+                o.add(r);
+                var s = this.afh(q.y, true);
+                n.h = Math.min(s.y, n.h);
+                n.d = Math.max(s.y, n.d);
+                n.f = Math.min(s.x, n.f);
+                n.g = Math.max(s.x, n.g);
+            }
+            var t = new List$1(DataAnnotationInfo.$, 0);
+            t = new List$1(DataAnnotationInfo.$, 0);
+            t.o(n.c);
+            t.o(n.b);
+            if (this.stylingShapeAnnotation != null) {
+                this.stylingShapeAnnotation(this, n);
+            }
+            b.ay.add(o);
+            b.aw.add(n.a);
+            b.av.add(n.shapeBrush);
+            b.ax.add(n.shapeOutline);
+            b.az.add(n.shapeThickness);
+            b.a0.add(this.acl);
+            var u = this.ab0;
+            if (u == null) {
+                u = this.aah ? g : Defaults.dataAnnotationLabelBackground;
+            }
+            var v = this.ab1;
+            if (v == null) {
+                v = this.aai ? h : Defaults.dataAnnotationLabelBorderStroke;
+            }
+            var w = this.acu ? n.shapeOutline : n.shapeBrush;
+            var x = this.ab2;
+            if (x == null) {
+                x = this.aak ? w : this.ab2;
+            }
+            var y = OverlayTextUtil.t(this.aap, Defaults.dataAnnotationLabelBorderThickness);
+            var z = OverlayTextUtil.t(this.aan, Defaults.dataAnnotationLabelBorderRadius);
+            try {
+                for (var _b = (e_3 = void 0, __values(fromEnum(t))), _c = _b.next(); !_c.done; _c = _b.next()) {
+                    var aa = _c.value;
+                    if (aa.borderColor == null) {
+                        aa.borderColor = v;
+                    }
+                    if (aa.background == null) {
+                        aa.background = u;
+                    }
+                    if (aa.textColor == null) {
+                        aa.textColor = x;
+                    }
+                    aa.borderColor = OverlayTextUtil.ah(aa.borderColor, this.aao, this.aab);
+                    aa.background = OverlayTextUtil.ah(aa.background, this.aam, this.aaa);
+                    aa.textColor = OverlayTextUtil.af(aa.background, aa.textColor, this.aaq, this.aac);
+                    if (isNaN_(aa.borderThickness)) {
+                        aa.borderThickness = y;
+                    }
+                    if (isNaN_(aa.borderRadius)) {
+                        aa.borderRadius = z;
+                    }
+                    var ab = this.afh(aa.y, false);
+                    aa.xAxisPixel = ab.x;
+                    aa.yAxisPixel = ab.y;
+                    aa.xAxisWindow = this.add(ab.x);
+                    aa.yAxisWindow = this.ade(ab.y);
+                    aa.xAxisValue = aa.c ? this.ab8.eo(ab.x, this.acf) : NaN;
+                    aa.yAxisValue = aa.d ? this.ab9.eo(ab.y, this.acg) : NaN;
+                    aa.xAxisLabel = this.adh(this.ab8, aa, true);
+                    aa.yAxisLabel = this.adh(this.ab9, aa, false);
+                    aa.dataIndex = n.dataIndex;
+                    if (this.stylingAxisAnnotation != null) {
+                        this.stylingAxisAnnotation(this, aa);
+                    }
+                }
+            }
+            catch (e_3_1) {
+                e_3 = { error: e_3_1 };
+            }
+            finally {
+                try {
+                    if (_c && !_c.done && (_a = _b.return))
+                        _a.call(_b);
+                }
+                finally {
+                    if (e_3)
+                        throw e_3.error;
+                }
+            }
+            if (this.aaj) {
+                for (var ac = 0; ac < t.count; ac++) {
+                    var ad = t._inner[ac];
+                    var ae = !stringIsNullOrEmpty(ad.xAxisLabel);
+                    var af = !stringIsNullOrEmpty(ad.yAxisLabel);
+                    DataAnnotationShapeFrameManager.b(b, ad.xAxisValue, ad.yAxisValue, ad.xAxisLabel, ad.yAxisLabel, ad.textColor, ad.background, ad.borderColor, ad.borderThickness, ad.borderRadius, this.ab3, ae, af, this.ab8, this.ab9, this.acf, this.acg);
+                }
+            }
+            var ag = this.adl;
+            if (stringIsNullOrEmpty(ag)) {
+                ag = this.adj(m, this.ack);
+            }
+            var ah = new Size(1, 0, 0);
+            var ai = { $type: Point_$type, x: NaN, y: NaN };
+            var aj = new OverlayTextUpdatingEventArgs();
+            aj.dataIndex = m;
+            aj.backgroundMode = this.ab4;
+            aj.backgroundShift = this.ac4;
+            aj.background = this.acq ? g : this.afb;
+            aj.borderMode = this.ab5;
+            aj.borderShift = this.ac6;
+            aj.borderStroke = this.acr ? g : this.afc;
+            aj.borderRadius = this.ac5;
+            aj.borderThickness = this.ac7;
+            aj.textLocation = this.acd;
+            aj.textAngle = this.ac3;
+            aj.textVisible = this.act;
+            aj.textContent = ag;
+            aj.textColorMode = this.ab6;
+            aj.textColorShift = this.ac8;
+            aj.textColor = this.acs ? g : this.afd;
+            aj.shapeBrush = g;
+            aj.shapeOutline = h;
+            aj.f = !i;
+            aj.horizontalMargin = this.ac9;
+            aj.verticalPadding = this.adc;
+            aj.verticalMargin = this.adb;
+            aj.horizontalPadding = this.ada;
+            if (this.stylingOverlayText != null) {
+                this.stylingOverlayText(this, aj);
+            }
+            OverlayTextUtil.ad(aj);
+            if (k && !stringIsNullOrEmpty(aj.textContent)) {
+                ah = this.cw.cc(aj.textContent, j);
+                ai = OverlayTextUtil.ak(aj.textLocation, ah, aj.textAngle, aj.horizontalMargin, aj.verticalMargin, aj.horizontalPadding, aj.verticalPadding, n.ac, i);
+            }
+            if (Extensions.a(ai)) {
+                b.aj.add(aj.borderThickness);
+                b.ah.add(aj.borderStroke);
+                b.ai.add(aj.borderRadius);
+                b.ag.add(aj.background);
+                b.ar.add(ah);
+                b.am.add(j);
+                b.ak.add(aj.textColor);
+                b.af.add(aj.textAngle);
+                b.al.add(aj.textContent);
+                b.ao.add(aj.horizontalPadding);
+                b.at.add(aj.verticalPadding);
+                b.an.add(aj.horizontalMargin);
+                b.as.add(aj.verticalMargin);
+                b.au.add(aj.textVisible);
+                b.ap.add(ai.x);
+                b.aq.add(ai.y);
+            }
+        }
+    };
+    DataAnnotationShapeLayer.prototype.aei = function () {
+        if (OverlayTextUtil.q(this.ach)) {
+            this.ach = OverlayTextUtil.c();
+        }
+        else if (OverlayTextUtil.k(this.ach)) {
+            this.ach = this.cw.l(this.ach.fontString);
+        }
+    };
+    DataAnnotationShapeLayer.prototype.adi = function (a, b, c, d) {
+        if (isNaN_(b)) {
+            return null;
+        }
+        if (c >= 0) {
+            var e = new NumberFormatSpecifier();
+            e.minimumFractionDigits = c;
+            e.maximumFractionDigits = d > 0 ? d : c;
+            var f = new BindingFormatter();
+            f.j = "{0}";
+            f.d = [e];
+            return f.i(b);
+        }
+        var g = 0;
+        if (d >= 0) {
+            g = d;
+        }
+        else if (a.cj) {
+            var h = a.ex();
+            g = h == 0 ? 0 : truncate(Math.max(-Math.floor(log10(h)), 0));
+            g += 1;
+        }
+        return round10N(b, g).toString();
+    };
+    DataAnnotationShapeLayer.prototype.adh = function (a, b, c) {
+        var d = c ? b.dataValueX : b.dataValueY;
+        var e = c ? b.dataLabelX : b.dataLabelY;
+        var f = c ? b.xAxisValue : b.yAxisValue;
+        var g = c ? b.xAxisPixel : b.yAxisPixel;
+        var h = c ? b.xAxisWindow : b.yAxisWindow;
+        var i = c ? b.a : b.b;
+        if (i == 6) {
+            return null;
+        }
+        if (this.aae != 0 && i == 0) {
+            i = this.aae;
+        }
+        if (i == 0) {
+            if (!stringIsNullOrEmpty(e)) {
+                return e;
+            }
+            else if (!isNaN_(d)) {
+                return this.adi(a, d, this.aas, this.aar);
+            }
+        }
+        else if (i == 1) {
+            return this.adi(a, d, this.aas, this.aar);
+        }
+        else if (i == 2) {
+            if (stringIsNullOrEmpty(e)) {
+                return null;
+            }
+            else {
+                return e;
+            }
+        }
+        else if (i == 4) {
+            var j = this.aas;
+            if (j < 0) {
+                j = 0;
+            }
+            var k = this.aas;
+            if (k < 0) {
+                k = 0;
+            }
+            return this.adi(a, g, j, k);
+        }
+        else if (i == 5) {
+            var l = this.aas;
+            if (l < 0) {
+                l = 2;
+            }
+            var m = this.aas;
+            if (m < 0) {
+                m = 2;
+            }
+            return this.adi(a, h, l, m);
+        }
+        else if (i == 3) {
+            if (a.cj) {
+                return this.adi(a, f, this.aas, this.aar);
+            }
+            else {
+                return a.gf(d);
+            }
+        }
+        return null;
+    };
+    DataAnnotationShapeLayer.prototype.y1 = function (a, b) {
+        var e_4, _a, e_5, _b;
+        _super.prototype.y1.call(this, a, b);
+        var c = this.acb.co;
+        var d = a;
+        var e = d.ay.count;
+        var f = 0;
+        var g = b.b9.top;
+        var h = b.b9.left;
+        var i = b.b9.right;
+        var j = b.b9.bottom;
+        var k = Math.min(h, i);
+        var l = Math.min(g, j);
+        var m = Math.max(h, i);
+        var n = Math.max(g, j);
+        var o = m - k;
+        var p = n - l;
+        for (var q = 0; q < e; q++) {
+            if (!d.a0._inner[q]) {
+                continue;
+            }
+            var r = null;
+            var s = this.aec(c, f, q, d);
+            r = s.c;
+            f = s.d;
+            var t = true;
+            var u = new List$1(PathFigure.$, 0);
+            var v = null;
+            var _loop_1 = function (w) {
+                if (!Extensions.a(w)) {
+                    t = true;
+                    if (v != null && v._segments.count > 0) {
+                        u.add(v);
+                    }
+                    return "continue";
+                }
+                if (t) {
+                    t = false;
+                    v = new PathFigure();
+                    v._startPoint = w;
+                }
+                else {
+                    var x = ((function () {
+                        var $ret = new LineSegment(1);
+                        $ret.c = w;
+                        return $ret;
+                    })());
+                    v._segments.add(x);
+                }
+            };
+            try {
+                for (var _c = (e_4 = void 0, __values(fromEnum(d.ay._inner[q]))), _d = _c.next(); !_d.done; _d = _c.next()) {
+                    var w = _d.value;
+                    _loop_1(w);
+                }
+            }
+            catch (e_4_1) {
+                e_4 = { error: e_4_1 };
+            }
+            finally {
+                try {
+                    if (_d && !_d.done && (_a = _c.return))
+                        _a.call(_c);
+                }
+                finally {
+                    if (e_4)
+                        throw e_4.error;
+                }
+            }
+            if (v != null && v._segments.count > 0) {
+                u.add(v);
+            }
+            var y = new PathGeometry();
+            try {
+                for (var _e = (e_5 = void 0, __values(fromEnum(u))), _f = _e.next(); !_f.done; _f = _e.next()) {
+                    var z = _f.value;
+                    z._isClosed = d.aw._inner[q];
+                    y.c.add(z);
+                }
+            }
+            catch (e_5_1) {
+                e_5 = { error: e_5_1 };
+            }
+            finally {
+                try {
+                    if (_f && !_f.done && (_b = _e.return))
+                        _b.call(_e);
+                }
+                finally {
+                    if (e_5)
+                        throw e_5.error;
+                }
+            }
+            r.an = y;
+            if (d.al.count > 0) {
+                var aa = new OverlayTextInfo();
+                aa.background = d.ag._inner[q];
+                aa.textColor = d.ak._inner[q];
+                aa.verticalPadding = d.at._inner[q];
+                aa.horizontalPadding = d.ao._inner[q];
+                aa.horizontalMargin = d.an._inner[q];
+                aa.verticalMargin = d.as._inner[q];
+                aa.borderThickness = d.aj._inner[q];
+                aa.borderStroke = d.ah._inner[q];
+                aa.borderRadius = d.ai._inner[q];
+                aa.textLocation = this.acd;
+                aa.textAngle = d.af._inner[q];
+                aa.textVisible = d.au._inner[q];
+                aa.textContent = d.al._inner[q];
+                aa.f = d.am._inner[q];
+                aa.ac = d.ar._inner[q];
+                aa.t = this.acb.cq.item(q);
+                aa.ab = this.acb.cp.item(q);
+                var ab = d.ap._inner[q];
+                var ac = d.aq._inner[q];
+                aa.z = { $type: Point_$type, x: ab, y: ac };
+                OverlayTextUtil.y(aa.ab, aa.background, aa.borderStroke, aa.borderThickness, aa.borderRadius);
+                OverlayTextUtil.z(aa.t, aa.textColor);
+                OverlayTextUtil.x(aa);
+                OverlayTextUtil.w(aa);
+                this.cw.av(aa.t, aa.f);
+                this.cw.aw(aa.t, aa.f);
+            }
+        }
+        c.count = f;
+        if (this.d4()) {
+            this.ael(this.xi, true);
+        }
+        else {
+            this.ael(this.xg, false);
+        }
+    };
+    DataAnnotationShapeLayer.prototype.aec = function (a, b, c, d) {
+        var e = a.item(b);
+        b++;
+        e.ad = d.az._inner[c];
+        e._stroke = d.ax._inner[c];
+        e._fill = d.av._inner[c];
+        e.ai = this.zv;
+        e.am = this.wa;
+        e.al = this.v9;
+        e.ak = this.v9;
+        e.aj = this.v8;
+        e.ac = this.ji;
+        return new Tuple$2(Path.$, Number_$type, e, b);
+    };
+    DataAnnotationShapeLayer.prototype.w7 = function () {
+        return 3;
+    };
+    DataAnnotationShapeLayer.prototype.xu = function () {
+        return 0.1;
+    };
+    DataAnnotationShapeLayer.prototype.xx = function () {
+        return -0.4;
+    };
+    DataAnnotationShapeLayer.prototype.xw = function () {
+        return NaN;
+    };
+    DataAnnotationShapeLayer.prototype.y6 = function () {
+        _super.prototype.y6.call(this);
+        this.xs = this.x0();
+    };
+    DataAnnotationShapeLayer.prototype.x0 = function () {
+        if (isNaN_(this.x3)) {
+            switch (this.w3) {
+                case 1: return this.xu();
+                case 2: return this.xx();
+                case 4:
+                case 3: return this.xw();
+            }
+        }
+        return this.x3;
+    };
+    DataAnnotationShapeLayer.prototype.zy = function () {
+        if (this.afe == null) {
+            this.afe = new DoubleCollection();
+            this.afe.add(DeviceUtils.g(2));
+            this.afe.add(DeviceUtils.g(4));
+        }
+        return this.afe;
+    };
+    DataAnnotationShapeLayer.prototype.adj = function (a, b) {
+        if (b == null || b.count <= a) {
+            return null;
+        }
+        var c = b.item(a);
+        return c != null ? c.toString() : null;
+    };
+    DataAnnotationShapeLayer.prototype.ac2 = function (a, b) {
+        if (b == null || b.count <= a) {
+            return NaN;
+        }
+        return b.item(a);
+    };
+    DataAnnotationShapeLayer.prototype.afg = function (a, b) {
+        if (b == null || b.count <= a) {
+            return { $type: Point_$type, x: NaN, y: NaN };
+        }
+        var c = b.item(a);
+        if (c == null || getInstanceType(c) != Point_$type) {
+            return { $type: Point_$type, x: NaN, y: NaN };
+        }
+        return b.item(a);
+    };
+    DataAnnotationShapeLayer.prototype.afh = function (a, b) {
+        if (b === void 0) {
+            b = false;
+        }
+        var c = b ? 1 : 2;
+        var d = b ? 0 : -1;
+        if (this.acp) {
+            var e = a.x;
+            var f = a.y;
+            if (isInfinity(e) && e > 0) {
+                e = c;
+            }
+            if (isInfinity(e) && e < 0) {
+                e = d;
+            }
+            if (isInfinity(f) && f > 0) {
+                f = c;
+            }
+            if (isInfinity(f) && f < 0) {
+                f = d;
+            }
+            return this.dc.v9({ $type: Point_$type, x: e, y: f });
+        }
+        else {
+            var g = a.x;
+            var h = a.y;
+            var i = false;
+            var j = false;
+            if (isInfinity(g) && g > 0) {
+                g = Math.floor(this.ac0(c));
+                i = true;
+            }
+            if (isInfinity(g) && g < 0) {
+                g = Math.floor(this.ac0(d));
+                i = true;
+            }
+            if (isInfinity(h) && h > 0) {
+                h = Math.floor(this.ac1(c));
+                j = true;
+            }
+            if (isInfinity(h) && h < 0) {
+                h = Math.floor(this.ac1(d));
+                j = true;
+            }
+            if (!i && !isNaN_(g)) {
+                g = this.ab8.el(g, this.acf);
+            }
+            if (!j && !isNaN_(h)) {
+                h = this.ab9.el(h, this.acg);
+            }
+            return { $type: Point_$type, x: g, y: h };
+        }
+    };
+    DataAnnotationShapeLayer.prototype.acy = function (a) {
+        return this.ab8.el(a, this.acf);
+    };
+    DataAnnotationShapeLayer.prototype.acz = function (a) {
+        return this.ab9.el(a, this.acg);
+    };
+    DataAnnotationShapeLayer.prototype.acn = function (a) {
+        if (this.ab8 == null) {
+            return false;
+        }
+        if (this.ab9 == null) {
+            return false;
+        }
+        if (this.acf == null) {
+            return false;
+        }
+        if (this.acg == null) {
+            return false;
+        }
+        if (this.dp == null) {
+            return false;
+        }
+        if (a < 0 || a >= this.dp.count) {
+            return false;
+        }
+        if (this.acx == null) {
+            return false;
+        }
+        if (a < 0 || a >= this.acx.count) {
+            return false;
+        }
+        return true;
+    };
+    DataAnnotationShapeLayer.prototype.ab7 = function (a) {
+        var e_6, _a;
+        if (typeCast(XamDataChart.$, this.dc) !== null) {
+            var b = this.dc;
+            try {
+                for (var _b = __values(fromEnum(b.axes)), _c = _b.next(); !_c.done; _c = _b.next()) {
+                    var c = _c.value;
+                    if (c.cp && !a.cp) {
+                        return c;
+                    }
+                    if (!c.cp && a.cp) {
+                        return c;
+                    }
+                }
+            }
+            catch (e_6_1) {
+                e_6 = { error: e_6_1 };
+            }
+            finally {
+                try {
+                    if (_c && !_c.done && (_a = _b.return))
+                        _a.call(_b);
+                }
+                finally {
+                    if (e_6)
+                        throw e_6.error;
+                }
+            }
+        }
+        return null;
+    };
+    DataAnnotationShapeLayer.prototype.aff = function (a) {
+        return this.dc.v9(a);
+    };
+    DataAnnotationShapeLayer.prototype.ac0 = function (a) {
+        return this.dc.v9({ $type: Point_$type, x: a, y: NaN }).x;
+    };
+    DataAnnotationShapeLayer.prototype.ac1 = function (a) {
+        return this.dc.v9({ $type: Point_$type, x: NaN, y: a }).y;
+    };
+    DataAnnotationShapeLayer.prototype.afi = function (a) {
+        return this.dc.wb(a);
+    };
+    DataAnnotationShapeLayer.prototype.add = function (a) {
+        return this.dc.wb({ $type: Point_$type, x: a, y: NaN }).x;
+    };
+    DataAnnotationShapeLayer.prototype.ade = function (a) {
+        return this.dc.wb({ $type: Point_$type, x: NaN, y: a }).y;
+    };
+    DataAnnotationShapeLayer.$t = markType(DataAnnotationShapeLayer, 'DataAnnotationShapeLayer', DataAnnotationAxisLayer.$);
+    DataAnnotationShapeLayer.$$p = markDep(DependencyProperty, PropertyMetadata, DataAnnotationShapeLayer, 'raisePropertyChanged', ['AnnotationShapeVisible:acl:aem', [0, true], 'ItemsUseWorldCoordinates:acp:aen', [0, false], 'OverlayTextAngle:ac3:aeo', [1, NaN], 'OverlayTextBackgroundMatchLayer:acq:aep', [0, false], 'OverlayTextBackgroundMode:ab4:aeq', [AnnotationAppearanceMode_$type, enumGetBox(AnnotationAppearanceMode_$type, 0)], 'OverlayTextBackground:afb:aer', [Brush.$, null], 'OverlayTextBackgroundShift:ac4:aes', [1, NaN], 'OverlayTextBorderColor:afc:aet', [Brush.$, null], 'OverlayTextBorderMatchLayer:acr:aeu', [0, false], 'OverlayTextBorderMode:ab5:aev', [AnnotationAppearanceMode_$type, enumGetBox(AnnotationAppearanceMode_$type, 0)], 'OverlayTextBorderRadius:ac5:aew', [1, NaN], 'OverlayTextBorderShift:ac6:aex', [1, NaN], 'OverlayTextBorderThickness:ac7:aey', [1, 1], 'OverlayTextColorMatchLayer:acs:aez', [0, true], 'OverlayTextColorMode:ab6:ae0', [AnnotationAppearanceMode_$type, enumGetBox(AnnotationAppearanceMode_$type, 0)], 'OverlayTextColor:afd:ae1', [Brush.$, null], 'OverlayTextColorShift:ac8:ae2', [1, NaN], 'OverlayTextHorizontalMargin:ac9:ae3', [1, NaN], 'OverlayTextHorizontalPadding:ada:ae4', [1, NaN], 'OverlayTextLocation:acd:ae5', [OverlayTextLocation_$type, enumGetBox(OverlayTextLocation_$type, 0)], 'OverlayTextMemberPath:ad5:ae6', [2, null], 'OverlayText:adl:ae7', [2, null], 'OverlayTextVerticalMargin:adb:ae8', [1, NaN], 'OverlayTextVerticalPadding:adc:ae9', [1, NaN], 'OverlayTextVisible:act:afa', [0, true]]);
+    return DataAnnotationShapeLayer;
+}(DataAnnotationAxisLayer));
+export { DataAnnotationShapeLayer };
+/**
+ * @hidden
+ */
+var DataAnnotationShapeLayerView = /** @class */ /*@__PURE__*/ (function (_super) {
+    __extends(DataAnnotationShapeLayerView, _super);
+    function DataAnnotationShapeLayerView(a) {
+        var _this = _super.call(this, a) || this;
+        _this.cn = null;
+        _this.co = null;
+        _this.ct = null;
+        _this.cs = null;
+        _this.cq = null;
+        _this.cr = null;
+        _this.cp = null;
+        _this.cn = a;
+        _this.ct = new List$1(Path.$, 0);
+        return _this;
+    }
+    DataAnnotationShapeLayerView.prototype.a4 = function () {
+        var _this = this;
+        _super.prototype.a4.call(this);
+        this.co = ((function () {
+            var $ret = new Pool$1(Path.$);
+            $ret.create = runOn(_this, _this.c6);
+            $ret.activate = runOn(_this, _this.cv);
+            $ret.disactivate = runOn(_this, _this.cx);
+            $ret.destroy = runOn(_this, _this.cw);
+            return $ret;
+        })());
+        this.cs = new List$1(TextBlock.$, 0);
+        this.cq = ((function () {
+            var $ret = new Pool$1(TextBlock.$);
+            $ret.create = runOn(_this, _this.c5);
+            $ret.activate = runOn(_this, _this.c1);
+            $ret.disactivate = runOn(_this, _this.c3);
+            $ret.destroy = runOn(_this, _this.c2);
+            return $ret;
+        })());
+        this.cr = new List$1(Rectangle.$, 0);
+        this.cp = ((function () {
+            var $ret = new Pool$1(Rectangle.$);
+            $ret.create = runOn(_this, _this.c7);
+            $ret.activate = runOn(_this, _this.cy);
+            $ret.disactivate = runOn(_this, _this.c0);
+            $ret.destroy = runOn(_this, _this.cz);
+            return $ret;
+        })());
+        this.cn.aeg();
+    };
+    DataAnnotationShapeLayerView.prototype.cu = function () {
+    };
+    DataAnnotationShapeLayerView.prototype.c5 = function () {
+        var a = new TextBlock();
+        this.cs.add(a);
+        return a;
+    };
+    DataAnnotationShapeLayerView.prototype.c2 = function (a) {
+        if (this.cs.contains(a)) {
+            this.cs.remove(a);
+        }
+    };
+    DataAnnotationShapeLayerView.prototype.c1 = function (a) {
+        a._visibility = 0;
+        a.s = 0;
+    };
+    DataAnnotationShapeLayerView.prototype.c3 = function (a) {
+        a._visibility = 1;
+    };
+    DataAnnotationShapeLayerView.prototype.c7 = function () {
+        var a = new Rectangle();
+        this.cr.add(a);
+        return a;
+    };
+    DataAnnotationShapeLayerView.prototype.cz = function (a) {
+        a.dataContext = null;
+        if (this.cr.contains(a)) {
+            this.cr.remove(a);
+        }
+    };
+    DataAnnotationShapeLayerView.prototype.cy = function (a) {
+        a._visibility = 0;
+    };
+    DataAnnotationShapeLayerView.prototype.c0 = function (a) {
+        a._visibility = 1;
+    };
+    DataAnnotationShapeLayerView.prototype.c6 = function () {
+        var a = new Path();
+        a.j = new TranslateTransform();
+        this.ct.add(a);
+        return a;
+    };
+    DataAnnotationShapeLayerView.prototype.cv = function (a) {
+        a._visibility = 0;
+    };
+    DataAnnotationShapeLayerView.prototype.cx = function (a) {
+        a._visibility = 1;
+    };
+    DataAnnotationShapeLayerView.prototype.cw = function (a) {
+        this.ct.remove(a);
+    };
+    DataAnnotationShapeLayerView.prototype.c4 = function (a, b, c, d) {
+        if (a.an == null || a.an.c.x != d || a.an.d.x != c) {
+            var e = ((function () {
+                var $ret = new LineGeometry();
+                $ret.d = { $type: Point_$type, x: c, y: b };
+                $ret.c = { $type: Point_$type, x: d, y: b };
+                return $ret;
+            })());
+            a.an = e;
+        }
+    };
+    DataAnnotationShapeLayerView.prototype.bj = function (a, b) {
+        _super.prototype.bj.call(this, a, b);
+        if (a.d && !b) {
+            for (var c = 0; c < this.ct.count; c++) {
+                var d = this.ct._inner[c];
+                if (d._visibility == 0) {
+                    a.t(d);
+                }
+            }
+            for (var e = 0; e < this.cr.count; e++) {
+                var f = this.cr._inner[e];
+                if (f._visibility == 0) {
+                    a.w(f);
+                }
+            }
+            for (var g = 0; g < this.cs.count; g++) {
+                var h = this.cs._inner[g];
+                a.ad(h.dataContext);
+                a.x(h);
+            }
+        }
+    };
+    DataAnnotationShapeLayerView.prototype.ax = function (a) {
+        _super.prototype.ax.call(this, a);
+        for (var b = 0; b < this.ct.count; b++) {
+            this.f.bc.exportPathData(a, this.ct._inner[b], "DataAnnotationPath", ["Main", "DataAnnotation"]);
+        }
+    };
+    DataAnnotationShapeLayerView.$t = markType(DataAnnotationShapeLayerView, 'DataAnnotationShapeLayerView', AnnotationLayerView.$);
+    return DataAnnotationShapeLayerView;
+}(AnnotationLayerView));
+export { DataAnnotationShapeLayerView };