Java tutorial
/* * * This file is part of the iText (R) project. Copyright (c) 1998-2019 iText Group NV * Authors: Bruno Lowagie, Paulo Soares, et al. * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU Affero General Public License version 3 * as published by the Free Software Foundation with the addition of the * following permission added to Section 15 as permitted in Section 7(a): * FOR ANY PART OF THE COVERED WORK IN WHICH THE COPYRIGHT IS OWNED BY * ITEXT GROUP. ITEXT GROUP DISCLAIMS THE WARRANTY OF NON INFRINGEMENT * OF THIRD PARTY RIGHTS * * This program is distributed in the hope that it will be useful, but * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY * or FITNESS FOR A PARTICULAR PURPOSE. * See the GNU Affero General Public License for more details. * You should have received a copy of the GNU Affero General Public License * along with this program; if not, see http://www.gnu.org/licenses or write to * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA, 02110-1301 USA, or download the license from the following URL: * http://itextpdf.com/terms-of-use/ * * The interactive user interfaces in modified source and object code versions * of this program must display Appropriate Legal Notices, as required under * Section 5 of the GNU Affero General Public License. * * In accordance with Section 7(b) of the GNU Affero General Public License, * a covered work must retain the producer line in every PDF that is created * or manipulated using iText. * * You can be released from the requirements of the license by purchasing * a commercial license. Buying such a license is mandatory as soon as you * develop commercial activities involving the iText software without * disclosing the source code of your own applications. * These activities include: offering paid services to customers as an ASP, * serving PDFs on the fly in a web application, shipping iText with a closed * source product. * * For more information, please contact iText Software Corp. at this * address: sales@itextpdf.com */ package com.itextpdf.text.pdf; import java.util.HashMap; import com.itextpdf.text.*; import com.itextpdf.text.log.Level; import com.itextpdf.text.log.Logger; import com.itextpdf.text.log.LoggerFactory; import com.itextpdf.text.pdf.interfaces.IAccessibleElement; /** * A row in a PdfPTable. * * @author Paulo Soares */ public class PdfPRow implements IAccessibleElement { private final Logger LOGGER = LoggerFactory.getLogger(PdfPRow.class); /** * True if the table may not break after this row. */ public boolean mayNotBreak = false; /** * the bottom limit (bottom right y) */ public static final float BOTTOM_LIMIT = -(1 << 30); /** * the right limit * * @since 2.1.5 */ public static final float RIGHT_LIMIT = 20000; protected PdfPCell cells[]; protected float widths[]; /** * extra heights that needs to be added to a cell because of rowspans. * * @since 2.1.6 */ protected float extraHeights[]; protected float maxHeight = 0; protected boolean calculated = false; protected boolean adjusted = false; private int[] canvasesPos; protected PdfName role = PdfName.TR; protected HashMap<PdfName, PdfObject> accessibleAttributes = null; protected AccessibleElementId id = new AccessibleElementId(); /** * Constructs a new PdfPRow with the cells in the array that was passed as a * parameter. * * @param cells */ public PdfPRow(PdfPCell cells[]) { this(cells, null); } public PdfPRow(PdfPCell cells[], PdfPRow source) { this.cells = cells; widths = new float[cells.length]; initExtraHeights(); if (source != null) { this.id = source.id; this.role = source.role; if (source.accessibleAttributes != null) { this.accessibleAttributes = new HashMap<PdfName, PdfObject>(source.accessibleAttributes); } } } /** * Makes a copy of an existing row. * * @param row */ public PdfPRow(PdfPRow row) { mayNotBreak = row.mayNotBreak; maxHeight = row.maxHeight; calculated = row.calculated; cells = new PdfPCell[row.cells.length]; for (int k = 0; k < cells.length; ++k) { if (row.cells[k] != null) { if (row.cells[k] instanceof PdfPHeaderCell) { cells[k] = new PdfPHeaderCell((PdfPHeaderCell) row.cells[k]); } else { cells[k] = new PdfPCell(row.cells[k]); } } } widths = new float[cells.length]; System.arraycopy(row.widths, 0, widths, 0, cells.length); initExtraHeights(); this.id = row.id; this.role = row.role; if (row.accessibleAttributes != null) { this.accessibleAttributes = new HashMap<PdfName, PdfObject>(row.accessibleAttributes); } } /** * Sets the widths of the columns in the row. * * @param widths * @return true if everything went right */ public boolean setWidths(float widths[]) { if (widths.length != cells.length) { return false; } System.arraycopy(widths, 0, this.widths, 0, cells.length); float total = 0; calculated = false; for (int k = 0; k < widths.length; ++k) { PdfPCell cell = cells[k]; if (cell == null) { total += widths[k]; continue; } cell.setLeft(total); int last = k + cell.getColspan(); for (; k < last; ++k) { total += widths[k]; } --k; cell.setRight(total); cell.setTop(0); } return true; } /** * Initializes the extra heights array. * * @since 2.1.6 */ protected void initExtraHeights() { extraHeights = new float[cells.length]; for (int i = 0; i < extraHeights.length; i++) { extraHeights[i] = 0; } } /** * Sets an extra height for a cell. * * @param cell the index of the cell that needs an extra height * @param height the extra height * @since 2.1.6 */ public void setExtraHeight(int cell, float height) { if (cell < 0 || cell >= cells.length) { return; } extraHeights[cell] = height; } /** * Calculates the heights of each cell in the row. */ protected void calculateHeights() { maxHeight = 0; LOGGER.info("calculateHeights"); for (int k = 0; k < cells.length; ++k) { PdfPCell cell = cells[k]; float height = 0; if (cell == null) { continue; } else { if (cell.hasCalculatedHeight()) { height = cell.getCalculatedHeight(); } else { height = cell.getMaxHeight(); } if ((height > maxHeight) && (cell.getRowspan() == 1)) { maxHeight = height; } } } calculated = true; } /** * Setter for the mayNotBreak variable. */ public void setMayNotBreak(boolean mayNotBreak) { this.mayNotBreak = mayNotBreak; } /** * Getter for the mayNotbreak variable. */ public boolean isMayNotBreak() { return mayNotBreak; } /** * Writes the border and background of one cell in the row. * * @param xPos The x-coordinate where the table starts on the canvas * @param yPos The y-coordinate where the table starts on the canvas * @param currentMaxHeight The height of the cell to be drawn. * @param cell * @param canvases * @since 2.1.6 extra parameter currentMaxHeight */ public void writeBorderAndBackground(float xPos, float yPos, float currentMaxHeight, PdfPCell cell, PdfContentByte[] canvases) { BaseColor background = cell.getBackgroundColor(); if (background != null || cell.hasBorders()) { // Add xPos resp. yPos to the cell's coordinates for absolute coordinates float right = cell.getRight() + xPos; float top = cell.getTop() + yPos; float left = cell.getLeft() + xPos; float bottom = top - currentMaxHeight; if (background != null) { PdfContentByte backgr = canvases[PdfPTable.BACKGROUNDCANVAS]; backgr.setColorFill(background); backgr.rectangle(left, bottom, right - left, top - bottom); backgr.fill(); } if (cell.hasBorders()) { Rectangle newRect = new Rectangle(left, bottom, right, top); // Clone non-position parameters except for the background color newRect.cloneNonPositionParameters(cell); newRect.setBackgroundColor(null); // Write the borders on the line canvas PdfContentByte lineCanvas = canvases[PdfPTable.LINECANVAS]; lineCanvas.rectangle(newRect); } } } /** * @since 2.1.6 private is now protected */ protected void saveAndRotateCanvases(PdfContentByte[] canvases, float a, float b, float c, float d, float e, float f) { int last = PdfPTable.TEXTCANVAS + 1; if (canvasesPos == null) { canvasesPos = new int[last * 2]; } for (int k = 0; k < last; ++k) { ByteBuffer bb = canvases[k].getInternalBuffer(); canvasesPos[k * 2] = bb.size(); canvases[k].saveState(); canvases[k].concatCTM(a, b, c, d, e, f); canvasesPos[k * 2 + 1] = bb.size(); } } /** * @since 2.1.6 private is now protected */ protected void restoreCanvases(PdfContentByte[] canvases) { int last = PdfPTable.TEXTCANVAS + 1; for (int k = 0; k < last; ++k) { ByteBuffer bb = canvases[k].getInternalBuffer(); int p1 = bb.size(); canvases[k].restoreState(); if (p1 == canvasesPos[k * 2 + 1]) { bb.setSize(canvasesPos[k * 2]); } } } /** * @since 3.0.0 protected is now public static */ public static float setColumn(ColumnText ct, float left, float bottom, float right, float top) { if (left > right) { right = left; } if (bottom > top) { top = bottom; } ct.setSimpleColumn(left, bottom, right, top); return top; } /** * Writes a number of cells (not necessarily all cells). * * @param colStart The first column to be written. Remember that the column * index starts with 0. * @param colEnd The last column to be written. Remember that the column * index starts with 0. If -1, all the columns to the end are written. * @param xPos The x-coordinate where the table starts on the canvas * @param yPos The y-coordinate where the table starts on the canvas * @param reusable if set to false, the content in the cells is "consumed"; * if true, you can reuse the cells, the row, the parent table as many times * you want. * @since 5.1.0 added the reusable parameter */ public void writeCells(int colStart, int colEnd, float xPos, float yPos, PdfContentByte[] canvases, boolean reusable) { if (!calculated) { calculateHeights(); } if (colEnd < 0) { colEnd = cells.length; } else { colEnd = Math.min(colEnd, cells.length); } if (colStart < 0) { colStart = 0; } if (colStart >= colEnd) { return; } int newStart; for (newStart = colStart; newStart >= 0; --newStart) { if (cells[newStart] != null) { break; } if (newStart > 0) { xPos -= widths[newStart - 1]; } } if (newStart < 0) { newStart = 0; } if (cells[newStart] != null) { xPos -= cells[newStart].getLeft(); } if (isTagged(canvases[PdfPTable.TEXTCANVAS])) { canvases[PdfPTable.TEXTCANVAS].openMCBlock(this); } for (int k = newStart; k < colEnd; ++k) { PdfPCell cell = cells[k]; if (cell == null) { continue; } if (isTagged(canvases[PdfPTable.TEXTCANVAS])) { canvases[PdfPTable.TEXTCANVAS].openMCBlock(cell); } float currentMaxHeight = maxHeight + extraHeights[k]; writeBorderAndBackground(xPos, yPos, currentMaxHeight, cell, canvases); Image img = cell.getImage(); float tly = cell.getTop() + yPos - cell.getEffectivePaddingTop(); if (cell.getHeight() <= currentMaxHeight) { switch (cell.getVerticalAlignment()) { case Element.ALIGN_BOTTOM: tly = cell.getTop() + yPos - currentMaxHeight + cell.getHeight() - cell.getEffectivePaddingTop(); break; case Element.ALIGN_MIDDLE: tly = cell.getTop() + yPos + (cell.getHeight() - currentMaxHeight) / 2 - cell.getEffectivePaddingTop(); break; default: break; } } if (img != null) { if (cell.getRotation() != 0) { img = Image.getInstance(img); img.setRotation(img.getImageRotation() + (float) (cell.getRotation() * Math.PI / 180.0)); } boolean vf = false; if (cell.getHeight() > currentMaxHeight) { if (!img.isScaleToFitHeight()) { continue; } img.scalePercent(100); float scale = (currentMaxHeight - cell.getEffectivePaddingTop() - cell.getEffectivePaddingBottom()) / img.getScaledHeight(); img.scalePercent(scale * 100); vf = true; } float left = cell.getLeft() + xPos + cell.getEffectivePaddingLeft(); if (vf) { switch (cell.getHorizontalAlignment()) { case Element.ALIGN_CENTER: left = xPos + (cell.getLeft() + cell.getEffectivePaddingLeft() + cell.getRight() - cell.getEffectivePaddingRight() - img.getScaledWidth()) / 2; break; case Element.ALIGN_RIGHT: left = xPos + cell.getRight() - cell.getEffectivePaddingRight() - img.getScaledWidth(); break; default: break; } tly = cell.getTop() + yPos - cell.getEffectivePaddingTop(); } img.setAbsolutePosition(left, tly - img.getScaledHeight()); try { if (isTagged(canvases[PdfPTable.TEXTCANVAS])) { canvases[PdfPTable.TEXTCANVAS].openMCBlock(img); } canvases[PdfPTable.TEXTCANVAS].addImage(img); if (isTagged(canvases[PdfPTable.TEXTCANVAS])) { canvases[PdfPTable.TEXTCANVAS].closeMCBlock(img); } } catch (DocumentException e) { throw new ExceptionConverter(e); } } else { // rotation sponsored by Connection GmbH if (cell.getRotation() == 90 || cell.getRotation() == 270) { float netWidth = currentMaxHeight - cell.getEffectivePaddingTop() - cell.getEffectivePaddingBottom(); float netHeight = cell.getWidth() - cell.getEffectivePaddingLeft() - cell.getEffectivePaddingRight(); ColumnText ct = ColumnText.duplicate(cell.getColumn()); ct.setCanvases(canvases); ct.setSimpleColumn(0, 0, netWidth + 0.001f, -netHeight); try { ct.go(true); } catch (DocumentException e) { throw new ExceptionConverter(e); } float calcHeight = -ct.getYLine(); if (netWidth <= 0 || netHeight <= 0) { calcHeight = 0; } if (calcHeight > 0) { if (cell.isUseDescender()) { calcHeight -= ct.getDescender(); } if (reusable) { ct = ColumnText.duplicate(cell.getColumn()); } else { ct = cell.getColumn(); } ct.setCanvases(canvases); ct.setSimpleColumn(-0.003f, -0.001f, netWidth + 0.003f, calcHeight); float pivotX; float pivotY; if (cell.getRotation() == 90) { pivotY = cell.getTop() + yPos - currentMaxHeight + cell.getEffectivePaddingBottom(); switch (cell.getVerticalAlignment()) { case Element.ALIGN_BOTTOM: pivotX = cell.getLeft() + xPos + cell.getWidth() - cell.getEffectivePaddingRight(); break; case Element.ALIGN_MIDDLE: pivotX = cell.getLeft() + xPos + (cell.getWidth() + cell.getEffectivePaddingLeft() - cell.getEffectivePaddingRight() + calcHeight) / 2; break; default: //top pivotX = cell.getLeft() + xPos + cell.getEffectivePaddingLeft() + calcHeight; break; } saveAndRotateCanvases(canvases, 0, 1, -1, 0, pivotX, pivotY); } else { pivotY = cell.getTop() + yPos - cell.getEffectivePaddingTop(); switch (cell.getVerticalAlignment()) { case Element.ALIGN_BOTTOM: pivotX = cell.getLeft() + xPos + cell.getEffectivePaddingLeft(); break; case Element.ALIGN_MIDDLE: pivotX = cell.getLeft() + xPos + (cell.getWidth() + cell.getEffectivePaddingLeft() - cell.getEffectivePaddingRight() - calcHeight) / 2; break; default: //top pivotX = cell.getLeft() + xPos + cell.getWidth() - cell.getEffectivePaddingRight() - calcHeight; break; } saveAndRotateCanvases(canvases, 0, -1, 1, 0, pivotX, pivotY); } try { ct.go(); } catch (DocumentException e) { throw new ExceptionConverter(e); } finally { restoreCanvases(canvases); } } } else { float fixedHeight = cell.getFixedHeight(); float rightLimit = cell.getRight() + xPos - cell.getEffectivePaddingRight(); float leftLimit = cell.getLeft() + xPos + cell.getEffectivePaddingLeft(); if (cell.isNoWrap()) { switch (cell.getHorizontalAlignment()) { case Element.ALIGN_CENTER: rightLimit += 10000; leftLimit -= 10000; break; case Element.ALIGN_RIGHT: if (cell.getRotation() == 180) { rightLimit += RIGHT_LIMIT; } else { leftLimit -= RIGHT_LIMIT; } break; default: if (cell.getRotation() == 180) { leftLimit -= RIGHT_LIMIT; } else { rightLimit += RIGHT_LIMIT; } break; } } ColumnText ct; if (reusable) { ct = ColumnText.duplicate(cell.getColumn()); } else { ct = cell.getColumn(); } ct.setCanvases(canvases); float bry = tly - (currentMaxHeight - cell.getEffectivePaddingTop() - cell.getEffectivePaddingBottom()); if (fixedHeight > 0) { if (cell.getHeight() > currentMaxHeight) { tly = cell.getTop() + yPos - cell.getEffectivePaddingTop(); bry = cell.getTop() + yPos - currentMaxHeight + cell.getEffectivePaddingBottom(); } } if ((tly > bry || ct.zeroHeightElement()) && leftLimit < rightLimit) { ct.setSimpleColumn(leftLimit, bry - 0.001f, rightLimit, tly); if (cell.getRotation() == 180) { float shx = leftLimit + rightLimit; float shy = yPos + yPos - currentMaxHeight + cell.getEffectivePaddingBottom() - cell.getEffectivePaddingTop(); saveAndRotateCanvases(canvases, -1, 0, 0, -1, shx, shy); } try { ct.go(); } catch (DocumentException e) { throw new ExceptionConverter(e); } finally { if (cell.getRotation() == 180) { restoreCanvases(canvases); } } } } } PdfPCellEvent evt = cell.getCellEvent(); if (evt != null) { Rectangle rect = new Rectangle(cell.getLeft() + xPos, cell.getTop() + yPos - currentMaxHeight, cell.getRight() + xPos, cell.getTop() + yPos); evt.cellLayout(cell, rect, canvases); } if (isTagged(canvases[PdfPTable.TEXTCANVAS])) { canvases[PdfPTable.TEXTCANVAS].closeMCBlock(cell); } } if (isTagged(canvases[PdfPTable.TEXTCANVAS])) { canvases[PdfPTable.TEXTCANVAS].closeMCBlock(this); } } /** * Checks if the dimensions of the columns were calculated. * * @return true if the dimensions of the columns were calculated */ public boolean isCalculated() { return calculated; } /** * Gets the maximum height of the row (i.e. of the 'highest' cell). * * @return the maximum height of the row */ public float getMaxHeights() { if (!calculated) { calculateHeights(); } return maxHeight; } /** * Changes the maximum height of the row (to make it higher). (added by * Jin-Hsia Yang) * * @param maxHeight the new maximum height */ public void setMaxHeights(float maxHeight) { this.maxHeight = maxHeight; } //end add float[] getEventWidth(float xPos, float[] absoluteWidths) { int n = 1; for (int k = 0; k < cells.length;) { if (cells[k] != null) { n++; k += cells[k].getColspan(); } else { while (k < cells.length && cells[k] == null) { n++; k++; } } } float width[] = new float[n]; width[0] = xPos; n = 1; for (int k = 0; k < cells.length && n < width.length;) { if (cells[k] != null) { int colspan = cells[k].getColspan(); width[n] = width[n - 1]; for (int i = 0; i < colspan && k < absoluteWidths.length; i++) { width[n] += absoluteWidths[k++]; } n++; } else { width[n] = width[n - 1]; while (k < cells.length && cells[k] == null) { width[n] += absoluteWidths[k++]; } n++; } } return width; } /** * Copies the content of a specific row in a table to this row. Don't do * this if the rows have a different number of cells. * * @param table the table from which you want to copy a row * @param idx the index of the row that needs to be copied * @since 5.1.0 */ public void copyRowContent(PdfPTable table, int idx) { if (table == null) { return; } PdfPCell copy; for (int i = 0; i < cells.length; ++i) { int lastRow = idx; copy = table.getRow(lastRow).getCells()[i]; while (copy == null && lastRow > 0) { copy = table.getRow(--lastRow).getCells()[i]; } if (cells[i] != null && copy != null) { cells[i].setColumn(copy.getColumn()); this.calculated = false; } } } /** * Splits a row to newHeight. The returned row is the remainder. It will * return null if the newHeight was so small that only an empty row would * result. * * @param new_height the new height * @return the remainder row or null if the newHeight was so small that only * an empty row would result */ public PdfPRow splitRow(PdfPTable table, int rowIndex, float new_height) { if (LOGGER.isLogging(Level.INFO)) { LOGGER.info(String.format("Splitting row %s available height: %s", rowIndex, new_height)); } // second part of the row PdfPCell newCells[] = new PdfPCell[cells.length]; float calHs[] = new float[cells.length]; float fixHs[] = new float[cells.length]; float minHs[] = new float[cells.length]; boolean allEmpty = true; // loop over all the cells for (int k = 0; k < cells.length; ++k) { float newHeight = new_height; PdfPCell cell = cells[k]; if (cell == null) { int index = rowIndex; if (table.rowSpanAbove(index, k)) { while (table.rowSpanAbove(--index, k)) { newHeight += table.getRow(index).getMaxHeights(); } PdfPRow row = table.getRow(index); if (row != null && row.getCells()[k] != null) { newCells[k] = new PdfPCell(row.getCells()[k]); newCells[k].setColumn(null); newCells[k].setRowspan(row.getCells()[k].getRowspan() - rowIndex + index); allEmpty = false; } } continue; } calHs[k] = cell.getCalculatedHeight(); fixHs[k] = cell.getFixedHeight(); minHs[k] = cell.getMinimumHeight(); Image img = cell.getImage(); PdfPCell newCell = new PdfPCell(cell); if (img != null) { float padding = cell.getEffectivePaddingBottom() + cell.getEffectivePaddingTop() + 2; if ((img.isScaleToFitHeight() || img.getScaledHeight() + padding < newHeight) && newHeight > padding) { newCell.setPhrase(null); allEmpty = false; } } else { float y; ColumnText ct = ColumnText.duplicate(cell.getColumn()); float left = cell.getLeft() + cell.getEffectivePaddingLeft(); float bottom = cell.getTop() + cell.getEffectivePaddingBottom() - newHeight; float right = cell.getRight() - cell.getEffectivePaddingRight(); float top = cell.getTop() - cell.getEffectivePaddingTop(); switch (cell.getRotation()) { case 90: case 270: y = setColumn(ct, bottom, left, top, right); break; default: y = setColumn(ct, left, bottom + 0.00001f, cell.isNoWrap() ? RIGHT_LIMIT : right, top); break; } int status; try { status = ct.go(true); } catch (DocumentException e) { throw new ExceptionConverter(e); } boolean thisEmpty = (ct.getYLine() == y); if (thisEmpty) { newCell.setColumn(ColumnText.duplicate(cell.getColumn())); ct.setFilledWidth(0); } else if ((status & ColumnText.NO_MORE_TEXT) == 0) { newCell.setColumn(ct); ct.setFilledWidth(0); } else { newCell.setPhrase(null); } allEmpty = (allEmpty && thisEmpty); } newCells[k] = newCell; cell.setCalculatedHeight(newHeight); } if (allEmpty) { for (int k = 0; k < cells.length; ++k) { PdfPCell cell = cells[k]; if (cell == null) { continue; } cell.setCalculatedHeight(calHs[k]); if (fixHs[k] > 0) { cell.setFixedHeight(fixHs[k]); } else { cell.setMinimumHeight(minHs[k]); } } return null; } calculateHeights(); PdfPRow split = new PdfPRow(newCells, this); split.widths = (float[]) widths.clone(); return split; } // Contributed by Deutsche Bahn Systel GmbH (Thorsten Seitz), splitting row spans public float getMaxRowHeightsWithoutCalculating() { return maxHeight; } // Contributed by Deutsche Bahn Systel GmbH (Thorsten Seitz), splitting row spans public void setFinalMaxHeights(float maxHeight) { setMaxHeights(maxHeight); calculated = true; // otherwise maxHeight would be recalculated in getter } // Contributed by Deutsche Bahn Systel GmbH (Thorsten Seitz), splitting row spans /** * Split rowspan of cells with rowspan on next page by inserting copies with * the remaining rowspan and reducing the previous rowspan appropriately, * i.e. if a cell with rowspan 7 gets split after 3 rows of that rowspan * have been laid out, its column on the next page should start with an * empty cell having the same attributes and rowspan 7 - 3 = 4. * * @since iText 5.4.3 */ public void splitRowspans(PdfPTable original, int originalIdx, PdfPTable part, int partIdx) { if (original == null || part == null) { return; } int i = 0; while (i < cells.length) { if (cells[i] == null) { int splittedRowIdx = original.getCellStartRowIndex(originalIdx, i); int copyRowIdx = part.getCellStartRowIndex(partIdx, i); PdfPCell splitted = original.getRow(splittedRowIdx).getCells()[i]; // need this to reduce its rowspan PdfPCell copy = part.getRow(copyRowIdx).getCells()[i]; // need this for (partially) consumed ColumnText if (splitted != null) { assert (copy != null); // both null or none cells[i] = new PdfPCell(copy); int rowspanOnPreviousPage = partIdx - copyRowIdx + 1; cells[i].setRowspan(copy.getRowspan() - rowspanOnPreviousPage); splitted.setRowspan(rowspanOnPreviousPage); this.calculated = false; } ++i; } else { i += cells[i].getColspan(); } } } /** * Returns the array of cells in the row. Please be extremely careful with * this method. Use the cells as read only objects. * * @return an array of cells * @since 2.1.1 */ public PdfPCell[] getCells() { return cells; } /** * Checks if a cell in the row has a rowspan greater than 1. * * @since 5.1.0 */ public boolean hasRowspan() { for (int i = 0; i < cells.length; i++) { if (cells[i] != null && cells[i].getRowspan() > 1) { return true; } } return false; } public boolean isAdjusted() { return adjusted; } public void setAdjusted(boolean adjusted) { this.adjusted = adjusted; } public PdfObject getAccessibleAttribute(final PdfName key) { if (accessibleAttributes != null) { return accessibleAttributes.get(key); } else { return null; } } public void setAccessibleAttribute(final PdfName key, final PdfObject value) { if (accessibleAttributes == null) { accessibleAttributes = new HashMap<PdfName, PdfObject>(); } accessibleAttributes.put(key, value); } public HashMap<PdfName, PdfObject> getAccessibleAttributes() { return accessibleAttributes; } public PdfName getRole() { return role; } public void setRole(final PdfName role) { this.role = role; } public AccessibleElementId getId() { return id; } public void setId(final AccessibleElementId id) { this.id = id; } static private boolean isTagged(PdfContentByte canvas) { return canvas != null && canvas.writer != null && canvas.writer.isTagged(); } public boolean isInline() { return false; } }