igniteui-webcomponents-layouts 3.2.3 → 3.5.0

package/esm5/lib/ToolPanelView_combined.js

@@ -0,0 +1,1853 @@
+/*
+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, 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
+ */
+var ToolPanelView = /** @class */ /*@__PURE__*/ (function (_super) {
+    tslib_1.__extends(ToolPanelView, _super);
+    function ToolPanelView() {
+        var _this = _super.call(this) || this;
+        _this.p = null;
+        _this.o = null;
+        _this.c = null;
+        _this.k = null;
+        _this.n = null;
+        _this.g = null;
+        _this.m = null;
+        _this.d = ((function () {
+            var $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;
+        return _this;
+    }
+    ToolPanelView.prototype.r = function () {
+        return this.k;
+    };
+    ToolPanelView.prototype.x = function () {
+    };
+    ToolPanelView.prototype.v = function (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();
+        var b = new ListPanel();
+        var c = this.k.createElement("div");
+        c.setStyleProperty("width", "100%");
+        c.setStyleProperty("height", "100%");
+        this.k.append(c);
+        var d = this.k.getSubRenderer(c);
+        b.provideContainer(d);
+        var e = this.k.getExternal(b, this.k.rootWrapper, this.k.getExternal(this.c, null, null));
+        b.externalListPanel = e;
+        this.c.aq(b);
+        var f = Math.round(a.rootWrapper.width());
+        var g = Math.round(a.rootWrapper.height());
+        this.k.rootWrapper.setStyleProperty("position", "relative");
+    };
+    ToolPanelView.prototype.aa = function () {
+    };
+    ToolPanelView.prototype.z = function () {
+        if (this.k != null) {
+        }
+    };
+    ToolPanelView.prototype.u = function () {
+        if (this.k == null) {
+            return;
+        }
+        var a = this.k.rootWrapper.width();
+        var b = this.k.rootWrapper.height();
+        this.ad = new Size(1, a, b);
+        if (this.c.p != null) {
+        }
+    };
+    ToolPanelView.prototype.ab = function () {
+        var a = this.k;
+        if (null == a) {
+            return;
+        }
+        var b = a.rootWrapper;
+        if (null != b) {
+            NativeUI.o(b, this.c.ba);
+            NativeUI.k(b, this.c.a7);
+        }
+    };
+    ToolPanelView.prototype.f = function () {
+        return this.d;
+    };
+    ToolPanelView.prototype.w = function () {
+    };
+    ToolPanelView.prototype.y = function () {
+    };
+    ToolPanelView.prototype.t = function () {
+    };
+    ToolPanelView.prototype.i = function () {
+        return this.ad.width;
+    };
+    ToolPanelView.prototype.j = function (a) {
+        this.e = this.c.o();
+        return FontUtil.measureStringWidth(a, this.e, this.g);
+    };
+    ToolPanelView.prototype.s = function (a, b) {
+        if (this.l == null) {
+            this.l = this.k.createElement("div");
+        }
+        b(this.l.getNativeElement());
+    };
+    ToolPanelView.prototype.a = function () {
+        var a = new Popup();
+        var b = this.k.getExternal(a, this.k.rootWrapper, this.k.getExternal(this.c, null, null));
+        return a;
+    };
+    ToolPanelView.prototype.b = function (a) {
+        var b = new ToolPanel();
+        var c = this.k.getExternal(b, this.k.rootWrapper, this.k.getExternal(this.c, null, null));
+        var d = a.v;
+        d.appendChild(b.l.k.rootWrapper.getNativeElement());
+        return b;
+    };
+    ToolPanelView.prototype.ac = function (a) {
+        var ele_ = a;
+        var bounds_ = (ele_.getBoundingClientRect());
+        var b = bounds_["left"];
+        var c = bounds_["top"];
+        var d = bounds_["width"];
+        var e = bounds_["height"];
+        return new Rect(0, b, c, d, e);
+    };
+    ToolPanelView.$t = markType(ToolPanelView, 'ToolPanelView');
+    return ToolPanelView;
+}(Base));
+export { ToolPanelView };
+/**
+ * @hidden
+ */
+var ToolAction = /** @class */ /*@__PURE__*/ (function (_super) {
+    tslib_1.__extends(ToolAction, _super);
+    function ToolAction() {
+        var _this = _super !== null && _super.apply(this, arguments) || this;
+        _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;
+        return _this;
+    }
+    Object.defineProperty(ToolAction.prototype, "ao", {
+        get: function () {
+            if (this.ar != null) {
+                return this.ar;
+            }
+            if (this.ap != null) {
+                return this.a1(this.ap);
+            }
+            return null;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    ToolAction.prototype.a1 = function (a) {
+        return stringReplace(a, " ", "_");
+    };
+    ToolAction.prototype.b = function (a) {
+        var _this = this;
+        return ((function () {
+            var $ret = new ToolActionEventDetail();
+            $ret.a = _this;
+            $ret.d = a;
+            return $ret;
+        })());
+    };
+    ToolAction.prototype.g = function () {
+        var _this = this;
+        return ((function () {
+            var $ret = new ToolCommandArgument();
+            $ret.argumentName = _this.az();
+            $ret.value = _this.w();
+            return $ret;
+        })());
+    };
+    ToolAction.prototype.az = function () {
+        if (this.af != null) {
+            return this.af;
+        }
+        return this.ao != null ? this.ao : "Unknown";
+    };
+    ToolAction.prototype.w = function () {
+        if (this.v != null) {
+            return this.v;
+        }
+        return this.x();
+    };
+    ToolAction.prototype.x = function () {
+        return null;
+    };
+    Object.defineProperty(ToolAction.prototype, "ax", {
+        get: function () {
+            return this.ae;
+        },
+        set: function (a) {
+            var b = this.ae;
+            this.ae = a;
+            if (b != this.ae) {
+                this.a8("ParentId", b, this.ae);
+            }
+        },
+        enumerable: true,
+        configurable: true
+    });
+    ToolAction.prototype.a0 = function () {
+        if (this.ai != null) {
+            return this.ai;
+        }
+        return this.ao;
+    };
+    Object.defineProperty(ToolAction.prototype, "ai", {
+        get: function () {
+            return this.z;
+        },
+        set: function (a) {
+            var b = this.z;
+            this.z = a;
+            if (b != this.z) {
+                this.a8("CommandId", b, this.z);
+            }
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(ToolAction.prototype, "af", {
+        get: function () {
+            return this.y;
+        },
+        set: function (a) {
+            var b = this.y;
+            this.y = a;
+            if (b != this.y) {
+                this.a8("CommandArgument", b, this.y);
+            }
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(ToolAction.prototype, "v", {
+        get: function () {
+            return this.u;
+        },
+        set: function (a) {
+            var b = this.u;
+            this.u = a;
+            if (b != this.u) {
+                this.a8("CommandArgumentValue", b, this.u);
+            }
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(ToolAction.prototype, "r", {
+        get: function () {
+            return this.k;
+        },
+        set: function (a) {
+            var b = this.k;
+            this.k = a;
+            if (b != this.k) {
+                this.a8("PaddingLeft", b, this.k);
+            }
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(ToolAction.prototype, "s", {
+        get: function () {
+            return this.l;
+        },
+        set: function (a) {
+            var b = this.l;
+            this.l = a;
+            if (b != this.l) {
+                this.a8("PaddingRight", b, this.l);
+            }
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(ToolAction.prototype, "q", {
+        get: function () {
+            return this.j;
+        },
+        set: function (a) {
+            var b = this.j;
+            this.j = a;
+            if (b != this.j) {
+                this.a8("PaddingBottom", b, this.j);
+            }
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(ToolAction.prototype, "t", {
+        get: function () {
+            return this.m;
+        },
+        set: function (a) {
+            var b = this.m;
+            this.m = a;
+            if (b != this.m) {
+                this.a8("PaddingTop", b, this.m);
+            }
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(ToolAction.prototype, "i", {
+        get: function () {
+            return this.ax != null;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(ToolAction.prototype, "ar", {
+        get: function () {
+            return this.ad;
+        },
+        set: function (a) {
+            var b = this.ad;
+            this.ad = a;
+            if (b != this.ad) {
+                this.a8("Name", b, this.ad);
+            }
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(ToolAction.prototype, "ap", {
+        get: function () {
+            return this.ac;
+        },
+        set: function (a) {
+            var b = this.ac;
+            this.ac = a;
+            if (b != this.ac) {
+                this.a8("Label", b, this.ac);
+            }
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(ToolAction.prototype, "am", {
+        get: function () {
+            return this.ab;
+        },
+        set: function (a) {
+            var b = this.ab;
+            this.ab = a;
+            if (b != this.ab) {
+                this.a8("IconName", b, this.ab);
+            }
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(ToolAction.prototype, "ak", {
+        get: function () {
+            return this.aa;
+        },
+        set: function (a) {
+            var b = this.aa;
+            this.aa = a;
+            if (b != this.aa) {
+                this.a8("IconCollectionName", b, this.aa);
+            }
+        },
+        enumerable: true,
+        configurable: true
+    });
+    ToolAction.prototype.a8 = function (a, b, c) {
+        if (this.propertyChanged != null) {
+            this.propertyChanged(this, new PropertyChangedEventArgs(a));
+        }
+        this.bc(a, b, c);
+    };
+    ToolAction.prototype.get_f = function () {
+        return 0;
+    };
+    Object.defineProperty(ToolAction.prototype, "f", {
+        get: function () {
+            return this.get_f();
+        },
+        enumerable: true,
+        configurable: true
+    });
+    ToolAction.prototype.bc = function (a, b, c) {
+    };
+    ToolAction.prototype.ba = function (a, b, c, d) {
+        this.bb(a, b, c, d);
+    };
+    ToolAction.prototype.bb = function (a, b, c, d) {
+    };
+    ToolAction.prototype.a4 = function (a, b) {
+        this.a5(a, b);
+    };
+    ToolAction.prototype.a5 = function (a, b) {
+        b.e = this.n(a, b);
+        b.g = this.p(a, b);
+        b.f = this.o(a, b);
+        if (b.a == 1) {
+            var 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;
+        }
+    };
+    ToolAction.prototype.o = function (a, b) {
+        return NaN;
+    };
+    ToolAction.prototype.p = function (a, b) {
+        if (this.ap == null) {
+            return NaN;
+        }
+        var c = a.l.j(this.ap);
+        return c;
+    };
+    ToolAction.prototype.n = function (a, b) {
+        return NaN;
+    };
+    ToolAction.prototype.a9 = function (a, b) {
+        this.bd();
+        if (this.i) {
+            var c = this.e.c(this.ax);
+            if (c != null) {
+                c.a7(this);
+            }
+        }
+        else {
+            if (this.e.u(this)) {
+                if (this.performed != null) {
+                    var d_1 = new ToolActionEventDetailCollection();
+                    this.a3(this, d_1, b);
+                    this.performed(this, ((function () {
+                        var $ret = new ToolActionPerformedEventArgs();
+                        $ret.c = true;
+                        $ret.b = d_1;
+                        return $ret;
+                    })()));
+                }
+            }
+            else {
+                if (this.performed != null) {
+                    this.performed(this, ((function () {
+                        var $ret = new ToolActionPerformedEventArgs();
+                        $ret.c = false;
+                        $ret.a = a;
+                        return $ret;
+                    })()));
+                }
+            }
+        }
+    };
+    ToolAction.prototype.bd = function () {
+        var a = this.a0();
+        if (a == null) {
+            return;
+        }
+        var b = new ToolCommand();
+        b.commandId = a;
+        var c = new List$1(ToolCommandArgument.$, 0);
+        this.a2(this, c);
+        b.argumentsList = c.toArray();
+        if (this.onCommand != null) {
+            this.onCommand(this, ((function () {
+                var $ret = new ToolCommandEventArgs();
+                $ret.a = b;
+                return $ret;
+            })()));
+        }
+        if (this.e != null) {
+            this.e.ay(this, b);
+        }
+    };
+    ToolAction.prototype.a2 = function (a, b) {
+        var c = a.g();
+        if (c != null) {
+            b.add(c);
+        }
+        var d = this.e.y(a);
+        if (d != null) {
+            for (var e = 0; e < d.count; e++) {
+                if (d._inner[e].h()) {
+                    this.a2(d._inner[e], b);
+                }
+            }
+        }
+    };
+    ToolAction.prototype.h = function () {
+        return true;
+    };
+    ToolAction.prototype.a7 = function (a) {
+        if (this.i) {
+            var b = this.e.c(this.ax);
+            if (b != null) {
+                b.a7(a);
+            }
+        }
+        else {
+            this.a9(this.b(false), a);
+        }
+    };
+    ToolAction.prototype.a3 = function (a, b, c) {
+        var d = a.b(a == c);
+        b.add(d);
+        var e = this.e.y(a);
+        if (e != null) {
+            for (var f = 0; f < e.count; f++) {
+                this.a3(e._inner[f], b, c);
+            }
+        }
+    };
+    ToolAction.a = function (a) {
+        var 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;
+    };
+    ToolAction.prototype.a6 = function (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 = markType(ToolAction, 'ToolAction', Base.$, [INotifyPropertyChanged_$type]);
+    return ToolAction;
+}(Base));
+export { ToolAction };
+/**
+ * @hidden
+ */
+var ToolActionLabel = /** @class */ /*@__PURE__*/ (function (_super) {
+    tslib_1.__extends(ToolActionLabel, _super);
+    function ToolActionLabel() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    ToolActionLabel.prototype.get_f = function () {
+        return 4;
+    };
+    ToolActionLabel.prototype.bf = function (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);
+    };
+    ToolActionLabel.prototype.be = function (a, b) {
+        this.a9(this.b(false), this);
+    };
+    ToolActionLabel.prototype.bb = function (a, b, c, d) {
+        var _this = this;
+        _super.prototype.bb.call(this, a, b, c, d);
+        var 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], function (f) {
+                var g = f[0];
+                var h = f[1];
+                e.a0 = g;
+                _this.bf(e, g, h, a, b, c, d);
+            });
+            ;
+        }
+        else {
+            var f = e.a0;
+            var g = f.au(0);
+            this.bf(e, f, g, a, b, c, d);
+        }
+    };
+    ToolActionLabel.$t = markType(ToolActionLabel, 'ToolActionLabel', ToolAction.$);
+    return ToolActionLabel;
+}(ToolAction));
+export { ToolActionLabel };
+/**
+ * @hidden
+ */
+var ToolActionRadio = /** @class */ /*@__PURE__*/ (function (_super) {
+    tslib_1.__extends(ToolActionRadio, _super);
+    function ToolActionRadio() {
+        var _this = _super !== null && _super.apply(this, arguments) || this;
+        _this.bf = null;
+        _this.be = null;
+        return _this;
+    }
+    ToolActionRadio.prototype.get_f = function () {
+        return 6;
+    };
+    ToolActionRadio.prototype.b = function (a) {
+        var b = new ToolActionEventDetail();
+        b.a = this;
+        b.b = this.f;
+        b.d = a;
+        if (this.be != null) {
+            b.c = this.be.aw;
+        }
+        return b;
+    };
+    ToolActionRadio.prototype.x = function () {
+        return this.be.aw;
+    };
+    ToolActionRadio.prototype.bg = function () {
+        if (this.be != null) {
+            this.be.aw = false;
+        }
+    };
+    ToolActionRadio.prototype.o = function (a, b) {
+        return 30;
+    };
+    ToolActionRadio.prototype.bi = function (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);
+    };
+    ToolActionRadio.prototype.bh = function (a, b) {
+        this.a9(this.b(true), this);
+    };
+    ToolActionRadio.prototype.bb = function (a, b, c, d) {
+        var _this = this;
+        _super.prototype.bb.call(this, a, b, c, d);
+        var 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], function (f) {
+                var g = f[0];
+                var h = f[1];
+                var i = f[2];
+                e.a0 = g;
+                _this.bi(e, g, h, i, a, b, c, d);
+            });
+        }
+        else {
+            var f = e.a0;
+            var g = f.au(0);
+            var h = f.au(1);
+            this.bi(e, f, g, h, a, b, c, d);
+        }
+    };
+    ToolActionRadio.$t = markType(ToolActionRadio, 'ToolActionRadio', ToolAction.$);
+    return ToolActionRadio;
+}(ToolAction));
+export { ToolActionRadio };
+/**
+ * @hidden
+ */
+var ToolActionSeparator = /** @class */ /*@__PURE__*/ (function (_super) {
+    tslib_1.__extends(ToolActionSeparator, _super);
+    function ToolActionSeparator() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    ToolActionSeparator.prototype.get_f = function () {
+        return 7;
+    };
+    ToolActionSeparator.prototype.a5 = function (a, b) {
+        _super.prototype.a5.call(this, a, b);
+        if (b.a == 1) {
+            b.d = 2;
+        }
+        else {
+            b.c = 2;
+        }
+    };
+    ToolActionSeparator.prototype.be = function (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);
+    };
+    ToolActionSeparator.prototype.bb = function (a, b, c, d) {
+        var _this = this;
+        _super.prototype.bb.call(this, a, b, c, d);
+        var e = c.b;
+        if (e.a0 == null || (e.w == null || EnumUtil.getEnumValue(ToolActionType_$type, e.w) != this.f)) {
+            NativeUIComponent.ab(b.l.r(), [7], function (f) {
+                var g = f[0];
+                e.a0 = g;
+                _this.be(e, g, a, b, c, d);
+            });
+        }
+        else {
+            var f = e.a0;
+            this.be(e, f, a, b, c, d);
+        }
+    };
+    ToolActionSeparator.$t = markType(ToolActionSeparator, 'ToolActionSeparator', ToolAction.$);
+    return ToolActionSeparator;
+}(ToolAction));
+export { ToolActionSeparator };
+/**
+ * @hidden
+ */
+var ToolActionIconButton = /** @class */ /*@__PURE__*/ (function (_super) {
+    tslib_1.__extends(ToolActionIconButton, _super);
+    function ToolActionIconButton() {
+        var _this = _super !== null && _super.apply(this, arguments) || this;
+        _this.be = null;
+        return _this;
+    }
+    ToolActionIconButton.prototype.get_f = function () {
+        return 3;
+    };
+    ToolActionIconButton.prototype.g = function () {
+        return null;
+    };
+    ToolActionIconButton.prototype.b = function (a) {
+        var b = new ToolActionEventDetail();
+        b.a = this;
+        b.b = this.f;
+        b.d = a;
+        return b;
+    };
+    ToolActionIconButton.prototype.o = function (a, b) {
+        return 30;
+    };
+    ToolActionIconButton.prototype.bg = function (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;
+    };
+    ToolActionIconButton.prototype.bf = function (a, b) {
+        this.a9(this.b(true), this);
+    };
+    ToolActionIconButton.prototype.bb = function (a, b, c, d) {
+        var _this = this;
+        _super.prototype.bb.call(this, a, b, c, d);
+        var 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], function (f) {
+                var g = f[0];
+                var h = f[1];
+                e.a0 = g;
+                _this.bg(e, g, h, a, b, c, d);
+            });
+        }
+        else {
+            var f = e.a0;
+            var g = f.au(0);
+            this.bg(e, f, g, a, b, c, d);
+        }
+    };
+    ToolActionIconButton.$t = markType(ToolActionIconButton, 'ToolActionIconButton', ToolAction.$);
+    return ToolActionIconButton;
+}(ToolAction));
+export { ToolActionIconButton };
+/**
+ * @hidden
+ */
+var ToolActionGroupHeader = /** @class */ /*@__PURE__*/ (function (_super) {
+    tslib_1.__extends(ToolActionGroupHeader, _super);
+    function ToolActionGroupHeader() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    ToolActionGroupHeader.prototype.get_f = function () {
+        return 1;
+    };
+    ToolActionGroupHeader.prototype.be = function (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);
+    };
+    ToolActionGroupHeader.prototype.bb = function (a, b, c, d) {
+        var _this = this;
+        _super.prototype.bb.call(this, a, b, c, d);
+        var 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], function (f) {
+                var g = f[0];
+                var h = f[1];
+                e.a0 = g;
+                _this.be(e, g, h, a, b, c, d);
+            });
+        }
+        else {
+            var f = e.a0;
+            var g = f.au(0);
+            this.be(e, f, g, a, b, c, d);
+        }
+    };
+    ToolActionGroupHeader.$t = markType(ToolActionGroupHeader, 'ToolActionGroupHeader', ToolAction.$);
+    return ToolActionGroupHeader;
+}(ToolAction));
+export { ToolActionGroupHeader };
+/**
+ * @hidden
+ */
+var ToolActionMenuBase = /** @class */ /*@__PURE__*/ (function (_super) {
+    tslib_1.__extends(ToolActionMenuBase, _super);
+    function ToolActionMenuBase() {
+        var _this = _super.call(this) || this;
+        _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;
+        var a = _this.bh;
+        a.collectionChanged = delegateCombine(a.collectionChanged, runOn(_this, _this.bq));
+        return _this;
+    }
+    ToolActionMenuBase.prototype.g = function () {
+        return null;
+    };
+    ToolActionMenuBase.prototype.a6 = function (a) {
+        _super.prototype.a6.call(this, a);
+        var b = a;
+        if (b.actions != null) {
+            for (var c = 0; c < b.actions.length; c++) {
+                this.bh.add(ToolAction.a(b.actions[c]));
+            }
+        }
+    };
+    ToolActionMenuBase.prototype.bq = function (a, b) {
+        this.bv();
+    };
+    ToolActionMenuBase.prototype.bv = function () {
+    };
+    Object.defineProperty(ToolActionMenuBase.prototype, "actions", {
+        get: function () {
+            return this.bh;
+        },
+        set: function (a) {
+            var b = this.bh;
+            this.bh = a;
+            if (b != this.bh) {
+                this.a8("Actions", b, this.bh);
+            }
+        },
+        enumerable: true,
+        configurable: true
+    });
+    ToolActionMenuBase.prototype.b = function (a) {
+        var b = new ToolActionEventDetail();
+        b.a = this;
+        b.b = this.f;
+        b.d = a;
+        return b;
+    };
+    ToolActionMenuBase.prototype.bw = function () {
+        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;
+            }
+        }
+    };
+    ToolActionMenuBase.prototype.bx = function () {
+        this.be.showRelativeToExclusionRect(this.by(), this.bg(), this.bf());
+    };
+    ToolActionMenuBase.prototype.bf = function () {
+        return 1;
+    };
+    ToolActionMenuBase.prototype.bg = function () {
+        return 1;
+    };
+    ToolActionMenuBase.prototype.bu = function () {
+        if (!this.bl) {
+            this.bl = true;
+            this.be.appendPopupContent(this.bk.v);
+        }
+    };
+    ToolActionMenuBase.prototype.bt = function () {
+        if (this.be == null) {
+            if (this.e == null) {
+                return;
+            }
+            this.be = this.e.l.a();
+        }
+    };
+    ToolActionMenuBase.prototype.bs = function () {
+        var _this = this;
+        if (this.bk == null) {
+            NativeUIContent.ac(this.e.l.r(), 0, function (a) { return _this.bk = a; });
+            this.bj = this.e.l.b(this.bk);
+            var a = this.bj;
+            a.contentRefreshed = delegateCombine(a.contentRefreshed, runOn(this, this.br));
+            this.bj.actions = this.actions;
+        }
+    };
+    ToolActionMenuBase.prototype.br = function (a, b) {
+        this.bo = true;
+        this.be.ar();
+        if (this.bn) {
+            this.bn = false;
+            this.bx();
+        }
+    };
+    ToolActionMenuBase.$t = markType(ToolActionMenuBase, 'ToolActionMenuBase', ToolAction.$);
+    return ToolActionMenuBase;
+}(ToolAction));
+export { ToolActionMenuBase };
+/**
+ * @hidden
+ */
+var ToolActionIconMenu = /** @class */ /*@__PURE__*/ (function (_super) {
+    tslib_1.__extends(ToolActionIconMenu, _super);
+    function ToolActionIconMenu() {
+        var _this = _super !== null && _super.apply(this, arguments) || this;
+        _this.bz = null;
+        return _this;
+    }
+    ToolActionIconMenu.prototype.get_f = function () {
+        return 3;
+    };
+    ToolActionIconMenu.prototype.o = function (a, b) {
+        return 30;
+    };
+    ToolActionIconMenu.prototype.by = function () {
+        return this.e.l.ac(this.bz.v);
+    };
+    ToolActionIconMenu.prototype.b1 = function (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;
+    };
+    ToolActionIconMenu.prototype.b0 = function (a, b) {
+        this.bw();
+    };
+    ToolActionIconMenu.prototype.bb = function (a, b, c, d) {
+        var _this = this;
+        _super.prototype.bb.call(this, a, b, c, d);
+        var 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], function (f) {
+                var g = f[0];
+                var h = f[1];
+                e.a0 = g;
+                _this.b1(e, g, h, a, b, c, d);
+            });
+        }
+        else {
+            var f = e.a0;
+            var g = f.au(0);
+            this.b1(e, f, g, a, b, c, d);
+        }
+    };
+    ToolActionIconMenu.$t = markType(ToolActionIconMenu, 'ToolActionIconMenu', ToolActionMenuBase.$);
+    return ToolActionIconMenu;
+}(ToolActionMenuBase));
+export { ToolActionIconMenu };
+/**
+ * @hidden
+ */
+var ToolActionCheckbox = /** @class */ /*@__PURE__*/ (function (_super) {
+    tslib_1.__extends(ToolActionCheckbox, _super);
+    function ToolActionCheckbox() {
+        var _this = _super !== null && _super.apply(this, arguments) || this;
+        _this.be = null;
+        return _this;
+    }
+    ToolActionCheckbox.prototype.get_f = function () {
+        return 2;
+    };
+    ToolActionCheckbox.prototype.b = function (a) {
+        var b = new ToolActionEventDetail();
+        b.a = this;
+        b.b = this.f;
+        b.d = a;
+        if (this.be != null) {
+            b.c = this.be.aw;
+        }
+        return b;
+    };
+    ToolActionCheckbox.prototype.x = function () {
+        return this.be.aw;
+    };
+    ToolActionCheckbox.prototype.o = function (a, b) {
+        return 30;
+    };
+    ToolActionCheckbox.prototype.bg = function (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);
+    };
+    ToolActionCheckbox.prototype.bf = function (a, b) {
+        this.a9(this.b(true), this);
+    };
+    ToolActionCheckbox.prototype.bb = function (a, b, c, d) {
+        var _this = this;
+        _super.prototype.bb.call(this, a, b, c, d);
+        var 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], function (f) {
+                var g = f[0];
+                var h = f[1];
+                var i = f[2];
+                e.a0 = g;
+                _this.bg(e, g, h, i, a, b, c, d);
+            });
+        }
+        else {
+            var f = e.a0;
+            var g = f.au(0);
+            var h = f.au(1);
+            this.bg(e, f, g, h, a, b, c, d);
+        }
+    };
+    ToolActionCheckbox.$t = markType(ToolActionCheckbox, 'ToolActionCheckbox', ToolAction.$);
+    return ToolActionCheckbox;
+}(ToolAction));
+export { ToolActionCheckbox };
+/**
+ * @hidden
+ */
+var ToolActionNumberInput = /** @class */ /*@__PURE__*/ (function (_super) {
+    tslib_1.__extends(ToolActionNumberInput, _super);
+    function ToolActionNumberInput() {
+        var _this = _super !== null && _super.apply(this, arguments) || this;
+        _this.be = null;
+        return _this;
+    }
+    ToolActionNumberInput.prototype.get_f = function () {
+        return 5;
+    };
+    ToolActionNumberInput.prototype.x = function () {
+        return this.bf();
+    };
+    ToolActionNumberInput.prototype.o = function (a, b) {
+        return 100;
+    };
+    ToolActionNumberInput.prototype.bh = function (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);
+    };
+    ToolActionNumberInput.prototype.bf = function () {
+        var _this = this;
+        var a;
+        a = NaN;
+        if (this.be != null && ((function () { var b = tryParseNumber(_this.be.ay, a); a = b.p1; return b.ret; })())) {
+        }
+        return a;
+    };
+    ToolActionNumberInput.prototype.b = function (a) {
+        var b = new ToolActionEventDetail();
+        b.a = this;
+        b.d = a;
+        b.b = this.f;
+        var c;
+        b.f = this.bf();
+        return b;
+    };
+    ToolActionNumberInput.prototype.bg = function (a, b) {
+        var c = a;
+        var d = this.b(true);
+        this.a9(d, this);
+    };
+    ToolActionNumberInput.prototype.bb = function (a, b, c, d) {
+        var _this = this;
+        _super.prototype.bb.call(this, a, b, c, d);
+        var 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], function (f) {
+                var g = f[0];
+                var h = f[1];
+                var i = f[2];
+                e.a0 = g;
+                _this.bh(e, g, h, i, a, b, c, d);
+            });
+        }
+        else {
+            var f = e.a0;
+            var g = f.au(0);
+            var h = f.au(1);
+            this.bh(e, f, g, h, a, b, c, d);
+        }
+    };
+    ToolActionNumberInput.$t = markType(ToolActionNumberInput, 'ToolActionNumberInput', ToolAction.$);
+    return ToolActionNumberInput;
+}(ToolAction));
+export { ToolActionNumberInput };
+/**
+ * @hidden
+ */
+var ToolActionCollection = /** @class */ /*@__PURE__*/ (function (_super) {
+    tslib_1.__extends(ToolActionCollection, _super);
+    function ToolActionCollection() {
+        return _super.call(this, ToolAction.$, 0) || this;
+    }
+    ToolActionCollection.$t = markType(ToolActionCollection, 'ToolActionCollection', ObservableCollection$1.$.specialize(ToolAction.$));
+    return ToolActionCollection;
+}(ObservableCollection$1));
+export { ToolActionCollection };
+/**
+ * @hidden
+ */
+var ToolActionPerformedEventArgs = /** @class */ /*@__PURE__*/ (function (_super) {
+    tslib_1.__extends(ToolActionPerformedEventArgs, _super);
+    function ToolActionPerformedEventArgs() {
+        var _this = _super.call(this) || this;
+        _this.c = false;
+        _this.a = null;
+        _this.b = null;
+        _this.b = new ToolActionEventDetailCollection();
+        return _this;
+    }
+    ToolActionPerformedEventArgs.$t = markType(ToolActionPerformedEventArgs, 'ToolActionPerformedEventArgs');
+    return ToolActionPerformedEventArgs;
+}(Base));
+export { ToolActionPerformedEventArgs };
+/**
+ * @hidden
+ */
+var ToolActionEventDetail = /** @class */ /*@__PURE__*/ (function (_super) {
+    tslib_1.__extends(ToolActionEventDetail, _super);
+    function ToolActionEventDetail() {
+        var _this = _super !== null && _super.apply(this, arguments) || this;
+        _this.a = null;
+        _this.b = 0;
+        _this.d = false;
+        _this.c = false;
+        _this.f = 0;
+        _this.e = new Date();
+        _this.g = null;
+        return _this;
+    }
+    ToolActionEventDetail.$t = markType(ToolActionEventDetail, 'ToolActionEventDetail');
+    return ToolActionEventDetail;
+}(Base));
+export { ToolActionEventDetail };
+/**
+ * @hidden
+ */
+var ToolActionEventDetailCollection = /** @class */ /*@__PURE__*/ (function (_super) {
+    tslib_1.__extends(ToolActionEventDetailCollection, _super);
+    function ToolActionEventDetailCollection() {
+        return _super.call(this, ToolActionEventDetail.$, 0) || this;
+    }
+    ToolActionEventDetailCollection.$t = markType(ToolActionEventDetailCollection, 'ToolActionEventDetailCollection', ObservableCollection$1.$.specialize(ToolActionEventDetail.$));
+    return ToolActionEventDetailCollection;
+}(ObservableCollection$1));
+export { ToolActionEventDetailCollection };
+/**
+ * @hidden
+ */
+var ToolPanel = /** @class */ /*@__PURE__*/ (function (_super) {
+    tslib_1.__extends(ToolPanel, _super);
+    function ToolPanel() {
+        var _this = _super.call(this) || this;
+        _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;
+        var a = _this.actions;
+        a.collectionChanged = delegateCombine(a.collectionChanged, runOn(_this, _this.ak));
+        NativeUIInputsFactory.m();
+        var b = new ToolPanelView();
+        b.c = _this;
+        _this.l = b;
+        _this.l.x();
+        return _this;
+    }
+    Object.defineProperty(ToolPanel.prototype, "r", {
+        get: function () {
+            if (this.q == null) {
+                this.q = new SRProvider(this.l.k);
+                this.q.cb("Layouts");
+            }
+            return this.q;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    ToolPanel.prototype.aq = function (a) {
+        this.b = a;
+        var b = this.b;
+        b.rowUpdating = delegateCombine(b.rowUpdating, runOn(this, this.aj));
+        var c = this.b;
+        c.contentRefreshed = delegateCombine(c.contentRefreshed, runOn(this, this.ag));
+        this.b.k = this.k;
+        this.b.ai = true;
+        var d = this.b;
+        d.itemHeightRequested = delegateCombine(d.itemHeightRequested, runOn(this, this.ah));
+        var e = this.b;
+        e.itemWidthRequested = delegateCombine(e.itemWidthRequested, runOn(this, this.ai));
+    };
+    ToolPanel.prototype.ag = function (a, b) {
+        if (this.contentRefreshed != null) {
+            this.contentRefreshed(this, new ToolPanelContentRefreshedEventArgs());
+        }
+    };
+    ToolPanel.prototype.ah = function (a, b) {
+        var c = b.c;
+        var d = new ToolActionMeasurementContext();
+        this.az(d);
+        c.a4(this, d);
+        if (!isNaN_(d.c)) {
+            b.a = d.c;
+        }
+        else {
+            b.a = this.b.av;
+        }
+    };
+    ToolPanel.prototype.ai = function (a, b) {
+        var c = b.c;
+        var d = new ToolActionMeasurementContext();
+        this.az(d);
+        c.a4(this, d);
+        if (!isNaN_(d.d)) {
+            b.a = d.d;
+        }
+        else {
+        }
+    };
+    ToolPanel.prototype.aj = function (a, b) {
+        var c = b.a.n;
+        var d = a;
+        if (this.k == 1) {
+            var e = new ToolActionMeasurementContext();
+            this.az(e);
+            c.a4(this, e);
+            c.ba(d, this, b, e);
+        }
+        else {
+            c.ba(d, this, b, this.f);
+        }
+    };
+    ToolPanel.prototype.aw = function (a) {
+        this.z = a.width;
+        this.a2();
+    };
+    Object.defineProperty(ToolPanel.prototype, "actions", {
+        get: function () {
+            return this.d;
+        },
+        set: function (a) {
+            var b = this.d;
+            this.d = a;
+            if (b != this.d) {
+                this.ax("Actions", b, this.d);
+            }
+        },
+        enumerable: true,
+        configurable: true
+    });
+    ToolPanel.prototype.ak = function (a, b) {
+        var e_1, _a, e_2, _b;
+        if (b.oldItems != null) {
+            try {
+                for (var _c = tslib_1.__values(fromEn(b.oldItems)), _d = _c.next(); !_d.done; _d = _c.next()) {
+                    var c = _d.value;
+                    if (typeCast(INotifyPropertyChanged_$type, c) !== null) {
+                        var d = c;
+                        d.propertyChanged = delegateRemove(d.propertyChanged, runOn(this, this.ar));
+                    }
+                }
+            }
+            catch (e_1_1) {
+                e_1 = { error: e_1_1 };
+            }
+            finally {
+                try {
+                    if (_d && !_d.done && (_a = _c.return))
+                        _a.call(_c);
+                }
+                finally {
+                    if (e_1)
+                        throw e_1.error;
+                }
+            }
+        }
+        if (b.newItems != null) {
+            try {
+                for (var _e = tslib_1.__values(fromEn(b.newItems)), _f = _e.next(); !_f.done; _f = _e.next()) {
+                    var e = _f.value;
+                    if (typeCast(INotifyPropertyChanged_$type, e) !== null) {
+                        var f = e;
+                        f.propertyChanged = delegateCombine(f.propertyChanged, runOn(this, this.ar));
+                    }
+                }
+            }
+            catch (e_2_1) {
+                e_2 = { error: e_2_1 };
+            }
+            finally {
+                try {
+                    if (_f && !_f.done && (_b = _e.return))
+                        _b.call(_e);
+                }
+                finally {
+                    if (e_2)
+                        throw e_2.error;
+                }
+            }
+        }
+        this.av();
+    };
+    ToolPanel.prototype.av = function () {
+        this.a2();
+    };
+    ToolPanel.prototype.a2 = function () {
+        if (this.t) {
+            return;
+        }
+        this.t = true;
+        this.a.enqueueAction(runOn(this, this.an));
+    };
+    ToolPanel.prototype.an = function () {
+        if (!this.t) {
+            return;
+        }
+        this.t = false;
+        this.al();
+        this.a4();
+        for (var a = 0; a < this.d.count; a++) {
+            this.as(this.d._inner[a]);
+        }
+        this.ao();
+    };
+    ToolPanel.prototype.al = function () {
+        this.w.clear();
+        this.x.clear();
+        this.v.clear();
+        for (var 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 (var 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));
+                    }
+                    var c = this.w.item(this.d._inner[b].ax);
+                    c.add(this.d._inner[b]);
+                }
+            }
+        }
+        for (var d = 0; d < this.d.count; d++) {
+            if (this.d._inner[d].f == 6) {
+                var 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]);
+            }
+        }
+    };
+    ToolPanel.prototype.u = function (a) {
+        if (a.ao == null) {
+            return false;
+        }
+        return this.w.containsKey(a.ao);
+    };
+    ToolPanel.prototype.c = function (a) {
+        if (this.v.containsKey(a)) {
+            return this.v.item(a);
+        }
+        return null;
+    };
+    ToolPanel.prototype.y = function (a) {
+        if (a.ao == null) {
+            return null;
+        }
+        if (this.w.containsKey(a.ao)) {
+            return this.w.item(a.ao);
+        }
+        return null;
+    };
+    ToolPanel.prototype.as = function (a) {
+        var b = new ToolActionMeasurementContext();
+        this.az(b);
+        a.a4(this, b);
+        this.at(this.f, b);
+    };
+    ToolPanel.prototype.az = function (a) {
+        a.a = this.k;
+        a.b = this.z;
+    };
+    ToolPanel.prototype.at = function (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);
+            }
+        }
+    };
+    ToolPanel.prototype.a4 = function () {
+        this.f = new ToolActionMeasurementContext();
+        this.f.a = this.k;
+        this.f.b = this.z;
+    };
+    ToolPanel.prototype.ao = function () {
+        if (this.b.itemsSource != this.actions) {
+            this.b.itemsSource = this.actions;
+        }
+    };
+    ToolPanel.prototype.ap = function () {
+        if (this.t) {
+            this.an();
+        }
+        if (this.b != null) {
+            this.b.bt();
+        }
+    };
+    ToolPanel.prototype.a3 = function (a) {
+        var b = a.bf;
+        var c = a.ao;
+        if (this.x != null) {
+            if (this.x.containsKey(b)) {
+                for (var 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();
+                    }
+                }
+            }
+        }
+    };
+    ToolPanel.prototype.ar = function (a, b) {
+        this.av();
+    };
+    ToolPanel.prototype.notifySizeChanged = function () {
+        this.l.u();
+    };
+    ToolPanel.prototype.destroy = function () {
+        this.provideContainer(null);
+    };
+    ToolPanel.prototype.provideContainer = function (a) {
+        this.l.v(a);
+    };
+    Object.defineProperty(ToolPanel.prototype, "n", {
+        get: function () {
+            return this.m;
+        },
+        set: function (a) {
+            var b = this.m;
+            this.m = a;
+            if (b != this.m) {
+                this.ax("CellTextStyle", b, this.m);
+            }
+        },
+        enumerable: true,
+        configurable: true
+    });
+    ToolPanel.prototype.o = function () {
+        if (this.n == null) {
+            return this.l.f();
+        }
+        return this.n;
+    };
+    ToolPanel.prototype.ax = function (a, b, c) {
+        if (this.propertyChanged != null) {
+            this.propertyChanged(this, new PropertyChangedEventArgs(a));
+        }
+        this.a0(a, b, c);
+    };
+    ToolPanel.prototype.a0 = function (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) {
+                    var d = b;
+                    d.collectionChanged = delegateRemove(d.collectionChanged, runOn(this, this.ak));
+                }
+                if (c != null) {
+                    var e = c;
+                    e.collectionChanged = delegateCombine(e.collectionChanged, runOn(this, this.ak));
+                }
+                this.a2();
+                break;
+        }
+    };
+    Object.defineProperty(ToolPanel.prototype, "a7", {
+        get: function () {
+            return this.a5;
+        },
+        set: function (a) {
+            var b = this.a5;
+            this.a5 = a;
+            if (b != this.a5) {
+                this.ax("BackgroundColor", b, a);
+            }
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(ToolPanel.prototype, "ba", {
+        get: function () {
+            return this.a6;
+        },
+        set: function (a) {
+            var b = this.a6;
+            this.a6 = a;
+            if (b != this.a6) {
+                this.ax("TextColor", b, a);
+            }
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(ToolPanel.prototype, "k", {
+        get: function () {
+            return this.i;
+        },
+        set: function (a) {
+            var b = this.i;
+            this.i = a;
+            if (b != this.i) {
+                this.ax("Orientation", enumGetBox(ToolPanelOrientation_$type, b), enumGetBox(ToolPanelOrientation_$type, a));
+            }
+        },
+        enumerable: true,
+        configurable: true
+    });
+    ToolPanel.prototype.ay = function (a, b) {
+        if (this.onCommand != null) {
+            this.onCommand(this, ((function () {
+                var $ret = new ToolCommandEventArgs();
+                $ret.a = b;
+                return $ret;
+            })()));
+        }
+        if (a.f == 6) {
+            this.a3(a);
+        }
+    };
+    ToolPanel.$t = markType(ToolPanel, 'ToolPanel', Base.$, [INotifyPropertyChanged_$type]);
+    ToolPanel.a8 = BrushUtil.g(255, 248, 248, 248);
+    ToolPanel.a9 = BrushUtil.g(255, 24, 29, 31);
+    ToolPanel.j = 0;
+    return ToolPanel;
+}(Base));
+export { ToolPanel };