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

package/lib/core/es6/grid/VirtualizedLayoutGrid.js

@@ -0,0 +1,907 @@
+/* eslint-disable */
+import Ext from "../../../tr-grid-util/es6/Ext.js";
+import TrackLayout from "./util/TrackLayout.js";
+import SelectionList from "./util/SelectionList.js";
+import Reverter from "./util/Reverter.js";
+import ILayoutGrid from "./ILayoutGrid.js";
+import LayoutGrid from "./LayoutGrid.js";
+import ElementWrapper from "./components/ElementWrapper.js";
+/* eslint-enable */
+
+/** @constructor
+ * @ignore
+ * @param {Element|null=} opt_initializer this can be either element id (string) or DOM element.
+ * @param {string=} opt_className
+ * @extends {ElementWrapper}
+*/
+var VirtualizedLayoutGrid = function (opt_initializer, opt_className) {
+	var _t = this;
+	_t._onRestingPosition = _t._onRestingPosition.bind(_t);
+
+	_t._element = opt_initializer ? opt_initializer : document.createElement("div");
+	_t._element.className = "tr-vlg";
+	if(opt_className) { _t.enableClass(/** @type{string} */(opt_className), true); }
+
+	_t._grid = new LayoutGrid(null, {"owner": this});
+	_t._grid.setParent(_t._element);
+
+	_t._layoutY = new TrackLayout();
+	_t._selectionList =  new SelectionList();
+	_t._reverter = new Reverter(_t._onRestingPosition, 200); // WORKAROUND: GRID-402
+
+	_t._addEvent("rowHighlighted");
+	_t._addEvent("rowCountChanged");
+	_t._addEvent("rowHeightChanged");
+	_t._addEvent("rowAvailable");
+};
+Ext.inherits(VirtualizedLayoutGrid, ElementWrapper);
+
+
+/** For virtualization in Y-Axis
+ * @private
+ * @type {number}
+ */
+VirtualizedLayoutGrid.prototype._index = -1;
+
+/**
+ * @private
+ * @type {number}
+ */
+VirtualizedLayoutGrid.prototype._indexOffset = 0;
+
+/**
+ * @private
+ * @type {number}
+ */
+VirtualizedLayoutGrid.prototype._firstIndex = 0;
+
+/** @private
+* @type {!LayoutGrid}
+*/
+VirtualizedLayoutGrid.prototype._grid;
+
+/** @private
+* @type {!TrackLayout}
+*/
+VirtualizedLayoutGrid.prototype._layoutY;
+
+/** @private
+ * @type {SelectionList}
+ */
+VirtualizedLayoutGrid.prototype._selectionList = null;
+
+/** @type {Reverter}
+ * @private
+ */
+VirtualizedLayoutGrid.prototype._reverter = null;
+
+//#region ====== Override ElementWrapper ======//
+/** @override */
+VirtualizedLayoutGrid.prototype.getWidth = function () {
+	if(this.isVisible()) {
+		return this._grid.getWidth();
+	}
+	return 0;
+};
+/** @override */
+VirtualizedLayoutGrid.prototype.getHeight = function () {
+	if (this.isVisible()) {
+		return this._element.offsetHeight;
+	}
+	return 0;
+};
+/** @override */
+VirtualizedLayoutGrid.prototype.dispose = function () {
+	this.setRowCount(0); // Fire rowCountChanged
+	this.unlistenAll();
+
+	this._grid.dispose();
+	this._dispose();
+	this._reverter.dispose();
+};
+/** @override */
+VirtualizedLayoutGrid.prototype.setWidth = function (px) {
+	return this._grid.setWidth(px);
+};
+/** @override */
+VirtualizedLayoutGrid.prototype.setHeight = function (px) {
+	console.log("unsupported");
+	return false;
+};
+/** {@link ElementWrapper#show}
+* @override */
+VirtualizedLayoutGrid.prototype.show = function (opt_shown) {
+	this._element.style.display = (opt_shown !== false) ? "" : "none";
+	this._dispatchRowHeightChangedEvent(0, this._layoutY.getLaneCount());
+};
+//#endregion
+
+//#region ====== Implementing ILayoutGrid ======//
+/** @inheritDoc */
+VirtualizedLayoutGrid.prototype.hitTest = function (x, y) {
+	var e = [];
+	e["colIndex"] = this._grid.hitTestX(x);
+	e["rowIndex"] = this._layoutY.hitTest(y);
+	return e;
+};
+/** @inheritDoc */
+VirtualizedLayoutGrid.prototype.hitTestX = function (x) {
+	return this._grid.hitTestX(x);
+};
+/** @inheritDoc */
+VirtualizedLayoutGrid.prototype.hitTestY = function (y) {
+	return this._layoutY.hitTest(y);
+};
+
+/** @inheritDoc */
+VirtualizedLayoutGrid.prototype.getDefaultColumnWidth = function () {
+	return this._grid.getDefaultColumnWidth();
+};
+/** @inheritDoc */
+VirtualizedLayoutGrid.prototype.setDefaultColumnWidth = function (val) {
+	this._grid.setDefaultColumnWidth(val);
+};
+
+/** @inheritDoc */
+VirtualizedLayoutGrid.prototype.getDefaultRowHeight = function () {
+	return this._layoutY.getDefaultLaneSize();
+};
+/** @inheritDoc */
+VirtualizedLayoutGrid.prototype.setDefaultRowHeight = function (val) {
+	var prevVal = this._layoutY.getDefaultLaneSize();
+	if (prevVal !== val) {
+		this._layoutY.setDefaultLaneSize(val);
+		this._element.style.height = this._layoutY.getTrackSize() + "px";
+		this._grid.setDefaultRowHeight(val);
+		this._dispatchRowHeightChangedEvent(0, this._layoutY.getLaneCount());
+	}
+};
+
+/** @inheritDoc */
+VirtualizedLayoutGrid.prototype.getColumnWidth = function (index) {
+	return this._grid.getColumnWidth(index);
+};
+/** @inheritDoc */
+VirtualizedLayoutGrid.prototype.setColumnWidth = function (index, val) {
+	return this._grid.setColumnWidth(index, val);
+};
+/** @public
+ * @ignore
+ * @param {number} indexX
+ * @param {number} val
+ * @return {boolean}
+ */
+VirtualizedLayoutGrid.prototype._setColumnWidth = function (indexX, val) {
+	return this._grid._setColumnWidth(indexX, val);
+};
+/** @public
+ * @ignore
+ */
+VirtualizedLayoutGrid.prototype._updateColumnLayout = function () {
+	this._grid._updateColumnLayout();
+};
+
+/** @inheritDoc */
+VirtualizedLayoutGrid.prototype.getRowHeight = function (index) {
+	return this._layoutY.getLaneSize(index);
+};
+/** @inheritDoc */
+VirtualizedLayoutGrid.prototype.setRowHeight = function (index, val) {
+	if(this._layoutY.setLaneSize(index, val)) {
+		this._grid.setRowHeight(index - this._firstIndex, val);
+		this._element.style.height = this._layoutY.getTrackSize() + "px";
+		return this._dispatchRowHeightChangedEvent(index, index + 1);
+	}
+	return false;
+};
+
+/** @inheritDoc */
+VirtualizedLayoutGrid.prototype.isColumnVisible = function (index) {
+	return this._grid.isColumnVisible(index);
+};
+/** @inheritDoc */
+VirtualizedLayoutGrid.prototype.hideColumn = function (index, val) {
+	return this._grid.hideColumn(index, val);
+};
+
+/** @inheritDoc */
+VirtualizedLayoutGrid.prototype.isRowVisible = function (index) {
+	return this._grid.isRowVisible(index - this._firstIndex);
+};
+/** @inheritDoc */
+VirtualizedLayoutGrid.prototype.hideRow = function (index, val) {
+	return this._grid.hideRow(index - this._firstIndex, val);
+};
+
+/** @inheritDoc */
+VirtualizedLayoutGrid.prototype.getMinimumColumnWidth = function (index) {
+	return this._grid.getMinimumColumnWidth(index);
+};
+/** @inheritDoc */
+VirtualizedLayoutGrid.prototype.setMinimumColumnWidth = function (index, val) {
+	return this._grid.setMinimumColumnWidth(index, val);
+};
+
+/** @inheritDoc */
+VirtualizedLayoutGrid.prototype.getMinimumRowHeight = function (index) {
+	return this._layoutY.getMinimumLaneSize(index);
+};
+/** @inheritDoc */
+VirtualizedLayoutGrid.prototype.setMinimumRowHeight = function (index, val) {
+	console.log("unsupported");
+	return false;
+};
+
+/** @inheritDoc */
+VirtualizedLayoutGrid.prototype.getCellLeft = function (indexX) {
+	return this._grid.getCellLeft(indexX);
+};
+/** @inheritDoc */
+VirtualizedLayoutGrid.prototype.getCellTop = function (indexY) {
+	return this._layoutY.getLaneStart(indexY);
+};
+/** @inheritDoc */
+VirtualizedLayoutGrid.prototype.getCellWidth = function (indexX, indexY) {
+	return this._grid.getCellWidth(indexX, 0); //In virtualization, every cell in the same column has the same width
+};
+/** @inheritDoc */
+VirtualizedLayoutGrid.prototype.getCellHeight = function (indexX, indexY) {
+	return this._layoutY.getLaneSize(indexY); //In virtualization, every cell in the same row has the same height
+};
+
+/** @inheritDoc */
+VirtualizedLayoutGrid.prototype.hasCellSpan = function () {
+	return this._grid.hasCellSpan();
+};
+//Not support row spanning in virtualization
+/** @inheritDoc */
+VirtualizedLayoutGrid.prototype.getCellRowSpan = function (indexX, indexY) {
+	return this._grid.getCellRowSpan(indexX, indexY - this._firstIndex);
+};
+/** @inheritDoc */
+VirtualizedLayoutGrid.prototype.setCellRowSpan = function (indexX, indexY, rowSpan) {
+	return this._grid.setCellRowSpan(indexX, indexY - this._firstIndex, rowSpan);
+};
+/** @inheritDoc */
+VirtualizedLayoutGrid.prototype.getCellColSpan = function (indexX, indexY) {
+	return this._grid.getCellColSpan(indexX, indexY - this._firstIndex);
+};
+/** @inheritDoc */
+VirtualizedLayoutGrid.prototype.setCellColSpan = function (indexX, indexY, colSpan) {
+	return this._grid.setCellColSpan(indexX, indexY - this._firstIndex, colSpan);
+};
+/** @inheritDoc */
+VirtualizedLayoutGrid.prototype.clearCellSpans = function () {
+	return this._grid.clearCellSpans();
+};
+/** @inheritDoc */
+VirtualizedLayoutGrid.prototype.clearColumnSpans = function (indexX) {
+	return this._grid.clearColumnSpans(indexX);
+};
+
+/** @inheritDoc */
+VirtualizedLayoutGrid.prototype.clearColumnCustomizations = function () {
+	this._grid.clearColumnCustomizations();
+};
+/** @inheritDoc */
+VirtualizedLayoutGrid.prototype.clearRowCustomizations = function () {
+	this._layoutY.clearLaneCustomizations();
+	this._grid.clearRowCustomizations();
+};
+
+/** @inheritDoc */
+VirtualizedLayoutGrid.prototype.getColumnScalability = function (indexX) {
+	return this._grid.getColumnScalability(indexX);
+};
+/** @inheritDoc */
+VirtualizedLayoutGrid.prototype.setColumnScalability = function (indexX, val) {
+	return this._grid.setColumnScalability(indexX, val);
+};
+
+/** @inheritDoc */
+VirtualizedLayoutGrid.prototype.getRowScalability = function (indexY) {
+	return this._layoutY.getLaneScalability(indexY);
+};
+/** @inheritDoc */
+VirtualizedLayoutGrid.prototype.setRowScalability = function (index, val) {
+	console.log("unsupported");
+	return false;
+};
+
+/** @inheritDoc */
+VirtualizedLayoutGrid.prototype.getCell = function (indexX, indexY, opt_includeSpan) {
+	return this._grid.getCell(indexX, indexY - this._firstIndex, opt_includeSpan);
+};
+/** @inheritDoc */
+VirtualizedLayoutGrid.prototype.getCellContent = function (indexX, indexY) {
+	return this._grid.getCellContent(indexX, indexY - this._firstIndex);
+};
+/** @inheritDoc */
+VirtualizedLayoutGrid.prototype.setCellContent = function (indexX, indexY, data) {
+	return this._grid.setCellContent(indexX, indexY - this._firstIndex, data);
+};
+
+/** @inheritDoc */
+VirtualizedLayoutGrid.prototype.getColumnCount = function () {
+	return this._grid.getColumnCount();
+};
+/** @inheritDoc */
+VirtualizedLayoutGrid.prototype.setColumnCount = function (val) {
+	this._grid.setColumnCount(val);
+};
+
+/** @inheritDoc */
+VirtualizedLayoutGrid.prototype.getRowCount = function () {
+	return this._layoutY.getLaneCount();
+};
+/** @inheritDoc */
+VirtualizedLayoutGrid.prototype.setRowCount = function (val, noBinding) {
+	var prevCount = this._layoutY.getLaneCount();
+	if(prevCount !== val){
+		this._layoutY.setLaneCount(val);
+		this._element.style.height = this._layoutY.getTrackSize() + "px";
+		//After rowCountChanged fires, virtualizer will update virtual row count if
+		//the range of virtual layout changed.
+		this._dispatch("rowCountChanged", { "rowCount": val, "prevCount": prevCount, "noBinding": noBinding });
+	}
+};
+/** @inheritDoc */
+VirtualizedLayoutGrid.prototype.getVisibleRowCount = function () {
+	return this.getRowCount();
+};
+/** @inheritDoc */
+VirtualizedLayoutGrid.prototype.addRow = function (val) {
+	if (val <= 0) { return; }
+	if (this._grid.getColumnCount() <= 0) {
+		console.log("WARNING: Row cannot be added, unless at least one column is added");
+		return;
+	}
+	this.setRowCount(this._layoutY.getLaneCount() + val);
+};
+/** @inheritDoc */
+VirtualizedLayoutGrid.prototype.removeRow = function (val) {
+	if (val <= 0) { return; }
+	var rowCount = this._layoutY.getLaneCount();
+	if (val > rowCount) { val = rowCount; }
+	this.setRowCount(rowCount - val);
+};
+
+/** @inheritDoc */
+VirtualizedLayoutGrid.prototype.setBorders = function (lft, top, rgt, btm) {
+	this._grid.setBorders(lft, top, rgt, btm);
+};
+/** @inheritDoc */
+VirtualizedLayoutGrid.prototype.getColumnStyle = function (colIndex, styleName) {
+	return this._grid.getColumnStyle(colIndex, styleName);
+};
+/** @inheritDoc */
+VirtualizedLayoutGrid.prototype.setColumnStyle = function (colIndex, styleName, value) {
+	this._grid.setColumnStyle(colIndex, styleName, value);
+};
+
+/** @inheritDoc */
+VirtualizedLayoutGrid.prototype.enableColumnClass = function (colIndex, className, enabled) {
+	this._grid.enableColumnClass(colIndex, className, enabled);
+};
+/** @inheritDoc */
+VirtualizedLayoutGrid.prototype.hasColumnClass = function (colIndex, className) {
+	return this._grid.hasColumnClass(colIndex, className);
+};
+/** @inheritDoc */
+VirtualizedLayoutGrid.prototype.enableRowClass = function (rowIndex, className, enabled) {
+	this._grid.enableRowClass(rowIndex - this._firstIndex, className, enabled);
+};
+/** @inheritDoc */
+VirtualizedLayoutGrid.prototype.setRowStyle = function (rowIndex, styleName, value, enabled) {
+	this._grid.setRowStyle(rowIndex - this._firstIndex, styleName, value, enabled);
+};
+
+/** @inheritDoc */
+VirtualizedLayoutGrid.prototype.getContentWidth = function () {
+	return this._grid.getContentWidth();
+};
+/** @inheritDoc */
+VirtualizedLayoutGrid.prototype.getContentHeight = function () {
+	return this._layoutY.getTrackSize();
+};
+
+/** @inheritDoc */
+VirtualizedLayoutGrid.prototype.getCellsByRowIndex = function(rowIndex) {
+	return this._grid.getCellsByRowIndex(rowIndex - this._firstIndex);
+};
+
+/** @inheritDoc */
+VirtualizedLayoutGrid.prototype.disableHorizontalGridLine = function (opt_bool) {
+	this._grid.disableHorizontalGridLine(opt_bool);
+};
+/** @inheritDoc */
+VirtualizedLayoutGrid.prototype.disableVerticalGridLine = function (opt_bool) {
+	this._grid.disableVerticalGridLine(opt_bool);
+};
+
+/** @inheritDoc */
+VirtualizedLayoutGrid.prototype.enableShading = function (enabled) {
+	this._grid.enableShading(enabled);
+};
+
+/** @inheritDoc */
+VirtualizedLayoutGrid.prototype.setTransposedShading = function (enabled) {
+	this._grid.setTransposedShading(enabled);
+};
+
+/** @inheritDoc */
+VirtualizedLayoutGrid.prototype.enableRowHighlighting = function (opt_bool) {
+	this._grid.enableRowHighlighting(opt_bool);
+};
+
+/** @inheritDoc */
+VirtualizedLayoutGrid.prototype.getRowHighlight = function () {
+	var index = this._grid.getRowHighlight();
+	if(index >= 0){
+		index += this._firstIndex;
+	}
+	return index;
+};
+
+/** @inheritDoc */
+VirtualizedLayoutGrid.prototype.setRowHighlight = function (rowIndex) {
+	var prevIndex = this._grid.getRowHighlight();
+	if (prevIndex >= 0) { prevIndex += this._firstIndex; }
+	this._grid.setRowHighlight(rowIndex - this._firstIndex);
+	//Check row highligh is in view
+	rowIndex = this._grid.getRowHighlight();
+	if (rowIndex >= 0) { rowIndex += this._firstIndex; }
+
+	if (this._hasListener("rowHighlighted")) {
+		var e = {};
+		e["prevRowIndex"] = prevIndex;
+		e["rowIndex"] = rowIndex;
+		this._dispatch("rowHighlighted", e);
+	}
+};
+
+/** @inheritDoc */
+VirtualizedLayoutGrid.prototype.getSelectedRows = function () {
+	if(this.getSelectedRowCount() > 0){
+		return this._selectionList.getAllSelections();
+	}
+	return null;
+};
+/** @inheritDoc */
+VirtualizedLayoutGrid.prototype.getSelectedRowCount = function () {
+	return this._selectionList.getSelectionCount();
+};
+
+/** @inheritDoc */
+VirtualizedLayoutGrid.prototype.isSelectedRow = function (at) {
+	return this._selectionList.getSelection(at);
+};
+
+/** @inheritDoc */
+VirtualizedLayoutGrid.prototype.setSelectedRow = function (rowIndex, opt_selected) {
+	this._selectionList.setSelection(rowIndex, opt_selected);
+
+	var adjustedIndex = rowIndex - this._firstIndex;
+	this._grid.setSelectedRow(adjustedIndex, this._selectionList.getSelection(rowIndex));
+};
+
+/** @inheritDoc */
+VirtualizedLayoutGrid.prototype.selectSingleRow = function (rowIndex) {
+	this.clearSelectedRows();
+	this.setSelectedRow(rowIndex);
+};
+/** @inheritDoc */
+VirtualizedLayoutGrid.prototype.selectRowRange = function (rowIndex, length) {
+	this._selectionList.selectRange(rowIndex, length);
+	this._updateRowSelection();
+};
+/** @inheritDoc */
+VirtualizedLayoutGrid.prototype.clearSelectedRows = function () {
+	var count = this._selectionList.clearAllSelections();
+	this._grid.clearSelectedRows();
+	return count;
+};
+/** @inheritDoc */
+VirtualizedLayoutGrid.prototype.getFirstSelectedRow = function () {
+	return this._selectionList.getFirstSelectedIndex();
+};
+/** @inheritDoc */
+VirtualizedLayoutGrid.prototype.getLastSelectedRow = function () {
+	return this._selectionList.getLastSelectedIndex();
+};
+/** @inheritDoc */
+VirtualizedLayoutGrid.prototype.getRowAnchor = function () {
+	return this._selectionList.getSelectionAnchor();
+};
+/** @inheritDoc */
+VirtualizedLayoutGrid.prototype.setRowAnchor = function (at) {
+	this._selectionList.setSelectionAnchor(at);
+};
+
+/** @inheritDoc */
+VirtualizedLayoutGrid.prototype.activateColumn = function (colIndex, opt_bool) {
+	this._grid.activateColumn(colIndex, opt_bool);
+};
+/** @inheritDoc */
+VirtualizedLayoutGrid.prototype.activateRows = function (from, to, updateRange) {
+	var maxLen = this._layoutY.getLaneCount();
+	if(!from) { from = this._rowOffset; }
+	if(!to && to !== 0) { to = from + maxLen; }
+
+	from -= this._rowOffset; // Convert to relative index
+	if(from < 0) { from = 0; }
+	to -= this._rowOffset; // Convert to relative index
+	if(to < 0) { to = 0; }
+
+	var prevLen = this._getInnerRowCount();
+	var pfi = this._firstIndex;
+	var fi = 0;
+
+	fi = from - (from & 1); // This is done to maintain zebra background color.
+	if (fi < 0) { fi = 0; }
+	else if (fi > maxLen) { fi = maxLen; }
+
+	var newLen = (to + (to & 1)) - fi;
+	if(newLen + 2 === prevLen) { // To remove unnecessary shrinking during scrolling
+		newLen = prevLen;
+	}
+
+	if(newLen < 0) { newLen = 0; }
+	else if(newLen + fi > maxLen) { newLen = maxLen - fi; }
+
+	this._firstIndex = fi;
+	var ei = fi + newLen;
+
+	// Re-position inner grid
+	var px = this._layoutY.getLaneStart(fi);
+	var gridElem = this._grid.getElement(); // GRID-347 Chrome 86 does not recognize top property of grand children
+	if(gridElem) {
+		gridElem.style.transform = px ? "translateY(" + px + "px)" : ""; // Replacement for this._grid.setTop(px);
+		gridElem.style.top = "";
+		this._reverter.start();
+	}
+	this._grid._onEnterDocument();
+	var force = false; // Forcing flag to update entire range
+
+	if (newLen !== prevLen) {
+		this._grid.setRowCount(newLen);
+		if(newLen > prevLen) { // New row is available. Fire event to render the cells.
+			var e = {};
+			e["prevRowIndex"] = fi + prevLen;
+			e["rowIndex"] = fi + newLen;
+			if(updateRange) {
+				e["noDataUpdate"] = true; // Data update will be triggered after this, so we notify grid not to update
+			}
+			this._dispatch("rowAvailable", e);
+		}
+		force = true; // Force update entire range
+	}
+	if(updateRange) { // Find actual update range
+		if(!force) {
+			// TODO: Check where to clearSelectedRows() more properly
+			this._grid.clearSelectedRows(); // Because row will be moving up and down, we need to clear the selection first
+			var pei = pfi + prevLen;
+			if(fi < pfi && pfi < ei && pei >= ei) {
+				this.moveRowsToTop(ei - pfi);
+				updateRange[0] = fi;
+				updateRange[1] = pfi;
+			} else if(pfi < fi && fi < pei && ei >= pei) {
+				this.moveRowsToTop(fi - pfi);
+				updateRange[0] = pei;
+				updateRange[1] = ei;
+			} else if(fi === pfi && ei === pei) {
+				updateRange[0] = 0;
+				updateRange[1] = 0;
+			} else {
+				force = true;
+			}
+		}
+
+		if(force) {
+			updateRange[0] = fi;
+			updateRange[1] = ei;
+		}
+	}
+
+	if(!this._layoutY.isHomogeneous()) { // Row heights need to be updated on each scrolling
+		this._grid._updateRowHeights(this._layoutY, fi); // TODO: Set height only for the actual update range
+	}
+
+	this._updateRowSelection();
+};
+/** @inheritDoc */
+VirtualizedLayoutGrid.prototype.moveRowsToTop = function (numRows) {
+	this._grid.moveRowsToTop(numRows);
+};
+
+/** @inheritDoc */
+VirtualizedLayoutGrid.prototype.getFirstIndexInView = function () {
+	return this._firstIndex;
+};
+
+/** @inheritDoc */
+VirtualizedLayoutGrid.prototype.getLastIndexInView = function () {
+	return this._firstIndex + this._getInnerRowCount() - 1;
+};
+
+/** @inheritDoc */
+VirtualizedLayoutGrid.prototype.isInCurrentView = function(index){
+	return (this._firstIndex <= index) && (index < this._firstIndex + this._getInnerRowCount());
+};
+
+/** @inheritDoc */
+VirtualizedLayoutGrid.prototype.getFrozenLayout = function () {
+	return this._grid.getFrozenLayout();
+};
+/** @inheritDoc */
+VirtualizedLayoutGrid.prototype.setFrozenLayout = function (bool) {
+	this._grid.setFrozenLayout(bool);
+};
+
+/** @inheritDoc */
+VirtualizedLayoutGrid.prototype.getColumn = function (index) {
+	return this._grid.getColumn(index);
+};
+
+/** @inheritDoc */
+VirtualizedLayoutGrid.prototype.insertColumn = function (index, opt_json) {
+	return this._grid.insertColumn(index, opt_json);
+};
+
+/** @inheritDoc */
+VirtualizedLayoutGrid.prototype.removeColumnAt = function (index) {
+	return this._grid.removeColumnAt(index);
+};
+
+/** @inheritDoc */
+VirtualizedLayoutGrid.prototype.moveColumn = function (from, to) {
+	this._grid.moveColumn(from, to);
+};
+
+/** @inheritDoc */
+VirtualizedLayoutGrid.prototype.enableRowVirtualization = function (bool) { };
+
+/** @inheritDoc */
+VirtualizedLayoutGrid.prototype.enableColumnVirtualization = function (bool) {
+	this._grid.enableColumnVirtualization(bool);
+};
+
+/** @inheritDoc */
+VirtualizedLayoutGrid.prototype.getColumnIndex = function (colElem) {
+	return this._grid.getColumnIndex(colElem);
+};
+/** @inheritDoc */
+VirtualizedLayoutGrid.prototype.getCellIndex = function (colIndex, cellElem) {
+	var at = this._grid.getCellIndex(colIndex, cellElem);
+	if(at < 0) {
+		return -1;
+	}
+	return at + this._firstIndex;
+};
+
+/** @inheritDoc */
+VirtualizedLayoutGrid.prototype.getIndex = function () {
+	return this._index;
+};
+/** @inheritDoc */
+VirtualizedLayoutGrid.prototype.setIndex = function (index) {
+	this._index = index;
+};
+
+/** @inheritDoc */
+VirtualizedLayoutGrid.prototype.setRowOffset = function(val){
+	this._rowOffset = val;
+};
+
+/** @inheritDoc */
+VirtualizedLayoutGrid.prototype.getRowOffset = function(){
+	return this._rowOffset;
+};
+
+/** @inheritDoc */
+VirtualizedLayoutGrid.prototype.updateLayout = function () {};
+
+/** {@link ILayoutGrid#stretchCell}
+* @inheritDoc */
+VirtualizedLayoutGrid.prototype.stretchCell = function (cellRef, rowIndex, opt_stretching, onlyToTheRight) {
+	return this._grid.stretchCell(
+		cellRef,
+		(rowIndex != null) ? rowIndex - this._firstIndex : null,
+		opt_stretching,
+		onlyToTheRight
+	);
+};
+
+/** {@link ILayoutGrid#unstretchCell}
+* @inheritDoc */
+VirtualizedLayoutGrid.prototype.unstretchCell = function (cellRef, rowIndex) {
+	return this._grid.unstretchCell(
+		cellRef,
+		(rowIndex != null) ? rowIndex - this._firstIndex : null
+	);
+};
+/** {@link ILayoutGrid#unstretchAllCells}
+* @inheritDoc */
+VirtualizedLayoutGrid.prototype.unstretchAllCells = function (cellRef, rowIndex) {
+	return this._grid.unstretchAllCells();
+};
+
+/** {@link ILayoutGrid#getStretchedCell}
+* @inheritDoc */
+VirtualizedLayoutGrid.prototype.getStretchedCell = function (cellRef, rowIndex) {
+	return this._grid.getStretchedCell(
+		cellRef,
+		(rowIndex != null) ? rowIndex - this._firstIndex : null
+	);
+};
+/** {@link ILayoutGrid#getStretchedCells}
+* @inheritDoc */
+VirtualizedLayoutGrid.prototype.getStretchedCells = function () {
+	return this._grid.getStretchedCells();
+};
+/** {@link ILayoutGrid#updateStretchedCells}
+* @inheritDoc */
+VirtualizedLayoutGrid.prototype.updateStretchedCells = function () {
+	return this._grid.updateStretchedCells();
+};
+
+/** {@link ILayoutGrid#getColumnHost}
+* @inheritDoc */
+VirtualizedLayoutGrid.prototype.getColumnHost = function () {
+	return this._grid.getElement();
+};
+/** {@link ILayoutGrid#setHidingMethod}
+* @inheritDoc */
+VirtualizedLayoutGrid.prototype.setHidingMethod = function (method) {
+	this._grid.setHidingMethod(method);
+};
+/** {@link ILayoutGrid#getHidingMethod}
+* @inheritDoc */
+VirtualizedLayoutGrid.prototype.getHidingMethod = function () {
+	return this._grid.getHidingMethod();
+};
+/** {@link ILayoutGrid#setColumnVisibility}
+* @inheritDoc */
+VirtualizedLayoutGrid.prototype.setColumnVisibility = function (colIndex, bool, flag) {
+	return this._grid.setColumnVisibility(colIndex, bool, flag);
+};
+/** {@link ILayoutGrid#setColumnVisibility}
+* @inheritDoc */
+VirtualizedLayoutGrid.prototype.getRowLayout = function () { return this._layoutY; };
+
+/** {@link ILayoutGrid#reserveRightSpace}
+* @inheritDoc */
+VirtualizedLayoutGrid.prototype.reserveRightSpace = function (size) {
+	return this._grid.reserveRightSpace(size);
+};
+/** {@link ILayoutGrid#reserveRightSpace}
+* @inheritDoc */
+VirtualizedLayoutGrid.prototype.getReservedSpace = function () {
+	return this._grid.getReservedSpace();
+};
+/** {@link ILayoutGrid#getComputedStyle}
+* @inheritDoc */
+VirtualizedLayoutGrid.prototype.getComputedStyle = function () {
+	return this._grid.getComputedStyle();
+};
+/** {@link ILayoutGrid#isColumnActive}
+* @inheritDoc
+*/
+VirtualizedLayoutGrid.prototype.isColumnActive = function (colIndex) {
+	return this._grid.isColumnActive(colIndex);
+};
+/** {@link ILayoutGrid#setRowAttributes}
+* @inheritDoc
+*/
+VirtualizedLayoutGrid.prototype.setRowAttributes = function (rowIndex, func) {
+	return this._grid.setRowAttributes(rowIndex, func);
+};
+/** @public
+* @param {number} rowIndex
+* @return {Object}
+*/
+VirtualizedLayoutGrid.prototype.getContextRow = function (rowIndex) {
+	return this._grid.getContextRow(rowIndex - this._firstIndex);
+};
+//#endregion public methods
+
+//#region ====== Private methods ======//
+/** @private
+* @return {number}
+*/
+VirtualizedLayoutGrid.prototype._getInnerRowCount = function () {
+	return this._grid.getRowCount();
+};
+
+/** @private */
+VirtualizedLayoutGrid.prototype._updateRowSelection = function () {
+	this._grid.clearSelectedRows();
+	var sl = this._selectionList;
+	var count = sl.getSelectionCount();
+	if(count <= 0) { return; }
+
+	var r;
+	var fi = this._firstIndex;
+	var ei = fi + this._getInnerRowCount();
+	if(count === 1) {
+		r = sl.getFirstSelectedIndex();
+		if (fi <= r && r < ei) {
+			this._grid.setSelectedRow(r - fi, true);
+		}
+	} else {
+		if(count >= ei - fi) {
+			for(r = fi; r < ei; ++r) {
+				if(sl.getSelection(r)) {
+					this._grid.setSelectedRow(r - fi, true);
+				}
+			}
+		} else {
+			var selections = sl.getAllSelections();
+			for(var i = 0; i < count; ++i){
+				r = selections[i];
+				if (fi <= r && r < ei) {
+					this._grid.setSelectedRow(r - fi, true);
+				}
+			}
+		}
+	}
+};
+
+/** @private
+ * @param {number} from
+ * @param {number} to
+ * @return {boolean}
+ */
+VirtualizedLayoutGrid.prototype._dispatchRowHeightChangedEvent = function (from, to) {
+	if (from >= to) { return false; }
+
+	var e = {};
+	e["rowIndex"] = from;
+	e["changeLength"] = to - from;
+	this._dispatch("rowHeightChanged", e);
+	return true;
+};
+/** @private
+ */
+VirtualizedLayoutGrid.prototype._onRestingPosition = function () {
+	var gridElem = this._grid.getElement();
+	if(gridElem) {
+		var px = this._layoutY.getLaneStart(this._firstIndex);
+		gridElem.style.transform = "";
+		gridElem.style.top = px ? px + "px" : ""; // WORKAROUND: GRID-402
+	}
+};
+/** @public
+* @ignore
+* @param {boolean} absolutePos if true, the right space element will be positioned absolutely
+*/
+VirtualizedLayoutGrid.prototype._updateRightSpaceStyle = function(absolutePos) {
+	this._grid._updateRightSpaceStyle(absolutePos);
+};
+/** @public
+* @ignore
+*/
+VirtualizedLayoutGrid.prototype._updateLayers = function() {
+	this._grid._updateLayers();
+};
+/** @public
+* @ignore
+* @param {*} ctx
+*/
+VirtualizedLayoutGrid.prototype._setContext = function(ctx) {
+	this._grid._setContext(ctx);
+};
+
+/** @public
+* @ignore
+* @return {*} ctx
+*/
+VirtualizedLayoutGrid.prototype._getContext = function () {
+	return this._grid._getContext();
+};
+//#endregion
+
+VirtualizedLayoutGrid._proto = VirtualizedLayoutGrid.prototype;
+
+export default VirtualizedLayoutGrid;
+export { VirtualizedLayoutGrid };