@refinitiv-ui/efx-grid 0.0.0-dev.12023565035.1

package/lib/core/es6/grid/components/StretchedCells.d.ts

@@ -0,0 +1,17 @@
+import Util from "../util/util.js";
+import TrackLayout from "../util/TrackLayout.js"; // eslint-disable-line
+import ILayoutGrid from "../ILayoutGrid.js"; // eslint-disable-line
+import Cell from "./Cell.js";
+
+declare class StretchedCells {
+
+    constructor(trackX: TrackLayout, trackY: TrackLayout, section: ILayoutGrid);
+
+    public dispose(): void;
+
+    public unstretchAllCells(): void;
+
+}
+
+export default StretchedCells;
+export { StretchedCells };

package/lib/core/es6/grid/components/StretchedCells.js

@@ -0,0 +1,342 @@
+import Util from "../util/util.js";
+import TrackLayout from "../util/TrackLayout.js"; // eslint-disable-line
+import ILayoutGrid from "../ILayoutGrid.js"; // eslint-disable-line
+import Cell from "./Cell.js";
+
+
+/** Update cell's top and height
+* @private
+* @param {Cell} cell
+* @param {TrackLayout} trackY
+* @param {number} rowIndex
+*/
+let _updateYAxis = function (cell, trackY, rowIndex) {
+	cell.setTop(trackY.getLaneStart(rowIndex));
+	cell.setHeight(trackY.getLaneSize(rowIndex));
+};
+/** Update cell's left and width
+* @private
+* @param {Cell} cell
+* @param {TrackLayout} trackX
+* @param {number} colIndex
+* @param {number} width
+*/
+let _updateXAxis = function (cell, trackX, colIndex, width) {
+	if(colIndex) {
+		let leftStart = trackX.getLaneStart(colIndex);
+		cell.setLeft(leftStart);
+		cell.setWidth(width - leftStart);
+	} else {
+		cell.setStyle("left", "");
+		cell.setWidth(width); // Cell width is always modified (colSpan styling will be reset)
+	}
+};
+
+
+/** @constructor
+* @ignore
+* @param {!TrackLayout} trackX
+* @param {!TrackLayout} trackY
+* @param {!ILayoutGrid} section
+*/
+let StretchedCells = function (trackX, trackY, section) {
+	this._trackX = trackX;
+	this._trackY = trackY;
+	this._section = section;
+	this._cells = [];
+};
+/** @type {!TrackLayout}
+* @private
+*/
+StretchedCells.prototype._trackX;
+/** @type {!TrackLayout}
+* @private
+*/
+StretchedCells.prototype._trackY;
+/** @type {!ILayoutGrid}
+* @private
+*/
+StretchedCells.prototype._section;
+/** @type {!Array.<Cell>}
+* @private
+*/
+StretchedCells.prototype._cells;
+/** @type {number}
+* @private
+*/
+StretchedCells.prototype._activeCount = 0;
+/** @type {number}
+* @private
+*/
+StretchedCells.prototype._stretchSize = 0;
+
+/** @public
+*/
+StretchedCells.prototype.dispose = function () {
+	let cells = this._cells;
+	if(this._activeCount) {
+		this._activeCount = 0;
+		for(let i = cells.length; --i >= 0;) {
+			let cell = cells[i];
+			if(cell) {
+				cell.dispose();
+			}
+		}
+	}
+	cells.length = 0;
+};
+
+/** @public
+* @ignore
+* @param {number} num
+*/
+StretchedCells.prototype.setStretchSize = function(num) {
+	this._stretchSize = num;
+};
+/** @public
+* @ignore
+* @return {number}
+*/
+StretchedCells.prototype.getStretchSize = function() {
+	return this._stretchSize;
+};
+
+/** @public
+* @ignore
+* @param {number} count
+*/
+StretchedCells.prototype.setCellCount = function (count) {
+	let cells = this._cells;
+	let len = cells.length;
+	if(len < count) {
+		cells.length = count;
+		while(len < count) {
+			cells[len++] = null;
+		}
+	} else if(len > count) {
+		while(--len >= count) {
+			let cell = cells[len];
+			if(cell) {
+				cell.dispose();
+			}
+		}
+		cells.length = count;
+	}
+};
+/** @public
+* @ignore
+* @param {number} rowIndex
+* @return {Cell}
+*/
+StretchedCells.prototype.getCell = function (rowIndex) {
+	let cell = this._cells[rowIndex];
+	if(cell && cell["getParent"]()) {
+		return cell;
+	}
+	return null;
+};
+/** @public
+* @ignore
+* @return {Array.<Cell>}
+*/
+StretchedCells.prototype.getCells = function () {
+	let outAry = [];
+	if(this._activeCount) {
+		let cells = this._cells;
+		let rowCount = cells.length;
+		for(let r = 0; r < rowCount; ++r) {
+			let cell = cells[r];
+			if(cell && cell.getParent()) {
+				outAry.push(cell);
+			}
+		}
+		this._activeCount = outAry.length;
+	}
+	return outAry;
+};
+/** @public
+* @ignore
+* @param {Cell|Element} cellRef
+* @return {number}
+*/
+StretchedCells.prototype.getColumnIndex = function (cellRef) {
+	if(cellRef) {
+		if(cellRef["getElement"]) {
+			let cellElement = cellRef["getElement"]();
+			if(cellElement) {
+				return cellElement._colIndex != null ? cellElement._colIndex : -1;
+			}
+		} else {
+			return cellRef._colIndex != null ? cellRef._colIndex : -1;
+		}
+	}
+	return -1;
+};
+/** @public
+* @ignore
+* @param {Cell|Element} cellRef
+* @return {number}
+*/
+StretchedCells.prototype.getRowIndex = function (cellRef) {
+	if(cellRef) {
+		if(cellRef["getElement"]) {
+			return cellRef["getParent"]() ? this._cells.indexOf(cellRef) : -1;
+		} else {
+			let cells = this._cells;
+			let rowCount = cells.length;
+			for(let r = 0; r < rowCount; ++r) {
+				let cell = cells[r];
+				if(cell && cell["getParent"]() && cell["getElement"]() === cellRef) {
+					return r;
+				}
+			}
+		}
+	}
+	return -1;
+};
+
+/** @public
+* @ignore
+* @param {number} rowIndex
+* @param {number=} colIndex Column index indicates the position of the cell. If not defined, the cell will always position at the left most
+* @return {Cell}
+*/
+StretchedCells.prototype.stretchCell = function (rowIndex, colIndex) {
+	// Increase the active count regardless of redundancy. This acts as a dirty flag. It does not need to be accurate
+	++this._activeCount;
+	if(!colIndex || colIndex < 0) {
+		colIndex = 0;
+	}
+
+	let cell = this._cells[rowIndex] || null;
+	if(!cell) {
+		cell = new Cell(null, this._section);
+		cell.addClass("tr-stretched");
+		cell["stretched"] = true;
+		this._cells[rowIndex] = cell;
+	}
+	let cellElem = cell["getElement"]();
+	cellElem["stretched"] = true;
+	if(cellElem._colIndex !== colIndex) {
+		cellElem._colIndex = colIndex;
+		if(colIndex > 0) {
+			cellElem.classList.add("right-stretching");
+		} else {
+			cellElem.classList.remove("right-stretching");
+		}
+	}
+	if(cellElem._rowIndex !== rowIndex) {
+		cellElem._rowIndex = rowIndex;
+	}
+
+	let width = this._stretchSize || this._trackX.getTrackSize();
+	_updateXAxis(cell, this._trackX, colIndex, width);
+	_updateYAxis(cell, this._trackY, rowIndex);
+
+	return cell;
+};
+/** @public
+* @ignore
+* @param {number} rowIndex
+* @return {Cell}
+*/
+StretchedCells.prototype.unstretchCell = function(rowIndex) {
+	let cell = this._cells[rowIndex] || null;
+	if(cell) {
+		cell.setParent(null);
+	}
+	return cell;
+};
+/** @public
+*/
+StretchedCells.prototype.unstretchAllCells = function () {
+	if(this._activeCount) {
+		this._activeCount = 0;
+		let cells = this._cells;
+		for(let i = cells.length; --i >= 0;) {
+			let cell = cells[i];
+			if(cell) {
+				cell.setParent(null);
+			}
+		}
+	}
+};
+
+/** Update cell's left, top, width and height for all active cells
+* @public
+* @ignore
+*/
+StretchedCells.prototype.updateCells = function() {
+	if(this._activeCount) {
+		let activeCount = 0;
+		let cells = this._cells;
+		let rowCount = cells.length;
+		let trackX = this._trackX;
+		let trackY = this._trackY;
+		let width = this._stretchSize || trackX.getTrackSize();
+		for(let r = 0; r < rowCount; ++r) {
+			let cell = cells[r];
+			if(cell && cell.getParent()) {
+				++activeCount;
+				_updateXAxis(cell, trackX, cell.getElement()._colIndex, width);
+				_updateYAxis(cell, trackY, r);
+			}
+		}
+		this._activeCount = activeCount;
+	}
+};
+/** Update cell's left, top, width and height for all active cells
+* @public
+* @ignore
+*/
+StretchedCells.prototype.updateXAxis = function() {
+	if(this._activeCount) {
+		let activeCount = 0;
+		let cells = this._cells;
+		let rowCount = cells.length;
+		let trackX = this._trackX;
+		let width = this._stretchSize || trackX.getTrackSize();
+		for(let r = 0; r < rowCount; ++r) {
+			let cell = cells[r];
+			if(cell && cell.getParent()) {
+				++activeCount;
+				_updateXAxis(cell, trackX, cell.getElement()._colIndex, width);
+			}
+		}
+		this._activeCount = activeCount;
+	}
+};
+/** Update cell's top and height for all active cells
+* @public
+* @ignore
+*/
+StretchedCells.prototype.updateYAxis = function () {
+	if(this._activeCount) {
+		let activeCount = 0;
+		let cells = this._cells;
+		let rowCount = cells.length;
+		let trackY = this._trackY;
+		for(let r = 0; r < rowCount; ++r) {
+			let cell = cells[r];
+			if(cell && cell.getParent()) {
+				++activeCount;
+				_updateYAxis(cell, trackY, r);
+			}
+		}
+		this._activeCount = activeCount;
+	}
+};
+
+/** @public
+* @ignore
+* @param {number} numCells Index of the first item to be moved to the top
+*/
+StretchedCells.prototype.moveCellsToTop = function (numCells) {
+	if(this._activeCount) {
+		this._cells = Util.cycleArray(this._cells, numCells);
+		this.updateYAxis(); // Reposition cells due to moving row index
+	}
+};
+
+export default StretchedCells;
+export { StretchedCells };

package/lib/core/es6/grid/components/VScrollbar.d.ts

@@ -0,0 +1,18 @@
+import Ext from "../../../../tr-grid-util/es6/Ext.js";
+import ElementWrapper from "../components/ElementWrapper.js";
+import Scrollbar from "./Scrollbar.js";
+
+declare class VScrollbar extends Scrollbar {
+
+    constructor();
+
+    public setScrollTop(px: number): void;
+
+    public isEndOfVerticalScroll(): boolean;
+
+    public getContentHeight(): number;
+
+}
+
+export default VScrollbar;
+export { VScrollbar };

package/lib/core/es6/grid/components/VScrollbar.js

@@ -0,0 +1,139 @@
+/* eslint-disable */
+import Ext from "../../../../tr-grid-util/es6/Ext.js";
+import ElementWrapper from "../components/ElementWrapper.js";
+import Scrollbar from "./Scrollbar.js";
+/* eslint-enable */
+
+/** @constructor
+* @extends {Scrollbar}
+*/
+let VScrollbar = function () {
+	let t = this; // Create a shorthand to shorthen file size
+	t._vertical = true;
+	t._hostClassName = "vscrollbar-host";
+	VScrollbar.base(this, 'constructor'); // Call base constructor
+
+	t._onScroll = t._onScroll.bind(t);
+
+	t._addPaneAt(); // Vertical scroll bar will have only one pane for multiple sections
+
+	// Styling
+	t._element.classList.add("grid-vscroll");
+	t._trackContent.style.width = "1px";
+
+	t.disableMouseWheel(false); // Mousewheel for vertical scrollbar is enabled by default
+
+	t.listen("scroll", t._onScroll); // For backward compatability
+	t._addEvent("contentScrolled");
+};
+Ext.inherits(VScrollbar, Scrollbar);
+
+
+/** For internal usage only
+* @public
+* @ignore
+* @param {ElementWrapper} grid
+* @param {Array.<ElementWrapper>} sections
+* @param {number} startingSection
+*/
+VScrollbar.prototype.setScrollContent = function (grid, sections, startingSection) {
+	this._clearAllPanes();
+
+	let sectionCount = sections.length;
+	if(sectionCount <= 0) { return; }
+
+	// Insert panes in the correct slot
+	let section;
+	let pane = this._panes[0]; // Vertical scrollbar has only one pane and one paneSlider
+	let paneSlider = this._paneSliders[0];
+
+	let s = 0;
+	while(s < startingSection) {
+		section = sections[s++];
+		section.setParent(grid);
+	}
+
+	pane.setParent(grid);
+	let dest = sectionCount - this._footerCount;
+
+	while(s < dest) {
+		section = sections[s++];
+		section.setParent(paneSlider);
+	}
+
+	while(s < sectionCount) {
+		section = sections[s++];
+		section.setParent(grid);
+	}
+	this.invalidateContent(); // Delay content update
+};
+
+/** @override
+*/
+VScrollbar.prototype.setHeight = function (val) {
+	this.setTrackSize(val, val);
+	return true;
+};
+/** @override
+*/
+VScrollbar.prototype.getHeight = function () {
+	return this.getPaneSize(); // Track size may not represent what the client want
+};
+
+/** @override */
+VScrollbar.prototype.getScrollTop = function () {
+	return this._getScrollValue();
+};
+/** @public
+* @param {number} px
+*/
+VScrollbar.prototype.setScrollTop = function (px) {
+	this.update();
+	this._scrollTo(px); // "scroll" event may be fired
+};
+
+/** @public
+* @override
+* @return {boolean}
+*/
+VScrollbar.prototype.isEndOfVerticalScroll = function () {
+	return this._isEndOfScroll();
+};
+/** @public
+* @return {number}
+*/
+VScrollbar.prototype.getContentHeight = function () {
+	let nodeList = this._paneSliders[0].getContent(true);
+	let sum = 0;
+	for (let i = nodeList.length; --i >= 0; ) {
+		sum += nodeList[i].offsetHeight; // TODO: Slow
+	}
+	return sum;
+};
+/** @override
+* @protected
+* @return {number}
+*/
+VScrollbar.prototype.calculateContentSize = function () {
+	return this.getContentHeight();
+};
+
+/** @public
+* @ignore
+* @return {ElementWrapper}
+*/
+VScrollbar.prototype.getPane = function () {
+	return this._panes[0];
+};
+
+/** @private
+* @param {!Object} e
+*/
+VScrollbar.prototype._onScroll = function (e) {
+	this._dispatch("contentScrolled", e); // For backward compatibility
+};
+
+VScrollbar._proto = VScrollbar.prototype;
+
+export default VScrollbar;
+export { VScrollbar };

package/lib/core/es6/grid/components/VirtualItems.d.ts

@@ -0,0 +1,12 @@
+import Util from "../util/util.js";
+
+declare class VirtualItems {
+
+    constructor();
+
+    public dispose(): void;
+
+}
+
+export default VirtualItems;
+export { VirtualItems };

package/lib/core/es6/grid/components/VirtualItems.js

@@ -0,0 +1,51 @@
+import Util from "../util/util.js";
+
+/** @constructor
+* @ignore
+*/
+let VirtualItems = function () {
+	this._items = [];
+};
+/** @type {Array.<!Object>}
+* @private
+*/
+VirtualItems.prototype._items = null;
+
+/** @public
+*/
+VirtualItems.prototype.dispose = function () {
+	this._items = null;
+};
+
+/** @public
+* @ignore
+* @param {number} count
+*/
+VirtualItems.prototype.setItemCount = function (count) {
+	let ary = this._items;
+	let len = ary.length;
+	if(len !== count) {
+		ary.length = count;
+		while(len < count) {
+			ary[len++] = {};
+		}
+	}
+};
+/** @public
+* @ignore
+* @param {number} idx
+* @return {Object}
+*/
+VirtualItems.prototype.getItem = function (idx) {
+	return this._items[idx] || null;
+};
+/** @public
+* @ignore
+* @param {number} numItems Index of the first item to be moved to the top
+*/
+VirtualItems.prototype.moveItemsToTop = function (numItems) {
+	this._items = Util.cycleArray(this._items, numItems);
+};
+
+export default VirtualItems;
+export { VirtualItems };

package/lib/core/es6/grid/event/EventDispatcher.d.ts

@@ -0,0 +1,16 @@
+import EventListeners from "./EventListeners.js";
+
+declare class EventDispatcher {
+
+    constructor();
+
+    public listen(type: string, handler: ((...params: any[]) => any)|null, opt_priority?: number|null): void;
+
+    public unlisten(type: string, handler: ((...params: any[]) => any)|null): void;
+
+    public unlistenAll(type?: string|null): void;
+
+}
+
+export default EventDispatcher;
+export { EventDispatcher };