Get dummy cell used when merging inner tables.
@return a cell with colspan 3 and no border
192002
private static Cell getDummyCell() {
        Cell cell = new Cell(true);
        cell.setColspan(3);
        cell.setBorder(NO_BORDER);
        return cell;
	}
1203903
@Override
	public int getColumnNumber() {
		int result = bufferStartColumn;
		for (int i = 0; i < position; i++) {
			if (buffer[i] == '\n') {
				result = 0;
			} else {
				result++;
			}
		}
		return result + 1; // the first column is '1'
	}
939200
public TableColumn copyBox()
    {
        TableColumn ret = new TableColumn(el, g, ctx);
        ret.copyValues(this);
        return ret;
    }
143991
@Override
  public CellType getCachedFormulaResultType() {
    if (formulaType) {
      if(contentsSupplier.getContent() == null || type == null) {
        return CellType.BLANK;
      } else if("n".equals(type)) {
        return CellType.NUMERIC;
      } else if("s".equals(type) || "inlineStr".equals(type) || "str".equals(type)) {
        return CellType.STRING;
      } else if("b".equals(type)) {
        return CellType.BOOLEAN;
      } else if("e".equals(type)) {
        return CellType.ERROR;
      } else {
        throw new UnsupportedOperationException("Unsupported cell type '" + type + "'");
      }
    } else  {
      throw new IllegalStateException("Only formula cells have cached results");
    }
  }
1255452
function getTableDetails(table) {
        return Tools.map(table.rows, function (row) {

          var cells = Tools.map(row.cells, function (cell) {

            var rowspan = cell.hasAttribute('rowspan') ? parseInt(cell.getAttribute('rowspan'), 10) : 1;
            var colspan = cell.hasAttribute('colspan') ? parseInt(cell.getAttribute('colspan'), 10) : 1;

            return {
              element: cell,
              rowspan: rowspan,
              colspan: colspan
            };
          });

          return {
            element: row,
            cells: cells
          };

        });

      }
78960
public CellStyleGenerator getDefaultCellStyleGenerator() {

        return new CellStyleGenerator() {

            private static final long serialVersionUID = 1L;

            @SuppressWarnings("synthetic-access")
            public String getStyle(Table source, Object itemId, Object propertyId) {

                for (ColumnBean colBean : m_columns) {
                    if (colBean.getProperty().getName().equals(propertyId)) {
                        return colBean.getInfo().styleName();
                    }
                }
                return "";
            }
        };
    }
331261
public static <V> Function<Table.Cell<?, ?, V>, V> TableCellValue() {
    return new Function<Table.Cell<?, ?, V>, V>() {
      @Override
      public V apply(Table.Cell<?, ?, V> input) {
        return input.getValue();
      }
    };
  }
281271
public int getMinimalColumnWidth(int col)
    {
        int ret = 0;
        int r = 0;
        while (r < getRowCount())
        {
            TableCellBox cell = cells[col][r];
            if (cell != null)
            {
                int min = cell.getMinimalWidth() / cell.getColspan();
                if (min > ret) ret = min;
                r += cell.getRowspan();
            }
            else
                r++;
        }
        return ret;
    }
624755
private Rectangle getVDropLineRect(JTable.DropLocation loc) {
        if (!loc.isInsertColumn()) {
            return null;
        }

        boolean   ltr  = table.getComponentOrientation().isLeftToRight();
        int       col  = loc.getColumn();
        Rectangle rect = table.getCellRect(loc.getRow(), col, true);

        if (col >= table.getColumnCount()) {
            col--;
            rect = table.getCellRect(loc.getRow(), col, true);
            if (ltr) {
                rect.x = rect.x + rect.width;
            }
        } else if (!ltr) {
            rect.x = rect.x + rect.width;
        }

        if (rect.x == 0) {
            rect.x = -1;
        } else {
            rect.x -= 2;
        }

        rect.width = 3;

        return rect;
    }
1288696
public Cell createCell(SimpleCell rowAttributes) throws BadElementException {
		Cell cell = new Cell();
		cell.cloneNonPositionParameters(rowAttributes);
		cell.softCloneNonPositionParameters(this);
		cell.setColspan(colspan);
		cell.setHorizontalAlignment(horizontalAlignment);
		cell.setVerticalAlignment(verticalAlignment);
		cell.setUseAscender(useAscender);
		cell.setUseBorderPadding(useBorderPadding);
		cell.setUseDescender(useDescender);
		Element element;
		for (Iterator i = content.iterator(); i.hasNext(); ) {
			element = (Element)i.next();
			cell.addElement(element);
		}
		return cell;
	}
744018
private String getRowLineBuf(int colCount, List<Integer> colMaxLenList, String[][] data) {
		
		S.Buffer rowBuilder = S.buffer();
		int colWidth;
		
		for (int i = 0 ; i < colCount ; i ++) {
			
			colWidth = colMaxLenList.get(i) + 3;
			
			for (int j = 0; j < colWidth ; j ++) {
				if (j==0) {
					rowBuilder.append("+");
				} else if ((i+1 == colCount && j+1 == colWidth)) {//for last column close the border
					rowBuilder.append("-+");
				} else {
					rowBuilder.append("-");
				}
			}
		}
		
		return rowBuilder.append("\n").toString();
	}
1368547
public static BorderStyle getBorderBottom(final Cell cell) {

        ArgUtils.notNull(cell, "cell");

        final Sheet sheet = cell.getSheet();
        CellRangeAddress mergedRegion = getMergedRegion(sheet, cell.getRowIndex(), cell.getColumnIndex());

        final Cell target;
        if(mergedRegion == null) {
            // 結合されていない場合
            target = cell;

        } else {
            if(mergedRegion.getLastRow() == cell.getRowIndex()) {
                // 引数のCellが下部のセルの場合
                target = cell;
            } else {
                target = getCell(sheet, cell.getColumnIndex(), mergedRegion.getLastRow());
            }

        }

        final CellStyle style = target.getCellStyle();
        if(style == null) {
            return BorderStyle.NONE;
        } else {
            return style.getBorderBottomEnum();
        }

    }
1182068
function cellOffsetToCell(cellOffset) {
		var colCnt = t.getColCnt();

		// rtl variables. wish we could pre-populate these. but where?
		var dis = isRTL ? -1 : 1;
		var dit = isRTL ? colCnt - 1 : 0;

		var row = Math.floor(cellOffset / colCnt);
		var col = ((cellOffset % colCnt + colCnt) % colCnt) * dis + dit; // column, adjusted for RTL (dis & dit)
		return {
			row: row,
			col: col
		};
	}
266266
public String getRowsWithColumnsAsString() {
		StringBuffer sb = new StringBuffer();
		int lvSize = rows.size();
		for (int i=0; i<lvSize; i++) {
			String lvRow = row2String(i); 
			sb.append(lvRow);
			if (i < (lvSize-1) && lvRow.endsWith(CsvParser.CRLF) == false) {
				sb.append(CsvParser.CRLF);
			}
		}
		return sb.toString();
	}
496329
public Cells getValueCells() {
        Cells res = new Cells(this.nameSpace);

        for (Map.Entry<String, List<Cell>> entry : cells.entrySet()) {
            Cells keys = getValueCells(entry.getKey());

            for (Cell c : keys) {
                res.add(entry.getKey(), c);
            }
        }

        return res;
    }
720116
private CellFormatResult getMergedCellValue(final Cell cell, final Locale locale) {

        final Sheet sheet = cell.getSheet();
        final int size = sheet.getNumMergedRegions();

        for(int i=0; i < size; i++) {
            final CellRangeAddress range = sheet.getMergedRegion(i);
            if(!range.isInRange(cell.getRowIndex(), cell.getColumnIndex())) {
                continue;
            }

            // 非BLANKまたはnullでないセルを取得する。
            for(int rowIdx=range.getFirstRow(); rowIdx <= range.getLastRow(); rowIdx++) {
                final Row row = sheet.getRow(rowIdx);
                if(row == null) {
                    continue;
                }

                for(int colIdx=range.getFirstColumn(); colIdx <= range.getLastColumn(); colIdx++) {
                    final Cell valueCell = row.getCell(colIdx);
                    if(valueCell == null || valueCell.getCellTypeEnum() == CellType.BLANK) {
                        continue;
                    }

                    return format(valueCell, locale);
                }
            }

        }

        return createBlankCellResult();
    }
900913
private float getColumnBottom() {
        if (desiredHeight == AUTOMATIC) {
            return document.bottom();
        } else {
            return Math.max(top - (desiredHeight - totalHeight), document.bottom());
        }
    }