igniteui-webcomponents-layouts 1.4.1 → 3.2.1

package/esm5/lib/PropertyEditorPanelView_combined.js

@@ -0,0 +1,1817 @@
+/*
+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, runOn, delegateCombine, typeCast, delegateRemove, fromEn, fromEnum, enumGetBox, String_$type, typeGetValue, Number_$type } from "igniteui-webcomponents-core";
+import { RenderingContext } from "igniteui-webcomponents-core";
+import { FontInfo } from "igniteui-webcomponents-core";
+import { DOMExecutionContext } from "igniteui-webcomponents-core";
+import { CanvasViewRenderer } from "igniteui-webcomponents-core";
+import { NativeUIComponent } from "igniteui-webcomponents-core";
+import { Size } from "igniteui-webcomponents-core";
+import { NativeUI } from "igniteui-webcomponents-core";
+import { FontUtil } from "igniteui-webcomponents-core";
+import { SRProvider } from "igniteui-webcomponents-core";
+import { PropertyEditorPropertyDescriptionCollection } from "./PropertyEditorPropertyDescriptionCollection";
+import { List$1 } from "igniteui-webcomponents-core";
+import { ObservableCollection$1 } from "igniteui-webcomponents-core";
+import { PropertyEditorPanelColumnDefinition } from "./PropertyEditorPanelColumnDefinition";
+import { ComponentRenderer } from "igniteui-webcomponents-core";
+import { DeviceUtils } from "igniteui-webcomponents-core";
+import { Dictionary$2 } from "igniteui-webcomponents-core";
+import { NativeUIInputsFactory } from "igniteui-webcomponents-core";
+import { PropertyEditorPropertyDescription } from "./PropertyEditorPropertyDescription";
+import { LocalDataSource } from "igniteui-webcomponents-core";
+import { HorizontalPropertyEditorPanelDataSource } from "./HorizontalPropertyEditorPanelDataSource";
+import { PropertyEditorDataSource } from "./PropertyEditorDataSource";
+import { HashSet$1 } from "igniteui-webcomponents-core";
+import { PropertyEditorValueType_$type } from "./PropertyEditorValueType";
+import { PropertyEditorTreeTransformer } from "./PropertyEditorTreeTransformer";
+import { BrushUtil } from "igniteui-webcomponents-core";
+import { Thickness } from "igniteui-webcomponents-core";
+import { truncate, isNaN_, tryParseNumber } from "igniteui-webcomponents-core";
+import { stringSplit } from "igniteui-webcomponents-core";
+import { stringContains, stringReplace } from "igniteui-webcomponents-core";
+import { tryParseBool } from "igniteui-webcomponents-core";
+/**
+ * @hidden
+ */
+var PropertyEditorPanelView = /** @class */ /*@__PURE__*/ (function (_super) {
+    tslib_1.__extends(PropertyEditorPanelView, _super);
+    function PropertyEditorPanelView() {
+        var _this = _super.call(this) || this;
+        _this.n = null;
+        _this.m = null;
+        _this.a = null;
+        _this.i = null;
+        _this.l = null;
+        _this.e = null;
+        _this.k = null;
+        _this.b = ((function () {
+            var $ret = new FontInfo();
+            $ret.n = "Verdana";
+            $ret.d = 13;
+            $ret.q = "Normal";
+            $ret.s = "Normal";
+            $ret.o = "Normal";
+            return $ret;
+        })());
+        _this.aa = new Size();
+        _this.c = null;
+        _this._gridExternal = null;
+        _this.f = false;
+        _this.j = null;
+        return _this;
+    }
+    PropertyEditorPanelView.prototype.p = function () {
+        return this.i;
+    };
+    PropertyEditorPanelView.prototype.v = function () {
+    };
+    PropertyEditorPanelView.prototype.t = function (a) {
+        var _this = this;
+        if (a == null) {
+            this.i = null;
+            return;
+        }
+        this.a.j = new DOMExecutionContext(a);
+        this.i = a;
+        this.l = this.i.createElement("canvas");
+        this.e = new RenderingContext(new CanvasViewRenderer(), this.i.get2DCanvasContext(this.l));
+        this.k = this.i.createElement("div");
+        this.y();
+        NativeUIComponent.z(this.p(), 7, function (b) {
+            var c = b;
+            _this.a.dh(c, _this.n);
+            _this.i.append(c.u);
+        });
+        var b = Math.round(a.rootWrapper.width());
+        var c = Math.round(a.rootWrapper.height());
+        this.i.rootWrapper.setStyleProperty("position", "relative");
+    };
+    PropertyEditorPanelView.prototype.y = function () {
+    };
+    PropertyEditorPanelView.prototype.x = function () {
+        if (this.i != null) {
+        }
+    };
+    PropertyEditorPanelView.prototype.s = function () {
+        if (this.i == null) {
+            return;
+        }
+        var a = this.i.rootWrapper.width();
+        var b = this.i.rootWrapper.height();
+        this.aa = new Size(1, a, b);
+        if (this.a.v != null) {
+            this.a.d2();
+        }
+    };
+    PropertyEditorPanelView.prototype.z = function () {
+        var a = this.i;
+        if (null == a) {
+            return;
+        }
+        var b = a.rootWrapper;
+        if (null != b) {
+            NativeUI.o(b, this.a.d9);
+            NativeUI.k(b, this.a.d6);
+        }
+    };
+    PropertyEditorPanelView.prototype.d = function () {
+        return this.b;
+    };
+    PropertyEditorPanelView.prototype.u = function () {
+    };
+    PropertyEditorPanelView.prototype.w = function () {
+    };
+    PropertyEditorPanelView.prototype.r = function () {
+        var a = this.a.ea();
+        if (a.height > 0) {
+            this.i.rootWrapper.setStyleProperty("min-height", a.height + "px");
+        }
+    };
+    PropertyEditorPanelView.prototype.g = function () {
+        return this.aa.width;
+    };
+    PropertyEditorPanelView.prototype.h = function (a) {
+        this.c = this.a.u();
+        return FontUtil.measureStringWidth(a, this.c, this.e);
+    };
+    PropertyEditorPanelView.prototype.q = function (a, b) {
+        if (this.j == null) {
+            this.j = this.i.createElement("div");
+        }
+        b(this.j.getNativeElement());
+    };
+    PropertyEditorPanelView.$t = markType(PropertyEditorPanelView, 'PropertyEditorPanelView');
+    return PropertyEditorPanelView;
+}(Base));
+export { PropertyEditorPanelView };
+/**
+ * @hidden
+ */
+var PropertyEditorPanel = /** @class */ /*@__PURE__*/ (function (_super) {
+    tslib_1.__extends(PropertyEditorPanel, _super);
+    function PropertyEditorPanel() {
+        var _this = _super.call(this) || this;
+        _this.l = null;
+        _this.v = null;
+        _this.r = null;
+        _this.y = false;
+        _this.z = false;
+        _this.w = null;
+        _this.propertyChanged = null;
+        _this.af = false;
+        _this.n = null;
+        _this.o = new PropertyEditorPropertyDescriptionCollection();
+        _this.bk = -1;
+        _this.aq = DeviceUtils.g(38);
+        _this.s = null;
+        _this.br = null;
+        _this.c = null;
+        _this.an = null;
+        _this.j = null;
+        _this.ae = false;
+        _this.ap = null;
+        _this.bj = -1;
+        _this.bt = null;
+        _this.ad = true;
+        _this.am = new Dictionary$2(PropertyEditorPanelColumnDefinition.$, Number_$type, 0);
+        _this.f = null;
+        _this.g = null;
+        _this.d = null;
+        _this.bq = null;
+        _this.bu = null;
+        _this.aa = false;
+        _this.ac = false;
+        _this.ab = false;
+        _this.d4 = PropertyEditorPanel.d7;
+        _this.d5 = PropertyEditorPanel.d8;
+        _this.bo = 0;
+        _this.bl = -1;
+        _this.k = null;
+        NativeUIInputsFactory.k();
+        _this.ap = new ObservableCollection$1(PropertyEditorPanelColumnDefinition.$, 0);
+        var a = new PropertyEditorPanelView();
+        a.a = _this;
+        var b = _this.properties;
+        b.collectionChanged = delegateCombine(b.collectionChanged, runOn(_this, _this.dx));
+        _this.l = a;
+        _this.l.v();
+        return _this;
+    }
+    Object.defineProperty(PropertyEditorPanel.prototype, "x", {
+        get: function () {
+            if (this.w == null) {
+                this.w = new SRProvider(this.l.i);
+                this.w.cb("Layouts");
+            }
+            return this.w;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    PropertyEditorPanel.prototype.dx = 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.dj));
+                    }
+                }
+            }
+            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.dj));
+                    }
+                }
+            }
+            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.aj();
+        if (this.properties.count > 0 && this.actualProperties != this.properties) {
+            this.actualProperties = this.properties;
+        }
+        this.dt();
+    };
+    PropertyEditorPanel.prototype.dt = function () {
+        if (!this.af) {
+            if (this.v != null) {
+                this.d2();
+            }
+        }
+    };
+    PropertyEditorPanel.prototype.dj = function (a, b) {
+        if (!this.af) {
+            this.aj();
+            if (this.v != null) {
+                this.d2();
+            }
+        }
+    };
+    PropertyEditorPanel.prototype.notifySizeChanged = function () {
+        this.l.s();
+    };
+    PropertyEditorPanel.prototype.dh = function (a, b) {
+        this.v = a;
+        if (null != this.v) {
+            if (this.actualProperties != null) {
+                if (this.ag) {
+                    if (this.actualProperties != null && !(typeCast(HorizontalPropertyEditorPanelDataSource.$, this.actualProperties) !== null)) {
+                        this.actualProperties = new HorizontalPropertyEditorPanelDataSource(this.actualProperties);
+                    }
+                }
+                else {
+                    if (typeCast(HorizontalPropertyEditorPanelDataSource.$, this.actualProperties) !== null) {
+                        var c = this.actualProperties;
+                        this.actualProperties = c.ae;
+                    }
+                }
+                this.br = this.actualProperties;
+                var d = this.actualProperties;
+                d = this.actualProperties.toArray();
+                var e = new LocalDataSource();
+                e.dataSource = d;
+                this.c = e;
+                this.ce();
+            }
+            if (this.actualProperties != null) {
+                this.d2();
+            }
+        }
+    };
+    PropertyEditorPanel.prototype.destroy = function () {
+        this.provideContainer(null);
+    };
+    PropertyEditorPanel.prototype.provideContainer = function (a) {
+        this.l.t(a);
+    };
+    PropertyEditorPanel.prototype.ds = function (a) {
+    };
+    Object.defineProperty(PropertyEditorPanel.prototype, "actualProperties", {
+        get: function () {
+            return this.n;
+        },
+        set: function (a) {
+            var b = this.n;
+            this.n = a;
+            if (b != this.n) {
+                this.du("ActualProperties", b, this.n);
+            }
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(PropertyEditorPanel.prototype, "properties", {
+        get: function () {
+            return this.o;
+        },
+        set: function (a) {
+            var b = this.o;
+            this.o = a;
+            if (b != this.o) {
+                this.du("Properties", b, this.o);
+            }
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(PropertyEditorPanel.prototype, "bp", {
+        get: function () {
+            return this.bk;
+        },
+        set: function (a) {
+            var b = this.bk;
+            this.bk = a;
+            if (b != this.bk) {
+                this.du("RowHeight", b, this.bk);
+            }
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(PropertyEditorPanel.prototype, "ar", {
+        get: function () {
+            return this.aq;
+        },
+        set: function (a) {
+            this.aq = a;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(PropertyEditorPanel.prototype, "t", {
+        get: function () {
+            return this.s;
+        },
+        set: function (a) {
+            var b = this.s;
+            this.s = a;
+            if (b != this.s) {
+                this.du("CellTextStyle", b, this.s);
+            }
+        },
+        enumerable: true,
+        configurable: true
+    });
+    PropertyEditorPanel.prototype.u = function () {
+        if (this.t == null) {
+            return this.l.d();
+        }
+        return this.t;
+    };
+    PropertyEditorPanel.prototype.du = function (a, b, c) {
+        if (this.propertyChanged != null) {
+            this.propertyChanged(this, new PropertyChangedEventArgs(a));
+        }
+        this.dy(a, b, c);
+    };
+    PropertyEditorPanel.prototype.dy = function (a, b, c) {
+        switch (a) {
+            case "DescriptionType":
+                if (this.b2 == null) {
+                    if (this.properties == null) {
+                        this.actualProperties = null;
+                    }
+                }
+                if (this.b2 != null) {
+                    if (this.k == null) {
+                        this.k = new PropertyEditorDataSource();
+                    }
+                    this.k.l = this.b2;
+                }
+                if (this.properties == null || this.properties.count == 0) {
+                    if (this.k.g != null) {
+                        this.actualProperties = this.k.g;
+                    }
+                }
+                else {
+                    if (this.properties != null && this.properties.count > 0) {
+                        this.aj();
+                    }
+                }
+                break;
+            case "ComponentRenderer":
+                if (b != null) {
+                    b.removeTargetPropertyUpdatingListener(runOn(this, this.al));
+                }
+                if (b != c) {
+                    this.ad = true;
+                }
+                if (this.e == null) {
+                    this.h = this.i;
+                }
+                else {
+                    this.h = this.e.context;
+                }
+                break;
+            case "Target":
+                if (ComponentRenderer.defaultInstance != null && this.e == null) {
+                    this.e = ComponentRenderer.defaultInstance;
+                }
+                break;
+            case "DescriptionContext":
+                if (this.e == null) {
+                    this.h = c;
+                }
+                break;
+            case "ActualContext":
+                if (this.h == null) {
+                    if (this.properties == null) {
+                        this.actualProperties = null;
+                    }
+                }
+                if (this.h != null) {
+                    if (this.k == null) {
+                        this.k = new PropertyEditorDataSource();
+                    }
+                    this.k.b = this.h;
+                }
+                if (this.properties == null || this.properties.count == 0) {
+                    if (this.k.g != null) {
+                        this.actualProperties = this.k.g;
+                    }
+                }
+                else {
+                    if (this.properties != null && this.properties.count > 0) {
+                        this.aj();
+                    }
+                }
+                break;
+            case "Properties":
+                this.actualProperties = this.properties;
+                break;
+            case "IsWrappingEnabled":
+                this.d2();
+                break;
+            case "IsHorizontal":
+                if (this.ag) {
+                    this.bj = -1;
+                    if (this.actualProperties != null && !(typeCast(HorizontalPropertyEditorPanelDataSource.$, this.actualProperties) !== null)) {
+                        this.actualProperties = new HorizontalPropertyEditorPanelDataSource(this.actualProperties);
+                    }
+                }
+                else {
+                    if (typeCast(HorizontalPropertyEditorPanelDataSource.$, this.actualProperties) !== null) {
+                        var d = this.actualProperties;
+                        this.actualProperties = d.ae;
+                    }
+                }
+                break;
+            case "ActualProperties":
+                if (this.ag) {
+                    if (this.actualProperties != null && !(typeCast(HorizontalPropertyEditorPanelDataSource.$, this.actualProperties) !== null)) {
+                        this.actualProperties = new HorizontalPropertyEditorPanelDataSource(this.actualProperties);
+                    }
+                }
+                else {
+                    if (typeCast(HorizontalPropertyEditorPanelDataSource.$, this.actualProperties) !== null) {
+                        var e = this.actualProperties;
+                        this.actualProperties = e.ae;
+                    }
+                }
+                if (this.v != null) {
+                    var f = this.br != this.actualProperties;
+                    if (this.ag) {
+                        if (this.actualProperties != null && !(typeCast(HorizontalPropertyEditorPanelDataSource.$, this.actualProperties) !== null)) {
+                            this.actualProperties = new HorizontalPropertyEditorPanelDataSource(this.actualProperties);
+                        }
+                    }
+                    else {
+                        if (typeCast(HorizontalPropertyEditorPanelDataSource.$, this.actualProperties) !== null) {
+                            var g = this.actualProperties;
+                            this.actualProperties = g.ae;
+                        }
+                    }
+                    this.br = this.actualProperties;
+                    var h = this.actualProperties;
+                    h = this.actualProperties.toArray();
+                    var i = new LocalDataSource();
+                    i.dataSource = h;
+                    this.c = i;
+                    this.ce();
+                    if (this.c != null) {
+                        var j = this.c;
+                        j.schemaChanged = delegateCombine(j.schemaChanged, runOn(this, this.dw));
+                    }
+                    if (f) {
+                        this.d2();
+                    }
+                }
+                break;
+            case "RowHeight":
+                if (this.v != null) {
+                    this.ar = this.bp;
+                }
+                break;
+            case "CellTextStyle":
+                this.d0();
+                break;
+            case "BackgroundColor":
+            case "TextColor":
+                this.d0();
+                break;
+        }
+    };
+    PropertyEditorPanel.prototype.aj = function () {
+        var e_3, _a;
+        var a = this.af;
+        this.af = true;
+        var b = false;
+        try {
+            for (var _b = tslib_1.__values(fromEnum(this.properties)), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var c = _c.value;
+                var d = c.al;
+                if (this.k != null) {
+                    var e = this.k.d(d, false);
+                    if (e != null) {
+                        if (c.p(e)) {
+                            b = true;
+                        }
+                    }
+                }
+            }
+        }
+        catch (e_3_1) {
+            e_3 = { error: e_3_1 };
+        }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return))
+                    _a.call(_b);
+            }
+            finally {
+                if (e_3)
+                    throw e_3.error;
+            }
+        }
+        if (b) {
+            this.d2();
+        }
+        else if (this.v != null) {
+            this.d0();
+        }
+        this.af = a;
+        return b;
+    };
+    PropertyEditorPanel.prototype.d0 = function () {
+        if (!this.ae && this.j != null) {
+            this.ae = true;
+            this.j.enqueueAction(runOn(this, this.cj));
+        }
+    };
+    PropertyEditorPanel.prototype.cj = function () {
+        var _this = this;
+        this.ae = false;
+        if (this.an == null) {
+            this.an = new List$1(List$1.$.specialize(NativeUIComponent.$), 0);
+        }
+        if (this.c == null) {
+            return;
+        }
+        var a = this.c.actualCount;
+        var _loop_1 = function (b) {
+            var c = b;
+            var d = this_1.c.getItemAtIndex(b);
+            if (this_1.v.az < c + 1) {
+                this_1.v.a1(c, 1, this_1.ar);
+            }
+            else {
+                this_1.v.a7(c, 1, this_1.ar);
+            }
+            if (this_1.an.count < c + 1) {
+                this_1.an.add(new List$1(NativeUIComponent.$, 0));
+            }
+            var e = this_1.an._inner[c];
+            var _loop_2 = function (f) {
+                var g = this_1.ap._inner[f];
+                if (e.count < f + 1) {
+                    NativeUIComponent.aa(this_1.l.p(), 0, function (h) {
+                        var i = h;
+                        i.e = 1;
+                        if (g.a == 0) {
+                            i.d = 2;
+                        }
+                        i.an = new Thickness(1, 5, 5, 5, 0);
+                        _this.v.as(i);
+                        _this.v.a5(i, c);
+                        _this.v.a4(i, f);
+                        e.add(i);
+                    });
+                }
+                if (this_1.v.aw < f + 1) {
+                    this_1.v.a0(f, 1, g.h);
+                }
+                else {
+                    this_1.v.a6(f, 1, g.h);
+                }
+                var h = e._inner[f];
+                var i = "PropertyPath";
+                if (g.a == 1) {
+                    i = "ValueType";
+                }
+                var j = h;
+                var k = this_1.m(g, c, d);
+                var l = null;
+                if (k != null) {
+                    l = this_1.c.getItemProperty(k, i);
+                    l = g.i(l, c, d);
+                    if (l != null) {
+                        h = g.e(h, c, d);
+                    }
+                }
+                if (l == null) {
+                    var m = h;
+                    m.aw = null;
+                }
+            };
+            for (var f = 0; f < this_1.ap.count; f++) {
+                _loop_2(f);
+            }
+        };
+        var this_1 = this;
+        for (var b = 0; b < a; b++) {
+            _loop_1(b);
+        }
+        var n = new HashSet$1(NativeUIComponent.$, 0);
+        for (var o = this.v.ar - 1; o >= 0; o--) {
+            var p = this.v.aq(o);
+            var q = this.v.ay(p);
+            var r = this.v.ax(p);
+            if ((q + 1) > a || (r + 1) > this.ap.count) {
+                n.add_1(p);
+            }
+        }
+        for (var s = this.v.ar - 1; s >= 0; s--) {
+            var t = this.v.aq(s);
+            if (n.contains(t)) {
+                this.v.au(s);
+            }
+        }
+        for (var u = this.an.count - 1; u >= 0; u--) {
+            for (var v = this.an._inner[u].count - 1; v >= 0; v--) {
+                var w = this.an._inner[u]._inner[v];
+                if (n.contains(w)) {
+                    this.an._inner[u].removeAt(v);
+                }
+            }
+            if (this.an._inner[u].count == 0) {
+                this.an.removeAt(u);
+            }
+        }
+        while (this.v.az > a) {
+            this.v.a3(this.v.az - 1);
+        }
+        while (this.v.aw > this.ap.count) {
+            this.v.a2(this.v.aw - 1);
+        }
+    };
+    PropertyEditorPanel.prototype.dw = function (a, b) {
+        this.z = true;
+        this.ce();
+        this.z = false;
+    };
+    PropertyEditorPanel.prototype.d2 = function () {
+        if (this.v == null) {
+            return;
+        }
+        this.am.clear();
+        this.ap.clear();
+        var a = this.bp == -1 ? 38 : this.bp;
+        var b = this.d6;
+        var c = this.u();
+        if (this.ag) {
+            this.cg();
+        }
+        else {
+            var d = new PropertyEditorPanelColumnDefinition();
+            d.b = 0;
+            d.f = 10;
+            d.g = 5;
+            d.a = 0;
+            d.dataBinding = delegateCombine(d.dataBinding, runOn(this, this.dl));
+            d.cellUpdating = delegateCombine(d.cellUpdating, runOn(this, this.dk));
+            d.j = "PropertyPath";
+            this.ap.add(d);
+            var e = new PropertyEditorPanelColumnDefinition();
+            e.b = 1;
+            e.a = 1;
+            e.f = 5;
+            e.g = 5;
+            e.dataBinding = delegateCombine(e.dataBinding, runOn(this, this.cl));
+            e.cellUpdating = delegateCombine(e.cellUpdating, runOn(this, this.ck));
+            e.j = "ValueType";
+            this.ap.add(e);
+        }
+        this.d0();
+    };
+    PropertyEditorPanel.prototype.cg = function () {
+        if (this.actualProperties == null) {
+            return;
+        }
+        var a = this.actualProperties.ae;
+        var b = a.count;
+        var c = new List$1(PropertyEditorPanelColumnDefinition.$, 0);
+        var d = this.bm(a, b, c, 0x7FFFFFFF);
+        for (var e = 0; e < c.count; e++) {
+            this.ap.add(c._inner[e]);
+        }
+        this.bo = d;
+        var f = this.actualProperties;
+        var g = this.bj;
+        f.clear();
+        for (var h = 0; h < this.bo; h++) {
+            f.add(new PropertyEditorPropertyDescription());
+        }
+        var i = this.actualProperties.toArray();
+        var j = new LocalDataSource();
+        j.dataSource = i;
+        this.c = j;
+        if (f.count != g) {
+            this.bj = f.count;
+            this.d0();
+            this.l.r();
+        }
+    };
+    PropertyEditorPanel.prototype.ea = function () {
+        if (this.ag && this.v != null && this.c != null) {
+            var a = this.ar;
+            var b = this.actualProperties;
+            return new Size(1, 0, b.count * a);
+        }
+        else {
+            return new Size(1, 0, 0);
+        }
+    };
+    PropertyEditorPanel.prototype.bm = function (a, b, c, d) {
+        var e = 0;
+        var f = 0;
+        var g = 0;
+        var h = this.l.g();
+        h -= 5;
+        if (!this.ai) {
+            h = 1.7976931348623157E+308;
+        }
+        var i = 0;
+        var j = h;
+        for (var k = 0; k < b; k++) {
+            var l = a.item(k);
+            var m = this.a9(l);
+            var n = this.a5(l);
+            if ((i + m + n > h && g > 0) || g >= d) {
+                if (f != 0 && g < d && d > 2) {
+                    var o = c._inner[g];
+                    var p = c._inner[g + 1];
+                    o.h = m;
+                    p.h = n;
+                    this.d1(h, c);
+                    if (c.count == 0) {
+                        return 0;
+                    }
+                    return this.bm(a, b, c, c.count);
+                }
+                d = Math.max(Math.min(d, g), 2);
+                f++;
+                var q = h - i;
+                if (q < j) {
+                    j = q;
+                }
+                i = 0;
+                g = 0;
+            }
+            var r = this.b5(l);
+            if (c.count <= g) {
+                var s = new PropertyEditorPanelColumnDefinition();
+                s.b = 0;
+                s.a = 0;
+                s.f = 10;
+                s.g = 5;
+                s.h = m;
+                s.dataBinding = delegateCombine(s.dataBinding, runOn(this, this.dl));
+                s.cellUpdating = delegateCombine(s.cellUpdating, runOn(this, this.dk));
+                s.j = "PropertyName_" + k;
+                c.add(s);
+                this.am.item(s, c.count - 1);
+                g++;
+            }
+            else {
+                var t = c._inner[g];
+                if (m > t.h) {
+                    var u = m - t.h;
+                    t.h = m;
+                    if (u > j && d > 2) {
+                        this.d1(h, c);
+                        if (c.count == 0) {
+                            return 0;
+                        }
+                        return this.bm(a, b, c, c.count);
+                    }
+                    else {
+                        j -= u;
+                        if (j < 0) {
+                            j = 0;
+                        }
+                        g++;
+                    }
+                }
+                else {
+                    m = t.h;
+                    g++;
+                }
+            }
+            if (c.count <= g) {
+                var v = new PropertyEditorPanelColumnDefinition();
+                v.b = 1;
+                v.a = 1;
+                v.j = "ValueType_" + k;
+                v.f = 5;
+                v.g = 5;
+                v.dataBinding = delegateCombine(v.dataBinding, runOn(this, this.cl));
+                v.h = n;
+                v.cellUpdating = delegateCombine(v.cellUpdating, runOn(this, this.ck));
+                c.add(v);
+                this.am.item(v, c.count - 1);
+                g++;
+            }
+            else {
+                var w = c._inner[g];
+                if (n > w.h) {
+                    var x = n - w.h;
+                    w.h = n;
+                    if (x > j && d > 2) {
+                        this.d1(h, c);
+                        if (c.count == 0) {
+                            return 0;
+                        }
+                        return this.bm(a, b, c, c.count);
+                    }
+                    else {
+                        j -= x;
+                        if (j < 0) {
+                            j = 0;
+                        }
+                        g++;
+                    }
+                }
+                else {
+                    n = w.h;
+                    g++;
+                }
+            }
+            i += m + n;
+        }
+        return f + 1;
+    };
+    PropertyEditorPanel.prototype.d1 = function (a, b) {
+        var e_4, _a;
+        var c = 0;
+        try {
+            for (var _b = tslib_1.__values(fromEnum(b)), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var d = _c.value;
+                c += d.h;
+            }
+        }
+        catch (e_4_1) {
+            e_4 = { error: e_4_1 };
+        }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return))
+                    _a.call(_b);
+            }
+            finally {
+                if (e_4)
+                    throw e_4.error;
+            }
+        }
+        while (c > a) {
+            if (b.count < 1) {
+                return;
+            }
+            if (b._inner[b.count - 1].b == 1) {
+                c -= b._inner[b.count - 1].h;
+                c -= b._inner[b.count - 2].h;
+                b.removeAt(b.count - 1);
+                b.removeAt(b.count - 1);
+            }
+            else {
+                c -= b._inner[b.count - 1].h;
+                b.removeAt(b.count - 1);
+            }
+        }
+    };
+    PropertyEditorPanel.prototype.cl = function (a, b) {
+        var c = a;
+        var d = this.m(c, b.a, b.c);
+        b.b = enumGetBox(PropertyEditorValueType_$type, d != null ? d.n : 0);
+    };
+    PropertyEditorPanel.prototype.dl = function (a, b) {
+        var c = a;
+        var d = this.m(c, b.a, b.c);
+        if (d == null) {
+            b.b = null;
+            return;
+        }
+        b.b = d.aj != null ? d.aj : d.al;
+    };
+    PropertyEditorPanel.prototype.a5 = function (a) {
+        if (!isNaN_(a.w)) {
+            return a.w;
+        }
+        switch (a.n) {
+            case 10: return this.as(a);
+            case 7: return this.at(a);
+            case 4: return this.av(a);
+            case 6: return this.au(a);
+            case 9: return this.ay(a);
+            case 5: return this.a0(a);
+            case 14: return this.az(a);
+            case 18: return this.a1(a);
+            case 3: return this.a2(a);
+            case 15: return this.a6(a);
+            case 17: return this.a7(a);
+            case 16: return this.ba(a);
+            case 1: return this.bb(a);
+            case 11: return this.bc(a);
+            case 13: return this.bd(a);
+            case 12: return this.be(a);
+            case 2: return this.bg(a);
+            case 8: return this.bh(a);
+            case 19: return this.bi(a);
+            case 0: return this.a8(a);
+            case 20: return this.aw(a);
+            case 21: return this.bf(a);
+        }
+        return 100;
+    };
+    PropertyEditorPanel.prototype.bi = function (a) {
+        return this.a8(a);
+    };
+    PropertyEditorPanel.prototype.a8 = function (a) {
+        return 175;
+    };
+    PropertyEditorPanel.prototype.aw = function (a) {
+        if (a.ad != null) {
+            return Math.max(100, this.l.h(a.ad.toString()) + 30);
+        }
+        return 80;
+    };
+    PropertyEditorPanel.prototype.bf = function (a) {
+        return 175;
+    };
+    PropertyEditorPanel.prototype.bh = function (a) {
+        return this.aw(a);
+    };
+    PropertyEditorPanel.prototype.bg = function (a) {
+        return this.a8(a);
+    };
+    PropertyEditorPanel.prototype.be = function (a) {
+        return this.a8(a);
+    };
+    PropertyEditorPanel.prototype.bd = function (a) {
+        return this.a8(a);
+    };
+    PropertyEditorPanel.prototype.bc = function (a) {
+        return this.a8(a);
+    };
+    PropertyEditorPanel.prototype.bb = function (a) {
+        return this.a8(a);
+    };
+    PropertyEditorPanel.prototype.ba = function (a) {
+        return this.aw(a);
+    };
+    PropertyEditorPanel.prototype.a7 = function (a) {
+        return this.aw(a);
+    };
+    PropertyEditorPanel.prototype.a6 = function (a) {
+        return this.a4(a);
+    };
+    PropertyEditorPanel.prototype.a4 = function (a) {
+        return this.a8(a);
+    };
+    PropertyEditorPanel.prototype.a2 = function (a) {
+        return this.a3(a);
+    };
+    PropertyEditorPanel.prototype.a3 = function (a) {
+        return this.a8(a);
+    };
+    PropertyEditorPanel.prototype.a1 = function (a) {
+        return this.aw(a);
+    };
+    PropertyEditorPanel.prototype.az = function (a) {
+        return this.aw(a);
+    };
+    PropertyEditorPanel.prototype.a0 = function (a) {
+        return this.a8(a);
+    };
+    PropertyEditorPanel.prototype.ay = function (a) {
+        return this.aw(a);
+    };
+    PropertyEditorPanel.prototype.au = function (a) {
+        return this.aw(a);
+    };
+    PropertyEditorPanel.prototype.av = function (a) {
+        return this.a8(a);
+    };
+    PropertyEditorPanel.prototype.at = function (a) {
+        return this.ax(a);
+    };
+    PropertyEditorPanel.prototype.ax = function (a) {
+        return 50;
+    };
+    PropertyEditorPanel.prototype.as = function (a) {
+        return this.aw(a);
+    };
+    PropertyEditorPanel.prototype.a9 = function (a) {
+        if (!isNaN_(a.x)) {
+            return a.x;
+        }
+        return this.l.h(this.b5(a)) + 17;
+    };
+    PropertyEditorPanel.prototype.b5 = function (a) {
+        return a.aj != null ? a.aj : a.al;
+    };
+    PropertyEditorPanel.prototype.dk = function (a, b) {
+        var c = a;
+        var d = this.m(c, b.b, b.c);
+        this.c7(c, b);
+    };
+    PropertyEditorPanel.prototype.ck = function (a, b) {
+        var c = a;
+        var d = this.m(c, b.b, b.c);
+        var e = d != null ? d.n : 0;
+        switch (e) {
+            case 10:
+                this.cs(c, b);
+                break;
+            case 7:
+                this.ct(c, b);
+                break;
+            case 4:
+                this.cv(c, b);
+                break;
+            case 6:
+                this.cu(c, b);
+                break;
+            case 9:
+                this.cx(c, b);
+                break;
+            case 5:
+                this.cz(c, b);
+                break;
+            case 14:
+                this.cy(c, b);
+                break;
+            case 18:
+                this.c0(c, b);
+                break;
+            case 3:
+                this.c1(c, b);
+                break;
+            case 15:
+                this.c4(c, b);
+                break;
+            case 17:
+                this.c5(c, b);
+                break;
+            case 16:
+                this.c8(c, b);
+                break;
+            case 1:
+                this.c9(c, b);
+                break;
+            case 11:
+                this.da(c, b);
+                break;
+            case 13:
+                this.db(c, b);
+                break;
+            case 12:
+                this.dc(c, b);
+                break;
+            case 2:
+                this.de(c, b);
+                break;
+            case 8:
+                this.df(c, b);
+                break;
+            case 19:
+                this.dg(c, b);
+                break;
+            case 20:
+                this.cw(c, b);
+                break;
+            case 21:
+                this.dd(c, b);
+                break;
+            case 0: break;
+        }
+    };
+    PropertyEditorPanel.prototype.dg = function (a, b) {
+        this.c6(a, b);
+    };
+    PropertyEditorPanel.prototype.df = function (a, b) {
+    };
+    PropertyEditorPanel.prototype.de = function (a, b) {
+        this.c6(a, b);
+    };
+    PropertyEditorPanel.prototype.dc = function (a, b) {
+        this.c6(a, b);
+    };
+    PropertyEditorPanel.prototype.db = function (a, b) {
+        this.c6(a, b);
+    };
+    PropertyEditorPanel.prototype.da = function (a, b) {
+        this.c6(a, b);
+    };
+    PropertyEditorPanel.prototype.c9 = function (a, b) {
+        this.c6(a, b);
+    };
+    PropertyEditorPanel.prototype.c7 = function (a, b) {
+        var _this = this;
+        this.cq(b, function (c, d) {
+            c.ap = _this.u();
+            c.e = 1;
+            var e = _this.m(a, b.b, b.c);
+            c.v = e;
+            c.aq = _this.b5(e);
+        });
+    };
+    PropertyEditorPanel.prototype.c6 = function (a, b) {
+        var _this = this;
+        this.cp(b, function (c, d) {
+            c.e = 1;
+            c.at = 1;
+            c.aq = 2;
+            var e = _this.m(a, b.b, b.c);
+            c.v = e;
+            c.au = (e.ad != null ? e.ad.toString() : "");
+            if (d) {
+                c.as = runOn(_this, _this.di);
+            }
+        });
+    };
+    PropertyEditorPanel.prototype.cq = function (a, b) {
+        var c = a.a;
+        var d = c.aw;
+        var e = false;
+        if (d == null || d.c != 3) {
+            e = true;
+            NativeUIComponent.z(this.l.p(), 3, function (f) {
+                c.aw = f;
+                b(f, e);
+            });
+            return;
+        }
+        b(d, e);
+    };
+    PropertyEditorPanel.prototype.cp = function (a, b) {
+        var c = a.a;
+        var d = c.aw;
+        var e = false;
+        if (d == null || d.c != 2) {
+            e = true;
+            NativeUIComponent.z(this.l.p(), 2, function (f) {
+                c.aw = f;
+                b(f, e);
+            });
+            return;
+        }
+        b(d, e);
+    };
+    PropertyEditorPanel.prototype.cm = function (a, b) {
+        var c = a.a;
+        var d = c.aw;
+        var e = false;
+        if (d == null || d.c != 1) {
+            e = true;
+            NativeUIComponent.z(this.l.p(), 1, function (f) {
+                c.aw = f;
+                b(f, e);
+            });
+            return;
+        }
+        b(d, e);
+    };
+    PropertyEditorPanel.prototype.cr = function (a, b) {
+        var c = a.a;
+        var d = c.aw;
+        var e = false;
+        if (d == null || d.c != 5) {
+            e = true;
+            NativeUIComponent.z(this.l.p(), 5, function (f) {
+                c.aw = f;
+                b(f, e);
+            });
+            return;
+        }
+        b(d, e);
+    };
+    PropertyEditorPanel.prototype.co = function (a, b) {
+        var c = a.a;
+        var d = c.aw;
+        var e = false;
+        if (d == null || d.c != 4) {
+            e = true;
+            NativeUIComponent.z(this.l.p(), 4, function (f) {
+                c.aw = f;
+                b(f, e);
+            });
+            return;
+        }
+        b(d, e);
+    };
+    PropertyEditorPanel.prototype.cn = function (a, b) {
+        var c = a.a;
+        var d = c.aw;
+        var e = false;
+        if (d == null || d.c != 6) {
+            e = true;
+            NativeUIComponent.z(this.l.p(), 6, function (f) {
+                c.aw = f;
+                b(f, e);
+            });
+            return;
+        }
+        b(d, e);
+    };
+    PropertyEditorPanel.prototype.cw = function (a, b) {
+        var _this = this;
+        this.cm(b, function (c, d) {
+            c.e = 1;
+            if (c.ar != 2) {
+                c.ar = 2;
+            }
+            var e = _this.m(a, b.b, b.c);
+            c.v = e;
+            var f = e.ad;
+            if (typeof e.ad === 'number' || typeof e.ad === 'number') {
+                f = e.ad.toString();
+            }
+            c.as = f;
+            if (d) {
+                c.aq = runOn(_this, _this.cd);
+            }
+        });
+    };
+    PropertyEditorPanel.prototype.dd = function (a, b) {
+        var _this = this;
+        this.cr(b, function (c, d) {
+            c.e = 1;
+            var e = _this.m(a, b.b, b.c);
+            c.v = e;
+            var f = e.ad;
+            if (typeof e.ad === 'number' || typeof e.ad === 'number') {
+                f = e.ad;
+            }
+            if (typeof e.ad === 'string') {
+                var g = 0;
+                var h = tryParseNumber(f, g);
+                g = h.p1;
+                f = g;
+            }
+            if (f == null) {
+                f = 0;
+            }
+            c.aw = f;
+            if (!isNaN_(e.z)) {
+                c.au = e.z;
+            }
+            else {
+                c.au = 0;
+            }
+            if (!isNaN_(e.y)) {
+                c.at = e.y;
+            }
+            else {
+                c.at = 100;
+            }
+            if (!isNaN_(e.aa)) {
+                c.av = e.aa;
+            }
+            else {
+                c.av = 1;
+            }
+            if (d) {
+                c.as = runOn(_this, _this.d3);
+            }
+        });
+    };
+    PropertyEditorPanel.prototype.d3 = function (a, b) {
+        var c = a;
+        var d = c.v;
+        this.af = true;
+        d.ad = c.aw;
+        this.af = false;
+        this.dv(d);
+    };
+    PropertyEditorPanel.prototype.c3 = function (a, b) {
+        var _this = this;
+        this.co(b, function (c, d) {
+            c.e = 1;
+            if (c.ap != 2) {
+                c.ap = 2;
+            }
+            var e = _this.m(a, b.b, b.c);
+            if (c.v != e) {
+                {
+                    c.ar = null;
+                }
+                c.v = e;
+                c.at = null;
+                c.as = _this.b(_this.a(e));
+                if (e.ad != c.at) {
+                    if (typeof e.ad === 'number' || typeof e.ad === 'number') {
+                        c.at = e.ad.toString();
+                    }
+                    else {
+                        c.at = e.ad;
+                    }
+                }
+                {
+                    c.ar = runOn(_this, _this.ch);
+                }
+            }
+            else {
+                if (e.ad != c.at) {
+                    if (typeof e.ad === 'number' || typeof e.ad === 'number') {
+                        c.at = e.ad.toString();
+                    }
+                    else {
+                        c.at = e.ad;
+                    }
+                }
+            }
+            if (d) {
+                if (c.ar == null) {
+                    c.ar = runOn(_this, _this.ch);
+                }
+                c.ah = BrushUtil.g(255, 255, 255, 255);
+            }
+        });
+    };
+    PropertyEditorPanel.prototype.b = function (a) {
+        return a;
+    };
+    PropertyEditorPanel.prototype.a = function (a) {
+        return a.c;
+    };
+    PropertyEditorPanel.prototype.ch = function (a, b) {
+        var c = a;
+        var d = c.v;
+        this.af = true;
+        d.ad = c.at;
+        d.am();
+        this.af = false;
+        this.dv(d);
+    };
+    PropertyEditorPanel.prototype.di = function (a, b) {
+        var c = a;
+        var d = c.v;
+        this.af = true;
+        if (d.n == 1) {
+            var e = 0;
+            var f = tryParseNumber(c.au, e);
+            e = f.p1;
+            d.ad = e;
+        }
+        else {
+            d.ad = c.au;
+        }
+        d.am();
+        this.af = false;
+        this.dv(d);
+    };
+    PropertyEditorPanel.prototype.cd = function (a, b) {
+        var c = a;
+        var d = c.v;
+        this.af = true;
+        d.an();
+        this.af = false;
+        this.dv(d);
+    };
+    PropertyEditorPanel.prototype.dv = function (a) {
+        var _this = this;
+        if (this.bs != null && this.e != null) {
+            if (this.ad) {
+                this.ad = false;
+                this.e.addTargetPropertyUpdatingListener(runOn(this, this.al));
+            }
+            var b = this.bt == null;
+            this.bt = this.b4();
+            if (b) {
+                this.l.q(this.bs, function (c) { return _this.e.loadJsonOverlay(_this.bt, function (d) { return c; }, function (d) { return _this.bs; }); });
+            }
+            else {
+                this.l.q(this.bs, function (c) { return _this.e.loadJsonDelta(_this.bt, function (d) { return c; }, false); });
+            }
+        }
+    };
+    PropertyEditorPanel.prototype.al = function (a, b, c) {
+        var d = this.actualProperties;
+        if (typeCast(HorizontalPropertyEditorPanelDataSource.$, d) !== null) {
+            d = d.ae;
+        }
+        for (var e = 0; e < d.count; e++) {
+            var f = d._inner[e].al;
+            if (this.ak(f, a)) {
+                d._inner[e].ap(a, b, c);
+            }
+        }
+        if (this.ah) {
+            return true;
+        }
+        return false;
+    };
+    PropertyEditorPanel.prototype.ak = function (a, b) {
+        if (a == null && b == null) {
+            return true;
+        }
+        if (a == null) {
+            return false;
+        }
+        if (b == null) {
+            return false;
+        }
+        var c = stringSplit(a, ['.', '['], 0);
+        var d = stringSplit(b, ['.', '['], 0);
+        if (c.length != d.length) {
+            return false;
+        }
+        for (var e = 0; e < c.length; e++) {
+            var f = c[e];
+            var g = d[e];
+            if (stringContains(f, "]")) {
+                if (!stringContains(g, "]")) {
+                    return false;
+                }
+                g = stringReplace(g, "]", "");
+                var h = this.ao(f);
+                if (!h.contains(g)) {
+                    return false;
+                }
+            }
+            else {
+                if (!Base.equalsStatic(f, g)) {
+                    return false;
+                }
+            }
+        }
+        return true;
+    };
+    PropertyEditorPanel.prototype.ao = function (a) {
+        var b = new List$1(String_$type, 0);
+        if (stringContains(a, "]")) {
+            a = stringReplace(a, "]", "");
+            var c = a.split(',');
+            for (var d = 0; d < c.length; d++) {
+                var e = c[d];
+                if (stringContains(e, "as")) {
+                    var f = e.indexOf("as");
+                    var g = e.substr(0, f).trim();
+                    b.add(g);
+                }
+            }
+            return b;
+        }
+        b.add(a);
+        return b;
+    };
+    PropertyEditorPanel.prototype.b4 = function () {
+        if (this.actualProperties == null) {
+            return null;
+        }
+        var a = this.actualProperties;
+        if (typeCast(HorizontalPropertyEditorPanelDataSource.$, a) !== null) {
+            a = a.ae;
+        }
+        var b = new PropertyEditorTreeTransformer(this.h, this.b2);
+        this.c2(a, "", b, this.b2);
+        return b.g();
+    };
+    PropertyEditorPanel.prototype.c2 = function (a, b, c, d) {
+        for (var e = 0; e < a.count; e++) {
+            var f = a._inner[e];
+            if (f.n == 20) {
+                continue;
+            }
+            if (f.i != null) {
+                for (var g = 0; g < f.i.count; g++) {
+                    var h = f.i._inner[g];
+                    var i = b + f.al + "[" + g + "]";
+                    this.c2(h.a, i, c, h.b);
+                }
+            }
+            else if (f.g != null) {
+                var j = b + f.al;
+                this.c2(f.g.a, j, c, f.g.b);
+            }
+            else {
+                c.h(b + f.al, f.ad, d);
+            }
+        }
+    };
+    PropertyEditorPanel.prototype.c8 = function (a, b) {
+    };
+    PropertyEditorPanel.prototype.c5 = function (a, b) {
+    };
+    PropertyEditorPanel.prototype.c4 = function (a, b) {
+        this.c3(a, b);
+    };
+    PropertyEditorPanel.prototype.c1 = function (a, b) {
+    };
+    PropertyEditorPanel.prototype.c0 = function (a, b) {
+    };
+    PropertyEditorPanel.prototype.cy = function (a, b) {
+    };
+    PropertyEditorPanel.prototype.cz = function (a, b) {
+        this.c6(a, b);
+    };
+    PropertyEditorPanel.prototype.cx = function (a, b) {
+    };
+    PropertyEditorPanel.prototype.cu = function (a, b) {
+    };
+    PropertyEditorPanel.prototype.cv = function (a, b) {
+        this.c6(a, b);
+    };
+    PropertyEditorPanel.prototype.ct = function (a, b) {
+        var _this = this;
+        this.cn(b, function (c, d) {
+            c.e = 1;
+            if (!c.ar) {
+                c.ar = true;
+            }
+            var e = _this.m(a, b.b, b.c);
+            var f = e.ad;
+            if (f == null) {
+                f = false;
+            }
+            if (typeof f === 'string') {
+                var g_1;
+                if (((function () { var h = tryParseBool(f, g_1); g_1 = h.p1; return h.ret; })())) {
+                    f = g_1;
+                    var h = _this.af;
+                    _this.af = true;
+                    e.ad = f;
+                    _this.af = h;
+                }
+            }
+            if (typeof f === 'number') {
+                if (typeGetValue(f) > 0) {
+                    f = true;
+                    var i = _this.af;
+                    _this.af = true;
+                    e.ad = f;
+                    _this.af = i;
+                }
+            }
+            if (typeof f === 'number') {
+                if (f > 0) {
+                    f = true;
+                    var j = _this.af;
+                    _this.af = true;
+                    e.ad = f;
+                    _this.af = j;
+                }
+            }
+            var k = f;
+            c.as = k;
+            c.v = e;
+            if (d) {
+                c.aq = runOn(_this, _this.cf);
+            }
+        });
+    };
+    PropertyEditorPanel.prototype.m = function (a, b, c) {
+        if (this.ag) {
+            var d = this.actualProperties.ae;
+            var e = d;
+            var f = truncate((this.ap.count / 2));
+            var g = b * f;
+            var h = this.bn(a);
+            h = truncate(Math.floor(h / 2)) + g;
+            if (h > e.count - 1) {
+                return null;
+            }
+            return e.item(h);
+        }
+        else {
+            return c;
+        }
+    };
+    PropertyEditorPanel.prototype.bn = function (a) {
+        return this.am.item(a);
+    };
+    PropertyEditorPanel.prototype.cf = function (a, b) {
+        var c = a;
+        var d = c.v;
+        this.af = true;
+        d.ad = c.as;
+        d.am();
+        this.af = false;
+        this.dv(d);
+    };
+    PropertyEditorPanel.prototype.cs = function (a, b) {
+    };
+    PropertyEditorPanel.prototype.dq = function (a, b, c) {
+        if (this.v != null) {
+            this.c.notifySetItem(a, b, c);
+        }
+    };
+    PropertyEditorPanel.prototype.dm = function () {
+        if (this.v != null) {
+            this.c.notifyClearItems();
+        }
+    };
+    PropertyEditorPanel.prototype.dn = function (a, b) {
+        if (this.v != null) {
+            this.c.notifyInsertItem(a, b);
+        }
+        ;
+    };
+    PropertyEditorPanel.prototype.dp = function (a, b) {
+        if (this.v != null) {
+            this.c.notifyRemoveItem(a, b);
+        }
+        ;
+    };
+    Object.defineProperty(PropertyEditorPanel.prototype, "h", {
+        get: function () {
+            return this.f;
+        },
+        set: function (a) {
+            var b = this.f;
+            this.f = a;
+            this.du("ActualContext", b, this.f);
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(PropertyEditorPanel.prototype, "i", {
+        get: function () {
+            return this.g;
+        },
+        set: function (a) {
+            var b = this.g;
+            this.g = a;
+            this.du("DescriptionContext", b, this.g);
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(PropertyEditorPanel.prototype, "e", {
+        get: function () {
+            return this.d;
+        },
+        set: function (a) {
+            var b = this.d;
+            this.d = a;
+            this.du("ComponentRenderer", b, this.d);
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(PropertyEditorPanel.prototype, "bs", {
+        get: function () {
+            return this.bq;
+        },
+        set: function (a) {
+            var b = this.bq;
+            this.bq = a;
+            this.du("Target", b, this.bq);
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(PropertyEditorPanel.prototype, "b2", {
+        get: function () {
+            return this.bu;
+        },
+        set: function (a) {
+            var b = this.bu;
+            this.bu = a;
+            this.du("DescriptionType", b, this.bu);
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(PropertyEditorPanel.prototype, "ag", {
+        get: function () {
+            return this.aa;
+        },
+        set: function (a) {
+            var b = this.aa;
+            this.aa = a;
+            this.du("IsHorizontal", b, this.aa);
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(PropertyEditorPanel.prototype, "ai", {
+        get: function () {
+            return this.ac;
+        },
+        set: function (a) {
+            var b = this.ac;
+            this.ac = a;
+            this.du("IsWrappingEnabled", b, this.ac);
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(PropertyEditorPanel.prototype, "ah", {
+        get: function () {
+            return this.ab;
+        },
+        set: function (a) {
+            var b = this.ab;
+            this.ab = a;
+            this.du("IsIndirectModeEnabled", b, this.ab);
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(PropertyEditorPanel.prototype, "d6", {
+        get: function () {
+            return this.d4;
+        },
+        set: function (a) {
+            var b = this.d4;
+            this.d4 = a;
+            if (b != this.d4) {
+                this.du("BackgroundColor", b, a);
+            }
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(PropertyEditorPanel.prototype, "d9", {
+        get: function () {
+            return this.d5;
+        },
+        set: function (a) {
+            var b = this.d5;
+            this.d5 = a;
+            if (b != this.d5) {
+                this.du("TextColor", b, a);
+            }
+        },
+        enumerable: true,
+        configurable: true
+    });
+    PropertyEditorPanel.prototype.ce = function () {
+        var a = this.c;
+        if (null != a) {
+            if (null == a.actualSchema) {
+                this.bl = -1;
+                return;
+            }
+            var b = a.actualCount;
+            this.bl = b;
+        }
+        else {
+            this.bl = -1;
+        }
+    };
+    PropertyEditorPanel.$t = markType(PropertyEditorPanel, 'PropertyEditorPanel', Base.$, [INotifyPropertyChanged_$type]);
+    PropertyEditorPanel.d7 = BrushUtil.g(255, 248, 248, 248);
+    PropertyEditorPanel.d8 = BrushUtil.g(255, 24, 29, 31);
+    return PropertyEditorPanel;
+}(Base));
+export { PropertyEditorPanel };