igniteui-webcomponents-layouts 1.4.1 → 3.2.1

package/esm2015/lib/PropertyEditorPanelView_combined.js

@@ -0,0 +1,1667 @@
+/*
+THIS INFRAGISTICS ULTIMATE SOFTWARE LICENSE  AGREEMENT ("AGREEMENT") LOCATED HERE:
+https://www.infragistics.com/legal/license/igultimate-la
+https://www.infragistics.com/legal/license/igultimate-eula
+GOVERNS THE LICENSING, INSTALLATION AND USE OF INFRAGISTICS SOFTWARE. BY DOWNLOADING AND/OR INSTALLING AND USING INFRAGISTICS SOFTWARE:  you are indicating that you have read and understand this Agreement, and agree to be legally bound by it on behalf of the yourself and your company.
+*/
+import { Base, markType, INotifyPropertyChanged_$type, PropertyChangedEventArgs, 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
+ */
+export let PropertyEditorPanelView = /*@__PURE__*/ (() => {
+    class PropertyEditorPanelView extends Base {
+        constructor() {
+            super();
+            this.n = null;
+            this.m = null;
+            this.a = null;
+            this.i = null;
+            this.l = null;
+            this.e = null;
+            this.k = null;
+            this.b = ((() => {
+                let $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;
+        }
+        p() {
+            return this.i;
+        }
+        v() {
+        }
+        t(a) {
+            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, (b) => {
+                let c = b;
+                this.a.dh(c, this.n);
+                this.i.append(c.u);
+            });
+            let b = Math.round(a.rootWrapper.width());
+            let c = Math.round(a.rootWrapper.height());
+            this.i.rootWrapper.setStyleProperty("position", "relative");
+        }
+        y() {
+        }
+        x() {
+            if (this.i != null) {
+            }
+        }
+        s() {
+            if (this.i == null) {
+                return;
+            }
+            let a = this.i.rootWrapper.width();
+            let b = this.i.rootWrapper.height();
+            this.aa = new Size(1, a, b);
+            if (this.a.v != null) {
+                this.a.d2();
+            }
+        }
+        z() {
+            let a = this.i;
+            if (null == a) {
+                return;
+            }
+            let b = a.rootWrapper;
+            if (null != b) {
+                NativeUI.o(b, this.a.d9);
+                NativeUI.k(b, this.a.d6);
+            }
+        }
+        d() {
+            return this.b;
+        }
+        u() {
+        }
+        w() {
+        }
+        r() {
+            let a = this.a.ea();
+            if (a.height > 0) {
+                this.i.rootWrapper.setStyleProperty("min-height", a.height + "px");
+            }
+        }
+        g() {
+            return this.aa.width;
+        }
+        h(a) {
+            this.c = this.a.u();
+            return FontUtil.measureStringWidth(a, this.c, this.e);
+        }
+        q(a, b) {
+            if (this.j == null) {
+                this.j = this.i.createElement("div");
+            }
+            b(this.j.getNativeElement());
+        }
+    }
+    PropertyEditorPanelView.$t = /*@__PURE__*/ markType(PropertyEditorPanelView, 'PropertyEditorPanelView');
+    return PropertyEditorPanelView;
+})();
+/**
+ * @hidden
+ */
+export let PropertyEditorPanel = /*@__PURE__*/ (() => {
+    class PropertyEditorPanel extends Base {
+        constructor() {
+            super();
+            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);
+            let a = new PropertyEditorPanelView();
+            a.a = this;
+            let b = this.properties;
+            b.collectionChanged = delegateCombine(b.collectionChanged, runOn(this, this.dx));
+            this.l = a;
+            this.l.v();
+        }
+        get x() {
+            if (this.w == null) {
+                this.w = new SRProvider(this.l.i);
+                this.w.cb("Layouts");
+            }
+            return this.w;
+        }
+        dx(a, b) {
+            if (b.oldItems != null) {
+                for (let c of fromEn(b.oldItems)) {
+                    if (typeCast(INotifyPropertyChanged_$type, c) !== null) {
+                        let d = c;
+                        d.propertyChanged = delegateRemove(d.propertyChanged, runOn(this, this.dj));
+                    }
+                }
+            }
+            if (b.newItems != null) {
+                for (let e of fromEn(b.newItems)) {
+                    if (typeCast(INotifyPropertyChanged_$type, e) !== null) {
+                        let f = e;
+                        f.propertyChanged = delegateCombine(f.propertyChanged, runOn(this, this.dj));
+                    }
+                }
+            }
+            this.aj();
+            if (this.properties.count > 0 && this.actualProperties != this.properties) {
+                this.actualProperties = this.properties;
+            }
+            this.dt();
+        }
+        dt() {
+            if (!this.af) {
+                if (this.v != null) {
+                    this.d2();
+                }
+            }
+        }
+        dj(a, b) {
+            if (!this.af) {
+                this.aj();
+                if (this.v != null) {
+                    this.d2();
+                }
+            }
+        }
+        notifySizeChanged() {
+            this.l.s();
+        }
+        dh(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) {
+                            let c = this.actualProperties;
+                            this.actualProperties = c.ae;
+                        }
+                    }
+                    this.br = this.actualProperties;
+                    let d = this.actualProperties;
+                    d = this.actualProperties.toArray();
+                    let e = new LocalDataSource();
+                    e.dataSource = d;
+                    this.c = e;
+                    this.ce();
+                }
+                if (this.actualProperties != null) {
+                    this.d2();
+                }
+            }
+        }
+        destroy() {
+            this.provideContainer(null);
+        }
+        provideContainer(a) {
+            this.l.t(a);
+        }
+        ds(a) {
+        }
+        get actualProperties() {
+            return this.n;
+        }
+        set actualProperties(a) {
+            let b = this.n;
+            this.n = a;
+            if (b != this.n) {
+                this.du("ActualProperties", b, this.n);
+            }
+        }
+        get properties() {
+            return this.o;
+        }
+        set properties(a) {
+            let b = this.o;
+            this.o = a;
+            if (b != this.o) {
+                this.du("Properties", b, this.o);
+            }
+        }
+        get bp() {
+            return this.bk;
+        }
+        set bp(a) {
+            let b = this.bk;
+            this.bk = a;
+            if (b != this.bk) {
+                this.du("RowHeight", b, this.bk);
+            }
+        }
+        get ar() {
+            return this.aq;
+        }
+        set ar(a) {
+            this.aq = a;
+        }
+        get t() {
+            return this.s;
+        }
+        set t(a) {
+            let b = this.s;
+            this.s = a;
+            if (b != this.s) {
+                this.du("CellTextStyle", b, this.s);
+            }
+        }
+        u() {
+            if (this.t == null) {
+                return this.l.d();
+            }
+            return this.t;
+        }
+        du(a, b, c) {
+            if (this.propertyChanged != null) {
+                this.propertyChanged(this, new PropertyChangedEventArgs(a));
+            }
+            this.dy(a, b, c);
+        }
+        dy(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) {
+                            let 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) {
+                            let e = this.actualProperties;
+                            this.actualProperties = e.ae;
+                        }
+                    }
+                    if (this.v != null) {
+                        let 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) {
+                                let g = this.actualProperties;
+                                this.actualProperties = g.ae;
+                            }
+                        }
+                        this.br = this.actualProperties;
+                        let h = this.actualProperties;
+                        h = this.actualProperties.toArray();
+                        let i = new LocalDataSource();
+                        i.dataSource = h;
+                        this.c = i;
+                        this.ce();
+                        if (this.c != null) {
+                            let 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;
+            }
+        }
+        aj() {
+            let a = this.af;
+            this.af = true;
+            let b = false;
+            for (let c of fromEnum(this.properties)) {
+                let d = c.al;
+                if (this.k != null) {
+                    let e = this.k.d(d, false);
+                    if (e != null) {
+                        if (c.p(e)) {
+                            b = true;
+                        }
+                    }
+                }
+            }
+            if (b) {
+                this.d2();
+            }
+            else if (this.v != null) {
+                this.d0();
+            }
+            this.af = a;
+            return b;
+        }
+        d0() {
+            if (!this.ae && this.j != null) {
+                this.ae = true;
+                this.j.enqueueAction(runOn(this, this.cj));
+            }
+        }
+        cj() {
+            this.ae = false;
+            if (this.an == null) {
+                this.an = new List$1(List$1.$.specialize(NativeUIComponent.$), 0);
+            }
+            if (this.c == null) {
+                return;
+            }
+            let a = this.c.actualCount;
+            for (let b = 0; b < a; b++) {
+                let c = b;
+                let d = this.c.getItemAtIndex(b);
+                if (this.v.az < c + 1) {
+                    this.v.a1(c, 1, this.ar);
+                }
+                else {
+                    this.v.a7(c, 1, this.ar);
+                }
+                if (this.an.count < c + 1) {
+                    this.an.add(new List$1(NativeUIComponent.$, 0));
+                }
+                let e = this.an._inner[c];
+                for (let f = 0; f < this.ap.count; f++) {
+                    let g = this.ap._inner[f];
+                    if (e.count < f + 1) {
+                        NativeUIComponent.aa(this.l.p(), 0, (h) => {
+                            let 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.v.aw < f + 1) {
+                        this.v.a0(f, 1, g.h);
+                    }
+                    else {
+                        this.v.a6(f, 1, g.h);
+                    }
+                    let h = e._inner[f];
+                    let i = "PropertyPath";
+                    if (g.a == 1) {
+                        i = "ValueType";
+                    }
+                    let j = h;
+                    let k = this.m(g, c, d);
+                    let l = null;
+                    if (k != null) {
+                        l = this.c.getItemProperty(k, i);
+                        l = g.i(l, c, d);
+                        if (l != null) {
+                            h = g.e(h, c, d);
+                        }
+                    }
+                    if (l == null) {
+                        let m = h;
+                        m.aw = null;
+                    }
+                }
+            }
+            let n = new HashSet$1(NativeUIComponent.$, 0);
+            for (let o = this.v.ar - 1; o >= 0; o--) {
+                let p = this.v.aq(o);
+                let q = this.v.ay(p);
+                let r = this.v.ax(p);
+                if ((q + 1) > a || (r + 1) > this.ap.count) {
+                    n.add_1(p);
+                }
+            }
+            for (let s = this.v.ar - 1; s >= 0; s--) {
+                let t = this.v.aq(s);
+                if (n.contains(t)) {
+                    this.v.au(s);
+                }
+            }
+            for (let u = this.an.count - 1; u >= 0; u--) {
+                for (let v = this.an._inner[u].count - 1; v >= 0; v--) {
+                    let 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);
+            }
+        }
+        dw(a, b) {
+            this.z = true;
+            this.ce();
+            this.z = false;
+        }
+        d2() {
+            if (this.v == null) {
+                return;
+            }
+            this.am.clear();
+            this.ap.clear();
+            let a = this.bp == -1 ? 38 : this.bp;
+            let b = this.d6;
+            let c = this.u();
+            if (this.ag) {
+                this.cg();
+            }
+            else {
+                let 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);
+                let 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();
+        }
+        cg() {
+            if (this.actualProperties == null) {
+                return;
+            }
+            let a = this.actualProperties.ae;
+            let b = a.count;
+            let c = new List$1(PropertyEditorPanelColumnDefinition.$, 0);
+            let d = this.bm(a, b, c, 0x7FFFFFFF);
+            for (let e = 0; e < c.count; e++) {
+                this.ap.add(c._inner[e]);
+            }
+            this.bo = d;
+            let f = this.actualProperties;
+            let g = this.bj;
+            f.clear();
+            for (let h = 0; h < this.bo; h++) {
+                f.add(new PropertyEditorPropertyDescription());
+            }
+            let i = this.actualProperties.toArray();
+            let j = new LocalDataSource();
+            j.dataSource = i;
+            this.c = j;
+            if (f.count != g) {
+                this.bj = f.count;
+                this.d0();
+                this.l.r();
+            }
+        }
+        ea() {
+            if (this.ag && this.v != null && this.c != null) {
+                let a = this.ar;
+                let b = this.actualProperties;
+                return new Size(1, 0, b.count * a);
+            }
+            else {
+                return new Size(1, 0, 0);
+            }
+        }
+        bm(a, b, c, d) {
+            let e = 0;
+            let f = 0;
+            let g = 0;
+            let h = this.l.g();
+            h -= 5;
+            if (!this.ai) {
+                h = 1.7976931348623157E+308;
+            }
+            let i = 0;
+            let j = h;
+            for (let k = 0; k < b; k++) {
+                let l = a.item(k);
+                let m = this.a9(l);
+                let n = this.a5(l);
+                if ((i + m + n > h && g > 0) || g >= d) {
+                    if (f != 0 && g < d && d > 2) {
+                        let o = c._inner[g];
+                        let 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++;
+                    let q = h - i;
+                    if (q < j) {
+                        j = q;
+                    }
+                    i = 0;
+                    g = 0;
+                }
+                let r = this.b5(l);
+                if (c.count <= g) {
+                    let 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 {
+                    let t = c._inner[g];
+                    if (m > t.h) {
+                        let 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) {
+                    let 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 {
+                    let w = c._inner[g];
+                    if (n > w.h) {
+                        let 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;
+        }
+        d1(a, b) {
+            let c = 0;
+            for (let d of fromEnum(b)) {
+                c += d.h;
+            }
+            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);
+                }
+            }
+        }
+        cl(a, b) {
+            let c = a;
+            let d = this.m(c, b.a, b.c);
+            b.b = enumGetBox(PropertyEditorValueType_$type, d != null ? d.n : 0);
+        }
+        dl(a, b) {
+            let c = a;
+            let d = this.m(c, b.a, b.c);
+            if (d == null) {
+                b.b = null;
+                return;
+            }
+            b.b = d.aj != null ? d.aj : d.al;
+        }
+        a5(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;
+        }
+        bi(a) {
+            return this.a8(a);
+        }
+        a8(a) {
+            return 175;
+        }
+        aw(a) {
+            if (a.ad != null) {
+                return Math.max(100, this.l.h(a.ad.toString()) + 30);
+            }
+            return 80;
+        }
+        bf(a) {
+            return 175;
+        }
+        bh(a) {
+            return this.aw(a);
+        }
+        bg(a) {
+            return this.a8(a);
+        }
+        be(a) {
+            return this.a8(a);
+        }
+        bd(a) {
+            return this.a8(a);
+        }
+        bc(a) {
+            return this.a8(a);
+        }
+        bb(a) {
+            return this.a8(a);
+        }
+        ba(a) {
+            return this.aw(a);
+        }
+        a7(a) {
+            return this.aw(a);
+        }
+        a6(a) {
+            return this.a4(a);
+        }
+        a4(a) {
+            return this.a8(a);
+        }
+        a2(a) {
+            return this.a3(a);
+        }
+        a3(a) {
+            return this.a8(a);
+        }
+        a1(a) {
+            return this.aw(a);
+        }
+        az(a) {
+            return this.aw(a);
+        }
+        a0(a) {
+            return this.a8(a);
+        }
+        ay(a) {
+            return this.aw(a);
+        }
+        au(a) {
+            return this.aw(a);
+        }
+        av(a) {
+            return this.a8(a);
+        }
+        at(a) {
+            return this.ax(a);
+        }
+        ax(a) {
+            return 50;
+        }
+        as(a) {
+            return this.aw(a);
+        }
+        a9(a) {
+            if (!isNaN_(a.x)) {
+                return a.x;
+            }
+            return this.l.h(this.b5(a)) + 17;
+        }
+        b5(a) {
+            return a.aj != null ? a.aj : a.al;
+        }
+        dk(a, b) {
+            let c = a;
+            let d = this.m(c, b.b, b.c);
+            this.c7(c, b);
+        }
+        ck(a, b) {
+            let c = a;
+            let d = this.m(c, b.b, b.c);
+            let 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;
+            }
+        }
+        dg(a, b) {
+            this.c6(a, b);
+        }
+        df(a, b) {
+        }
+        de(a, b) {
+            this.c6(a, b);
+        }
+        dc(a, b) {
+            this.c6(a, b);
+        }
+        db(a, b) {
+            this.c6(a, b);
+        }
+        da(a, b) {
+            this.c6(a, b);
+        }
+        c9(a, b) {
+            this.c6(a, b);
+        }
+        c7(a, b) {
+            this.cq(b, (c, d) => {
+                c.ap = this.u();
+                c.e = 1;
+                let e = this.m(a, b.b, b.c);
+                c.v = e;
+                c.aq = this.b5(e);
+            });
+        }
+        c6(a, b) {
+            this.cp(b, (c, d) => {
+                c.e = 1;
+                c.at = 1;
+                c.aq = 2;
+                let 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);
+                }
+            });
+        }
+        cq(a, b) {
+            let c = a.a;
+            let d = c.aw;
+            let e = false;
+            if (d == null || d.c != 3) {
+                e = true;
+                NativeUIComponent.z(this.l.p(), 3, (f) => {
+                    c.aw = f;
+                    b(f, e);
+                });
+                return;
+            }
+            b(d, e);
+        }
+        cp(a, b) {
+            let c = a.a;
+            let d = c.aw;
+            let e = false;
+            if (d == null || d.c != 2) {
+                e = true;
+                NativeUIComponent.z(this.l.p(), 2, (f) => {
+                    c.aw = f;
+                    b(f, e);
+                });
+                return;
+            }
+            b(d, e);
+        }
+        cm(a, b) {
+            let c = a.a;
+            let d = c.aw;
+            let e = false;
+            if (d == null || d.c != 1) {
+                e = true;
+                NativeUIComponent.z(this.l.p(), 1, (f) => {
+                    c.aw = f;
+                    b(f, e);
+                });
+                return;
+            }
+            b(d, e);
+        }
+        cr(a, b) {
+            let c = a.a;
+            let d = c.aw;
+            let e = false;
+            if (d == null || d.c != 5) {
+                e = true;
+                NativeUIComponent.z(this.l.p(), 5, (f) => {
+                    c.aw = f;
+                    b(f, e);
+                });
+                return;
+            }
+            b(d, e);
+        }
+        co(a, b) {
+            let c = a.a;
+            let d = c.aw;
+            let e = false;
+            if (d == null || d.c != 4) {
+                e = true;
+                NativeUIComponent.z(this.l.p(), 4, (f) => {
+                    c.aw = f;
+                    b(f, e);
+                });
+                return;
+            }
+            b(d, e);
+        }
+        cn(a, b) {
+            let c = a.a;
+            let d = c.aw;
+            let e = false;
+            if (d == null || d.c != 6) {
+                e = true;
+                NativeUIComponent.z(this.l.p(), 6, (f) => {
+                    c.aw = f;
+                    b(f, e);
+                });
+                return;
+            }
+            b(d, e);
+        }
+        cw(a, b) {
+            this.cm(b, (c, d) => {
+                c.e = 1;
+                if (c.ar != 2) {
+                    c.ar = 2;
+                }
+                let e = this.m(a, b.b, b.c);
+                c.v = e;
+                let 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);
+                }
+            });
+        }
+        dd(a, b) {
+            this.cr(b, (c, d) => {
+                c.e = 1;
+                let e = this.m(a, b.b, b.c);
+                c.v = e;
+                let f = e.ad;
+                if (typeof e.ad === 'number' || typeof e.ad === 'number') {
+                    f = e.ad;
+                }
+                if (typeof e.ad === 'string') {
+                    let g = 0;
+                    let 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);
+                }
+            });
+        }
+        d3(a, b) {
+            let c = a;
+            let d = c.v;
+            this.af = true;
+            d.ad = c.aw;
+            this.af = false;
+            this.dv(d);
+        }
+        c3(a, b) {
+            this.co(b, (c, d) => {
+                c.e = 1;
+                if (c.ap != 2) {
+                    c.ap = 2;
+                }
+                let 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);
+                }
+            });
+        }
+        b(a) {
+            return a;
+        }
+        a(a) {
+            return a.c;
+        }
+        ch(a, b) {
+            let c = a;
+            let d = c.v;
+            this.af = true;
+            d.ad = c.at;
+            d.am();
+            this.af = false;
+            this.dv(d);
+        }
+        di(a, b) {
+            let c = a;
+            let d = c.v;
+            this.af = true;
+            if (d.n == 1) {
+                let e = 0;
+                let f = tryParseNumber(c.au, e);
+                e = f.p1;
+                d.ad = e;
+            }
+            else {
+                d.ad = c.au;
+            }
+            d.am();
+            this.af = false;
+            this.dv(d);
+        }
+        cd(a, b) {
+            let c = a;
+            let d = c.v;
+            this.af = true;
+            d.an();
+            this.af = false;
+            this.dv(d);
+        }
+        dv(a) {
+            if (this.bs != null && this.e != null) {
+                if (this.ad) {
+                    this.ad = false;
+                    this.e.addTargetPropertyUpdatingListener(runOn(this, this.al));
+                }
+                let b = this.bt == null;
+                this.bt = this.b4();
+                if (b) {
+                    this.l.q(this.bs, (c) => this.e.loadJsonOverlay(this.bt, (d) => c, (d) => this.bs));
+                }
+                else {
+                    this.l.q(this.bs, (c) => this.e.loadJsonDelta(this.bt, (d) => c, false));
+                }
+            }
+        }
+        al(a, b, c) {
+            let d = this.actualProperties;
+            if (typeCast(HorizontalPropertyEditorPanelDataSource.$, d) !== null) {
+                d = d.ae;
+            }
+            for (let e = 0; e < d.count; e++) {
+                let f = d._inner[e].al;
+                if (this.ak(f, a)) {
+                    d._inner[e].ap(a, b, c);
+                }
+            }
+            if (this.ah) {
+                return true;
+            }
+            return false;
+        }
+        ak(a, b) {
+            if (a == null && b == null) {
+                return true;
+            }
+            if (a == null) {
+                return false;
+            }
+            if (b == null) {
+                return false;
+            }
+            let c = stringSplit(a, ['.', '['], 0);
+            let d = stringSplit(b, ['.', '['], 0);
+            if (c.length != d.length) {
+                return false;
+            }
+            for (let e = 0; e < c.length; e++) {
+                let f = c[e];
+                let g = d[e];
+                if (stringContains(f, "]")) {
+                    if (!stringContains(g, "]")) {
+                        return false;
+                    }
+                    g = stringReplace(g, "]", "");
+                    let h = this.ao(f);
+                    if (!h.contains(g)) {
+                        return false;
+                    }
+                }
+                else {
+                    if (!Base.equalsStatic(f, g)) {
+                        return false;
+                    }
+                }
+            }
+            return true;
+        }
+        ao(a) {
+            let b = new List$1(String_$type, 0);
+            if (stringContains(a, "]")) {
+                a = stringReplace(a, "]", "");
+                let c = a.split(',');
+                for (let d = 0; d < c.length; d++) {
+                    let e = c[d];
+                    if (stringContains(e, "as")) {
+                        let f = e.indexOf("as");
+                        let g = e.substr(0, f).trim();
+                        b.add(g);
+                    }
+                }
+                return b;
+            }
+            b.add(a);
+            return b;
+        }
+        b4() {
+            if (this.actualProperties == null) {
+                return null;
+            }
+            let a = this.actualProperties;
+            if (typeCast(HorizontalPropertyEditorPanelDataSource.$, a) !== null) {
+                a = a.ae;
+            }
+            let b = new PropertyEditorTreeTransformer(this.h, this.b2);
+            this.c2(a, "", b, this.b2);
+            return b.g();
+        }
+        c2(a, b, c, d) {
+            for (let e = 0; e < a.count; e++) {
+                let f = a._inner[e];
+                if (f.n == 20) {
+                    continue;
+                }
+                if (f.i != null) {
+                    for (let g = 0; g < f.i.count; g++) {
+                        let h = f.i._inner[g];
+                        let i = b + f.al + "[" + g + "]";
+                        this.c2(h.a, i, c, h.b);
+                    }
+                }
+                else if (f.g != null) {
+                    let j = b + f.al;
+                    this.c2(f.g.a, j, c, f.g.b);
+                }
+                else {
+                    c.h(b + f.al, f.ad, d);
+                }
+            }
+        }
+        c8(a, b) {
+        }
+        c5(a, b) {
+        }
+        c4(a, b) {
+            this.c3(a, b);
+        }
+        c1(a, b) {
+        }
+        c0(a, b) {
+        }
+        cy(a, b) {
+        }
+        cz(a, b) {
+            this.c6(a, b);
+        }
+        cx(a, b) {
+        }
+        cu(a, b) {
+        }
+        cv(a, b) {
+            this.c6(a, b);
+        }
+        ct(a, b) {
+            this.cn(b, (c, d) => {
+                c.e = 1;
+                if (!c.ar) {
+                    c.ar = true;
+                }
+                let e = this.m(a, b.b, b.c);
+                let f = e.ad;
+                if (f == null) {
+                    f = false;
+                }
+                if (typeof f === 'string') {
+                    let g;
+                    if (((() => { let h = tryParseBool(f, g); g = h.p1; return h.ret; })())) {
+                        f = g;
+                        let h = this.af;
+                        this.af = true;
+                        e.ad = f;
+                        this.af = h;
+                    }
+                }
+                if (typeof f === 'number') {
+                    if (typeGetValue(f) > 0) {
+                        f = true;
+                        let i = this.af;
+                        this.af = true;
+                        e.ad = f;
+                        this.af = i;
+                    }
+                }
+                if (typeof f === 'number') {
+                    if (f > 0) {
+                        f = true;
+                        let j = this.af;
+                        this.af = true;
+                        e.ad = f;
+                        this.af = j;
+                    }
+                }
+                let k = f;
+                c.as = k;
+                c.v = e;
+                if (d) {
+                    c.aq = runOn(this, this.cf);
+                }
+            });
+        }
+        m(a, b, c) {
+            if (this.ag) {
+                let d = this.actualProperties.ae;
+                let e = d;
+                let f = truncate((this.ap.count / 2));
+                let g = b * f;
+                let 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;
+            }
+        }
+        bn(a) {
+            return this.am.item(a);
+        }
+        cf(a, b) {
+            let c = a;
+            let d = c.v;
+            this.af = true;
+            d.ad = c.as;
+            d.am();
+            this.af = false;
+            this.dv(d);
+        }
+        cs(a, b) {
+        }
+        dq(a, b, c) {
+            if (this.v != null) {
+                this.c.notifySetItem(a, b, c);
+            }
+        }
+        dm() {
+            if (this.v != null) {
+                this.c.notifyClearItems();
+            }
+        }
+        dn(a, b) {
+            if (this.v != null) {
+                this.c.notifyInsertItem(a, b);
+            }
+            ;
+        }
+        dp(a, b) {
+            if (this.v != null) {
+                this.c.notifyRemoveItem(a, b);
+            }
+            ;
+        }
+        get h() {
+            return this.f;
+        }
+        set h(a) {
+            let b = this.f;
+            this.f = a;
+            this.du("ActualContext", b, this.f);
+        }
+        get i() {
+            return this.g;
+        }
+        set i(a) {
+            let b = this.g;
+            this.g = a;
+            this.du("DescriptionContext", b, this.g);
+        }
+        get e() {
+            return this.d;
+        }
+        set e(a) {
+            let b = this.d;
+            this.d = a;
+            this.du("ComponentRenderer", b, this.d);
+        }
+        get bs() {
+            return this.bq;
+        }
+        set bs(a) {
+            let b = this.bq;
+            this.bq = a;
+            this.du("Target", b, this.bq);
+        }
+        get b2() {
+            return this.bu;
+        }
+        set b2(a) {
+            let b = this.bu;
+            this.bu = a;
+            this.du("DescriptionType", b, this.bu);
+        }
+        get ag() {
+            return this.aa;
+        }
+        set ag(a) {
+            let b = this.aa;
+            this.aa = a;
+            this.du("IsHorizontal", b, this.aa);
+        }
+        get ai() {
+            return this.ac;
+        }
+        set ai(a) {
+            let b = this.ac;
+            this.ac = a;
+            this.du("IsWrappingEnabled", b, this.ac);
+        }
+        get ah() {
+            return this.ab;
+        }
+        set ah(a) {
+            let b = this.ab;
+            this.ab = a;
+            this.du("IsIndirectModeEnabled", b, this.ab);
+        }
+        get d6() {
+            return this.d4;
+        }
+        set d6(a) {
+            let b = this.d4;
+            this.d4 = a;
+            if (b != this.d4) {
+                this.du("BackgroundColor", b, a);
+            }
+        }
+        get d9() {
+            return this.d5;
+        }
+        set d9(a) {
+            let b = this.d5;
+            this.d5 = a;
+            if (b != this.d5) {
+                this.du("TextColor", b, a);
+            }
+        }
+        ce() {
+            let a = this.c;
+            if (null != a) {
+                if (null == a.actualSchema) {
+                    this.bl = -1;
+                    return;
+                }
+                let b = a.actualCount;
+                this.bl = b;
+            }
+            else {
+                this.bl = -1;
+            }
+        }
+    }
+    PropertyEditorPanel.$t = /*@__PURE__*/ markType(PropertyEditorPanel, 'PropertyEditorPanel', Base.$, [INotifyPropertyChanged_$type]);
+    PropertyEditorPanel.d7 = /*@__PURE__*/ BrushUtil.g(255, 248, 248, 248);
+    PropertyEditorPanel.d8 = /*@__PURE__*/ BrushUtil.g(255, 24, 29, 31);
+    return PropertyEditorPanel;
+})();