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

package/lib/core/es6/grid/util/SectionSettings.js

@@ -0,0 +1,674 @@
+/* eslint-disable */
+import Ext from "../../../../tr-grid-util/es6/Ext.js";
+import Util from "../util/util.js";
+import EventDispatcher from "../event/EventDispatcher.js";
+import ILayoutGrid from "../ILayoutGrid.js";
+import LayoutGrid from "../LayoutGrid.js";
+import DataTable from "../../data/DataTable.js";
+import DataView from "../../data/DataView.js";
+import Conflator from "../util/Conflator.js";
+/* eslint-enable */
+
+/** @constructor
+* @extends {EventDispatcher}
+* @param {!ILayoutGrid} grid
+*/
+var SectionSettings = function (grid) {
+	var _t = this;
+	_t._onDataChanged = _t._onDataChanged.bind(_t);
+	_t.extendEventArg = _t.extendEventArg.bind(_t);
+
+	_t._dataChangedConflator = new Conflator(100, _t._onDataChanged);
+
+	_t._grid = grid;
+	_t._grid.setEventArgExtender("rowCountChanged", _t.extendEventArg);
+	_t._grid.setEventArgExtender("rowHeightChanged", _t.extendEventArg);
+	_t._grid.setEventArgExtender("rowAvailable", _t.extendEventArg);
+	_t._grid.listen("rowAvailable", _t._dispatch.bind(this, "rowAvailable"));
+
+	_t._addEvent("dataChanged");
+	_t._addEvent("rowAvailable");
+};
+Ext.inherits(SectionSettings, EventDispatcher); // Inherits() will replace prototype of the derived object
+
+/** @type {number}
+* @private
+*/
+SectionSettings._runningId = 0;
+/** @type {string}
+* @private
+*/
+SectionSettings.prototype._id = "";
+/** @type {string}
+* @private
+*/
+SectionSettings.prototype._type = "";
+/** @type {ILayoutGrid}
+* @private
+*/
+SectionSettings.prototype._grid = null;
+/** @type {ILayoutGrid}
+* @private
+*/
+SectionSettings.prototype._snapshot = null;
+
+/** @type {DataView}
+* @private
+*/
+SectionSettings.prototype._dataView = null;
+/** @type {Object}
+* @private
+*/
+SectionSettings.prototype._dataArg = null;
+
+/** @type {boolean}
+* @description When the parameter is not specifically set by user, The mode will be switched automatically based on SectionSettings type
+* @private
+*/
+SectionSettings.prototype._autoSyncRowCount; // Intentionally left undefined
+/** @type {boolean}
+* @private
+*/
+SectionSettings.prototype._bindingEnabled = true;
+/** @type {SectionSettings}
+* @private
+*/
+SectionSettings.prototype._parent = null;
+/** @type {Array.<SectionSettings>}
+* @private
+*/
+SectionSettings.prototype._children = null;
+/** @type {!Conflator}
+* @private
+*/
+SectionSettings.prototype._dataChangedConflator;
+
+
+/** @public
+* @return {string}
+*/
+SectionSettings.prototype.getId = function () {
+	return this._id;
+};
+/** @public
+* @param {string=} str
+* @return {string}
+*/
+SectionSettings.prototype.setId = function (str) {
+	this._id = (str) ? str : "section" + SectionSettings._runningId++;
+
+	this._grid.setAttribute("id", this._id);
+	return this._id;
+};
+/** @public
+* @return {ILayoutGrid}
+*/
+SectionSettings.prototype.getSection = function () {
+	return this._snapshot || this._grid;
+};
+/** @public
+* @return {string}
+*/
+SectionSettings.prototype.getSectionName = function () {
+	return this._grid.getId();
+};
+/** @public
+* @return {number}
+*/
+SectionSettings.prototype.getIndex = function () {
+	return this._grid.getIndex();
+};
+/** @public
+* @return {string}
+*/
+SectionSettings.prototype.getType = function () {
+	return this._type;
+};
+/** @public
+* @param {string} type
+*/
+SectionSettings.prototype.setType = function (type) {
+	if(this._type !== type) {
+		if(this._type) {
+			this._grid.removeClass(this._type);
+		}
+		this._type = type || "";
+		if(type) {
+			this._grid.addClass(type);
+		}
+	}
+};
+
+/** @public
+* @return {DataView}
+*/
+SectionSettings.prototype.getDataSource = function () {
+	return this._dataView;
+};
+/** @public
+* @param {DataView} dataView
+*/
+SectionSettings.prototype.setDataSource = function (dataView) {
+	var t = this;
+	if(!t.getAutoSyncRowCount() || t._dataView === dataView) {
+		return;
+	}
+
+	if (t._dataView) {
+		t._dataView.unlisten("dataChanged", this._onDataChanged);
+	}
+
+	t._dataChangedConflator.reset();
+	t._dataArg = null;
+
+	t._dataView = dataView;
+
+	if (t._dataView !== null) {
+		t._dataView.listen("dataChanged", t._onDataChanged);
+	}
+	t._dispatchDataChanged(0, NaN);
+};
+/** @public
+* @return {DataTable|DataView}
+*/
+SectionSettings.prototype.getRootDataSource = function () {
+	if (!this._dataView) { return null; }
+
+	var dataTable = this._dataView.getDataSource();
+	if (!dataTable) { return null; }
+
+	while (dataTable.getDataSource()) {
+		dataTable = dataTable.getDataSource();
+	}
+	return dataTable;
+};
+/** @public
+* @param {string} colName
+* @param {number|string} rowRef Number is treated as row index relative to this section data view. String is data view row id
+* @return {*} Returns undefined if not success
+*/
+SectionSettings.prototype.getData = function (colName, rowRef) {
+	if (!this._dataView) { return null; }
+
+	rowRef = this._getRowId(rowRef);
+	return this._dataView.getData(rowRef, colName);
+};
+/** @public
+* @param {string} colName
+* @param {number|string} rowRef Number is treated as row index relative to this section data view. String is data view row id
+* @param {*} data
+* @return {boolean} Returns true for successful data setting
+*/
+SectionSettings.prototype.setData = function (colName, rowRef, data) {
+	if (!this._dataView) { return false; }
+
+	rowRef = this._getRowId(rowRef);
+	this._dataView.setData(rowRef, colName, data);
+	return true;
+};
+/** @public
+* @param {number|string} rowRef Row Index of the display section or row id of the data table
+* @return {Object.<string, *>}
+*/
+SectionSettings.prototype.getRowData = function (rowRef) {
+	if (!this._dataView) { return null; }
+
+	rowRef = this._getRowId(rowRef);
+	return this._dataView.getRowData(rowRef);
+};
+/** @public
+* @param {number|string} rowRef Row Index of the display section or row id of the data table
+* @return {boolean} Returns true for successful data removing
+*/
+SectionSettings.prototype.removeRowData = function (rowRef) {
+	if (!this._dataView) { return false; }
+
+	var dataTable = /** @type{DataTable} */(this.getRootDataSource());
+	if (!dataTable) { return false; }
+
+	rowRef = this._getRowId(rowRef);
+	var rowIndex = dataTable.getRowIndex(/** @type{string} */(rowRef));
+	if (rowIndex < 0) { return false; }
+
+	dataTable.removeRow(rowIndex);
+	return true;
+};
+/** @public
+* @param {Array.<boolean|undefined>} activations
+* @param {number} firstIndex
+* @param {number} lastIndex
+*/
+SectionSettings.prototype.activateColumns = function (activations, firstIndex, lastIndex) {
+	// Column virtual rendering should only work with content section only
+	if (this._type === "content") {
+		for(var c = lastIndex + 1; --c >= firstIndex;) {
+			var activation = activations[c];
+			if (activation != null) {
+				this._grid.activateColumn(c, activation);
+			}
+		}
+	}
+};
+
+/** Clone a copy of the list of SectionSettingss. If there is no tree relationship, return null
+* @public
+* @return {Array.<SectionSettings>}
+*/
+SectionSettings.prototype.getChildren = function () { // TODO: Deprecate this method
+	return this._children;
+};
+/**
+* @public
+* @ignore
+* @param {SectionSettings} parent
+*/
+SectionSettings.prototype.setParent = function (parent) { // TODO: Deprecate this method
+	if(this._parent) {
+		var at = this._parent._children.indexOf(this);
+		if(at >= 0) {
+			this._parent._children.splice(at, 1);
+			if(this._parent._children.length <= 0) {
+				this._parent._children = null;
+			}
+		}
+		this._parent = null;
+	}
+	this._parent = parent;
+	if(this._parent) {
+		if(!this._parent._children) {
+			this._parent._children = [];
+		}
+		this._parent._children.push(this);
+	}
+};
+/**
+* @public
+* @return {SectionSettings}
+*/
+SectionSettings.prototype.getParent = function () { // TODO: Deprecate this method
+	return this._parent;
+};
+
+/** @public
+* @return {!Conflator}
+*/
+SectionSettings.prototype.getDataChangedConflator = function () {
+	return this._dataChangedConflator;
+};
+/** @public
+* @param {boolean} opt_disabled
+*/
+SectionSettings.prototype.disableConflation = function (opt_disabled) {
+	this._dataChangedConflator.disable(opt_disabled);
+};
+/** @public
+* @param {boolean=} opt_disabled
+*/
+SectionSettings.prototype.disableDataBinding = function (opt_disabled) {
+	this._bindingEnabled = opt_disabled === false;
+};
+/** When the parameter is not specifically set by user, The mode will be switched automatically based on SectionSettings type
+* @public
+* @return {boolean}
+*/
+SectionSettings.prototype.getAutoSyncRowCount = function () {
+	return (this._autoSyncRowCount != null) ? this._autoSyncRowCount : (this._type === "content");
+};
+/** @public
+* @param {boolean} bool
+*/
+SectionSettings.prototype.setAutoSyncRowCount = function (bool) {
+	this._autoSyncRowCount = bool;
+	if (this.getAutoSyncRowCount()) {
+		var newRowCount = (this._dataView) ? this._dataView.getVisibleRowCount() : 0;
+		this._grid.setRowCount(newRowCount);
+	}
+};
+
+/** @public
+* @ignore
+* @return {boolean}
+*/
+SectionSettings.prototype.isDataBindable = function () {
+	return (this._bindingEnabled && this._dataView) ? true : false;
+};
+
+
+/** WARNING: Do not call dispose directly, unless you know what you are doing
+* @public
+* @ignore
+*/
+SectionSettings.prototype.dispose = function () {
+	var _t = this;
+	_t._dataChangedConflator.reset();
+	_t._dataArg = null;
+	if (_t._grid) {
+		_t._grid.dispose(); // Release from DOM document
+	}
+	if (_t._dataView) {
+		_t._dataView.unlisten("dataChanged", _t._onDataChanged);
+	}
+	_t.unlistenAll();
+
+	_t.setParent(null);
+	_t._grid = null; // It is important release grid object
+	_t._dataView = null;
+};
+
+/** @public
+* @param {Object=} e
+* @return {!Object}
+*/
+SectionSettings.prototype.extendEventArg = function (e) {
+	if(!e) { e = {}; }
+	if(e["sectionSettings"] !== this) {
+		e["sectionSettings"] = this; // Be careful of circular reference
+		e["section"] = this._snapshot || this._grid;
+		e["sectionName"] = this._grid.getId();
+		e["sectionIndex"] = this._grid.getIndex();
+		e["sectionType"] = this._type;
+
+		e["dataSource"] = this._dataView;
+
+		if(this._snapshot) {
+			e["print"] = true; // Add print flag to tell renderers of the current state
+		} else if(e["print"]) {
+			e["print"] = false;
+		}
+	}
+	return e;
+};
+/** @public
+* @param {Object} e
+* @param {number} fromR
+* @param {number} toR
+* @return {!Object}
+*/
+SectionSettings.prototype.extendRenderEventArg = function (e, fromR, toR) {
+	e = this.extendEventArg(e);
+	if(!(fromR >= 0)) {
+		if(this._snapshot) {
+			fromR = 0;
+			toR = this._grid.getRowCount();
+		} else {
+			fromR = this._grid.getFirstIndexInView();
+			toR = this._grid.getLastIndexInView() + 1;
+		}
+	}
+	e["fromRowIndex"] = fromR;
+	e["toRowIndex"] = toR;
+	return e;
+};
+
+/** @public
+* @param {Object=} e
+* @param {number=} begin INCLUSIVE. The value can be undefined or NaN
+* @param {number=} end INCLUSIVE. The value can be undefined or NaN
+* @return {!Object}
+*/
+SectionSettings.prototype.extendDataEventArg = function (e, begin, end) {
+	if (!e) { e = {}; }
+	// WARNING: Dynamic property adding for internal use
+	e.firstUpdate = begin;
+	e.lastUpdate = end;
+
+	var firstInView, endOfView;
+	if(this._snapshot) {
+		firstInView = 0;
+		endOfView = this._grid.getRowCount();
+	} else {
+		firstInView = this._grid.getFirstIndexInView();
+		endOfView = this._grid.getLastIndexInView() + 1;
+	}
+
+	e["fromRowIndex"] = (begin > firstInView) ? begin : firstInView; // Handles NaN value
+	if (this._dataView) {
+		var dataRowCount = this._dataView.getVisibleRowCount();
+		e["dataRowCount"] = dataRowCount;
+		if (endOfView > dataRowCount) {
+			endOfView = dataRowCount;
+		}
+	}
+	e["toRowIndex"] = ((end + 1) < endOfView) ? (end + 1) : endOfView; // Handles NaN value
+
+	this.extendEventArg(e);
+	return e;
+};
+
+/** @public
+* @ignore
+* @param {number} val
+*/
+SectionSettings.prototype.setIndex = function (val) {
+	this._grid.setIndex(val);
+};
+/** @public
+* @ignore
+* @return {number}
+*/
+SectionSettings.prototype.getRowOffset = function () {
+	return this._grid.getRowOffset();
+};
+/** @public
+* @ignore
+* @param {number} val
+*/
+SectionSettings.prototype.setRowOffset = function (val) {
+	this._grid.setRowOffset(val);
+};
+
+/** @public
+* @param {boolean=} opt_enabled
+*/
+SectionSettings.prototype.enableColumnVirtualization = function (opt_enabled) {
+	opt_enabled = (opt_enabled !== false);
+	if (this._type === "content") {
+		this._grid.enableColumnVirtualization(opt_enabled);
+	}
+};
+/** @public
+* @return {boolean}
+*/
+SectionSettings.prototype.isBinding = function () {
+	return this._isEventDispatching("dataChanged");
+};
+
+
+/** @private
+* @param {Object} e
+*/
+SectionSettings.prototype._onDataChanged = function (e) {
+	if(this.isBinding()) { // During data binding, changing data is not allowed
+		return;
+	}
+
+	if(this._bindingEnabled) {
+		if (e) {
+			this._mergeEvent(e);
+		} else if (!this._dataArg) { // e does not exist due to the conflator
+			return; // Invalid logic detected!
+		}
+	} else if(!this.getAutoSyncRowCount()) {
+		return;
+	}
+
+	if (this._dataChangedConflator.conflate()) {
+		return;
+	}
+	this._calculateChangeIndices();
+	if(this._dataArg) {
+		this._dispatchDataChanged(this._dataArg.firstUpdate, this._dataArg.lastUpdate);
+	} else {
+		this._dispatchDataChanged(0, NaN);
+	}
+};
+/** @private
+* @param {number} firstUpdate
+* @param {number} lastUpdate
+ */
+SectionSettings.prototype._dispatchDataChanged = function (firstUpdate, lastUpdate) {
+	var isAutoSync = this.getAutoSyncRowCount();
+	var newCount = (this._dataView) ? this._dataView.getVisibleRowCount() : 0;
+	var prevCount = this._grid.getRowCount();
+	if (isAutoSync) {
+		if (newCount !== prevCount) {
+			this._grid.setRowCount(newCount, true);
+		}
+	} else {
+		if (newCount > prevCount) {
+			lastUpdate = prevCount - 1;
+		}
+	}
+
+	this.updateRowData(firstUpdate, lastUpdate, this._dataArg);
+	this._dataArg = null; // Data argument must be cleared to prevent memory leak
+};
+/** Fires data binding event without actual change in the data source.
+* This will force visual elements to be re-rendered with the latest data in the data source.
+* @public
+* @param {number=} fromRowIndex INCLUSIVE If the value is undefined, the first row index will be used
+* @param {number=} lastRowIndex INCLUSIVE If the value is undefined, the last row index will be used
+* @param {Object=} e Additional parameters to be fired with the event
+*/
+SectionSettings.prototype.updateRowData = function (fromRowIndex, lastRowIndex, e) {
+	if(this.isDataBindable()) { // Prevent dispatching dataChanged event without the data view
+		e = this.extendDataEventArg(e, fromRowIndex, lastRowIndex);
+		if(e["fromRowIndex"] < e["toRowIndex"]) {
+			this._dispatch("dataChanged", e);
+		}
+	}
+};
+/** @description Rerender section content. If the section is bound with the data source, dataChanged event is fired. Otherwise, rowAvailable event is fired instead.
+* @public
+*/
+SectionSettings.prototype.rerender = function () {
+	if(this.isDataBindable()) {
+		this.updateRowData();
+	} else {
+		this._dispatch("rowAvailable", this.extendEventArg());
+	}
+};
+/** Regenerate the section (UI part) on a different object
+* @public
+* @param {ILayoutGrid} clone A LayoutGrid that will be rendered
+*/
+SectionSettings.prototype.snapshot = function (clone) {
+	if(clone) {
+		this._snapshot = clone;
+		try {
+			clone["setColumnCount"](this._grid.getColumnCount());
+			clone["setRowCount"](this._grid.getRowCount());
+			this._dispatch("rowAvailable", this.extendEventArg());
+		} catch (err) {
+			console.warn("Unable to take a snapshot: " + err.message);
+		}
+		this._snapshot = null;
+
+		// Since states could be changed after taking the snapshot, force rerendering again
+		this._dispatch("rowAvailable", this.extendEventArg());
+	}
+};
+
+/** @private
+* @param {string|number|null=} rowRef
+* @return {string}
+*/
+SectionSettings.prototype._getRowId = function (rowRef) {
+	if (Util.isNumber(rowRef)) {
+		return this._dataView.getRowId(/** @type{number} */(rowRef));
+	}
+	return /** @type{string} */(rowRef);
+};
+
+/** @private
+* @param {!Object} e
+*/
+SectionSettings.prototype._mergeEvent = function (e) {
+	var arg = this._dataArg;
+	if(!arg) {
+		arg = this._dataArg = {};
+		arg["actualUpdate"] = true; // Indicate that this event is fired because of some changes from data view
+		arg["positionChangeOnly"] = true; // The change only cause position changes
+		arg["events"] = [];
+		arg.firstUpdate = NaN;
+		arg.lastUpdate = NaN;
+		arg.updatedRids = {};
+	}
+	if(!e["positionChangeOnly"]) {
+		arg["positionChangeOnly"] = false;
+	}
+
+	if (e.events) {
+		arg["events"] = arg["events"].concat(e.events);
+	} else {
+		arg["events"].push(e);
+	}
+
+	if(arg["globalChange"]) {
+		return;
+	}
+	if(e["globalChange"]) {
+		arg["globalChange"] = true;
+		arg.firstUpdate = 0;
+		arg.lastUpdate = NaN;
+		return;
+	}
+
+	var rids = e["rids"];
+	if(rids) {
+		for(var i = rids.length; --i >= 0;) {
+			arg.updatedRids[rids[i]] = true;
+		}
+	} else if(e["rid"]) {
+		arg.updatedRids[e["rid"]] = true;
+	}
+
+	if(e["type"] !== "updated") { // inserted or removed
+		arg.indexShifted = true;
+		if(e["type"] === "removed") {
+			arg.dataRemoved = true;
+		}
+	}
+};
+/** @private
+*/
+SectionSettings.prototype._calculateChangeIndices = function () {
+	if(!this.isDataBindable() || this._dataArg["globalChange"]) {
+		return;
+	}
+
+	// Calculate the first and last update indices.
+	var rid, rowIndex;
+	if(this._dataArg.indexShifted) {
+		if(this._dataArg.dataRemoved) {
+			this._dataArg.firstUpdate = 0;
+		} else {
+			for(rid in this._dataArg.updatedRids) {
+				rowIndex = this._dataView.getRowIndex(rid);
+				if(rowIndex >= 0) {
+					if (!(this._dataArg.firstUpdate <= rowIndex)) {
+						this._dataArg.firstUpdate = rowIndex;
+					}
+				}
+			}
+		}
+		this._dataArg.lastUpdate = this._dataView.getVisibleRowCount();
+	} else {
+		for(rid in this._dataArg.updatedRids) {
+			rowIndex = this._dataView.getRowIndex(rid);
+			if(rowIndex >= 0) {
+				if (!(this._dataArg.firstUpdate <= rowIndex)) {
+					this._dataArg.firstUpdate = rowIndex;
+				}
+				if (!(this._dataArg.lastUpdate >= rowIndex)) {
+					this._dataArg.lastUpdate = rowIndex;
+				}
+			}
+		}
+	}
+};
+
+SectionSettings._proto = SectionSettings.prototype;
+
+export default SectionSettings;
+export { SectionSettings };

package/lib/core/es6/grid/util/SelectionList.d.ts

@@ -0,0 +1,50 @@
+
+
+declare class SelectionList {
+
+    constructor();
+
+    public clone(): SelectionList;
+
+    public toString(): string;
+
+    public select(at: number): boolean;
+
+    public deselect(at: number): boolean;
+
+    public toggleSelection(at: number): void;
+
+    public singularlySelect(at: number): boolean;
+
+    public selectRange(anchor: number, length: number): void;
+
+    public deselectRange(at: number, length: number): void;
+
+    public hasSelection(at: number, length: number): boolean;
+
+    public getSelection(at: number): boolean;
+
+    public setSelection(at: number, opt_selected?: boolean): boolean;
+
+    public getSelectionAnchor(): number;
+
+    public setSelectionAnchor(at: number): void;
+
+    public getSelectionCount(): number;
+
+    public getFirstSelectedIndex(): number;
+
+    public getLastSelectedIndex(): number;
+
+    public getAllSelections(): (number)[];
+
+    public getSelectionMap(): (boolean)[];
+
+    public clearAllSelections(): number;
+
+    public copyFrom(srcSelections: SelectionList, fromSrcIndex: number, offsetIndex: number, forLength: number): void;
+
+}
+
+export default SelectionList;
+export { SelectionList };