/*
 * $Id: 2e0ec56d4ddf05644df9eb5257e202956c9e9fa4 $
 *
 * This file is part of the iText (R) project.
 * Copyright (c) 1998-2015 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.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) {
        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;
    }
}
