iText 5 itextpdf.jar Source Code

itextpdf.jar is a component in iText 5 Java library to provide core functionalities. iText Java library allows you to generate and manage PDF documents.

The Source Code files are provided at iText GitHub site.

You can compile it to generate your JAR file, using pom.xml as the build configuration file.

The source code of itextpdf-5.5.14.jar is provided below:

✍: FYIcenter.com

com/itextpdf/text/pdf/PdfPRow.java

/*
 *
 * This file is part of the iText (R) project.
    Copyright (c) 1998-2020 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;
    }
}

com/itextpdf/text/pdf/PdfPRow.java

 

⇒ iText-2.1.6.jar - iText, a JAVA-PDF library

⇐ iText layout.jar Source Code

⇑ Download and Install iText Java Library

⇑⇑ iText for PDF Generation

2021-07-03, 47933👍, 0💬