igniteui-angular-inputs 16.1.0-beta.1

package/esm5/lib/IconView_combined.js

@@ -0,0 +1,1012 @@
+/*
+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 { Base, String_$type, Delegate_$type, fromEnum, runOn, markType, INotifyPropertyChanged_$type, PropertyChangedEventArgs, enumGetBox } from "igniteui-angular-core";
+import { List$1 } from "igniteui-angular-core";
+import { Tuple$2 } from "igniteui-angular-core";
+import { SVGNode } from "igniteui-angular-core";
+import { FastIterationDictionary$2 } from "igniteui-angular-core";
+import { isNaN_ } from "igniteui-angular-core";
+import { IIcon_$type } from "igniteui-angular-core";
+import { BaseControlTheme_$type } from "igniteui-angular-core";
+import { NativeUI } from "igniteui-angular-core";
+import { IconClickedEventArgs } from "./IconClickedEventArgs";
+import { IconVisualModelExport } from "./IconVisualModelExport";
+import { AppearanceHelper } from "igniteui-angular-core";
+import { FontUtil } from "igniteui-angular-core";
+import { stringStartsWith } from "igniteui-angular-core";
+import { trimStart } from "igniteui-angular-core";
+/**
+ * @hidden
+ */
+var IconView = /** @class */ /*@__PURE__*/ (function (_super) {
+    __extends(IconView, _super);
+    function IconView() {
+        var _this = _super.call(this) || this;
+        _this.b = null;
+        _this.o = null;
+        _this.e = null;
+        _this.i = new List$1(Delegate_$type, 0);
+        _this.j = null;
+        _this.k = null;
+        _this.l = null;
+        _this.m = null;
+        _this.n = null;
+        _this.c = null;
+        _this.d = null;
+        _this.u = null;
+        _this.t = null;
+        _this.f = true;
+        _this.p = null;
+        _this.q = null;
+        _this.j = new List$1(Tuple$2.$.specialize(SVGNode.$, Base.$), 0);
+        _this.k = new List$1(Tuple$2.$.specialize(SVGNode.$, Base.$), 0);
+        _this.l = new List$1(Tuple$2.$.specialize(SVGNode.$, Base.$), 0);
+        _this.m = new List$1(Tuple$2.$.specialize(SVGNode.$, Base.$), 0);
+        _this.n = new List$1(Tuple$2.$.specialize(SVGNode.$, Base.$), 0);
+        _this.c = new FastIterationDictionary$2(String_$type, List$1.$.specialize(Tuple$2.$.specialize(SVGNode.$, Base.$)), 0);
+        _this.d = new FastIterationDictionary$2(String_$type, List$1.$.specialize(Tuple$2.$.specialize(SVGNode.$, Base.$)), 0);
+        return _this;
+    }
+    IconView.prototype.ac = function () {
+    };
+    IconView.prototype.g = function () {
+        return true;
+    };
+    Object.defineProperty(IconView.prototype, "r", {
+        get: function () {
+            return this.p;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(IconView.prototype, "s", {
+        get: function () {
+            return null;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(IconView.prototype, "h", {
+        get: function () {
+            return true;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    IconView.prototype.aa = function (a) {
+        var e_1, _a;
+        if (a == null) {
+            try {
+                for (var _b = __values(fromEnum(this.i)), _c = _b.next(); !_c.done; _c = _b.next()) {
+                    var b = _c.value;
+                    b();
+                }
+            }
+            catch (e_1_1) {
+                e_1 = { error: e_1_1 };
+            }
+            finally {
+                try {
+                    if (_c && !_c.done && (_a = _b.return))
+                        _a.call(_b);
+                }
+                finally {
+                    if (e_1)
+                        throw e_1.error;
+                }
+            }
+            this.i.clear();
+            if (this.p != null) {
+                this.p.unlistenAll();
+            }
+        }
+        this.o = a;
+        a.rootWrapper.setStyleProperty("position", "relative");
+        this.o.rootWrapper.setStyleProperty("display", "flex");
+        this.o.rootWrapper.setStyleProperty("flex-direction", "row");
+        this.o.rootWrapper.setStyleProperty("flex-wrap", "no-wrap");
+        this.o.rootWrapper.setStyleProperty("align-items", "center");
+        this.ae();
+        var c = this.o.createElementNS("svg", "http://www.w3.org/2000/svg");
+        c.setStyleProperty("position", "absolute");
+        c.setStyleProperty("top", "0");
+        c.setStyleProperty("left", "0");
+        c.setStyleProperty("right", "0");
+        c.setStyleProperty("bottom", "0");
+        this.p = c;
+        this.ai();
+        var d = this.o.createElementNS("path", "http://www.w3.org/2000/svg");
+        d.setAttribute("d", "");
+        this.p.append(d);
+        if (this.u != null) {
+            d.setAttribute("d", this.u);
+        }
+        this.q = d;
+        this.o.append(this.p);
+        this.i.add(c.listen("click", runOn(this, this.z)));
+        this.b.b6();
+    };
+    IconView.prototype.ag = function (a) {
+        if (this.u != a) {
+            this.u = a;
+            this.o.rootWrapper.removeChildren();
+            this.o.rootWrapper.append(this.p);
+            if (this.q != null) {
+                this.q.setAttribute("d", this.u);
+            }
+        }
+    };
+    IconView.prototype.af = function (a) {
+        if (this.t != a) {
+            this.t = a;
+            this.o.rootWrapper.removeChildren();
+            var b = this.o.rootWrapper.getNativeElement();
+            b.innerHTML = this.t;
+        }
+    };
+    IconView.prototype.ae = function () {
+        this.o.rootWrapper.setStyleProperty("width", isNaN_(this.b.ao) ? "1.5rem" : this.b.ao + "px");
+        this.o.rootWrapper.setStyleProperty("height", isNaN_(this.b.ag) ? "1.5rem" : this.b.ag + "px");
+    };
+    IconView.prototype.ai = function () {
+        this.p.setAttribute("viewBox", (isNaN_(this.b.al) ? 0 : this.b.al) + " " + (isNaN_(this.b.am) ? 0 : this.b.am) + " " + (isNaN_(this.b.an) ? 24 : this.b.an) + " " + (isNaN_(this.b.ak) ? 24 : this.b.ak));
+    };
+    IconView.prototype.v = function (a) {
+    };
+    IconView.prototype.ad = function () {
+        if (this.g()) {
+        }
+    };
+    IconView.prototype.w = function (a) {
+        this.b.b3();
+    };
+    IconView.prototype.x = function (a) {
+        this.b.b4();
+    };
+    IconView.prototype.y = function () {
+        this.f = true;
+        this.i.add(this.o.rootWrapper.listen("mouseenter", runOn(this, this.w)));
+        this.i.add(this.o.rootWrapper.listen("mouseleave", runOn(this, this.x)));
+    };
+    IconView.prototype.ab = function () {
+        var e_2, _a;
+        this.f = false;
+        try {
+            for (var _b = __values(fromEnum(this.i)), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var a = _c.value;
+                a();
+            }
+        }
+        catch (e_2_1) {
+            e_2 = { error: e_2_1 };
+        }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return))
+                    _a.call(_b);
+            }
+            finally {
+                if (e_2)
+                    throw e_2.error;
+            }
+        }
+        this.i.clear();
+    };
+    IconView.prototype.ah = function (a) {
+        if (a != null) {
+            this.o.rootWrapper.setStyleProperty("font", a.fontString);
+        }
+    };
+    IconView.prototype.a = function () {
+        var rect_ = this.o.rootWrapper.getNativeElement().getBoundingClientRect();
+        var a = (rect_.top);
+        var b = (rect_.left);
+        var c = new Array(2);
+        c[0] = a;
+        c[1] = b;
+        return c;
+    };
+    IconView.prototype.z = function (a) {
+        this.b.b1();
+    };
+    IconView.$t = markType(IconView, 'IconView');
+    return IconView;
+}(Base));
+export { IconView };
+/**
+ * @hidden
+ */
+var XIcon = /** @class */ /*@__PURE__*/ (function (_super) {
+    __extends(XIcon, _super);
+    function XIcon() {
+        var _this = _super.call(this) || this;
+        _this._view = null;
+        _this.h = 0;
+        _this.cc = XIcon.cs;
+        _this.cd = XIcon.cw;
+        _this.ce = XIcon.cx;
+        _this.t = XIcon.af;
+        _this.cf = XIcon.cs;
+        _this.cn = XIcon.cw;
+        _this.x = XIcon.af;
+        _this.co = XIcon.cx;
+        _this.cg = XIcon.ct;
+        _this.ch = XIcon.cu;
+        _this.v = XIcon.ae;
+        _this.ci = null;
+        _this.a = null;
+        _this.b = null;
+        _this.cj = null;
+        _this.ck = null;
+        _this.cl = null;
+        _this.cm = null;
+        _this.aw = null;
+        _this.av = null;
+        _this.j = null;
+        _this.au = "ig-icon-" + XIcon.ar++;
+        _this.ap = 0;
+        _this.l = false;
+        _this.at = null;
+        _this.n = false;
+        _this.m = false;
+        _this.w = 1;
+        _this.z = NaN;
+        _this.aa = NaN;
+        _this.ab = NaN;
+        _this.y = NaN;
+        _this.ac = NaN;
+        _this.u = NaN;
+        _this.clicked = null;
+        _this.propertyChanged = null;
+        var a = new IconView();
+        a.b = _this;
+        _this.view = a;
+        _this.view.ac();
+        return _this;
+    }
+    Object.defineProperty(XIcon.prototype, "view", {
+        get: function () {
+            return this._view;
+        },
+        set: function (a) {
+            this._view = a;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    XIcon.prototype.destroy = function () {
+        this.provideContainer(null);
+    };
+    XIcon.prototype.b5 = function (a, b, c) {
+        if (this.propertyChanged != null) {
+            this.propertyChanged(this, new PropertyChangedEventArgs(a));
+        }
+        this.b7(a, b, c);
+    };
+    XIcon.prototype.b7 = function (a, b, c) {
+        switch (a) {
+            case "Fill":
+            case "Stroke":
+            case "StrokeWidth":
+            case "HoverFill":
+            case "HoverStroke":
+            case "HoverStrokeThickness":
+            case "IsHover":
+                this.cb();
+                break;
+            case "ActualFill":
+            case "ActualStroke":
+            case "ActualStrokeWidth":
+            case "SVGPath":
+            case "SVG":
+                this.b9();
+                break;
+            case "Opacity":
+                this.ca();
+                break;
+            case "ViewBoxLeft":
+            case "ViewBoxTop":
+            case "ViewBoxWidth":
+            case "ViewBoxHeight":
+                this.view.ai();
+                break;
+            case "Width":
+            case "Height":
+                this.view.ae();
+                break;
+        }
+    };
+    XIcon.prototype.cb = function () {
+        var a = this.fill != null ? this.fill : XIcon.cs;
+        var b = this.c5 != null ? this.c5 : XIcon.cw;
+        var c = !isNaN_(this.aj) ? this.aj : XIcon.af;
+        var d = this.c6 != null ? this.c6 : XIcon.cx;
+        if (this.r) {
+            this.cp = this.cy != null ? this.cy : a;
+            this.cq = this.cz != null ? this.cz : b;
+            this.ad = !isNaN_(this.ah) ? this.ah : c;
+            this.cr = this.c0 != null ? this.c0 : d;
+        }
+        else {
+            this.cp = a;
+            this.cq = b;
+            this.ad = c;
+            this.cr = d;
+        }
+    };
+    Object.defineProperty(XIcon.prototype, "p", {
+        get: function () {
+            return this.svgPath != null && !this.view.h;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    XIcon.prototype.ca = function () {
+        NativeUI.w(this.view.r, this.ai);
+    };
+    XIcon.prototype.b9 = function () {
+        var a = this.view.r;
+        if (this.p) {
+            var b = this.view.s;
+            NativeUI.q(b, this.cp);
+            NativeUI.y(b, this.cq);
+            NativeUI.ab(b, this.ad);
+        }
+        else {
+            var c = false;
+            if (this.svgPath != null) {
+                if (stringStartsWith(trimStart(this.svgPath, ' ', '\n', '\r', '\t'), "<svg")) {
+                    this.view.af(this.svgPath);
+                    c = true;
+                }
+                else {
+                    this.view.ag(this.svgPath);
+                }
+            }
+            else if (this.svg != null) {
+                this.view.af(this.svg);
+                c = true;
+            }
+            if (c) {
+                for (var d = 0; d < this.view.k.count; d++) {
+                    var e = this.view.k._inner[d].c;
+                    NativeUI.q(this.view.k._inner[d].d, e.l.f(this.c1));
+                }
+                for (var f = 0; f < this.view.l.count; f++) {
+                    var g = this.view.l._inner[f].c;
+                    NativeUI.y(this.view.l._inner[f].d, g.m.f(this.c2));
+                }
+                for (var h = 0; h < this.view.m.count; h++) {
+                    var i = this.view.m._inner[h].c;
+                    NativeUI.q(this.view.m._inner[h].d, i.l.f(this.c3));
+                }
+                for (var j = 0; j < this.view.n.count; j++) {
+                    var k = this.view.n._inner[j].c;
+                    NativeUI.y(this.view.n._inner[j].d, k.m.f(this.c4));
+                }
+                for (var l = 0; l < this.view.c.o.count; l++) {
+                    var m = this.view.c.o._inner[l];
+                    var n = m.split('-');
+                    var o = parseInt(n[n.length - 1]);
+                    if (o < this.c.count) {
+                        for (var p = 0; p < this.view.c.q._inner[l].count; p++) {
+                            var q = this.view.c.q._inner[l]._inner[p].c;
+                            NativeUI.q(this.view.c.q._inner[l]._inner[p].d, q.l.f(this.c.item(o)));
+                        }
+                    }
+                }
+                for (var r = 0; r < this.view.d.o.count; r++) {
+                    var s = this.view.d.o._inner[r];
+                    var t = s.split('-');
+                    var u = parseInt(t[t.length - 1]);
+                    if (u < this.d.count) {
+                        for (var v = 0; v < this.view.d.q._inner[r].count; v++) {
+                            var w = this.view.d.q._inner[r]._inner[v].c;
+                            NativeUI.y(this.view.d.q._inner[r]._inner[v].d, w.m.f(this.d.item(u)));
+                        }
+                    }
+                }
+                for (var x = 0; x < this.view.j.count; x++) {
+                    var y = this.view.j._inner[x].c;
+                    NativeUI.q(this.view.j._inner[x].d, y.l.f(this.cp));
+                    NativeUI.y(this.view.j._inner[x].d, y.m.f(this.cq));
+                }
+            }
+            var z = this.view.r;
+            if (this.cp != null) {
+                NativeUI.q(z, this.cp);
+            }
+            if (this.cq != null) {
+                NativeUI.y(z, this.cq);
+            }
+            if (!isNaN_(this.ad)) {
+                NativeUI.ab(z, this.ad);
+            }
+        }
+        if (this.k != null) {
+            this.view.ah(this.k);
+        }
+        if (this.cr != null) {
+            NativeUI.p(this.view.r, this.cr);
+        }
+    };
+    Object.defineProperty(XIcon.prototype, "i", {
+        get: function () {
+            return this.h;
+        },
+        set: function (a) {
+            var b = this.h;
+            this.h = a;
+            if (b != this.h) {
+                this.b5("BaseTheme", enumGetBox(BaseControlTheme_$type, b), enumGetBox(BaseControlTheme_$type, a));
+            }
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(XIcon.prototype, "cp", {
+        get: function () {
+            return this.cc;
+        },
+        set: function (a) {
+            var b = this.cc;
+            this.cc = a;
+            if (b != this.cc) {
+                this.b5("ActualFill", b, a);
+            }
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(XIcon.prototype, "cq", {
+        get: function () {
+            return this.cd;
+        },
+        set: function (a) {
+            var b = this.cd;
+            this.cd = a;
+            if (b != this.cd) {
+                this.b5("ActualStroke", b, a);
+            }
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(XIcon.prototype, "cr", {
+        get: function () {
+            return this.ce;
+        },
+        set: function (a) {
+            var b = this.ce;
+            this.ce = a;
+            if (b != this.ce) {
+                this.b5("ActualTextColor", b, a);
+            }
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(XIcon.prototype, "ad", {
+        get: function () {
+            return this.t;
+        },
+        set: function (a) {
+            var b = this.t;
+            this.t = a;
+            if (b != this.t) {
+                this.b5("ActualStrokeWidth", b, a);
+            }
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(XIcon.prototype, "fill", {
+        get: function () {
+            return this.cf;
+        },
+        set: function (a) {
+            var b = this.cf;
+            this.cf = a;
+            if (b != this.cf) {
+                this.b5("Fill", b, a);
+            }
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(XIcon.prototype, "c5", {
+        get: function () {
+            return this.cn;
+        },
+        set: function (a) {
+            var b = this.cn;
+            this.cn = a;
+            if (b != this.cn) {
+                this.b5("Stroke", b, a);
+            }
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(XIcon.prototype, "aj", {
+        get: function () {
+            return this.x;
+        },
+        set: function (a) {
+            var b = this.x;
+            this.x = a;
+            if (b != this.x) {
+                this.b5("StrokeWidth", b, a);
+            }
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(XIcon.prototype, "c6", {
+        get: function () {
+            return this.co;
+        },
+        set: function (a) {
+            var b = this.co;
+            this.co = a;
+            if (b != this.co) {
+                this.b5("TextColor", b, a);
+            }
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(XIcon.prototype, "cy", {
+        get: function () {
+            return this.cg;
+        },
+        set: function (a) {
+            var b = this.cg;
+            this.cg = a;
+            if (b != this.cg) {
+                this.b5("HoverFill", b, a);
+            }
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(XIcon.prototype, "cz", {
+        get: function () {
+            return this.ch;
+        },
+        set: function (a) {
+            var b = this.ch;
+            this.ch = a;
+            if (b != this.ch) {
+                this.b5("HoverStroke", b, a);
+            }
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(XIcon.prototype, "ah", {
+        get: function () {
+            return this.v;
+        },
+        set: function (a) {
+            var b = this.v;
+            this.v = a;
+            if (b != this.v) {
+                this.b5("HoverStrokeThickness", b, a);
+            }
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(XIcon.prototype, "c0", {
+        get: function () {
+            return this.ci;
+        },
+        set: function (a) {
+            var b = this.ci;
+            this.ci = a;
+            if (b != this.ci) {
+                this.b5("HoverTextColor", b, a);
+            }
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(XIcon.prototype, "c", {
+        get: function () {
+            return this.a;
+        },
+        set: function (a) {
+            var b = this.a;
+            this.a = a;
+            if (b != this.a) {
+                this.b5("FillColors", b, this.a);
+            }
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(XIcon.prototype, "d", {
+        get: function () {
+            return this.b;
+        },
+        set: function (a) {
+            var b = this.b;
+            this.b = a;
+            if (b != this.b) {
+                this.b5("StrokeColors", b, this.b);
+            }
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(XIcon.prototype, "c1", {
+        get: function () {
+            return this.cj;
+        },
+        set: function (a) {
+            var b = this.cj;
+            this.cj = a;
+            if (b != this.cj) {
+                this.b5("PrimaryFillColor", b, this.cj);
+            }
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(XIcon.prototype, "c2", {
+        get: function () {
+            return this.ck;
+        },
+        set: function (a) {
+            var b = this.ck;
+            this.ck = a;
+            if (b != this.ck) {
+                this.b5("PrimaryStrokeColor", b, this.ck);
+            }
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(XIcon.prototype, "c3", {
+        get: function () {
+            return this.cl;
+        },
+        set: function (a) {
+            var b = this.cl;
+            this.cl = a;
+            if (b != this.cl) {
+                this.b5("SecondaryFillColor", b, this.cl);
+            }
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(XIcon.prototype, "c4", {
+        get: function () {
+            return this.cm;
+        },
+        set: function (a) {
+            var b = this.cm;
+            this.cm = a;
+            if (b != this.cm) {
+                this.b5("SecondaryStrokeColor", b, this.cm);
+            }
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(XIcon.prototype, "svgPath", {
+        get: function () {
+            return this.aw;
+        },
+        set: function (a) {
+            var b = this.aw;
+            this.aw = a;
+            if (b != this.aw) {
+                this.b5("SVGPath", b, a);
+            }
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(XIcon.prototype, "svg", {
+        get: function () {
+            return this.av;
+        },
+        set: function (a) {
+            var b = this.av;
+            this.av = a;
+            if (b != this.av) {
+                this.b5("SVG", b, this.av);
+            }
+        },
+        enumerable: false,
+        configurable: true
+    });
+    XIcon.prototype.b3 = function () {
+        this.r = true;
+    };
+    XIcon.prototype.b4 = function () {
+        this.r = false;
+    };
+    Object.defineProperty(XIcon.prototype, "k", {
+        get: function () {
+            return this.j;
+        },
+        set: function (a) {
+            var b = this.j;
+            this.j = a;
+            if (b != this.j) {
+                this.b5("TextStyle", b, a);
+            }
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(XIcon.prototype, "bc", {
+        get: function () {
+            return this.au;
+        },
+        set: function (a) {
+            var b = this.au;
+            this.au = a;
+            if (b != this.au) {
+                this.b5("Id", b, a);
+            }
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(XIcon.prototype, "o", {
+        get: function () {
+            return this.l;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(XIcon.prototype, "aq", {
+        get: function () {
+            return this.ap;
+        },
+        set: function (a) {
+            var b = this.ap;
+            this.ap = a;
+            this.l = true;
+            if (b != this.ap) {
+                this.b5("TabIndex", b, a);
+            }
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(XIcon.prototype, "a1", {
+        get: function () {
+            return this.at;
+        },
+        set: function (a) {
+            var b = this.at;
+            this.at = a;
+            if (b != this.at) {
+                this.b5("AriaLabel", b, a);
+            }
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(XIcon.prototype, "r", {
+        get: function () {
+            return this.n;
+        },
+        set: function (a) {
+            var b = this.n;
+            this.n = a;
+            if (b != this.n) {
+                this.b5("IsHover", b, a);
+            }
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(XIcon.prototype, "disabled", {
+        get: function () {
+            return this.m;
+        },
+        set: function (a) {
+            var b = this.m;
+            this.m = a;
+            if (b != this.m) {
+                this.b5("IsDisabled", b, a);
+            }
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(XIcon.prototype, "ai", {
+        get: function () {
+            return this.w;
+        },
+        set: function (a) {
+            var b = this.w;
+            this.w = a;
+            if (b != this.w) {
+                this.b5("Opacity", b, this.w);
+            }
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(XIcon.prototype, "al", {
+        get: function () {
+            return this.z;
+        },
+        set: function (a) {
+            var b = this.z;
+            this.z = a;
+            if (b != this.z) {
+                this.b5("ViewBoxLeft", b, this.z);
+            }
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(XIcon.prototype, "am", {
+        get: function () {
+            return this.aa;
+        },
+        set: function (a) {
+            var b = this.aa;
+            this.aa = a;
+            if (b != this.aa) {
+                this.b5("ViewBoxTop", b, this.aa);
+            }
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(XIcon.prototype, "an", {
+        get: function () {
+            return this.ab;
+        },
+        set: function (a) {
+            var b = this.ab;
+            this.ab = a;
+            if (b != this.ab) {
+                this.b5("ViewBoxWidth", b, this.ab);
+            }
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(XIcon.prototype, "ak", {
+        get: function () {
+            return this.y;
+        },
+        set: function (a) {
+            var b = this.y;
+            this.y = a;
+            if (b != this.y) {
+                this.b5("ViewBoxHeight", b, this.y);
+            }
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(XIcon.prototype, "ao", {
+        get: function () {
+            return this.ac;
+        },
+        set: function (a) {
+            var b = this.ac;
+            this.ac = a;
+            if (b != this.ac) {
+                this.b5("Width", b, this.ac);
+            }
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(XIcon.prototype, "ag", {
+        get: function () {
+            return this.u;
+        },
+        set: function (a) {
+            var b = this.u;
+            this.u = a;
+            if (b != this.u) {
+                this.b5("Height", b, this.u);
+            }
+        },
+        enumerable: false,
+        configurable: true
+    });
+    XIcon.prototype.b6 = function () {
+    };
+    XIcon.prototype.onDetachedFromUI = function () {
+        this.view.ab();
+    };
+    XIcon.prototype.onAttachedToUI = function () {
+        this.view.y();
+    };
+    XIcon.prototype.b1 = function () {
+        if (this.disabled) {
+            return;
+        }
+        if (this.clicked != null) {
+            this.clicked(this, new IconClickedEventArgs());
+        }
+    };
+    XIcon.prototype.s = function () {
+        return this.view.g();
+    };
+    XIcon.prototype.as = function () {
+        return this.e();
+    };
+    XIcon.prototype.a4 = function () {
+        var a = this.e();
+        return a.j();
+    };
+    XIcon.prototype.e = function () {
+        var a = new IconVisualModelExport();
+        var b = this.view.r;
+        a.a = AppearanceHelper.a(NativeUI.aj(b));
+        a.c = AppearanceHelper.a(NativeUI.aj(b));
+        a.b = AppearanceHelper.a(NativeUI.ak(b));
+        a.d = this.ad;
+        var c = this.view.a();
+        a.h = c[0];
+        a.f = c[1];
+        a.e = NativeUI.d(b);
+        a.i = NativeUI.j(b);
+        a.svgPath = this.svgPath;
+        if (this.k != null) {
+            var d = this.k;
+            if (this.view != null && d.n == null) {
+                var e = this.view.o;
+                var f = FontUtil.getFontInfoFromString(e, d.fontString);
+                d.n = f.n;
+                d.d = f.d;
+                d.o = f.o;
+                d.q = f.q;
+                d.r = f.r;
+                d.s = f.s;
+            }
+            if (d.n != null) {
+                a.l = d.n;
+            }
+            if (!isNaN_(d.d)) {
+                a.g = d.d;
+            }
+            if (d.s != null) {
+                a.p = d.s;
+            }
+            if (d.q != null) {
+                a.n = d.q;
+            }
+            if (d.o != null) {
+                a.m = d.q;
+            }
+        }
+        return a;
+    };
+    XIcon.prototype.provideContainer = function (a) {
+        this.view.aa(a);
+    };
+    XIcon.$t = markType(XIcon, 'XIcon', Base.$, [INotifyPropertyChanged_$type, IIcon_$type]);
+    XIcon.cs = null;
+    XIcon.cx = null;
+    XIcon.cw = null;
+    XIcon.ct = null;
+    XIcon.cu = null;
+    XIcon.cv = null;
+    XIcon.af = NaN;
+    XIcon.ae = NaN;
+    XIcon.ar = 0;
+    return XIcon;
+}(Base));
+export { XIcon };