igniteui-webcomponents-layouts 3.2.3 → 3.5.0

package/esm2015/lib/ToolPanelView_combined.js

@@ -0,0 +1,1699 @@
+/*
+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 { Base, markType, INotifyPropertyChanged_$type, PropertyChangedEventArgs, EnumUtil, runOn, delegateCombine, typeCast, delegateRemove, fromEn, String_$type, enumGetBox } from "igniteui-webcomponents-core";
+import { RenderingContext } from "igniteui-webcomponents-core";
+import { FontInfo } from "igniteui-webcomponents-core";
+import { ListPanel } from "./ListPanel";
+import { DOMExecutionContext } from "igniteui-webcomponents-core";
+import { CanvasViewRenderer } from "igniteui-webcomponents-core";
+import { Size } from "igniteui-webcomponents-core";
+import { NativeUI } from "igniteui-webcomponents-core";
+import { FontUtil } from "igniteui-webcomponents-core";
+import { Popup } from "./Popup";
+import { NativeUIContent } from "igniteui-webcomponents-core";
+import { NativeUIComponent } from "igniteui-webcomponents-core";
+import { Rect } from "igniteui-webcomponents-core";
+import { ToolActionType_$type } from "igniteui-webcomponents-core";
+import { ToolCommandArgument } from "igniteui-webcomponents-core";
+import { ToolActionMeasurementContext } from "./ToolActionMeasurementContext";
+import { ToolCommand } from "igniteui-webcomponents-core";
+import { List$1 } from "igniteui-webcomponents-core";
+import { ToolCommandEventArgs } from "./ToolCommandEventArgs";
+import { DeviceUtils } from "igniteui-webcomponents-core";
+import { ToolPanelOrientation_$type } from "./ToolPanelOrientation";
+import { stringReplace } from "igniteui-webcomponents-core";
+import { isNaN_, tryParseNumber } from "igniteui-webcomponents-core";
+import { Thickness } from "igniteui-webcomponents-core";
+import { BrushUtil } from "igniteui-webcomponents-core";
+import { ObservableCollection$1 } from "igniteui-webcomponents-core";
+import { ToolPanelContentRefreshedEventArgs } from "./ToolPanelContentRefreshedEventArgs";
+import { SRProvider } from "igniteui-webcomponents-core";
+import { Dictionary$2 } from "igniteui-webcomponents-core";
+import { NativeUIInputsFactory } from "igniteui-webcomponents-core";
+/**
+ * @hidden
+ */
+export let ToolPanelView = /*@__PURE__*/ (() => {
+    class ToolPanelView extends Base {
+        constructor() {
+            super();
+            this.p = null;
+            this.o = null;
+            this.c = null;
+            this.k = null;
+            this.n = null;
+            this.g = null;
+            this.m = null;
+            this.d = ((() => {
+                let $ret = new FontInfo();
+                $ret.n = "Verdana";
+                $ret.d = 13;
+                $ret.q = "Normal";
+                $ret.s = "Normal";
+                $ret.o = "Normal";
+                return $ret;
+            })());
+            this.ad = new Size();
+            this.e = null;
+            this._gridExternal = null;
+            this.h = false;
+            this.l = null;
+        }
+        r() {
+            return this.k;
+        }
+        x() {
+        }
+        v(a) {
+            if (a == null) {
+                this.k = null;
+                return;
+            }
+            this.c.a = new DOMExecutionContext(a);
+            this.k = a;
+            this.n = this.k.createElement("canvas");
+            this.g = new RenderingContext(new CanvasViewRenderer(), this.k.get2DCanvasContext(this.n));
+            this.m = this.k.createElement("div");
+            this.aa();
+            let b = new ListPanel();
+            let c = this.k.createElement("div");
+            c.setStyleProperty("width", "100%");
+            c.setStyleProperty("height", "100%");
+            this.k.append(c);
+            let d = this.k.getSubRenderer(c);
+            b.provideContainer(d);
+            let e = this.k.getExternal(b, this.k.rootWrapper, this.k.getExternal(this.c, null, null));
+            b.externalListPanel = e;
+            this.c.aq(b);
+            let f = Math.round(a.rootWrapper.width());
+            let g = Math.round(a.rootWrapper.height());
+            this.k.rootWrapper.setStyleProperty("position", "relative");
+        }
+        aa() {
+        }
+        z() {
+            if (this.k != null) {
+            }
+        }
+        u() {
+            if (this.k == null) {
+                return;
+            }
+            let a = this.k.rootWrapper.width();
+            let b = this.k.rootWrapper.height();
+            this.ad = new Size(1, a, b);
+            if (this.c.p != null) {
+            }
+        }
+        ab() {
+            let a = this.k;
+            if (null == a) {
+                return;
+            }
+            let b = a.rootWrapper;
+            if (null != b) {
+                NativeUI.o(b, this.c.ba);
+                NativeUI.k(b, this.c.a7);
+            }
+        }
+        f() {
+            return this.d;
+        }
+        w() {
+        }
+        y() {
+        }
+        t() {
+        }
+        i() {
+            return this.ad.width;
+        }
+        j(a) {
+            this.e = this.c.o();
+            return FontUtil.measureStringWidth(a, this.e, this.g);
+        }
+        s(a, b) {
+            if (this.l == null) {
+                this.l = this.k.createElement("div");
+            }
+            b(this.l.getNativeElement());
+        }
+        a() {
+            let a = new Popup();
+            let b = this.k.getExternal(a, this.k.rootWrapper, this.k.getExternal(this.c, null, null));
+            return a;
+        }
+        b(a) {
+            let b = new ToolPanel();
+            let c = this.k.getExternal(b, this.k.rootWrapper, this.k.getExternal(this.c, null, null));
+            let d = a.v;
+            d.appendChild(b.l.k.rootWrapper.getNativeElement());
+            return b;
+        }
+        ac(a) {
+            let ele_ = a;
+            let bounds_ = (ele_.getBoundingClientRect());
+            let b = bounds_["left"];
+            let c = bounds_["top"];
+            let d = bounds_["width"];
+            let e = bounds_["height"];
+            return new Rect(0, b, c, d, e);
+        }
+    }
+    ToolPanelView.$t = /*@__PURE__*/ markType(ToolPanelView, 'ToolPanelView');
+    return ToolPanelView;
+})();
+/**
+ * @hidden
+ */
+export let ToolAction = /*@__PURE__*/ (() => {
+    class ToolAction extends Base {
+        constructor() {
+            super(...arguments);
+            this.e = null;
+            this.ae = null;
+            this.z = null;
+            this.y = null;
+            this.u = null;
+            this.k = DeviceUtils.g(5);
+            this.l = DeviceUtils.g(5);
+            this.j = DeviceUtils.g(2);
+            this.m = DeviceUtils.g(2);
+            this.ad = null;
+            this.ac = null;
+            this.ab = null;
+            this.aa = null;
+            this.propertyChanged = null;
+            this.onCommand = null;
+            this.performed = null;
+        }
+        get ao() {
+            if (this.ar != null) {
+                return this.ar;
+            }
+            if (this.ap != null) {
+                return this.a1(this.ap);
+            }
+            return null;
+        }
+        a1(a) {
+            return stringReplace(a, " ", "_");
+        }
+        b(a) {
+            return ((() => {
+                let $ret = new ToolActionEventDetail();
+                $ret.a = this;
+                $ret.d = a;
+                return $ret;
+            })());
+        }
+        g() {
+            return ((() => {
+                let $ret = new ToolCommandArgument();
+                $ret.argumentName = this.az();
+                $ret.value = this.w();
+                return $ret;
+            })());
+        }
+        az() {
+            if (this.af != null) {
+                return this.af;
+            }
+            return this.ao != null ? this.ao : "Unknown";
+        }
+        w() {
+            if (this.v != null) {
+                return this.v;
+            }
+            return this.x();
+        }
+        x() {
+            return null;
+        }
+        get ax() {
+            return this.ae;
+        }
+        set ax(a) {
+            let b = this.ae;
+            this.ae = a;
+            if (b != this.ae) {
+                this.a8("ParentId", b, this.ae);
+            }
+        }
+        a0() {
+            if (this.ai != null) {
+                return this.ai;
+            }
+            return this.ao;
+        }
+        get ai() {
+            return this.z;
+        }
+        set ai(a) {
+            let b = this.z;
+            this.z = a;
+            if (b != this.z) {
+                this.a8("CommandId", b, this.z);
+            }
+        }
+        get af() {
+            return this.y;
+        }
+        set af(a) {
+            let b = this.y;
+            this.y = a;
+            if (b != this.y) {
+                this.a8("CommandArgument", b, this.y);
+            }
+        }
+        get v() {
+            return this.u;
+        }
+        set v(a) {
+            let b = this.u;
+            this.u = a;
+            if (b != this.u) {
+                this.a8("CommandArgumentValue", b, this.u);
+            }
+        }
+        get r() {
+            return this.k;
+        }
+        set r(a) {
+            let b = this.k;
+            this.k = a;
+            if (b != this.k) {
+                this.a8("PaddingLeft", b, this.k);
+            }
+        }
+        get s() {
+            return this.l;
+        }
+        set s(a) {
+            let b = this.l;
+            this.l = a;
+            if (b != this.l) {
+                this.a8("PaddingRight", b, this.l);
+            }
+        }
+        get q() {
+            return this.j;
+        }
+        set q(a) {
+            let b = this.j;
+            this.j = a;
+            if (b != this.j) {
+                this.a8("PaddingBottom", b, this.j);
+            }
+        }
+        get t() {
+            return this.m;
+        }
+        set t(a) {
+            let b = this.m;
+            this.m = a;
+            if (b != this.m) {
+                this.a8("PaddingTop", b, this.m);
+            }
+        }
+        get i() {
+            return this.ax != null;
+        }
+        get ar() {
+            return this.ad;
+        }
+        set ar(a) {
+            let b = this.ad;
+            this.ad = a;
+            if (b != this.ad) {
+                this.a8("Name", b, this.ad);
+            }
+        }
+        get ap() {
+            return this.ac;
+        }
+        set ap(a) {
+            let b = this.ac;
+            this.ac = a;
+            if (b != this.ac) {
+                this.a8("Label", b, this.ac);
+            }
+        }
+        get am() {
+            return this.ab;
+        }
+        set am(a) {
+            let b = this.ab;
+            this.ab = a;
+            if (b != this.ab) {
+                this.a8("IconName", b, this.ab);
+            }
+        }
+        get ak() {
+            return this.aa;
+        }
+        set ak(a) {
+            let b = this.aa;
+            this.aa = a;
+            if (b != this.aa) {
+                this.a8("IconCollectionName", b, this.aa);
+            }
+        }
+        a8(a, b, c) {
+            if (this.propertyChanged != null) {
+                this.propertyChanged(this, new PropertyChangedEventArgs(a));
+            }
+            this.bc(a, b, c);
+        }
+        get_f() {
+            return 0;
+        }
+        get f() {
+            return this.get_f();
+        }
+        bc(a, b, c) {
+        }
+        ba(a, b, c, d) {
+            this.bb(a, b, c, d);
+        }
+        bb(a, b, c, d) {
+        }
+        a4(a, b) {
+            this.a5(a, b);
+        }
+        a5(a, b) {
+            b.e = this.n(a, b);
+            b.g = this.p(a, b);
+            b.f = this.o(a, b);
+            if (b.a == 1) {
+                let c = 0;
+                if (!isNaN_(b.e)) {
+                    c += b.e;
+                }
+                if (!isNaN_(b.g)) {
+                    c += b.g;
+                }
+                if (!isNaN_(b.f)) {
+                    c += b.f;
+                }
+                c += (this.r + this.s);
+                b.d = c;
+            }
+        }
+        o(a, b) {
+            return NaN;
+        }
+        p(a, b) {
+            if (this.ap == null) {
+                return NaN;
+            }
+            let c = a.l.j(this.ap);
+            return c;
+        }
+        n(a, b) {
+            return NaN;
+        }
+        a9(a, b) {
+            this.bd();
+            if (this.i) {
+                let c = this.e.c(this.ax);
+                if (c != null) {
+                    c.a7(this);
+                }
+            }
+            else {
+                if (this.e.u(this)) {
+                    if (this.performed != null) {
+                        let d = new ToolActionEventDetailCollection();
+                        this.a3(this, d, b);
+                        this.performed(this, ((() => {
+                            let $ret = new ToolActionPerformedEventArgs();
+                            $ret.c = true;
+                            $ret.b = d;
+                            return $ret;
+                        })()));
+                    }
+                }
+                else {
+                    if (this.performed != null) {
+                        this.performed(this, ((() => {
+                            let $ret = new ToolActionPerformedEventArgs();
+                            $ret.c = false;
+                            $ret.a = a;
+                            return $ret;
+                        })()));
+                    }
+                }
+            }
+        }
+        bd() {
+            let a = this.a0();
+            if (a == null) {
+                return;
+            }
+            let b = new ToolCommand();
+            b.commandId = a;
+            let c = new List$1(ToolCommandArgument.$, 0);
+            this.a2(this, c);
+            b.argumentsList = c.toArray();
+            if (this.onCommand != null) {
+                this.onCommand(this, ((() => {
+                    let $ret = new ToolCommandEventArgs();
+                    $ret.a = b;
+                    return $ret;
+                })()));
+            }
+            if (this.e != null) {
+                this.e.ay(this, b);
+            }
+        }
+        a2(a, b) {
+            let c = a.g();
+            if (c != null) {
+                b.add(c);
+            }
+            let d = this.e.y(a);
+            if (d != null) {
+                for (let e = 0; e < d.count; e++) {
+                    if (d._inner[e].h()) {
+                        this.a2(d._inner[e], b);
+                    }
+                }
+            }
+        }
+        h() {
+            return true;
+        }
+        a7(a) {
+            if (this.i) {
+                let b = this.e.c(this.ax);
+                if (b != null) {
+                    b.a7(a);
+                }
+            }
+            else {
+                this.a9(this.b(false), a);
+            }
+        }
+        a3(a, b, c) {
+            let d = a.b(a == c);
+            b.add(d);
+            let e = this.e.y(a);
+            if (e != null) {
+                for (let f = 0; f < e.count; f++) {
+                    this.a3(e._inner[f], b, c);
+                }
+            }
+        }
+        static a(a) {
+            let b = null;
+            switch (a.a) {
+                case 2:
+                    b = new ToolActionCheckbox();
+                    break;
+                case 1:
+                    b = new ToolActionGroupHeader();
+                    break;
+                case 3:
+                    b = new ToolActionIconButton();
+                    break;
+                case 4:
+                    b = new ToolActionLabel();
+                    break;
+                case 5:
+                    b = new ToolActionNumberInput();
+                    break;
+                case 6:
+                    b = new ToolActionRadio();
+                    break;
+                case 7:
+                    b = new ToolActionSeparator();
+                    break;
+                case 8:
+                    b = new ToolActionIconMenu();
+                    break;
+                case 0: return null;
+            }
+            b.a6(a);
+            return b;
+        }
+        a6(a) {
+            this.ar = a.name;
+            this.ap = a.label;
+            this.af = a.commandArgument;
+            this.v = a.commandArgumentValue;
+            this.ai = a.commandId;
+            this.am = a.iconName;
+            this.ak = a.iconCollectionName;
+            this.r = a.paddingLeft;
+            this.s = a.paddingRight;
+            this.t = a.paddingTop;
+            this.q = a.paddingBottom;
+            this.ax = a.parentId;
+        }
+    }
+    ToolAction.$t = /*@__PURE__*/ markType(ToolAction, 'ToolAction', Base.$, [INotifyPropertyChanged_$type]);
+    return ToolAction;
+})();
+/**
+ * @hidden
+ */
+export let ToolActionLabel = /*@__PURE__*/ (() => {
+    class ToolActionLabel extends ToolAction {
+        get_f() {
+            return 4;
+        }
+        bf(a, b, c, d, e, f, g) {
+            if (a.w == null || EnumUtil.getEnumValue(ToolActionType_$type, a.w) != this.f) {
+                a.a0 = b;
+                if (g.a == 1) {
+                    b.d = 0;
+                }
+                else {
+                    b.d = 3;
+                }
+                b.a7(0, 2, 1);
+                b.a6(0, 1, isNaN_(g.e) ? 0 : g.e);
+                b.a6(1, 1, isNaN_(g.g) ? 0 : g.g);
+                b.as = new Thickness(1, this.r, this.t, this.s, this.q);
+                if (b.av == 0) {
+                    b.aw(c);
+                }
+                b.bb(c, 0);
+                b.ba(c, 1);
+                c.e = 1;
+                b.a1 = runOn(this, this.be);
+            }
+            b.h = f.a.j;
+            b.aj = BrushUtil.g(0, 0, 0, 0);
+            c.au = this.ap;
+            c.al = BrushUtil.g(255, 20, 20, 20);
+        }
+        be(a, b) {
+            this.a9(this.b(false), this);
+        }
+        bb(a, b, c, d) {
+            super.bb(a, b, c, d);
+            let e = c.b;
+            if (e.a0 == null || (e.w == null || EnumUtil.getEnumValue(ToolActionType_$type, e.w) != this.f)) {
+                NativeUIComponent.ab(b.l.r(), [7, 3], (f) => {
+                    let g = f[0];
+                    let h = f[1];
+                    e.a0 = g;
+                    this.bf(e, g, h, a, b, c, d);
+                });
+                ;
+            }
+            else {
+                let f = e.a0;
+                let g = f.au(0);
+                this.bf(e, f, g, a, b, c, d);
+            }
+        }
+    }
+    ToolActionLabel.$t = /*@__PURE__*/ markType(ToolActionLabel, 'ToolActionLabel', ToolAction.$);
+    return ToolActionLabel;
+})();
+/**
+ * @hidden
+ */
+export let ToolActionRadio = /*@__PURE__*/ (() => {
+    class ToolActionRadio extends ToolAction {
+        constructor() {
+            super(...arguments);
+            this.bf = null;
+            this.be = null;
+        }
+        get_f() {
+            return 6;
+        }
+        b(a) {
+            let b = new ToolActionEventDetail();
+            b.a = this;
+            b.b = this.f;
+            b.d = a;
+            if (this.be != null) {
+                b.c = this.be.aw;
+            }
+            return b;
+        }
+        x() {
+            return this.be.aw;
+        }
+        bg() {
+            if (this.be != null) {
+                this.be.aw = false;
+            }
+        }
+        o(a, b) {
+            return 30;
+        }
+        bi(a, b, c, d, e, f, g, h) {
+            if (a.w == null || EnumUtil.getEnumValue(ToolActionType_$type, a.w) != this.f) {
+                a.a0 = b;
+                if (h.a == 1) {
+                    b.d = 0;
+                }
+                else {
+                    b.d = 3;
+                }
+                b.a7(0, 2, 1);
+                b.a6(0, 1, isNaN_(h.e) ? 0 : h.e);
+                b.a6(1, 1, isNaN_(h.g) ? 0 : h.g);
+                b.a6(1, 2, 1);
+                b.as = new Thickness(1, this.r, this.t, this.s, this.q);
+                if (b.av == 0) {
+                    b.aw(c);
+                    b.aw(d);
+                }
+                b.bb(c, 0);
+                b.ba(c, 1);
+                b.bb(d, 0);
+                b.ba(d, 2);
+                this.be = d;
+                d.ax = 25;
+                d.av = true;
+                d.d = 2;
+                d.e = 1;
+                d.au = runOn(this, this.bh);
+                c.e = 1;
+            }
+            b.h = g.a.j;
+            c.au = this.ap;
+            c.al = BrushUtil.g(255, 20, 20, 20);
+        }
+        bh(a, b) {
+            this.a9(this.b(true), this);
+        }
+        bb(a, b, c, d) {
+            super.bb(a, b, c, d);
+            let e = c.b;
+            if (e.a0 == null || (e.w == null || EnumUtil.getEnumValue(ToolActionType_$type, e.w) != this.f)) {
+                NativeUIComponent.ab(b.l.r(), [7, 3, 6], (f) => {
+                    let g = f[0];
+                    let h = f[1];
+                    let i = f[2];
+                    e.a0 = g;
+                    this.bi(e, g, h, i, a, b, c, d);
+                });
+            }
+            else {
+                let f = e.a0;
+                let g = f.au(0);
+                let h = f.au(1);
+                this.bi(e, f, g, h, a, b, c, d);
+            }
+        }
+    }
+    ToolActionRadio.$t = /*@__PURE__*/ markType(ToolActionRadio, 'ToolActionRadio', ToolAction.$);
+    return ToolActionRadio;
+})();
+/**
+ * @hidden
+ */
+export let ToolActionSeparator = /*@__PURE__*/ (() => {
+    class ToolActionSeparator extends ToolAction {
+        get_f() {
+            return 7;
+        }
+        a5(a, b) {
+            super.a5(a, b);
+            if (b.a == 1) {
+                b.d = 2;
+            }
+            else {
+                b.c = 2;
+            }
+        }
+        be(a, b, c, d, e, f) {
+            if (a.w == null || EnumUtil.getEnumValue(ToolActionType_$type, a.w) != this.f) {
+                a.a0 = b;
+                if (f.a == 1) {
+                    b.d = 0;
+                    b.e = 3;
+                }
+                else {
+                    b.d = 3;
+                }
+            }
+            if (f.a == 1) {
+                b.n = DeviceUtils.g(2);
+            }
+            else {
+                b.h = DeviceUtils.g(2);
+            }
+            b.aj = BrushUtil.g(255, 200, 200, 200);
+            b.ak = BrushUtil.g(255, 80, 80, 80);
+        }
+        bb(a, b, c, d) {
+            super.bb(a, b, c, d);
+            let e = c.b;
+            if (e.a0 == null || (e.w == null || EnumUtil.getEnumValue(ToolActionType_$type, e.w) != this.f)) {
+                NativeUIComponent.ab(b.l.r(), [7], (f) => {
+                    let g = f[0];
+                    e.a0 = g;
+                    this.be(e, g, a, b, c, d);
+                });
+            }
+            else {
+                let f = e.a0;
+                this.be(e, f, a, b, c, d);
+            }
+        }
+    }
+    ToolActionSeparator.$t = /*@__PURE__*/ markType(ToolActionSeparator, 'ToolActionSeparator', ToolAction.$);
+    return ToolActionSeparator;
+})();
+/**
+ * @hidden
+ */
+export let ToolActionIconButton = /*@__PURE__*/ (() => {
+    class ToolActionIconButton extends ToolAction {
+        constructor() {
+            super(...arguments);
+            this.be = null;
+        }
+        get_f() {
+            return 3;
+        }
+        g() {
+            return null;
+        }
+        b(a) {
+            let b = new ToolActionEventDetail();
+            b.a = this;
+            b.b = this.f;
+            b.d = a;
+            return b;
+        }
+        o(a, b) {
+            return 30;
+        }
+        bg(a, b, c, d, e, f, g) {
+            if (a.w == null || EnumUtil.getEnumValue(ToolActionType_$type, a.w) != this.f) {
+                a.a0 = b;
+                if (g.a == 1) {
+                    b.d = 0;
+                }
+                else {
+                    b.d = 3;
+                }
+                b.a7(0, 2, 1);
+                b.a6(0, 1, isNaN_(g.f) ? 0 : g.f);
+                b.as = new Thickness(1, this.r, this.t, this.s, this.q);
+                if (b.av == 0) {
+                    b.aw(c);
+                }
+                b.bb(c, 0);
+                b.ba(c, 0);
+                this.be = c;
+                this.be.av = 2;
+                this.be.au = runOn(this, this.bf);
+            }
+            this.be.ay = this.am;
+            this.be.ax = this.ak;
+            b.h = f.a.j;
+        }
+        bf(a, b) {
+            this.a9(this.b(true), this);
+        }
+        bb(a, b, c, d) {
+            super.bb(a, b, c, d);
+            let e = c.b;
+            if (e.a0 == null || (e.w == null || EnumUtil.getEnumValue(ToolActionType_$type, e.w) != this.f)) {
+                NativeUIComponent.ab(b.l.r(), [7, 10], (f) => {
+                    let g = f[0];
+                    let h = f[1];
+                    e.a0 = g;
+                    this.bg(e, g, h, a, b, c, d);
+                });
+            }
+            else {
+                let f = e.a0;
+                let g = f.au(0);
+                this.bg(e, f, g, a, b, c, d);
+            }
+        }
+    }
+    ToolActionIconButton.$t = /*@__PURE__*/ markType(ToolActionIconButton, 'ToolActionIconButton', ToolAction.$);
+    return ToolActionIconButton;
+})();
+/**
+ * @hidden
+ */
+export let ToolActionGroupHeader = /*@__PURE__*/ (() => {
+    class ToolActionGroupHeader extends ToolAction {
+        get_f() {
+            return 1;
+        }
+        be(a, b, c, d, e, f, g) {
+            if (a.w == null || EnumUtil.getEnumValue(ToolActionType_$type, a.w) != this.f) {
+                a.a0 = b;
+                if (g.a == 1) {
+                    b.d = 0;
+                }
+                else {
+                    b.d = 3;
+                }
+                b.a7(0, 2, 1);
+                b.a6(0, 1, isNaN_(g.e) ? 0 : g.e);
+                b.a6(1, 2, 1);
+                b.as = new Thickness(1, this.r, this.t, this.s, this.q);
+                if (b.av == 0) {
+                    b.aw(c);
+                }
+                c.e = 1;
+            }
+            b.h = f.a.j;
+            b.aj = BrushUtil.g(255, 200, 200, 200);
+            b.ak = BrushUtil.g(255, 80, 80, 80);
+            b.aq = new Thickness(1, 0, 0, 0, 2);
+            c.au = this.ap;
+            c.al = BrushUtil.g(255, 20, 20, 20);
+            b.bb(c, 0);
+            b.ba(c, 1);
+        }
+        bb(a, b, c, d) {
+            super.bb(a, b, c, d);
+            let e = c.b;
+            if (e.a0 == null || (e.w == null || EnumUtil.getEnumValue(ToolActionType_$type, e.w) != this.f)) {
+                NativeUIComponent.ab(b.l.r(), [7, 3], (f) => {
+                    let g = f[0];
+                    let h = f[1];
+                    e.a0 = g;
+                    this.be(e, g, h, a, b, c, d);
+                });
+            }
+            else {
+                let f = e.a0;
+                let g = f.au(0);
+                this.be(e, f, g, a, b, c, d);
+            }
+        }
+    }
+    ToolActionGroupHeader.$t = /*@__PURE__*/ markType(ToolActionGroupHeader, 'ToolActionGroupHeader', ToolAction.$);
+    return ToolActionGroupHeader;
+})();
+/**
+ * @hidden
+ */
+export let ToolActionMenuBase = /*@__PURE__*/ (() => {
+    class ToolActionMenuBase extends ToolAction {
+        constructor() {
+            super();
+            this.bh = new ToolActionCollection();
+            this.bm = false;
+            this.be = null;
+            this.bk = null;
+            this.bl = false;
+            this.bj = null;
+            this.bo = false;
+            this.bn = false;
+            let a = this.bh;
+            a.collectionChanged = delegateCombine(a.collectionChanged, runOn(this, this.bq));
+        }
+        g() {
+            return null;
+        }
+        a6(a) {
+            super.a6(a);
+            let b = a;
+            if (b.actions != null) {
+                for (let c = 0; c < b.actions.length; c++) {
+                    this.bh.add(ToolAction.a(b.actions[c]));
+                }
+            }
+        }
+        bq(a, b) {
+            this.bv();
+        }
+        bv() {
+        }
+        get actions() {
+            return this.bh;
+        }
+        set actions(a) {
+            let b = this.bh;
+            this.bh = a;
+            if (b != this.bh) {
+                this.a8("Actions", b, this.bh);
+            }
+        }
+        b(a) {
+            let b = new ToolActionEventDetail();
+            b.a = this;
+            b.b = this.f;
+            b.d = a;
+            return b;
+        }
+        bw() {
+            this.bt();
+            this.bs();
+            this.bu();
+            if (this.be.t || this.bn) {
+                if (this.bn) {
+                    this.bn = false;
+                }
+                else {
+                    this.be.ao();
+                }
+            }
+            else {
+                if (this.bo) {
+                    this.bx();
+                }
+                else {
+                    this.bn = true;
+                }
+            }
+        }
+        bx() {
+            this.be.showRelativeToExclusionRect(this.by(), this.bg(), this.bf());
+        }
+        bf() {
+            return 1;
+        }
+        bg() {
+            return 1;
+        }
+        bu() {
+            if (!this.bl) {
+                this.bl = true;
+                this.be.appendPopupContent(this.bk.v);
+            }
+        }
+        bt() {
+            if (this.be == null) {
+                if (this.e == null) {
+                    return;
+                }
+                this.be = this.e.l.a();
+            }
+        }
+        bs() {
+            if (this.bk == null) {
+                NativeUIContent.ac(this.e.l.r(), 0, (a) => this.bk = a);
+                this.bj = this.e.l.b(this.bk);
+                let a = this.bj;
+                a.contentRefreshed = delegateCombine(a.contentRefreshed, runOn(this, this.br));
+                this.bj.actions = this.actions;
+            }
+        }
+        br(a, b) {
+            this.bo = true;
+            this.be.ar();
+            if (this.bn) {
+                this.bn = false;
+                this.bx();
+            }
+        }
+    }
+    ToolActionMenuBase.$t = /*@__PURE__*/ markType(ToolActionMenuBase, 'ToolActionMenuBase', ToolAction.$);
+    return ToolActionMenuBase;
+})();
+/**
+ * @hidden
+ */
+export let ToolActionIconMenu = /*@__PURE__*/ (() => {
+    class ToolActionIconMenu extends ToolActionMenuBase {
+        constructor() {
+            super(...arguments);
+            this.bz = null;
+        }
+        get_f() {
+            return 3;
+        }
+        o(a, b) {
+            return 30;
+        }
+        by() {
+            return this.e.l.ac(this.bz.v);
+        }
+        b1(a, b, c, d, e, f, g) {
+            if (a.w == null || EnumUtil.getEnumValue(ToolActionType_$type, a.w) != this.f) {
+                a.a0 = b;
+                if (g.a == 1) {
+                    b.d = 0;
+                }
+                else {
+                    b.d = 3;
+                }
+                b.a7(0, 2, 1);
+                b.a6(0, 1, isNaN_(g.f) ? 0 : g.f);
+                b.as = new Thickness(1, this.r, this.t, this.s, this.q);
+                if (b.av == 0) {
+                    b.aw(c);
+                }
+                b.bb(c, 0);
+                b.ba(c, 0);
+                this.bz = c;
+                this.bz.av = 2;
+                this.bz.au = runOn(this, this.b0);
+            }
+            this.bz.ay = this.am;
+            this.bz.ax = this.ak;
+            b.h = f.a.j;
+        }
+        b0(a, b) {
+            this.bw();
+        }
+        bb(a, b, c, d) {
+            super.bb(a, b, c, d);
+            let e = c.b;
+            if (e.a0 == null || (e.w == null || EnumUtil.getEnumValue(ToolActionType_$type, e.w) != this.f)) {
+                NativeUIComponent.ab(b.l.r(), [7, 10], (f) => {
+                    let g = f[0];
+                    let h = f[1];
+                    e.a0 = g;
+                    this.b1(e, g, h, a, b, c, d);
+                });
+            }
+            else {
+                let f = e.a0;
+                let g = f.au(0);
+                this.b1(e, f, g, a, b, c, d);
+            }
+        }
+    }
+    ToolActionIconMenu.$t = /*@__PURE__*/ markType(ToolActionIconMenu, 'ToolActionIconMenu', ToolActionMenuBase.$);
+    return ToolActionIconMenu;
+})();
+/**
+ * @hidden
+ */
+export let ToolActionCheckbox = /*@__PURE__*/ (() => {
+    class ToolActionCheckbox extends ToolAction {
+        constructor() {
+            super(...arguments);
+            this.be = null;
+        }
+        get_f() {
+            return 2;
+        }
+        b(a) {
+            let b = new ToolActionEventDetail();
+            b.a = this;
+            b.b = this.f;
+            b.d = a;
+            if (this.be != null) {
+                b.c = this.be.aw;
+            }
+            return b;
+        }
+        x() {
+            return this.be.aw;
+        }
+        o(a, b) {
+            return 30;
+        }
+        bg(a, b, c, d, e, f, g, h) {
+            if (a.w == null || EnumUtil.getEnumValue(ToolActionType_$type, a.w) != this.f) {
+                a.a0 = b;
+                if (h.a == 1) {
+                    b.d = 0;
+                }
+                else {
+                    b.d = 3;
+                }
+                b.a7(0, 2, 1);
+                b.a6(0, 1, isNaN_(h.e) ? 0 : h.e);
+                b.a6(1, 1, isNaN_(h.g) ? 0 : h.g);
+                b.a6(1, 2, 1);
+                b.as = new Thickness(1, this.r, this.t, this.s, this.q);
+                if (b.av == 0) {
+                    b.aw(c);
+                    b.aw(d);
+                }
+                b.bb(c, 0);
+                b.ba(c, 1);
+                b.bb(d, 0);
+                b.ba(d, 2);
+                this.be = d;
+                d.av = true;
+                d.d = 2;
+                d.e = 1;
+                d.au = runOn(this, this.bf);
+                c.e = 1;
+            }
+            b.h = g.a.j;
+            c.au = this.ap;
+            c.al = BrushUtil.g(255, 20, 20, 20);
+        }
+        bf(a, b) {
+            this.a9(this.b(true), this);
+        }
+        bb(a, b, c, d) {
+            super.bb(a, b, c, d);
+            let e = c.b;
+            if (e.a0 == null || (e.w == null || EnumUtil.getEnumValue(ToolActionType_$type, e.w) != this.f)) {
+                NativeUIComponent.ab(b.l.r(), [7, 3, 6], (f) => {
+                    let g = f[0];
+                    let h = f[1];
+                    let i = f[2];
+                    e.a0 = g;
+                    this.bg(e, g, h, i, a, b, c, d);
+                });
+            }
+            else {
+                let f = e.a0;
+                let g = f.au(0);
+                let h = f.au(1);
+                this.bg(e, f, g, h, a, b, c, d);
+            }
+        }
+    }
+    ToolActionCheckbox.$t = /*@__PURE__*/ markType(ToolActionCheckbox, 'ToolActionCheckbox', ToolAction.$);
+    return ToolActionCheckbox;
+})();
+/**
+ * @hidden
+ */
+export let ToolActionNumberInput = /*@__PURE__*/ (() => {
+    class ToolActionNumberInput extends ToolAction {
+        constructor() {
+            super(...arguments);
+            this.be = null;
+        }
+        get_f() {
+            return 5;
+        }
+        x() {
+            return this.bf();
+        }
+        o(a, b) {
+            return 100;
+        }
+        bh(a, b, c, d, e, f, g, h) {
+            if (a.w == null || EnumUtil.getEnumValue(ToolActionType_$type, a.w) != this.f) {
+                a.a0 = b;
+                if (h.a == 1) {
+                    b.d = 0;
+                }
+                else {
+                    b.d = 3;
+                }
+                b.a7(0, 2, 1);
+                b.a6(0, 1, isNaN_(h.e) ? 0 : h.e);
+                b.a6(1, 1, isNaN_(h.g) ? 0 : h.g);
+                b.a6(1, 2, 1);
+                b.as = new Thickness(1, this.r, this.t, this.s, this.q);
+                if (b.av == 0) {
+                    b.aw(c);
+                    b.aw(d);
+                }
+                b.bb(c, 0);
+                b.ba(c, 1);
+                b.bb(d, 0);
+                b.ba(d, 2);
+                this.be = d;
+                d.n = 100;
+                d.au = 2;
+                d.ax = 1;
+                d.d = 2;
+                d.e = 1;
+                d.aw = runOn(this, this.bg);
+                c.e = 1;
+            }
+            b.h = g.a.j;
+            c.au = this.ap;
+            c.al = BrushUtil.g(255, 20, 20, 20);
+        }
+        bf() {
+            let a;
+            a = NaN;
+            if (this.be != null && ((() => { let b = tryParseNumber(this.be.ay, a); a = b.p1; return b.ret; })())) {
+            }
+            return a;
+        }
+        b(a) {
+            let b = new ToolActionEventDetail();
+            b.a = this;
+            b.d = a;
+            b.b = this.f;
+            let c;
+            b.f = this.bf();
+            return b;
+        }
+        bg(a, b) {
+            let c = a;
+            let d = this.b(true);
+            this.a9(d, this);
+        }
+        bb(a, b, c, d) {
+            super.bb(a, b, c, d);
+            let e = c.b;
+            if (e.a0 == null || (e.w == null || EnumUtil.getEnumValue(ToolActionType_$type, e.w) != this.f)) {
+                NativeUIComponent.ab(b.l.r(), [7, 3, 2], (f) => {
+                    let g = f[0];
+                    let h = f[1];
+                    let i = f[2];
+                    e.a0 = g;
+                    this.bh(e, g, h, i, a, b, c, d);
+                });
+            }
+            else {
+                let f = e.a0;
+                let g = f.au(0);
+                let h = f.au(1);
+                this.bh(e, f, g, h, a, b, c, d);
+            }
+        }
+    }
+    ToolActionNumberInput.$t = /*@__PURE__*/ markType(ToolActionNumberInput, 'ToolActionNumberInput', ToolAction.$);
+    return ToolActionNumberInput;
+})();
+/**
+ * @hidden
+ */
+export let ToolActionCollection = /*@__PURE__*/ (() => {
+    class ToolActionCollection extends ObservableCollection$1 {
+        constructor() {
+            super(ToolAction.$, 0);
+        }
+    }
+    ToolActionCollection.$t = /*@__PURE__*/ markType(ToolActionCollection, 'ToolActionCollection', /*@__PURE__*/ ObservableCollection$1.$.specialize(ToolAction.$));
+    return ToolActionCollection;
+})();
+/**
+ * @hidden
+ */
+export let ToolActionPerformedEventArgs = /*@__PURE__*/ (() => {
+    class ToolActionPerformedEventArgs extends Base {
+        constructor() {
+            super();
+            this.c = false;
+            this.a = null;
+            this.b = null;
+            this.b = new ToolActionEventDetailCollection();
+        }
+    }
+    ToolActionPerformedEventArgs.$t = /*@__PURE__*/ markType(ToolActionPerformedEventArgs, 'ToolActionPerformedEventArgs');
+    return ToolActionPerformedEventArgs;
+})();
+/**
+ * @hidden
+ */
+export let ToolActionEventDetail = /*@__PURE__*/ (() => {
+    class ToolActionEventDetail extends Base {
+        constructor() {
+            super(...arguments);
+            this.a = null;
+            this.b = 0;
+            this.d = false;
+            this.c = false;
+            this.f = 0;
+            this.e = new Date();
+            this.g = null;
+        }
+    }
+    ToolActionEventDetail.$t = /*@__PURE__*/ markType(ToolActionEventDetail, 'ToolActionEventDetail');
+    return ToolActionEventDetail;
+})();
+/**
+ * @hidden
+ */
+export let ToolActionEventDetailCollection = /*@__PURE__*/ (() => {
+    class ToolActionEventDetailCollection extends ObservableCollection$1 {
+        constructor() {
+            super(ToolActionEventDetail.$, 0);
+        }
+    }
+    ToolActionEventDetailCollection.$t = /*@__PURE__*/ markType(ToolActionEventDetailCollection, 'ToolActionEventDetailCollection', /*@__PURE__*/ ObservableCollection$1.$.specialize(ToolActionEventDetail.$));
+    return ToolActionEventDetailCollection;
+})();
+/**
+ * @hidden
+ */
+export let ToolPanel = /*@__PURE__*/ (() => {
+    class ToolPanel extends Base {
+        constructor() {
+            super();
+            this.l = null;
+            this.p = null;
+            this.s = false;
+            this.q = null;
+            this.f = new ToolActionMeasurementContext();
+            this.propertyChanged = null;
+            this.d = new ToolActionCollection();
+            this.contentRefreshed = null;
+            this.t = false;
+            this.w = new Dictionary$2(String_$type, List$1.$.specialize(ToolAction.$), 0);
+            this.x = new Dictionary$2(String_$type, List$1.$.specialize(ToolAction.$), 0);
+            this.v = new Dictionary$2(String_$type, ToolAction.$, 0);
+            this.m = null;
+            this.a = null;
+            this.a5 = ToolPanel.a8;
+            this.a6 = ToolPanel.a9;
+            this.b = null;
+            this.z = Number.POSITIVE_INFINITY;
+            this.i = ToolPanel.j;
+            this.onCommand = null;
+            let a = this.actions;
+            a.collectionChanged = delegateCombine(a.collectionChanged, runOn(this, this.ak));
+            NativeUIInputsFactory.m();
+            let b = new ToolPanelView();
+            b.c = this;
+            this.l = b;
+            this.l.x();
+        }
+        get r() {
+            if (this.q == null) {
+                this.q = new SRProvider(this.l.k);
+                this.q.cb("Layouts");
+            }
+            return this.q;
+        }
+        aq(a) {
+            this.b = a;
+            let b = this.b;
+            b.rowUpdating = delegateCombine(b.rowUpdating, runOn(this, this.aj));
+            let c = this.b;
+            c.contentRefreshed = delegateCombine(c.contentRefreshed, runOn(this, this.ag));
+            this.b.k = this.k;
+            this.b.ai = true;
+            let d = this.b;
+            d.itemHeightRequested = delegateCombine(d.itemHeightRequested, runOn(this, this.ah));
+            let e = this.b;
+            e.itemWidthRequested = delegateCombine(e.itemWidthRequested, runOn(this, this.ai));
+        }
+        ag(a, b) {
+            if (this.contentRefreshed != null) {
+                this.contentRefreshed(this, new ToolPanelContentRefreshedEventArgs());
+            }
+        }
+        ah(a, b) {
+            let c = b.c;
+            let d = new ToolActionMeasurementContext();
+            this.az(d);
+            c.a4(this, d);
+            if (!isNaN_(d.c)) {
+                b.a = d.c;
+            }
+            else {
+                b.a = this.b.av;
+            }
+        }
+        ai(a, b) {
+            let c = b.c;
+            let d = new ToolActionMeasurementContext();
+            this.az(d);
+            c.a4(this, d);
+            if (!isNaN_(d.d)) {
+                b.a = d.d;
+            }
+            else {
+            }
+        }
+        aj(a, b) {
+            let c = b.a.n;
+            let d = a;
+            if (this.k == 1) {
+                let e = new ToolActionMeasurementContext();
+                this.az(e);
+                c.a4(this, e);
+                c.ba(d, this, b, e);
+            }
+            else {
+                c.ba(d, this, b, this.f);
+            }
+        }
+        aw(a) {
+            this.z = a.width;
+            this.a2();
+        }
+        get actions() {
+            return this.d;
+        }
+        set actions(a) {
+            let b = this.d;
+            this.d = a;
+            if (b != this.d) {
+                this.ax("Actions", b, this.d);
+            }
+        }
+        ak(a, b) {
+            if (b.oldItems != null) {
+                for (let c of fromEn(b.oldItems)) {
+                    if (typeCast(INotifyPropertyChanged_$type, c) !== null) {
+                        let d = c;
+                        d.propertyChanged = delegateRemove(d.propertyChanged, runOn(this, this.ar));
+                    }
+                }
+            }
+            if (b.newItems != null) {
+                for (let e of fromEn(b.newItems)) {
+                    if (typeCast(INotifyPropertyChanged_$type, e) !== null) {
+                        let f = e;
+                        f.propertyChanged = delegateCombine(f.propertyChanged, runOn(this, this.ar));
+                    }
+                }
+            }
+            this.av();
+        }
+        av() {
+            this.a2();
+        }
+        a2() {
+            if (this.t) {
+                return;
+            }
+            this.t = true;
+            this.a.enqueueAction(runOn(this, this.an));
+        }
+        an() {
+            if (!this.t) {
+                return;
+            }
+            this.t = false;
+            this.al();
+            this.a4();
+            for (let a = 0; a < this.d.count; a++) {
+                this.as(this.d._inner[a]);
+            }
+            this.ao();
+        }
+        al() {
+            this.w.clear();
+            this.x.clear();
+            this.v.clear();
+            for (let a = 0; a < this.d.count; a++) {
+                this.d._inner[a].e = this;
+                if (this.d._inner[a].ao != null) {
+                    this.v.item(this.d._inner[a].ao, this.d._inner[a]);
+                }
+            }
+            for (let b = 0; b < this.d.count; b++) {
+                if (this.d._inner[b].ax != null) {
+                    if (this.v.containsKey(this.d._inner[b].ax)) {
+                        if (!this.w.containsKey(this.d._inner[b].ax)) {
+                            this.w.item(this.d._inner[b].ax, new List$1(ToolAction.$, 0));
+                        }
+                        let c = this.w.item(this.d._inner[b].ax);
+                        c.add(this.d._inner[b]);
+                    }
+                }
+            }
+            for (let d = 0; d < this.d.count; d++) {
+                if (this.d._inner[d].f == 6) {
+                    let e = this.d._inner[d].bf;
+                    if (!this.x.containsKey(e)) {
+                        this.x.item(e, new List$1(ToolAction.$, 0));
+                    }
+                    this.x.item(e).add(this.d._inner[d]);
+                }
+            }
+        }
+        u(a) {
+            if (a.ao == null) {
+                return false;
+            }
+            return this.w.containsKey(a.ao);
+        }
+        c(a) {
+            if (this.v.containsKey(a)) {
+                return this.v.item(a);
+            }
+            return null;
+        }
+        y(a) {
+            if (a.ao == null) {
+                return null;
+            }
+            if (this.w.containsKey(a.ao)) {
+                return this.w.item(a.ao);
+            }
+            return null;
+        }
+        as(a) {
+            let b = new ToolActionMeasurementContext();
+            this.az(b);
+            a.a4(this, b);
+            this.at(this.f, b);
+        }
+        az(a) {
+            a.a = this.k;
+            a.b = this.z;
+        }
+        at(a, b) {
+            if (!isNaN_(b.e)) {
+                if (isNaN_(a.e)) {
+                    a.e = b.e;
+                }
+                else {
+                    a.e = Math.max(a.e, b.e);
+                }
+            }
+            if (!isNaN_(b.g)) {
+                if (isNaN_(a.g)) {
+                    a.g = b.g;
+                }
+                else {
+                    a.g = Math.max(a.g, b.g);
+                }
+            }
+        }
+        a4() {
+            this.f = new ToolActionMeasurementContext();
+            this.f.a = this.k;
+            this.f.b = this.z;
+        }
+        ao() {
+            if (this.b.itemsSource != this.actions) {
+                this.b.itemsSource = this.actions;
+            }
+        }
+        ap() {
+            if (this.t) {
+                this.an();
+            }
+            if (this.b != null) {
+                this.b.bt();
+            }
+        }
+        a3(a) {
+            let b = a.bf;
+            let c = a.ao;
+            if (this.x != null) {
+                if (this.x.containsKey(b)) {
+                    for (let d = 0; d < this.x.item(b).count; d++) {
+                        if (this.x.item(b)._inner[d].ao != c) {
+                            this.x.item(b)._inner[d].bg();
+                        }
+                    }
+                }
+            }
+        }
+        ar(a, b) {
+            this.av();
+        }
+        notifySizeChanged() {
+            this.l.u();
+        }
+        destroy() {
+            this.provideContainer(null);
+        }
+        provideContainer(a) {
+            this.l.v(a);
+        }
+        get n() {
+            return this.m;
+        }
+        set n(a) {
+            let b = this.m;
+            this.m = a;
+            if (b != this.m) {
+                this.ax("CellTextStyle", b, this.m);
+            }
+        }
+        o() {
+            if (this.n == null) {
+                return this.l.f();
+            }
+            return this.n;
+        }
+        ax(a, b, c) {
+            if (this.propertyChanged != null) {
+                this.propertyChanged(this, new PropertyChangedEventArgs(a));
+            }
+            this.a0(a, b, c);
+        }
+        a0(a, b, c) {
+            switch (a) {
+                case "CellTextStyle":
+                    this.a2();
+                    break;
+                case "BackgroundColor":
+                case "TextColor":
+                    this.a2();
+                    break;
+                case "Orientation":
+                    if (this.b != null) {
+                        this.b.k = this.k;
+                    }
+                    break;
+                case "Actions":
+                    if (b != null) {
+                        let d = b;
+                        d.collectionChanged = delegateRemove(d.collectionChanged, runOn(this, this.ak));
+                    }
+                    if (c != null) {
+                        let e = c;
+                        e.collectionChanged = delegateCombine(e.collectionChanged, runOn(this, this.ak));
+                    }
+                    this.a2();
+                    break;
+            }
+        }
+        get a7() {
+            return this.a5;
+        }
+        set a7(a) {
+            let b = this.a5;
+            this.a5 = a;
+            if (b != this.a5) {
+                this.ax("BackgroundColor", b, a);
+            }
+        }
+        get ba() {
+            return this.a6;
+        }
+        set ba(a) {
+            let b = this.a6;
+            this.a6 = a;
+            if (b != this.a6) {
+                this.ax("TextColor", b, a);
+            }
+        }
+        get k() {
+            return this.i;
+        }
+        set k(a) {
+            let b = this.i;
+            this.i = a;
+            if (b != this.i) {
+                this.ax("Orientation", enumGetBox(ToolPanelOrientation_$type, b), enumGetBox(ToolPanelOrientation_$type, a));
+            }
+        }
+        ay(a, b) {
+            if (this.onCommand != null) {
+                this.onCommand(this, ((() => {
+                    let $ret = new ToolCommandEventArgs();
+                    $ret.a = b;
+                    return $ret;
+                })()));
+            }
+            if (a.f == 6) {
+                this.a3(a);
+            }
+        }
+    }
+    ToolPanel.$t = /*@__PURE__*/ markType(ToolPanel, 'ToolPanel', Base.$, [INotifyPropertyChanged_$type]);
+    ToolPanel.a8 = /*@__PURE__*/ BrushUtil.g(255, 248, 248, 248);
+    ToolPanel.a9 = /*@__PURE__*/ BrushUtil.g(255, 24, 29, 31);
+    ToolPanel.j = 0;
+    return ToolPanel;
+})();