| Method from com.lowagie.text.pdf.PdfPTable Detail: |
|---|
 public void addCell(PdfPCell cell) {
rowCompleted = false;
PdfPCell ncell = new PdfPCell(cell);
int colspan = ncell.getColspan();
colspan = Math.max(colspan, 1);
colspan = Math.min(colspan, currentRow.length - currentRowIdx);
ncell.setColspan(colspan);
if (colspan != 1)
isColspan = true;
int rdir = ncell.getRunDirection();
if (rdir == PdfWriter.RUN_DIRECTION_DEFAULT)
ncell.setRunDirection(runDirection);
skipColsWithRowspanAbove();
boolean cellAdded = false;
if (currentRowIdx < currentRow.length) {
currentRow[currentRowIdx] = ncell;
currentRowIdx += colspan;
cellAdded = true;
}
skipColsWithRowspanAbove();
if (currentRowIdx >= currentRow.length) {
int numCols = getNumberOfColumns();
if (runDirection == PdfWriter.RUN_DIRECTION_RTL) {
PdfPCell rtlRow[] = new PdfPCell[numCols];
int rev = currentRow.length;
for (int k = 0; k < currentRow.length; ++k) {
PdfPCell rcell = currentRow[k];
int cspan = rcell.getColspan();
rev -= cspan;
rtlRow[rev] = rcell;
k += cspan - 1;
}
currentRow = rtlRow;
}
PdfPRow row = new PdfPRow(currentRow);
if (totalWidth > 0) {
row.setWidths(absoluteWidths);
totalHeight += row.getMaxHeights();
}
rows.add(row);
currentRow = new PdfPCell[numCols];
currentRowIdx = 0;
rowCompleted = true;
}
if (!cellAdded) {
currentRow[currentRowIdx] = ncell;
currentRowIdx += colspan;
}
}
|
public void addCell(String text) {
addCell(new Phrase(text));
} |
public void addCell(PdfPTable table) {
defaultCell.setTable(table);
addCell(defaultCell);
defaultCell.setTable(null);
} |
public void addCell(Image image) {
defaultCell.setImage(image);
addCell(defaultCell);
defaultCell.setImage(null);
} |
public void addCell(Phrase phrase) {
defaultCell.setPhrase(phrase);
addCell(defaultCell);
defaultCell.setPhrase(null);
} |
protected PdfPRow adjustCellsInRow(int start,
int end) {
PdfPRow row = new PdfPRow(getRow(start));
row.initExtraHeights();
PdfPCell cell;
PdfPCell[] cells = row.getCells();
for (int i = 0; i < cells.length; i++) {
cell = cells[i];
if (cell == null || cell.getRowspan() == 1)
continue;
int stop = Math.min(end, start + cell.getRowspan());
float extra = 0;
for (int k = start + 1; k < stop; k++) {
extra += getRowHeight(k);
}
row.setExtraHeight(i, extra);
}
return row;
} Calculates the extra height needed in a row because of rowspans. |
public static PdfContentByte[] beginWritingRows(PdfContentByte canvas) {
return new PdfContentByte[]{
canvas,
canvas.getDuplicate(),
canvas.getDuplicate(),
canvas.getDuplicate(),
};
} |
public float calculateHeights(boolean firsttime) {
if (totalWidth < = 0)
return 0;
totalHeight = 0;
for (int k = 0; k < rows.size(); ++k) {
totalHeight += getRowHeight(k, firsttime);
}
return totalHeight;
} Calculates the heights of the table. |
public void calculateHeightsFast() {
calculateHeights(false);
} Calculates the heights of the table. |
protected void calculateWidths() {
if (totalWidth < = 0)
return;
float total = 0;
int numCols = getNumberOfColumns();
for (int k = 0; k < numCols; ++k)
total += relativeWidths[k];
for (int k = 0; k < numCols; ++k)
absoluteWidths[k] = totalWidth * relativeWidths[k] / total;
} |
public void completeRow() {
while (!rowCompleted) {
addCell(defaultCell);
}
} Completes the current row with the default cell. An incomplete row will
be dropped but calling this method will make sure that it will be
present in the table. |
protected void copyFormat(PdfPTable sourceTable) {
relativeWidths = new float[sourceTable.getNumberOfColumns()];
absoluteWidths = new float[sourceTable.getNumberOfColumns()];
System.arraycopy(sourceTable.relativeWidths, 0, relativeWidths, 0, getNumberOfColumns());
System.arraycopy(sourceTable.absoluteWidths, 0, absoluteWidths, 0, getNumberOfColumns());
totalWidth = sourceTable.totalWidth;
totalHeight = sourceTable.totalHeight;
currentRowIdx = 0;
tableEvent = sourceTable.tableEvent;
runDirection = sourceTable.runDirection;
defaultCell = new PdfPCell(sourceTable.defaultCell);
currentRow = new PdfPCell[sourceTable.currentRow.length];
isColspan = sourceTable.isColspan;
splitRows = sourceTable.splitRows;
spacingAfter = sourceTable.spacingAfter;
spacingBefore = sourceTable.spacingBefore;
headerRows = sourceTable.headerRows;
footerRows = sourceTable.footerRows;
lockedWidth = sourceTable.lockedWidth;
extendLastRow = sourceTable.extendLastRow;
headersInEvent = sourceTable.headersInEvent;
widthPercentage = sourceTable.widthPercentage;
splitLate = sourceTable.splitLate;
skipFirstHeader = sourceTable.skipFirstHeader;
skipLastFooter = sourceTable.skipLastFooter;
horizontalAlignment = sourceTable.horizontalAlignment;
keepTogether = sourceTable.keepTogether;
complete = sourceTable.complete;
} Copies the format of the sourceTable without copying the content. |
public void deleteBodyRows() {
ArrayList rows2 = new ArrayList();
for (int k = 0; k < headerRows; ++k)
rows2.add(rows.get(k));
rows = rows2;
totalHeight = 0;
if (totalWidth > 0)
totalHeight = getHeaderHeight();
} Removes all of the rows except headers |
public boolean deleteLastRow() {
return deleteRow(rows.size() - 1);
} Deletes the last row in the table. |
public boolean deleteRow(int rowNumber) {
if (rowNumber < 0 || rowNumber >= rows.size())
return false;
if (totalWidth > 0) {
PdfPRow row = (PdfPRow)rows.get(rowNumber);
if (row != null)
totalHeight -= row.getMaxHeights();
}
rows.remove(rowNumber);
if (rowNumber < headerRows) {
--headerRows;
if (rowNumber >= (headerRows - footerRows))
--footerRows;
}
return true;
} Deletes a row from the table. |
public static void endWritingRows(PdfContentByte[] canvases) {
PdfContentByte canvas = canvases[BASECANVAS];
canvas.saveState();
canvas.add(canvases[BACKGROUNDCANVAS]);
canvas.restoreState();
canvas.saveState();
canvas.setLineCap(2);
canvas.resetRGBColorStroke();
canvas.add(canvases[LINECANVAS]);
canvas.restoreState();
canvas.add(canvases[TEXTCANVAS]);
} Finishes writing the table. |
public void flushContent() {
deleteBodyRows();
setSkipFirstHeader(true);
} |
public float[] getAbsoluteWidths() {
return absoluteWidths;
} Gets the absolute sizes of each column width. |
public ArrayList getChunks() {
return new ArrayList();
} Gets all the chunks in this element. |
public PdfPCell getDefaultCell() {
return defaultCell;
} Gets the default PdfPCell that will be used as
reference for all the addCell methods except
addCell(PdfPCell). |
float[][] getEventWidths(float xPos,
int firstRow,
int lastRow,
boolean includeHeaders) {
if (includeHeaders) {
firstRow = Math.max(firstRow, headerRows);
lastRow = Math.max(lastRow, headerRows);
}
float widths[][] = new float[(includeHeaders ? headerRows : 0) + lastRow - firstRow][];
if (isColspan) {
int n = 0;
if (includeHeaders) {
for (int k = 0; k < headerRows; ++k) {
PdfPRow row = (PdfPRow)rows.get(k);
if (row == null)
++n;
else
widths[n++] = row.getEventWidth(xPos);
}
}
for (; firstRow < lastRow; ++firstRow) {
PdfPRow row = (PdfPRow)rows.get(firstRow);
if (row == null)
++n;
else
widths[n++] = row.getEventWidth(xPos);
}
}
else {
int numCols = getNumberOfColumns();
float width[] = new float[numCols + 1];
width[0] = xPos;
for (int k = 0; k < numCols; ++k)
width[k + 1] = width[k] + absoluteWidths[k];
for (int k = 0; k < widths.length; ++k)
widths[k] = width;
}
return widths;
} |
public float getFooterHeight() {
float total = 0;
int start = Math.max(0, headerRows - footerRows);
int size = Math.min(rows.size(), headerRows);
for (int k = start; k < size; ++k) {
PdfPRow row = (PdfPRow)rows.get(k);
if (row != null)
total += row.getMaxHeights();
}
return total;
} Gets the height of the rows that constitute the footer as defined by
setFooterRows(). |
public int getFooterRows() {
return this.footerRows;
} Gets the number of rows in the footer. |
public float getHeaderHeight() {
float total = 0;
int size = Math.min(rows.size(), headerRows);
for (int k = 0; k < size; ++k) {
PdfPRow row = (PdfPRow)rows.get(k);
if (row != null)
total += row.getMaxHeights();
}
return total;
} Gets the height of the rows that constitute the header as defined by
setHeaderRows(). |
public int getHeaderRows() {
return headerRows;
} Gets the number of the rows that constitute the header. |
public int getHorizontalAlignment() {
return horizontalAlignment;
} Gets the horizontal alignment of the table relative to the page. |
public boolean getKeepTogether() {
return keepTogether;
} Getter for property keepTogether |
public int getNumberOfColumns() {
return relativeWidths.length;
} Returns the number of columns. |
public PdfPRow getRow(int idx) {
return (PdfPRow)rows.get(idx);
} Gets a row with a given index
(added by Jin-Hsia Yang). |
public float getRowHeight(int idx) {
return getRowHeight(idx, false);
} Gets the height of a particular row. |
public float getRowHeight(int idx,
boolean firsttime) {
if (totalWidth < = 0 || idx < 0 || idx >= rows.size())
return 0;
PdfPRow row = (PdfPRow)rows.get(idx);
if (row == null)
return 0;
if (firsttime)
row.setWidths(absoluteWidths);
float height = row.getMaxHeights();
PdfPCell cell;
PdfPRow tmprow;
for (int i = 0; i < relativeWidths.length; i++) {
if(!rowSpanAbove(idx, i))
continue;
int rs = 1;
while (rowSpanAbove(idx - rs, i)) {
rs++;
}
tmprow = (PdfPRow)rows.get(idx - rs);
cell = tmprow.getCells()[i];
float tmp = 0;
if (cell.getRowspan() == rs + 1) {
tmp = cell.getMaxHeight();
while (rs > 0) {
tmp -= getRowHeight(idx - rs);
rs--;
}
}
if (tmp > height)
height = tmp;
}
row.setMaxHeights(height);
return height;
} Gets the height of a particular row. |
public ArrayList getRows() {
return rows;
} Gets an arraylist with all the rows in the table. |
public ArrayList getRows(int start,
int end) {
ArrayList list = new ArrayList();
if (start < 0 || end > size()) {
return list;
}
PdfPRow firstRow = adjustCellsInRow(start, end);
int colIndex = 0;
PdfPCell cell;
while (colIndex < getNumberOfColumns()) {
int rowIndex = start;
while (rowSpanAbove(rowIndex--, colIndex)) {
PdfPRow row = getRow(rowIndex);
if (row != null) {
PdfPCell replaceCell = row.getCells()[colIndex];
if (replaceCell != null) {
firstRow.getCells()[colIndex] = new PdfPCell(replaceCell);
float extra = 0;
int stop = Math.min(rowIndex + replaceCell.getRowspan(), end);
for (int j = start + 1; j < stop; j++) {
extra += getRowHeight(j);
}
firstRow.setExtraHeight(colIndex, extra);
float diff = getRowspanHeight(rowIndex, colIndex)
- getRowHeight(start) - extra;
firstRow.getCells()[colIndex].consumeHeight(diff);
}
}
}
cell = firstRow.getCells()[colIndex];
if (cell == null)
colIndex++;
else
colIndex += cell.getColspan();
}
list.add(firstRow);
for (int i = start + 1; i < end; i++) {
list.add(adjustCellsInRow(i, end));
}
return list;
} Gets an arraylist with a selection of rows. |
public float getRowspanHeight(int rowIndex,
int cellIndex) {
if (totalWidth < = 0 || rowIndex < 0 || rowIndex >= rows.size())
return 0;
PdfPRow row = (PdfPRow)rows.get(rowIndex);
if (row == null || cellIndex >= row.getCells().length)
return 0;
PdfPCell cell = row.getCells()[cellIndex];
if (cell == null)
return 0;
float rowspanHeight = 0;
for (int j = 0; j < cell.getRowspan(); j++) {
rowspanHeight += getRowHeight(rowIndex + j);
}
return rowspanHeight;
} Gets the maximum height of a cell in a particular row (will only be different
from getRowHeight is one of the cells in the row has a rowspan > 1). |
public int getRunDirection() {
return runDirection;
} Returns the run direction of the contents in the table. |
public PdfPTableEvent getTableEvent() {
return tableEvent;
} Gets the table event for this page. |
public float getTotalHeight() {
return totalHeight;
} Gets the total height of the table. |
public float getTotalWidth() {
return totalWidth;
} Gets the full width of the table. |
public float getWidthPercentage() {
return widthPercentage;
} Gets the width percentage that the table will occupy in the page. |
public boolean isComplete() {
return complete;
} |
public boolean isContent() {
return true;
} |
public boolean isExtendLastRow() {
return extendLastRow;
} Gets the value of the last row extension. |
public boolean isHeadersInEvent() {
return headersInEvent;
} Gets the header status inclusion in PdfPTableEvent. |
public boolean isLockedWidth() {
return this.lockedWidth;
} Getter for property lockedWidth. |
public boolean isNestable() {
return true;
} |
public boolean isSkipFirstHeader() {
return skipFirstHeader;
} Tells you if the first header needs to be skipped
(for instance if the header says "continued from the previous page"). |
public boolean isSkipLastFooter() {
return skipLastFooter;
} Tells you if the last footer needs to be skipped
(for instance if the footer says "continued on the next page") |
public boolean isSplitLate() {
return splitLate;
} Gets the property splitLate. |
public boolean isSplitRows() {
return this.splitRows;
} |
public boolean process(ElementListener listener) {
try {
return listener.add(this);
}
catch(DocumentException de) {
return false;
}
} Processes the element by adding it (or the different parts) to an
ElementListener. |
boolean rowSpanAbove(int currRow,
int currCol) {
if ((currCol >= getNumberOfColumns())
|| (currCol < 0)
|| (currRow == 0))
return false;
int row = currRow - 1;
PdfPRow aboveRow = (PdfPRow)rows.get(row);
if (aboveRow == null)
return false;
PdfPCell aboveCell = (PdfPCell)aboveRow.getCells()[currCol];
while ((aboveCell == null) && (row > 0)) {
aboveRow = (PdfPRow)rows.get(--row);
if (aboveRow == null)
return false;
aboveCell = (PdfPCell)aboveRow.getCells()[currCol];
}
int distance = currRow - row;
if (aboveCell == null) {
int col = currCol - 1;
aboveCell = (PdfPCell)aboveRow.getCells()[col];
while ((aboveCell == null) && (row > 0))
aboveCell = (PdfPCell)aboveRow.getCells()[--col];
return aboveCell != null && aboveCell.getRowspan() > distance;
}
if ((aboveCell.getRowspan() == 1) && (distance > 1)) {
int col = currCol - 1;
aboveRow = (PdfPRow)rows.get(row + 1);
distance--;
aboveCell = (PdfPCell)aboveRow.getCells()[col];
while ((aboveCell == null) && (col > 0))
aboveCell = (PdfPCell)aboveRow.getCells()[--col];
}
return aboveCell != null && aboveCell.getRowspan() > distance;
} Checks if there are rows above belonging to a rowspan. |
public void setComplete(boolean complete) {
this.complete = complete;
} |
public void setExtendLastRow(boolean extendLastRow) {
this.extendLastRow = extendLastRow;
} When set the last row will be extended to fill all the remaining space
to the bottom boundary. |
public void setFooterRows(int footerRows) {
if (footerRows < 0)
footerRows = 0;
this.footerRows = footerRows;
} Sets the number of rows to be used for the footer. The number
of footer rows are subtracted from the header rows. For
example, for a table with two header rows and one footer row the
code would be:
table.setHeaderRows(3);
table.setFooterRows(1);
Row 0 and 1 will be the header rows and row 2 will be the footer row. |
public void setHeaderRows(int headerRows) {
if (headerRows < 0)
headerRows = 0;
this.headerRows = headerRows;
} Sets the number of the top rows that constitute the header.
This header has only meaning if the table is added to Document
and the table crosses pages. |
public void setHeadersInEvent(boolean headersInEvent) {
this.headersInEvent = headersInEvent;
} When set the PdfPTableEvent will include the headers. |
public void setHorizontalAlignment(int horizontalAlignment) {
this.horizontalAlignment = horizontalAlignment;
} Sets the horizontal alignment of the table relative to the page.
It only has meaning if the width percentage is less than 100%. |
public void setKeepTogether(boolean keepTogether) {
this.keepTogether = keepTogether;
} If true the table will be kept on one page if it fits, by forcing a
new page if it doesn't fit on the current page. The default is to
split the table over multiple pages. |
public void setLockedWidth(boolean lockedWidth) {
this.lockedWidth = lockedWidth;
} Uses the value in setTotalWidth() in Document.add(). |
public void setRunDirection(int runDirection) {
switch (runDirection) {
case PdfWriter.RUN_DIRECTION_DEFAULT:
case PdfWriter.RUN_DIRECTION_NO_BIDI:
case PdfWriter.RUN_DIRECTION_LTR:
case PdfWriter.RUN_DIRECTION_RTL:
this.runDirection = runDirection;
break;
default:
throw new RuntimeException("Invalid run direction: " + runDirection);
}
} Sets the run direction of the contents of the table. |
public void setSkipFirstHeader(boolean skipFirstHeader) {
this.skipFirstHeader = skipFirstHeader;
} Skips the printing of the first header. Used when printing
tables in succession belonging to the same printed table aspect. |
public void setSkipLastFooter(boolean skipLastFooter) {
this.skipLastFooter = skipLastFooter;
} Skips the printing of the last footer. Used when printing
tables in succession belonging to the same printed table aspect. |
public void setSpacingAfter(float spacing) {
this.spacingAfter = spacing;
} Sets the spacing after this table. |
public void setSpacingBefore(float spacing) {
this.spacingBefore = spacing;
} Sets the spacing before this table. |
public void setSplitLate(boolean splitLate) {
this.splitLate = splitLate;
} If true the row will only split if it's the first one in an empty page.
It's true by default.
It's only meaningful if setSplitRows(true). |
public void setSplitRows(boolean splitRows) {
this.splitRows = splitRows;
} When set the rows that won't fit in the page will be split.
Note that it takes at least twice the memory to handle a split table row
than a normal table. true by default. |
public void setTableEvent(PdfPTableEvent event) {
if (event == null)
this.tableEvent = null;
else if (this.tableEvent == null)
this.tableEvent = event;
else if (this.tableEvent instanceof PdfPTableEventForwarder)
((PdfPTableEventForwarder)this.tableEvent).addTableEvent(event);
else {
PdfPTableEventForwarder forward = new PdfPTableEventForwarder();
forward.addTableEvent(this.tableEvent);
forward.addTableEvent(event);
this.tableEvent = forward;
}
} Sets the table event for this table. |
public void setTotalWidth(float totalWidth) {
if (this.totalWidth == totalWidth)
return;
this.totalWidth = totalWidth;
totalHeight = 0;
calculateWidths();
calculateHeights(true);
} Sets the full width of the table. |
public void setTotalWidth(float[] columnWidth) throws DocumentException {
if (columnWidth.length != getNumberOfColumns())
throw new DocumentException("Wrong number of columns.");
totalWidth = 0;
for (int k = 0; k < columnWidth.length; ++k)
totalWidth += columnWidth[k];
setWidths(columnWidth);
} Sets the full width of the table from the absolute column width. |
public void setWidthPercentage(float widthPercentage) {
this.widthPercentage = widthPercentage;
} Sets the width percentage that the table will occupy in the page. |
public void setWidthPercentage(float[] columnWidth,
Rectangle pageSize) throws DocumentException {
if (columnWidth.length != getNumberOfColumns())
throw new IllegalArgumentException("Wrong number of columns.");
float totalWidth = 0;
for (int k = 0; k < columnWidth.length; ++k)
totalWidth += columnWidth[k];
widthPercentage = totalWidth / (pageSize.getRight() - pageSize.getLeft()) * 100f;
setWidths(columnWidth);
} Sets the percentage width of the table from the absolute column width. |
public void setWidths(float[] relativeWidths) throws DocumentException {
if (relativeWidths.length != getNumberOfColumns())
throw new DocumentException("Wrong number of columns.");
this.relativeWidths = new float[relativeWidths.length];
System.arraycopy(relativeWidths, 0, this.relativeWidths, 0, relativeWidths.length);
absoluteWidths = new float[relativeWidths.length];
totalHeight = 0;
calculateWidths();
calculateHeights(true);
} Sets the relative widths of the table. |
public void setWidths(int[] relativeWidths) throws DocumentException {
float tb[] = new float[relativeWidths.length];
for (int k = 0; k < relativeWidths.length; ++k)
tb[k] = relativeWidths[k];
setWidths(tb);
} Sets the relative widths of the table. |
public static PdfPTable shallowCopy(PdfPTable table) {
PdfPTable nt = new PdfPTable();
nt.copyFormat(table);
return nt;
} Makes a shallow copy of a table (format without content). |
public int size() {
return rows.size();
} Gets the number of rows in this table. |
public float spacingAfter() {
return spacingAfter;
} Gets the spacing after this table. |
public float spacingBefore() {
return spacingBefore;
} Gets the spacing before this table. |
public int type() {
return Element.PTABLE;
} Gets the type of the text element. |
public float writeSelectedRows(int rowStart,
int rowEnd,
float xPos,
float yPos,
PdfContentByte[] canvases) {
return writeSelectedRows(0, -1, rowStart, rowEnd, xPos, yPos, canvases);
} Writes the selected rows to the document.
canvases is obtained from beginWritingRows(). |
public float writeSelectedRows(int rowStart,
int rowEnd,
float xPos,
float yPos,
PdfContentByte canvas) {
return writeSelectedRows(0, -1, rowStart, rowEnd, xPos, yPos, canvas);
} Writes the selected rows to the document. |
public float writeSelectedRows(int colStart,
int colEnd,
int rowStart,
int rowEnd,
float xPos,
float yPos,
PdfContentByte[] canvases) {
if (totalWidth < = 0)
throw new RuntimeException("The table width must be greater than zero.");
int totalRows = rows.size();
if (rowStart < 0)
rowStart = 0;
if (rowEnd < 0)
rowEnd = totalRows;
else
rowEnd = Math.min(rowEnd, totalRows);
if (rowStart >= rowEnd)
return yPos;
int totalCols = getNumberOfColumns();
if (colStart < 0)
colStart = 0;
else
colStart = Math.min(colStart, totalCols);
if (colEnd < 0)
colEnd = totalCols;
else
colEnd = Math.min(colEnd, totalCols);
float yPosStart = yPos;
for (int k = rowStart; k < rowEnd; ++k) {
PdfPRow row = (PdfPRow)rows.get(k);
if (row != null) {
row.writeCells(colStart, colEnd, xPos, yPos, canvases);
yPos -= row.getMaxHeights();
}
}
if (tableEvent != null && colStart == 0 && colEnd == totalCols) {
float heights[] = new float[rowEnd - rowStart + 1];
heights[0] = yPosStart;
for (int k = rowStart; k < rowEnd; ++k) {
PdfPRow row = (PdfPRow)rows.get(k);
float hr = 0;
if (row != null)
hr = row.getMaxHeights();
heights[k - rowStart + 1] = heights[k - rowStart] - hr;
}
tableEvent.tableLayout(this, getEventWidths(xPos, rowStart, rowEnd, headersInEvent), heights, headersInEvent ? headerRows : 0, rowStart, canvases);
}
return yPos;
} Writes the selected rows and columns to the document.
This method does not clip the columns; this is only important
if there are columns with colspan at boundaries.
canvases is obtained from beginWritingRows().
The table event is only fired for complete rows. |
public float writeSelectedRows(int colStart,
int colEnd,
int rowStart,
int rowEnd,
float xPos,
float yPos,
PdfContentByte canvas) {
int totalCols = getNumberOfColumns();
if (colStart < 0)
colStart = 0;
else
colStart = Math.min(colStart, totalCols);
if (colEnd < 0)
colEnd = totalCols;
else
colEnd = Math.min(colEnd, totalCols);
boolean clip = (colStart != 0 || colEnd != totalCols);
if (clip) {
float w = 0;
for (int k = colStart; k < colEnd; ++k)
w += absoluteWidths[k];
canvas.saveState();
float lx = (colStart == 0) ? 10000 : 0;
float rx = (colEnd == totalCols) ? 10000 : 0;
canvas.rectangle(xPos - lx, -10000, w + lx + rx, PdfPRow.RIGHT_LIMIT);
canvas.clip();
canvas.newPath();
}
PdfContentByte[] canvases = beginWritingRows(canvas);
float y = writeSelectedRows(colStart, colEnd, rowStart, rowEnd, xPos, yPos, canvases);
endWritingRows(canvases);
if (clip)
canvas.restoreState();
return y;
} Writes the selected rows and columns to the document.
This method clips the columns; this is only important
if there are columns with colspan at boundaries.
The table event is only fired for complete rows. |
com.lowagie.text.pdf.PdfPTable
Save This Page