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

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

@@ -0,0 +1,24 @@
+import Ext from "../../../../tr-grid-util/es6/Ext.js";
+import ElementWrapper from "../components/ElementWrapper.js";
+import Scrollbar from "./Scrollbar.js";
+
+declare class HScrollbar extends Scrollbar {
+
+    constructor();
+
+    public setScrollLeft(px: number): void;
+
+    public isEndOfHorizontalScroll(): boolean;
+
+    public getContentWidth(): number;
+
+    public getTrackSize(): number;
+
+}
+
+declare function columns(): void;
+
+declare function elem(): number;
+
+export default HScrollbar;
+export { HScrollbar };

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

@@ -0,0 +1,222 @@
+/* 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}
+*/
+var HScrollbar = function () {
+	var t = this; // Create a shorthand to shorthen file size
+	t._vertical = false;
+	t._onDeactivated = t._onDeactivated.bind(t);
+	t._onActivated = t._onActivated.bind(t);
+	t._hostClassName = "hscrollbar-host";
+	HScrollbar.base(this, 'constructor'); // Call base constructor
+
+	// Styling
+	t._element.classList.add("grid-hscroll");
+	t._trackContent.style.height = "1px";
+
+	t.disableMouseWheel(false); // Mousewheel for horizontal scrollbar is enabled by default
+
+	t.listen("activated", t._onActivated);
+	t.listen("deactivated", t._onDeactivated);
+};
+Ext.inherits(HScrollbar, Scrollbar);
+
+/** @type {number}
+* @private
+*/
+HScrollbar.prototype._pinnedRightColumnCount = 0;
+
+/** For internal use only
+* @public
+* @ignore
+* @param {ElementWrapper} grid Grid object is not used in this case
+* @param {!Array.<ElementWrapper>} sections
+* @param {number} startColIndex
+* @param {number=} pinnedRightColumn Number of pinned columns on the right side
+*/
+HScrollbar.prototype.setScrollContent = function (grid, sections, startColIndex, pinnedRightColumn) {
+	this._clearAllPanes();
+
+	var sectionCount = sections.length;
+	if(sectionCount <= 0) { return; }
+
+	this._pinnedRightColumnCount = pinnedRightColumn > 0 ? pinnedRightColumn : 0;
+	var section = sections[0];
+	var colCount = section.getColumnCount();
+	var endColIndex = colCount - pinnedRightColumn; // WARNING: If number of pinned column is greater than the scrollable range, the pinning will not be applied
+	if(!endColIndex || endColIndex < 0) {
+		endColIndex = colCount;
+	}
+
+	// Insert panes in the correct slot
+	for (var s = 0; s < sectionCount; ++s) {
+		section = sections[s];
+
+		var pane = this._addPaneAt(s);
+		var paneSlider = this._paneSliders[s];
+		var paneElem = pane.getElement();
+		var sliderElem = paneSlider.getElement();
+
+		paneElem.classList.toggle("right-pinning", this._pinnedRightColumnCount ? true : false);
+
+		var c;
+		var column;
+		for (c = 0; c < startColIndex; ++c) {
+			column = /** @type{Column} */(section.getColumn(c));
+			column.setScrollState(paneElem, null, false);
+		}
+		pane.setParent(section.getColumnHost());
+		var columns = [];
+		var content = [];
+		for (c = startColIndex; c < endColIndex; ++c) {
+			column = /** @type{Column} */(section.getColumn(c));
+			column.setScrollState(null, sliderElem, this.isActive());
+
+			columns.push(column);
+			content.push(column.getElement());
+		}
+		for (c = endColIndex; c < colCount; ++c) {
+			column = /** @type{Column} */(section.getColumn(c));
+			column.setScrollState(null, null, false);
+		}
+
+		var rs = section.getReservedSpace();
+		if(rs) {
+			if(!this._pinnedRightColumnCount) {
+				paneSlider.addContent(rs);
+				content.push(rs);
+			}
+			section._updateRightSpaceStyle(this.isActive() && !this._pinnedRightColumnCount);
+		}
+		section._updateLayers(); // Order of the layers may be changed due to change in rightspace and/or column pinning
+		paneSlider._titleSection = section.getElement().classList.contains("title"); // To cache virtualized title section
+		paneSlider._columns = columns; // To cache virtualized columns
+		paneSlider._content = content; // To cache virtualized columns
+	}
+	this.invalidateContent(); // Delay content update
+};
+
+/** @override
+*/
+HScrollbar.prototype.setWidth = function (val) {
+	this.setTrackSize(val, val);
+	return true;
+};
+/** @override
+*/
+HScrollbar.prototype.getWidth = function () {
+	return this.getPaneSize(); // Track size may not represent what the client want
+};
+
+/** @override */
+HScrollbar.prototype.getScrollLeft = function () {
+	return this._getScrollValue();
+};
+/** @public
+* @param {number} px
+*/
+HScrollbar.prototype.setScrollLeft = function (px) {
+	this.update();
+	this._scrollTo(px); // "scroll" event may be fired
+};
+
+/** @public
+* @ignore
+* @param {number} val
+*/
+HScrollbar.prototype.setPaneLeft = function (val) {
+	var px = val && this.isActive() ? (-val + "px") : "";
+	for (var i = this._panes.length; --i >= 0; ) {
+		this._paneSliders[i].setStyle("marginLeft", px);
+	}
+};
+
+/** @public
+* @override
+* @return {boolean}
+*/
+HScrollbar.prototype.isEndOfHorizontalScroll = function () {
+	return this._isEndOfScroll();
+};
+/** @public
+* @return {number}
+*/
+HScrollbar.prototype.getContentWidth = function () {
+	var paneSlider = this._paneSliders[0]; // Get content width from the first pane slider
+	var sum = 0;
+	if (paneSlider) {
+		var colList = /** @type{Array} */(paneSlider._content);
+		for (var i = colList.length; --i >= 0; ) {
+			var elem = colList[i];
+			var width = elem ? elem.style.width : 0; // HACK
+			if(width) {
+				sum += parseFloat(width); // TODO: parseFloat is not fast
+			}
+		}
+	}
+	return sum;
+};
+/** @override
+* @protected
+* @return {number}
+*/
+HScrollbar.prototype.calculateContentSize = function () {
+	return this.getContentWidth();
+};
+
+/** Horizontal scrollbar will be shrunk if vertical scrollbar exists at the same time
+* @override
+* @public
+* @return {number}
+*/
+HScrollbar.prototype.getTrackSize = function () {
+	// Horizontal scrollbar may be overlap with vertical scrollbar
+	if(this._footerCount <= 0) { // Horizontal scrollbar is NOT on top of a footer section and may be overlap
+		if(this._otherScrollbar) { // The other scrollbar exists
+			if(this._otherScrollbar.isActive() && !this._pinnedRightColumnCount) { // The other scrollbar is active and hence it is overlap with this scrollbar
+				return this._trackSize - this.getTrackThickness();
+			}
+		}
+	}
+	return this._trackSize;
+};
+
+/** @private
+* @param {Object} e
+*/
+HScrollbar.prototype._onActivated = function (e) {
+	this._updateActivation(true);
+};
+/** @private
+* @param {Object} e
+*/
+HScrollbar.prototype._onDeactivated = function (e) {
+	this._updateActivation(false);
+};
+/** @private
+* @param {boolean} bool
+*/
+HScrollbar.prototype._updateActivation = function (bool) {
+	var sectCount = this._paneSliders.length;
+	for(var s = 0; s < sectCount; ++s) {
+		var paneSlider = this._paneSliders[s];
+		var columns = paneSlider._columns;
+		var colCount = columns ? columns.length : 0;
+		for(var c = 0; c < colCount; ++c) {
+			var column = columns[c];
+			if(column.getElement()) { // Column may have been disposed
+				column.enableAbsolutePosition(bool);
+			}
+		}
+	}
+};
+
+HScrollbar._proto = HScrollbar.prototype;
+
+export default HScrollbar;
+export { HScrollbar };

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

@@ -0,0 +1,61 @@
+import Ext from "../../../../tr-grid-util/es6/Ext.js";
+import Util from "../util/util.js";
+import ElementWrapper from "../components/ElementWrapper.js";
+import Reverter from "../util/Reverter.js";
+
+declare class Scrollbar extends ElementWrapper {
+
+    constructor();
+
+    public static updateTrackThickness(): void;
+
+    public attachToExternalElement(host: Element|Node): void;
+
+    public isActive(): boolean;
+
+    public isEnabled(): boolean;
+
+    public enable(opt_enabled?: boolean): void;
+
+    public disable(opt_disabled?: boolean): void;
+
+    public getTrackSize(): number;
+
+    public getContentSize(): number;
+
+    public getTrackThickness(): number;
+
+    public getScrollGap(): number;
+
+    public setTrackSize(size: number, paneSize: number): void;
+
+    public update(): boolean;
+
+    public flash(): void;
+
+    public disableKeyboardInput(opt_disabled?: boolean): void;
+
+    public disableTouchInput(opt_disabled?: boolean): void;
+
+    public setAutoHide(hide: boolean): void;
+
+    public getAutoHide(): boolean;
+
+    public disableMouseWheel(opt_disabled?: boolean): void;
+
+    public addWheelListener(elem: Element): void;
+
+    public removeWheelListener(elem: Element): void;
+
+    public setMouseWheelSpeed(val: string): void;
+
+    public getDefaultMouseWheelLogic(): ((...params: any[]) => any);
+
+    public setScrollingStep(px: number): void;
+
+    public freezeScrolling(frozen?: boolean): boolean;
+
+}
+
+export default Scrollbar;
+export { Scrollbar };