public PdfCell(Cell cell,
    int rownumber,
    float left,
    float right,
    float top,
    float cellspacing,
    float cellpadding) 
{
    // constructors
        // constructs a Rectangle (the bottomvalue will be changed afterwards)
        super(left, top, right, top);
        // copying the other Rectangle attributes from class Cell
        cloneNonPositionParameters(cell);
        this.cellpadding = cellpadding;
        this.cellspacing = cellspacing;
        this.verticalAlignment = cell.getVerticalAlignment();
        this.useAscender = cell.isUseAscender();
        this.useDescender = cell.isUseDescender();
        this.useBorderPadding = cell.isUseBorderPadding();
        // initialization of some parameters
        PdfChunk chunk;
        Element element;
        PdfChunk overflow;
        lines = new ArrayList();
        images = new ArrayList();
        leading = cell.getLeading();
        int alignment = cell.getHorizontalAlignment();
        left += cellspacing + cellpadding;
        right -= cellspacing + cellpadding;
        left += getBorderWidthInside(LEFT);
        right -= getBorderWidthInside(RIGHT);
        contentHeight = 0;
        rowspan = cell.getRowspan();
        ArrayList allActions;
        int aCounter;
        // we loop over all the elements of the cell
        for (Iterator i = cell.getElements(); i.hasNext();) {
            element = (Element) i.next();
            switch (element.type()) {
                case Element.JPEG:
                case Element.JPEG2000:
                case Element.IMGRAW:
                case Element.IMGTEMPLATE:
                    addImage((Image) element, left, right, 0.4f * leading, alignment); //
                    break;
                    // if the element is a list
                case Element.LIST:
                    if (line != null && line.size()  > 0) {
                        line.resetAlignment();
                        addLine(line);
                    }
                    // we loop over all the listitems
                    addList((List)element, left, right, alignment);
                    line = new PdfLine(left, right, alignment, leading);
                    break;
                    // if the element is something else
                default:
                    allActions = new ArrayList();
                    processActions(element, null, allActions);
                    aCounter = 0;
                    float currentLineLeading = leading;
                    float currentLeft = left;
                    float currentRight = right;
                    if (element instanceof Phrase) {
                        currentLineLeading = ((Phrase) element).getLeading();
                    }
                    if (element instanceof Paragraph) {
                        Paragraph p = (Paragraph) element;
                        currentLeft += p.getIndentationLeft();
                        currentRight -= p.getIndentationRight();
                    }
                    if (line == null) {
                        line = new PdfLine(currentLeft, currentRight, alignment, currentLineLeading);
                    }
                    // we loop over the chunks
                    ArrayList chunks = element.getChunks();
                    if (chunks.isEmpty()) {
                       addLine(line); // add empty line - all cells need some lines even if they are empty
                       line = new PdfLine(currentLeft, currentRight, alignment, currentLineLeading);
                    }
                    else {
                        for (Iterator j = chunks.iterator(); j.hasNext();) {
                            Chunk c = (Chunk) j.next();
                            chunk = new PdfChunk(c, (PdfAction) (allActions.get(aCounter++)));
                            while ((overflow = line.add(chunk)) != null) {
                                addLine(line);
                                line = new PdfLine(currentLeft, currentRight, alignment, currentLineLeading);
                                chunk = overflow;
                            }
                        }
                    }
                    // if the element is a paragraph, section or chapter, we reset the alignment and add the line
                    switch (element.type()) {
                        case Element.PARAGRAPH:
                        case Element.SECTION:
                        case Element.CHAPTER:
                            line.resetAlignment();
                            flushCurrentLine();
                    }
            }
        }
        flushCurrentLine();
        if (lines.size()  > cell.getMaxLines()) {
            while (lines.size()  > cell.getMaxLines()) {
                removeLine(lines.size() - 1);
            }
            if (cell.getMaxLines()  > 0) {
                String more = cell.getShowTruncation();
                if (more != null && more.length()  > 0) {
                    // Denote that the content has been truncated
                    lastLine = (PdfLine) lines.get(lines.size() - 1);
                    if (lastLine.size()  >= 0) {
                        PdfChunk lastChunk = lastLine.getChunk(lastLine.size() - 1);
                        float moreWidth = new PdfChunk(more, lastChunk).width();
                        while (lastChunk.toString().length()  > 0 && lastChunk.width() + moreWidth  > right - left) {
                            // Remove characters to leave room for the 'more' indicator
                            lastChunk.setValue(lastChunk.toString().substring(0, lastChunk.length() - 1));
                        }
                        lastChunk.setValue(lastChunk.toString() + more);
                    } else {
                        lastLine.add(new PdfChunk(new Chunk(more), null));
                    }
                }
            }
        }
        // we set some additional parameters
        if (useDescender && lastLine != null) {
            contentHeight -= lastLine.getDescender();
        }
        // adjust first line height so that it touches the top
        if (!lines.isEmpty()) {
            firstLine = (PdfLine) lines.get(0);
            float firstLineRealHeight = firstLineRealHeight();
            contentHeight -= firstLine.height();
            firstLine.height = firstLineRealHeight;
            contentHeight += firstLineRealHeight;
        }
        float newBottom = top - contentHeight - (2f * cellpadding()) - (2f * cellspacing());
        newBottom -= getBorderWidthInside(TOP) + getBorderWidthInside(BOTTOM);
        setBottom(newBottom);
        this.rownumber = rownumber;
}

Constructs a PdfCell-object.

Parameters:

cell - the original Cell

rownumber - the number of the Row the Cell was in.

left - the left border of the PdfCell

right - the right border of the PdfCell

top - the top border of the PdfCell

cellspacing - the cellspacing of the Table

cellpadding - the cellpadding of the Table

 public float cellpadding() 
{
        return cellpadding;
}

Gets the cellpadding of a cell..

 public float cellspacing() 
{
        return cellspacing;
}

Gets the cellspacing of a cell.

 public float getBottom() 
{
        return super.getBottom(cellspacing);
}

Returns the lower left y-coordinate.

 public int getGroupNumber() 
{
        return groupNumber;
}

Gets the number of the group this cell is in..

 public ArrayList getImages(float top,
    float bottom) 
{
        // if the bottom of the page is higher than the top of the cell: do nothing
        if (getTop() <  bottom) {
            return new ArrayList();
        }
        top = Math.min(getTop(), top);
        // initializations
        Image image;
        float height;
        ArrayList result = new ArrayList();
        // we loop over the images
        for (Iterator i = images.iterator(); i.hasNext() && !header;) {
            image = (Image) i.next();
            height = image.getAbsoluteY();
            // if the currentPosition is higher than the bottom, we add the line to the result
            if (top - height  > (bottom + cellpadding)) {
                image.setAbsolutePosition(image.getAbsoluteX(), top - height);
                result.add(image);
                i.remove();
            }
        }
        return result;
}

Gets the images of a cell that can be drawn between certain limits.

Remark: all the lines that can be drawn are removed from the object!

 public float getLeft() 
{
        return super.getLeft(cellspacing);
}

Returns the lower left x-coordinate.

 public ArrayList getLines(float top,
    float bottom) 
{
        float lineHeight;
        float currentPosition = Math.min(getTop(), top);
        setTop(currentPosition + cellspacing);
        ArrayList result = new ArrayList();
        // if the bottom of the page is higher than the top of the cell: do nothing
        if (getTop() <  bottom) {
            return result;
        }
        // we loop over the lines
        int size = lines.size();
        boolean aboveBottom = true;
        for (int i = 0; i <  size && aboveBottom; i++) {
            line = (PdfLine) lines.get(i);
            lineHeight = line.height();
            currentPosition -= lineHeight;
            // if the currentPosition is higher than the bottom, we add the line to the result
            if (currentPosition  > (bottom + cellpadding + getBorderWidthInside(BOTTOM))) {
                result.add(line);
            } else {
                aboveBottom = false;
            }
        }
        // if the bottom of the cell is higher than the bottom of the page, the cell is written, so we can remove all lines
        float difference = 0f;
        if (!header) {
            if (aboveBottom) {
                lines = new ArrayList();
                contentHeight = 0f;
            } else {
                size = result.size();
                for (int i = 0; i <  size; i++) {
                    line = removeLine(0);
                    difference += line.height();
                }
            }
        }
        if (difference  > 0) {
            Image image;
            for (Iterator i = images.iterator(); i.hasNext();) {
                image = (Image) i.next();
                image.setAbsolutePosition(image.getAbsoluteX(), image.getAbsoluteY() - difference - leading);
            }
        }
        return result;
}

Gets the lines of a cell that can be drawn between certain limits.

Remark: all the lines that can be drawn are removed from the object!

 public float getRight() 
{
        return super.getRight(cellspacing);
}

Returns the upper right x-coordinate.

 public float getTop() 
{
        return super.getTop(cellspacing);
}

Returns the upper right y-coordinate.

 boolean isHeader() 
{
        return header;
}

Checks if this cell belongs to the header of a PdfTable.

 public boolean isUseAscender() 
{
        return useAscender;
}

Gets the value of useAscender

 public boolean isUseBorderPadding() 
{
        return useBorderPadding;
}

Gets the value of useBorderPadding.

 public boolean isUseDescender() 
{
        return useDescender;
}

gets the value of useDescender

 public float leading() 
{
        return leading;
}

Gets the leading of a cell.

 boolean mayBeRemoved() 
{
        return (header || (lines.isEmpty() && images.isEmpty()));
}

Checks if the cell may be removed.

Headers may always be removed, even if they are drawn only partially: they will be repeated on each following page anyway!

 protected  void processActions(Element element,
    PdfAction action,
    ArrayList allActions) 
{
        if (element.type() == Element.ANCHOR) {
            String url = ((Anchor) element).getReference();
            if (url != null) {
                action = new PdfAction(url);
            }
        }
        Iterator i;
        switch (element.type()) {
            case Element.PHRASE:
            case Element.SECTION:
            case Element.ANCHOR:
            case Element.CHAPTER:
            case Element.LISTITEM:
            case Element.PARAGRAPH:
                for (i = ((ArrayList) element).iterator(); i.hasNext();) {
                    processActions((Element) i.next(), action, allActions);
                }
                break;
            case Element.CHUNK:
                allActions.add(action);
                break;
            case Element.LIST:
                for (i = ((List) element).getItems().iterator(); i.hasNext();) {
                    processActions((Element) i.next(), action, allActions);
                }
                break;
            default:
                int n = element.getChunks().size();
                while (n--  > 0)
                    allActions.add(action);
                break;
        }
}

Processes all actions contained in the cell.

 public Rectangle rectangle(float top,
    float bottom) 
{
        Rectangle tmp = new Rectangle(getLeft(), getBottom(), getRight(), getTop());
        tmp.cloneNonPositionParameters(this);
        if (getTop()  > top) {
            tmp.setTop(top);
            tmp.setBorder(border - (border & TOP));
        }
        if (getBottom() <  bottom) {
            tmp.setBottom(bottom);
            tmp.setBorder(border - (border & BOTTOM));
        }
        return tmp;
}

Gets a Rectangle that is altered to fit on the page.

 public float remainingHeight() 
{
        float result = 0f;
        for (Iterator i = images.iterator(); i.hasNext();) {
            Image image = (Image) i.next();
            result += image.getScaledHeight();
        }
        return remainingLinesHeight() + cellspacing + 2 * cellpadding + result;
}

Returns the height needed to draw the remaining text.

 public int rownumber() 
{
        return rownumber;
}

Gets the number of the row this cell is in..

 public int rowspan() 
{
        return rowspan;
}

Gets the rowspan of a cell.

 public  void setBottom(float value) 
{
        super.setBottom(value);
        float firstLineRealHeight = firstLineRealHeight();
        float totalHeight = ury - value; // can't use top (already compensates for cellspacing)
        float nonContentHeight = (cellpadding() * 2f) + (cellspacing() * 2f);
        nonContentHeight += getBorderWidthInside(TOP) + getBorderWidthInside(BOTTOM);
        float interiorHeight = totalHeight - nonContentHeight;
        float extraHeight = 0.0f;
        switch (verticalAlignment) {
            case Element.ALIGN_BOTTOM:
                extraHeight = interiorHeight - contentHeight;
                break;
            case Element.ALIGN_MIDDLE:
                extraHeight = (interiorHeight - contentHeight) / 2.0f;
                break;
            default:    // ALIGN_TOP
                extraHeight = 0f;
        }
        extraHeight += cellpadding() + cellspacing();
        extraHeight += getBorderWidthInside(TOP);
        if (firstLine != null) {
            firstLine.height = firstLineRealHeight + extraHeight;
        }
}

Sets the bottom of the Rectangle and determines the proper {link #verticalOffset} to appropriately align the contents vertically.

  void setGroupNumber(int number) 
{
        groupNumber = number;
}

Sets the group number.

  void setHeader() 
{
        header = true;
}

Indicates that this cell belongs to the header of a PdfTable.

 public  void setUseAscender(boolean use) 
{
        useAscender = use;
}

Sets the value of useAscender.

 public  void setUseBorderPadding(boolean use) 
{
        useBorderPadding = use;
}

Sets the value of useBorderPadding.

 public  void setUseDescender(boolean use) 
{
        useDescender = use;
}

Sets the value of useDescender.

 public int size() 
{
        return lines.size();
}

Returns the number of lines in the cell.