Initial Commit
This commit is contained in:
875
iTechSharp/iTextSharp/text/pdf/PdfCell.cs
Normal file
875
iTechSharp/iTextSharp/text/pdf/PdfCell.cs
Normal file
@@ -0,0 +1,875 @@
|
||||
using System;
|
||||
using System.Collections;
|
||||
|
||||
using iTextSharp.text;
|
||||
|
||||
/*
|
||||
* $Id: PdfCell.cs,v 1.10 2008/05/13 11:25:19 psoares33 Exp $
|
||||
*
|
||||
*
|
||||
* Copyright 1999, 2000, 2001, 2002 Bruno Lowagie
|
||||
*
|
||||
* The contents of this file are subject to the Mozilla Public License Version 1.1
|
||||
* (the "License"); you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at http://www.mozilla.org/MPL/
|
||||
*
|
||||
* Software distributed under the License is distributed on an "AS IS" basis,
|
||||
* WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
|
||||
* for the specific language governing rights and limitations under the License.
|
||||
*
|
||||
* The Original Code is 'iText, a free JAVA-PDF library'.
|
||||
*
|
||||
* The Initial Developer of the Original Code is Bruno Lowagie. Portions created by
|
||||
* the Initial Developer are Copyright (C) 1999, 2000, 2001, 2002 by Bruno Lowagie.
|
||||
* All Rights Reserved.
|
||||
* Co-Developer of the code is Paulo Soares. Portions created by the Co-Developer
|
||||
* are Copyright (C) 2000, 2001, 2002 by Paulo Soares. All Rights Reserved.
|
||||
*
|
||||
* Contributor(s): all the names of the contributors are added in the source code
|
||||
* where applicable.
|
||||
*
|
||||
* Alternatively, the contents of this file may be used under the terms of the
|
||||
* LGPL license (the "GNU LIBRARY GENERAL PUBLIC LICENSE"), in which case the
|
||||
* provisions of LGPL are applicable instead of those above. If you wish to
|
||||
* allow use of your version of this file only under the terms of the LGPL
|
||||
* License and not to allow others to use your version of this file under
|
||||
* the MPL, indicate your decision by deleting the provisions above and
|
||||
* replace them with the notice and other provisions required by the LGPL.
|
||||
* If you do not delete the provisions above, a recipient may use your version
|
||||
* of this file under either the MPL or the GNU LIBRARY GENERAL PUBLIC LICENSE.
|
||||
*
|
||||
* This library is free software; you can redistribute it and/or modify it
|
||||
* under the terms of the MPL as stated above or under the terms of the GNU
|
||||
* Library General Public License as published by the Free Software Foundation;
|
||||
* either version 2 of the License, or any later version.
|
||||
*
|
||||
* This library 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 Library general Public License for more
|
||||
* details.
|
||||
*
|
||||
* If you didn't download this code from the following link, you should check if
|
||||
* you aren't using an obsolete version:
|
||||
* http://www.lowagie.com/iText/
|
||||
*/
|
||||
|
||||
namespace iTextSharp.text.pdf {
|
||||
|
||||
/**
|
||||
* A <CODE>PdfCell</CODE> is the PDF translation of a <CODE>Cell</CODE>.
|
||||
* <P>
|
||||
* A <CODE>PdfCell</CODE> is an <CODE>ArrayList</CODE> of <CODE>PdfLine</CODE>s.
|
||||
*
|
||||
* @see iTextSharp.text.Rectangle
|
||||
* @see iTextSharp.text.Cell
|
||||
* @see PdfLine
|
||||
* @see PdfTable
|
||||
*/
|
||||
|
||||
public class PdfCell : Rectangle {
|
||||
|
||||
// membervariables
|
||||
|
||||
/** These are the PdfLines in the Cell. */
|
||||
private ArrayList lines;
|
||||
|
||||
/** These are the PdfLines in the Cell. */
|
||||
private PdfLine line;
|
||||
|
||||
/** These are the Images in the Cell. */
|
||||
private ArrayList images;
|
||||
|
||||
/** This is the leading of the lines. */
|
||||
private float leading;
|
||||
|
||||
/** This is the number of the row the cell is in. */
|
||||
private int rownumber;
|
||||
|
||||
/** This is the rowspan of the cell. */
|
||||
private int rowspan;
|
||||
|
||||
/** This is the cellspacing of the cell. */
|
||||
private float cellspacing;
|
||||
|
||||
/** This is the cellpadding of the cell. */
|
||||
private float cellpadding;
|
||||
|
||||
/** Indicates if this cell belongs to the header of a <CODE>PdfTable</CODE> */
|
||||
private bool header = false;
|
||||
|
||||
/**
|
||||
* This is the total height of the content of the cell. Note that the actual cell
|
||||
* height may be larger due to another cell on the row *
|
||||
*/
|
||||
private float contentHeight = 0.0f;
|
||||
|
||||
/**
|
||||
* Indicates that the largest ascender height should be used to
|
||||
* determine the height of the first line. Setting this to true can help
|
||||
* with vertical alignment problems. */
|
||||
private bool useAscender;
|
||||
|
||||
/**
|
||||
* Indicates that the largest descender height should be added to the height of
|
||||
* the last line (so characters like y don't dip into the border). */
|
||||
private bool useDescender;
|
||||
|
||||
/**
|
||||
* Adjusts the cell contents to compensate for border widths.
|
||||
*/
|
||||
private bool useBorderPadding;
|
||||
|
||||
private int verticalAlignment;
|
||||
|
||||
private PdfLine firstLine;
|
||||
private PdfLine lastLine;
|
||||
|
||||
// constructors
|
||||
|
||||
/**
|
||||
* Constructs a <CODE>PdfCell</CODE>-object.
|
||||
*
|
||||
* @param cell the original <CODE>Cell</CODE>
|
||||
* @param rownumber the number of the <CODE>Row</CODE> the <CODE>Cell</CODE> was in.
|
||||
* @param left the left border of the <CODE>PdfCell</CODE>
|
||||
* @param right the right border of the <CODE>PdfCell</CODE>
|
||||
* @param top the top border of the <CODE>PdfCell</CODE>
|
||||
* @param cellspacing the cellspacing of the <CODE>Table</CODE>
|
||||
* @param cellpadding the cellpadding of the <CODE>Table</CODE>
|
||||
*/
|
||||
|
||||
public PdfCell(Cell cell, int rownumber, float left, float right, float top, float cellspacing, float cellpadding) : base(left, top, right, top) {
|
||||
// copying the other Rectangle attributes from class Cell
|
||||
CloneNonPositionParameters(cell);
|
||||
this.cellpadding = cellpadding;
|
||||
this.cellspacing = cellspacing;
|
||||
this.verticalAlignment = cell.VerticalAlignment;
|
||||
this.useAscender = cell.UseAscender;
|
||||
this.useDescender = cell.UseDescender;
|
||||
this.useBorderPadding = cell.UseBorderPadding;
|
||||
|
||||
// initialisation of some parameters
|
||||
PdfChunk chunk;
|
||||
PdfChunk overflow;
|
||||
lines = new ArrayList();
|
||||
images = new ArrayList();
|
||||
leading = cell.Leading;
|
||||
int alignment = cell.HorizontalAlignment;
|
||||
left += cellspacing + cellpadding;
|
||||
right -= cellspacing + cellpadding;
|
||||
|
||||
left += GetBorderWidthInside(LEFT_BORDER);
|
||||
right -= GetBorderWidthInside(RIGHT_BORDER);
|
||||
contentHeight = 0;
|
||||
rowspan = cell.Rowspan;
|
||||
|
||||
ArrayList allActions;
|
||||
int aCounter;
|
||||
// we loop over all the elements of the cell
|
||||
foreach (IElement ele in cell.Elements) {
|
||||
switch (ele.Type) {
|
||||
case Element.JPEG:
|
||||
case Element.JPEG2000:
|
||||
case Element.IMGRAW:
|
||||
case Element.IMGTEMPLATE:
|
||||
AddImage((Image)ele, 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)ele, left, right, alignment);
|
||||
line = new PdfLine(left, right, alignment, leading);
|
||||
break;
|
||||
// if the element is something else
|
||||
default:
|
||||
allActions = new ArrayList();
|
||||
ProcessActions(ele, null, allActions);
|
||||
aCounter = 0;
|
||||
|
||||
float currentLineLeading = leading;
|
||||
float currentLeft = left;
|
||||
float currentRight = right;
|
||||
if (ele is Phrase) {
|
||||
currentLineLeading = ((Phrase) ele).Leading;
|
||||
}
|
||||
if (ele is Paragraph) {
|
||||
Paragraph p = (Paragraph) ele;
|
||||
currentLeft += p.IndentationLeft;
|
||||
currentRight -= p.IndentationRight;
|
||||
}
|
||||
if (line == null) {
|
||||
line = new PdfLine(currentLeft, currentRight, alignment, currentLineLeading);
|
||||
}
|
||||
// we loop over the chunks
|
||||
ArrayList chunks = ele.Chunks;
|
||||
if (chunks.Count == 0) {
|
||||
AddLine(line); // add empty line - all cells need some lines even if they are empty
|
||||
line = new PdfLine(currentLeft, currentRight, alignment, currentLineLeading);
|
||||
}
|
||||
else {
|
||||
foreach (Chunk c in chunks) {
|
||||
chunk = new PdfChunk(c, (PdfAction)allActions[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 (ele.Type) {
|
||||
case Element.PARAGRAPH:
|
||||
case Element.SECTION:
|
||||
case Element.CHAPTER:
|
||||
line.ResetAlignment();
|
||||
FlushCurrentLine();
|
||||
break;
|
||||
}
|
||||
break;
|
||||
}
|
||||
}
|
||||
FlushCurrentLine();
|
||||
if (lines.Count > cell.MaxLines) {
|
||||
while (lines.Count > cell.MaxLines) {
|
||||
RemoveLine(lines.Count - 1);
|
||||
}
|
||||
if (cell.MaxLines > 0) {
|
||||
String more = cell.ShowTruncation;
|
||||
if (more != null && more.Length > 0) {
|
||||
// Denote that the content has been truncated
|
||||
lastLine = (PdfLine) lines[lines.Count - 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.Value = lastChunk.ToString().Substring(0, lastChunk.Length - 1);
|
||||
}
|
||||
lastChunk.Value = lastChunk.ToString() + more;
|
||||
} else {
|
||||
lastLine.Add(new PdfChunk(new Chunk(more), null));
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
// we set some additional parameters
|
||||
if (useDescender && lastLine != null) {
|
||||
contentHeight -= lastLine.Descender;
|
||||
}
|
||||
|
||||
// adjust first line height so that it touches the top
|
||||
if (lines.Count > 0) {
|
||||
firstLine = (PdfLine) lines[0];
|
||||
float firstLineRealHeight = FirstLineRealHeight;
|
||||
contentHeight -= firstLine.Height;
|
||||
firstLine.height = firstLineRealHeight;
|
||||
contentHeight += firstLineRealHeight;
|
||||
}
|
||||
|
||||
float newBottom = top - contentHeight - (2f * Cellpadding) - (2f * Cellspacing);
|
||||
newBottom -= GetBorderWidthInside(TOP_BORDER) + GetBorderWidthInside(BOTTOM_BORDER);
|
||||
Bottom = newBottom;
|
||||
|
||||
this.rownumber = rownumber;
|
||||
}
|
||||
|
||||
private void AddList(List list, float left, float right, int alignment) {
|
||||
PdfChunk chunk;
|
||||
PdfChunk overflow;
|
||||
ArrayList allActions = new ArrayList();
|
||||
ProcessActions(list, null, allActions);
|
||||
int aCounter = 0;
|
||||
foreach (IElement ele in list.Items) {
|
||||
switch (ele.Type) {
|
||||
case Element.LISTITEM:
|
||||
ListItem item = (ListItem)ele;
|
||||
line = new PdfLine(left + item.IndentationLeft, right, alignment, item.Leading);
|
||||
line.ListItem = item;
|
||||
foreach (Chunk c in item.Chunks) {
|
||||
chunk = new PdfChunk(c, (PdfAction)(allActions[aCounter++]));
|
||||
while ((overflow = line.Add(chunk)) != null) {
|
||||
AddLine(line);
|
||||
line = new PdfLine(left + item.IndentationLeft, right, alignment, item.Leading);
|
||||
chunk = overflow;
|
||||
}
|
||||
line.ResetAlignment();
|
||||
AddLine(line);
|
||||
line = new PdfLine(left + item.IndentationLeft, right, alignment, leading);
|
||||
}
|
||||
break;
|
||||
case Element.LIST:
|
||||
List sublist = (List)ele;
|
||||
AddList(sublist, left + sublist.IndentationLeft, right, alignment);
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// overriding of the Rectangle methods
|
||||
|
||||
/**
|
||||
* Returns the lower left x-coordinaat.
|
||||
*
|
||||
* @return the lower left x-coordinaat
|
||||
*/
|
||||
|
||||
public override float Left {
|
||||
get {
|
||||
return base.GetLeft(cellspacing);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns the upper right x-coordinate.
|
||||
*
|
||||
* @return the upper right x-coordinate
|
||||
*/
|
||||
|
||||
public override float Right {
|
||||
get {
|
||||
return base.GetRight(cellspacing);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns the upper right y-coordinate.
|
||||
*
|
||||
* @return the upper right y-coordinate
|
||||
*/
|
||||
|
||||
public override float Top {
|
||||
get {
|
||||
return base.GetTop(cellspacing);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns the lower left y-coordinate.
|
||||
*
|
||||
* @return the lower left y-coordinate
|
||||
*/
|
||||
|
||||
public override float Bottom {
|
||||
get {
|
||||
return base.GetBottom(cellspacing);
|
||||
}
|
||||
set {
|
||||
base.Bottom = 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_BORDER) + GetBorderWidthInside(BOTTOM_BORDER);
|
||||
|
||||
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;
|
||||
break;
|
||||
}
|
||||
|
||||
extraHeight += Cellpadding + Cellspacing;
|
||||
extraHeight += GetBorderWidthInside(TOP_BORDER);
|
||||
if (firstLine != null) {
|
||||
firstLine.height = firstLineRealHeight + extraHeight;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// methods
|
||||
|
||||
private void AddLine(PdfLine line) {
|
||||
lines.Add(line);
|
||||
contentHeight += line.Height;
|
||||
lastLine = line;
|
||||
this.line = null;
|
||||
}
|
||||
|
||||
private PdfLine RemoveLine(int index) {
|
||||
PdfLine oldLine = (PdfLine)lines[index];
|
||||
lines.RemoveAt(index);
|
||||
contentHeight -= oldLine.Height;
|
||||
if (index == 0) {
|
||||
if (lines.Count > 0) {
|
||||
firstLine = (PdfLine) lines[0];
|
||||
float firstLineRealHeight = FirstLineRealHeight;
|
||||
contentHeight -= firstLine.Height;
|
||||
firstLine.height = firstLineRealHeight;
|
||||
contentHeight += firstLineRealHeight;
|
||||
}
|
||||
}
|
||||
return oldLine;
|
||||
}
|
||||
|
||||
private void FlushCurrentLine() {
|
||||
if (line != null && line.Size > 0) {
|
||||
AddLine(line);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Calculates what the height of the first line should be so that the content will be
|
||||
* flush with the top. For text, this is the height of the ascender. For an image,
|
||||
* it is the actual height of the image.
|
||||
* @return the real height of the first line
|
||||
*/
|
||||
private float FirstLineRealHeight {
|
||||
get {
|
||||
float firstLineRealHeight = 0f;
|
||||
if (firstLine != null) {
|
||||
PdfChunk chunk = firstLine.GetChunk(0);
|
||||
if (chunk != null) {
|
||||
Image image = chunk.Image;
|
||||
if (image != null) {
|
||||
firstLineRealHeight = firstLine.GetChunk(0).Image.ScaledHeight;
|
||||
} else {
|
||||
firstLineRealHeight = useAscender ? firstLine.Ascender : leading;
|
||||
}
|
||||
}
|
||||
}
|
||||
return firstLineRealHeight;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Gets the amount of the border for the specified side that is inside the Rectangle.
|
||||
* For non-variable width borders this is only 1/2 the border width on that side. This
|
||||
* always returns 0 if {@link #useBorderPadding} is false;
|
||||
* @param side the side to check. One of the side constants in {@link com.lowagie.text.Rectangle}
|
||||
* @return the borderwidth inside the cell
|
||||
*/
|
||||
private float GetBorderWidthInside(int side) {
|
||||
float width = 0f;
|
||||
if (useBorderPadding) {
|
||||
switch (side) {
|
||||
case iTextSharp.text.Rectangle.LEFT_BORDER:
|
||||
width = BorderWidthLeft;
|
||||
break;
|
||||
|
||||
case iTextSharp.text.Rectangle.RIGHT_BORDER:
|
||||
width = BorderWidthRight;
|
||||
break;
|
||||
|
||||
case iTextSharp.text.Rectangle.TOP_BORDER:
|
||||
width = BorderWidthTop;
|
||||
break;
|
||||
|
||||
default: // default and BOTTOM
|
||||
width = BorderWidthBottom;
|
||||
break;
|
||||
}
|
||||
// non-variable (original style) borders overlap the rectangle (only 1/2 counts)
|
||||
if (!UseVariableBorders) {
|
||||
width = width / 2f;
|
||||
}
|
||||
}
|
||||
return width;
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Adds an image to this Cell.
|
||||
*
|
||||
* @param i the image to add
|
||||
* @param left the left border
|
||||
* @param right the right border
|
||||
* @param extraHeight extra height to add above image
|
||||
* @param alignment horizontal alignment (constant from Element class)
|
||||
* @return the height of the image
|
||||
*/
|
||||
|
||||
private float AddImage(Image i, float left, float right, float extraHeight, int alignment) {
|
||||
Image image = Image.GetInstance(i);
|
||||
if (image.ScaledWidth > right - left) {
|
||||
image.ScaleToFit(right - left, float.MaxValue);
|
||||
}
|
||||
FlushCurrentLine();
|
||||
if (line == null) {
|
||||
line = new PdfLine(left, right, alignment, leading);
|
||||
}
|
||||
PdfLine imageLine = line;
|
||||
|
||||
// left and right in chunk is relative to the start of the line
|
||||
right = right - left;
|
||||
left = 0f;
|
||||
|
||||
if ((image.Alignment & Image.RIGHT_ALIGN) == Image.RIGHT_ALIGN) { // fix Uwe Zimmerman
|
||||
left = right - image.ScaledWidth;
|
||||
} else if ((image.Alignment & Image.MIDDLE_ALIGN) == Image.MIDDLE_ALIGN) {
|
||||
left = left + ((right - left - image.ScaledWidth) / 2f);
|
||||
}
|
||||
Chunk imageChunk = new Chunk(image, left, 0);
|
||||
imageLine.Add(new PdfChunk(imageChunk, null));
|
||||
AddLine(imageLine);
|
||||
return imageLine.Height;
|
||||
}
|
||||
|
||||
/**
|
||||
* Gets the lines of a cell that can be drawn between certain limits.
|
||||
* <P>
|
||||
* Remark: all the lines that can be drawn are removed from the object!
|
||||
*
|
||||
* @param top the top of the part of the table that can be drawn
|
||||
* @param bottom the bottom of the part of the table that can be drawn
|
||||
* @return an <CODE>ArrayList</CODE> of <CODE>PdfLine</CODE>s
|
||||
*/
|
||||
|
||||
public ArrayList GetLines(float top, float bottom) {
|
||||
float lineHeight;
|
||||
float currentPosition = Math.Min(this.Top, top);
|
||||
this.Top = currentPosition + cellspacing;
|
||||
ArrayList result = new ArrayList();
|
||||
|
||||
// if the bottom of the page is higher than the top of the cell: do nothing
|
||||
if (Top < bottom) {
|
||||
return result;
|
||||
}
|
||||
|
||||
// we loop over the lines
|
||||
int size = lines.Count;
|
||||
bool aboveBottom = true;
|
||||
for (int i = 0; i < size && aboveBottom; i++) {
|
||||
line = (PdfLine) lines[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_BORDER))) { // bugfix by Tom Ring and Veerendra Namineni
|
||||
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.Count;
|
||||
for (int i = 0; i < size; i++) {
|
||||
line = RemoveLine(0);
|
||||
difference += line.Height;
|
||||
}
|
||||
}
|
||||
}
|
||||
if (difference > 0) {
|
||||
foreach (Image image in images) {
|
||||
image.SetAbsolutePosition(image.AbsoluteX, image.AbsoluteY - difference - leading);
|
||||
}
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
/**
|
||||
* Gets the images of a cell that can be drawn between certain limits.
|
||||
* <P>
|
||||
* Remark: all the lines that can be drawn are removed from the object!
|
||||
*
|
||||
* @param top the top of the part of the table that can be drawn
|
||||
* @param bottom the bottom of the part of the table that can be drawn
|
||||
* @return an <CODE>ArrayList</CODE> of <CODE>Image</CODE>s
|
||||
*/
|
||||
|
||||
public ArrayList GetImages(float top, float bottom) {
|
||||
|
||||
// if the bottom of the page is higher than the top of the cell: do nothing
|
||||
if (this.Top < bottom) {
|
||||
return new ArrayList();
|
||||
}
|
||||
top = Math.Min(this.Top, top);
|
||||
// initialisations
|
||||
float height;
|
||||
ArrayList result = new ArrayList();
|
||||
// we loop over the images
|
||||
ArrayList remove = new ArrayList();
|
||||
foreach (Image image in images) {
|
||||
height = image.AbsoluteY;
|
||||
// if the currentPosition is higher than the bottom, we add the line to the result
|
||||
if (top - height > (bottom + cellpadding)) {
|
||||
image.SetAbsolutePosition(image.AbsoluteX, top - height);
|
||||
result.Add(image);
|
||||
remove.Add(image);
|
||||
}
|
||||
}
|
||||
foreach (Image image in remove) {
|
||||
images.Remove(image);
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
/**
|
||||
* Checks if this cell belongs to the header of a <CODE>PdfTable</CODE>.
|
||||
*
|
||||
* @return <CODE>void</CODE>
|
||||
*/
|
||||
|
||||
internal void SetHeader() {
|
||||
header = true;
|
||||
}
|
||||
|
||||
/**
|
||||
* Indicates that this cell belongs to the header of a <CODE>PdfTable</CODE>.
|
||||
*/
|
||||
|
||||
internal bool Header {
|
||||
get {
|
||||
return header;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Checks if the cell may be removed.
|
||||
* <P>
|
||||
* Headers may allways be removed, even if they are drawn only partially:
|
||||
* they will be repeated on each following page anyway!
|
||||
*
|
||||
* @return <CODE>true</CODE> if all the lines are allready drawn; <CODE>false</CODE> otherwise.
|
||||
*/
|
||||
|
||||
internal bool MayBeRemoved() {
|
||||
return (header || (lines.Count == 0 && images.Count == 0));
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns the number of lines in the cell.
|
||||
*
|
||||
* @return a value
|
||||
*/
|
||||
|
||||
public int Size {
|
||||
get {
|
||||
return lines.Count;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns the total height of all the lines in the cell.
|
||||
*
|
||||
* @return a value
|
||||
*/
|
||||
|
||||
private float RemainingLinesHeight() {
|
||||
if (lines.Count == 0) return 0;
|
||||
float result = 0;
|
||||
int size = lines.Count;
|
||||
PdfLine line;
|
||||
for (int i = 0; i < size; i++) {
|
||||
line = (PdfLine) lines[i];
|
||||
result += line.Height;
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns the height needed to draw the remaining text.
|
||||
*
|
||||
* @return a height
|
||||
*/
|
||||
|
||||
public float RemainingHeight {
|
||||
get {
|
||||
float result = 0f;
|
||||
foreach (Image image in images) {
|
||||
result += image.ScaledHeight;
|
||||
}
|
||||
return RemainingLinesHeight() + cellspacing + 2 * cellpadding + result;
|
||||
}
|
||||
}
|
||||
|
||||
// methods to retrieve membervariables
|
||||
|
||||
/**
|
||||
* Gets the leading of a cell.
|
||||
*
|
||||
* @return the leading of the lines is the cell.
|
||||
*/
|
||||
|
||||
public float Leading {
|
||||
get {
|
||||
return leading;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Gets the number of the row this cell is in..
|
||||
*
|
||||
* @return a number
|
||||
*/
|
||||
|
||||
public int Rownumber {
|
||||
get {
|
||||
return rownumber;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Gets the rowspan of a cell.
|
||||
*
|
||||
* @return the rowspan of the cell
|
||||
*/
|
||||
|
||||
public int Rowspan {
|
||||
get {
|
||||
return rowspan;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Gets the cellspacing of a cell.
|
||||
*
|
||||
* @return a value
|
||||
*/
|
||||
|
||||
public float Cellspacing {
|
||||
get {
|
||||
return cellspacing;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Gets the cellpadding of a cell..
|
||||
*
|
||||
* @return a value
|
||||
*/
|
||||
|
||||
public float Cellpadding {
|
||||
get {
|
||||
return cellpadding;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Processes all actions contained in the cell.
|
||||
*/
|
||||
|
||||
protected void ProcessActions(IElement element, PdfAction action, ArrayList allActions) {
|
||||
if (element.Type == Element.ANCHOR) {
|
||||
string url = ((Anchor)element).Reference;
|
||||
if (url != null) {
|
||||
action = new PdfAction(url);
|
||||
}
|
||||
}
|
||||
switch (element.Type) {
|
||||
case Element.PHRASE:
|
||||
case Element.SECTION:
|
||||
case Element.ANCHOR:
|
||||
case Element.CHAPTER:
|
||||
case Element.LISTITEM:
|
||||
case Element.PARAGRAPH:
|
||||
foreach (IElement ele in ((ArrayList)element)) {
|
||||
ProcessActions(ele, action, allActions);
|
||||
}
|
||||
break;
|
||||
case Element.CHUNK:
|
||||
allActions.Add(action);
|
||||
break;
|
||||
case Element.LIST:
|
||||
foreach (IElement ele in ((List)element).Items) {
|
||||
ProcessActions(ele, action, allActions);
|
||||
}
|
||||
break;
|
||||
default:
|
||||
int n = element.Chunks.Count;
|
||||
while (n-- > 0)
|
||||
allActions.Add(action);
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* This is the number of the group the cell is in.
|
||||
*/
|
||||
private int groupNumber;
|
||||
|
||||
/**
|
||||
* Gets the number of the group this cell is in..
|
||||
*
|
||||
* @return a number
|
||||
*/
|
||||
|
||||
public int GroupNumber {
|
||||
get {
|
||||
return groupNumber;
|
||||
}
|
||||
set {
|
||||
groupNumber = value;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Gets a Rectangle that is altered to fit on the page.
|
||||
*
|
||||
* @param top the top position
|
||||
* @param bottom the bottom position
|
||||
* @return a <CODE>Rectangle</CODE>
|
||||
*/
|
||||
|
||||
public Rectangle Rectangle(float top, float bottom) {
|
||||
Rectangle tmp = new Rectangle(Left, Bottom, Right, Top);
|
||||
tmp.CloneNonPositionParameters(this);
|
||||
if (Top > top) {
|
||||
tmp.Top = top;
|
||||
tmp.Border = border - (border & TOP_BORDER);
|
||||
}
|
||||
if (Bottom < bottom) {
|
||||
tmp.Bottom = bottom;
|
||||
tmp.Border = border - (border & BOTTOM_BORDER);
|
||||
}
|
||||
return tmp;
|
||||
}
|
||||
|
||||
/**
|
||||
* Gets the value of {@link #useAscender}
|
||||
* @return useAscender
|
||||
*/
|
||||
public bool UseAscender {
|
||||
get {
|
||||
return useAscender;
|
||||
}
|
||||
set {
|
||||
useAscender = value;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Gets the value of {@link #useDescender}
|
||||
* @return useDescender
|
||||
*/
|
||||
public bool UseDescender {
|
||||
get {
|
||||
return useDescender;
|
||||
}
|
||||
set {
|
||||
useDescender = value;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Sets the value of {@link #useBorderPadding}.
|
||||
* @param use adjust layour for borders if true
|
||||
*/
|
||||
public bool UseBorderPadding {
|
||||
set {
|
||||
useBorderPadding = value;
|
||||
}
|
||||
get {
|
||||
return useBorderPadding;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user