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

package/lib/tr-grid-printer/es6/PrintTrait.d.ts

@@ -0,0 +1,38 @@
+import { Ext } from "../../tr-grid-util/es6/Ext.js";
+import { EventDispatcher } from "../../tr-grid-util/es6/EventDispatcher.js";
+
+declare class PrintTrait {
+
+    constructor();
+
+    public static readonly DEBUG: boolean;
+
+    public static calculateEnvironment(): any;
+
+    public observe(iframeElement?: HTMLIFrameElement): void;
+
+    public unobserve(): void;
+
+    public isObserving(): boolean;
+
+    public dispose(): void;
+
+    public print(): void;
+
+    public _print(): void;
+
+    public static createBlankPages(pageCount: number): Element;
+
+    public createClientBox(pw: number, ph: number): Element;
+
+    public enablePaperSizeCorrection(enabled: boolean): void;
+
+    public fixPaperSize(enabled: boolean): void;
+
+    public getDocumentElement(): Element|null;
+
+    public getBodyElement(): Element|null;
+
+}
+
+export { PrintTrait };

package/lib/tr-grid-printer/es6/PrintTrait.js

@@ -0,0 +1,481 @@
+import { Ext } from "../../tr-grid-util/es6/Ext.js";
+import { EventDispatcher } from "../../tr-grid-util/es6/EventDispatcher.js";
+
+/** @event PrintTrait#beforeprint
+* @description Triggered before the printing and print preview.
+* @property {number} pageWidth Width of the print page
+* @property {number} pageHeight Height of the print page
+*/
+/** @event PrintTrait#afterprint
+* @description Triggered after the printing is completed or canceled. This event is fired only once at the end of printing
+* @property {number} pageWidth Width of the current client window (not the print page)
+* @property {number} pageHeight Height of the current client window (not the print page)
+*/
+/** @event PrintTrait#pageCounting
+* @description Triggered before actual print command and {@link PrintTrait#beforeprint} event.<br>
+* Used mainly for setting number of rendered pages for the preview dialog<br>
+* Page counting must be done before triggering browser's preview dialog, because we cannot change number of rendered pages, while the dialog is opened.<br>
+* Note that given paper size is NOT from the print device.
+* @property {number} pageWidth=739 Width of portrait "letter" paper type (739px)
+* @property {number} pageHeight=978 Height of portrait "letter" paper type (978px)
+*/
+
+/** PrintTrait simplify print process to 2 simple events ("beforeprint" and "afterprint").<br>
+* PrintTrait works by intercepting Window's print call and preparing the necessary information.
+* @constructor
+* @extends{EventDispatcher}
+* @suppress {checkTypes}
+*/
+var PrintTrait = function() {
+	var t = this;
+	t._onKeyDown = t._onKeyDown.bind(t);
+	t._onMediaQuery = t._onMediaQuery.bind(t);
+	t._onBeforePrint = t._onBeforePrint.bind(t);
+	t._onAfterPrint = t._onAfterPrint.bind(t);
+	t._onPrintEnd = t._onPrintEnd.bind(t);
+	t._print = t._print.bind(t);
+	t.print = t.print.bind(t);
+	t._eventArg = {};
+
+	PrintTrait.calculateEnvironment();
+};
+Ext.inherits(PrintTrait, EventDispatcher);
+
+/** @type {number}
+* @private
+*/
+var IDLE = 0;
+/** @type {number}
+* @private
+*/
+var COUNTING = 1;
+/** @type {number}
+* @private
+*/
+var BEFORE_PRINT = 2;
+/** @type {number}
+* @private
+*/
+var AFTER_PRINT = 3;
+
+/** @type {number}
+* @private
+*/
+PrintTrait.prototype._defaultWidth = 739;
+/** @type {number}
+* @private
+*/
+PrintTrait.prototype._defaultHeight = 978;
+/** @type {Window}
+* @private
+*/
+PrintTrait.prototype._window = null;
+/** @type {Function}
+* @private
+*/
+PrintTrait.prototype._defaultPrint = null;
+/** @type {Object}
+* @private
+*/
+PrintTrait.prototype._eventArg = null;
+/** @type {MediaQueryList}
+* @private
+*/
+PrintTrait.prototype._printMedia = null;
+/** @type {boolean}
+* @private
+*/
+PrintTrait.prototype._correction = false;
+/** @type {boolean}
+* @private
+*/
+PrintTrait.prototype._fixedSize = false;
+/** @type {number}
+* @private
+*/
+PrintTrait.prototype._state = IDLE;
+/** @type {number}
+* @private
+*/
+PrintTrait.prototype._timerId = 0;
+/** @type {boolean}
+* @public
+*/
+PrintTrait.DEBUG = false;
+/** @type {Element}
+* @private
+*/
+PrintTrait._debugBtn = null;
+
+
+/** @type {Object}
+* @private
+*/
+PrintTrait._env = {};
+/** @public
+* @function
+* @return {Object}
+*/
+PrintTrait.calculateEnvironment = function() {
+	var env = PrintTrait._env;
+	var ua = navigator.userAgent;
+	var jet = window["JET"];
+	var cd = jet ? jet["ContainerDescription"] : "";
+
+	env.isMac = /Mac/.test(navigator.platform);
+	env.isIE = (ua.indexOf("MSIE ") > 0) || (ua.indexOf("Trident/")  > 0) || (ua.indexOf("Edge/")  > 0);
+	env.isEikonDesktop = cd ? cd["name"] === "Thomson Reuters Eikon" : false;
+	return env;
+};
+
+/** @public
+* @param {HTMLIFrameElement=} iframeElement If not specified, current window is used instead. Specify null to un-observe existing window object.
+* @suppress {checkTypes}
+*/
+PrintTrait.prototype.observe = function(iframeElement) {
+	if(this._state > IDLE && this._state < AFTER_PRINT) {
+		console.warn("Cannot observe another window object while printing process is running.");
+		return;
+	}
+
+	var winObj = null;
+
+	if(iframeElement) {
+		if(iframeElement.contentWindow) {
+			winObj = /** @type{Window} */(iframeElement.contentWindow);
+		}
+	}
+	// eslint-disable-next-line
+	else if (iframeElement === undefined) {
+		winObj = /** @type{Window} */(window);
+	}
+
+	if(this._window === winObj) {
+		return;
+	}
+
+	if(this._window) {
+		this._window.print = this._defaultPrint; // Restore native print() method
+		this._defaultPrint = null;
+
+		this._window.removeEventListener("keydown", this._onKeyDown, false);
+		this._window.removeEventListener("afterprint", this._onAfterPrint, false);
+		this._window = null;
+
+		if(this._printMedia) {
+			this._printMedia.removeListener(this._onMediaQuery);
+			this._printMedia = null;
+		}
+	}
+
+	this._window = winObj;
+
+	if(winObj) {
+		this._defaultPrint = winObj.print;
+
+		winObj.print = this.print; // WARNING: Override native print() method
+		winObj.addEventListener("keydown", this._onKeyDown, false);
+		winObj.addEventListener("afterprint", this._onAfterPrint, false);
+
+		this._printMedia = winObj.matchMedia("print");
+		if(this._printMedia) {
+			this._printMedia.addListener(this._onMediaQuery);
+		}
+	}
+};
+/** @public
+*/
+PrintTrait.prototype.unobserve = function() {
+	this.observe(null);
+};
+/** @public
+* @return {boolean}
+*/
+PrintTrait.prototype.isObserving = function() {
+	return this._window ? true : false;
+};
+
+/** @public
+* @suppress {checkTypes}
+*/
+PrintTrait.prototype.dispose = function() {
+	this.removeAllEventlisteners();
+
+	if(this._timerId) {
+		clearTimeout(this._timerId);
+	}
+
+	this._onPrintEnd(); // Force ending the process
+	this.unobserve();
+	this._eventArg = null;
+};
+/** @public
+*/
+PrintTrait.prototype.print = function() {
+	if(!this._window) {
+		console.error("Cannot perform printing. Window object must be specified by using observe() method.");
+		return;
+	}
+	if(this._state !== IDLE) {
+		console.warn("Cannot initiate another printing command while another printing process is running.");
+		return;
+	}
+	this._state = COUNTING;
+	if(PrintTrait._env.isEikonDesktop) { // DPI is reduced in Eikon Desktop
+		this._defaultWidth = 672; // 692 for letter width
+		this._defaultHeight = 917;
+	} else {
+		this._defaultWidth = 717; // A4 safe width
+		this._defaultHeight = 978; // letter safe height
+	}
+	this._eventArg["pageWidth"] = this._defaultWidth;
+	this._eventArg["pageHeight"] = this._defaultHeight;
+	this._eventArg["documentElement"] = this.getDocumentElement();
+	this._eventArg["bodyElement"] = this.getBodyElement();
+	this.getDocumentElement().classList.add("tr-printing-mode");
+	this._dispatch("pageCounting", this._eventArg);
+
+	if(PrintTrait.DEBUG) {
+		var debugBtn = PrintTrait._debugBtn = document.createElement("button");
+		debugBtn.addEventListener("click", this._onBeforePrint);
+		debugBtn.textContent = "BeforePrint";
+		debugBtn.style.display = "unset";
+		debugBtn.style.position = "fixed";
+		debugBtn.style.width = "100px";
+		debugBtn.style.left = "50%";
+		debugBtn.style.transform = "translateX(-50%)";
+		debugBtn.style.top = "20px";
+		document.body.appendChild(debugBtn);
+	} else {
+		/**
+		 * _onBeforePrint() was originally execute by window 'beforeprint' event.
+		 * Due to Custom Elements can't be create during 'beforeprint', _onBeforePrint() needs to be executed manually.
+		 * And window.print() need to be executed after some delay to make sure Custom Elements are created and rendered.
+		 * See here: https://html.spec.whatwg.org/multipage/custom-elements.html#custom-element-reactions
+		 */
+		this._onBeforePrint();
+		setTimeout(this._print, 500);
+	}
+};
+/** @public
+*/
+PrintTrait.prototype._print = function() {
+	this._defaultPrint.call(this._window);
+};
+/** @public
+* @param {number} pageCount
+* @return {!Element}
+*/
+PrintTrait.createBlankPages = function(pageCount) {
+	var rootElem = document.createElement("div");
+	for(var i = 0; i < pageCount; ++i) {
+		var bp = document.createElement("div");
+		if(PrintTrait.DEBUG) {
+			bp.textContent = "Page " + (i + 1);
+		} else {
+			bp.className = "tr-blank-page";
+		}
+		rootElem.appendChild(bp);
+	}
+	rootElem.style.display = "block"; // This will beat any CSS selector
+	return rootElem;
+};
+/** @public
+* @param {number} pw Page width
+* @param {number} ph Page height
+* @return {!Element}
+*/
+PrintTrait.prototype.createClientBox = function(pw, ph) {
+	var rootElem = document.createElement("div");
+	var styObj = rootElem.style;
+	styObj.width = pw + "px";
+	styObj.height = ph + "px";
+
+	styObj.display = "block";
+	styObj.border = "2px solid red";
+	styObj.boxSizing = "border-box";
+
+	styObj.fontSize = "3em";
+	rootElem.textContent = pw + " x " + ph;
+	return rootElem;
+};
+/** @public
+* @param {boolean} enabled
+*/
+PrintTrait.prototype.enablePaperSizeCorrection = function(enabled) {
+	this._correction = (enabled !== false);
+};
+/** @public
+* @param {boolean} enabled
+*/
+PrintTrait.prototype.fixPaperSize = function(enabled) {
+	this._fixedSize = (enabled !== false);
+};
+/** @public
+* @return {Element|null} html tag element
+*/
+PrintTrait.prototype.getDocumentElement = function() {
+	return this._window.document.documentElement || null;
+};
+/** @public
+* @return {Element|null} body tag element
+*/
+PrintTrait.prototype.getBodyElement = function() {
+	return this._window.document.body || null;
+};
+
+
+/** @private
+* @param {KeyboardEvent} e
+*/
+PrintTrait.prototype._onKeyDown = function(e) {
+	var ctrlCmdKey = PrintTrait._env.isMac ? e.metaKey : e.ctrlKey;
+
+	if(ctrlCmdKey) {
+		if(!e.altKey) {
+			if(e.keyCode === 80) { // P
+				e.preventDefault();
+				e.stopPropagation();
+				this.print();
+			}
+		}
+	}
+};
+/** @private
+* @param {Object} e
+*/
+PrintTrait.prototype._onMediaQuery = function(e) {
+	if (e["matches"]) {
+		this._onBeforePrint();
+	} else {
+		this._onAfterPrint();
+	}
+};
+/** @private
+* @param {Object=} e
+*/
+PrintTrait.prototype._onBeforePrint = function(e) {
+	if(this._state < BEFORE_PRINT) {
+		this._state = BEFORE_PRINT;
+		this._calculatePageSize(this._correction, this._fixedSize);
+
+
+		this._eventArg["documentElement"] = this.getDocumentElement();
+		this._eventArg["bodyElement"] = this.getBodyElement();
+		this.getDocumentElement().classList.add("tr-printing-mode");
+		this._dispatch("beforeprint", this._eventArg);
+
+		if(PrintTrait.DEBUG) {
+			var debugBtn = PrintTrait._debugBtn;
+			debugBtn.removeEventListener("click", this._onBeforePrint);
+			debugBtn.addEventListener("click", this._onAfterPrint);
+			debugBtn.textContent = "AfterPrint";
+		}
+	}
+};
+/** @private
+* @param {Object=} e
+*/
+PrintTrait.prototype._onAfterPrint = function(e) {
+	if(this._state < AFTER_PRINT) {
+		this._state = AFTER_PRINT;
+		this._calculatePageSize();
+
+		this.getDocumentElement().classList.remove("tr-printing-mode");
+		this._dispatch("afterprint", this._eventArg);
+		this._timerId = setTimeout(this._onPrintEnd, 0);
+
+		if (PrintTrait._debugBtn) { // For debugging
+			var pn = PrintTrait._debugBtn.parentNode;
+			if(pn) {
+				pn.removeChild(PrintTrait._debugBtn);
+			}
+			PrintTrait._debugBtn = null;
+		}
+	}
+};
+/** @private
+*/
+PrintTrait.prototype._onPrintEnd = function() {
+	this._timerId = 0;
+	this._state = IDLE;
+};
+/** @private
+* @param {boolean=} sizeCorrection
+* @param {boolean=} fixedSize
+* @return {boolean} True if there is any change
+*/
+PrintTrait.prototype._calculatePageSize = function(sizeCorrection, fixedSize) {
+	if(PrintTrait._env.isIE) {
+		return false; // Cannot calculate paper size in IE
+	}
+	var documentElement = this.getDocumentElement();
+	var cw = documentElement.clientWidth;
+	var	iw = this._window.innerWidth || 0;
+	var ch = documentElement.clientHeight;
+	var	ih = this._window.innerHeight || 0;
+	var nw = (cw >= iw) ? cw : iw;
+	var nh = (ch >= ih) ? ch : ih;
+
+	if(fixedSize) {
+		if(nw > nh) {
+			nw = this._defaultHeight;
+			nh = this._defaultWidth;
+		} else {
+			nw = this._defaultWidth;
+			nh = this._defaultHeight;
+		}
+	} else if(sizeCorrection) {
+		var portrait = nh >= nw;
+		var ar = this._calculateAspectRatio(nw, nh);
+		var paperSize = PrintTrait._paperSizes[ar];
+		if(!paperSize) {
+			paperSize = PrintTrait._paperSizes[ar - 1] || PrintTrait._paperSizes[ar + 1];
+		}
+		if(paperSize) {
+			if(portrait) {
+				nw = paperSize[0];
+				nh = paperSize[1];
+			} else {
+				nh = paperSize[0];
+				nw = paperSize[1];
+			}
+		}
+	}
+
+	if(this._eventArg["pageWidth"] !== nw || this._eventArg["pageHeight"] !== nh) {
+		this._eventArg["pageWidth"] = nw;
+		this._eventArg["pageHeight"] = nh;
+		return true;
+	}
+	return false;
+};
+
+/** @private
+* @param {number} w width
+* @param {number} h height
+* @return {number}
+*/
+PrintTrait.prototype._calculateAspectRatio = function(w, h) {
+	var portrait = h >= w;
+	var ratio = (portrait) ? w / h : h / w;
+	return Math.floor(ratio * 1000); // Return 3 digit precision
+};
+
+/** @private
+* @type {Object.<number, Array.<number>>}
+*/
+PrintTrait._paperSizes = {
+	702: [3101, 4414], // "A0"
+	699: [2168, 3100], // "A1"
+	697: [1511, 2167], // "A2"
+	692: [1046, 1511], // "A3"
+	685: [717, 1046], // "A4"
+	674: [483, 715], // "A5"
+	583: [739, 1266], // "legal"
+	755: [739, 978], // "letter"
+	629: [979, 1554]  // "tabloid"
+};
+
+
+export { PrintTrait };

package/lib/tr-grid-printer/es6/SectionWriter.d.ts

@@ -0,0 +1,54 @@
+import { Ext } from "../../tr-grid-util/es6/Ext.js";
+import { ElementWrapper } from "../../tr-grid-util/es6/ElementWrapper.js";
+import { Table } from "../../tr-grid-util/es6/Table.js";
+import { CellWriter } from "./CellWriter.js";
+
+declare class SectionWriter extends ElementWrapper {
+
+    constructor();
+
+    public getFirstIndexInView(): number;
+
+    public getLastIndexInView(): number;
+
+    public getColumnCount(): number;
+
+    public getColumn(colIndex: number): any;
+
+    public setColumnCount(val: number): void;
+
+    public getRowCount(): number;
+
+    public setRowCount(val: number): void;
+
+    public getCell(colIndex: number, rowIndex: number): CellWriter;
+
+    public getCellContent(colIndex: number, rowIndex: number): Element|Node|NodeList;
+
+    public setCellContent(colIndex: number, rowIndex: number, data: string|Element|any|any): void;
+
+    public enableRowClass(rowIndex: number, className: string, enabled: boolean): void;
+
+    public stretchCell(colIndex: number, rowIndex: number, opt_stretching?: boolean, opt_noLeftStretching?: boolean): void;
+
+    public hasCellSpan(): boolean;
+
+    public getCellRowSpan(colIndex: number, rowIndex: number): number;
+
+    public setCellRowSpan(colIndex: number, rowIndex: number, rowSpan: number): void;
+
+    public getCellColSpan(colIndex: number, rowIndex: number): number;
+
+    public setCellColSpan(colIndex: number, rowIndex: number, colSpan: number): void;
+
+    public clearCellSpans(): void;
+
+    public clearColumnSpans(colIndex: number): void;
+
+    public isColumnActive(colIndex: number): boolean;
+
+    public getCellElement(colIndex: number, rowIndex: number): Element;
+
+}
+
+export { SectionWriter };