| Method from com.lowagie.text.pdf.PdfPTable Detail: |
|---|
 public void addCell(PdfPCell cell) {
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);
currentRow[currentRowIdx] = ncell;
currentRowIdx += colspan;
if (currentRowIdx >= currentRow.length) {
if (runDirection == PdfWriter.RUN_DIRECTION_RTL) {
PdfPCell rtlRow[] = new PdfPCell[absoluteWidths.length];
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[absoluteWidths.length];
currentRowIdx = 0;
}
}
|
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);
} |
public static PdfContentByte[] beginWritingRows(PdfContentByte canvas) {
return new PdfContentByte[]{
canvas,
canvas.getDuplicate(),
canvas.getDuplicate(),
canvas.getDuplicate(),
};
} |
void calculateHeights() {
if (totalWidth < = 0)
return;
totalHeight = 0;
for (int k = 0; k < rows.size(); ++k) {
PdfPRow row = (PdfPRow)rows.get(k);
if (row != null) {
row.setWidths(absoluteWidths);
totalHeight += row.getMaxHeights();
}
}
} |
public void calculateHeightsFast() {
if (totalWidth < = 0)
return;
totalHeight = 0;
for (int k = 0; k < rows.size(); ++k) {
PdfPRow row = (PdfPRow)rows.get(k);
if (row != null)
totalHeight += row.getMaxHeights();
}
} Calculates the heights of the table. |
public void completeRow() {
while (currentRowIdx > 0) {
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. |
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);
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 {
float width[] = new float[absoluteWidths.length + 1];
width[0] = xPos;
for (int k = 0; k < absoluteWidths.length; ++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.min(0, headerRows - footerRows);
int size = Math.min(rows.size(), footerRows);
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 header 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;
} |
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) {
if (totalWidth < = 0 || idx < 0 || idx >= rows.size())
return 0;
PdfPRow row = (PdfPRow)rows.get(idx);
if (row == null)
return 0;
return row.getMaxHeights();
} Gets the height of a particular row. |
public ArrayList getRows() {
return rows;
} Gets an arraylist with all the rows in the table. |
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 this.extendLastRow;
} Gets the value of the last row extension. |
public boolean isHeadersInEvent() {
return this.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;
} Getter for property skipFirstHeader. |
public boolean isSplitLate() {
return this.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. |
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 p_KeepTogether) {
keepTogether = p_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) {
if (runDirection < PdfWriter.RUN_DIRECTION_DEFAULT || runDirection > PdfWriter.RUN_DIRECTION_RTL)
throw new RuntimeException("Invalid run direction: " + runDirection);
this.runDirection = 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 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;
} |
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();
} Sets the full width of the table. |
public void setTotalWidth(float[] columnWidth) throws DocumentException {
if (columnWidth.length != this.relativeWidths.length)
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 != this.relativeWidths.length)
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 != this.relativeWidths.length)
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();
} 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);
} |
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 size = rows.size();
if (rowEnd < 0)
rowEnd = size;
rowEnd = Math.min(rowEnd, size);
if (rowStart < 0)
rowStart = 0;
if (rowStart >= rowEnd)
return yPos;
if (colEnd < 0)
colEnd = absoluteWidths.length;
colEnd = Math.min(colEnd, absoluteWidths.length);
if (colStart < 0)
colStart = 0;
colStart = Math.min(colStart, absoluteWidths.length);
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 == absoluteWidths.length) {
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) {
if (colEnd < 0)
colEnd = absoluteWidths.length;
colEnd = Math.min(colEnd, absoluteWidths.length);
if (colStart < 0)
colStart = 0;
colStart = Math.min(colStart, absoluteWidths.length);
if (colStart != 0 || colEnd != absoluteWidths.length) {
float w = 0;
for (int k = colStart; k < colEnd; ++k)
w += absoluteWidths[k];
canvas.saveState();
float lx = 0;
float rx = 0;
if (colStart == 0)
lx = 10000;
if (colEnd == absoluteWidths.length)
rx = 10000;
canvas.rectangle(xPos - lx, -10000, w + lx + rx, 20000);
canvas.clip();
canvas.newPath();
}
PdfContentByte[] canvases = beginWritingRows(canvas);
float y = writeSelectedRows(colStart, colEnd, rowStart, rowEnd, xPos, yPos, canvases);
endWritingRows(canvases);
if (colStart != 0 || colEnd != absoluteWidths.length)
canvas.restoreState();
return y;
} |
com.lowagie.text.pdf.PdfPTable
Save This Page