@refinitiv-ui/efx-grid 6.0.30 → 6.0.32

package/lib/tr-grid-content-wrap/es6/ContentWrap.js

@@ -17,7 +17,7 @@ import { GridPlugin } from '../../tr-grid-util/es6/GridPlugin.js';
 var ContentWrapPlugin = function ContentWrapPlugin() {
   this._onColumnAdded = this._onColumnAdded.bind(this);
   this._onRecalculation = this._onRecalculation.bind(this);
-  this._setReCalculationTimer = this._setReCalculationTimer.bind(this);
+  this._requestRecalculation = this._requestRecalculation.bind(this);
   this._hosts = [];
 };
 
@@ -77,10 +77,10 @@ ContentWrapPlugin.prototype.initialize = function (host, options) {
 
   this._hosts.push(host);
 
-  window.addEventListener("load", this._setReCalculationTimer); // Since CSS can impact font, we need adjust accordingly
+  window.addEventListener("load", this._requestRecalculation); // Since CSS can impact font, we need adjust accordingly
 
-  host.listen("widthChanged", this._setReCalculationTimer);
-  host.listen("postSectionDataBinding", this._setReCalculationTimer); // In case of lazy loading
+  host.listen("widthChanged", this._requestRecalculation);
+  host.listen("postSectionDataBinding", this._requestRecalculation); // In case of lazy loading
 
   this.config(options);
   host.listen("columnAdded", this._onColumnAdded);
@@ -99,11 +99,13 @@ ContentWrapPlugin.prototype.unload = function (host) {
 
   this._hosts.splice(at, 1);
 
-  window.removeEventListener("load", this._setReCalculationTimer);
-  host.unlisten("widthChanged", this._setReCalculationTimer);
-  host.unlisten("postSectionDataBinding", this._setReCalculationTimer);
+  window.removeEventListener("load", this._requestRecalculation);
+  host.unlisten("widthChanged", this._requestRecalculation);
+  host.unlisten("postSectionDataBinding", this._requestRecalculation);
   host.unlisten("columnAdded", this._onColumnAdded);
 
+  this._dispose();
+
   this._clearTimer();
 };
 /** @public
@@ -182,7 +184,7 @@ ContentWrapPlugin.prototype.getConfigObject = function (gridOptions) {
 
 
 ContentWrapPlugin.prototype.adjustRowHeight = function (sectionRef, from, to) {
-  if (this._adjusting || this._hosts.length === 0) {
+  if (this._adjusting || !this._hosts.length) {
     return false; // Quite if grid has not been registered or in the process of adjusting row height
   }
 
@@ -198,17 +200,30 @@ ContentWrapPlugin.prototype.adjustRowHeight = function (sectionRef, from, to) {
     return false;
   }
 
+  var sectionElem = section.getElement();
+
+  if (!sectionElem || !sectionElem.offsetParent) {
+    return false;
+  }
+
   this._adjusting = true; // Prevent infinite loop
 
   var dirtyRows = []; // Collect dirty rows
 
-  var results = this._calculateRowHeight(section, from, to, dirtyRows); // Setting row height for multiple rows can cause performance issue
+  var maxHeight = NaN;
+  var heights = null;
 
+  if (this._evenRowHeight) {
+    maxHeight = this._calcMaxRowHeight(section, dirtyRows, from, to);
+  } else {
+    heights = this._calcRowHeights(section, dirtyRows, from, to);
+  } // Setting row height for multiple rows can cause performance issue
 
-  var rowCount = dirtyRows.length;
+
+  var dirtyCount = dirtyRows.length;
   var prevFState = false;
 
-  if (rowCount > this._freezingThreshold) {
+  if (dirtyCount > this._freezingThreshold) {
     if (section.getFrozenLayout) {
       prevFState = section.getFrozenLayout();
       section.setFrozenLayout(true);
@@ -219,29 +234,25 @@ ContentWrapPlugin.prototype.adjustRowHeight = function (sectionRef, from, to) {
   var r, rowIndex;
 
   if (this._evenRowHeight) {
-    var max = results["max"];
-
-    for (r = 0; r < rowCount; ++r) {
+    for (r = 0; r < dirtyCount; ++r) {
       rowIndex = dirtyRows[r];
-      section.setRowHeight(rowIndex, max);
+      section.setRowHeight(rowIndex, maxHeight);
     }
   } else {
-    var heights = results["heights"];
-
-    for (r = 0; r < rowCount; ++r) {
+    for (r = 0; r < dirtyCount; ++r) {
       rowIndex = dirtyRows[r];
       section.setRowHeight(rowIndex, heights[rowIndex]);
     }
   }
 
-  if (rowCount > this._freezingThreshold) {
+  if (dirtyCount > this._freezingThreshold) {
     if (section.setFrozenLayout) {
       section.setFrozenLayout(prevFState);
     }
   }
 
   this._adjusting = false;
-  return rowCount ? true : false;
+  return dirtyCount ? true : false;
 };
 /** @public
 * @param {Object} sectionRef core grid SectionReference object
@@ -300,8 +311,8 @@ ContentWrapPlugin.prototype._setColumnContentWrapping = function (colIndex, colu
 /** @private */
 
 
-ContentWrapPlugin.prototype._setReCalculationTimer = function () {
-  if (!this._recalTimer) {
+ContentWrapPlugin.prototype._requestRecalculation = function () {
+  if (!this._recalTimer && !this._adjusting) {
     this._recalTimer = setTimeout(this._onRecalculation, 100);
   }
 };
@@ -328,7 +339,7 @@ ContentWrapPlugin.prototype._clearTimer = function () {
 
 
 ContentWrapPlugin.prototype._getSteppingHeight = function (height) {
-  return Math.floor(height + 1) + 12; // Add top and bottom padding
+  return Math.ceil(height) + 14; // Add top and bottom padding
 };
 /** @private
 * @param {Object} section ILayoutGrid
@@ -343,25 +354,31 @@ ContentWrapPlugin.prototype._calculateRowHeightAt = function (section, rowIndex)
   var colCount = section.getColumnCount();
 
   for (var c = 0; c < colCount; ++c) {
-    if (this.isWrappingContent(c)) {
-      var cell = section.getCell(c, rowIndex, false); // TODO: Handle cell spanning
+    if (!this.isWrappingContent(c)) {
+      continue;
+    }
 
-      if (cell && cell.isVisible()) {
-        var cellContent = cell.getContent();
+    var cell = section.getCell(c, rowIndex, false); // TODO: Handle cell spanning
 
-        if (cellContent) {
-          if (!cellContent.offsetParent) {
-            // Cell content is not in the document, so the height cannot be calculated
-            return NaN;
-          }
+    if (!cell || !cell.isVisible()) {
+      continue;
+    }
 
-          var contentHeight = this._getSteppingHeight(cellContent.offsetHeight);
+    var cellContent = cell.getContent();
 
-          if (contentHeight > maxHeight) {
-            maxHeight = contentHeight;
-          }
-        }
-      }
+    if (!cellContent) {
+      continue;
+    }
+
+    if (!cellContent.offsetParent) {
+      // Cell content is not in the document, so the height cannot be calculated
+      continue;
+    }
+
+    var contentHeight = this._getSteppingHeight(cellContent.offsetHeight);
+
+    if (contentHeight > maxHeight) {
+      maxHeight = contentHeight;
     }
   }
 
@@ -369,61 +386,90 @@ ContentWrapPlugin.prototype._calculateRowHeightAt = function (section, rowIndex)
 };
 /** @private
 * @param {Object} section ILayoutGrid
+* @param {!Array.<number>} dirtyRows
 * @param {number=} from
 * @param {number=} to
-* @param {Array.<number>=} opt_dirtyRows
-* @return {!Object}
+* @return {number}
 */
 
 
-ContentWrapPlugin.prototype._calculateRowHeight = function (section, from, to, opt_dirtyRows) {
-  if (!from || from < 0) {
+ContentWrapPlugin.prototype._calcMaxRowHeight = function (section, dirtyRows, from, to) {
+  if (from == null) {
+    from = section.getFirstIndexInView();
+  } else if (!from || from < 0) {
     from = 0;
   }
 
-  var rowCount = section.getRowCount();
+  if (to == null) {
+    to = section.getLastIndexInView() + 1;
+  } else {
+    var rowCount = section.getRowCount();
 
-  if (!to || to > rowCount) {
-    to = rowCount;
+    if (!to || to > rowCount) {
+      to = rowCount;
+    }
   }
 
-  var r, h;
-  var results = {};
+  var r;
+  var max = 0;
 
-  if (this._evenRowHeight) {
-    var max = 0;
-
-    for (r = from; r < to; ++r) {
-      h = this._calculateRowHeightAt(section, r);
+  for (r = from; r < to; ++r) {
+    var h = this._calculateRowHeightAt(section, r);
 
-      if (max < h) {
-        max = h;
-      }
+    if (max < h) {
+      max = h;
     }
+  }
 
-    results["max"] = max;
-
+  if (max) {
     for (r = from; r < to; ++r) {
-      if (max && opt_dirtyRows && max !== section.getRowHeight(r)) {
-        opt_dirtyRows.push(r);
+      if (max !== section.getRowHeight(r)) {
+        dirtyRows.push(r);
       }
     }
-  } else {
-    var heights = new Array(to);
+  }
 
-    for (r = from; r < to; ++r) {
-      h = this._calculateRowHeightAt(section, r);
-      heights[r] = h;
+  return max;
+};
+/** @private
+* @param {Object} section ILayoutGrid
+* @param {!Array.<number>} dirtyRows
+* @param {number=} from
+* @param {number=} to
+* @return {!Array.<number>}
+*/
 
-      if (h && opt_dirtyRows && h !== section.getRowHeight(r)) {
-        opt_dirtyRows.push(r);
-      }
+
+ContentWrapPlugin.prototype._calcRowHeights = function (section, dirtyRows, from, to) {
+  if (from == null) {
+    from = section.getFirstIndexInView();
+  } else if (!from || from < 0) {
+    from = 0;
+  }
+
+  if (to == null) {
+    to = section.getLastIndexInView() + 1;
+  } else {
+    var rowCount = section.getRowCount();
+
+    if (!to || to > rowCount) {
+      to = rowCount;
     }
+  }
+
+  var heights = new Array(to);
 
-    results["heights"] = heights;
+  for (var r = from; r < to; ++r) {
+    var h = this._calculateRowHeightAt(section, r);
+
+    heights[r] = h;
+
+    if (h && h !== section.getRowHeight(r)) {
+      dirtyRows.push(r);
+    }
   }
 
-  return results;
+  return heights;
 };
 /** @private
 * @param {number} colIndex
@@ -434,7 +480,7 @@ ContentWrapPlugin.prototype._calculateRowHeight = function (section, from, to, o
 ContentWrapPlugin.prototype._wrapContent = function (colIndex, bool) {
   this._hosts[0].enableColumnClass(colIndex, "wrap", bool, "content");
 
-  this._setReCalculationTimer();
+  this._requestRecalculation();
 };
 /** @public
 * @param {number} colIndex

package/lib/tr-grid-row-dragging/es6/RowDragging.d.ts

@@ -39,7 +39,7 @@ declare class RowDraggingPlugin extends GridPlugin {
 
     public getConfigObject(out_obj?: any): any;
 
-    public startDrag(startRef: any, opt_suppressEvent?: boolean|null): void;
+    public startDrag(startRef?: any): void;
 
     public stopDrag(): void;
 
@@ -53,6 +53,28 @@ declare class RowDraggingPlugin extends GridPlugin {
 
     public disableUIs(disabled?: boolean|null): void;
 
+    public allowDrag(allowed?: boolean|null): void;
+
+    public allowDrop(allowed?: boolean|null): void;
+
+    public setDragContent(content: any): void;
+
+    public getDragBox(): Element|null;
+
+    public getDragSource(): string;
+
+    public isDragging(): boolean;
+
+    public disableDragging(disabled?: boolean|null): void;
+
+    public enableJETDragAndDrop(enabled?: boolean|null): void;
+
+    public getJETDragContent(): any;
+
+    public setJETDragContent(content: any): void;
+
+    public setJETDragContent(content: any): void;
+
 }
 
 export default RowDraggingPlugin;