handsontable 0.0.0-next-baf2fcf-20230809 → 0.0.0-next-be16baf-20230809

package/3rdparty/walkontable/src/selection/manager.mjs

@@ -0,0 +1,254 @@
+import "core-js/modules/es.array.unscopables.flat.js";
+import "core-js/modules/es.error.cause.js";
+function _classPrivateMethodInitSpec(obj, privateSet) { _checkPrivateRedeclaration(obj, privateSet); privateSet.add(obj); }
+function _classPrivateFieldInitSpec(obj, privateMap, value) { _checkPrivateRedeclaration(obj, privateMap); privateMap.set(obj, value); }
+function _checkPrivateRedeclaration(obj, privateCollection) { if (privateCollection.has(obj)) { throw new TypeError("Cannot initialize the same private elements twice on an object"); } }
+function _classPrivateMethodGet(receiver, privateSet, fn) { if (!privateSet.has(receiver)) { throw new TypeError("attempted to get private field on non-instance"); } return fn; }
+function _classPrivateFieldGet(receiver, privateMap) { var descriptor = _classExtractFieldDescriptor(receiver, privateMap, "get"); return _classApplyDescriptorGet(receiver, descriptor); }
+function _classApplyDescriptorGet(receiver, descriptor) { if (descriptor.get) { return descriptor.get.call(receiver); } return descriptor.value; }
+function _classPrivateFieldSet(receiver, privateMap, value) { var descriptor = _classExtractFieldDescriptor(receiver, privateMap, "set"); _classApplyDescriptorSet(receiver, descriptor, value); return value; }
+function _classExtractFieldDescriptor(receiver, privateMap, action) { if (!privateMap.has(receiver)) { throw new TypeError("attempted to " + action + " private field on non-instance"); } return privateMap.get(receiver); }
+function _classApplyDescriptorSet(receiver, descriptor, value) { if (descriptor.set) { descriptor.set.call(receiver, value); } else { if (!descriptor.writable) { throw new TypeError("attempted to set read only private field"); } descriptor.value = value; } }
+import { removeClass, addClass } from "../../../../helpers/dom/element.mjs";
+import { SelectionScanner } from "./scanner.mjs";
+import Border from "./border/border.mjs";
+/**
+ * Module responsible for rendering selections (CSS classes) and borders based on the
+ * collection of the Selection instances provided throughout the `selections` Walkontable
+ * setting.
+ *
+ * @private
+ */
+var _activeOverlaysWot = /*#__PURE__*/new WeakMap();
+var _selections = /*#__PURE__*/new WeakMap();
+var _scanner = /*#__PURE__*/new WeakMap();
+var _appliedClasses = /*#__PURE__*/new WeakMap();
+var _destroyListeners = /*#__PURE__*/new WeakMap();
+var _selectionBorders = /*#__PURE__*/new WeakMap();
+var _resetCells = /*#__PURE__*/new WeakSet();
+export class SelectionManager {
+  constructor(selections) {
+    /**
+     * Resets the elements to their initial state (remove the CSS classes that are added in the
+     * previous render cycle).
+     */
+    _classPrivateMethodInitSpec(this, _resetCells);
+    /**
+     * The overlay's Walkontable instance that are currently processed.
+     *
+     * @type {Walkontable}
+     */
+    _classPrivateFieldInitSpec(this, _activeOverlaysWot, {
+      writable: true,
+      value: void 0
+    });
+    /**
+     * The Highlight instance that holds Selections instances within it.
+     *
+     * @type {Highlight|null}
+     */
+    _classPrivateFieldInitSpec(this, _selections, {
+      writable: true,
+      value: void 0
+    });
+    /**
+     * The SelectionScanner allows to scan and collect the cell and header elements that matches
+     * to the coords defined in the selections.
+     *
+     * @type {SelectionScanner}
+     */
+    _classPrivateFieldInitSpec(this, _scanner, {
+      writable: true,
+      value: new SelectionScanner()
+    });
+    /**
+     * The Map tracks applied CSS classes. It's used to reset the elements state to their initial state.
+     *
+     * @type {WeakMap}
+     */
+    _classPrivateFieldInitSpec(this, _appliedClasses, {
+      writable: true,
+      value: new WeakMap()
+    });
+    /**
+     * The Map tracks applied "destroy" listeners for Selection instances.
+     *
+     * @type {WeakMap}
+     */
+    _classPrivateFieldInitSpec(this, _destroyListeners, {
+      writable: true,
+      value: new WeakSet()
+    });
+    /**
+     * The Map holds references to Border classes for Selection instances which requires that when
+     * the "border" setting is defined.
+     *
+     * @type {Map}
+     */
+    _classPrivateFieldInitSpec(this, _selectionBorders, {
+      writable: true,
+      value: new Map()
+    });
+    _classPrivateFieldSet(this, _selections, selections);
+  }
+
+  /**
+   * Sets the active Walkontable instance.
+   *
+   * @param {Walkontable} activeWot The overlays or master Walkontable instance.
+   * @returns {SelectionManager}
+   */
+  setActiveOverlay(activeWot) {
+    _classPrivateFieldSet(this, _activeOverlaysWot, activeWot);
+    _classPrivateFieldGet(this, _scanner).setActiveOverlay(_classPrivateFieldGet(this, _activeOverlaysWot));
+    if (!_classPrivateFieldGet(this, _appliedClasses).has(_classPrivateFieldGet(this, _activeOverlaysWot))) {
+      _classPrivateFieldGet(this, _appliedClasses).set(_classPrivateFieldGet(this, _activeOverlaysWot), new Set());
+    }
+    return this;
+  }
+
+  /**
+   * Gets the Selection instance of the "focus" type.
+   *
+   * @returns {Selection|null}
+   */
+  getFocusSelection() {
+    return _classPrivateFieldGet(this, _selections) !== null ? _classPrivateFieldGet(this, _selections).getFocus() : null;
+  }
+
+  /**
+   * Gets the Selection instance of the "area" type.
+   *
+   * @returns {Selection|null}
+   */
+  getAreaSelection() {
+    return _classPrivateFieldGet(this, _selections) !== null ? _classPrivateFieldGet(this, _selections).createLayeredArea() : null;
+  }
+
+  /**
+   * Gets the Border instance associated with Selection instance.
+   *
+   * @param {Selection} selection The selection instance.
+   * @returns {Border|null} Returns the Border instance (new for each overlay Walkontable instance).
+   */
+  getBorderInstance(selection) {
+    if (!selection.settings.border) {
+      return null;
+    }
+    if (_classPrivateFieldGet(this, _selectionBorders).has(selection)) {
+      const borders = _classPrivateFieldGet(this, _selectionBorders).get(selection);
+      if (borders.has(_classPrivateFieldGet(this, _activeOverlaysWot))) {
+        return borders.get(_classPrivateFieldGet(this, _activeOverlaysWot));
+      }
+      const border = new Border(_classPrivateFieldGet(this, _activeOverlaysWot), selection.settings);
+      borders.set(_classPrivateFieldGet(this, _activeOverlaysWot), border);
+      return border;
+    }
+    const border = new Border(_classPrivateFieldGet(this, _activeOverlaysWot), selection.settings);
+    _classPrivateFieldGet(this, _selectionBorders).set(selection, new Map([[_classPrivateFieldGet(this, _activeOverlaysWot), border]]));
+    return border;
+  }
+
+  /**
+   * Gets all Border instances associated with Selection instance for all overlays.
+   *
+   * @param {Selection} selection The selection instance.
+   * @returns {Border[]}
+   */
+  getBorderInstances(selection) {
+    var _classPrivateFieldGet2, _classPrivateFieldGet3;
+    return Array.from((_classPrivateFieldGet2 = (_classPrivateFieldGet3 = _classPrivateFieldGet(this, _selectionBorders).get(selection)) === null || _classPrivateFieldGet3 === void 0 ? void 0 : _classPrivateFieldGet3.values()) !== null && _classPrivateFieldGet2 !== void 0 ? _classPrivateFieldGet2 : []);
+  }
+
+  /**
+   * Destroys the Border instance associated with Selection instance.
+   *
+   * @param {Selection} selection The selection instance.
+   */
+  destroyBorders(selection) {
+    _classPrivateFieldGet(this, _selectionBorders).get(selection).forEach(border => border.destroy());
+    _classPrivateFieldGet(this, _selectionBorders).delete(selection);
+  }
+
+  /**
+   * Renders all the selections (add CSS classes to cells and draw borders).
+   *
+   * @param {boolean} fastDraw Indicates the render cycle type (fast/slow).
+   */
+  render(fastDraw) {
+    if (_classPrivateFieldGet(this, _selections) === null) {
+      return;
+    }
+    if (fastDraw) {
+      // there was no rerender, so we need to remove classNames by ourselves
+      _classPrivateMethodGet(this, _resetCells, _resetCells2).call(this);
+    }
+    const selections = Array.from(_classPrivateFieldGet(this, _selections));
+    const classNamesMap = new Map();
+    for (let i = 0; i < selections.length; i++) {
+      const selection = selections[i];
+      const {
+        className,
+        createLayers,
+        selectionType
+      } = selection.settings;
+      if (!_classPrivateFieldGet(this, _destroyListeners).has(selection)) {
+        _classPrivateFieldGet(this, _destroyListeners).add(selection);
+        selection.addLocalHook('destroy', () => this.destroyBorders(selection));
+      }
+      const borderInstance = this.getBorderInstance(selection);
+      if (selection.isEmpty()) {
+        borderInstance === null || borderInstance === void 0 ? void 0 : borderInstance.disappear();
+        continue; // eslint-disable-line no-continue
+      }
+
+      if (className) {
+        const elements = _classPrivateFieldGet(this, _scanner).setActiveSelection(selection).scan();
+        elements.forEach(element => {
+          if (classNamesMap.has(element)) {
+            const classNamesLayers = classNamesMap.get(element);
+            if (classNamesLayers.has(className) && createLayers === true) {
+              classNamesLayers.set(className, classNamesLayers.get(className) + 1);
+            } else {
+              classNamesLayers.set(className, 1);
+            }
+          } else {
+            classNamesMap.set(element, new Map([[className, 1]]));
+          }
+        });
+      }
+      const corners = selection.getCorners();
+      _classPrivateFieldGet(this, _activeOverlaysWot).getSetting('onBeforeDrawBorders', corners, selectionType);
+      borderInstance === null || borderInstance === void 0 ? void 0 : borderInstance.appear(corners);
+    }
+    classNamesMap.forEach((classNamesLayers, element) => {
+      const classNames = Array.from(classNamesLayers).map(_ref => {
+        let [className, occurrenceCount] = _ref;
+        if (occurrenceCount === 1) {
+          return className;
+        }
+        return [className, ...Array.from({
+          length: occurrenceCount - 1
+        }, (_, i) => `${className}-${i + 1}`)];
+      }).flat();
+      classNames.forEach(className => _classPrivateFieldGet(this, _appliedClasses).get(_classPrivateFieldGet(this, _activeOverlaysWot)).add(className));
+      addClass(element, classNames);
+    });
+  }
+}
+function _resetCells2() {
+  const appliedOverlaysClasses = _classPrivateFieldGet(this, _appliedClasses).get(_classPrivateFieldGet(this, _activeOverlaysWot));
+  const classesToRemove = _classPrivateFieldGet(this, _activeOverlaysWot).wtSettings.getSetting('onBeforeRemoveCellClassNames');
+  if (Array.isArray(classesToRemove)) {
+    for (let i = 0; i < classesToRemove.length; i++) {
+      appliedOverlaysClasses.add(classesToRemove[i]);
+    }
+  }
+  appliedOverlaysClasses.forEach(className => {
+    const nodes = _classPrivateFieldGet(this, _activeOverlaysWot).wtTable.TABLE.querySelectorAll(`.${className}`);
+    for (let i = 0, len = nodes.length; i < len; i++) {
+      removeClass(nodes[i], className);
+    }
+  });
+  appliedOverlaysClasses.clear();
+}

package/3rdparty/walkontable/src/selection/scanner.js

@@ -0,0 +1,270 @@
+"use strict";
+
+exports.__esModule = true;
+require("core-js/modules/es.error.cause.js");
+var _element = require("../../../../helpers/dom/element");
+function _classPrivateMethodInitSpec(obj, privateSet) { _checkPrivateRedeclaration(obj, privateSet); privateSet.add(obj); }
+function _classPrivateFieldInitSpec(obj, privateMap, value) { _checkPrivateRedeclaration(obj, privateMap); privateMap.set(obj, value); }
+function _checkPrivateRedeclaration(obj, privateCollection) { if (privateCollection.has(obj)) { throw new TypeError("Cannot initialize the same private elements twice on an object"); } }
+function _classPrivateMethodGet(receiver, privateSet, fn) { if (!privateSet.has(receiver)) { throw new TypeError("attempted to get private field on non-instance"); } return fn; }
+function _classPrivateFieldGet(receiver, privateMap) { var descriptor = _classExtractFieldDescriptor(receiver, privateMap, "get"); return _classApplyDescriptorGet(receiver, descriptor); }
+function _classApplyDescriptorGet(receiver, descriptor) { if (descriptor.get) { return descriptor.get.call(receiver); } return descriptor.value; }
+function _classPrivateFieldSet(receiver, privateMap, value) { var descriptor = _classExtractFieldDescriptor(receiver, privateMap, "set"); _classApplyDescriptorSet(receiver, descriptor, value); return value; }
+function _classExtractFieldDescriptor(receiver, privateMap, action) { if (!privateMap.has(receiver)) { throw new TypeError("attempted to " + action + " private field on non-instance"); } return privateMap.get(receiver); }
+function _classApplyDescriptorSet(receiver, descriptor, value) { if (descriptor.set) { descriptor.set.call(receiver, value); } else { if (!descriptor.writable) { throw new TypeError("attempted to set read only private field"); } descriptor.value = value; } } /* eslint-disable no-continue */
+/**
+ * Selection scanner module scans the rendered cells and headers and if it finds an intersection with
+ * the coordinates of the Selection class (highlight) it returns the DOM elements.
+ *
+ * @private
+ */
+var _selection = /*#__PURE__*/new WeakMap();
+var _activeOverlaysWot = /*#__PURE__*/new WeakMap();
+var _scanCellsRange = /*#__PURE__*/new WeakSet();
+class SelectionScanner {
+  constructor() {
+    /**
+     * The method triggers a callback for each rendered cell.
+     *
+     * @param {function(number, number): void} callback The callback function to trigger.
+     */
+    _classPrivateMethodInitSpec(this, _scanCellsRange);
+    /**
+     * Active Selection instance to process.
+     *
+     * @type {Selection}
+     */
+    _classPrivateFieldInitSpec(this, _selection, {
+      writable: true,
+      value: void 0
+    });
+    /**
+     * The Walkontable instance that the scans depends on.
+     *
+     * @type {Walkontable}
+     */
+    _classPrivateFieldInitSpec(this, _activeOverlaysWot, {
+      writable: true,
+      value: void 0
+    });
+  }
+  /**
+   * Sets the Walkontable instance that will be taking into account while scanning the table.
+   *
+   * @param {Walkontable} activeOverlaysWot The Walkontable instance.
+   * @returns {SelectionScanner}
+   */
+  setActiveOverlay(activeOverlaysWot) {
+    _classPrivateFieldSet(this, _activeOverlaysWot, activeOverlaysWot);
+    return this;
+  }
+
+  /**
+   * Sets the Selection instance to process.
+   *
+   * @param {Selection} selection The Selection instance.
+   * @returns {SelectionScanner}
+   */
+  setActiveSelection(selection) {
+    _classPrivateFieldSet(this, _selection, selection);
+    return this;
+  }
+
+  /**
+   * Scans the rendered table with selection and returns elements that intersects
+   * with selection coordinates.
+   *
+   * @returns {HTMLTableElement[]}
+   */
+  scan() {
+    const selectionType = _classPrivateFieldGet(this, _selection).settings.selectionType;
+    const elements = new Set();
+
+    // TODO(improvement): use heuristics from coords to detect what type of scan
+    // the Selection needs instead of using `selectionType` property.
+    if (selectionType === 'active-header') {
+      this.scanColumnsInHeadersRange(element => elements.add(element));
+      this.scanRowsInHeadersRange(element => elements.add(element));
+    } else if (selectionType === 'area') {
+      this.scanCellsRange(element => elements.add(element));
+    } else if (selectionType === 'focus') {
+      this.scanColumnsInHeadersRange(element => elements.add(element));
+      this.scanRowsInHeadersRange(element => elements.add(element));
+      this.scanCellsRange(element => elements.add(element));
+    } else if (selectionType === 'fill') {
+      this.scanCellsRange(element => elements.add(element));
+    } else if (selectionType === 'header') {
+      this.scanColumnsInHeadersRange(element => elements.add(element));
+      this.scanRowsInHeadersRange(element => elements.add(element));
+    } else if (selectionType === 'row') {
+      this.scanRowsInHeadersRange(element => elements.add(element));
+      this.scanRowsInCellsRange(element => elements.add(element));
+    } else if (selectionType === 'column') {
+      this.scanColumnsInHeadersRange(element => elements.add(element));
+      this.scanColumnsInCellsRange(element => elements.add(element));
+    }
+    return elements;
+  }
+
+  /**
+   * Scans the table (only rendered headers) and collect all column headers (TH) that match
+   * the coordinates passed in the Selection instance.
+   *
+   * @param {function(HTMLTableElement): void} callback The callback function to trigger.
+   */
+  scanColumnsInHeadersRange(callback) {
+    const [topRow, topColumn, bottomRow, bottomColumn] = _classPrivateFieldGet(this, _selection).getCorners();
+    const {
+      wtTable
+    } = _classPrivateFieldGet(this, _activeOverlaysWot);
+    const renderedColumnsCount = wtTable.getRenderedColumnsCount();
+    const columnHeadersCount = wtTable.getColumnHeadersCount();
+    let cursor = 0;
+    for (let column = -wtTable.getRowHeadersCount(); column < renderedColumnsCount; column++) {
+      const sourceColumn = wtTable.columnFilter.renderedToSource(column);
+      if (sourceColumn < topColumn || sourceColumn > bottomColumn) {
+        continue;
+      }
+      for (let headerLevel = -columnHeadersCount; headerLevel < 0; headerLevel++) {
+        if (headerLevel < topRow || headerLevel > bottomRow) {
+          continue;
+        }
+        const positiveBasedHeaderLevel = headerLevel + columnHeadersCount;
+        let TH = wtTable.getColumnHeader(sourceColumn, positiveBasedHeaderLevel);
+        const newSourceCol = _classPrivateFieldGet(this, _activeOverlaysWot).getSetting('onBeforeHighlightingColumnHeader', sourceColumn, positiveBasedHeaderLevel, {
+          selectionType: _classPrivateFieldGet(this, _selection).settings.selectionType,
+          columnCursor: cursor,
+          selectionWidth: bottomColumn - topColumn + 1
+        });
+        if (newSourceCol === null) {
+          continue;
+        }
+        if (newSourceCol !== sourceColumn) {
+          TH = wtTable.getColumnHeader(newSourceCol, positiveBasedHeaderLevel);
+        }
+        callback(TH);
+      }
+      cursor += 1;
+    }
+  }
+
+  /**
+   * Scans the table (only rendered headers) and collect all row headers (TH) that match
+   * the coordinates passed in the Selection instance.
+   *
+   * @param {function(HTMLTableElement): void} callback The callback function to trigger.
+   */
+  scanRowsInHeadersRange(callback) {
+    const [topRow, topColumn, bottomRow, bottomColumn] = _classPrivateFieldGet(this, _selection).getCorners();
+    const {
+      wtTable
+    } = _classPrivateFieldGet(this, _activeOverlaysWot);
+    const renderedRowsCount = wtTable.getRenderedRowsCount();
+    const rowHeadersCount = wtTable.getRowHeadersCount();
+    let cursor = 0;
+    for (let row = -wtTable.getColumnHeadersCount(); row < renderedRowsCount; row++) {
+      const sourceRow = wtTable.rowFilter.renderedToSource(row);
+      if (sourceRow < topRow || sourceRow > bottomRow) {
+        continue;
+      }
+      for (let headerLevel = -rowHeadersCount; headerLevel < 0; headerLevel++) {
+        if (headerLevel < topColumn || headerLevel > bottomColumn) {
+          continue;
+        }
+        const positiveBasedHeaderLevel = headerLevel + rowHeadersCount;
+        let TH = wtTable.getRowHeader(sourceRow, positiveBasedHeaderLevel);
+        const newSourceRow = _classPrivateFieldGet(this, _activeOverlaysWot).getSetting('onBeforeHighlightingRowHeader', sourceRow, positiveBasedHeaderLevel, {
+          selectionType: _classPrivateFieldGet(this, _selection).settings.selectionType,
+          rowCursor: cursor,
+          selectionHeight: bottomRow - topRow + 1
+        });
+        if (newSourceRow === null) {
+          continue;
+        }
+        if (newSourceRow !== sourceRow) {
+          TH = wtTable.getRowHeader(newSourceRow, positiveBasedHeaderLevel);
+        }
+        callback(TH);
+      }
+      cursor += 1;
+    }
+  }
+
+  /**
+   * Scans the table (only rendered cells) and collect all cells (TR) that match
+   * the coordinates passed in the Selection instance.
+   *
+   * @param {function(HTMLTableElement): void} callback The callback function to trigger.
+   */
+  scanCellsRange(callback) {
+    const [topRow, topColumn, bottomRow, bottomColumn] = _classPrivateFieldGet(this, _selection).getCorners();
+    const {
+      wtTable
+    } = _classPrivateFieldGet(this, _activeOverlaysWot);
+    _classPrivateMethodGet(this, _scanCellsRange, _scanCellsRange2).call(this, (sourceRow, sourceColumn) => {
+      if (sourceRow >= topRow && sourceRow <= bottomRow && sourceColumn >= topColumn && sourceColumn <= bottomColumn) {
+        const cell = wtTable.getCell(_classPrivateFieldGet(this, _activeOverlaysWot).createCellCoords(sourceRow, sourceColumn));
+
+        // support for old API
+        const additionalSelectionClass = _classPrivateFieldGet(this, _activeOverlaysWot).getSetting('onAfterDrawSelection', sourceRow, sourceColumn, _classPrivateFieldGet(this, _selection).settings.layerLevel);
+        if (typeof additionalSelectionClass === 'string') {
+          (0, _element.addClass)(cell, additionalSelectionClass);
+        }
+        callback(cell);
+      }
+    });
+  }
+
+  /**
+   * Scans the table (only rendered cells) and collects all cells (TR) that match the coordinates
+   * passed in the Selection instance but only for the X axis (rows).
+   *
+   * @param {function(HTMLTableElement): void} callback The callback function to trigger.
+   */
+  scanRowsInCellsRange(callback) {
+    // eslint-disable-next-line comma-spacing
+    const [topRow,, bottomRow] = _classPrivateFieldGet(this, _selection).getCorners();
+    const {
+      wtTable
+    } = _classPrivateFieldGet(this, _activeOverlaysWot);
+    _classPrivateMethodGet(this, _scanCellsRange, _scanCellsRange2).call(this, (sourceRow, sourceColumn) => {
+      if (sourceRow >= topRow && sourceRow <= bottomRow) {
+        const cell = wtTable.getCell(_classPrivateFieldGet(this, _activeOverlaysWot).createCellCoords(sourceRow, sourceColumn));
+        callback(cell);
+      }
+    });
+  }
+
+  /**
+   * Scans the table (only rendered cells) and collects all cells (TR) that match the coordinates
+   * passed in the Selection instance but only for the Y axis (columns).
+   *
+   * @param {function(HTMLTableElement): void} callback The callback function to trigger.
+   */
+  scanColumnsInCellsRange(callback) {
+    const [, topColumn,, bottomColumn] = _classPrivateFieldGet(this, _selection).getCorners();
+    const {
+      wtTable
+    } = _classPrivateFieldGet(this, _activeOverlaysWot);
+    _classPrivateMethodGet(this, _scanCellsRange, _scanCellsRange2).call(this, (sourceRow, sourceColumn) => {
+      if (sourceColumn >= topColumn && sourceColumn <= bottomColumn) {
+        const cell = wtTable.getCell(_classPrivateFieldGet(this, _activeOverlaysWot).createCellCoords(sourceRow, sourceColumn));
+        callback(cell);
+      }
+    });
+  }
+}
+exports.SelectionScanner = SelectionScanner;
+function _scanCellsRange2(callback) {
+  const {
+    wtTable
+  } = _classPrivateFieldGet(this, _activeOverlaysWot);
+  const renderedRowsCount = wtTable.getRenderedRowsCount();
+  const renderedColumnsCount = wtTable.getRenderedColumnsCount();
+  for (let row = 0; row < renderedRowsCount; row += 1) {
+    const sourceRow = wtTable.rowFilter.renderedToSource(row);
+    for (let column = 0; column < renderedColumnsCount; column += 1) {
+      callback(sourceRow, wtTable.columnFilter.renderedToSource(column));
+    }
+  }
+}