igniteui-angular-data-grids 19.1.0-beta.0

package/esm2015/lib/CheckboxListView_combined.js

@@ -0,0 +1,1945 @@
+/*
+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, delegateCombine, typeCast, fromEnum, markType, INotifyPropertyChanged_$type, PropertyChangedEventArgs, delegateRemove, EnumUtil, enumGetBox } from "igniteui-angular-core";
+import { DomWrapper_$type } from "igniteui-angular-core";
+import { Dictionary$2 } from "igniteui-angular-core";
+import { XCheckbox } from "igniteui-angular-inputs";
+import { XLabel } from "igniteui-angular-inputs";
+import { XIcon } from "igniteui-angular-inputs";
+import { XPrefix } from "igniteui-angular-inputs";
+import { XInputGroup } from "igniteui-angular-inputs";
+import { XInput } from "igniteui-angular-inputs";
+import { ControlDisplayDensity_$type } from "igniteui-angular-core";
+import { FontInfo } from "igniteui-angular-core";
+import { DataContext } from "igniteui-angular-core";
+import { IDataLegendTarget_$type } from "igniteui-angular-core";
+import { BrushUtil } from "igniteui-angular-core";
+import { DeviceUtils } from "igniteui-angular-core";
+import { Brush } from "igniteui-angular-core";
+import { Color } from "igniteui-angular-core";
+import { NativeUI } from "igniteui-angular-core";
+import { PrimaryKeyValue } from "./PrimaryKeyValue";
+import { Thickness } from "igniteui-angular-core";
+import { CheckboxListIndexType_$type } from "./CheckboxListIndexType";
+import { stringIsNullOrEmpty, stringIsNullOrWhiteSpace } from "igniteui-angular-core";
+import { SRProvider } from "igniteui-angular-core";
+import { GridSelectedKeysCollection } from "./GridSelectedKeysCollection";
+import { InputGroupDisplayType_$type } from "igniteui-angular-inputs";
+import { GridStyleRepository } from "./GridStyleRepository";
+import { BaseControlTheme_$type } from "igniteui-angular-core";
+import { ScrollbarStyle_$type } from "igniteui-angular-core";
+import { FilterFactory } from "igniteui-angular-core";
+import { CheckboxListKeysClearedEventArgs } from "./CheckboxListKeysClearedEventArgs";
+import { CheckedChangedEventArgs } from "./CheckedChangedEventArgs";
+import { TemplateColumn } from "./TemplateColumn";
+import { FastReflectionHelper } from "igniteui-angular-core";
+import { DataSeriesPropertyType_$type } from "igniteui-angular-core";
+import { SvgIconRegistry } from "igniteui-angular-core";
+import { DataSourceSchemaPropertyType_$type } from "igniteui-angular-core";
+import { CheckboxListIndexTypeChangedEventArgs } from "./CheckboxListIndexTypeChangedEventArgs";
+import { ColumnWidth } from "./ColumnWidth";
+import { DateTimeColumn } from "./DateTimeColumn";
+import { NumericColumn } from "./NumericColumn";
+import { TextColumn } from "./TextColumn";
+import { ArgumentException } from "igniteui-angular-core";
+import { Size } from "igniteui-angular-core";
+import { ComponentSizeHelpers } from "igniteui-angular-core";
+import { SelectAllCheckboxChangedEventArgs } from "./SelectAllCheckboxChangedEventArgs";
+import { isPositiveInfinity } from "igniteui-angular-core";
+/**
+ * @hidden
+ */
+export let CheckboxListView = /*@__PURE__*/ (() => {
+    class CheckboxListView extends Base {
+        constructor() {
+            super();
+            this.e = new Dictionary$2(DomWrapper_$type, XCheckbox.$, 0);
+            this.h = new Dictionary$2(DomWrapper_$type, XLabel.$, 0);
+            this.g = new Dictionary$2(DomWrapper_$type, XLabel.$, 0);
+            this.f = new Dictionary$2(DomWrapper_$type, XIcon.$, 0);
+            this.m = null;
+            this.a = null;
+            this.l = null;
+            this.k = null;
+            this.c = null;
+            this.b = null;
+            this.i = null;
+            this.d = false;
+            this.j = null;
+        }
+        q() {
+        }
+        p(a) {
+            if (a == null) {
+                this.i = null;
+                this.e.clear();
+                return;
+            }
+            this.i = a;
+            this.aa();
+            this.aj();
+            this.am();
+            this.x();
+            let b = Math.round(a.rootWrapper.width());
+            let c = Math.round(a.rootWrapper.height());
+            this.i.rootWrapper.setStyleProperty("position", "relative");
+            this.i.rootWrapper.setStyleProperty("padding-bottom", "4px");
+            this.al();
+        }
+        aa() {
+            if (this.i != null) {
+                this.ab(this.i);
+            }
+        }
+        ab(a) {
+            let b = a.rootWrapper.getChildAt(0);
+            this.k = b;
+            this.b.w = new XInputGroup();
+            let c = a.getSubRenderer(b);
+            this.b.w.provideContainer(c);
+            let d = c.getExternal(this.b.w, c.rootWrapper, c.getExternal(this.b, null, null));
+            this.b.w.d = this.b.y;
+            this.b.w.p = this.b.baseTheme;
+            this.b.w.t = this.b.density;
+            let e = a.createElement("div");
+            let f = a.getSubRenderer(e);
+            let g = new XPrefix();
+            g.provideContainer(f);
+            let h = f.getExternal(g, f.rootWrapper, f.getExternal(this.b, null, null));
+            let i = a.createElement("div");
+            let j = a.getSubRenderer(i);
+            this.c = new XIcon();
+            this.c.provideContainer(j);
+            this.c.fill = this.b.searchIconColor;
+            this.c.svgPath = CheckboxList.cl;
+            let k = f.getExternal(this.c, j.rootWrapper, j.getExternal(this.b, null, null));
+            g.appendContentChild(i);
+            this.b.w.appendContentChild(e);
+            this.b.w.inputs.add(g);
+            let l = a.createElement("div");
+            l.setRawStyleProperty("flex-grow", "1");
+            let m = a.getSubRenderer(l);
+            this.b.u = new XInput();
+            this.b.u.provideContainer(m);
+            this.b.u.b8 = "text";
+            let n = m.getExternal(this.b.u, m.rootWrapper, m.getExternal(this.b, null, null));
+            if (this.b.b4 != null) {
+                this.b.u.cg = this.b.b4;
+            }
+            this.b.w.appendContentChild(l);
+            this.b.w.inputs.add(this.b.u);
+            this.b.dl();
+        }
+        x() {
+            if (this.i != null) {
+                let a = this.i.rootWrapper.getChildAt(3);
+                a.setStyleProperty("width", "100%");
+                a.setStyleProperty("margin", "4px 0px 0px 0px");
+                if (!this.b.a3 && !this.b.showSelectAll) {
+                    a.setStyleProperty("height", "100%");
+                }
+                else {
+                    let b = this.b.a9();
+                    a.setStyleProperty("height", "calc(100% - " + b + "px");
+                }
+            }
+        }
+        r(a, b, c) {
+            let d = null;
+            if (a.getChildCount() == 0) {
+                d = new XCheckbox();
+                let e = this.i.getSubRenderer(a);
+                d.provideContainer(e);
+                let f = this.i.getExternal(d, e.rootWrapper, this.i.getExternal(this.b, null, null));
+                this.e.addItem(a, d);
+                d.n = this.b.baseTheme;
+                d.y = true;
+                d.change = delegateCombine(d.change, runOn(this, this.n));
+                let g = this.i.createElement("div");
+                a.setStyleProperty("display", "flex");
+                a.setStyleProperty("height", "100%");
+                a.setStyleProperty("align-items", "center");
+                switch (this.b.density) {
+                    case 1:
+                        a.setStyleProperty("margin-top", "-4px");
+                        break;
+                    case 2:
+                        a.setStyleProperty("margin-top", "-1px");
+                        break;
+                    case 4:
+                    case 3:
+                        a.setStyleProperty("margin-top", "1px");
+                        break;
+                }
+                a.append(g);
+            }
+            else {
+                d = this.e.item(a);
+            }
+            if (d != null) {
+                let h = d.z;
+                try {
+                    d.z = true;
+                    d.ar = this.b.a7;
+                    d.a4 = b;
+                    if (c) {
+                        if (this.b.indexType == 0) {
+                            d.checked = false;
+                        }
+                        else {
+                            d.checked = true;
+                        }
+                    }
+                    else {
+                        if (this.b.indexType == 0) {
+                            d.checked = true;
+                        }
+                        else {
+                            d.checked = false;
+                        }
+                    }
+                }
+                finally {
+                    d.z = h;
+                }
+                d.dk = this.b.et;
+                d.dd = this.b.er;
+                d.dl = this.b.eu;
+                d.de = this.b.es;
+                d.dm = this.b.ev;
+            }
+        }
+        s(a, b, c, d, e, f, g, h, i, j, k) {
+            let l = null;
+            let m = null;
+            let n = null;
+            let o = null;
+            if (a.getChildCount() == 0) {
+                o = new XIcon();
+                l = new XLabel();
+                m = new XLabel();
+                a.setStyleProperty("display", "flex");
+                a.setStyleProperty("align-items", "center");
+                a.setStyleProperty("height", "100%");
+                let p = this.i.createElement("div");
+                let q = this.i.getSubRenderer(p);
+                o.provideContainer(q);
+                o.ap = 24;
+                o.as = 24;
+                p.setStyleProperty("margin-right", "10px");
+                let r = this.i.createElement("div");
+                let s = this.i.getSubRenderer(r);
+                l.provideContainer(s);
+                let t = this.i.createElement("div");
+                let u = this.i.getSubRenderer(t);
+                m.provideContainer(u);
+                this.h.addItem(a, l);
+                this.g.addItem(a, m);
+                this.f.addItem(a, o);
+                n = new XIcon();
+                let v = this.i.createElement("div");
+                let w = this.i.getSubRenderer(v);
+                n.provideContainer(w);
+                v.setStyleProperty("height", "100%");
+                v.setStyleProperty("margin-left", "-4px");
+                n.al = 16;
+                n.at = 16;
+                n.ap = 16;
+                n.as = 16;
+                n.ar = 2;
+                n.svgPath = "<svg width=\"16\" height=\"16\" viewBox=\"0 2 24 24\" fill=\"none\" stroke=\"rgba(0, 0, 0, 255)\" xmlns=\"http://www.w3.org/2000/svg\">\r\n" + "<path d=\"M20 11.1205L16.2166 14.8795L12.4575 11.1205\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/>\r\n" + "</svg>\r\n";
+                n.dp = BrushUtil.j(120, 0, 0, 0);
+                n.ao = DeviceUtils.g(1);
+                r.setStyleProperty("display", "flex");
+                r.setStyleProperty("height", "100%");
+                r.setStyleProperty("align-items", "center");
+                r.setStyleProperty("justify-content", "start");
+                r.setStyleProperty("flex", "auto");
+                t.setStyleProperty("display", "flex");
+                t.setStyleProperty("height", "100%");
+                t.setStyleProperty("align-items", "center");
+                t.setStyleProperty("justify-content", "center");
+                t.setStyleProperty("flex-direction", "column");
+                a.append(p);
+                a.append(r);
+                a.append(t);
+                a.append(v);
+            }
+            else {
+                l = this.h.item(a);
+                m = this.g.item(a);
+                o = this.f.item(a);
+            }
+            if (l != null) {
+                try {
+                    o.svg = null;
+                    o.cu = null;
+                    o.az = null;
+                    let x = e != null ? e : ((() => {
+                        let $ret = new FontInfo();
+                        $ret.f = g;
+                        $ret.q = f;
+                        return $ret;
+                    })());
+                    l.ak = true;
+                    l.p = this.b.baseTheme;
+                    l.y = x;
+                    l.text = c;
+                    l.l = 0;
+                    let y = a.getChildAt(0);
+                    let z = h != null || i != null || k != null;
+                    let aa = false;
+                    y.setStyleProperty("width", z ? "24px" : "0px");
+                    if (i != null) {
+                        aa = true;
+                        o.cu = i;
+                        let ab = ((() => {
+                            let $ret = new DataContext();
+                            $ret.series = this;
+                            $ret.item = null;
+                            $ret.itemBrush = ((() => {
+                                let $ret = new Brush();
+                                $ret.color = Color.u(255, 0, 0, 0);
+                                $ret.fill = "black";
+                                return $ret;
+                            })());
+                            return $ret;
+                        })());
+                        o.az = ab;
+                    }
+                    else if (h != null) {
+                        let ac = typeCast(IDataLegendTarget_$type, h);
+                        let ad = ac.getDataLegendSeries();
+                        if (ad != null) {
+                            for (let ae = 0; ae < ad.length; ae++) {
+                                let af = ad[ae];
+                                let ag = af.getDataLegendSeriesTitle();
+                                if (c == ag || c + " " + d == ag) {
+                                    aa = true;
+                                    o.cu = af.getDataLegendBadge();
+                                    o.az = af.getDataLegendBadgeContext();
+                                    break;
+                                }
+                            }
+                        }
+                        y.setStyleProperty("padding-bottom", "6px");
+                    }
+                    else if (k != null) {
+                        aa = true;
+                        o.aq = 0;
+                        o.ar = 0;
+                        o.al = 24;
+                        o.at = 24;
+                        o.ap = 24;
+                        o.as = 24;
+                        o.dh = BrushUtil.j(0, 255, 255, 255);
+                        o.fill = BrushUtil.j(0, 255, 255, 255);
+                        o.dp = BrushUtil.j(0, 255, 255, 255);
+                        o.di = BrushUtil.j(0, 255, 255, 255);
+                        o.svg = k;
+                    }
+                    if (!aa) {
+                        o.view.af();
+                    }
+                    let ah = a.getChildAt(2);
+                    let ai = a.getChildAt(3);
+                    if (stringIsNullOrEmpty(d)) {
+                        ah.setStyleProperty("display", "none");
+                        ai.setStyleProperty("display", "none");
+                        return;
+                    }
+                    else {
+                        ah.setStyleProperty("display", "flex");
+                        ai.setStyleProperty("display", "flex");
+                    }
+                    m.p = this.b.baseTheme;
+                    x.f = x.f - 2;
+                    m.ak = true;
+                    m.y = x;
+                    m.text = d;
+                    m.dj = BrushUtil.j(180, 0, 0, 0);
+                    m.l = 0;
+                }
+                finally {
+                }
+            }
+        }
+        ae() {
+            if (this.e != null) {
+                for (let a of fromEnum(this.e)) {
+                    let b = a.value;
+                    b.n = this.b.baseTheme;
+                }
+            }
+            if (this.a != null) {
+                this.a.n = this.b.baseTheme;
+            }
+        }
+        ac() {
+        }
+        n(a, b) {
+            let c = a;
+            let d = parseInt(c.a4.toString());
+            let e = c.checked;
+            if (e == true) {
+                if (this.b.indexType == 0) {
+                    this.b.d0(d);
+                }
+                else {
+                    this.b.cz(d);
+                }
+            }
+            else {
+                if (this.b.indexType == 0) {
+                    this.b.cz(d);
+                }
+                else {
+                    this.b.d0(d);
+                }
+            }
+            this.b.di(d, e);
+            this.al(false);
+        }
+        o() {
+        }
+        y(a, b) {
+            for (let c of fromEnum(this.e)) {
+                let d = c.value;
+                let e = parseInt(d.a4.toString());
+                if (e == a) {
+                    d.checked = b;
+                    this.b.di(e, b);
+                }
+            }
+            this.al();
+        }
+        z(a) {
+            for (let b of fromEnum(this.e)) {
+                let c = b.value;
+                c.checked = a;
+            }
+        }
+        u(a) {
+            this.m = a;
+            if (null != this.m) {
+                this.m.setStyleProperty("margin", "5px 0px 4px 0px");
+            }
+        }
+        am() {
+            let a = this.i;
+            if (null == a || null == this.m) {
+                return;
+            }
+            let b = a.createElement("div");
+            let c = a.getSubRenderer(b);
+            this.a = new XCheckbox();
+            this.a.provideContainer(c);
+            let d = this.i.getExternal(this.a, c.rootWrapper, this.i.getExternal(this.b, null, null));
+            this.a.n = this.b.baseTheme;
+            this.l = a.createElement("label");
+            this.l.setRawText(this.b.cp);
+            this.l.setStyleProperty("font-size", "13px");
+            this.m.setStyleProperty("display", "flex");
+            this.m.setStyleProperty("flex-direction", "row");
+            this.m.setStyleProperty("font-family", "Verdana");
+            this.m.setStyleProperty("align-items", "center");
+            this.m.append(b);
+            this.m.append(this.l);
+            this.an();
+            this.ak();
+            let e = this.a;
+            e.change = delegateCombine(e.change, runOn(this, this.w));
+            this.a.y = true;
+        }
+        ak() {
+            if (null != this.l) {
+                this.l.setRawText(this.b.cp);
+                NativeUI.q(this.l, this.b.ep);
+            }
+        }
+        an() {
+            if (null != this.l) {
+                let a = this.b.showSelectAll ? "flex" : "none";
+                this.m.setStyleProperty("display", a);
+            }
+        }
+        aj() {
+            if (this.k != null) {
+                this.k.setStyleProperty("display", this.b.a3 ? "block" : "none");
+            }
+            if (this.j != null) {
+                this.j.setStyleProperty("display", this.b.a3 ? "block" : "none");
+            }
+        }
+        al(a = true) {
+            if (this.a == null) {
+                return;
+            }
+            let b = this.d;
+            this.d = true;
+            let c = this.a.z;
+            this.a.z = a;
+            try {
+                if (this.b.a0) {
+                    this.a.indeterminate = true;
+                    return;
+                }
+                this.a.indeterminate = false;
+                if (this.b.indexType == 0) {
+                    this.a.checked = this.b.keys.count == 0;
+                }
+                else {
+                    this.a.checked = this.b.keys.count != 0;
+                }
+            }
+            finally {
+                this.a.z = c;
+                this.d = b;
+            }
+        }
+        w(a, b) {
+            if (this.d || b.isIndeterminate) {
+                return;
+            }
+            if (b.isChecked) {
+                this.b.d3();
+                this.b.dr(b.isChecked);
+            }
+            else {
+                this.b.c5();
+                this.b.dr(b.isChecked);
+            }
+        }
+        ai() {
+            let a = this.i;
+            if (null == a) {
+                return;
+            }
+            let b = a.rootWrapper;
+            if (null != b) {
+                NativeUI.q(b, this.b.e7);
+                NativeUI.m(b, this.b.backgroundColor);
+            }
+        }
+        ag() {
+            if (this.c != null) {
+                this.c.fill = this.b.searchIconColor;
+            }
+        }
+        ah() {
+            if (this.b.am != null) {
+                this.l.setStyleProperty("font", this.b.am.fontString);
+            }
+            else {
+                this.l.setStyleProperty("font-family", "Verdana");
+                this.l.setStyleProperty("font-size", 13 + "px");
+            }
+        }
+        ad() {
+            if (this.a == null) {
+                return;
+            }
+            this.a.dk = this.b.et;
+            this.a.dd = this.b.er;
+            this.a.dl = this.b.eu;
+            this.a.de = this.b.es;
+            this.a.dm = this.b.ev;
+        }
+        af(a) {
+            if (this.j != null) {
+                NativeUI.w(this.j, a);
+            }
+        }
+        t(a) {
+            this.j = a;
+        }
+        v() {
+            for (let a of fromEnum(this.f)) {
+                a.value.cu = null;
+                a.value.az = null;
+            }
+        }
+    }
+    CheckboxListView.$t = markType(CheckboxListView, 'CheckboxListView');
+    return CheckboxListView;
+})();
+/**
+ * @hidden
+ */
+export let CheckboxList = /*@__PURE__*/ (() => {
+    class CheckboxList extends Base {
+        constructor() {
+            super();
+            this._view = null;
+            this.f = null;
+            this.j = null;
+            this.ai = null;
+            this.ag = null;
+            this.aj = null;
+            this.ah = null;
+            this.d = null;
+            this.aq = false;
+            this.c = null;
+            this.t = null;
+            this.v = null;
+            this.ar = false;
+            this.ao = null;
+            this.g = new GridSelectedKeysCollection();
+            this.a = null;
+            this.propertyChanged = null;
+            this.selectedKeyAdded = null;
+            this.selectedKeyRemoved = null;
+            this.checkedChanged = null;
+            this.labelClicked = null;
+            this.bg = null;
+            this.bj = null;
+            this.bf = null;
+            this.bn = null;
+            this.bl = null;
+            this.bm = null;
+            this.bk = null;
+            this.x = 3;
+            this.bb = -1;
+            this.ak = null;
+            this.k = 1;
+            this.ac = 1;
+            this.ae = 2;
+            this.el = BrushUtil.j(255, 24, 29, 31);
+            this.ej = null;
+            this.at = true;
+            this.em = null;
+            this.ek = null;
+            this.al = null;
+            this.ee = null;
+            this.ec = null;
+            this.ef = null;
+            this.ed = null;
+            this.eg = null;
+            this.a6 = NaN;
+            this.aa = 0;
+            this.ei = null;
+            this.indexTypeChanged = null;
+            this.as = false;
+            this.co = null;
+            this.en = null;
+            this.ea = CheckboxList.ey;
+            this.a4 = true;
+            this.eb = CheckboxList.ew;
+            this.eh = CheckboxList.ex;
+            this.eo = CheckboxList.ey;
+            this.keysCleared = null;
+            this.selectAllCheckboxChanged = null;
+            this.bd = -1;
+            this.a2 = true;
+            this.ay = true;
+            this.au = false;
+            let a = this.g;
+            a.collectionChanged = delegateCombine(a.collectionChanged, runOn(this, this.du));
+            this.g.am(runOn(this, this.dt));
+            this.d = new FilterFactory();
+            let b = new CheckboxListView();
+            b.b = this;
+            this.view = b;
+            this.view.q();
+        }
+        get view() {
+            return this._view;
+        }
+        set view(a) {
+            this._view = a;
+        }
+        get w() {
+            return this.v;
+        }
+        set w(a) {
+            this.v = a;
+        }
+        get u() {
+            return this.t;
+        }
+        set u(a) {
+            this.t = a;
+        }
+        get e() {
+            if (this.f == null) {
+                return null;
+            }
+            return this.f.actualDataSource;
+        }
+        get ap() {
+            if (this.ao == null) {
+                this.ao = new SRProvider(this.view.i);
+                this.ao.cb("DataGrid");
+            }
+            return this.ao;
+        }
+        get keys() {
+            return this.g;
+        }
+        get primaryKey() {
+            return this.a;
+        }
+        set primaryKey(a) {
+            let b = this.a;
+            this.a = a;
+            if (b != this.a) {
+                this.dp("PrimaryKey", b, this.a);
+            }
+        }
+        clearSelectedKeys() {
+            this.keys.clear();
+            if (this.keysCleared != null) {
+                this.keysCleared(this, new CheckboxListKeysClearedEventArgs());
+            }
+        }
+        addSelectedKey(a, b) {
+            this.keys.add(new PrimaryKeyValue(a, b));
+        }
+        insertSelectedKey(a, b, c) {
+            this.keys.insert(a, new PrimaryKeyValue(b, c));
+        }
+        removeSelectedKeyAt(a) {
+            this.keys.removeAt(a);
+        }
+        dt() {
+            this.db();
+            if (this.keysCleared != null) {
+                this.keysCleared(this, new CheckboxListKeysClearedEventArgs());
+            }
+        }
+        du(a, b) {
+            if (this.e == null || this.e.actualSchema == null || this.aq) {
+                return;
+            }
+            switch (b.action) {
+                case 0:
+                    for (let c = 0; c < b.newItems.count; c++) {
+                        this.dm(b.newItems.item(c));
+                    }
+                    break;
+                case 1:
+                    for (let d = 0; d < b.oldItems.count; d++) {
+                        this.dn(b.oldItems.item(d));
+                    }
+                    break;
+                case 2:
+                    for (let e = 0; e < b.oldItems.count; e++) {
+                        this.dn(b.oldItems.item(e));
+                    }
+                    for (let f = 0; f < b.newItems.count; f++) {
+                        this.dm(b.newItems.item(f));
+                    }
+                    break;
+                case 4:
+                    this.view.z(this.indexType == 0);
+                    for (let g = 0; g < this.keys.ae.count; g++) {
+                        this.dm(this.keys.ae._inner[g]);
+                    }
+                    break;
+            }
+        }
+        dm(a) {
+            let b = this.e.indexOfKey(a.value);
+            if (b >= 0) {
+                this.view.y(b, this.indexType == 1);
+            }
+            if (this.selectedKeyAdded == null) {
+                return;
+            }
+            this.selectedKeyAdded(this, ((() => {
+                let $ret = new CheckedChangedEventArgs();
+                $ret.c = b;
+                $ret.b = this.indexType == 1;
+                $ret.a = a.value;
+                return $ret;
+            })()));
+        }
+        dn(a) {
+            let b = this.e.indexOfKey(a.value);
+            if (b >= 0) {
+                this.view.y(b, this.indexType == 0);
+            }
+            if (this.selectedKeyRemoved == null) {
+                return;
+            }
+            this.selectedKeyRemoved(this, ((() => {
+                let $ret = new CheckedChangedEventArgs();
+                $ret.c = b;
+                $ret.b = this.indexType == 0;
+                $ret.a = a.value;
+                return $ret;
+            })()));
+        }
+        di(a, b) {
+            if (this.checkedChanged != null && this.ar == false) {
+                let c = null;
+                if (this.e.actualPrimaryKey != null && this.e.actualPrimaryKey.length > 0) {
+                    c = new Array(this.e.actualPrimaryKey.length);
+                    for (let d = 0; d < this.e.actualPrimaryKey.length; d++) {
+                        c[d] = this.e.getItemPropertyAtIndex(a, this.e.actualPrimaryKey[d]);
+                    }
+                }
+                this.checkedChanged(this, ((() => {
+                    let $ret = new CheckedChangedEventArgs();
+                    $ret.c = a;
+                    $ret.b = b;
+                    $ret.a = c;
+                    return $ret;
+                })()));
+            }
+        }
+        notifySizeChanged() {
+            this.view.o();
+        }
+        destroy() {
+            if (this.f != null) {
+                let a = this.f;
+                a.cellClicked = delegateRemove(a.cellClicked, runOn(this, this.c7));
+                let b = this.f;
+                b.sizeChanged = delegateRemove(b.sizeChanged, runOn(this, this.c8));
+                if (this.f.actualDataSource != null) {
+                    let c = this.f.actualDataSource;
+                    c.schemaChanged = delegateRemove(c.schemaChanged, runOn(this, this.dq));
+                }
+            }
+            if (this.t != null) {
+                let d = this.t;
+                d.change = delegateRemove(d.change, runOn(this, this.c9));
+            }
+            this.provideContainer(null, null, null);
+            if (this.j != null) {
+                let e = this.j;
+                e.cellUpdating = delegateRemove(e.cellUpdating, runOn(this, this.c3));
+            }
+        }
+        provideContainer(a, b, c) {
+            this.f = b;
+            if (null != this.f) {
+                this.f.scrollbarStyle = 1;
+                let d = this.f;
+                d.sizeChanged = delegateCombine(d.sizeChanged, runOn(this, this.c8));
+                this.f.scrollbarBackground = this.e0;
+                this.f.headerHeight = 0;
+                this.f.rowSeparatorHeight = 0;
+                this.f.defaultColumnMinWidth = NaN;
+                this.f.autoGenerateColumns = false;
+                this.f.activationMode = 0;
+                this.f.editMode = 0;
+                let e = this.f;
+                e.cellClicked = delegateCombine(e.cellClicked, runOn(this, this.c7));
+                if (this.bg != null) {
+                    this.f.itemsSource = this.bg;
+                    this.c2();
+                    this.ds();
+                }
+                if (this.bj != null) {
+                    this.ds();
+                    this.d6();
+                }
+            }
+            this.view.u(c);
+            if (this.av) {
+                this.d8();
+            }
+            this.view.p(a);
+        }
+        c8(a, b) {
+            this.f.scrollbarStyle = this.ab;
+        }
+        provideSelectAllSection(a) {
+            this.view.u(a);
+        }
+        c7(a, b) {
+            if (!this.av && b.cellInfo.l.a5 == 0 || this.av && b.cellInfo.l.a5 == 1) {
+                return;
+            }
+            let c = b.cellInfo.l.x;
+            if (-1 == c) {
+                return;
+            }
+            let d = b.cellInfo.hn;
+            let e = this.i(d);
+            if (this.a1) {
+                if (this.keys.contains(e)) {
+                    if (this.ai != null) {
+                        this.ai.setPropertyValue(d, false);
+                    }
+                    this.keys.remove(e);
+                }
+                else {
+                    if (this.ai != null) {
+                        this.ai.setPropertyValue(d, true);
+                    }
+                    this.keys.add(e);
+                }
+            }
+            this.de(c, this.keys.contains(e));
+        }
+        de(a, b) {
+            let c = null;
+            if (this.e.actualPrimaryKey != null && this.e.actualPrimaryKey.length > 0) {
+                c = new Array(this.e.actualPrimaryKey.length);
+                for (let d = 0; d < this.e.actualPrimaryKey.length; d++) {
+                    c[d] = this.e.getItemPropertyAtIndex(a, this.e.actualPrimaryKey[d]);
+                }
+            }
+            if (this.labelClicked == null) {
+                return;
+            }
+            this.labelClicked(this, ((() => {
+                let $ret = new CheckedChangedEventArgs();
+                $ret.c = a;
+                $ret.b = b;
+                $ret.a = c;
+                return $ret;
+            })()));
+        }
+        c3(a, b) {
+            let c = b.cellInfo.l.x;
+            if (-1 == c) {
+                return;
+            }
+            let d = false;
+            if (b.cellInfo.hn != null) {
+                let e = this.i(b.cellInfo.hn);
+                if (this.keys.contains(e)) {
+                    d = true;
+                }
+            }
+            this.view.r(b.content.element, c, d);
+        }
+        d7(a, b) {
+            let c = b.cellInfo.l.x;
+            if (-1 == c) {
+                return;
+            }
+            let d = null;
+            let e = null;
+            let f = null;
+            let g = null;
+            let h = null;
+            if (b.cellInfo.hn != null) {
+                d = this.ag.getPropertyValue(b.cellInfo.hn);
+                if (this.aj != null) {
+                    e = this.aj.getPropertyValue(b.cellInfo.hn);
+                }
+                if (this.ah != null) {
+                    let i = EnumUtil.getEnumValue(DataSeriesPropertyType_$type, this.ah.getPropertyValue(b.cellInfo.hn));
+                    if (i == 0) {
+                        h = SvgIconRegistry.instance.getSvgPathString("ChartToolbarIcons", "string-field");
+                    }
+                    else if (i == 2) {
+                        h = SvgIconRegistry.instance.getSvgPathString("ChartToolbarIcons", "numeric-field");
+                    }
+                    else if (i == 1) {
+                        h = SvgIconRegistry.instance.getSvgPathString("ChartToolbarIcons", "date-time-field");
+                    }
+                }
+            }
+            this.view.s(b.content.element, c, d, e, this.ak, "Verdana", 13, this.bf, f, g, h);
+        }
+        dj(a) {
+            if (this.bj != null) {
+                let b = this.d.property(this.bj).cast(enumGetBox(DataSourceSchemaPropertyType_$type, 0)).toLower();
+                let c = b.contains(a);
+                if (!this.f.filterExpressions.k.contains(this.c)) {
+                    this.c = c;
+                    this.f.filterExpressions.add(this.c);
+                }
+                else {
+                    let d = this.f.filterExpressions.k.indexOf(this.c);
+                    this.f.filterExpressions.k.item(d, this.c = c);
+                }
+            }
+        }
+        get itemsSource() {
+            return this.bg;
+        }
+        set itemsSource(a) {
+            let b = this.bg;
+            this.bg = a;
+            if (b != this.bg) {
+                this.dp("ItemsSource", b, this.bg);
+            }
+        }
+        get dataMemberPath() {
+            return this.bj;
+        }
+        set dataMemberPath(a) {
+            let b = this.bj;
+            this.bj = a;
+            if (b != this.bj) {
+                this.dp("DataMemberPath", b, this.bj);
+            }
+        }
+        get bh() {
+            return this.bf;
+        }
+        set bh(a) {
+            let b = this.bf;
+            this.bf = a;
+            if (b != this.bf) {
+                this.dp("DataLegendTarget", b, this.bf);
+            }
+        }
+        get cw() {
+            return this.bn;
+        }
+        set cw(a) {
+            let b = this.bn;
+            this.bn = a;
+            if (b != this.bn) {
+                this.dp("SubtitleMemberPath", b, this.bn);
+            }
+        }
+        get cb() {
+            return this.bl;
+        }
+        set cb(a) {
+            let b = this.bl;
+            this.bl = a;
+            if (b != this.bl) {
+                this.dp("PropertyTypeMemberPath", b, this.bl);
+            }
+        }
+        get selectedMemberPath() {
+            return this.bm;
+        }
+        set selectedMemberPath(a) {
+            let b = this.bm;
+            this.bm = a;
+            if (b != this.bm) {
+                this.dp("SelectedMemberPath", b, this.bm);
+            }
+        }
+        get b4() {
+            return this.bk;
+        }
+        set b4(a) {
+            let b = this.bk;
+            this.bk = a;
+            if (b != this.bk) {
+                this.dp("FilterPlaceholderText", b, this.bk);
+            }
+        }
+        get y() {
+            return this.x;
+        }
+        set y(a) {
+            let b = this.x;
+            this.x = a;
+            if (b != this.x) {
+                this.dp("SearchInputType", enumGetBox(InputGroupDisplayType_$type, b), enumGetBox(InputGroupDisplayType_$type, this.x));
+            }
+        }
+        get be() {
+            return this.bb;
+        }
+        set be(a) {
+            let b = this.bb;
+            this.bb = a;
+            if (b != this.bb) {
+                this.dp("RowHeight", b, this.bb);
+            }
+        }
+        get bc() {
+            if (this.f != null) {
+                return this.f.actualRowHeight;
+            }
+            else if (this.bb != -1) {
+                return this.bb;
+            }
+            else {
+                switch (this.density) {
+                    case 4:
+                    case 3: return GridStyleRepository.q;
+                    case 0:
+                    case 2: return GridStyleRepository.r;
+                    case 1: return GridStyleRepository.p;
+                }
+                return GridStyleRepository.r;
+            }
+        }
+        get am() {
+            return this.ak;
+        }
+        set am(a) {
+            let b = this.ak;
+            this.ak = a;
+            if (b != this.ak) {
+                this.dp("CellTextStyle", b, this.ak);
+            }
+        }
+        get indexType() {
+            return this.k;
+        }
+        set indexType(a) {
+            let b = this.k;
+            this.k = a;
+            if (b != this.k) {
+                this.dp("IndexType", enumGetBox(CheckboxListIndexType_$type, b), enumGetBox(CheckboxListIndexType_$type, this.k));
+            }
+        }
+        get baseTheme() {
+            return this.ac;
+        }
+        set baseTheme(a) {
+            let b = this.ac;
+            this.ac = a;
+            if (b != this.ac) {
+                this.dp("BaseTheme", enumGetBox(BaseControlTheme_$type, b), enumGetBox(BaseControlTheme_$type, this.ac));
+            }
+        }
+        get density() {
+            return this.ae;
+        }
+        set density(a) {
+            let b = this.ae;
+            this.ae = a;
+            if (b != this.ae) {
+                this.dp("Density", enumGetBox(ControlDisplayDensity_$type, b), enumGetBox(ControlDisplayDensity_$type, this.ae));
+            }
+        }
+        get searchIconColor() {
+            return this.el;
+        }
+        set searchIconColor(a) {
+            let b = this.el;
+            this.el = a;
+            if (b != this.el) {
+                this.dp("SearchIconColor", b, this.el);
+            }
+        }
+        get e1() {
+            return this.ej;
+        }
+        set e1(a) {
+            let b = this.ej;
+            this.ej = a;
+            if (b != this.ej) {
+                this.dp("SearchBackgroundColor", b, this.ej);
+            }
+        }
+        get a1() {
+            return this.at;
+        }
+        set a1(a) {
+            let b = this.at;
+            this.at = a;
+            if (b != this.at) {
+                this.dp("LabelClickTriggersChange", b, this.at);
+            }
+        }
+        get searchTextColor() {
+            return this.em;
+        }
+        set searchTextColor(a) {
+            let b = this.em;
+            this.em = a;
+            if (b != this.em) {
+                this.dp("SearchTextColor", b, this.em);
+            }
+        }
+        get e2() {
+            return this.ek;
+        }
+        set e2(a) {
+            let b = this.ek;
+            this.ek = a;
+            if (b != this.ek) {
+                this.dp("SearchBorderColor", b, this.ek);
+            }
+        }
+        get an() {
+            return this.al;
+        }
+        set an(a) {
+            let b = this.al;
+            this.al = a;
+            if (b != this.al) {
+                this.dp("SearchTextStyle", b, this.al);
+            }
+        }
+        get et() {
+            return this.ee;
+        }
+        set et(a) {
+            let b = this.ee;
+            this.ee = a;
+            if (b != this.ee) {
+                this.dp("CheckboxTickColor", b, this.ee);
+            }
+        }
+        get er() {
+            return this.ec;
+        }
+        set er(a) {
+            let b = this.ec;
+            this.ec = a;
+            if (b != this.ec) {
+                this.dp("CheckboxCheckedBackgroundColor", b, this.ec);
+            }
+        }
+        get eu() {
+            return this.ef;
+        }
+        set eu(a) {
+            let b = this.ef;
+            this.ef = a;
+            if (b != this.ef) {
+                this.dp("CheckboxUncheckedBackgroundColor", b, this.ef);
+            }
+        }
+        get es() {
+            return this.ed;
+        }
+        set es(a) {
+            let b = this.ed;
+            this.ed = a;
+            if (b != this.ed) {
+                this.dp("CheckboxCheckedBorderColor", b, this.ed);
+            }
+        }
+        get ev() {
+            return this.eg;
+        }
+        set ev(a) {
+            let b = this.eg;
+            this.eg = a;
+            if (b != this.eg) {
+                this.dp("CheckboxUncheckedBorderColor", b, this.eg);
+            }
+        }
+        get a7() {
+            return this.a6;
+        }
+        set a7(a) {
+            let b = this.a6;
+            this.a6 = a;
+            if (b != this.a6) {
+                this.dp("CheckboxCornerRadius", b, this.a6);
+            }
+        }
+        get ab() {
+            return this.aa;
+        }
+        set ab(a) {
+            let b = this.aa;
+            this.aa = a;
+            if (b != this.aa) {
+                this.dp("ScrollbarStyle", enumGetBox(ScrollbarStyle_$type, b), enumGetBox(ScrollbarStyle_$type, this.aa));
+            }
+        }
+        get e0() {
+            return this.ei;
+        }
+        set e0(a) {
+            let b = this.ei;
+            this.ei = a;
+            if (b != this.ei) {
+                this.dp("ScrollbarBackground", b, this.ei);
+            }
+        }
+        dp(a, b, c) {
+            if (this.propertyChanged != null) {
+                this.propertyChanged(this, new PropertyChangedEventArgs(a));
+            }
+            this.dv(a, b, c);
+        }
+        dv(a, b, c) {
+            switch (a) {
+                case "IndexType":
+                    this.keys.clear();
+                    this.db();
+                    if (this.keysCleared != null) {
+                        this.keysCleared(this, new CheckboxListKeysClearedEventArgs());
+                    }
+                    this.view.al();
+                    this.dk(b, c);
+                    break;
+                case "ItemsSource":
+                    if (this.f != null) {
+                        this.indexType = 1;
+                        if (c != null) {
+                            this.f.groupDescriptions.n();
+                            this.f.sortDescriptions.n();
+                            this.f.filterExpressions.clear();
+                            this.f.summaryDescriptions.n();
+                        }
+                        if (this.f.actualDataSource != null) {
+                            let d = this.f.actualDataSource;
+                            d.schemaChanged = delegateRemove(d.schemaChanged, runOn(this, this.dq));
+                        }
+                        this.f.itemsSource = this.bg;
+                        this.c2();
+                        if (this.f.actualDataSource != null) {
+                            let e = this.f.actualDataSource;
+                            e.schemaChanged = delegateCombine(e.schemaChanged, runOn(this, this.dq));
+                        }
+                        this.ar = true;
+                        this.ds();
+                        this.ar = false;
+                        this.view.al();
+                    }
+                    break;
+                case "DataMemberPath":
+                case "SelectedMemberPath":
+                case "SubtitleMemberPath":
+                case "PropertyTypeMemberPath":
+                    if (this.f != null) {
+                        if (this.bj != null) {
+                            this.ds();
+                            this.d6();
+                        }
+                    }
+                    break;
+                case "PrimaryKey":
+                    if (this.f != null) {
+                        this.f.primaryKey = this.primaryKey;
+                    }
+                    break;
+                case "SelectAllCaptionTextColor":
+                    this.ep = null != this.e5 ? this.e5 : CheckboxList.ey;
+                    break;
+                case "SelectAllCaption":
+                case "ActualSelectAllCaptionTextColor":
+                    this.view.ak();
+                    break;
+                case "showSelectAll":
+                    this.view.an();
+                    this.view.x();
+                    break;
+                case "ShowFilter":
+                    this.view.aj();
+                    this.view.x();
+                    break;
+                case "FilterPlaceholderText":
+                    if (this.t != null) {
+                        this.t.cg = this.b4;
+                    }
+                    break;
+                case "SearchInputType":
+                    if (this.v != null) {
+                        this.v.d = this.y;
+                    }
+                    break;
+                case "RowHeight":
+                    if (this.f != null) {
+                        this.f.rowHeight = this.be;
+                    }
+                    break;
+                case "CellTextStyle":
+                    if (this.f != null) {
+                        this.f.cellTextStyle = this.am;
+                    }
+                    this.view.ah();
+                    break;
+                case "BackgroundColor":
+                case "TextColor":
+                case "RowHoverBackgroundColor":
+                    let f = this.f;
+                    if (null != f) {
+                        f.cellTextColor = this.e7;
+                        f.cellBackground = this.backgroundColor;
+                        f.cellSelectedBackground = this.backgroundColor;
+                        f.rowHoverBackground = this.rowHoverBackgroundColor;
+                    }
+                    this.view.ai();
+                    break;
+                case "BaseTheme":
+                    this.d5();
+                    break;
+                case "Density":
+                    this.d4();
+                    break;
+                case "IsRowHoverEnabled":
+                    if (this.f != null) {
+                        this.f.isRowHoverEnabled = this.az;
+                    }
+                    break;
+                case "ScrollbarStyle":
+                    if (this.f != null) {
+                        this.f.scrollbarStyle = this.ab;
+                    }
+                    break;
+                case "ScrollbarBackground":
+                    if (this.f != null) {
+                        this.f.scrollbarBackground = this.e0;
+                    }
+                    break;
+                case "SearchIconColor":
+                    this.view.ag();
+                    break;
+                case "SearchBackgroundColor":
+                    this.w.mc = this.e1;
+                    break;
+                case "SearchBorderColor":
+                    this.w.md = this.e2;
+                    break;
+                case "SearchTextColor":
+                    if (this.u != null) {
+                        this.u.d8 = this.searchTextColor;
+                    }
+                    break;
+                case "SearchTextStyle":
+                    this.u.af = this.an;
+                    break;
+                case "CheckboxTickColor":
+                case "CheckboxCheckedBackgroundColor":
+                case "CheckboxUncheckedBackgroundColor":
+                case "CheckboxCheckedBorderColor":
+                case "CheckboxUncheckedBorderColor":
+                case "CheckboxCornerRadius":
+                    this.view.ad();
+                    if (this.f != null) {
+                        this.f.xq();
+                    }
+                    break;
+                case "CheckboxAlignedRight":
+                    if (this.f != null) {
+                        this.d8();
+                    }
+                    break;
+                case "DataLegendTarget":
+                    if (this.f != null) {
+                        this.f.xq();
+                    }
+                    break;
+            }
+        }
+        d8() {
+            if (this.f.actualColumns.count == 0) {
+                return;
+            }
+            let a = this.f.actualColumns._inner[0];
+            let b = this.f.actualColumns._inner[1];
+            let c = this.f.actualColumns._inner[2];
+            this.f.actualColumns.clear();
+            if (this.av) {
+                this.f.columns.add(b);
+                this.f.columns.add(a);
+            }
+            else {
+                this.f.columns.add(a);
+                this.f.columns.add(b);
+            }
+            this.f.columns.add(c);
+        }
+        dk(a, b) {
+            if (this.indexTypeChanged != null) {
+                this.indexTypeChanged(this, ((() => {
+                    let $ret = new CheckboxListIndexTypeChangedEventArgs();
+                    $ret.b = EnumUtil.getEnumValue(CheckboxListIndexType_$type, a);
+                    $ret.a = EnumUtil.getEnumValue(CheckboxListIndexType_$type, b);
+                    return $ret;
+                })()));
+            }
+        }
+        d4() {
+            if (this.f != null) {
+                this.f.density = this.density;
+            }
+            if (this.v != null) {
+                this.v.t = this.density;
+            }
+            this.view.ac();
+        }
+        d5() {
+            if (this.v != null) {
+                this.v.p = this.baseTheme;
+            }
+            if (this.u != null) {
+                this.u.d8 = this.searchTextColor;
+            }
+            if (this.f != null) {
+                this.f.cellTextColor = this.e7;
+                this.f.cellBackground = this.backgroundColor;
+                this.f.cellSelectedBackground = this.backgroundColor;
+                this.f.rowHoverBackground = this.rowHoverBackgroundColor;
+            }
+            this.view.ae();
+        }
+        dq(a, b) {
+            this.ar = true;
+            this.c2();
+            if (b.schema != null) {
+                this.ds();
+                for (let c = 0; c < this.keys.count; c++) {
+                    this.dm(this.keys._inner[c]);
+                }
+                this.view.al();
+            }
+            this.ar = false;
+        }
+        ds() {
+            if (this.ai == null && this.bm != null && this.bm != "") {
+                this.ai = new FastReflectionHelper(false, this.bm);
+            }
+            if (this.ag == null && this.bj != null && this.bj != "") {
+                this.ag = new FastReflectionHelper(false, this.bj);
+            }
+            if (this.aj == null && this.bn != null && this.bn != "") {
+                this.aj = new FastReflectionHelper(false, this.bn);
+            }
+            if (this.ah == null && this.bl != null && this.bl != "") {
+                this.ah = new FastReflectionHelper(false, this.bl);
+            }
+            if (this.ag != null) {
+                this.ag.propertyName = this.bj;
+            }
+            if (this.aj != null) {
+                this.aj.propertyName = this.bn;
+            }
+            if (this.ah != null) {
+                this.ah.propertyName = this.bl;
+            }
+            if (this.bg != null && this.ai != null && this.f.actualDataSource.actualSchema != null) {
+                this.ai.propertyName = this.bm;
+                let a = this.f.actualDataSource.actualCount;
+                for (let b = 0; b < a; b++) {
+                    let c = this.f.actualDataSource.getItemAtIndex(b);
+                    let d = this.i(c);
+                    let e = this.ai.getPropertyValue(c);
+                    if (e == true) {
+                        if (!this.keys.contains(d)) {
+                            this.keys.add(d);
+                        }
+                    }
+                    else if (this.keys.contains(d)) {
+                        this.keys.remove(d);
+                    }
+                }
+            }
+        }
+        d6() {
+            this.f.actualColumns.clear();
+            this.f.primaryKey = this.primaryKey;
+            this.f.isGroupRowSticky = false;
+            this.f.rowHeight = this.be;
+            this.f.cellBackground = this.backgroundColor;
+            this.f.cellSelectedBackground = this.backgroundColor;
+            this.f.density = this.density;
+            this.f.isRowHoverEnabled = this.az;
+            this.f.borderWidth = new Thickness(0, 0);
+            if (this.am != null) {
+                this.f.cellTextStyle = this.am;
+            }
+            let a = new TemplateColumn();
+            if (this.bm == null) {
+                this.bm = "";
+            }
+            a.lo = this.bm;
+            a.mf = "CheckboxColumn";
+            let b = new ColumnWidth();
+            b.c = false;
+            b.f = 28;
+            a.width = b;
+            a.kk = 0;
+            a.kl = 0;
+            a.cellUpdating = delegateCombine(a.cellUpdating, runOn(this, this.c3));
+            this.j = a;
+            this.f.columns.add(a);
+            let c = this.f.actualDataSource.resolveSchemaPropertyType(this.bj);
+            if ((this.bn != null || this.bl != null) && (c == 0 || c == 11 || c == 2)) {
+                let d = new TemplateColumn();
+                d.lo = this.bj;
+                d.mf = "DataColumn";
+                d.kk = 0;
+                d.g = 0;
+                d.cellUpdating = delegateCombine(d.cellUpdating, runOn(this, this.d7));
+                this.f.columns.add(d);
+            }
+            else {
+                let e;
+                switch (c) {
+                    case 8:
+                    case 9:
+                        e = new DateTimeColumn();
+                        break;
+                    case 1:
+                    case 3:
+                    case 4:
+                    case 5:
+                    case 6:
+                    case 7:
+                    case 10:
+                        e = new NumericColumn();
+                        break;
+                    case 2:
+                    case 11:
+                    case 0:
+                    default:
+                        e = new TextColumn();
+                        break;
+                }
+                e.lo = this.bj;
+                e.mf = "DataColumn";
+                e.kk = 0;
+                e.g = 0;
+                this.f.columns.add(e);
+            }
+            let f = new TemplateColumn();
+            let g = new ColumnWidth();
+            g.c = false;
+            g.f = 10;
+            f.lo = "PaddingColumn";
+            f.mf = "PaddingColumn";
+            f.kk = 0;
+            f.width = g;
+            this.f.columns.add(f);
+        }
+        updateHrMargin(a) {
+            this.view.af(a);
+        }
+        provideHrElement(a) {
+            this.view.t(a);
+        }
+        dl() {
+            let a = this.u;
+            a.changing = delegateCombine(a.changing, runOn(this, this.c9));
+            this.d5();
+        }
+        c9(a, b) {
+            let c = b.value.toLowerCase();
+            this.dj(c);
+        }
+        i(a) {
+            if (this.primaryKey == null) {
+                return PrimaryKeyValue.createIdentityKey(a);
+            }
+            let b = new Array(this.primaryKey.length);
+            let c = new Array(this.primaryKey.length);
+            for (let d = 0; d < b.length; d++) {
+                b[d] = this.primaryKey[d];
+                c[d] = this.e.getItemProperty(a, b[d]);
+            }
+            return new PrimaryKeyValue(b, c);
+        }
+        d0(a) {
+            this.aq = true;
+            let b = this.e.getItemAtIndex(a);
+            if (this.ai != null) {
+                this.ai.setPropertyValue(b, false);
+            }
+            let c = this.i(b);
+            this.keys.remove(c);
+            this.aq = false;
+        }
+        cz(a) {
+            this.aq = true;
+            let b = this.e.getItemAtIndex(a);
+            if (this.ai != null) {
+                this.ai.setPropertyValue(b, true);
+            }
+            let c = this.i(b);
+            this.keys.add(c);
+            this.aq = false;
+        }
+        d3() {
+            this.indexType = 0;
+            this.keys.clear();
+            this.db();
+            if (this.keysCleared != null) {
+                this.keysCleared(this, new CheckboxListKeysClearedEventArgs());
+            }
+        }
+        c5() {
+            this.indexType = 1;
+            this.keys.clear();
+            this.db();
+            if (this.keysCleared != null) {
+                this.keysCleared(this, new CheckboxListKeysClearedEventArgs());
+            }
+        }
+        dg(a, b, c) {
+            if (this.f != null) {
+                this.f.notifySetItem(a, b, c);
+            }
+        }
+        dc() {
+            if (this.f != null) {
+                this.f.notifyClearItems();
+            }
+        }
+        db() {
+            if (this.f != null) {
+                this.f.invalidateVisibleRows();
+            }
+        }
+        dd(a, b) {
+            if (this.f != null) {
+                this.f.notifyInsertItem(a, b);
+            }
+            ;
+        }
+        df(a, b) {
+            if (this.f != null) {
+                this.f.notifyRemoveItem(a, b);
+            }
+            ;
+        }
+        refresh() {
+            if (this.as) {
+                return;
+            }
+            if (this.f != null) {
+                this.as = true;
+                this.view.v();
+                this.f.refresh();
+                this.as = false;
+            }
+        }
+        c0(a) {
+            let b = null;
+            if (this.primaryKey == null || this.primaryKey.length == 0) {
+                b = new PrimaryKeyValue(null, a);
+            }
+            else if (this.primaryKey.length == a.length) {
+                b = new PrimaryKeyValue(this.primaryKey, a);
+            }
+            else {
+                throw new ArgumentException(1, "value length must match PrimaryKey length");
+            }
+            if (b != null) {
+                if (this.ai != null) {
+                    let c = this.e.indexOfKey(a);
+                    let d = this.e.getItemAtIndex(c);
+                    this.ai.setPropertyValue(d, true);
+                }
+                this.keys.add(b);
+            }
+        }
+        d1(a) {
+            let b = null;
+            if (this.primaryKey == null || this.primaryKey.length == 0) {
+                b = new PrimaryKeyValue(null, a);
+            }
+            else if (this.primaryKey.length == a.length) {
+                b = new PrimaryKeyValue(this.primaryKey, a);
+            }
+            else {
+                throw new ArgumentException(1, "value length must match PrimaryKey length");
+            }
+            if (this.keys.contains(b)) {
+                if (this.ai != null) {
+                    let c = this.e.indexOfKey(a);
+                    let d = this.e.getItemAtIndex(c);
+                    this.ai.setPropertyValue(d, false);
+                }
+                this.keys.remove(b);
+            }
+        }
+        getDesiredSize(a) {
+            let b = 248;
+            let c = 0;
+            let d = this.a9();
+            let e = 5;
+            if (this.f != null && this.f.actualDataSource != null && this.f.actualDataSource.actualCount > 0) {
+                e = this.f.actualDataSource.actualCount;
+            }
+            let f = this.bc * e;
+            let g = this.bc * (this.showSelectAll ? 4 : 5);
+            let h = f > g ? g : f;
+            let i = d + h;
+            if (isPositiveInfinity(a.height)) {
+                c = i;
+            }
+            else {
+                if (a.height <= i) {
+                    c = i;
+                }
+                else {
+                    let j = a.height - i;
+                    c = d + j;
+                }
+            }
+            return new Size(1, b, c);
+        }
+        a9() {
+            let a = 0;
+            a += ComponentSizeHelpers.d(this.density, this.baseTheme);
+            a += ComponentSizeHelpers.c(this.density, this.baseTheme);
+            a += (0.8 + 6);
+            a += 4;
+            if (this.showSelectAll) {
+                a += this.bc;
+            }
+            a += 4;
+            return a;
+        }
+        get cp() {
+            return this.co != null ? this.co : !stringIsNullOrWhiteSpace(this.ap.b1("Select_All")) ? this.ap.b1("Select_All") : "(Select All)";
+        }
+        set cp(a) {
+            if (a == this.co) {
+                return;
+            }
+            let b = this.co;
+            this.co = a;
+            this.dp("SelectAllCaption", b, this.co);
+        }
+        get e5() {
+            return this.en;
+        }
+        set e5(a) {
+            let b = this.en;
+            this.en = a;
+            if (b != this.en) {
+                this.dp("SelectAllCaptionTextColor", b, a);
+            }
+        }
+        get ep() {
+            return this.ea;
+        }
+        set ep(a) {
+            let b = this.ea;
+            this.ea = a;
+            if (b != this.ea) {
+                this.dp("ActualSelectAllCaptionTextColor", b, a);
+            }
+        }
+        get a0() {
+            if (-1 == this.bd) {
+                return false;
+            }
+            let a = this.keys.count;
+            if (0 == a) {
+                return false;
+            }
+            if (a == this.bd) {
+                return false;
+            }
+            return true;
+        }
+        get showSelectAll() {
+            return this.a4;
+        }
+        set showSelectAll(a) {
+            if (a == this.a4) {
+                return;
+            }
+            let b = this.a4;
+            this.a4 = a;
+            this.dp("showSelectAll", b, this.a4);
+        }
+        get backgroundColor() {
+            return this.eb;
+        }
+        set backgroundColor(a) {
+            let b = this.eb;
+            this.eb = a;
+            if (b != this.eb) {
+                this.dp("BackgroundColor", b, a);
+            }
+        }
+        get rowHoverBackgroundColor() {
+            return this.eh;
+        }
+        set rowHoverBackgroundColor(a) {
+            let b = this.eh;
+            this.eh = a;
+            if (b != this.eh) {
+                this.dp("RowHoverBackgroundColor", b, a);
+            }
+        }
+        get e7() {
+            return this.eo;
+        }
+        set e7(a) {
+            let b = this.eo;
+            this.eo = a;
+            if (b != this.eo) {
+                this.dp("TextColor", b, a);
+            }
+        }
+        dr(a) {
+            if (this.selectAllCheckboxChanged != null) {
+                this.selectAllCheckboxChanged(this, ((() => {
+                    let $ret = new SelectAllCheckboxChangedEventArgs();
+                    $ret.a = a;
+                    return $ret;
+                })()));
+            }
+        }
+        ax() {
+            if (-1 == this.bd) {
+                return true;
+            }
+            let a = this.keys.count;
+            switch (this.indexType) {
+                case 0: return this.bd == a;
+                case 1: return 0 == a;
+                default: return false;
+            }
+        }
+        aw() {
+            if (-1 == this.bd) {
+                return false;
+            }
+            let a = this.keys.count;
+            switch (this.indexType) {
+                case 0: return 0 == a;
+                case 1: return this.bd == a;
+                default: return false;
+            }
+        }
+        c2() {
+            let a = this.f.actualDataSource;
+            if (null != a) {
+                if (null == a.actualSchema) {
+                    this.bd = -1;
+                    return;
+                }
+                let b = a.actualCount;
+                this.bd = b;
+            }
+            else {
+                this.bd = -1;
+            }
+        }
+        get a3() {
+            return this.a2;
+        }
+        set a3(a) {
+            if (a == this.a2) {
+                return;
+            }
+            let b = this.a2;
+            this.a2 = a;
+            this.dp("ShowFilter", b, this.a2);
+        }
+        get az() {
+            return this.ay;
+        }
+        set az(a) {
+            if (a == this.ay) {
+                return;
+            }
+            let b = this.ay;
+            this.ay = a;
+            this.dp("IsRowHoverEnabled", b, this.ay);
+        }
+        get av() {
+            return this.au;
+        }
+        set av(a) {
+            if (a == this.au) {
+                return;
+            }
+            let b = this.au;
+            this.au = a;
+            this.dp("CheckboxAlignedRight", b, this.au);
+        }
+    }
+    CheckboxList.$t = markType(CheckboxList, 'CheckboxList', Base.$, [INotifyPropertyChanged_$type]);
+    CheckboxList.e6 = BrushUtil.j(255, 24, 29, 31);
+    CheckboxList.cl = "M15.5 14h-.79l-.28-.27C15.41 12.59 16 11.11 16 9.5 16 5.91 13.09 3 9.5 3S3 5.91 3 9.5 5.91 16 9.5 16c1.61 0 3.09-.59 4.23-1.57l.27.28v.79l5 4.99L20.49 19l-4.99-5zm-6 0C7.01 14 5 11.99 5 9.5S7.01 5 9.5 5 14 7.01 14 9.5 11.99 14 9.5 14z";
+    CheckboxList.ew = BrushUtil.j(255, 248, 248, 248);
+    CheckboxList.ex = null;
+    CheckboxList.ey = BrushUtil.j(255, 24, 29, 31);
+    return CheckboxList;
+})();