Find last index of col merged cells.
@param {Array.<Array.<object>>} tableData - tableData data
@param {number} rowIndex - row index of base data
@param {number} colIndex - column index of tabld data
@returns {number}
@ignore
510060
function findRowMergedLastIndex(tableData, rowIndex, colIndex) {
  const cellData = tableData[rowIndex][colIndex];
  let foundRowIndex = rowIndex;

  if (cellData.rowspan > 1) {
    foundRowIndex += cellData.rowspan - 1;
  }

  return foundRowIndex;
}
748677
function(data){
			var rows = this.calculateRowsNumber();
			var datas = [];
			for(var i = 0; i < data.length; i += rows){
				datas.push(data.slice(i, i+rows));
			}
			return datas;
		}
245802
public synchronized V getCell(int columnIndex, int rowIndex) {
        if(rowIndex < 0 || columnIndex < 0) {
            throw new IndexOutOfBoundsException("Invalid row or column index: " + rowIndex + " " + columnIndex);
        }
        else if (rowIndex >= getRowCount()) {
            throw new IndexOutOfBoundsException("TableModel has " + getRowCount() + " rows, invalid access at rowIndex " + rowIndex);
        }
        if(columnIndex >= getColumnCount()) {
            throw new IndexOutOfBoundsException("TableModel has " + columnIndex + " columns, invalid access at columnIndex " + columnIndex);
        }
        return rows.get(rowIndex).get(columnIndex);
    }
602899
public static Object[] getAt(TableModel self, int index) {
        int cols = self.getColumnCount();
        Object[] rowData = new Object[cols];
        for (int col = 0; col < cols; col++) {
            rowData[col] = self.getValueAt(index, col);
        }
        return rowData;
    }
881379
function(rowIndex, selected, fire) {
        var self = this;
        if (rowIndex === 0) {
            rowIndex = $.map(this.options.data, function(val, index) {
                return index + 1;
            });
        }
        if (!$.isArray(rowIndex)) {
            rowIndex = [rowIndex];
        }

        $.each(rowIndex, function(index, val) {
            var tr = self.$tableBody.find('tbody tr:nth-child(' + (self.rowSpan > 1 ? (val * self.rowSpan) : val) + ')')
                .filter('[class!="sum"]')
                .filter('[class!="select-disabled"]'),
                checkbox = tr.find('.select-col :checkbox');
            if (selected) {
                checkbox.bizCheckbox('check');
                tr.addClass('selected');
            } else {
                checkbox.bizCheckbox('uncheck');
                tr.removeClass('selected');
            }
        });

        var selectedCount = self.$tableBody.find('.select-col .biz-checkbox-checked').length,
            checkboxCount = self.$tableBody.find('.select-col :checkbox').filter(':not(:disabled)').length,
            selectAll = self.$tableHead.find('.select-col :checkbox');
        if (selectedCount === checkboxCount) {
            selectAll.bizCheckbox('check');
        } else {
            selectAll.bizCheckbox('uncheck');
        }

        if (fire && this.options.onSelect) {
            this.options.onSelect.call(this, this.getSelected());
        }
    }
243484
private RowIndex[] removeRowIndexes(RowIndex fromRowIndex) {
        SortedSet<RowIndex> indexes = rowIndexes.tailSet(fromRowIndex);
        RowIndex[] removedIndexes = new RowIndex[indexes.size()];
        removedIndexes = indexes.toArray(removedIndexes);
        indexes.clear();
        return removedIndexes;
    }
36357
def _stringify_row(self, row_index):
        '''
        
        '''
        table_row = self.table[row_index]
        prior_cell = None
        for column_index in range(self.start[1], self.end[1]):
            cell, changed = self._check_interpret_cell(table_row[column_index], prior_cell, row_index, column_index)
            if changed:
                table_row[column_index] = cell
            prior_cell = cell
731664
function findTdAtColIdx($tr, colIdx) {
		var colspan,
			res = null,
			idx = 0;

		$tr.children().each(function() {
			if (idx >= colIdx) {
				res = $(this);
				return false;
			}
			colspan = $(this).prop("colspan");
			idx += colspan ? colspan : 1;
		});
		return res;
	}
473678
public void getRowHeadingBasedOnCells(TableCandidate tc) {
	String rowHeadingThisTable = "";
	int footnoteLineIndex = tc.getFootnoteBeginRow();
	String[][] cells = tc.getCells();
	// if (cells[0][0].length()==0 ) {
	for (int j = 0; j < footnoteLineIndex; j++) {
	    if (cells[j][0].length() > 0)
		rowHeadingThisTable = rowHeadingThisTable + cells[j][0] + "; ";
	}
	// }
	rowHeadingThisTable = tc
		.replaceAllSpecialChracters(rowHeadingThisTable);
	tc.setHeadingRows(rowHeadingThisTable);
    }
330902
function _initCellData(targetRows, startColIndex, endColIndex) {
  const limitColIndex = endColIndex + 1;
  const targetCells = targetRows.map(rowData => rowData.slice(startColIndex, limitColIndex));

  [].concat(...targetCells).slice(1).forEach(cellData => {
    const {nodeName} = cellData;

    util.forEach(cellData, (value, name) => (delete cellData[name]));
    cellData.nodeName = nodeName;
  });
}
604698
function getTableColumnStyle(tableColumn, tableStyle) {
  var tableColumnStyle;
  if (defined(tableColumn) && defined(tableStyle.columns)) {
    if (defined(tableStyle.columns[tableColumn.id])) {
      tableColumnStyle = clone(tableStyle.columns[tableColumn.id]);
    } else {
      // Also support column indices as keys into tableStyle.columns
      var tableStructure = tableColumn.parent;
      var columnIndex = tableStructure.columns.indexOf(tableColumn);
      if (defined(tableStyle.columns[columnIndex])) {
        tableColumnStyle = clone(tableStyle.columns[columnIndex]);
      }
    }
  }
  if (!defined(tableColumnStyle)) {
    return tableStyle;
  }
  // Copy defaults from tableStyle too.
  for (var propertyName in tableStyle) {
    if (
      tableStyle.hasOwnProperty(propertyName) &&
      tableColumnStyle.hasOwnProperty(propertyName)
    ) {
      if (!defined(tableColumnStyle[propertyName])) {
        tableColumnStyle[propertyName] = tableStyle[propertyName];
      }
    }
  }
  return tableColumnStyle;
}
947173
def _cellValue(self, index):
        
        row = index.row()
        col = index.column()
        if (row < 0 or row >= self.rowCount() or col < 0 or col >= self.columnCount()):
            return None

        # The check above should have returned None if the sliced array is None
        assert self._slicedArray is not None, "Sanity check failed."

        nFields = len(self._fieldNames)

        data = self._slicedArray.data
        if self._separateFieldOrientation == Qt.Horizontal:
            dataValue = data[row, col // nFields][self._fieldNames[col % nFields]]
        elif self._separateFieldOrientation == Qt.Vertical:
            dataValue = data[row // nFields, col][self._fieldNames[row % nFields]]
        else:
            dataValue = data[row, col]

        return dataValue
1319526
function _findFocusCell($newTable, rowIndex, colIndex) {
  const tableData = dataHandler.createTableData($newTable);

  if (tableData[0].length - 1 < colIndex) {
    colIndex -= 1;
  }

  const cellElementIndex = dataHandler.findElementIndex(tableData, rowIndex, colIndex);

  return $newTable.find('tr').eq(cellElementIndex.rowIndex).find('td, th')[cellElementIndex.colIndex];
}
653298
function stuffCellsIntoIncompleteRow(tableData, limitIndex) {
  tableData.forEach((rowData, rowIndex) => {
    const startIndex = rowData.length;
    if (startIndex) {
      const [{nodeName}] = rowData;

      util.range(startIndex, limitIndex).forEach(colIndex => {
        rowData.push(createBasicCell(rowIndex, colIndex, nodeName));
      });
    }
  });
}
1127759
function(rowIndex) {
        if (typeof rowIndex !== 'undefined') {
            if ($.isArray(rowIndex)) {
                var result = [],
                    self = this;
                $.each(rowIndex, function(index, value) {
                    var item = self.options.data[value - 1];
                    if (item) {
                        result.push(item);
                    }
                });
                return result.length !== 0 ? result : null;
            } else {
                return this.options.data[rowIndex - 1] || null;
            }
        } else {
            return this.options.data;
        }
    }
1273477
function() {
      var i, j, col1, col2;
      var from = this.originalTable.startIndex;
      var to = this.originalTable.endIndex;
      /* Find children thead and tbody.
       * Only to process the immediate tr-children. Bugfix for inner tables
       */
      var thtb = this.originalTable.el.children();
      if (this.options.excludeFooter) {
        thtb = thtb.not('tfoot');
      }
      if (from < to) {
        for (i = from; i < to; i++) {
          col1 = thtb.find('> tr > td:nth-child(' + i + ')')
            .add(thtb.find('> tr > th:nth-child(' + i + ')'));
          col2 = thtb.find('> tr > td:nth-child(' + (i + 1) + ')')
            .add(thtb.find('> tr > th:nth-child(' + (i + 1) + ')'));
          for (j = 0; j < col1.length; j++) {
            swapNodes(col1[j], col2[j]);
          }
        }
      } else {
        for (i = from; i > to; i--) {
          col1 = thtb.find('> tr > td:nth-child(' + i + ')')
            .add(thtb.find('> tr > th:nth-child(' + i + ')'));
          col2 = thtb.find('> tr > td:nth-child(' + (i - 1) + ')')
            .add(thtb.find('> tr > th:nth-child(' + (i - 1) + ')'));
          for (j = 0; j < col1.length; j++) {
            swapNodes(col1[j], col2[j]);
          }
        }
      }
    }
702748
private int clientIndexToTabIndex(final int clientIndex) {
		int childCount = getTotalTabs();
		int serverIndex = clientIndex;

		for (int i = 0; i <= serverIndex && i < childCount; i++) {
			if (!isTabVisible(i)) {
				serverIndex++;
			}
		}

		return serverIndex;
	}