@refinitiv-ui/efx-grid 6.0.0-next.0

package/lib/tr-grid-checkbox/es6/Checkbox.js

@@ -0,0 +1,1476 @@
+import {Ext} from '../../tr-grid-util/es6/Ext.js';
+import {GridPlugin} from '../../tr-grid-util/es6/GridPlugin.js';
+import {ElfUtil} from '../../tr-grid-util/es6/ElfUtil.js';
+import {injectCss, prettifyCss, extendObject} from "../../tr-grid-util/es6/Util.js";
+
+/** @typedef {Object} CheckboxPlugin~Options
+* @description Available options describing `checkbox` object specified in grid's option
+* @property {boolean=} rowSelection=false If enabled, grid row will be selected as checkbox is checked.
+* @property {string=} field="CHECK_BOX" Field that will be used for storing check state
+* @property {string=} disablingField="CHECK_BOX_DISABLED" Field that will be used for storing disabling state
+* @property {Function=} checkboxCreated=null Function handler for checkboxCreated event
+* @property {Function=} checkboxBinding=null Function handler for checkboxBinding event
+* @property {Function=} clicked=null Function handler for checkbox clicked event
+* @property {number=} width=34 Width for checkbox column
+*/
+
+/** @typedef {Object} CheckboxPlugin~ColumnOptions
+* @property {boolean=} checkboxColumn=false If enabled, the correspondence column will use as checkbox column.
+*/
+
+/** @event CheckboxPlugin#checkboxCreated
+* @description Fired on each creation of checkbox element
+* @property {Element} input Checkbox element that is an alias to `checkbox`
+* @property {Element} checkbox Checkbox element
+* @property {Object} cell Grid Cell object
+* @property {Object} section Grid ILayoutGrid object
+* @property {Object} grid Core Grid object
+* @property {number} colIndex
+* @property {number} rowIndex
+*/
+
+/** @event CheckboxPlugin#checkboxBinding
+* @description Fired on each rendering of checkbox element
+* @property {Element} checkbox Checkbox element
+* @property {Object} rowData
+* @property {number} rowIndex
+*/
+
+/** @event CheckboxPlugin#clicked
+* @property {Element} checkbox element
+* @property {number} rowIndex
+* @property {boolean} checked
+* @property {string} checkState
+*/
+
+
+/** @constructor
+* @extends {GridPlugin}
+* @param {CheckboxPlugin~Options=} options
+*/
+var CheckboxPlugin = function (options) {
+	var t = this;
+	t._onPreSectionRender = t._onPreSectionRender.bind(t);
+	t._onPostSectionDataBinding = t._onPostSectionDataBinding.bind(t);
+	t._onCheckboxClicked = t._onCheckboxClicked.bind(t);
+	t._onColumnIndexChanged = t._onColumnIndexChanged.bind(t);
+	t._onColumnAdded = t._onColumnAdded.bind(t);
+	t._requestUIPopulation = t._requestUIPopulation.bind(t);
+	t._populateUIs = t._populateUIs.bind(t);
+	t.selectAll = t.selectAll.bind(t);
+	t.deselectAll = t.deselectAll.bind(t);
+	t._hosts = [];
+
+	if(options) {
+		t.config({"checkbox": options});
+	}
+};
+Ext.inherits(CheckboxPlugin, GridPlugin);
+
+/** @type {number}
+* @private
+*/
+CheckboxPlugin.prototype._width = 34;
+/** @type {number}
+* @private
+*/
+CheckboxPlugin.prototype._displayColumn = -1;
+/** @type {number}
+* @private
+*/
+CheckboxPlugin.prototype._userCheckboxIdx = -1;
+/** @type {number}
+* @private
+*/
+CheckboxPlugin.prototype._updateTimer = 0;
+/** @type {boolean}
+* @private
+*/
+CheckboxPlugin.prototype._initializing = false;
+/** @type {number}
+* @private
+*/
+CheckboxPlugin.prototype._coralCheckboxVer = -1; // Contains version number of the coral checkbox, -1 means not initialize yet
+/** @type {string}
+* @private
+*/
+CheckboxPlugin.prototype._checkboxField = "CHECK_BOX";
+/** @type {string}
+* @private
+*/
+CheckboxPlugin.prototype._disablingField = "CHECK_BOX_DISABLED";
+/** @type {boolean}
+* @private
+*/
+CheckboxPlugin.prototype._autoRowSelection = false;
+/** @type {Function}
+* @private
+*/
+CheckboxPlugin._emptyFunc = function () { };
+/** @type {Object.<string, number>}
+* @private
+*/
+CheckboxPlugin._exceptions = {
+	"filterInputs": 1,
+	"bottomPadding": 1
+};
+/** @type {string}
+* @private
+*/
+CheckboxPlugin._styles = prettifyCss([
+	".tr-checkbox-column input[type='checkbox'], .tr-checkbox-column input+label", [
+		"cursor: pointer;"
+	],
+	".column.tr-checkbox-column .cell", [
+		"padding: 0;",
+		"text-align: center;"
+	]
+]);
+/** @private
+* @param {Object} grid core grid object
+*/
+CheckboxPlugin._applyStyles = function(grid) {
+	if(grid && !grid._checkboxStyles) { // TODO: Support run-time theme loading
+		grid._checkboxStyles = true; // Prevent loading the same style twice
+		injectCss(CheckboxPlugin._styles, grid.getElement());
+	}
+};
+
+/** @type {number}
+* @private
+*/
+CheckboxPlugin._runningId = 0;
+
+/** @private
+* @function
+* @param {*} val
+* @return {string}
+*/
+CheckboxPlugin._toCheckState = function (val) {
+	if (val === "partial") {
+		return "partial";
+	} else {
+		return (val) ? "checked" : "unchecked";
+	}
+};
+/** @private
+* @function
+* @param {Element} chkbox
+* @return {string}
+*/
+CheckboxPlugin._getCheckState = function (chkbox) {
+	if(chkbox.style.display == "none" || chkbox.hasAttribute("disabled")) { // slow
+		return "";
+	}
+	// WORKAROUND
+	// in elf v3, v4 chkbox.indeterminate can represent 'partial' state
+	// but we check class 'square-shape' instead to support elf v1 and native checkbox input
+	else if (chkbox.classList.contains('square-shape')) {
+		return "partial";
+	} else if (chkbox.checked) {
+		return "checked";
+	} else {
+		return "unchecked";
+	}
+};
+/** @private
+* @function
+* @param {Element} chkbox
+* @param {string} state
+* @return {number} Return non-zero value if there is a state change
+*/
+CheckboxPlugin._setCheckState = function (chkbox, state) {
+	if (chkbox._forceNewState) { // WORKAROUND: to force checkbox move to next state
+		state = chkbox._forceNewState;
+		chkbox._forceNewState = null;
+	} else if (CheckboxPlugin._getCheckState(chkbox) === state) { // Process change only when necessary
+		return 0;
+	}
+
+	if(state === "partial") {
+		chkbox.classList.add("square-shape");
+		// Elf v3 will clear indeterminate state when setting checked property
+		chkbox.checked = (this._coralCheckboxVer < 3); // WARNING: This is not a conventional standard
+		chkbox.setAttribute("indeterminate", "");
+	} else {
+		chkbox.classList.remove("square-shape");
+		chkbox.checked = (state === "checked");
+		chkbox.removeAttribute("indeterminate");
+	}
+	// WORKAROUND: to force detech _prevState of check box
+	chkbox._prevState = state;
+	return 1;
+};
+/** @private
+* @function
+* @param {string} curState checked|unchecked|partial
+* @return {string} Return new state checked|unchecked
+*/
+CheckboxPlugin._toggleState = function (curState) {
+	// WARNING: When clicking indeterminated checkbox, it should result in selecting all (checked)
+	return (curState == "checked" || curState == "partial") ? "unchecked" : "checked";
+};
+/** @private
+* @function
+* @param {string} curState
+* @param {string} state
+* @return {string} checked|unchecked|partial
+*/
+CheckboxPlugin._mergeState = function(curState, state) {
+	if(curState) {
+		if(state) {
+			if(curState !== state) {
+				return "partial";
+			}
+		} else {
+			return curState;
+		}
+	}
+	return state;
+};
+/** @private
+* @function
+* @param {Array.<string>} states
+* @return {string} checked|unchecked|partial
+*/
+CheckboxPlugin._mergeStates = function(states) {
+	var state = "";
+	for (var i = states.length; --i >= 0; ) {
+		state = CheckboxPlugin._mergeState(state, states[i]);
+		if (state === "partial") {
+			return state;
+		}
+	}
+	return state;
+};
+/** @private
+* @function
+* @param {number} count
+* @param {boolean} bool
+* @return {Array.<boolean>}
+*/
+CheckboxPlugin._genData = function (count, bool) {
+	var data = new Array(count);
+	for(var i = count; --i >= 0;) { data[i] = bool; }
+	return data;
+};
+
+/** @public
+* @return {string}
+*/
+CheckboxPlugin.prototype.getName = function () {
+	return "CheckboxPlugin"; // Read Only
+};
+/** @public
+* @param {Object} host core grid object
+* @param {Object=} options
+*/
+CheckboxPlugin.prototype.initialize = function (host, options) {
+	if(this._hosts.indexOf(host) >= 0) { return; }
+	this._hosts.push(host);
+
+	host.listen("preSectionRender", this._onPreSectionRender);
+	host.listen("postSectionDataBinding", this._onPostSectionDataBinding);
+
+	host.listen("columnAdded", this._onColumnIndexChanged);
+	host.listen("columnAdded", this._onColumnAdded);
+	host.listen("columnMoved", this._onColumnIndexChanged);
+	host.listen("columnRemoved", this._onColumnIndexChanged);
+
+	this.config(options);
+	CheckboxPlugin._applyStyles(host);
+
+	this._requestUIPopulation();
+};
+/** @public
+* @param {Object} host core grid object
+*/
+CheckboxPlugin.prototype.unload = function (host) {
+	var at = this._hosts.indexOf(host);
+	if(at < 0) { return; }
+
+	host.unlisten("preSectionRender", this._onPreSectionRender);
+	host.unlisten("postSectionDataBinding", this._onPostSectionDataBinding);
+
+	host.unlisten("columnAdded", this._onColumnIndexChanged);
+	host.unlisten("columnAdded", this._onColumnAdded);
+	host.unlisten("columnMoved", this._onColumnIndexChanged);
+	host.unlisten("columnRemoved", this._onColumnIndexChanged);
+
+	this._hosts.splice(at, 1);
+
+	if(!this._hosts.length) {
+		this._compositeGrid = null;
+		if(this._updateTimer) {
+			clearTimeout(this._updateTimer);
+			this._updateTimer = 0;
+		}
+	}
+};
+/** Remove redundant built-in feature
+* @public
+* @param {string} optionName
+* @param {*} optionVal
+* @return {*} The transformed value of the option
+*/
+CheckboxPlugin.prototype.beforeProcessOption = function (optionName, optionVal) {
+	if (optionName == "checkboxSelector") {
+		return null; // eslint-disable-line
+	}
+	return; // eslint-disable-line
+};
+
+/** @public
+* @param {Object=} options
+*/
+CheckboxPlugin.prototype.config = function (options) {
+	if(!options) { return; }
+
+	var chkboxOpt = /** @type{Object} */(options["checkbox"]);
+	if(!chkboxOpt) {
+		return;
+	}
+
+	var val;
+	val = chkboxOpt["rowSelection"]; // previously named "selectCheckedRow"
+	if(val != null) {
+		this._autoRowSelection = val ? true : false;
+	}
+	val = chkboxOpt["field"];
+	if(val) {
+		this._checkboxField = val;
+	}
+	val = chkboxOpt["disablingField"];
+	if(val) {
+		this._disablingField = val;
+	}
+	val = chkboxOpt["width"];
+	if(val) {
+		this._width = val;
+	}
+
+	this.addListener(chkboxOpt, "checkboxCreated");
+	this.addListener(chkboxOpt, "clicked");
+	this.addListener(chkboxOpt, "checkboxBinding");
+};
+
+/** @public
+* @param {Object=} gridOptions
+* @return {!Object}
+*/
+CheckboxPlugin.prototype.getConfigObject = function (gridOptions) {
+	var obj = gridOptions || {};
+
+	var columns = obj.columns;
+	if (!columns) {
+		columns = obj.columns = [];
+	}
+
+	var len = this.getColumnCount();
+	for(var i = 0; i < len; ++i) {
+		var col = columns[i];
+		if (!col) {
+			col = columns[i] = {};
+		}
+
+		var colOptions = this._getColumnData(i);
+		if(colOptions.isCheckboxColumn || i === this._userCheckboxIdx) {
+			col.checkboxColumn = true;
+		}
+	}
+
+	var extOptions = obj.checkbox;
+	if(!extOptions) {
+		extOptions = obj.checkbox = {};
+	}
+
+	if(this._autoRowSelection) {
+		extOptions.rowSelection = true;
+	}
+
+	if(this._checkboxField !== "CHECK_BOX") {
+		extOptions.field = this._checkboxField;
+	}
+
+	if(this._disablingField !== "CHECK_BOX_DISABLED") {
+		extOptions.disablingField = this._disablingField;
+	}
+
+	if(this._width !== 34) {
+		extOptions.width = this._width;
+	}
+
+	return obj;
+};
+
+/** @public
+ * @ignore
+* @param {Element} elem
+* @param {Object} config
+* @param {boolean} runTime Indicates that this is runtime loading
+*/
+CheckboxPlugin.prototype.beforeInit = function(elem, config, runTime) {
+	if(runTime) {
+		return; // Since this is runTime loading, there is no point of processing config object.
+	}
+	var t = this;
+	t._displayColumn = -1;
+
+	// Add missing fields to avoid shifting of data due to adding of checkbox column
+	var columns = config["columns"];
+	if (config.dataModel) {
+		config.dataModel = t._prepareData(columns, config.dataModel);
+	}
+	if (config.staticDataRows) {
+		config.staticDataRows = t._prepareData(columns, config.staticDataRows);
+	}
+
+	var chbxConfig = config["checkbox"];
+	if (chbxConfig) {
+		// Set checkbox column width here to ensure the column width will not blink during the initialization
+		if (chbxConfig["width"] != null) {
+			t._width = chbxConfig["width"];
+		}
+
+		if (chbxConfig["field"] != null) {
+			t._checkboxField = chbxConfig["field"];
+		}
+	}
+
+	var chbxCol = t._genCheckboxColumn();
+	var checkboxIdx = t._userCheckboxIdx = t._findCheckboxColumnIndexFromConfig(columns);
+
+	if (checkboxIdx >= 0) {
+		// WARNING:: User column config will be deleted here since we swap user column with our generated checkbox column
+		extendObject(columns[checkboxIdx], chbxCol);
+	} else {
+		checkboxIdx = t._userCheckboxIdx = 0;
+		columns.unshift(chbxCol);
+	}
+
+	// Ensure freeze columns on the left of checkbox column
+	var freezeCol;
+	var freezeColumn = config["freezeColumn"];
+	var columnFreezing = config["columnFreezing"];
+	if (freezeColumn != null && freezeColumn >= 0) {
+		freezeCol = freezeColumn;
+	}
+	if (columnFreezing != null && columnFreezing >= 0) {
+		freezeCol = columnFreezing;
+	}
+	if (checkboxIdx <= freezeColumn) {
+		config["freezeColumn"] = config["columnFreezing"] = freezeCol + 1;
+	}
+};
+
+/** @private
+* @return {Object} checkbox column config
+*/
+CheckboxPlugin.prototype._genCheckboxColumn = function () {
+	return {
+		autoGenerated: true,
+		width: this._width,
+		sortable: false,
+		className: "tr-checkbox-column", // For rt-grid
+		classes: { "tr-checkbox-column": 1 }, // For composite grid
+		noResizing: true, // ColumnResizing Extension
+		resizable: false, // ResizableTitlePlugin
+		headerRenderer: this._onPreSectionRender, // rt-grid support
+		filterInput: { disabled: true },
+		field: this._checkboxField,
+		notRealTimeField: true, // Checkbox column is not a real-time field
+		checkboxColumn: true,
+		binding: CheckboxPlugin._emptyFunc, // rt-grid binding
+		formatter: { // composite-grid binding,
+			renderTitle: CheckboxPlugin._emptyFunc,
+			render: CheckboxPlugin._emptyFunc,
+			bind: CheckboxPlugin._emptyFunc
+		}
+	};
+};
+
+/** @private
+* @param {Array.<Object>} columns
+* @param {Array.<Object>|Object} dataModel
+* @return {Object} data model
+*/
+CheckboxPlugin.prototype._prepareData = function (columns, dataModel) {
+	var model = dataModel;
+	if (Array.isArray(dataModel)) {
+		model = { data: dataModel };
+	}
+	if (model.data && !model.fields) {
+		// if data is 2D then we should add fields into dataModel
+		if (Array.isArray(model.data[0])) {
+			model.fields = this._getFieldsFromColumns(columns);
+		}
+	}
+
+	return model;
+};
+
+/** @private
+* @param {Array.<Object>} columns
+* @return {Array.<string>} list of fields
+*/
+CheckboxPlugin.prototype._getFieldsFromColumns = function (columns) {
+	var colCount = columns.length;
+	var fields = new Array(colCount);
+	for (var c = 0; c < colCount; c++) {
+		var col = columns[c];
+		if(!col) {
+			fields[c] = "";
+		} else if (typeof col === "string") {
+			fields[c] = col;
+		} else {
+			fields[c] = col.field || "";
+		}
+	}
+	return fields;
+};
+
+/** @private
+ * @param {Array.<Object>} columns
+* @return {number} Return negative number if the column not found
+*/
+CheckboxPlugin.prototype._findCheckboxColumnIndexFromConfig = function (columns) {
+	if (Array.isArray(columns)) {
+		var colCount = columns.length;
+		for (var i = 0; i < colCount; i++) {
+			if (columns[i].checkboxColumn) {
+				return i;
+			}
+		}
+	}
+	return -1;
+};
+
+/** @public
+* @return {number} Return negative number if the column not found
+*/
+CheckboxPlugin.prototype.getCheckboxColumnIndex = function () {
+	if(this._displayColumn < 0) {
+		var host = this._hosts[0];
+		var colCount = host ? host.getColumnCount() : 0;
+		for(var c = 0; c < colCount; ++c) {
+			var colData = this._getColumnData(c, host);
+			if(colData && colData.isCheckboxColumn) {
+				this._displayColumn = c;
+				break;
+			}
+		}
+	}
+	return this._displayColumn;
+};
+/** @public
+* @function
+* @param {number}
+* @return {number} Return negative number if the column not found
+*/
+CheckboxPlugin.prototype.getDisplayColumn = CheckboxPlugin.prototype.getCheckboxColumnIndex;
+/** @public
+* @param {Object} sectionRef Grid SectionReference object
+* @param {number} rowIndex
+* @return {Element}
+*/
+CheckboxPlugin.prototype.getCheckbox = function (sectionRef, rowIndex) {
+	var host = this._hosts[0];
+	var sectionSettings = host.getSectionSettings(sectionRef);
+	if (sectionSettings) {
+		return this._getCheckbox(sectionSettings, rowIndex);
+	}
+
+	return null;
+};
+
+
+/** @private
+* @param {Object} sectionSettings Grid sectionSettings object
+* @param {number} colIndex
+* @param {number} rowIndex
+* @return {Element}
+*/
+CheckboxPlugin.prototype._createCheckbox = function (sectionSettings, colIndex, rowIndex) {
+	var section = sectionSettings.getSection();
+
+	var cell = section.getCell(colIndex, rowIndex);
+	if(!cell) {
+		return null;
+	}
+	var content = cell.getContent();
+	if(content && content._chkbox) {
+		return content;
+	}
+
+	if (this._coralCheckboxVer === -1) {
+		this._coralCheckboxVer = ElfUtil.hasComponent("ef-checkbox");
+	}
+
+	var chkbox;
+	if(this._coralCheckboxVer) {
+		chkbox = document.createElement("ef-checkbox");
+	} else {
+		chkbox = document.createElement("input");
+		chkbox.setAttribute("type", "checkbox");
+	}
+	chkbox._chkbox = true;
+
+	chkbox.addEventListener("click", this._onCheckboxClicked, false);
+	// chkbox.addEventListener("checked-changed", this._onCheckboxClicked, false); // Elf v3
+
+	cell.setContent(chkbox);
+	var sectionType = sectionSettings.getType();
+	if(sectionType == "title") {
+		cell.enableClass("no-sort");
+	}
+
+	if(!this._coralCheckboxVer) { // Workaround for UIFR theme styling
+		var lbl = document.createElement("label");
+		var id = "tr_grid_checkbox_" + CheckboxPlugin._runningId++;
+		chkbox.setAttribute("id", id);
+		lbl.setAttribute("for", id);
+		chkbox.parentElement.appendChild(lbl); // HACK
+	}
+
+	this._dispatch("checkboxCreated", {
+		"input": chkbox
+		, "checkbox": chkbox
+		, "cell": cell
+		, "colIndex": colIndex
+		, "rowIndex": rowIndex
+		, "grid": this._hosts[0]
+		, "section": section
+		, "sectionType": sectionType
+	});
+
+	return chkbox;
+};
+
+
+/** Select all checkboxes that are not affected by filtering and pagination logics. This is equivalent to ticking the checkbox at the top header section of the grid
+* @public
+*/
+CheckboxPlugin.prototype.selectAll = function () {
+	this.checkAll(true);
+};
+/** Deselect all checkboxes that are not affected by filtering and pagination logics. This is equivalent to un-ticking the checkbox at the top header section of the grid
+* @public
+* @param {boolean} check
+*/
+CheckboxPlugin.prototype.deselectAll = function () {
+	this.checkAll(false);
+};
+
+/** This is equivalent to clicking the checkbox at the top header section of the grid. <br>
+* Use {@link CheckboxPlugin#setAllCheckStates} to set all states regardless of filtering and pagination
+* @public
+* @param {boolean} checked Truthy or Falsy value
+* @see {@link CheckboxPlugin#setAllCheckStates}
+*/
+CheckboxPlugin.prototype.checkAll = function (checked) {
+	var state = CheckboxPlugin._toCheckState(checked != null ? checked : true);
+	var host = this._hosts[0];
+	var titles = host ? host.getAllSectionSettings("title") : null;
+	if (!titles) return;
+
+	var rootSettings;
+	for(var i = 0; i < titles.length; ++i) { // Find the root settings
+		if(titles[i].getChildren()) {
+			rootSettings = titles[i];
+			break;
+		}
+	}
+	if(!rootSettings) { return; }
+
+	this._setSectionState(rootSettings, state);
+	this._setDescendantCheckState(rootSettings, state);
+};
+/** Set state for all checkboxes regardless of filtering and pagination
+* @public
+* @param {boolean} checked Truthy or Falsy value
+* @see {@link CheckboxPlugin#checkAll}
+*/
+CheckboxPlugin.prototype.setAllCheckStates = function (checked) {
+	checked = checked ? true : false;
+	var host = this._hosts[0];
+	var dv = host ? host.getDataSource() : null;
+	var dt = dv ? dv.getDataSource() : null;
+
+	if(dt) {
+		var valueList = CheckboxPlugin._genData(dt.getRowCount(), checked);
+		var rids = dt.getAllRowIds();
+		this._setColumnData(dv, this._checkboxField, valueList, rids);
+	}
+};
+
+/** @public
+* @param {number|string} rowRef Row id in the data table or row index
+* @param {boolean} disabled Truthy or Falsy value
+*/
+CheckboxPlugin.prototype.disableCheckbox = function(rowRef, disabled) {
+	var host = this._hosts[0];
+	var dv = host ? host.getDataSource() : null;
+	if(!dv) { return; }
+
+	if(typeof rowRef === "string") {
+		// TODO: should allow invisible row
+		rowRef = dv.getRowIndex(rowRef);
+	}
+
+	if(rowRef == null || rowRef < 0) {
+		return;
+	}
+
+	this._setData(dv, rowRef, this._disablingField, disabled !== false);
+};
+
+/** @public
+* @param {number|string} rowRef Row id in the data table or row index
+*/
+CheckboxPlugin.prototype.enableCheckbox = function(rowRef) {
+	this.disableCheckbox(rowRef, false);
+};
+
+/** WARNING: Index is not reliable when use with row grouping due to dynamic nature of the features (e.g. expanding and collapsing of the group). <br>
+* Please use {@link CheckboxPlugin#getSelectedRowData} instead. <br>
+* Current behavior is to get selected index from un-filtered rows.
+* @public
+* @param {Object} sectionRef Grid SectionReference object
+* @param {string=} state Specifies state for searching. Default is "checked"
+* @return {!Array.<number>} the indices are relative to the specified section
+* @see {@link CheckboxPlugin#getSelectedRowData}
+*/
+CheckboxPlugin.prototype.getAllCheckedIndices = function (sectionRef, state) {
+	var ary = [];
+	var colIndex = this.getCheckboxColumnIndex();
+	var host = colIndex >= 0 ? this._hosts[0] : null;
+	var sectionSettings = host ? host.getSectionSettings(sectionRef) : null;
+
+	if (sectionSettings) {
+		if (state == null) { state = "checked"; }
+		var r, rowCount;
+		if (this._isDataBound(sectionSettings)) {
+			var dv = sectionSettings.getDataSource();
+			var rowIds = dv.getVisibleRowIds(true); // Filter and pagination are applied
+			rowCount = rowIds.length;
+			for (r = 0; r < rowCount; ++r) {
+				var rowData = this._getRowFromId(dv, rowIds[r]);
+				if(rowData) {
+					if (CheckboxPlugin._toCheckState(rowData[this._checkboxField]) === state) {
+						ary.push(r);
+					}
+				}
+			}
+		} else {
+			var section = sectionSettings.getSection();
+			rowCount = section.getRowCount();
+			for (r = 0; r < rowCount; ++r) {
+				var chkbox = this._getCheckbox(section, r);
+				if (CheckboxPlugin._getCheckState(chkbox) === state) {
+					ary.push(r);
+				}
+			}
+		}
+	}
+	return ary;
+};
+
+/** Return selected rows, excluding rows that are filtered or hidden due to pagination.
+* @public
+* @param {string=} field="" When field is not provided, entire rowData is returned. If field is specified, field values will be returned. Use "ROW_ID" as the field for retrieving internal row ids.
+* @return {!Array} Returns selected rows
+*/
+CheckboxPlugin.prototype.getFilteredSelectedData = function (field) {
+	var host = this._hosts[0];
+	return this._getSelectedRowData(host ? host.getDataSource() : null, field);
+};
+
+/** Returns all selected rows, even if the rows are filtered or hidden due to group collapsing or pagination. <br>
+* Note that the results are NOT shown in order of the current appearance (i.e. sorting has no impact).
+* @public
+* @param {string=} field="" When field is not provided, entire rowData is returned. If field is specified, field values will be returned. Use "ROW_ID" as the field for retrieving internal row ids.
+* @return {!Array} Returns selected rows
+* @example
+* var chkBoxExtension = new CheckboxExtension();
+* chkBoxExtension.getSelectedRowData(); // Get all selected row data in this format [{}, {}, ... RowData objects, {}]
+* chkBoxExtension.getSelectedRowData("field"); // Get all field values from selected row data in this format [value1, value2, ... values, valueN]
+*/
+CheckboxPlugin.prototype.getAllSelectedData = function (field) {
+	var host = this._hosts[0];
+	var dv = host ? host.getDataSource() : null;
+	var dt = dv ? dv.getDataSource() : null; // get All selected Data we use dataTable instead
+	return this._getSelectedRowData(dt, field);
+};
+
+/** Alias of {@link CheckboxPlugin#getAllSelectedData}
+* @public
+* @param {string=} field="" When field is not provided, entire rowData is returned. If field is specified, field values will be returned. Use "ROW_ID" as the field for retrieving internal row ids.
+* @return {!Array} Returns selected rows
+*/
+CheckboxPlugin.prototype.getSelectedRowData = CheckboxPlugin.prototype.getAllSelectedData;
+
+/** @private
+* @param {Object} dataSource DataView or DataTable object
+* @return {!Array} Returns selected row ids
+*/
+CheckboxPlugin.prototype._getSelectedRowIds = function (dataSource) {
+	if (!dataSource || this.getCheckboxColumnIndex() < 0) {
+		return [];
+	}
+
+	var rowIds = this._getRowMemberIdsInView(dataSource);
+	var rowCount = rowIds.length;
+	var selRowIds = [];
+	var i, rowId;
+	for (i = 0; i < rowCount; ++i) {
+		rowId = rowIds[i];
+		if (this._getCheckboxValue(dataSource, rowId)) {
+			selRowIds.push(rowId);
+		}
+	}
+	return selRowIds;
+};
+
+/** @private
+* @param {Object} dataSource DataView or DataTable object
+* @param {string=} field="" When field is not provided, entire rowData is returned. If field is specified, field values will be returned. Use "ROW_ID" as the field for retrieving internal row ids.
+* @return {!Array} Returns selected rows
+*/
+CheckboxPlugin.prototype._getSelectedRowData = function (dataSource, field) {
+	var selRowIds = this._getSelectedRowIds(dataSource);
+	var i, rowCount = selRowIds.length;
+	if (field === "ROW_ID" || rowCount === 0) {
+		return selRowIds; // Row Ids
+	} else {
+		var selRows = new Array(rowCount);
+		for (i = 0; i < rowCount; ++i) {
+			selRows[i] = this._getRowFromId(dataSource, selRowIds[i]);
+		}
+		if (field) {
+			var values = new Array(rowCount);
+			for (i = 0; i < rowCount; ++i) {
+				values[i] = selRows[i][field];
+			}
+			return values; // Field values
+		} else {
+			return selRows; // Row objects
+		}
+	}
+};
+
+/** @private
+* @function
+* @param {Object} dv DataView
+* @param {string} rowId
+* @return {boolean} Check State
+*/
+CheckboxPlugin.prototype._getRowFromId = function (dv, rowId) {
+	return this._rowGetter(dv.getRowData(rowId));
+};
+/** @private
+* @param {Object} dv DataView
+* @param {string} rowId
+* @return {boolean} Check State
+*/
+CheckboxPlugin.prototype._getCheckboxValue = function (dv, rowId) {
+	var row = this._getRowFromId(dv, rowId);
+	if(row) {
+		return row[this._checkboxField] ? true : false;
+	}
+	return false;
+};
+/** @private
+* @param {Object} dv DataView
+* @return {string} state
+*/
+CheckboxPlugin.prototype._getGroupState = function (dv) {
+	if (!dv) return "unchecked";
+
+	var rowIds;
+	if (dv.getGroupLevel && 0 === dv.getGroupLevel()) {
+		// case root group we check state from member that visible in view
+		rowIds = this._getRowMemberIdsInView(dv);
+	} else {
+		// case dataTable or subGroup we check state from member in group
+		rowIds = dv.getAllRowIds(true); // Getting shallow copy and excluding header rows
+	}
+
+	var dataRows = dv.getMultipleRowData(rowIds);
+	var len = rowIds.length;
+	if (0 === len) return "unchecked";
+
+	var dataRow;
+	var states = [];
+	for(var i = 0; i < len; ++i) {
+		if (dv.getGroupByRowId(rowIds[i])) { continue; }
+		dataRow = dataRows[i];
+		if(dataRow && dataRow[this._disablingField]) {
+			continue;
+		}
+		states.push(CheckboxPlugin._toCheckState(this._getCheckboxValue(dv, rowIds[i])));
+	}
+	return CheckboxPlugin._mergeStates(states);
+};
+/** @private
+* @param {Object} sectionSettings Grid sectionSettings object
+* @return {string}
+*/
+CheckboxPlugin.prototype._getSectionState = function (sectionSettings) {
+	if (this._isDataBound(sectionSettings)) {
+		return this._getGroupState(sectionSettings.getDataSource());
+	} else {
+		var checkboxes = this._getAllCheckboxes(sectionSettings);
+		var states = checkboxes.map(CheckboxPlugin._getCheckState);
+		return CheckboxPlugin._mergeStates(states);
+	}
+};
+/** @private
+* @param {Object} sectionSettings Grid sectionSettings object
+* @param {number} rowIndex
+* @return {Element}
+*/
+CheckboxPlugin.prototype._getCheckbox = function (sectionSettings, rowIndex) {
+	var section = sectionSettings.getSection();
+	var chkbox = /** @type{Element} */(section.getCellContent(this._displayColumn, rowIndex));
+	if (!chkbox) {
+		return null;
+	} else if (chkbox.tagName === "EF-CHECKBOX") {
+		return chkbox;
+	} else if(chkbox.type === "checkbox") {
+		return chkbox;
+	} else {
+		return null;
+	}
+};
+/** @private
+* @param {Object} sectionSettings Grid sectionSettings object
+* @param {Array.<Element>=} ary
+* @return {!Array.<Element>}
+*/
+CheckboxPlugin.prototype._getAllCheckboxes = function (sectionSettings, ary) {
+	ary = ary || [];
+
+	var section = sectionSettings.getSection();
+	var fi = section.getFirstIndexInView();
+	var li = section.getLastIndexInView();
+	for(var r = fi; r <= li; ++r) { // WARNING: Index could be shifted
+		var chkbox = this._getCheckbox(sectionSettings, r);
+		if(chkbox) { // WARNING: Index is shifted
+			ary.push(chkbox);
+		}
+	}
+	return ary;
+};
+
+/** @private
+* @param {Object} sectionSettings Grid sectionSettings object
+* @param {string} state
+*/
+CheckboxPlugin.prototype._setDescendantCheckState = function (sectionSettings, state) {
+	var children = sectionSettings.getChildren();
+	if (children) {
+		for (var i = 0; i < children.length; ++i) {
+			var child = children[i];
+			this._setSectionState(child, state);
+			this._setDescendantCheckState(child, state);
+		}
+	}
+};
+/** @private
+* @param {Object} sectionSettings Grid sectionSettings object
+* @param {string=} callerState
+*/
+CheckboxPlugin.prototype._syncAscendantCheckState = function (sectionSettings, callerState) {
+	var parent = sectionSettings.getParent();
+	if (!parent || !parent.getSection().isVisible()) { return; }
+
+	var state = callerState || "";
+	if (state !== "partial") {
+		if(!callerState) {
+			sectionSettings = null; // Force checking state of the caller
+		}
+
+		var children = parent.getChildren();
+		if(children) {
+			for (var i = children.length; --i >= 0; ) {
+				var child = children[i];
+				if (child !== sectionSettings) {
+					var childState = this._getSectionState(child);
+					state = CheckboxPlugin._mergeState(childState, state);
+					if (state === "partial") {
+						break;
+					}
+				}
+			}
+		}
+	}
+
+	this._setSectionState(parent, state);
+	this._syncAscendantCheckState(parent, state);
+};
+
+/** @private
+* @param {Object} sectionSettings Grid sectionSettings object
+* @param {string} state
+*/
+CheckboxPlugin.prototype._setSectionState = function (sectionSettings, state) {
+	var i;
+	if (!state) {
+		return;
+	}
+
+	if (this._isDataBound(sectionSettings)) {
+		var dv = /** @type{DataView} */(sectionSettings.getDataSource());
+
+		// create row dict and mark unchecked
+		var rowIdDict = {};
+		// in state !== unchecked we will get filtered row in group
+		// and set rowIdDict[checkID] = true
+		var checkIDs = this._getRowMemberIdsInView(dv);
+		for (i = 0; i < checkIDs.length; i++) {
+			var checkID = checkIDs[i];
+
+			// there are header group rows in the case of paging and grouping
+			if (dv.getGroupByRowId(checkID)) { continue; }
+
+			var dataRow = this._getRowFromId(dv, checkID);
+			if (dataRow && dataRow[this._disablingField]) {
+				continue;
+			}
+
+			if (state === "unchecked") {
+				// TODO: This will not work in RT grid
+				rowIdDict[checkID] = false;
+			} else {
+				rowIdDict[checkID] = true;
+			}
+		}
+
+		// create data array and rowIds array
+		var data = [];
+		var allRowIDInGroup = [];
+		for (var rowID in rowIdDict) {
+			allRowIDInGroup.push(rowID);
+			data.push(rowIdDict[rowID]);
+		}
+
+		// finally set all data
+		this._setColumnData(dv, this._checkboxField, data, allRowIDInGroup);
+	} else {
+		var checkboxes = this._getAllCheckboxes(sectionSettings);
+		for (i = checkboxes.length; --i >= 0; ) {
+			CheckboxPlugin._setCheckState(checkboxes[i], state);
+		}
+	}
+};
+
+/** similar to check section type = content
+* @private
+* @param {Object} sectionSettings Grid sectionSettings object
+* @return {boolean}
+*/
+CheckboxPlugin.prototype._isDataBound = function (sectionSettings) {
+	if (this._checkboxField) {
+		if (sectionSettings.getDataSource()) {
+			if (sectionSettings.getType() === "content") {
+				return true;
+			}
+		}
+	}
+	return false;
+};
+
+/** @private
+* @param {Object=} e
+*/
+CheckboxPlugin.prototype._onColumnIndexChanged = function (e) {
+	this._displayColumn = -1;
+};
+/** @private
+* @param {Object=} e
+*/
+CheckboxPlugin.prototype._onColumnAdded = function(e) {
+	if(this._initializing) {
+		return;
+	}
+
+	var host = this._hosts[0];
+	if(host) {
+		var column = e.context;
+		if(column) {
+			if(column.checkboxColumn) { // Ignore this if we already have one
+				var existingCheckbox = this.getCheckboxColumnIndex();
+				if(existingCheckbox < 0) { // Only if there is no existing checkbox column
+					this._displayColumn = e.colIndex;
+					var colData = this._newColumnData(e.colIndex, host);
+					colData.isCheckboxColumn = true; // Mark the column for later referencing
+					// TODO: Extend or replace the column options with our checkbox column
+				}
+			}
+			this._requestUIPopulation();
+		}
+	}
+};
+/** @private
+* @param {Object=} e
+*/
+CheckboxPlugin.prototype._requestUIPopulation = function (e) {
+	if(!this._updateTimer) {
+		this._updateTimer = setTimeout(this._populateUIs, 50);
+	}
+};
+
+/** @private */
+CheckboxPlugin.prototype._populateUIs = function () {
+	this._updateTimer = 0;
+
+	if (this._initializing) { return; }
+
+	var host = this._hosts[0];
+	if (!host) { return; }
+
+	this._initializing = true;
+
+	if(this._userCheckboxIdx >= 0) {
+		// TODO: Ensure that the index is valid with current grid UI
+		this._displayColumn = this._userCheckboxIdx;
+		this._userCheckboxIdx = -1;
+	} else {
+		this._displayColumn = -1; // Force updating to avoid duplication with existing checkbox column
+		this.getCheckboxColumnIndex();
+
+		if(this._displayColumn < 0) {
+			// In case checkbox extension doesn't load during grid beforeInit (eg. load checkbox extension at runtime)
+			var chbxCol = this._genCheckboxColumn();
+			if(this._compositeGrid) { // TODO: This could be unnecessary workaround
+				var model = this._compositeGrid.getModel();
+				var columns = model ? model.columns : null;
+				if(columns) {
+					columns.unshift(chbxCol); // TODO: Check if this is appropriate
+				}
+				host.insertColumn(0, chbxCol); // preSectionRender and columnAdded is fired
+			} else if (this._realTimeGrid) { // TODO: Handle multiple grids
+				this._realTimeGrid.insertColumn(chbxCol, 0);
+			}
+
+			this._displayColumn = 0;
+		}
+	}
+
+	var colData = this._newColumnData(this._displayColumn, host);
+	colData.isCheckboxColumn = true; // Mark the column for later referencing
+
+	// HACK: for filter-input extension
+	var filterInput = colData.filterInputOption;
+	if(!filterInput) {
+		filterInput = colData.filterInputOption = {};
+	}
+	filterInput.disabled = true;
+
+	this._createCheckboxes(host.getSectionSettings("title")); // For title
+	host.requestRowRefresh(); // For content
+	this._initializing = false;
+};
+/** @private
+* @param {Event} e
+*/
+CheckboxPlugin.prototype._onCheckboxClicked = function (e) {
+	if(this._coralCheckboxVer === 1) {
+		// Workaround for duplicate event from ef-checkbox
+		if(e.target.tagName === "LABEL") {
+			return;
+		}
+	}
+
+	var chkbox = /** @type{Element} */(e.currentTarget);
+
+	// after checkbox change by user clicked action
+	// the checkbox state is change only 'unchecked' or 'checked' only
+	// so we must remove 'square-shape' class that use in only 'partial' state
+	chkbox.classList.remove('square-shape');
+
+	var newState = CheckboxPlugin._getCheckState(chkbox);
+	if(this._coralCheckboxVer === 1) { // State of the ef-checkbox will not be reflected immediately after click
+		newState = CheckboxPlugin._toggleState(newState);
+	}
+
+	var host = this._hosts[0];
+	var pos = host.getRelativePosition(e); // Getting row index
+	var sectionSettings = pos["sectionSettings"];
+	if(!sectionSettings) {
+		return; // Unsuccessful hit testing
+	}
+
+	if (this._isDataBound(sectionSettings)) {
+		var rowIndex = pos["rowIndex"];
+		var bool = newState !== "unchecked";
+		var dv = sectionSettings.getDataSource();
+		var rid = dv.getRowId(rowIndex);
+		var dataRow = this._getRowFromId(dv, rid);
+		if(dataRow) {
+			if (dataRow[this._disablingField]) {
+				return;
+			}
+			this._setData(dv, rowIndex, this._checkboxField, bool);
+		} else { // Group header
+			var subGroup = dv.getGroupByRowId(rid);
+			if (subGroup) {
+				// prepare data for _setColumnData fn.
+				var rowMemberIds = this._getRowMemberIdsOfGroupInView(dv, subGroup);
+				var len = rowMemberIds.length;
+
+				var dataRows = dv.getMultipleRowData(rowMemberIds);
+				var rids = [];
+				var data = [];
+				for (var i = 0; i < len; i++) {
+					dataRow = dataRows[i];
+					if (dataRow && dataRow[this._disablingField]) {
+						continue;
+					}
+					rids.push(rowMemberIds[i]);
+					data.push(bool);
+				}
+
+				this._setColumnData(dv, this._checkboxField, data, rids);
+
+				// WORKAROUND: to force group move to next state from partial state
+				if (newState === 'checked' && chkbox._prevState === 'partial') {
+					chkbox._forceNewState = newState;
+				}
+			}
+		}
+	}
+
+	this._setDescendantCheckState(sectionSettings, newState); // This only works with root section where root UI is linked with its children section.
+	this._syncAscendantCheckState(sectionSettings); // The clicked row may be a member of row group and thus the state has to be calculated
+
+	if (this.hasListener("clicked")) {
+		pos["checkbox"] = chkbox;
+		pos["checkState"] = newState;
+		pos["checked"] = chkbox.checked;
+		this._dispatch("clicked", pos);
+	}
+
+	e.stopPropagation();
+};
+
+/** get member items in view. the items in view are items on current page and already filtered , include items in collapsed group
+* @private
+* @param {Object} view dataview object
+* @param {Object} targetGroup dataview object
+* @return {!Array.<string>} list of row member ids of group in view
+*/
+CheckboxPlugin.prototype._getRowMemberIdsOfGroupInView = function (view, targetGroup) {
+	var visibleRowIds = view.getVisibleRowIds(true);
+	var beginPos = 0;
+
+	// if group header is in view and collapsed we can return all id in view immediately
+	var pos = visibleRowIds.indexOf(targetGroup.getGroupRowId());
+	if (pos >= 0) {
+		if (targetGroup.isCollapsed()) return targetGroup.getAllRowIds(true);
+		else beginPos = pos + 1;
+	} else { // not support case group header not in view or inside group parent that collapsed
+		return [];
+	}
+
+	// loop to check which member is in view
+	var groupVisibleRowIds = targetGroup.getVisibleRowIds(true);
+	var result = [], id, childGroup, i;
+	var len = groupVisibleRowIds.length;
+	for (i = 0; i < len; i++) {
+		id = groupVisibleRowIds[i];
+		pos = visibleRowIds.indexOf(id, beginPos);
+		if (pos >= 0) {
+			beginPos = pos + 1;
+			childGroup = view.getGroupByRowId(id);
+			if (childGroup) {
+				if (childGroup.isCollapsed()) {
+					// child group collapsed then all rows in childGroup are in view
+					result = result.concat(childGroup.getAllRowIds(true) || []);
+				}
+			} else {
+				result.push(id);
+			}
+		}
+	}
+
+	return result;
+};
+
+/** @private
+* @param {Object} view dataview or datatable object
+* @return {!Array.<string>} list of row member ids in view
+*/
+CheckboxPlugin.prototype._getRowMemberIdsInView = function (view) {
+	// 1. get All member and group rowIds
+	// 2. loop check whether rowIds is group or just row member
+	// 3. if rowId is not group then it's just a row member
+	// 4. in case rowId is group and collapsed we will get all member rowIds of group and add to memberRowIds
+
+	if (view.getDataSource()) { // check is dataView
+		// TODO: support multi-level grouping
+		// if view is DataView -> view.getVisibleRowIds(true) will get member and group rowIds in view
+		var rids = view.getVisibleRowIds(true);
+		var len = rids.length;
+		var allRids = [];
+		var rid, group, i;
+		for (i = 0; i < len; i++) { // 2
+			rid = rids[i];
+			group = view.getGroupByRowId(rid);
+			if (!group) {
+				allRids.push(rid); // 3
+			} else if (group.isCollapsed()) { // 4
+				allRids = allRids.concat(group.getAllRowIds(true) || []);
+			}
+		}
+
+		// remove disabled row
+		rids = [];
+		var dataRows = view.getMultipleRowData(allRids);
+		len = dataRows.length;
+		var dataRow;
+		for(i = 0; i < len; i++) {
+			dataRow = dataRows[i];
+			if(dataRow && dataRow[this._disablingField]) {
+				continue;
+			}
+			rids.push(allRids[i]);
+		}
+		// if view is DataView, the intention is to get data with applied filter/hidden. row expansion should also filtered out.
+		return rids.filter(this._isNotRowExpansion.bind(null, view));
+	} else {
+		// if view is DataTable -> view.getAllRowIds(true) will get all member in grid regardless of hidden/filtered state.
+		return view.getAllRowIds(true);
+	}
+};
+
+/** @private
+* @param {Object} view DataView object
+* @param {string} rid
+* @return {boolean}
+*/
+CheckboxPlugin.prototype._isNotRowExpansion = function (view, rid) {
+	// NOTE: isRowExpansion() is only available in DataView.
+	return !view.isRowExpansion(rid);
+};
+
+/** @private
+* @param {Object} e
+*/
+CheckboxPlugin.prototype._onPreSectionRender = function (e) {
+	var displayCol = this.getCheckboxColumnIndex();
+	if(displayCol < e["fromColIndex"] || displayCol >= e["toColIndex"]) {
+		return;
+	}
+
+	var sectionSettings = /** @type{SectionSettings} */(e["sectionSettings"]);
+	if(sectionSettings.getType() !== "title") {
+		return;
+	}
+	this._createCheckboxes(sectionSettings, e["fromRowIndex"], e["toRowIndex"]);
+};
+
+/** @private
+* @param {Object} sectionSettings core grid sectionSettings
+* @param {number=} fromRow
+* @param {number=} toRow
+*/
+CheckboxPlugin.prototype._createCheckboxes = function (sectionSettings, fromRow, toRow) {
+	var displayCol = this.getCheckboxColumnIndex();
+	if(displayCol < 0) {
+		return;
+	}
+	if(!sectionSettings) {
+		return;
+	}
+	if(CheckboxPlugin._exceptions[sectionSettings.getSectionName()]) {
+		return;
+	}
+
+	var section = sectionSettings.getSection();
+	var fi = (fromRow != null) ? fromRow : section.getFirstIndexInView();
+	var li = (toRow != null) ? toRow : section.getLastIndexInView() + 1;
+
+	for (var r = fi; r < li; ++r) {
+		this._createCheckbox(sectionSettings, displayCol, r);
+	}
+};
+/** @private
+* @param {Object} e
+*/
+CheckboxPlugin.prototype._onPostSectionDataBinding = function (e) {
+	if (!this._checkboxField) {
+		return;
+	}
+	var displayCol = this.getCheckboxColumnIndex();
+	if(displayCol < 0) { return; }
+
+	var section = /** @type{ILayoutGrid} */(e["section"]);
+	var dv = /** @type{DataView} */(e["dataSource"]);
+
+	var fromR = /** @type{number} */(e["fromRowIndex"]);
+	if(dv.hasGroup()) { // This is because we need to update group header when any group member is updated
+		fromR = section.getFirstIndexInView();
+	}
+
+	var toR = /** @type{number} */(e["toRowIndex"]);
+	var bindingCount = toR - fromR;
+	if(bindingCount <= 0) {
+		return;
+	}
+
+	var checkboxes = new Array(bindingCount);
+
+	var i, rowIndex, chkbox, rowData;
+	var arg = null;
+	var hasBinding = this.hasListener("checkboxBinding");
+	if(hasBinding) {
+		arg = {
+			"colIndex": displayCol
+		};
+	}
+
+	var sectionSettings = /** @type{SectionSettings} */(e["sectionSettings"]);
+	for(i = 0; i < bindingCount; ++i) {
+		rowIndex = fromR + i;
+		chkbox = checkboxes[i] = this._getCheckbox(sectionSettings, rowIndex);
+		if (!chkbox) {
+			chkbox = checkboxes[i] = this._createCheckbox(sectionSettings, this._displayColumn, rowIndex);
+		}
+		var rowId = dv.getRowId(rowIndex); // Slow
+		rowData = this._rowGetter(dv.getRowData(rowId));
+		if(hasBinding && chkbox) {
+			arg["checkbox"] = chkbox;
+			arg["rowIndex"] = rowIndex;
+			arg["rowData"] = rowData;
+			this._dispatch("checkboxBinding", arg);
+		}
+
+		var disabled = false;
+		var state = "";
+		if(rowData) {
+			state = CheckboxPlugin._toCheckState(rowData[this._checkboxField]);
+			disabled = rowData[this._disablingField] === true;
+		} else { // Group header row has no rowData
+			state = this._getGroupState(dv.getGroupByRowId(rowId));
+		}
+		if (this._autoRowSelection) {
+			section.setSelectedRow(rowIndex, (rowData || false) && state === "checked");
+		}
+
+		if(chkbox) {
+			if(disabled) {
+				chkbox.setAttribute("disabled", "");
+			} else {
+				chkbox.removeAttribute("disabled");
+			}
+			CheckboxPlugin._setCheckState(chkbox, state);
+		}
+	}
+
+	this._syncAscendantCheckState(e["sectionSettings"]);
+};
+
+
+export default CheckboxPlugin;
+export { CheckboxPlugin, CheckboxPlugin as Checkbox, CheckboxPlugin as CheckboxExtension };