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

package/lib/tr-grid-util/es6/GridPlugin.js

@@ -0,0 +1,747 @@
+import {Ext} from "./Ext.js";
+import {EventDispatcher} from "./EventDispatcher.js";
+import {Deferred} from "./Deferred.js";
+
+/** This class is designed to be a base class for other tr.Grid plug-ins. It provide commonly used functionalities by the plug-ins.
+* @constructor
+* @extends {EventDispatcher}
+* @example
+* import {Ext} from "../../node_modules/tr-grid-util/src/Ext.js";
+* import {GridPlugin} from "../../node_modules/tr-grid-util/src/GridPlugin.js";
+*
+* var SomePlugin = function() {};
+* Ext.inherits(SomePlugin, GridPlugin);
+*/
+var GridPlugin = function() {};
+Ext.inherits(GridPlugin, EventDispatcher);
+
+/** @type {Array.<tr.Grid>}
+* @protected
+* @ignore
+*/
+GridPlugin.prototype._hosts = null;
+/** This is for backward compatible with tr.CompositeGrid
+* @type {tr.CompositeGrid}
+* @protected
+* @ignore
+*/
+GridPlugin.prototype._compositeGrid = null;
+/** @type {tr.rt.Grid}
+* @protected
+* @ignore
+*/
+GridPlugin.prototype._realTimeGrid = null;
+/** @type {Function}
+* @protected
+* @ignore
+*/
+GridPlugin.prototype._rowGetter = null;
+/** Indicates that columns, rows, and components in the primary grid have been initialized
+* @type {boolean}
+* @protected
+* @ignore
+*/
+GridPlugin.prototype._initializedGrid = false;
+
+
+/** Alias to {@link EventDispatcher#addEventListener}
+* @public
+* @function
+* @param {string} type Event name
+* @param {Function} handler Event handler
+*/
+GridPlugin.prototype.listen = GridPlugin.prototype.addEventListener;
+/** Alias to {@link EventDispatcher#removeEventListener}
+* @public
+* @function
+* @param {string} type Event name
+* @param {Function} handler Event handler
+*/
+GridPlugin.prototype.unlisten = GridPlugin.prototype.removeEventListener;
+
+/** This is for Composite Grid support. Do NOT override this method. Use protected _afterInit() instead.
+* @public
+* @param {Element=} elem Root element
+* @param {Object=} model Composite grid object model
+* @param {tr.CompositeGrid=} grid Composite grid control
+*/
+GridPlugin.prototype.afterInit = function(elem, model, grid) {
+	var core = null;
+	if(grid && grid["getCoreGrid"]) {
+		core = grid["getCoreGrid"]();
+	}
+
+	if(core) {
+		if(!this.getGridApi()) {
+			this.setGridWrapper("compositegrid", grid); // Plugin is loaded in afterInit for composite grid
+		}
+		if(this._compositeGrid) {
+			core.loadPlugin(this, model); // Allow sharing extension/plugin
+		}
+	}
+
+
+	if(!this._initializedGrid) { // Calling _afterInit only once per extension/plugin
+		this._initializedGrid = true;
+		this._rowGetter = this._realTimeGrid ? rowDefRowGetter : defaultRowGetter;
+		this._afterInit();
+	}
+};
+/** This method guarantees that grid (host) and config have been set. It should be used to update any setting that requires different implementation between Composite grid and Real-time grid
+* @protected
+* @ignore
+*/
+GridPlugin.prototype._afterInit = function() {};
+
+/** This method is meant to be used by a derived class to release any resource hold by GridPlugin. Do not override this method.
+* @protected
+* @ignore
+*/
+GridPlugin.prototype._dispose = function() {
+	if(this._hosts) {
+		if(!this._hosts.length) {
+			this._compositeGrid = this._realTimeGrid = null;
+			this._initializedGrid = false;
+		}
+	}
+};
+
+
+/** Plugin that has multi-table support means that it can have multiple hosts/tables and share its states across those hosts/tables.
+* @public
+* @return {boolean}
+*/
+GridPlugin.prototype.hasMultiTableSupport = function() {
+	return false;
+};
+
+/** Executed before dispatching, allowing modification of user's event argument object.
+* @protected
+* @ignore
+* @param {string} type Event name
+* @param {Object} eventArg User's event argument object
+* @return {Object} New event argument object
+*/
+GridPlugin.prototype._prepareEventArguments = function(type, eventArg) {
+	if(!eventArg) {
+		eventArg = {};
+	}
+	eventArg.api = this.getGridApi();
+	return eventArg;
+};
+
+/** Get plugin/extension name. This should be unique as it will be used for duplicate protection. Derived class must override this method.
+* @public
+* @return {string}
+*/
+GridPlugin.prototype.getName = function () {
+	return "GridPlugin"; // Readonly
+};
+/** This is the entry point where Core grid instance has been initialized and grid configuration object is passed to the extension. Derived class should override this method to keep reference of Core grid for later referencing.
+* @public
+* @param {tr.Grid} host Core grid instance
+* @param {Object=} gridOptions Grid configuration object
+*/
+GridPlugin.prototype.initialize = function (host, gridOptions) {};
+/** This is where Core grid instance is being disposed. Derived class should override this method to release any resource hold by this plugin/extension, if the last core grid is being disposed (there will be multiple instances for multi-table mode).
+* @public
+* @param {tr.Grid=} host Core grid instance
+*/
+GridPlugin.prototype.unload = function (host) {
+	this._dispose();
+};
+
+/** Get Core grid instance from the given object (usually an Event Argument object).
+* @public
+* @param {Event|Element|tr.IElementControl} e
+* @return {tr.Grid}
+*/
+GridPlugin.prototype.getRelativeGrid = function (e) {
+	var targetEl = null;
+	if(e.target) { // The Given object is an Event
+		targetEl = /** @type{Element} */(e.target);
+		var gridAPI = targetEl["api"];
+		if(gridAPI && gridAPI["getCoreGrid"]) {
+			return /** @type{tr.Grid} */(gridAPI["getCoreGrid"]());
+		}
+	} else if(e["getElement"]) { // The Given object is implementing tr.IElementControl
+		targetEl = /** @type{Element} */(e["getElement"]());
+	} else if(e.nodeType === 1) { // The Given object is just an element
+		targetEl = /** @type{Element} */(e);
+	}
+
+	if(targetEl) {
+		for(var i = this._hosts.length; --i >= 0;) {
+			var host = this._hosts[i];
+			if(host.getElement().contains(targetEl)) {
+				return host;
+			}
+		}
+	}
+	return null;
+};
+
+/** @public
+* @param {string} gridType
+* @param {*} wrapperInstance
+*/
+GridPlugin.prototype.setGridWrapper = function (gridType, wrapperInstance) {
+	if(gridType) {
+		gridType = gridType.toLowerCase();
+		if(gridType === "compositegrid") {
+			this._compositeGrid = wrapperInstance;
+		} else if(gridType === "realtimegrid") {
+			this._realTimeGrid = wrapperInstance;
+		}
+	}
+};
+/** Get JavaScript wrapper instance. This could be either composite grid or real-time grid.
+* @public
+* @param {(number|Object)=} coreRef An index of the core grid or an instance of the core grid
+* @return {*} wrapperInstance
+*/
+GridPlugin.prototype.getGridApi = function (coreRef) {
+	if(coreRef == null) {
+		return this._compositeGrid || this._realTimeGrid;
+	} else {
+		var host = (typeof coreRef == "number") ? this._hosts[coreRef] : coreRef;
+		return host ? (host._wrapper || null) : null;
+	}
+};
+
+/** Get user specified column label (e.g. name) or field, if name does not exist
+* @public
+* @param {number|string} colRef Column index or column Id
+* @return {string}
+*/
+GridPlugin.prototype.getColumnName = function (colRef) {
+	if(this._compositeGrid) {
+		var colOptions = this._compositeGrid.getColumnModel(colRef);
+		if(colOptions) {
+			if(colOptions.title) {
+				return colOptions.title;
+			} else {
+				return colOptions.field;
+			}
+		}
+	} else {
+		var colIndex = this.getColumnIndex(colRef);
+		var colDef = this._realTimeGrid.getColumnDefinition(colIndex);
+		if(colDef) {
+			return colDef.getName();
+		}
+	}
+	return "";
+};
+/** @public
+* @param {number|string} colId Column index or column Id
+* @return {number}
+*/
+GridPlugin.prototype.getColumnIndex = function (colId) {
+	if(typeof colId === "number") {
+		return colId;
+	}
+	if(this._compositeGrid) {
+		return this._compositeGrid.getColumnIndex(colId);
+	} else {
+		var rtGrid = this._realTimeGrid;
+		var colCount = rtGrid.getColumnCount();
+		for(var i = 0; i < colCount; ++i) {
+			var colDef = rtGrid.getColumnDefinition(i);
+			if(colDef && colDef.getId() === colId) {
+				return i;
+			}
+		}
+	}
+	return -1;
+};
+/** @public
+* @param {Array.<number|string>} colRefs column references field name or column index
+* @return {Array.<number>} column indices
+*/
+GridPlugin.prototype.getColumnIndices = function (colRefs) {
+	if(this._compositeGrid) {
+		var allFields = this._compositeGrid.getColumnFields();
+		var columnIndices = [];
+		for (var i = 0; i < colRefs.length; i++) {
+
+			if(typeof colRefs[i] === 'number') { // When user pass index
+				columnIndices.push(colRefs[i]);
+			} else {
+				var columnIndex = allFields.indexOf(colRefs[i]); // Looping check column index of colRefs field
+				if(columnIndex !== -1) {
+					columnIndices.push(columnIndex);
+				}
+			}
+		}
+		return columnIndices;
+	} else {
+		return this._realTimeGrid.getColumnIndices(colRefs);
+	}
+};
+/** @public
+* @param {number|string} colIndex Column index or column Id
+* @return {string}
+*/
+GridPlugin.prototype.getColumnId = function (colIndex) {
+	if(typeof colIndex === "string") {
+		return colIndex;
+	}
+	if(this._compositeGrid) {
+		return this._compositeGrid.getColumnId(colIndex);
+	} else {
+		var colDef = this._realTimeGrid.getColumnDefinition(colIndex);
+		if(colDef) {
+			return colDef.getId();
+		}
+	}
+	return "";
+};
+/** @public
+* @return {number}
+*/
+GridPlugin.prototype.getColumnCount = function() {
+	if(this._hosts) {
+		var g = this._hosts[0];
+		return g ? g.getColumnCount() : 0;
+	}
+	return 0;
+};
+
+/** @protected
+* @deprecated
+* @ignore
+* @param {*} curPlugin
+* @param {tr.Grid} host
+* @param {string} pluginName
+* @return {*} curPlugin
+*/
+GridPlugin.prototype._loadPlugin = function (curPlugin, host, pluginName) {
+	if(!curPlugin) {
+		curPlugin = host.getPlugin(pluginName);
+		if(!curPlugin) {
+			curPlugin = host.loadPlugin(pluginName);
+			if(curPlugin && this._initializedGrid) {
+				curPlugin._initializedGrid = true; // WARNING: Accessing private member
+			}
+		}
+	}
+	return curPlugin;
+};
+/** WARNING: Call this method only in _afterInit method to ensure existence of composite grid and real-time grid
+* @protected
+* @ignore
+* @param {tr.Grid} host
+* @param {*} pluginRef
+* @param {Object=} configObj
+* @return {Promise}
+*/
+GridPlugin.prototype._requestPlugin = function (host, pluginRef, configObj) {
+	if(this._initializedGrid) {
+		return GridPlugin.requestPlugin(host, pluginRef, configObj, this._compositeGrid, this._realTimeGrid);
+	}
+	return Promise.reject("Plugin should be requested after the initialization");
+};
+/** Make a request to load a plugin/extension into the given core grid (tr-grid). Return a promise of plugin/extension instance
+* @public
+* @param {*} ref This can be ef-grid, atlas-blotter, composite grid, real-time grid, or core grid.
+* @param {*} pluginRef Plugin/Extension name or instance
+* @param {Object=} configObj
+* @param {*=} compositeGrid
+* @param {*=} realTimeGrid
+* @return {Promise}
+*/
+GridPlugin.requestPlugin = function (ref, pluginRef, configObj, compositeGrid, realTimeGrid) {
+	var core = null;
+	if(ref) {
+		var gridWrapper = null;
+		if(ref.nodeType === 1) { // This is an element
+			// TODO: Support delayed resolving
+			gridWrapper = ref.api; // Grid element must already be initialized and configured
+		} else if(ref.getCoreGrid) {
+			gridWrapper = ref;
+		} else if(ref.getPlugin) {
+			core = ref;
+		}
+		if(gridWrapper) {
+			core = gridWrapper.getCoreGrid();
+			if(!compositeGrid && !realTimeGrid) {
+				if(gridWrapper.getModel) {
+					compositeGrid = gridWrapper;
+				} else {
+					realTimeGrid = gridWrapper;
+				}
+			}
+		}
+	}
+
+	if(!core) {
+		return Promise.reject("Cannot find grid element");
+	}
+
+	var curPlugin = core.getPlugin(pluginRef);
+	if(curPlugin) {
+		return Promise.resolve(curPlugin);
+	} else {
+		var d = new Deferred();
+		setTimeout(GridPlugin._onPluginRequested.bind(null, {
+			grid: core,
+			pluginRef: pluginRef,
+			compositeGrid: compositeGrid,
+			realTimeGrid: realTimeGrid,
+			config: configObj,
+			deferred: d
+		}), 10);
+		return d.promise;
+	}
+};
+/** @private
+* @param {Object} ctx
+* @return {Promise.<*>} Promise of plugin object
+*/
+GridPlugin._onPluginRequested = function (ctx) {
+	var grid = ctx.grid;
+	if(!grid.getElement()) {
+		return ctx.deferred.reject("Grid has been disposed before the plugin is fully loaded: " + ctx.pluginRef);
+	}
+
+	var curPlugin = grid.getPlugin(ctx.pluginRef);
+	if(curPlugin) {
+		return ctx.deferred.resolve(curPlugin);
+	}
+
+	var beforeInitPerformed = false;
+	if(ctx.pluginRef.beforeInit) { // WARNING: beforeInit is usually performed before the actual loading
+		beforeInitPerformed = true;
+		ctx.pluginRef.beforeInit(grid.getElement(), ctx.config, true);
+	}
+
+	curPlugin = grid.loadPlugin(ctx.pluginRef, ctx.config);
+	if(!curPlugin) {
+		return ctx.deferred.reject("Unable to load required dependency: " + ctx.pluginRef);
+	}
+
+	if(!beforeInitPerformed && curPlugin.beforeInit) { // WARNING: beforeInit is usually performed before the actual loading
+		beforeInitPerformed = true;
+		curPlugin.beforeInit(grid.getElement(), ctx.config);
+	}
+	if(curPlugin.setGridWrapper) {
+		if(ctx.compositeGrid) {
+			curPlugin.setGridWrapper("compositegrid", ctx.compositeGrid);
+		} else if(ctx.realTimeGrid) {
+			curPlugin.setGridWrapper("realtimegrid", ctx.realTimeGrid);
+		}
+	}
+	if(curPlugin.afterInit) {
+		curPlugin.afterInit();
+	}
+	return ctx.deferred.resolve(curPlugin);
+};
+/** @protected
+* @ignore
+* @param {string} pluginName
+* @param {tr.Grid=} grid
+* @return {*}
+*/
+GridPlugin.prototype._getPlugin = function(pluginName, grid) {
+	if(grid == null) {
+		grid = this._hosts[0];
+	}
+	return (grid) ? grid.getPlugin(pluginName) : null;
+};
+
+/** @protected
+* @ignore
+* @param {number} colIndex
+* @param {tr.Grid=} grid
+* @return {Object}
+*/
+GridPlugin.prototype._getColumnData = function(colIndex, grid) {
+	if(grid == null) {
+		grid = this._hosts[0];
+	}
+	return grid ? grid.getColumnData(colIndex) : null;
+};
+/** @protected
+* @ignore
+* @param {number} colIndex
+* @param {string} prop
+* @param {tr.Grid=} grid
+* @return {*}
+*/
+GridPlugin.prototype._getColumnOption = function(colIndex, prop, grid) {
+	var colData = this._getColumnData(colIndex, grid);
+	if(colData) {
+		return colData[prop];
+	}
+	return null;
+};
+/** @protected
+* @ignore
+* @param {number} colIndex
+* @param {tr.Grid=} grid
+* @return {!Object}
+*/
+GridPlugin.prototype._newColumnData = function(colIndex, grid) {
+	if(grid == null) {
+		grid = this._hosts[0];
+	}
+	if(!grid) {
+		return {};
+	}
+
+	var colData = grid.getColumnData(colIndex);
+	if(!colData) {
+		colData = grid.setColumnData(colIndex, {});
+	}
+	return colData;
+};
+/** @protected
+* @ignore
+* @param {number} colIndex
+* @return {string}
+*/
+GridPlugin.prototype._getField = function(colIndex) {
+	var gridInst = this._compositeGrid || this._realTimeGrid;
+	if (gridInst) {
+		return gridInst.getColumnField(colIndex);
+	}
+	return "";
+};
+/** Note that this method is quite misleading and not consistent with other API method. Please avoid using it. We will deprecate this in the future. <br>
+* Use _rowGetter instead
+* @protected
+* @ignore
+* @deprecated
+* @param {Object} dvRowData { "a": 10, "c": 21 }
+* @return {Object}
+*/
+GridPlugin.prototype._getRowData = function(dvRowData) {
+	if(this._realTimeGrid) {
+		if(dvRowData) {
+			return dvRowData["ROW_DEF"].getRowData();
+		}
+	}
+	return dvRowData;
+};
+/** @protected
+* @ignore
+* @param {tr.DataView} dv
+* @param {number} rowIndex
+* @return {Object} dvRowData
+*/
+GridPlugin.prototype._getRow = function(dv, rowIndex) {
+	return rowGetter(dv.getRowDataAt(rowIndex));
+};
+/** @protected
+* @ignore
+* @param {tr.DataView} dv
+* @param {number} rowIndex
+* @param {string} field
+* @return {*}
+*/
+GridPlugin.prototype._getData = function(dv, rowIndex, field) {
+	var row = this._getRow(dv, rowIndex);
+	return row ? row[field] : undefined; // eslint-disable-line
+};
+/** @protected
+* @ignore
+* @param {tr.DataView} dv
+* @param {number} rowIndex
+* @param {string} field
+* @param {*} val
+*/
+GridPlugin.prototype._setData = function(dv, rowIndex, field, val) {
+	if(this._realTimeGrid) {
+		var row = dv.getRowDataAt(rowIndex);
+		if(row) {
+			row["ROW_DEF"].setData(field, val);
+		}
+	} else {
+		dv.setDataAt(rowIndex, field, val);
+	}
+};
+/** @protected
+* @ignore
+* @param {tr.DataView} dv
+* @param {number} rowIndex
+* @param {Object} rowData
+*/
+GridPlugin.prototype._setRowData = function(dv, rowIndex, rowData) {
+	if(this._realTimeGrid) {
+		var dvRowData = dv.getRowDataAt(rowIndex);
+		if(dvRowData) {
+			dvRowData["ROW_DEF"].setRowData(rowData);
+		}
+	} else {
+		dv.setRowDataAt(rowIndex, rowData);
+	}
+};
+/** Set data in a column manner. This is faster than repeatedly calling this._setData
+* @protected
+* @ignore
+* @param {tr.DataView} dv
+* @param {string} cid
+* @param {Array} valueList
+* @param {Array.<string>=} opt_ridList Specify row id to be set corresponding to the data item
+* @example
+* var dv = this._activeGrid.getDataSource();
+* this._setColumnData(dv, "column 1", ["1st row data", "2nd row data", "3rd row data"]);
+*/
+GridPlugin.prototype._setColumnData = function (dv, cid, valueList, opt_ridList) { // Data changed event may be dispatched
+	opt_ridList = opt_ridList || dv.getAllRowIds() || [];
+
+	if (this._realTimeGrid) {
+		var dt = dv.getDataSource();
+		// freeze data to prevent sorting event occur
+		var prevFrozen = dt.freeze();
+
+		var len = (valueList.length < opt_ridList.length) ? valueList.length : opt_ridList.length;
+
+		for (var i = 0; i < len; ++i) {
+			var row = dv.getRowData(opt_ridList[i]);
+			if (row) {
+				row["ROW_DEF"].setData(cid, valueList[i]);
+			}
+		}
+
+		dt.freeze(prevFrozen);
+	} else {
+		dv.setColumnData(cid, valueList, opt_ridList);
+	}
+};
+
+/** @protected
+* @ignore
+* @param {number} colIndex
+* @param {string=} id
+* @param {Function=} renderer
+*/
+GridPlugin.prototype._activateColumnRenderer = function(colIndex, id, renderer) {
+	// TODO: Support multiple Grids
+	if (colIndex == null) {
+		return;
+	}
+
+	var rtGrid = this._realTimeGrid;
+	if (rtGrid) {
+		rtGrid.activateColumnRenderer(colIndex, id, renderer);
+	} else {
+		if (typeof renderer === "function") {
+			this._hosts[0].setColumnDataBindingHandler(colIndex, renderer);
+		} else {
+			this._hosts[0].setColumnDataBindingHandler(colIndex, null);
+		}
+	}
+};
+
+/** Export the plugin to the given object by attaching it to tr and tr.grid namespaces
+* @public
+* @function
+* @param {Window|Object} winObj
+* @param {GridPlugin} plugin
+* @example
+* import {exportExtension} from "../node_modules/tr-grid-util/src/GridPlugin.js";
+* import {SomePlugin} from "./js/SomePlugin.js";
+* exportExtension(window, SomePlugin);
+* console.log(tr.grid.SomePlugin); // tr.grid.SomePlugin is added to window scope
+* console.log(tr.SomeExtension); // tr.SomeExtension is added to window scope
+*/
+var exportExtension = function(winObj, plugin) {
+	if(!winObj || !plugin) { return; }
+	if(!plugin.prototype["getName"]) { return; }
+	var pluginName = plugin.prototype["getName"]().replace(/Plugin$/, "");
+	if(!pluginName) { return; }
+
+	var trNamespace = winObj["tr"]; // For supporting composite grid extension scheme
+	if(!trNamespace) {
+		trNamespace = winObj["tr"] = {};
+	}
+	var gridNamespace = trNamespace["grid"]; // For supporting grid plugin scheme
+	if(!gridNamespace) {
+		gridNamespace = trNamespace["grid"] = {};
+	}
+
+	gridNamespace[pluginName + "Plugin"] = plugin;
+	trNamespace[pluginName + "Extension"] = plugin;
+};
+
+/** @public
+* @function
+* @param {string} field
+* @param {Object} dvRowData Row data from tr.DataView
+* @return {*} Data value returned from the specified row and field
+*/
+var defaultDataGetter = function (field, dvRowData) {
+	return dvRowData[field];
+};
+/** @public
+* @function
+* @param {string} field
+* @param {Object} dvRowData Row data from tr.DataView
+* @return {*} Data value returned from the specified row and field
+*/
+var rowDefDataGetter = function (field, dvRowData) {
+	var rowData = dvRowData["ROW_DEF"].getRowData();
+	return (rowData) ? rowData[field] : null;
+};
+/** @public
+* @function
+* @param {Object} dvRowData
+* @return {Object} Row data Nothing is changed
+*/
+var defaultRowGetter = function (dvRowData) {
+	return dvRowData;
+};
+/** @public
+* @function
+* @param {Object} dvRowData Row data from tr.DataView
+* @return {Object} Row data
+*/
+var rowDefRowGetter = function (dvRowData) {
+	return dvRowData ? dvRowData["ROW_DEF"].getRowData() : null;
+};
+/** This is slower version of row getter. It is intended for ease of use.
+* @public
+* @function
+* @param {Object} dvRowData Row data from tr.DataView
+* @return {Object} Row data
+*/
+var rowGetter = function (dvRowData) {
+	if(dvRowData) {
+		var rowDef = dvRowData["ROW_DEF"];
+		return rowDef ? rowDef.getRowData() : dvRowData;
+	}
+	return null;
+};
+
+/** @public
+* @function
+* @param {string} field
+* @param {tr.DataTable} dt
+* @return {!Array.<Object>} Array of row data
+*/
+var colDataGetter = function(field, dt) {
+	var rowDefs = dt.getAllRowData();
+	var rowCount = rowDefs.length;
+	var rows = new Array(rowCount);
+	for(var i = 0; i < rowCount; ++i) { // WARNING: No data checking
+		rows[i] = rowDefDataGetter(field, rowDefs[i]);
+	}
+	return rows;
+};
+
+export default GridPlugin;
+export {
+	GridPlugin,
+	exportExtension,
+
+	defaultDataGetter,
+	rowDefDataGetter,
+
+	defaultRowGetter,
+	rowDefRowGetter,
+	rowGetter,
+
+	colDataGetter
+};