igniteui-webcomponents-layouts 7.1.1-beta.1 → 7.1.1-beta.3

package/esm2022/lib/ComboEditorView_combined.js

@@ -0,0 +1,2563 @@
+/*
+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, runOn, typeCast, fromEnum, markType, INotifyPropertyChanged_$type, PropertyChangedEventArgs, enumGetBox, String_$type, delegateRemove, delegateCombine, Array_$type } from "igniteui-webcomponents-core";
+import { Rect } from "igniteui-webcomponents-core";
+import { NativeUIComponent } from "igniteui-webcomponents-core";
+import { XInputGroup } from "igniteui-webcomponents-inputs";
+import { XLabel } from "igniteui-webcomponents-inputs";
+import { List$1 } from "igniteui-webcomponents-core";
+import { XInput } from "igniteui-webcomponents-inputs";
+import { NativeUIContent } from "igniteui-webcomponents-core";
+import { FontInfo } from "igniteui-webcomponents-core";
+import { SRProvider } from "igniteui-webcomponents-core";
+import { DeviceUtils } from "igniteui-webcomponents-core";
+import { BaseControlTheme_$type } from "igniteui-webcomponents-core";
+import { Thickness } from "igniteui-webcomponents-core";
+import { CornerRadius } from "igniteui-webcomponents-core";
+import { ControlDisplayDensity_$type } from "igniteui-webcomponents-core";
+import { StringComparer } from "igniteui-webcomponents-core";
+import { InputGroupDisplayType_$type } from "igniteui-webcomponents-inputs";
+import { ThemeResolver } from "igniteui-webcomponents-inputs";
+import { ComboEditorTextChangedEventArgs } from "./ComboEditorTextChangedEventArgs";
+import { ComboEditorValueChangedEventArgs } from "./ComboEditorValueChangedEventArgs";
+import { FastReflectionHelper } from "igniteui-webcomponents-core";
+import { ComboEditorVisualModelExport } from "./ComboEditorVisualModelExport";
+import { AppearanceHelper } from "igniteui-webcomponents-core";
+import { FontUtil } from "igniteui-webcomponents-core";
+import { ComboEditorGotFocusEventArgs } from "./ComboEditorGotFocusEventArgs";
+import { ComboEditorLostFocusEventArgs } from "./ComboEditorLostFocusEventArgs";
+import { KeyEventArgs } from "igniteui-webcomponents-core";
+import { InputChangeEventArgs } from "igniteui-webcomponents-inputs";
+import { FilterFactory } from "igniteui-webcomponents-core";
+import { IDataSourceUpdateNotifier_$type } from "igniteui-webcomponents-core";
+import { ComboEditorMultipleDataSourceNotifier } from "./ComboEditorMultipleDataSourceNotifier";
+import { BrushUtil } from "igniteui-webcomponents-core";
+import { isNaN_ } from "igniteui-webcomponents-core";
+import { stringIsNullOrEmpty, stringEmpty, stringIsNullOrWhiteSpace } from "igniteui-webcomponents-core";
+/**
+ * @hidden
+ */
+class ComboEditorView extends Base {
+    static { this.$t = markType(ComboEditorView, 'ComboEditorView'); }
+    constructor(a) {
+        super();
+        this.b = false;
+        this.a = null;
+        this.c = null;
+        this.a = a;
+    }
+    g() {
+    }
+    r() {
+        let a = this.c.rootWrapper.getNativeElement();
+        let b = (a.getBoundingClientRect());
+        return new Rect(0, b.left + window.pageXOffset, b.top + window.pageYOffset, b.width, b.height);
+    }
+    f(a, b) {
+        this.c.getPortal(a.ao, "ListPanel", (c) => {
+            let d = c.componentRef;
+            let e = (d.i);
+            b(e);
+        }, false);
+    }
+    i() {
+        if (this.b) {
+            this.b = false;
+            window.addEventListener("resize", runOn(this, this.q), false);
+        }
+    }
+    h() {
+        if (!this.b) {
+            this.b = true;
+            window.removeEventListener("resize", runOn(this, this.q), false);
+        }
+    }
+    q(a) {
+        let b = this.a.bh;
+        if (null == b || false == b.b7) {
+            return;
+        }
+        let c = this.r();
+        this.a.bh.cf(c);
+    }
+    k(a) {
+        let b = this.a;
+        let c = typeCast(XInputGroup.$, a.ao);
+        if (c != null) {
+            c.oi = b.k4;
+            c.ks = b.jg;
+            c.no = b.j7;
+            c.eg = b.cx;
+            c.np = b.j8;
+            c.eh = b.cy;
+            c.ei = b.cz;
+            c.nq = b.j9;
+            c.ej = b.c0;
+            c.ek = b.c1;
+            c.n6 = b.ke;
+            c.e5 = b.c2;
+            c.n7 = b.kf;
+            c.e6 = b.c3;
+            c.e7 = b.c4;
+            c.e8 = b.c5;
+            for (let d of fromEnum(c.inputs)) {
+                if (d != null && typeCast(XInput.$, d) !== null) {
+                    d.cg = b.gc;
+                }
+            }
+            for (let e of fromEnum(c.inputs)) {
+                if (e != null && typeCast(XLabel.$, e) !== null) {
+                    e.dj = b.ka;
+                    let f = e;
+                    if (b.av != null) {
+                        f.y = b.av;
+                    }
+                }
+            }
+        }
+    }
+    l(a) {
+        if (this.a.be != null) {
+            let b = this.a.be.ao;
+            for (let c = 0; c < b.inputs.count; c++) {
+                if (typeCast(XInput.$, b.inputs._inner[c]) !== null) {
+                    b.inputs._inner[c].e = a;
+                }
+            }
+        }
+    }
+    o() {
+        if (this.a.disallowTabFocus) {
+            let a = this.a.bb.ao;
+            if (a != null) {
+                a.setAttribute("tabIndex", "-1");
+            }
+            if (this.a.be != null) {
+                let b = this.a.be.ao;
+                for (let c = 0; c < b.inputs.count; c++) {
+                    if (typeCast(XInput.$, b.inputs._inner[c]) !== null) {
+                        b.inputs._inner[c].be = -1;
+                    }
+                }
+            }
+        }
+        else {
+            let d = this.a.bb.ao;
+            if (d != null) {
+                d.setAttribute("tabIndex", "0");
+            }
+            if (this.a.be != null) {
+                let e = this.a.be.ao;
+                for (let f = 0; f < e.inputs.count; f++) {
+                    if (typeCast(XInput.$, e.inputs._inner[f]) !== null) {
+                        e.inputs._inner[f].cu();
+                    }
+                }
+            }
+        }
+    }
+    n() {
+        if (this.a.bh != null) {
+            let a = this.a.bh.ao;
+            a.ar = this.a.b4;
+        }
+    }
+    p() {
+        if (this.a.bh != null) {
+            let a = this.a.bh.ao;
+            a.ay = this.a.cb;
+        }
+    }
+    j(a) {
+        if (a == null) {
+            this.i();
+            this.c = null;
+            return;
+        }
+        this.c = a;
+        NativeUIComponent.av(this.c, 7, (b) => {
+            this.c.append(b.ao);
+            this.a.ie(b);
+        });
+        this.h();
+    }
+    d() {
+        return this.c;
+    }
+    m(a, b) {
+    }
+    e(a, b) {
+        let c = (a.ao);
+        c.remove();
+        c.append(b.view.j.rootWrapper);
+    }
+}
+export { ComboEditorView };
+/**
+ * @hidden
+ */
+class ComboEditor extends Base {
+    static { this.$t = markType(ComboEditor, 'ComboEditor', Base.$, [INotifyPropertyChanged_$type]); }
+    static { this.ag = 1; }
+    static { this.ki = ThemeResolver.aj(ComboEditor.ag, XLabel.de, XLabel.c7); }
+    static { this.kk = ThemeResolver.aj(ComboEditor.ag, XLabel.de, XLabel.c7); }
+    static { this.kj = BrushUtil.l(255, 255, 255, 255); }
+    constructor() {
+        super();
+        this.d0 = null;
+        this.kl = XInputGroup.m.af(ComboEditor.ag, enumGetBox(InputGroupDisplayType_$type, 0), "BackgroundColor");
+        this.km = XInputGroup.m.af(ComboEditor.ag, enumGetBox(InputGroupDisplayType_$type, 0), "BorderColor");
+        this.c8 = XInputGroup.m.i(ComboEditor.ag, enumGetBox(InputGroupDisplayType_$type, 0), "BorderWidth");
+        this.k6 = XInputGroup.m.ak(ComboEditor.ag, enumGetBox(InputGroupDisplayType_$type, 0), "ContentPadding");
+        this.ji = XInputGroup.m.z(ComboEditor.ag, enumGetBox(InputGroupDisplayType_$type, 0), "CornerRadius");
+        this.kn = XInputGroup.m.af(ComboEditor.ag, enumGetBox(InputGroupDisplayType_$type, 0), "FocusBorderColor");
+        this.c9 = XInputGroup.m.i(ComboEditor.ag, enumGetBox(InputGroupDisplayType_$type, 0), "FocusBorderWidth");
+        this.ko = XInputGroup.m.af(ComboEditor.ag, enumGetBox(InputGroupDisplayType_$type, 0), "FocusUnderlineColor");
+        this.da = XInputGroup.m.i(ComboEditor.ag, enumGetBox(InputGroupDisplayType_$type, 0), "FocusUnderlineOpacity");
+        this.db = XInputGroup.m.i(ComboEditor.ag, enumGetBox(InputGroupDisplayType_$type, 0), "FocusUnderlineRippleOpacity");
+        this.kp = XInputGroup.m.af(ComboEditor.ag, enumGetBox(InputGroupDisplayType_$type, 0), "HoverUnderlineColor");
+        this.dc = XInputGroup.m.i(ComboEditor.ag, enumGetBox(InputGroupDisplayType_$type, 0), "HoverUnderlineOpacity");
+        this.dd = XInputGroup.m.i(ComboEditor.ag, enumGetBox(InputGroupDisplayType_$type, 0), "HoverUnderlineWidth");
+        this.kq = XInputGroup.m.af(ComboEditor.ag, enumGetBox(InputGroupDisplayType_$type, 0), "UnderlineColor");
+        this.de = XInputGroup.m.i(ComboEditor.ag, enumGetBox(InputGroupDisplayType_$type, 0), "UnderlineOpacity");
+        this.kr = XInputGroup.m.af(ComboEditor.ag, enumGetBox(InputGroupDisplayType_$type, 0), "UnderlineRippleColor");
+        this.df = XInputGroup.m.i(ComboEditor.ag, enumGetBox(InputGroupDisplayType_$type, 0), "FocusUnderlineRippleOpacity");
+        this.dg = XInputGroup.m.i(ComboEditor.ag, enumGetBox(InputGroupDisplayType_$type, 0), "UnderlineRippleWidth");
+        this.dh = XInputGroup.m.i(ComboEditor.ag, enumGetBox(InputGroupDisplayType_$type, 0), "HoverUnderlineWidth");
+        this.bi = null;
+        this.a0 = null;
+        this.ab = null;
+        this.bl = false;
+        this.c = null;
+        this.ju = null;
+        this.jj = ThemeResolver.ah(ComboEditor.ag, XInputGroup.m, enumGetBox(InputGroupDisplayType_$type, 0), "BackgroundColor");
+        this.af = 0;
+        this.ae = 1;
+        this.jv = null;
+        this.jk = ThemeResolver.ah(ComboEditor.ag, XInputGroup.m, enumGetBox(InputGroupDisplayType_$type, 0), "BorderColor");
+        this.cm = NaN;
+        this.cc = ThemeResolver.k(ComboEditor.ag, XInputGroup.m, enumGetBox(InputGroupDisplayType_$type, 0), "BorderWidth");
+        this.k3 = new Thickness(1, NaN, NaN, NaN, NaN);
+        this.k2 = ThemeResolver.am(ComboEditor.ag, XInputGroup.m, enumGetBox(InputGroupDisplayType_$type, 0), "ContentPadding");
+        this.jf = new CornerRadius(1, NaN, NaN, NaN, NaN);
+        this.je = ThemeResolver.ab(ComboEditor.ag, XInputGroup.m, enumGetBox(InputGroupDisplayType_$type, 0), "CornerRadius");
+        this.b = null;
+        this.al = 0;
+        this.ak = 0;
+        this.bw = true;
+        this.jw = null;
+        this.jl = ThemeResolver.ah(ComboEditor.ag, XInputGroup.m, enumGetBox(InputGroupDisplayType_$type, 0), "FocusBorderColor");
+        this.cn = NaN;
+        this.cd = ThemeResolver.k(ComboEditor.ag, XInputGroup.m, enumGetBox(InputGroupDisplayType_$type, 0), "FocusBorderWidth");
+        this.jx = null;
+        this.jm = ThemeResolver.ah(ComboEditor.ag, XInputGroup.m, enumGetBox(InputGroupDisplayType_$type, 0), "FocusUnderlineColor");
+        this.co = NaN;
+        this.ce = ThemeResolver.k(ComboEditor.ag, XInputGroup.m, enumGetBox(InputGroupDisplayType_$type, 0), "FocusUnderlineOpacity");
+        this.cp = NaN;
+        this.cf = ThemeResolver.k(ComboEditor.ag, XInputGroup.m, enumGetBox(InputGroupDisplayType_$type, 0), "FocusUnderlineRippleOpacity");
+        this.jy = null;
+        this.jn = ThemeResolver.ah(ComboEditor.ag, XInputGroup.m, enumGetBox(InputGroupDisplayType_$type, 0), "HoverUnderlineColor");
+        this.cq = NaN;
+        this.cg = ThemeResolver.k(ComboEditor.ag, XInputGroup.m, enumGetBox(InputGroupDisplayType_$type, 0), "HoverUnderlineOpacity");
+        this.cr = NaN;
+        this.ch = ThemeResolver.k(ComboEditor.ag, XInputGroup.m, enumGetBox(InputGroupDisplayType_$type, 0), "HoverUnderlineWidth");
+        this.du = null;
+        this.f2 = null;
+        this.jz = null;
+        this.jo = ComboEditor.ki;
+        this.as = null;
+        this.ap = null;
+        this.bs = false;
+        this.f5 = null;
+        this.er = "No Matches Found";
+        this.j0 = null;
+        this.jp = ComboEditor.kj;
+        this.j1 = null;
+        this.jq = ComboEditor.kk;
+        this.at = null;
+        this.aq = null;
+        this.gd = "";
+        this.j2 = ComboEditor.ks;
+        this.jr = ComboEditor.ks;
+        this.au = null;
+        this.ar = null;
+        this.j3 = null;
+        this.js = ThemeResolver.ah(ComboEditor.ag, XInputGroup.m, enumGetBox(InputGroupDisplayType_$type, 0), "UnderlineColor");
+        this.cs = NaN;
+        this.ci = ThemeResolver.k(ComboEditor.ag, XInputGroup.m, enumGetBox(InputGroupDisplayType_$type, 0), "UnderlineOpacity");
+        this.j4 = null;
+        this.jt = ThemeResolver.ah(ComboEditor.ag, XInputGroup.m, enumGetBox(InputGroupDisplayType_$type, 0), "UnderlineRippleColor");
+        this.ct = NaN;
+        this.cj = ThemeResolver.k(ComboEditor.ag, XInputGroup.m, enumGetBox(InputGroupDisplayType_$type, 0), "UnderlineRippleOpacity");
+        this.cu = NaN;
+        this.ck = ThemeResolver.k(ComboEditor.ag, XInputGroup.m, enumGetBox(InputGroupDisplayType_$type, 0), "UnderlineRippleWidth");
+        this.cv = NaN;
+        this.cl = ThemeResolver.k(ComboEditor.ag, XInputGroup.m, enumGetBox(InputGroupDisplayType_$type, 0), "UnderlineWidth");
+        this.bk = true;
+        this.d6 = null;
+        this.d5 = null;
+        this.d = null;
+        this.a = null;
+        this.dv = null;
+        this.q = 0;
+        this.b2 = false;
+        this.bn = false;
+        this.bq = false;
+        this.br = false;
+        this.gotFocus = null;
+        this.lostFocus = null;
+        this.textValueChanged = null;
+        this.selectedValueChanged = null;
+        this.keyDown = null;
+        this.change = null;
+        this.changing = null;
+        this.propertyChanged = null;
+        this.a6 = null;
+        this.a9 = null;
+        this.a7 = null;
+        this.bd = null;
+        this.bg = null;
+        this.ac = null;
+        this.d7 = null;
+        this.ca = true;
+        this.dt = 0;
+        this.b6 = false;
+        this.l = null;
+        this.v = 0;
+        this.b5 = false;
+        this.b1 = false;
+        this.b0 = false;
+        this.by = false;
+        this.ba = null;
+        this.a5 = null;
+        this.n = null;
+        this.ds = -1;
+        this.bo = false;
+        this.b8 = false;
+        this.bp = false;
+        this.bm = false;
+        this.a8 = null;
+        this.bf = null;
+        let a = this.aa();
+        this.ab = a;
+    }
+    gz() {
+        let a = this.ad;
+        a.dw = -1;
+    }
+    get bj() {
+        if (this.bi == null) {
+            this.bi = new SRProvider(this.ab.c);
+            this.bi.cb("ComboEditor");
+        }
+        return this.bi;
+    }
+    aa() {
+        return new ComboEditorView(this);
+    }
+    iq(a, b, c) {
+        switch (a) {
+            case "BackgroundColor":
+                this.j5 = this.kg != null ? this.kg : this.kl;
+                break;
+            case "BorderColor":
+                this.j6 = this.kh != null ? this.kh : this.km;
+                break;
+            case "BorderWidth":
+                this.cw = !isNaN_(this.c6) ? this.c6 : this.c8;
+                break;
+            case "ContentPadding":
+                this.k4 = XInputGroup.oh(this.k5, this.k6);
+                break;
+            case "CornerRadius":
+                this.jg = XInputGroup.kr(this.jh, this.ji);
+                break;
+            case "FocusBorderColor":
+                this.j7 = this.kt != null ? this.kt : this.kn;
+                break;
+            case "FocusBorderWidth":
+                this.cx = !isNaN_(this.di) ? this.di : this.c9;
+                break;
+            case "FocusUnderlineColor":
+                this.j8 = this.ku != null ? this.ku : this.ko;
+                break;
+            case "FocusUnderlineOpacity":
+                this.cy = !isNaN_(this.dj) ? this.dj : this.da;
+                break;
+            case "FocusUnderlineRippleOpacity":
+                this.cz = !isNaN_(this.dk) ? this.dk : this.db;
+                break;
+            case "HoverUnderlineColor":
+                this.j9 = this.kv != null ? this.kv : this.kp;
+                break;
+            case "HoverUnderlineOpacity":
+                this.c0 = !isNaN_(this.dl) ? this.dl : this.dc;
+                break;
+            case "HoverUnderlineWidth":
+                this.c1 = !isNaN_(this.dm) ? this.dm : this.dd;
+                break;
+            case "ItemsSource":
+            case "ValueField":
+            case "DataSourceDesiredProperties":
+            case "Fields":
+                this.jb();
+                break;
+            case "LabelTextColor":
+                this.ka = this.kw != null ? this.kw : ComboEditor.ki;
+                break;
+            case "LabelTextStyle":
+                this.av = this.a2 != null ? this.a2 : ComboEditor.ay;
+                break;
+            case "NoMatchesFoundLabelTextColor":
+                this.kc = this.ky != null ? this.ky : ComboEditor.kk;
+                break;
+            case "NoMatchesFoundLabelBackgroundColor":
+                this.kb = this.kx != null ? this.kx : ComboEditor.kj;
+                break;
+            case "NoMatchesFoundLabelTextStyle":
+                this.aw = this.a3 != null ? this.a3 : ComboEditor.az;
+                break;
+            case "UnderlineColor":
+                this.ke = this.k0 != null ? this.k0 : this.kq;
+                break;
+            case "UnderlineOpacity":
+                this.c2 = !isNaN_(this.dn) ? this.dn : this.de;
+                break;
+            case "UnderlineRippleColor":
+                this.kf = this.k1 != null ? this.k1 : this.kr;
+                break;
+            case "UnderlineRippleOpacity":
+                this.c3 = !isNaN_(this.dp) ? this.dp : this.df;
+                break;
+            case "UnderlineRippleWidth":
+                this.c4 = !isNaN_(this.dq) ? this.dq : this.dg;
+                break;
+            case "UnderlineWidth":
+                this.c5 = !isNaN_(this.dr) ? this.dr : this.dh;
+                break;
+            case "BaseTheme":
+                this.ah = this.ai == 0 ? 1 : this.ai;
+                break;
+            case "Density":
+                this.am = this.density == 0 ? 0 : this.density;
+                break;
+            case "TextColor":
+                this.kd = this.kz != null ? this.kz : ComboEditor.ks;
+                break;
+            case "TextStyle":
+                this.ax = this.a4 != null ? this.a4 : null;
+                break;
+            case "ActualDensity":
+            case "ActualBaseTheme":
+            case "ActualTextColor":
+            case "ActualTextStyle":
+            case "DisplayType":
+            case "ActualBackgroundColor":
+            case "ActualBorderColor":
+            case "ActualBorderWidth":
+            case "ActualContentPadding":
+            case "ActualCornerRadius":
+            case "ActualFocusBorderColor":
+            case "ActualFocusBorderWidth":
+            case "ActualFocusUnderlineColor":
+            case "ActualFocusUnderlineOpacity":
+            case "ActualFocusUnderlineRippleOpacity":
+            case "ActualHoverUnderlineColor":
+            case "ActualHoverUnderlineOpacity":
+            case "ActualHoverUnderlineWidth":
+            case "ActualLabelTextColor":
+            case "ActualLabelTextStyle":
+            case "ActualUnderlineColor":
+            case "ActualUnderlineOpacity":
+            case "ActualUnderlineRippleColor":
+            case "ActualUnderlineRippleOpacity":
+            case "ActualUnderlineRippleWidth":
+            case "ActualUnderlineWidth":
+            case "DropDownButtonVisible":
+            case "ActualNoMatchesFoundLabel":
+            case "ActualNoMatchesFoundLabelTextColor":
+            case "ActualNoMatchesFoundLabelTextStyle":
+            case ComboEditor.et:
+                this.i2();
+                break;
+            case "NoMatchesFoundLabel":
+                this.actualNoMatchesFoundLabel = stringIsNullOrEmpty(this.f6) ? "No Matches Found" : this.f6;
+                break;
+            case "Label":
+            case "PlaceholderText":
+                this.i2();
+                this.actualLabelVisible = !stringIsNullOrEmpty(this.f2);
+                break;
+            case "Text":
+                this.i6();
+                let d = b != null ? b.toString() : null;
+                let e = c != null ? c.toString() : null;
+                this.id(new ComboEditorTextChangedEventArgs(d, e));
+                this.ip(1, e);
+                break;
+            case "Value":
+                this.ia(new ComboEditorValueChangedEventArgs(b, c));
+                this.ip(0, c);
+                break;
+            case "AllowFilter":
+                this.g7(this.bu);
+                break;
+            case "DisallowTabFocus":
+                this.ab.o();
+                break;
+            case "IsFixed":
+                this.ab.n();
+                break;
+            case "UseTopLayer":
+                this.ab.p();
+                break;
+        }
+    }
+    get a1() {
+        if (null == this.a0) {
+            this.a0 = new FontInfo();
+            this.a0.q = "Verdana";
+            this.a0.f = DeviceUtils.f(16);
+        }
+        return this.a0;
+    }
+    focus(a) {
+        this.g9(a);
+    }
+    setName(a) {
+        this.ab.l(a);
+    }
+    get disallowTabFocus() {
+        return this.bl;
+    }
+    set disallowTabFocus(a) {
+        let b = this.bl;
+        this.bl = a;
+        if (b != this.bl) {
+            this.h7("DisallowTabFocus", b, this.bl);
+        }
+    }
+    get g() {
+        return this.c;
+    }
+    set g(a) {
+        let b = this.c;
+        this.c = a;
+        if (b != this.c) {
+            this.h7("Fields", b, this.c);
+        }
+    }
+    get kg() {
+        return this.ju;
+    }
+    set kg(a) {
+        let b = this.ju;
+        this.ju = a;
+        if (b != this.ju) {
+            this.h7("BackgroundColor", b, a);
+        }
+    }
+    get j5() {
+        return this.jj;
+    }
+    set j5(a) {
+        let b = this.jj;
+        this.jj = a;
+        if (b != this.jj) {
+            this.h7("ActualBackgroundColor", b, a);
+        }
+    }
+    get ai() {
+        return this.af;
+    }
+    set ai(a) {
+        let b = this.af;
+        this.af = a;
+        if (b != this.af) {
+            this.h7("BaseTheme", enumGetBox(BaseControlTheme_$type, b), enumGetBox(BaseControlTheme_$type, a));
+        }
+    }
+    get ah() {
+        return this.ae;
+    }
+    set ah(a) {
+        let b = this.ae;
+        this.ae = a;
+        if (b != this.ae) {
+            this.h7("ActualBaseTheme", enumGetBox(BaseControlTheme_$type, b), enumGetBox(BaseControlTheme_$type, a));
+        }
+    }
+    get kh() {
+        return this.jv;
+    }
+    set kh(a) {
+        let b = this.jv;
+        this.jv = a;
+        if (b != this.jv) {
+            this.h7("BorderColor", b, a);
+        }
+    }
+    get j6() {
+        return this.jk;
+    }
+    set j6(a) {
+        let b = this.jk;
+        this.jk = a;
+        if (b != this.jk) {
+            this.h7("ActualBorderColor", b, a);
+        }
+    }
+    get c6() {
+        return this.cm;
+    }
+    set c6(a) {
+        let b = this.cm;
+        this.cm = a;
+        if (b != this.cm) {
+            this.h7("BorderWidth", b, a);
+        }
+    }
+    get cw() {
+        return this.cc;
+    }
+    set cw(a) {
+        let b = this.cc;
+        this.cc = a;
+        if (b != this.cc) {
+            this.h7("ActualBorderWidth", b, a);
+        }
+    }
+    get k5() {
+        return this.k3;
+    }
+    set k5(a) {
+        let b = this.k3;
+        this.k3 = a;
+        if (b != this.k3) {
+            this.h7("ContentPadding", b, a);
+        }
+    }
+    get k4() {
+        return this.k2;
+    }
+    set k4(a) {
+        let b = this.k2;
+        this.k2 = a;
+        if (b != this.k2) {
+            this.h7("ActualContentPadding", b, a);
+        }
+    }
+    get jh() {
+        return this.jf;
+    }
+    set jh(a) {
+        let b = this.jf;
+        this.jf = a;
+        if (b != this.jf) {
+            this.h7("CornerRadius", b, a);
+        }
+    }
+    get jg() {
+        return this.je;
+    }
+    set jg(a) {
+        let b = this.je;
+        this.je = a;
+        if (b != this.je) {
+            this.h7("ActualCornerRadius", b, a);
+        }
+    }
+    get f() {
+        return this.b;
+    }
+    set f(a) {
+        let b = this.b;
+        this.b = a;
+        if (b != this.b) {
+            this.h7("DataSourceDesiredProperties", b, this.b);
+        }
+    }
+    get density() {
+        return this.al;
+    }
+    set density(a) {
+        let b = this.al;
+        this.al = a;
+        if (b != this.al) {
+            this.h7("Density", enumGetBox(ControlDisplayDensity_$type, b), enumGetBox(ControlDisplayDensity_$type, a));
+        }
+    }
+    get am() {
+        return this.ak;
+    }
+    set am(a) {
+        let b = this.ak;
+        this.ak = a;
+        if (b != this.ak) {
+            this.h7("ActualDensity", enumGetBox(ControlDisplayDensity_$type, b), enumGetBox(ControlDisplayDensity_$type, a));
+        }
+    }
+    get dropDownButtonVisible() {
+        return this.bw;
+    }
+    set dropDownButtonVisible(a) {
+        let b = this.bw;
+        this.bw = a;
+        if (b != this.bw) {
+            this.h7("DropDownButtonVisible", b, a);
+        }
+    }
+    get kt() {
+        return this.jw;
+    }
+    set kt(a) {
+        let b = this.jw;
+        this.jw = a;
+        if (b != this.jw) {
+            this.h7("FocusBorderColor", b, a);
+        }
+    }
+    get j7() {
+        return this.jl;
+    }
+    set j7(a) {
+        let b = this.jl;
+        this.jl = a;
+        if (b != this.jl) {
+            this.h7("ActualFocusBorderColor", b, a);
+        }
+    }
+    get di() {
+        return this.cn;
+    }
+    set di(a) {
+        let b = this.cn;
+        this.cn = a;
+        if (b != this.cn) {
+            this.h7("FocusBorderWidth", b, a);
+        }
+    }
+    get cx() {
+        return this.cd;
+    }
+    set cx(a) {
+        let b = this.cd;
+        this.cd = a;
+        if (b != this.cd) {
+            this.h7("ActualFocusBorderWidth", b, a);
+        }
+    }
+    get ku() {
+        return this.jx;
+    }
+    set ku(a) {
+        let b = this.jx;
+        this.jx = a;
+        if (b != this.jx) {
+            this.h7("FocusUnderlineColor", b, a);
+        }
+    }
+    get j8() {
+        return this.jm;
+    }
+    set j8(a) {
+        let b = this.jm;
+        this.jx = a;
+        if (b != this.jm) {
+            this.h7("ActualFocusUnderlineColor", b, a);
+        }
+    }
+    get dj() {
+        return this.co;
+    }
+    set dj(a) {
+        let b = this.co;
+        this.co = a;
+        if (b != this.co) {
+            this.h7("FocusUnderlineOpacity", b, a);
+        }
+    }
+    get cy() {
+        return this.ce;
+    }
+    set cy(a) {
+        let b = this.ce;
+        this.ce = a;
+        if (b != this.ce) {
+            this.h7("ActualFocusUnderlineOpacity", b, a);
+        }
+    }
+    get dk() {
+        return this.cp;
+    }
+    set dk(a) {
+        let b = this.cp;
+        this.cp = a;
+        if (b != this.cp) {
+            this.h7("FocusUnderlineRippleOpacity", b, a);
+        }
+    }
+    get cz() {
+        return this.cf;
+    }
+    set cz(a) {
+        let b = this.cf;
+        this.cf = a;
+        if (b != this.cf) {
+            this.h7("ActualFocusUnderlineRippleOpacity", b, a);
+        }
+    }
+    get kv() {
+        return this.jy;
+    }
+    set kv(a) {
+        let b = this.jy;
+        this.jy = a;
+        if (b != this.jy) {
+            this.h7("HoverUnderlineColor", b, a);
+        }
+    }
+    get j9() {
+        return this.jn;
+    }
+    set j9(a) {
+        let b = this.jn;
+        this.jn = a;
+        if (b != this.jn) {
+            this.h7("ActualHoverUnderlineColor", b, a);
+        }
+    }
+    get dl() {
+        return this.cq;
+    }
+    set dl(a) {
+        let b = this.cq;
+        this.cq = a;
+        if (b != this.cq) {
+            this.h7("HoverUnderlineOpacity", b, a);
+        }
+    }
+    get c0() {
+        return this.cg;
+    }
+    set c0(a) {
+        let b = this.cg;
+        this.cg = a;
+        if (b != this.cg) {
+            this.h7("ActualHoverUnderlineOpacity", b, a);
+        }
+    }
+    get dm() {
+        return this.cr;
+    }
+    set dm(a) {
+        let b = this.cr;
+        this.cr = a;
+        if (b != this.cr) {
+            this.h7("HoverUnderlineWidth", b, a);
+        }
+    }
+    get c1() {
+        return this.ch;
+    }
+    set c1(a) {
+        let b = this.ch;
+        this.ch = a;
+        if (b != this.ch) {
+            this.h7("ActualHoverUnderlineWidth", b, a);
+        }
+    }
+    get itemsSource() {
+        return this.du;
+    }
+    set itemsSource(a) {
+        let b = this.du;
+        this.du = a;
+        if (b != this.du) {
+            this.h7("ItemsSource", b, this.du);
+        }
+    }
+    get actualDataSource() {
+        return this.m();
+    }
+    get f0() {
+        return this.f2;
+    }
+    set f0(a) {
+        let b = this.f0;
+        if (0 == StringComparer.b.compare(a, b)) {
+            return;
+        }
+        this.f2 = a;
+        this.h7("Label", b, this.f2);
+    }
+    get kw() {
+        return this.jz;
+    }
+    set kw(a) {
+        let b = this.jz;
+        this.jz = a;
+        if (b != this.jz) {
+            this.h7("LabelTextColor", b, a);
+        }
+    }
+    get ka() {
+        return this.jo;
+    }
+    set ka(a) {
+        let b = this.jo;
+        this.jo = a;
+        if (b != this.jo) {
+            this.h7("ActualLabelTextColor", b, a);
+        }
+    }
+    static { this.ay = null; }
+    get a2() {
+        return this.as;
+    }
+    set a2(a) {
+        let b = this.as;
+        this.as = a;
+        if (b != this.as) {
+            this.h7("LabelTextStyle", b, this.as);
+        }
+    }
+    get av() {
+        return this.ap;
+    }
+    set av(a) {
+        let b = this.ap;
+        this.ap = a;
+        if (this.ap != b) {
+            this.h7("ActualLabelTextStyle", b, this.ap);
+        }
+    }
+    get actualLabelVisible() {
+        return this.bs;
+    }
+    set actualLabelVisible(a) {
+        let b = this.bs;
+        this.bs = a;
+        if (b != this.bs) {
+            this.h7("ActualLabelVisible", b, a);
+        }
+    }
+    get f6() {
+        return this.f5;
+    }
+    set f6(a) {
+        let b = this.f5;
+        if (0 == StringComparer.b.compare(a, b)) {
+            return;
+        }
+        this.f5 = a;
+        this.h7("NoMatchesFoundLabel", b, this.f5);
+    }
+    get actualNoMatchesFoundLabel() {
+        return this.er;
+    }
+    set actualNoMatchesFoundLabel(a) {
+        let b = this.er;
+        this.er = a;
+        if (b != this.er) {
+            this.h7("ActualNoMatchesFoundLabel", b, a);
+        }
+    }
+    get kx() {
+        return this.j0;
+    }
+    set kx(a) {
+        let b = this.j0;
+        this.j0 = a;
+        if (b != this.j0) {
+            this.h7("NoMatchesFoundLabelBackgroundColor", b, a);
+        }
+    }
+    static { this.et = "ActualNoMatchesFoundLabelBackgroundColor"; }
+    get kb() {
+        return this.jp;
+    }
+    set kb(a) {
+        let b = this.jp;
+        this.jp = a;
+        if (b != this.jp) {
+            this.h7(ComboEditor.et, b, a);
+        }
+    }
+    get ky() {
+        return this.j1;
+    }
+    set ky(a) {
+        let b = this.j1;
+        this.j1 = a;
+        if (b != this.j1) {
+            this.h7("NoMatchesFoundLabelTextColor", b, a);
+        }
+    }
+    get kc() {
+        return this.jq;
+    }
+    set kc(a) {
+        let b = this.jq;
+        this.jq = a;
+        if (b != this.jq) {
+            this.h7("ActualNoMatchesFoundLabelTextColor", b, a);
+        }
+    }
+    static { this.az = null; }
+    get a3() {
+        return this.at;
+    }
+    set a3(a) {
+        let b = this.at;
+        this.at = a;
+        if (b != this.at) {
+            this.h7("NoMatchesFoundLabelTextStyle", b, this.at);
+        }
+    }
+    get aw() {
+        return this.aq;
+    }
+    set aw(a) {
+        let b = this.aq;
+        this.aq = a;
+        if (this.aq != b) {
+            this.h7("ActualNoMatchesFoundLabelTextStyle", b, this.aq);
+        }
+    }
+    get gc() {
+        return this.gd;
+    }
+    set gc(a) {
+        let b = this.gc;
+        if (0 == StringComparer.b.compare(a, b)) {
+            return;
+        }
+        this.gd = a;
+        this.h7("PlaceholderText", b, this.gd);
+    }
+    static { this.ks = BrushUtil.l(221, 0, 0, 0); }
+    get kz() {
+        return this.j2;
+    }
+    set kz(a) {
+        let b = this.j2;
+        this.j2 = a;
+        if (b != this.j2) {
+            this.h7("TextColor", b, a);
+        }
+    }
+    get kd() {
+        return this.jr;
+    }
+    set kd(a) {
+        let b = this.jr;
+        this.jr = a;
+        if (b != this.jr) {
+            this.h7("ActualTextColor", b, a);
+        }
+    }
+    get a4() {
+        return this.au;
+    }
+    set a4(a) {
+        let b = this.au;
+        this.au = a;
+        if (b != this.au) {
+            this.h7("TextStyle", b, this.au);
+        }
+    }
+    get ax() {
+        return this.ar;
+    }
+    set ax(a) {
+        let b = this.ar;
+        this.ar = a;
+        if (this.ar != b) {
+            this.h7("ActualTextStyle", b, this.ar);
+        }
+    }
+    get k0() {
+        return this.j3;
+    }
+    set k0(a) {
+        let b = this.j3;
+        this.j3 = a;
+        if (b != this.j3) {
+            this.h7("UnderlineColor", b, a);
+        }
+    }
+    get ke() {
+        return this.js;
+    }
+    set ke(a) {
+        let b = this.js;
+        this.js = a;
+        if (b != this.js) {
+            this.h7("ActualUnderlineColor", b, a);
+        }
+    }
+    get dn() {
+        return this.cs;
+    }
+    set dn(a) {
+        let b = this.cs;
+        this.cs = a;
+        if (b != this.cs) {
+            this.h7("UnderlineOpacity", b, a);
+        }
+    }
+    get c2() {
+        return this.ci;
+    }
+    set c2(a) {
+        let b = this.ci;
+        this.ci = a;
+        if (b != this.ci) {
+            this.h7("ActualUnderlineOpacity", b, a);
+        }
+    }
+    get k1() {
+        return this.j4;
+    }
+    set k1(a) {
+        let b = this.j4;
+        this.j4 = a;
+        if (b != this.j4) {
+            this.h7("UnderlineRippleColor", b, a);
+        }
+    }
+    get kf() {
+        return this.jt;
+    }
+    set kf(a) {
+        let b = this.jt;
+        this.jt = a;
+        if (b != this.jt) {
+            this.h7("ActualUnderlineRippleColor", b, a);
+        }
+    }
+    get dp() {
+        return this.ct;
+    }
+    set dp(a) {
+        let b = this.ct;
+        this.ct = a;
+        if (b != this.ct) {
+            this.h7("UnderlineRippleOpacity", b, a);
+        }
+    }
+    get c3() {
+        return this.cj;
+    }
+    set c3(a) {
+        let b = this.cj;
+        this.cj = a;
+        if (b != this.cj) {
+            this.h7("ActualUnderlineRippleOpacity", b, a);
+        }
+    }
+    get dq() {
+        return this.cu;
+    }
+    set dq(a) {
+        let b = this.cu;
+        this.cu = a;
+        if (b != this.cu) {
+            this.h7("UnderlineRippleWidth", b, a);
+        }
+    }
+    get c4() {
+        return this.ck;
+    }
+    set c4(a) {
+        let b = this.ck;
+        this.ck = a;
+        if (b != this.ck) {
+            this.h7("ActualUnderlineRippleWidth", b, a);
+        }
+    }
+    get dr() {
+        return this.cv;
+    }
+    set dr(a) {
+        let b = this.cv;
+        this.cv = a;
+        if (b != this.cv) {
+            this.h7("UnderlineWidth", b, a);
+        }
+    }
+    get c5() {
+        return this.cl;
+    }
+    set c5(a) {
+        let b = this.cl;
+        this.cl = a;
+        if (b != this.cl) {
+            this.h7("ActualUnderlineWidth", b, a);
+        }
+    }
+    get bu() {
+        return this.bk;
+    }
+    set bu(a) {
+        let b = this.bk;
+        this.bk = a;
+        if (b != this.bk) {
+            this.h7("AllowFilter", b, a);
+        }
+    }
+    get gh() {
+        return this.d6;
+    }
+    set gh(a) {
+        let b = this.d6;
+        this.d6 = a;
+        if (b != this.d6) {
+            this.h7("TextField", b, a);
+        }
+    }
+    get text() {
+        return this.d5;
+    }
+    set text(a) {
+        let b = this.d5;
+        this.d5 = a;
+        if (b != this.d5) {
+            this.h7("Text", b, a);
+        }
+    }
+    get j() {
+        return this.d;
+    }
+    set j(a) {
+        let b = this.d;
+        this.d = a;
+        if (b != this.d) {
+            this.h7("ValueField", b, a);
+        }
+    }
+    get e() {
+        return this.a;
+    }
+    set e(a) {
+        let b = this.a;
+        this.a = a;
+        if (b != this.a) {
+            this.h7("ActualValueField", b, a);
+        }
+    }
+    get value() {
+        return this.dv;
+    }
+    set value(a) {
+        let b = this.dv;
+        this.dv = a;
+        if (b != this.dv) {
+            this.h7("Value", b, a);
+        }
+    }
+    get s() {
+        return this.q;
+    }
+    set s(a) {
+        let b = this.q;
+        this.q = a;
+        if (b != this.q) {
+            this.h7("DisplayType", enumGetBox(InputGroupDisplayType_$type, b), enumGetBox(InputGroupDisplayType_$type, a));
+        }
+    }
+    dx(a, b) {
+        let c = new FastReflectionHelper(false, b);
+        return c.getPropertyValue(a);
+    }
+    fu() {
+        return this.ft(this.gh);
+    }
+    dy(a) {
+        let b = this.i();
+        if (null == b || b.length == 0) {
+            return null;
+        }
+        let c = new List$1(Base.$, 0);
+        for (let e = 0; e < b.length; e++) {
+            let d = b[e];
+            let f = this.dx(a, d);
+            c.add1(f);
+        }
+        if (c.count == 1) {
+            return c._inner[0];
+        }
+        return c.toArray();
+    }
+    fr(a) {
+        let b = this.fu();
+        let c;
+        if (null != b) {
+            let d = this.dx(a, b);
+            c = null != d ? d.toString() : null;
+        }
+        else {
+            c = null;
+        }
+        return c;
+    }
+    ft(a) {
+        if (stringIsNullOrEmpty(a)) {
+            let b = this.actualDataSource;
+            if (null == b) {
+                return null;
+            }
+            let c = b.actualSchema;
+            if (null == c) {
+                return null;
+            }
+            let d = c.propertyNames;
+            if (0 == d.length) {
+                return null;
+            }
+            return d[0];
+        }
+        return a;
+    }
+    h(a) {
+        let b = new List$1(String_$type, 0);
+        if (null == a || a.length == 0) {
+            let c = this.ft(null);
+            if (stringIsNullOrEmpty(c)) {
+                return null;
+            }
+            b.add(c);
+            return b.toArray();
+        }
+        for (let e = 0; e < a.length; e++) {
+            let d = a[e];
+            let f = this.ft(d);
+            if (null != f) {
+                b.add(f);
+            }
+        }
+        if (b.count > 0) {
+            return b.toArray();
+        }
+        return null;
+    }
+    i() {
+        let a = this.j;
+        return this.h(a);
+    }
+    h9(a) {
+        this.ip(2, a);
+    }
+    ip(a, b) {
+        if (this.b2) {
+            return;
+        }
+        this.b2 = true;
+        try {
+            switch (a) {
+                case 2:
+                    {
+                        let c = b;
+                        let d;
+                        let e;
+                        if (null != c) {
+                            d = this.fr(c);
+                            e = this.dy(c);
+                        }
+                        else {
+                            d = stringEmpty();
+                            e = null;
+                        }
+                        if (this.text != d) {
+                            this.text = d;
+                        }
+                        if (this.value != e) {
+                            this.value = e;
+                        }
+                    }
+                    break;
+                case 1:
+                    this.i1(b.toString());
+                    break;
+                case 0:
+                    this.i0(b);
+                    break;
+            }
+        }
+        finally {
+            this.b2 = false;
+        }
+    }
+    iz(a) {
+        this.text = a;
+    }
+    jd() {
+        this.ax = (null == this.a4) ? this.a1 : this.a4;
+        this.av = (null == this.a2) ? this.a1 : this.a2;
+    }
+    i4() {
+    }
+    closeUp() {
+        this.g1();
+    }
+    destroy() {
+        this.provideRenderer(null);
+    }
+    dropDown() {
+        this.g6();
+    }
+    select() {
+        this.iv();
+    }
+    notifySizeChanged() {
+        this.ab.g();
+    }
+    provideRenderer(a) {
+        this.ab.j(a);
+        this.actualNoMatchesFoundLabel = !stringIsNullOrWhiteSpace(this.bj.b1("NoMatches")) ? this.bj.b1("NoMatches") : "No Matches Found";
+    }
+    dw() {
+        return this.u();
+    }
+    fk() {
+        let a = this.u();
+        return a.aq();
+    }
+    u() {
+        let a = new ComboEditorVisualModelExport();
+        a.i = this.ac.ei();
+        a.n = this.bh.b7;
+        for (let b of fromEnum(a.i.a)) {
+            let c = b.e;
+            let d = this.actualDataSource.getItemAtIndex(c);
+            let e = this.fs(d);
+            b.f = e;
+        }
+        a.a = AppearanceHelper.a(this.j5);
+        a.j = this.ah;
+        a.b = AppearanceHelper.a(this.j6);
+        a.p = this.cw;
+        a.ay = this.k4;
+        a.ax = this.jg;
+        a.k = this.am;
+        a.dropDownButtonVisible = this.dropDownButtonVisible;
+        a.q = this.cy;
+        a.ae = this.f0;
+        a.c = AppearanceHelper.a(this.ka);
+        a.actualLabelVisible = this.actualLabelVisible;
+        a.actualNoMatchesFoundLabel = this.actualNoMatchesFoundLabel;
+        a.d = AppearanceHelper.a(this.kb);
+        a.e = AppearanceHelper.a(this.kc);
+        a.ap = this.gc;
+        a.f = AppearanceHelper.a(this.kd);
+        a.g = AppearanceHelper.a(this.ke);
+        a.r = this.c2;
+        a.h = AppearanceHelper.a(this.kf);
+        a.s = this.c3;
+        a.t = this.c4;
+        a.u = this.c5;
+        a.ar = this.text;
+        a.ac = this.value;
+        if (this.av != null) {
+            let f = this.av;
+            if (this.ab != null && f.q == null) {
+                let g = this.ab.c;
+                let h = FontUtil.getFontInfoFromString(g, f.fontString);
+                f.q = h.q;
+                f.f = h.f;
+                f.r = h.r;
+                f.t = h.t;
+                f.u = h.u;
+                f.v = h.v;
+            }
+            if (f.q != null) {
+                a.af = f.q;
+            }
+            if (!isNaN_(f.f)) {
+                a.w = f.f;
+            }
+            if (f.v != null) {
+                a.aj = f.v;
+            }
+            if (f.t != null) {
+                a.ah = f.t;
+            }
+            if (f.r != null) {
+                a.ag = f.t;
+            }
+        }
+        if (this.aw != null) {
+            let i = this.aw;
+            if (this.ab != null && i.q == null) {
+                let j = this.ab.c;
+                let k = FontUtil.getFontInfoFromString(j, i.fontString);
+                i.q = k.q;
+                i.f = k.f;
+                i.r = k.r;
+                i.t = k.t;
+                i.u = k.u;
+                i.v = k.v;
+            }
+            if (i.q != null) {
+                a.ak = i.q;
+            }
+            if (!isNaN_(i.f)) {
+                a.y = i.f;
+            }
+            if (i.v != null) {
+                a.ao = i.v;
+            }
+            if (i.t != null) {
+                a.am = i.t;
+            }
+            if (i.r != null) {
+                a.al = i.t;
+            }
+        }
+        if (this.ax != null) {
+            let l = this.ax;
+            if (this.ab != null && l.q == null) {
+                let m = this.ab.c;
+                let n = FontUtil.getFontInfoFromString(m, l.fontString);
+                l.q = n.q;
+                l.f = n.f;
+                l.r = n.r;
+                l.t = n.t;
+                l.u = n.u;
+                l.v = n.v;
+            }
+            if (l.q != null) {
+                a.as = l.q;
+            }
+            if (!isNaN_(l.f)) {
+                a.z = l.f;
+            }
+            if (l.v != null) {
+                a.aw = l.v;
+            }
+            if (l.t != null) {
+                a.au = l.t;
+            }
+            if (l.r != null) {
+                a.at = l.t;
+            }
+        }
+        return a;
+    }
+    get b4() {
+        return this.bn;
+    }
+    set b4(a) {
+        let b = this.bn;
+        this.bn = a;
+        if (b != this.bn) {
+            this.h7("IsFixed", b, this.bn);
+        }
+    }
+    get b9() {
+        return this.bq;
+    }
+    set b9(a) {
+        let b = this.bq;
+        this.bq = a;
+        if (b != this.bq) {
+            this.h7("OpenAsChild", b, this.bq);
+        }
+    }
+    get cb() {
+        return this.br;
+    }
+    set cb(a) {
+        let b = this.br;
+        this.br = a;
+        if (b != this.br) {
+            this.h7("UseTopLayer", b, this.br);
+        }
+    }
+    h2(a) {
+        if (null != this.gotFocus) {
+            this.gotFocus(this, a);
+        }
+    }
+    h5(a) {
+        if (null != this.lostFocus) {
+            this.lostFocus(this, a);
+        }
+    }
+    id(a) {
+        if (null != this.textValueChanged) {
+            this.textValueChanged(this, a);
+        }
+    }
+    ia(a) {
+        if (null != this.selectedValueChanged) {
+            this.selectedValueChanged(this, a);
+        }
+    }
+    h7(a, b, c) {
+        if (this.propertyChanged != null) {
+            this.propertyChanged(this, new PropertyChangedEventArgs(a));
+        }
+        this.iq(a, b, c);
+    }
+    h4(a) {
+        if (null != this.keyDown) {
+            let b = new KeyEventArgs(1, a.g, a.a, a.e, a.b, a.h);
+            this.keyDown(this, b);
+        }
+    }
+    hr(a) {
+        let b = new InputChangeEventArgs();
+        b.isCompositionInProgress = a.a;
+        b.value = a.b;
+        if (null != this.changing) {
+            this.changing(this, b);
+        }
+    }
+    static { this.d2 = "M19 6.41L17.59 5 12 10.59 6.41 5 5 6.41 10.59 12 5 17.59 6.41 19 12 13.41 17.59 19 19 17.59 13.41 12z"; }
+    static { this.d4 = "M16.59 8.59L12 13.17 7.41 8.59 6 10l6 6 6-6z"; }
+    static { this.d3 = "M12 8l-6 6 1.41 1.41L12 10.83l4.59 4.58L18 14z"; }
+    get ad() {
+        return this.ac;
+    }
+    get b7() {
+        return this.dt == 46;
+    }
+    get bh() {
+        return this.bg;
+    }
+    ie(a) {
+        this.a9 = a;
+        this.h6();
+    }
+    h1() {
+        this.ab.i();
+    }
+    hq() {
+        this.ab.h();
+    }
+    h6() {
+        this.g3();
+        this.i9();
+        this.g2();
+        this.bc.bo(this.a7);
+        this.i2();
+        this.i3();
+        this.ab.h();
+    }
+    gw(a) {
+        let b = this.m();
+        if (this.n != null) {
+            if (b != null) {
+                if (b.filterExpressions.k.contains(this.n)) {
+                    b.filterExpressions.remove(this.n);
+                }
+            }
+        }
+        this.n = a;
+        this.by = false;
+        if (a != null && b != null && !b.filterExpressions.k.contains(a)) {
+            b.filterExpressions.add(a);
+            this.by = true;
+        }
+        else {
+            this.dropDown();
+        }
+    }
+    gx() {
+        let a = this.m();
+        if (a != null) {
+            if (a.filterExpressions.k.contains(this.n)) {
+                a.filterExpressions.remove(this.n);
+            }
+        }
+        this.n = null;
+    }
+    g1() {
+        let a = this.bh;
+        if (null != a) {
+            a.cd();
+        }
+        this.i3();
+        this.gx();
+    }
+    get bb() {
+        return this.a7;
+    }
+    b3(a) {
+        if (null == a) {
+            return false;
+        }
+        let b = this.a7;
+        let c = this.ac;
+        let d = this.a5;
+        return this.bh.t(a) || this.bc.t(a);
+    }
+    g2() {
+        let a = this.ab.d();
+        NativeUIContent.aw(a, [7, 2], [2, 2], (b) => {
+            this.a7 = b[0];
+            this.a7.h = 3;
+            this.a7.n = runOn(this, this.hl);
+            this.a7.o = runOn(this, this.hm);
+            this.bd = b[1];
+            this.a7.bo(this.bd);
+            this.bd.b8 = this.text;
+            this.bd.bt = runOn(this, this.hg);
+            this.bd.bu = runOn(this, this.hh);
+            this.bd.by = runOn(this, this.hj);
+            this.bd.n = runOn(this, this.hi);
+            this.bd.b0 = runOn(this, this.hk);
+            this.g7(this.bu);
+            this.bd.b7 = ComboEditor.d2;
+            this.bd.cd = BrushUtil.l(255, 0, 0, 0);
+            this.bd.bo = runOn(this, this.ic);
+        });
+    }
+    get be() {
+        return this.bd;
+    }
+    g3() {
+        NativeUIContent.aw(this.ab.d(), [7, 12, 0, 3, 7], [2, 2, 2, 2, 2], (a) => {
+            let b = a[1];
+            this.bg = b;
+            this.bg.b8 = true;
+            this.a5 = a[2];
+            this.a5.bj = new Thickness(0, 4);
+            this.ba = a[0];
+            this.ba.bo(this.a5);
+            this.a8 = a[4];
+            this.ba.bo(this.a8);
+            this.a9.bo(this.bg);
+            this.bf = a[3];
+            this.bg.bo(this.ba);
+            this.bg.bx = runOn(this, this.ih);
+        });
+    }
+    ih(a, b) {
+        if (this.ad != null && this.a8.bk == 0) {
+            this.ad.notifySizeChanged();
+        }
+    }
+    hu(a, b) {
+    }
+    hx(a, b, c) {
+    }
+    ht() {
+        switch (this.v) {
+            case 2:
+            case 1:
+                if (null == this.l) {
+                    this.v = 0;
+                }
+                break;
+        }
+        let a = null;
+        switch (this.v) {
+            case 2:
+                {
+                    let b = this.l.actualCount;
+                    if (b == 0) {
+                        this.value = null;
+                    }
+                    else {
+                        if (b > 1) {
+                        }
+                        a = this.l.getItemAtIndex(0);
+                        let c = this.i();
+                        let d = new List$1(Base.$, 0);
+                        for (let f = 0; f < c.length; f++) {
+                            let e = c[f];
+                            let g = this.l.getItemProperty(a, e);
+                            d.add1(g);
+                        }
+                        this.value = d.count == 1 ? d._inner[0] : d.toArray();
+                    }
+                }
+                break;
+            case 1:
+                {
+                    let h = this.l.actualCount;
+                    if (h == 0) {
+                        this.text = stringEmpty();
+                    }
+                    else {
+                        if (h > 1) {
+                        }
+                        let i = this.fu();
+                        a = this.l.getItemAtIndex(0);
+                        let j = this.l.getItemProperty(a, i).toString();
+                        this.text = j;
+                    }
+                    let k = this.m();
+                    let l = k.indexOfItem(a);
+                    this.ix(l);
+                }
+                break;
+            case 0:
+            default: return;
+        }
+        if (null != a) {
+            let m = this.m();
+            let n = m.indexOfItem(a);
+            this.ix(n);
+        }
+        else {
+            this.ix(-1);
+        }
+        if (this.l != null) {
+            this.l.updateNotifier = null;
+            this.l = null;
+        }
+        this.v = 0;
+    }
+    hv(a, b) {
+    }
+    hw(a, b) {
+    }
+    h0(a, b) {
+        let c = this.ad;
+        if (null != c) {
+            let d = c.dw;
+            if (-1 != d) {
+                if (d >= a && d <= b) {
+                    this.iu(d);
+                    this.ja();
+                }
+            }
+        }
+    }
+    ib(a, b, c) {
+    }
+    hs() {
+        this.ij();
+        if (this.b5) {
+            let a = this.m();
+            let b = a.actualCount;
+            if (this.ca && b > 0) {
+                this.il();
+            }
+            else {
+                this.im();
+            }
+        }
+        else {
+            this.i8();
+        }
+    }
+    h3(a, b) {
+    }
+    h8(a, b) {
+    }
+    g6() {
+        this.jc();
+        this.hn();
+        let a = this.bh;
+        if (a.b7) {
+            return;
+        }
+        a.b1 = !this.b5;
+        a.ch(this.bc, 1, 1);
+        this.i3();
+    }
+    m() {
+        let a = this.ad;
+        if (null != a) {
+            return a.actualDataSource;
+        }
+        return null;
+    }
+    bz(a) {
+        let b = this.ac.ai;
+        let c = b.count;
+        if (0 == c) {
+            a = null;
+            return {
+                ret: true,
+                p0: a
+            };
+        }
+        else if (1 == c) {
+            a = b._inner[0];
+        }
+        else {
+            a = b._inner[0];
+        }
+        return {
+            ret: null != a,
+            p0: a
+        };
+    }
+    hb(a) {
+        let b = -1 != a ? a : -1;
+        this.iu(b);
+    }
+    hd() {
+        if (this.bo) {
+            return;
+        }
+        let a;
+        let b = ((() => { let c = this.bz(a); a = c.p0; return c.ret; })());
+        if (!b) {
+            return;
+        }
+        if (a == null) {
+            return;
+        }
+        this.h9(a);
+    }
+    hn() {
+        this.bh.ce();
+    }
+    hp() {
+        let a = this.bh;
+        if (a.b7) {
+            this.closeUp();
+            let b = this.bd;
+            b.a0();
+            let c = b.b8;
+            let d = null != c ? b.b8.length : 0;
+            b.cb(d, d);
+        }
+    }
+    hy() {
+        this.bd.b2 = true;
+        this.bd.ca();
+        let a = new ComboEditorGotFocusEventArgs();
+        this.h2(a);
+    }
+    hz() {
+        this.closeUp();
+        this.bd.b9();
+        let a = new ComboEditorLostFocusEventArgs();
+        this.h5(a);
+    }
+    im() {
+        let a = this.ac;
+        a.selectedItemsChanged = delegateRemove(a.selectedItemsChanged, runOn(this, this.he));
+        this.bo = true;
+        try {
+            this.iz(this.d7);
+        }
+        finally {
+            this.bo = false;
+            let b = this.ac;
+            b.selectedItemsChanged = delegateCombine(b.selectedItemsChanged, runOn(this, this.he));
+        }
+        this.b5 = false;
+    }
+    io() {
+        this.b5 = true;
+        if (stringIsNullOrEmpty(this.d7)) {
+            if (this.n != null) {
+                this.gw(null);
+            }
+            else {
+                this.im();
+            }
+        }
+        else {
+            let a = FilterFactory.instance.property(this.fu()).toLower().startsWith(this.d7.toLowerCase());
+            this.gw(a);
+        }
+    }
+    is() {
+        this.dt = 0;
+        this.b6 = false;
+    }
+    iu(a) {
+        let b = this.m();
+        let c = b.isPlaceholderItem(a);
+        if (c) {
+        }
+        else {
+            let d = this.ad;
+            if (a < 0) {
+                this.b1 = false;
+                d.ai.clear();
+                if (!this.b1) {
+                    this.hd();
+                }
+                return;
+            }
+            d.selectedItemsChanged = delegateRemove(d.selectedItemsChanged, runOn(this, this.he));
+            try {
+                d.ai.clear();
+            }
+            finally {
+                d.selectedItemsChanged = delegateCombine(d.selectedItemsChanged, runOn(this, this.he));
+            }
+            if (a >= 0) {
+                let e = b.getItemAtIndex(a);
+                this.b1 = false;
+                d.ai.add1(e);
+                if (!this.b1) {
+                    this.hd();
+                }
+            }
+        }
+    }
+    ix(a) {
+        let b = this.ad;
+        if (-1 == a) {
+            b.dw = -1;
+            return;
+        }
+        let c = b.dw;
+        let d = -1;
+        let e;
+        this.ds = a;
+        d = a;
+        this.b0 = false;
+        b.dw = d;
+        if (!this.b0) {
+            this.hb(b.dw);
+        }
+        this.ja();
+    }
+    i1(a) {
+        this.ig(2, a);
+    }
+    i0(a) {
+        this.ig(1, a);
+    }
+    i2() {
+        let a = this;
+        if (null != this.bd) {
+            this.bd.bq = a.density;
+            this.bd.c = a.ah;
+            this.bd.bv = a.s;
+            this.bd.a9 = a.j5;
+            this.bd.ba = a.j6;
+            this.bd.bh = new Thickness(0, a.cw);
+            this.bd.bq = a.am;
+            this.ab.k(this.bd);
+        }
+        if (null != this.bd) {
+            this.bd.cf = a.kd;
+            this.bd.bl = a.ax;
+        }
+        if (null != this.bd) {
+            this.bd.b6 = a.f0;
+        }
+        if (null != this.a5) {
+            this.a5.bb = a.kc;
+            this.a5.a9 = a.kb;
+            if (null != a.aw) {
+                let b = a.aw;
+                this.ab.m(this.a5, b);
+            }
+            this.a5.bt = this.bf;
+            this.bf.bo = this.actualNoMatchesFoundLabel;
+            this.hn();
+        }
+        if (null != this.ad) {
+        }
+    }
+    i6() {
+        if (!this.bo) {
+            if (null != this.bd) {
+                let a = this.text;
+                this.bd.b8 = a;
+            }
+        }
+    }
+    i3() {
+        let a = this.bh;
+        let b = null != a ? a.b7 : false;
+        this.bd.b7 = b ? ComboEditor.d3 : ComboEditor.d4;
+    }
+    i5() {
+        this.jd();
+        let a = this.ac.ia();
+        let b = Math.min(a.height, 40 * 8);
+        this.a8.z = b;
+        let c = a.width;
+        c = Math.max(c, 150);
+        this.a8.af = c;
+    }
+    i7() {
+        if (this.b5) {
+            return;
+        }
+        this.d7 = null;
+        if (this.n != null) {
+            this.gx();
+        }
+        else {
+            this.i8();
+        }
+    }
+    i8() {
+        if (null != this.value) {
+            let a = this.value;
+            let b = typeCast(Array_$type, a) !== null ? a : [a];
+            let c = this.m();
+            let d = c.indexOfKey(b);
+            if (-1 != d) {
+                this.ix(d);
+            }
+        }
+    }
+    i9() {
+        if (null == this.ad) {
+            this.jd();
+            this.ab.f(this.a8, (a) => {
+                let b = a;
+                this.ac = b;
+                let c = this.ac;
+                c.rowUpdating = delegateCombine(c.rowUpdating, runOn(this, this.gu));
+                this.jb();
+                this.ad.as = 1;
+                this.ad.an = 0;
+                this.ad.r = 1;
+                this.a8.a9 = BrushUtil.l(255, 255, 255, 255);
+                this.ac.h8 = BrushUtil.l(255, 200, 200, 200);
+                this.ac.h2 = BrushUtil.l(255, 100, 100, 100);
+                this.ac.ef = 32;
+                this.ad.h6 = BrushUtil.l(0, 0, 0, 0);
+                this.ad.by = false;
+                this.ad.bt = false;
+                let d = this.ad;
+                d.activeRowChanged = delegateCombine(d.activeRowChanged, runOn(this, this.ha));
+                let e = this.ad;
+                e.selectedItemsChanged = delegateCombine(e.selectedItemsChanged, runOn(this, this.he));
+                let f = this.ad;
+                f.itemClicked = delegateCombine(f.itemClicked, runOn(this, this.hc));
+                this.ad.a9 = runOn(this, this.hf);
+                this.i2();
+            });
+        }
+    }
+    gu(a, b) {
+        if (b.b != null) {
+            let c = null;
+            if (b.b.ap != "comboItem") {
+                NativeUIComponent.av(this.ab.d(), 3, (d) => {
+                    let e = d;
+                    e.bl = this.ax;
+                    b.b.bt = e;
+                    b.b.ap = "comboItem";
+                    e.f = 0;
+                    e.h = 1;
+                    e.bi = new Thickness(0, 5);
+                    e.bo = this.fs(b.a.x);
+                });
+            }
+            else {
+                let d = b.b.bt;
+                d.bo = this.fs(b.a.x);
+            }
+        }
+    }
+    fs(a) {
+        return this.fu() != null ? this.actualDataSource.getItemProperty(a, this.fu()).toString() : "";
+    }
+    ig(a, b) {
+        let c = this.m();
+        if (null == c) {
+            return;
+        }
+        if (null != this.l) {
+            if (a != this.v) {
+            }
+            this.l.updateNotifier = null;
+            this.l = null;
+        }
+        this.v = a;
+        let d = new FilterFactory();
+        let e = null;
+        let f = null;
+        switch (a) {
+            case 2:
+                {
+                    let g = this.fu();
+                    if (stringIsNullOrEmpty(g)) {
+                        return;
+                    }
+                    e = b.toString();
+                    let h = d.property(g);
+                    f = h.isEqualTo(e);
+                }
+                break;
+            case 1:
+                {
+                    let i = this.i();
+                    if (i == null || i.length < 1) {
+                        return;
+                    }
+                    let j = typeCast(Array_$type, b) !== null ? b : [b];
+                    if (i.length != j.length) {
+                        return;
+                    }
+                    for (let k = 0; k < i.length; k++) {
+                        let l = i[k];
+                        e = j[k];
+                        let m = d.property(l);
+                        let n = m.isEqualTo(e);
+                        if (null == f) {
+                            f = n;
+                        }
+                        else {
+                            f.and(n);
+                        }
+                    }
+                }
+                break;
+            case 0:
+            default: return;
+        }
+        this.l = c.clone();
+        this.l.filterExpressions.clear();
+        this.l.updateNotifier = new ComboEditorDataSourceNotificationHandler(this, true);
+        this.l.filterExpressions.add(f);
+        if (!this.l.isVirtual) {
+            this.l.flushAutoRefresh();
+        }
+    }
+    ii() {
+        this.i6();
+        let a = this.text;
+        let b = this.d7.length;
+        let c = !stringIsNullOrEmpty(a) ? a.length : 0;
+        if (this.b6 && !stringIsNullOrEmpty(this.d7) && b > 0) {
+            b--;
+        }
+        this.bd.cb(b, c);
+    }
+    ij() {
+        if (this.by) {
+            this.by = false;
+            this.dropDown();
+        }
+    }
+    ik(a) {
+        this.d7 = a;
+        this.ca = !this.b7;
+        this.io();
+    }
+    il() {
+        if (stringIsNullOrEmpty(this.d7)) {
+            this.gy();
+        }
+        else {
+            this.ix(0);
+        }
+        this.ii();
+        this.b5 = false;
+    }
+    gy() {
+        let a = this.ad;
+        a.dw = -1;
+    }
+    g7(a) {
+        if (this.bd != null) {
+            this.bd.b1 = !a;
+        }
+    }
+    ja() {
+        if (!this.bp) {
+            return;
+        }
+        let a = this.ad;
+        let b = a.dw;
+        if (-1 != b) {
+            let c = this.m();
+            if (null != c) {
+                let d = b < c.actualCount ? c.getItemAtIndex(b) : 0;
+                if (null == d) {
+                    return;
+                }
+                a.cl(d);
+            }
+        }
+        else {
+            a.hj(0);
+        }
+    }
+    jb() {
+        if (this.ad != null) {
+            let a = this.itemsSource;
+            this.ad.ai.clear();
+            if (this.ad.actualDataSource != null) {
+                let b = this.ad.actualDataSource;
+                b.schemaChanged = delegateRemove(b.schemaChanged, runOn(this, this.gv));
+            }
+            this.ad.g = null;
+            this.ad.itemsSource = a;
+            this.ad.f = this.i();
+            this.ds = -1;
+            let c = this.m();
+            if (null != c) {
+                let d = c.updateNotifier;
+                let e = new ComboEditorDataSourceNotificationHandler(this, false);
+                let f = new ComboEditorMultipleDataSourceNotifier(1, [d, e]);
+                c.updateNotifier = f;
+                c.propertiesRequested = this.f;
+                c.schemaChanged = delegateCombine(c.schemaChanged, runOn(this, this.gv));
+                if (this.value != null) {
+                    this.ig(1, this.value);
+                }
+            }
+            this.l = null;
+        }
+    }
+    gv(a, b) {
+        if (this.ds != -1) {
+            this.ix(this.ds);
+            this.ds = -1;
+        }
+    }
+    iw(a) {
+        if (this.bd != null) {
+            this.bd.b1 = !a;
+        }
+    }
+    jc() {
+        this.i5();
+        if (!this.b5) {
+            this.b8 = false;
+        }
+        else {
+            let a = this.m();
+            this.b8 = a.actualCount == 0;
+        }
+        this.a5.bk = this.b8 ? 0 : 1;
+        let b = this.a8.bk;
+        this.a8.bk = !this.b8 ? 0 : 1;
+    }
+    g9(a) {
+        if (this.bd != null) {
+            if (a) {
+                this.bd.a1();
+            }
+            else {
+                this.bd.a0();
+            }
+        }
+    }
+    iv() {
+        if (this.bd != null) {
+            this.bd.ca();
+        }
+    }
+    get bc() {
+        return this.a9;
+    }
+    ic(a, b) {
+        b.a = true;
+        let c = this.bh;
+        if (c.b7) {
+            this.closeUp();
+        }
+        else {
+            this.gw(null);
+        }
+        if (null != this.bd) {
+            this.bd.a0();
+            this.bd.ca();
+        }
+    }
+    ha(a, b) {
+        let c = b.newActiveRow;
+        this.hb(c);
+        this.b0 = true;
+    }
+    hc(a, b) {
+        this.hp();
+    }
+    he(a, b) {
+        this.hd();
+        this.b1 = true;
+    }
+    hf() {
+        this.bp = this.ad.ay.a;
+        this.ja();
+    }
+    hg(a, b) {
+        if (b.a) {
+            return;
+        }
+        this.hr(b);
+        let c = b.b;
+        this.ik(c);
+    }
+    hh(a, b) {
+        let c = this.bd.b8;
+        this.ik(c);
+    }
+    hi(a, b) {
+        this.is();
+    }
+    hj(a, b) {
+        this.h4(b);
+        if (b.c) {
+            return;
+        }
+        let c = b.g;
+        this.dt = c;
+        this.b6 = false;
+        switch (c) {
+            case 8:
+                let d = this.bd.b5;
+                if (0 == d) {
+                    break;
+                }
+                let e = this.bd.b8;
+                if (stringIsNullOrEmpty(e)) {
+                    break;
+                }
+                let f = e.length;
+                let g = this.bd.b4;
+                let h = g - d;
+                if (h > 0 && h < f && g == f) {
+                    this.b6 = true;
+                }
+                break;
+            case 40:
+                if (b.a) {
+                    this.dropDown();
+                    this.i7();
+                    b.d = true;
+                }
+                else {
+                    let i = this.ad;
+                    if (null == i) {
+                        return;
+                    }
+                    let j = this.ad.dw;
+                    if (-1 != i.dw) {
+                        this.ad.b4(false, false);
+                        b.d = true;
+                    }
+                    else {
+                        let k = this.m();
+                        if (null != k) {
+                            let l = k.actualCount;
+                            if (l > 0) {
+                                this.ix(0);
+                                b.d = true;
+                            }
+                        }
+                    }
+                }
+                break;
+            case 38:
+                if (b.a) {
+                    this.closeUp();
+                    b.d = true;
+                }
+                else {
+                    let m = this.ad;
+                    if (null == m) {
+                        return;
+                    }
+                    let n = this.ad.dw;
+                    if (null != m.dw) {
+                        this.ac.ch(false, false);
+                        b.d = true;
+                    }
+                    else {
+                        let o = this.m();
+                        if (null != o) {
+                            let p = o.actualCount;
+                            if (p > 0) {
+                                this.ix(p - 1);
+                                b.d = true;
+                            }
+                        }
+                    }
+                }
+                break;
+            case 13:
+                if (this.bh.b7) {
+                    b.f = true;
+                }
+                this.hp();
+                break;
+            case 27:
+                this.closeUp();
+                break;
+        }
+    }
+    hk(a, b) {
+    }
+    hl(a, b) {
+        if (this.bm) {
+            return;
+        }
+        this.bm = true;
+        this.bd.a0();
+        this.bm = false;
+        let c = b.b;
+        if (!this.b3(c)) {
+            this.hy();
+        }
+    }
+    hm(a, b) {
+        let c = b.b;
+        if (!this.b3(c)) {
+            this.hz();
+        }
+    }
+}
+export { ComboEditor };
+/**
+ * @hidden
+ */
+class ComboEditorDataSourceNotificationHandler extends Base {
+    static { this.$t = markType(ComboEditorDataSourceNotificationHandler, 'ComboEditorDataSourceNotificationHandler', Base.$, [IDataSourceUpdateNotifier_$type]); }
+    constructor(a, b) {
+        super();
+        this.a = null;
+        this.b = false;
+        this.a = a;
+        this.b = b;
+    }
+    rangeActualized(a, b) {
+        if (!this.b) {
+            this.a.h0(a, b);
+        }
+        else {
+            this.a.hu(a, b);
+        }
+    }
+    notifySetItem(a, b, c) {
+        if (!this.b) {
+            this.a.ib(a, b, c);
+        }
+        else {
+            this.a.hx(a, b, c);
+        }
+    }
+    notifyClearItems() {
+        if (!this.b) {
+            this.a.hs();
+        }
+        else {
+            this.a.ht();
+        }
+    }
+    notifyInsertItem(a, b) {
+        if (!this.b) {
+            this.a.h3(a, b);
+        }
+        else {
+            this.a.hv(a, b);
+        }
+    }
+    notifyRemoveItem(a, b) {
+        if (!this.b) {
+            this.a.h8(a, b);
+        }
+        else {
+            this.a.hw(a, b);
+        }
+    }
+}
+export { ComboEditorDataSourceNotificationHandler };