igniteui-webcomponents-inputs 1.3.3

package/esm5/lib/CheckboxView_combined.js

@@ -0,0 +1,1220 @@
+/*
+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 * as tslib_1 from "tslib";
+import { Base, Delegate_$type, fromEnum, runOn, markType, INotifyPropertyChanged_$type, PropertyChangedEventArgs, enumGetBox } from "igniteui-webcomponents-core";
+import { Ripple } from "./Ripple";
+import { List$1 } from "igniteui-webcomponents-core";
+import { KeyFrameAnimationFactory } from "igniteui-webcomponents-core";
+import { AnimationKeyFrameEffect } from "igniteui-webcomponents-core";
+import { AnimationKeyFrameEffectTiming } from "igniteui-webcomponents-core";
+import { stringReplace } from "igniteui-webcomponents-core";
+import { BaseControlTheme_$type } from "igniteui-webcomponents-core";
+import { CheckboxLabelPosition_$type } from "./CheckboxLabelPosition";
+import { ThemeResolver } from "./ThemeResolver";
+import { CornerRadius } from "igniteui-webcomponents-core";
+import { NativeUI } from "igniteui-webcomponents-core";
+import { Thickness } from "igniteui-webcomponents-core";
+import { CheckboxChangeEventArgs } from "./CheckboxChangeEventArgs";
+import { BrushUtil } from "igniteui-webcomponents-core";
+import { AnimationKeyFrameProperty } from "igniteui-webcomponents-core";
+import { TransformGroup } from "igniteui-webcomponents-core";
+import { RotateTransform } from "igniteui-webcomponents-core";
+import { TranslateTransform } from "igniteui-webcomponents-core";
+import { CheckboxVisualModelExport } from "./CheckboxVisualModelExport";
+import { AppearanceHelper } from "igniteui-webcomponents-core";
+import { isNaN_ } from "igniteui-webcomponents-core";
+/**
+ * @hidden
+ */
+var CheckboxView = /** @class */ /*@__PURE__*/ (function (_super) {
+    tslib_1.__extends(CheckboxView, _super);
+    function CheckboxView() {
+        var _this = _super.call(this) || this;
+        _this.c = null;
+        _this.l = null;
+        _this.f = null;
+        _this.j = new List$1(Delegate_$type, 0);
+        _this.g = true;
+        _this.q = null;
+        _this.m = null;
+        _this.p = null;
+        _this.n = null;
+        _this.d = null;
+        _this.o = null;
+        return _this;
+    }
+    CheckboxView.prototype.ad = function () {
+    };
+    CheckboxView.prototype.i = function () {
+        return true;
+    };
+    CheckboxView.prototype.ab = function (a) {
+        var e_1, _a;
+        if (a == null) {
+            try {
+                for (var _b = tslib_1.__values(fromEnum(this.j)), _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.j.clear();
+            return;
+        }
+        this.l = a;
+        this.l.rootWrapper.setStyleProperty("display", "flex");
+        this.l.rootWrapper.setStyleProperty("flex-direction", "row");
+        this.l.rootWrapper.setStyleProperty("flex-wrap", "no-wrap");
+        this.l.rootWrapper.setStyleProperty("align-items", "center");
+        var c = this.l.createElement("input");
+        this.q = c;
+        this.q.addClass("ig-native-checkbox");
+        this.q.setStyleProperty("position", "absolute");
+        this.q.setStyleProperty("width", "1px");
+        this.q.setStyleProperty("height", "1px");
+        this.q.setStyleProperty("margin", "-1px");
+        this.q.setStyleProperty("border", "none");
+        this.q.setStyleProperty("clip", "rect(0, 0, 0, 0)");
+        this.q.setStyleProperty("outline", "0");
+        this.q.setStyleProperty("pointer-events", "none");
+        this.q.setStyleProperty("overflow", "hidden");
+        this.q.setStyleProperty("-webkit-appearance", "none");
+        this.q.setStyleProperty("-moz-appearance", "none");
+        this.q.setStyleProperty("appearance", "none");
+        this.q.setAttribute("type", "checkbox");
+        this.q.setAttribute("id", this.c.by);
+        this.ag();
+        this.j.add(c.listen("change", runOn(this, this.v)));
+        this.j.add(c.listen("click", runOn(this, this.w)));
+        this.j.add(c.listen("focus", runOn(this, this.x)));
+        this.j.add(c.listen("blur", runOn(this, this.u)));
+        this.l.append(c);
+        var d = this.l.createElement("div");
+        d.addClass("ig-checkbox-box");
+        d.setStyleProperty("width", "1.25em");
+        d.setStyleProperty("height", "1.25em");
+        d.setStyleProperty("position", "relative");
+        this.m = d;
+        this.l.append(d);
+        var e = this.l.createElement("label");
+        e.setAttribute("for", this.c.by);
+        e.addClass("ig-checkbox-composite");
+        e.setStyleProperty("box-sizing", "border-box");
+        e.setStyleProperty("position", "relative");
+        e.setStyleProperty("display", "inline-block");
+        e.setStyleProperty("cursor", "pointer");
+        e.setStyleProperty("width", "1.25em");
+        e.setStyleProperty("height", "1.25em");
+        e.setStyleProperty("min-width", "1.25em");
+        e.setStyleProperty("border-width", "0.125rem");
+        e.setStyleProperty("border-style", "solid");
+        e.setStyleProperty("border-color", "rgba(0,0,0,0.54)");
+        e.setStyleProperty("border-top-color", "rgba(0, 0, 0, 0.54)");
+        e.setStyleProperty("border-right-color", "rgba(0, 0, 0, 0.54)");
+        e.setStyleProperty("border-bottom-color", "rgba(0, 0, 0, 0.54)");
+        e.setStyleProperty("border-left-color", "rgba(0, 0, 0, 0.54)");
+        e.setStyleProperty("border-radius", "2px");
+        e.setStyleProperty("-webkit-tap-highlight-color", "transparent");
+        e.setStyleProperty("overflow", "hidden");
+        this.p = e;
+        this.m.append(e);
+        var f = this.l.createElementNS("svg", "http://www.w3.org/2000/svg");
+        f.setAttribute("viewBox", "0 0 24 24");
+        f.addClass("ig-checkbox-mark");
+        f.setStyleProperty("position", "absolute");
+        f.setStyleProperty("top", "0");
+        f.setStyleProperty("left", "0");
+        f.setStyleProperty("right", "0");
+        f.setStyleProperty("bottom", "0");
+        f.setStyleProperty("stroke", "#fff");
+        f.setStyleProperty("stroke-linecap", "square");
+        f.setStyleProperty("stroke-width", "3");
+        f.setStyleProperty("stroke-dasharray", "24");
+        f.setStyleProperty("stroke-dashoffset", "24");
+        f.setStyleProperty("fill", "none");
+        f.setStyleProperty("opacity", "0");
+        f.setStyleProperty("z-index", "1");
+        this.n = f;
+        e.append(f);
+        var g = this.l.createElementNS("path", "http://www.w3.org/2000/svg");
+        g.setAttribute("d", "M4.1,12.7 9,17.6 20.3,6.3");
+        f.append(g);
+        var h = this.l.createElement("div");
+        var i = this.l.getSubRenderer(h);
+        h.setStyleProperty("position", "absolute");
+        h.setStyleProperty("width", "3em");
+        h.setStyleProperty("height", "3em");
+        h.setStyleProperty("right", "calc(50% - 1.5em)");
+        h.setStyleProperty("top", "calc(50% - 1.5em)");
+        h.setStyleProperty("border-radius", "24px");
+        h.setStyleProperty("overflow", "hidden");
+        var j = new Ripple();
+        j.provideContainer(i);
+        j.q = d;
+        var k = this.l.getExternal(j, this.l.rootWrapper, this.l.getExternal(this.c, null, null));
+        j.h = true;
+        j.k = true;
+        this.d = j;
+        d.append(h);
+        var l = this.l.createElement("span");
+        l.addClass("ig-checkbox-label");
+        l.setStyleProperty("font-family", "'Segoe UI', Verdana");
+        l.setStyleProperty("font-weight", "400");
+        l.setStyleProperty("font-size", "1rem");
+        l.setStyleProperty("letter-spacing", ".00937rem");
+        l.setStyleProperty("text-transform", "none");
+        l.setStyleProperty("line-height", "1.5rem");
+        l.setStyleProperty("margin-left", "8px");
+        l.setStyleProperty("margin-top", "0");
+        l.setStyleProperty("margin-bottom", "0");
+        l.setStyleProperty("cursor", "pointer");
+        l.setStyleProperty("role", "label");
+        this.o = l;
+        this.j.add(l.listen("click", runOn(this, this.t)));
+        this.l.append(l);
+        this.l.getPortal(l, "ChildContent", function (m) {
+        }, true);
+        this.c.cm();
+    };
+    CheckboxView.prototype.t = function (a) {
+        this.c.toggle();
+    };
+    CheckboxView.prototype.ag = function () {
+        if (this.i()) {
+            var a = this.c.by;
+            this.q.setAttribute("name", this.c.b7);
+            this.q.setProperty("value", this.c.a5);
+            if (this.c.v) {
+                this.q.setAttribute("tabindex", this.c.a0.toString());
+            }
+            this.q.setProperty("disabled", this.c.disabled);
+            this.q.setProperty("indeterminate", this.c.indeterminate);
+            this.q.setProperty("checked", this.c.checked);
+            this.q.setProperty("required", this.c.az);
+            if (this.c.indeterminate) {
+                this.q.setAttribute("aria-checked", "mixed");
+            }
+            else {
+                this.q.setAttribute("aria-checked", this.c.checked ? "true" : "false");
+            }
+            this.q.setAttribute("aria-labelledby", this.c.bl);
+            this.q.setAttribute("aria-label", this.c.bk);
+        }
+    };
+    CheckboxView.prototype.ae = function () {
+        if (this.i()) {
+            var a = this.c.by;
+            this.q.setAttribute("id", a);
+            this.p.setAttribute("for", a);
+        }
+    };
+    CheckboxView.prototype.u = function (a) {
+        this.c.focused = false;
+    };
+    CheckboxView.prototype.x = function (a) {
+        this.c.focused = true;
+    };
+    CheckboxView.prototype.w = function (a) {
+        a.stopPropagation();
+        if (this.h()) {
+            var native_ = this.q.getNativeElement();
+            native_.blur();
+        }
+        this.c.toggle();
+    };
+    CheckboxView.prototype.h = function () {
+        return false;
+    };
+    CheckboxView.prototype.v = function (a) {
+        a.stopPropagation();
+    };
+    CheckboxView.prototype.y = function () {
+        if (KeyFrameAnimationFactory.h == null) {
+            KeyFrameAnimationFactory.h = this.l;
+        }
+    };
+    CheckboxView.prototype.a = function (a) {
+        return new AnimationKeyFrameEffect(0, this.p, 0, null, a);
+    };
+    CheckboxView.prototype.b = function (a) {
+        return new AnimationKeyFrameEffect(0, this.n, 0, null, a);
+    };
+    CheckboxView.prototype.z = function (a) {
+    };
+    Object.defineProperty(CheckboxView.prototype, "r", {
+        get: function () {
+            return this.p;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(CheckboxView.prototype, "e", {
+        get: function () {
+            return this.d;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(CheckboxView.prototype, "s", {
+        get: function () {
+            return this.n;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    CheckboxView.prototype.aa = function () {
+        this.g = true;
+        this.j.add(this.q.listen("change", runOn(this, this.v)));
+        this.j.add(this.q.listen("click", runOn(this, this.w)));
+        this.j.add(this.q.listen("focus", runOn(this, this.x)));
+        this.j.add(this.q.listen("blur", runOn(this, this.u)));
+        this.j.add(this.o.listen("click", runOn(this, this.t)));
+    };
+    CheckboxView.prototype.ac = function () {
+        var e_2, _a;
+        this.g = false;
+        try {
+            for (var _b = tslib_1.__values(fromEnum(this.j)), _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.j.clear();
+    };
+    CheckboxView.prototype.af = function () {
+        var model_ = this.c;
+        if (model_.externalObject && model_.externalObject.refreshDefaults) {
+            model_.externalObject.refreshDefaults();
+        }
+        ;
+    };
+    CheckboxView.prototype.ah = function (a, b) {
+        this.d.ax = a;
+        this.d.aw = b;
+    };
+    CheckboxView.prototype.k = function () {
+        var a = this.p.getStyleProperty("border-top-width");
+        a = stringReplace(a, "px", "");
+        return parseFloat(a);
+    };
+    CheckboxView.$t = markType(CheckboxView, 'CheckboxView');
+    return CheckboxView;
+}(Base));
+export { CheckboxView };
+/**
+ * @hidden
+ */
+var Checkbox = /** @class */ /*@__PURE__*/ (function (_super) {
+    tslib_1.__extends(Checkbox, _super);
+    function Checkbox() {
+        var _this = _super.call(this) || this;
+        _this._view = null;
+        _this.b = 0;
+        _this.n = false;
+        _this.ab = false;
+        _this.c3 = null;
+        _this.cy = ThemeResolver.e(Checkbox.c, Checkbox.dm, Checkbox.dh);
+        _this.c0 = null;
+        _this.c2 = null;
+        _this.cx = ThemeResolver.e(Checkbox.c, Checkbox.dl, Checkbox.dg);
+        _this.c4 = null;
+        _this.c1 = null;
+        _this.dr = ThemeResolver.e(Checkbox.c, Checkbox.dn, Checkbox.di);
+        _this.dd = ThemeResolver.e(Checkbox.c, Checkbox.dk, Checkbox.df);
+        _this.an = ThemeResolver.b(Checkbox.c, Checkbox.as, Checkbox.ap);
+        _this.dc = ThemeResolver.e(Checkbox.c, Checkbox.dj, Checkbox.de);
+        _this.ao = ThemeResolver.b(Checkbox.c, Checkbox.at, Checkbox.aq);
+        _this.dp = ThemeResolver.e(Checkbox.c, Checkbox.dl, Checkbox.dg);
+        _this.av = ThemeResolver.b(Checkbox.c, Checkbox.au, Checkbox.ar);
+        _this.dq = ThemeResolver.e(Checkbox.c, Checkbox.dm, Checkbox.dh);
+        _this.cz = ThemeResolver.e(Checkbox.c, Checkbox.dn, Checkbox.di);
+        _this.cw = ThemeResolver.e(Checkbox.c, Checkbox.dk, Checkbox.df);
+        _this.af = NaN;
+        _this.ac = ThemeResolver.b(Checkbox.c, Checkbox.as, Checkbox.ap);
+        _this.ag = NaN;
+        _this.ah = NaN;
+        _this.ae = ThemeResolver.b(Checkbox.c, Checkbox.au, Checkbox.ar);
+        _this.ad = ThemeResolver.b(Checkbox.c, Checkbox.at, Checkbox.aq);
+        _this.cv = ThemeResolver.e(Checkbox.c, Checkbox.dj, Checkbox.de);
+        _this.a9 = "ig-native-checkbox-" + Checkbox.a2++;
+        _this.a8 = "ig-checkbox-" + Checkbox.a1++;
+        _this.ba = null;
+        _this.bb = null;
+        _this.ay = 0;
+        _this.o = false;
+        _this.ax = 0;
+        _this.a7 = null;
+        _this.a6 = null;
+        _this.a3 = null;
+        _this.r = false;
+        _this.change = null;
+        _this.g = 0;
+        _this.l = false;
+        _this.p = false;
+        _this.s = false;
+        _this.q = false;
+        _this.m = false;
+        _this.j = null;
+        _this.k = null;
+        _this.propertyChanged = null;
+        _this.ba = _this.a8 + "-label";
+        _this.a7 = _this.ba;
+        var a = new CheckboxView();
+        a.c = _this;
+        _this.view = a;
+        _this.view.ad();
+        return _this;
+    }
+    Object.defineProperty(Checkbox.prototype, "view", {
+        get: function () {
+            return this._view;
+        },
+        set: function (a) {
+            this._view = a;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(Checkbox.prototype, "d", {
+        get: function () {
+            return this.b;
+        },
+        set: function (a) {
+            var b = this.b;
+            this.b = a;
+            if (b != this.b) {
+                this.cl("BaseTheme", enumGetBox(BaseControlTheme_$type, b), enumGetBox(BaseControlTheme_$type, a));
+            }
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Checkbox.prototype.destroy = function () {
+        this.provideContainer(null);
+    };
+    Checkbox.prototype.cl = function (a, b, c) {
+        if (this.propertyChanged != null) {
+            this.propertyChanged(this, new PropertyChangedEventArgs(a));
+        }
+        this.cn(a, b, c);
+    };
+    Checkbox.prototype.cr = function () {
+        this.c7 = this.ds != null ? this.ds : this.dp;
+        this.c9 = this.du != null ? this.du : this.dr;
+        this.c6 = this.db != null ? this.db : this.dd;
+        this.ai = !isNaN_(this.al) ? this.al : this.an;
+        this.c5 = this.da != null ? this.da : this.dc;
+        this.c8 = this.dt != null ? this.dt : this.dq;
+        this.aj = !isNaN_(this.am) ? this.am : this.ao;
+        this.ak = !isNaN_(this.aw) ? this.aw : this.av;
+    };
+    Checkbox.prototype.cn = function (a, b, c) {
+        switch (a) {
+            case "BaseTheme":
+                this.cu(this.d);
+                this.cr();
+                break;
+            case "TickColor":
+                this.c7 = this.ds != null ? this.ds : this.dp;
+                break;
+            case "UncheckedBorderColor":
+                this.c9 = this.du != null ? this.du : this.dr;
+                break;
+            case "CheckedBorderColor":
+                this.c6 = this.db != null ? this.db : this.dd;
+                break;
+            case "BorderWidth":
+                this.ai = !isNaN_(this.al) ? this.al : this.an;
+                break;
+            case "CheckedBackgroundColor":
+                this.c5 = this.da != null ? this.da : this.dc;
+                break;
+            case "UncheckedBackgroundColor":
+                this.c8 = this.dt != null ? this.dt : this.dq;
+                break;
+            case "CornerRadius":
+                this.aj = !isNaN_(this.am) ? this.am : this.ao;
+                break;
+            case "TickStrokeWidth":
+                this.ak = !isNaN_(this.aw) ? this.aw : this.av;
+                break;
+            case "ActualTickStrokeWidth":
+            case "ActualTickColor":
+                this.ct();
+                break;
+            case "ActualCheckedBackgroundColor":
+            case "ActualUncheckedBackgroundColor":
+            case "ActualUncheckedBorderColor":
+            case "ActualCheckedBorderColor":
+            case "ActualBorderWidth":
+                if (this.j != null) {
+                    this.j.cancel();
+                }
+                if (this.k != null) {
+                    this.k.cancel();
+                }
+                this.j = null;
+                this.k = null;
+                this.cq();
+                var d = (this.u);
+                this.u = true;
+                this.cs(this.indeterminate);
+                this.u = d;
+                break;
+            case "ActualCornerRadius":
+                this.cq();
+                break;
+            case "IsChecked":
+                if (!this.n) {
+                    var e = this.indeterminate;
+                    this.n = true;
+                    this.indeterminate = false;
+                    this.n = false;
+                    var f = (this.u);
+                    this.u = true;
+                    this.cs(e);
+                    this.u = f;
+                }
+                break;
+            case "IsIndeterminate":
+                if (!this.n) {
+                    this.cs(b);
+                }
+                break;
+            case "DisableRipple":
+                this.view.e.i = this.t;
+                break;
+            case "InputId":
+                this.view.ae();
+                break;
+        }
+    };
+    Checkbox.prototype.cq = function () {
+        var a = this.view.r;
+        if (a == null) {
+            return;
+        }
+        NativeUI.l(a, new CornerRadius(0, this.aj));
+        if (!isNaN_(this.ai)) {
+            NativeUI.m(a, new Thickness(0, this.ai));
+        }
+        if (this.checked) {
+            NativeUI.j(a, this.c5);
+            NativeUI.k(a, this.c6);
+        }
+        else {
+            NativeUI.j(a, this.c8);
+            NativeUI.k(a, this.c9);
+        }
+    };
+    Checkbox.prototype.ct = function () {
+        var a = this.view.s;
+        if (a == null) {
+            return;
+        }
+        NativeUI.v(a, this.c7);
+        NativeUI.y(a, this.ak);
+    };
+    Object.defineProperty(Checkbox.prototype, "dt", {
+        get: function () {
+            return this.c3;
+        },
+        set: function (a) {
+            var b = this.c3;
+            this.c3 = a;
+            if (b != this.c3) {
+                this.cl("UncheckedBackgroundColor", b, a);
+            }
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(Checkbox.prototype, "c8", {
+        get: function () {
+            return this.cy;
+        },
+        set: function (a) {
+            var b = this.cy;
+            this.cy = a;
+            if (b != this.cy) {
+                this.cl("ActualUncheckedBackgroundColor", b, a);
+            }
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(Checkbox.prototype, "da", {
+        get: function () {
+            return this.c0;
+        },
+        set: function (a) {
+            var b = this.c0;
+            this.c0 = a;
+            if (b != this.c0) {
+                this.cl("CheckedBackgroundColor", b, a);
+            }
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(Checkbox.prototype, "ds", {
+        get: function () {
+            return this.c2;
+        },
+        set: function (a) {
+            var b = this.c2;
+            this.c2 = a;
+            if (b != this.c2) {
+                this.cl("TickColor", b, a);
+            }
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(Checkbox.prototype, "c7", {
+        get: function () {
+            return this.cx;
+        },
+        set: function (a) {
+            var b = this.cx;
+            this.cx = a;
+            if (b != this.cx) {
+                this.cl("ActualTickColor", b, a);
+            }
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(Checkbox.prototype, "du", {
+        get: function () {
+            return this.c4;
+        },
+        set: function (a) {
+            var b = this.c4;
+            this.c4 = a;
+            if (b != this.c4) {
+                this.cl("UncheckedBorderColor", b, a);
+            }
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(Checkbox.prototype, "db", {
+        get: function () {
+            return this.c1;
+        },
+        set: function (a) {
+            var b = this.c1;
+            this.c1 = a;
+            if (b != this.c1) {
+                this.cl("CheckedBorderColor", b, a);
+            }
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Checkbox.prototype.cu = function (a) {
+        this.dr = ThemeResolver.e(a, Checkbox.dn, Checkbox.di);
+        this.dd = ThemeResolver.e(a, Checkbox.dk, Checkbox.df);
+        this.an = ThemeResolver.b(a, Checkbox.as, Checkbox.ap);
+        this.dc = ThemeResolver.e(a, Checkbox.dj, Checkbox.de);
+        this.ao = ThemeResolver.b(a, Checkbox.at, Checkbox.aq);
+        this.dp = ThemeResolver.e(a, Checkbox.dl, Checkbox.dg);
+        this.av = ThemeResolver.b(a, Checkbox.au, Checkbox.ar);
+        this.dq = ThemeResolver.e(a, Checkbox.dm, Checkbox.dh);
+    };
+    Object.defineProperty(Checkbox.prototype, "c9", {
+        get: function () {
+            return this.cz;
+        },
+        set: function (a) {
+            var b = this.cz;
+            this.cz = a;
+            if (b != this.cz) {
+                this.cl("ActualUncheckedBorderColor", b, a);
+            }
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(Checkbox.prototype, "c6", {
+        get: function () {
+            return this.cw;
+        },
+        set: function (a) {
+            var b = this.cw;
+            this.cw = a;
+            if (b != this.cw) {
+                this.cl("ActualCheckedBorderColor", b, a);
+            }
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(Checkbox.prototype, "al", {
+        get: function () {
+            return this.af;
+        },
+        set: function (a) {
+            var b = this.af;
+            this.af = a;
+            if (b != this.af) {
+                this.cl("BorderWidth", b, a);
+            }
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(Checkbox.prototype, "ai", {
+        get: function () {
+            return this.ac;
+        },
+        set: function (a) {
+            var b = this.ac;
+            this.ac = a;
+            if (b != this.ac) {
+                this.cl("ActualBorderWidth", b, a);
+            }
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(Checkbox.prototype, "am", {
+        get: function () {
+            return this.ag;
+        },
+        set: function (a) {
+            var b = this.ag;
+            this.ag = a;
+            if (b != this.ag) {
+                this.cl("CornerRadius", b, a);
+            }
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(Checkbox.prototype, "aw", {
+        get: function () {
+            return this.ah;
+        },
+        set: function (a) {
+            var b = this.ah;
+            this.ah = a;
+            if (b != this.ah) {
+                this.cl("TickStrokeWidth", b, a);
+            }
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(Checkbox.prototype, "ak", {
+        get: function () {
+            return this.ae;
+        },
+        set: function (a) {
+            var b = this.ae;
+            this.ae = a;
+            if (b != this.ae) {
+                this.cl("ActualTickStrokeWidth", b, a);
+            }
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(Checkbox.prototype, "aj", {
+        get: function () {
+            return this.ad;
+        },
+        set: function (a) {
+            var b = this.ad;
+            this.ad = a;
+            if (b != this.ad) {
+                this.cl("ActualCornerRadius", b, a);
+            }
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(Checkbox.prototype, "c5", {
+        get: function () {
+            return this.cv;
+        },
+        set: function (a) {
+            var b = this.cv;
+            this.cv = a;
+            if (b != this.cv) {
+                this.cl("ActualCheckedBackgroundColor", b, a);
+            }
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(Checkbox.prototype, "by", {
+        get: function () {
+            return this.a9;
+        },
+        set: function (a) {
+            var b = this.a9;
+            this.a9 = a;
+            if (b != this.a9) {
+                this.cl("InputId", b, a);
+            }
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(Checkbox.prototype, "bw", {
+        get: function () {
+            return this.a8;
+        },
+        set: function (a) {
+            var b = this.a8;
+            this.a8 = a;
+            if (b != this.a8) {
+                this.cl("Id", b, a);
+            }
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(Checkbox.prototype, "labelId", {
+        get: function () {
+            return this.ba;
+        },
+        set: function (a) {
+            var b = this.ba;
+            this.ba = a;
+            if (b != this.ba) {
+                this.cl("LabelId", b, a);
+            }
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(Checkbox.prototype, "b7", {
+        get: function () {
+            return this.bb;
+        },
+        set: function (a) {
+            var b = this.bb;
+            this.bb = a;
+            if (b != this.bb) {
+                this.cl("Name", b, a);
+            }
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(Checkbox.prototype, "v", {
+        get: function () {
+            return this.o;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(Checkbox.prototype, "a0", {
+        get: function () {
+            return this.ay;
+        },
+        set: function (a) {
+            var b = this.ay;
+            this.ay = a;
+            this.o = true;
+            if (b != this.ay) {
+                this.cl("TabIndex", b, a);
+            }
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(Checkbox.prototype, "az", {
+        get: function () {
+            return this.ax;
+        },
+        set: function (a) {
+            var b = this.ax;
+            this.ax = a;
+            if (b != this.ax) {
+                this.cl("Required", b, a);
+            }
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(Checkbox.prototype, "bl", {
+        get: function () {
+            return this.a7;
+        },
+        set: function (a) {
+            var b = this.a7;
+            this.a7 = a;
+            if (b != this.a7) {
+                this.cl("AriaLabelledBy", b, a);
+            }
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(Checkbox.prototype, "bk", {
+        get: function () {
+            return this.a6;
+        },
+        set: function (a) {
+            var b = this.a6;
+            this.a6 = a;
+            if (b != this.a6) {
+                this.cl("AriaLabel", b, a);
+            }
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(Checkbox.prototype, "a5", {
+        get: function () {
+            return this.a3;
+        },
+        set: function (a) {
+            var b = this.a3;
+            this.a3 = a;
+            if (b != this.a3) {
+                this.cl("Value", b, a);
+            }
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(Checkbox.prototype, "focused", {
+        get: function () {
+            return this.r;
+        },
+        set: function (a) {
+            var b = this.r;
+            this.r = a;
+            if (b != this.r) {
+                this.cl("IsFocused", b, a);
+            }
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(Checkbox.prototype, "h", {
+        get: function () {
+            return this.g;
+        },
+        set: function (a) {
+            var b = this.g;
+            this.g = a;
+            if (b != this.g) {
+                this.cl("LabelPosition", enumGetBox(CheckboxLabelPosition_$type, b), enumGetBox(CheckboxLabelPosition_$type, a));
+            }
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(Checkbox.prototype, "t", {
+        get: function () {
+            return this.l;
+        },
+        set: function (a) {
+            var b = this.l;
+            this.l = a;
+            if (b != this.l) {
+                this.cl("DisableRipple", b, a);
+            }
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(Checkbox.prototype, "checked", {
+        get: function () {
+            return this.p;
+        },
+        set: function (a) {
+            var b = this.p;
+            this.p = a;
+            if (b != this.p) {
+                this.cl("IsChecked", b, a);
+            }
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(Checkbox.prototype, "indeterminate", {
+        get: function () {
+            return this.s;
+        },
+        set: function (a) {
+            var b = this.s;
+            this.s = a;
+            if (b != this.s) {
+                this.cl("IsIndeterminate", b, a);
+            }
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(Checkbox.prototype, "disabled", {
+        get: function () {
+            return this.q;
+        },
+        set: function (a) {
+            var b = this.q;
+            this.q = a;
+            if (b != this.q) {
+                this.cl("IsDisabled", b, a);
+            }
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(Checkbox.prototype, "u", {
+        get: function () {
+            return this.m;
+        },
+        set: function (a) {
+            var b = this.m;
+            this.m = a;
+            if (b != this.m) {
+                this.cl("DisableTransitions", b, a);
+            }
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Checkbox.prototype.cm = function () {
+        this.ch();
+        if (this.checked) {
+            this.view.ah(BrushUtil.n(this.c5, 0.6), BrushUtil.n(this.c5, 0.1));
+        }
+        else {
+            this.view.ah(BrushUtil.n(this.c5, 0.6), BrushUtil.n(this.c9, 0.1));
+        }
+    };
+    Object.defineProperty(Checkbox.prototype, "a", {
+        get: function () {
+            var a = new AnimationKeyFrameEffectTiming();
+            a.g = 300;
+            a.b = 0;
+            return a;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Checkbox.prototype.ch = function () {
+        this.view.y();
+        var a = false;
+        if (this.j == null) {
+            if (!a) {
+                a = true;
+                this.view.af();
+            }
+            this.j = KeyFrameAnimationFactory.f.c(this.view.a(this.a).m(new AnimationKeyFrameProperty(2, this.c8), new AnimationKeyFrameProperty(3, this.c9)).m(new AnimationKeyFrameProperty(2, this.c5), new AnimationKeyFrameProperty(3, this.c6)));
+            this.k = KeyFrameAnimationFactory.f.c(this.view.b(this.a).m(new AnimationKeyFrameProperty(19, 24), new AnimationKeyFrameProperty(1, 0)).m(new AnimationKeyFrameProperty(19, 0), new AnimationKeyFrameProperty(1, 1)));
+        }
+    };
+    Checkbox.prototype.toggle = function () {
+        if (this.disabled) {
+            return;
+        }
+        this.ch();
+        this.focused = false;
+        this.n = true;
+        var a = false;
+        if (this.indeterminate) {
+            a = true;
+            this.checked = true;
+        }
+        this.indeterminate = false;
+        this.checked = !this.checked;
+        this.n = false;
+        this.cs(a);
+        if (this.change != null) {
+            var b = new CheckboxChangeEventArgs();
+            b.isChecked = this.checked;
+            b.isIndeterminate = this.indeterminate;
+            this.change(this, b);
+        }
+    };
+    Checkbox.prototype.cs = function (a) {
+        var _this = this;
+        this.ch();
+        var b = this.checked;
+        if (this.indeterminate) {
+            b = true;
+        }
+        var c = 1;
+        if (!b) {
+            c = -1;
+        }
+        if (b) {
+            this.view.ah(BrushUtil.n(this.c5, 0.6), BrushUtil.n(this.c5, 0.1));
+        }
+        else {
+            this.view.ah(BrushUtil.n(this.c5, 0.6), BrushUtil.n(this.c9, 0.1));
+        }
+        if (!this.indeterminate) {
+            NativeUI.z(this.view.s, null);
+        }
+        if (this.u || this.indeterminate || a) {
+            var d = this.view.r;
+            var e = this.view.s;
+            if (this.indeterminate) {
+                var f = new TransformGroup();
+                f.j.add(((function () {
+                    var $ret = new RotateTransform();
+                    $ret.j = 45;
+                    return $ret;
+                })()));
+                f.j.add(((function () {
+                    var $ret = new TranslateTransform();
+                    $ret.j = -_this.view.k();
+                    return $ret;
+                })()));
+                NativeUI.j(d, this.c5);
+                NativeUI.k(d, this.c6);
+                NativeUI.t(e, 1);
+                NativeUI.x(e, 41);
+                NativeUI.z(e, f);
+            }
+            else if (b) {
+                NativeUI.j(d, this.c5);
+                NativeUI.k(d, this.c6);
+                NativeUI.t(e, 1);
+                NativeUI.x(e, 0);
+            }
+            else {
+                NativeUI.j(d, this.c8);
+                NativeUI.k(d, this.c9);
+                NativeUI.t(e, 0);
+                NativeUI.x(e, 24);
+            }
+            return;
+        }
+        if ((c > 0 && this.j.playbackRate < 0) || (c < 0 && this.j.playbackRate > 0)) {
+            this.j.reverse();
+            this.j.finished.f(function (g) {
+                if (_this.j != null) {
+                    _this.j.commitStyles();
+                }
+            });
+            this.k.reverse();
+            this.k.finished.f(function (g) {
+                if (_this.k != null) {
+                    _this.k.commitStyles();
+                }
+            });
+        }
+        else {
+            this.j.play();
+            this.j.finished.f(function (g) {
+                if (_this.j != null) {
+                    _this.j.commitStyles();
+                }
+            });
+            this.k.play();
+            this.k.finished.f(function (g) {
+                if (_this.k != null) {
+                    _this.k.commitStyles();
+                }
+            });
+        }
+    };
+    Checkbox.prototype.onDetachedFromUI = function () {
+        this.view.ac();
+    };
+    Checkbox.prototype.onAttachedToUI = function () {
+        this.view.aa();
+    };
+    Checkbox.prototype.onContentReady = function () {
+        if (this.indeterminate) {
+            this.cs(false);
+        }
+    };
+    Checkbox.prototype.aa = function () {
+        return this.view.i();
+    };
+    Checkbox.prototype.a4 = function () {
+        return this.e();
+    };
+    Checkbox.prototype.bv = function () {
+        var a = this.e();
+        return a.s();
+    };
+    Checkbox.prototype.e = function () {
+        var a = new CheckboxVisualModelExport();
+        a.f = this.d;
+        a.d = AppearanceHelper.a(this.c8);
+        a.c = AppearanceHelper.a(this.c7);
+        a.e = AppearanceHelper.a(this.c9);
+        a.b = AppearanceHelper.a(this.c6);
+        a.o = this.al;
+        a.l = this.ai;
+        a.p = this.am;
+        a.q = this.aw;
+        a.n = this.ak;
+        a.m = this.aj;
+        a.a = AppearanceHelper.a(this.c5);
+        a.r = this.a5;
+        a.j = this.focused;
+        a.g = this.t;
+        a.h = this.checked;
+        a.k = this.indeterminate;
+        a.i = this.disabled;
+        return a;
+    };
+    Checkbox.prototype.provideContainer = function (a) {
+        this.view.ab(a);
+    };
+    Checkbox.$t = markType(Checkbox, 'Checkbox', Base.$, [INotifyPropertyChanged_$type]);
+    Checkbox.dn = BrushUtil.g(138, 0, 0, 0);
+    Checkbox.dk = BrushUtil.g(138, 0, 0, 0);
+    Checkbox.as = NaN;
+    Checkbox.dj = BrushUtil.g(255, 228, 28, 119);
+    Checkbox.at = 2;
+    Checkbox.dl = BrushUtil.g(255, 255, 255, 255);
+    Checkbox.au = 3;
+    Checkbox.dm = BrushUtil.g(255, 255, 255, 255);
+    Checkbox.di = BrushUtil.g(255, 153, 153, 153);
+    Checkbox.df = BrushUtil.g(138, 33, 150, 243);
+    Checkbox.ap = NaN;
+    Checkbox.de = BrushUtil.g(255, 33, 150, 243);
+    Checkbox.aq = 2;
+    Checkbox.dg = BrushUtil.g(255, 255, 255, 255);
+    Checkbox.ar = 3;
+    Checkbox.dh = BrushUtil.g(255, 255, 255, 255);
+    Checkbox.c = 2;
+    Checkbox.a2 = 0;
+    Checkbox.a1 = 0;
+    return Checkbox;
+}(Base));
+export { Checkbox };
+//# sourceMappingURL=CheckboxView_combined.js.map