Cell is a Rectangle containing other
* Elements.
*
* A Cell must be added to a Table.
* The Table will place the Cell in
* a Row.
*
* Example: *
* Table table = new Table(3);
* table.setBorderWidth(1);
* table.setBorderColor(new Color(0, 0, 255));
* table.setCellpadding(5);
* table.setCellspacing(5);
* Cell cell = new Cell("header");
* cell.setHeader(true);
* cell.setColspan(3);
* table.addCell(cell);
* cell = new Cell("example cell with colspan 1 and rowspan 2");
* cell.setRowspan(2);
* cell.setBorderColor(new Color(255, 0, 0));
* table.addCell(cell);
* table.addCell("1.1");
* table.addCell("2.1");
* table.addCell("1.2");
* table.addCell("2.2");
* ArrayList of Elements. */
protected ArrayList arrayList = null;
/** This is the horizontal alignment. */
protected int horizontalAlignment = Element.ALIGN_UNDEFINED;
/** This is the vertical alignment. */
protected int verticalAlignment = Element.ALIGN_UNDEFINED;
/** This is the vertical alignment. */
protected String width;
/** This is the colspan. */
protected int colspan = 1;
/** This is the rowspan. */
protected int rowspan = 1;
/** This is the leading. */
float leading = Float.NaN;
/** Is this Cell a header? */
protected boolean header;
/** Indicates that the largest ascender height should be used to determine the
* height of the first line. Note that this only has an effect when rendered
* to PDF. Setting this to true can help with vertical alignment problems. */
protected boolean useAscender = false;
/** 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). Note that
* this only has an effect when rendered to PDF. */
protected boolean useDescender = false;
/**
* Adjusts the cell contents to compensate for border widths. Note that
* this only has an effect when rendered to PDF.
*/
protected boolean useBorderPadding;
// constructors
/**
* Constructs an empty Cell.
*/
public Cell() {
// creates a Rectangle with BY DEFAULT a border of 0.5
super(0, 0, 0, 0);
setBorder(UNDEFINED);
setBorderWidth(0.5f);
// initializes the arraylist and adds an element
arrayList = new ArrayList();
}
/**
* Constructs an empty Cell (for internal use only).
*
* @param dummy a dummy value
*/
public Cell(boolean dummy) {
this();
arrayList.add(new Paragraph(0));
}
/**
* Constructs a Cell with a certain content.
*
* The String will be converted into a Paragraph.
*
* @param content a String
*/
public Cell(String content) {
// creates a Rectangle with BY DEFAULT a border of 0.5
super(0, 0, 0, 0);
setBorder(UNDEFINED);
setBorderWidth(0.5f);
// initializes the arraylist and adds an element
arrayList = new ArrayList();
try {
addElement(new Paragraph(content));
}
catch(BadElementException bee) {
}
}
/**
* Constructs a Cell with a certain Element.
*
* if the element is a
* Remark: you can't add ListItem, Row or
* Cell, an exception will be thrown.
*
* @param element the element
* @throws BadElementException when the creator was called with a ListItem, Row or Cell
*/
public Cell(Element element) throws BadElementException {
// creates a Rectangle with BY DEFAULT a border of 0.5
super(0, 0, 0, 0);
setBorder(UNDEFINED);
setBorderWidth(0.5f);
// Update by Benoit WIART Cell that has been constructed taking in account
* the value of some attributes.
*
* @param attributes Some attributes
*/
public Cell(Properties attributes) {
this();
String value;
if ((value = (String)attributes.remove(ElementTags.HORIZONTALALIGN)) != null) {
setHorizontalAlignment(value);
}
if ((value = (String)attributes.remove(ElementTags.VERTICALALIGN)) != null) {
setVerticalAlignment(value);
}
if ((value = (String)attributes.remove(ElementTags.WIDTH)) != null) {
setWidth(value);
}
if ((value = (String)attributes.remove(ElementTags.COLSPAN)) != null) {
setColspan(Integer.parseInt(value));
}
if ((value = (String)attributes.remove(ElementTags.ROWSPAN)) != null) {
setRowspan(Integer.parseInt(value));
}
if ((value = (String)attributes.remove(ElementTags.LEADING)) != null) {
setLeading(Float.valueOf(value + "f").floatValue());
}
if ((value = (String)attributes.remove(ElementTags.HEADER)) != null) {
setHeader(new Boolean(value).booleanValue());
}
if ((value = (String)attributes.remove(ElementTags.NOWRAP)) != null) {
setNoWrap(new Boolean(value).booleanValue());
}
if ((value = (String)attributes.remove(ElementTags.BORDERWIDTH)) != null) {
setBorderWidth(Float.valueOf(value + "f").floatValue());
}
int border = 0;
if ((value = (String)attributes.remove(ElementTags.LEFT)) != null) {
if (new Boolean(value).booleanValue()) border |= Rectangle.LEFT;
}
if ((value = (String)attributes.remove(ElementTags.RIGHT)) != null) {
if (new Boolean(value).booleanValue()) border |= Rectangle.RIGHT;
}
if ((value = (String)attributes.remove(ElementTags.TOP)) != null) {
if (new Boolean(value).booleanValue()) border |= Rectangle.TOP;
}
if ((value = (String)attributes.remove(ElementTags.BOTTOM)) != null) {
if (new Boolean(value).booleanValue()) border |= Rectangle.BOTTOM;
}
setBorder(border);
String r = (String)attributes.remove(ElementTags.RED);
String g = (String)attributes.remove(ElementTags.GREEN);
String b = (String)attributes.remove(ElementTags.BLUE);
if (r != null || g != null || b != null) {
int red = 0;
int green = 0;
int blue = 0;
if (r != null) red = Integer.parseInt(r);
if (g != null) green = Integer.parseInt(g);
if (b != null) blue = Integer.parseInt(b);
setBorderColor(new Color(red, green, blue));
}
else if ((value = (String)attributes.remove(ElementTags.BORDERCOLOR)) != null) {
setBorderColor(MarkupParser.decodeColor(value));
}
r = (String)attributes.remove(ElementTags.BGRED);
g = (String)attributes.remove(ElementTags.BGGREEN);
b = (String)attributes.remove(ElementTags.BGBLUE);
if (r != null || g != null || b != null) {
int red = 0;
int green = 0;
int blue = 0;
if (r != null) red = Integer.parseInt(r);
if (g != null) green = Integer.parseInt(g);
if (b != null) blue = Integer.parseInt(b);
setBackgroundColor(new Color(red, green, blue));
}
else if ((value = (String)attributes.remove(ElementTags.BACKGROUNDCOLOR)) != null) {
setBackgroundColor(MarkupParser.decodeColor(value));
}
if ((value = (String)attributes.remove(ElementTags.GRAYFILL)) != null) {
setGrayFill(Float.valueOf(value + "f").floatValue());
}
if (attributes.size() > 0) setMarkupAttributes(attributes);
}
// implementation of the Element-methods
/**
* Processes the element by adding it (or the different parts) to an
* ElementListener.
*
* @param listener an ElementListener
* @return true if the element was processed successfully
*/
public boolean process(ElementListener listener) {
try {
return listener.add(this);
}
catch(DocumentException de) {
return false;
}
}
/**
* Gets the type of the text element.
*
* @return a type
*/
public int type() {
return Element.CELL;
}
/**
* Gets all the chunks in this element.
*
* @return an ArrayList
*/
public ArrayList getChunks() {
ArrayList tmp = new ArrayList();
for (Iterator i = arrayList.iterator(); i.hasNext(); ) {
tmp.addAll(((Element) i.next()).getChunks());
}
return tmp;
}
// methods to set the membervariables
/**
* Adds an element to this Cell.
* ListItems, Rows, Cells,
* JPEGs, GIFs or PNGs to a Cell.
*
* @param element The Element to add
* @throws BadElementException if the method was called with a ListItem, Row or Cell
*/
public void addElement(Element element) throws BadElementException {
if (isTable()) {
Table table = (Table) arrayList.get(0);
Cell tmp = new Cell(element);
tmp.setBorder(NO_BORDER);
tmp.setColspan(table.columns());
table.addCell(tmp);
return;
}
switch(element.type()) {
case Element.LISTITEM:
case Element.ROW:
case Element.CELL:
throw new BadElementException("You can't add listitems, rows or cells to a cell.");
case Element.LIST:
if (Float.isNaN(leading)) {
leading = ((List) element).leading();
}
if (((List) element).size() == 0) return;
arrayList.add(element);
return;
case Element.ANCHOR:
case Element.PARAGRAPH:
case Element.PHRASE:
if (Float.isNaN(leading)) {
leading = ((Phrase) element).leading();
}
if (((Phrase) element).isEmpty()) return;
arrayList.add(element);
return;
case Element.CHUNK:
if (((Chunk) element).isEmpty()) return;
arrayList.add(element);
return;
case Element.TABLE:
Table table = new Table(3);
float[] widths = new float[3];
widths[1] = ((Table)element).widthPercentage();
switch(((Table)element).alignment()) {
case Element.ALIGN_LEFT:
widths[0] = 0f;
widths[2] = 100f - widths[1];
break;
case Element.ALIGN_CENTER:
widths[0] = (100f - widths[1]) / 2f;
widths[2] = widths[0];
break;
case Element.ALIGN_RIGHT:
widths[0] = 100f - widths[1];
widths[2] = 0f;
}
table.setWidths(widths);
Cell tmp;
if (arrayList.size() == 0) {
table.addCell(getDummyCell());
}
else {
tmp = new Cell();
tmp.setBorder(NO_BORDER);
tmp.setColspan(3);
for (Iterator i = arrayList.iterator(); i.hasNext(); ) {
tmp.add((Element) i.next());
}
table.addCell(tmp);
}
tmp = new Cell();
tmp.setBorder(NO_BORDER);
table.addCell(tmp);
table.insertTable((Table)element);
table.addCell(tmp);
table.addCell(getDummyCell());
clear();
arrayList.add(table);
return;
default:
arrayList.add(element);
}
}
/**
* Add an Object to this cell.
*
* @param o the object to add
* @return always true
*/
public boolean add(Object o) {
try {
this.addElement((Element) o);
return true;
}
catch(ClassCastException cce) {
throw new ClassCastException("You can only add objects that implement the Element interface.");
}
catch(BadElementException bee) {
throw new ClassCastException(bee.getMessage());
}
}
/**
* Sets the leading.
*
* @param value the new value
*/
public void setLeading(float value) {
leading = value;
}
/**
* Sets the horizontal alignment.
*
* @param value the new value
*/
public void setHorizontalAlignment(int value) {
horizontalAlignment = value;
}
/**
* Sets the alignment of this cell.
*
* @param alignment the new alignment as a String
*/
public void setHorizontalAlignment(String alignment) {
if (ElementTags.ALIGN_CENTER.equalsIgnoreCase(alignment)) {
this.horizontalAlignment = Element.ALIGN_CENTER;
return;
}
if (ElementTags.ALIGN_RIGHT.equalsIgnoreCase(alignment)) {
this.horizontalAlignment = Element.ALIGN_RIGHT;
return;
}
if (ElementTags.ALIGN_JUSTIFIED.equalsIgnoreCase(alignment)) {
this.horizontalAlignment = Element.ALIGN_JUSTIFIED;
return;
}
if (ElementTags.ALIGN_JUSTIFIED_ALL.equalsIgnoreCase(alignment)) {
this.horizontalAlignment = Element.ALIGN_JUSTIFIED_ALL;
return;
}
this.horizontalAlignment = Element.ALIGN_LEFT;
}
/**
* Sets the vertical alignment.
*
* @param value the new value
*/
public void setVerticalAlignment(int value) {
verticalAlignment = value;
}
/**
* Sets the alignment of this paragraph.
*
* @param alignment the new alignment as a String
*/
public void setVerticalAlignment(String alignment) {
if (ElementTags.ALIGN_MIDDLE.equalsIgnoreCase(alignment)) {
this.verticalAlignment = Element.ALIGN_MIDDLE;
return;
}
if (ElementTags.ALIGN_BOTTOM.equalsIgnoreCase(alignment)) {
this.verticalAlignment = Element.ALIGN_BOTTOM;
return;
}
if (ElementTags.ALIGN_BASELINE.equalsIgnoreCase(alignment)) {
this.verticalAlignment = Element.ALIGN_BASELINE;
return;
}
this.verticalAlignment = Element.ALIGN_TOP;
}
/**
* Sets the width.
*
* @param value the new value
*/
public void setWidth(String value) {
width = value;
}
/**
* Sets the colspan.
*
* @param value the new value
*/
public void setColspan(int value) {
colspan = value;
}
/**
* Sets the rowspan.
*
* @param value the new value
*/
public void setRowspan(int value) {
rowspan = value;
}
/**
* Sets header.
*
* @param value the new value
*/
public void setHeader(boolean value) {
header = value;
}
/**
* Set nowrap.
*
* @param value the new value
*/
public void setNoWrap(boolean value) {
maxLines = 1;
}
// methods to retrieve information
/**
* Gets the number of Elements in the Cell.
*
* @return a size.
*/
public int size() {
return arrayList.size();
}
/**
* Checks if the Cell is empty.
*
* @return false if there are non-empty Elements in the Cell.
*/
public boolean isEmpty() {
switch(size()) {
case 0:
return true;
case 1:
Element element = (Element) arrayList.get(0);
switch (element.type()) {
case Element.CHUNK:
return ((Chunk) element).isEmpty();
case Element.ANCHOR:
case Element.PHRASE:
case Element.PARAGRAPH:
return ((Phrase) element).isEmpty();
case Element.LIST:
return ((List) element).size() == 0;
}
return false;
default:
return false;
}
}
/**
* Makes sure there is at least 1 object in the Cell.
*
* Otherwise it might not be shown in the table.
*/
void fill() {
if (size() == 0) arrayList.add(new Paragraph(0));
}
/**
* Checks if the Cell is empty.
*
* @return false if there are non-empty Elements in the Cell.
*/
public boolean isTable() {
return (size() == 1) && (((Element)arrayList.get(0)).type() == Element.TABLE);
}
/**
* Gets an iterator of Elements.
*
* @return an Iterator.
*/
public Iterator getElements() {
return arrayList.iterator();
}
/**
* Gets the horizontal alignment.
*
* @return a value
*/
public int horizontalAlignment() {
return horizontalAlignment;
}
/**
* Gets the vertical alignment.
*
* @return a value
*/
public int verticalAlignment() {
return verticalAlignment;
}
/**
* Gets the width.
*
* @return a value
*/
public String cellWidth() {
return width;
}
/**
* Gets the colspan.
*
* @return a value
*/
public int colspan() {
return colspan;
}
/**
* Gets the rowspan.
*
* @return a value
*/
public int rowspan() {
return rowspan;
}
/**
* Gets the leading.
*
* @return a value
*/
public float leading() {
if (Float.isNaN(leading)) {
return 16;
}
return leading;
}
/**
* Is this Cell a header?
*
* @return a value
*/
public boolean header() {
return header;
}
/**
* Get nowrap.
*
* @return a value
*/
public boolean noWrap() {
return maxLines == 1;
}
/**
* Clears all the Elements of this Cell.
*/
public void clear() {
arrayList.clear();
}
/**
* This method throws an UnsupportedOperationException.
* @return NA
*/
public float top() {
throw new UnsupportedOperationException("Dimensions of a Cell can't be calculated. See the FAQ.");
}
/**
* This method throws an UnsupportedOperationException.
* @return NA
*/
public float bottom() {
throw new UnsupportedOperationException("Dimensions of a Cell can't be calculated. See the FAQ.");
}
/**
* This method throws an UnsupportedOperationException.
* @return NA
*/
public float left() {
throw new UnsupportedOperationException("Dimensions of a Cell can't be calculated. See the FAQ.");
}
/**
* This method throws an UnsupportedOperationException.
* @return NA
*/
public float right() {
throw new UnsupportedOperationException("Dimensions of a Cell can't be calculated. See the FAQ.");
}
/**
* This method throws an UnsupportedOperationException.
* @param margin
* @return NA
*/
public float top(int margin) {
throw new UnsupportedOperationException("Dimensions of a Cell can't be calculated. See the FAQ.");
}
/**
* This method throws an UnsupportedOperationException.
* @param margin
* @return NA
*/
public float bottom(int margin) {
throw new UnsupportedOperationException("Dimensions of a Cell can't be calculated. See the FAQ.");
}
/**
* This method throws an UnsupportedOperationException.
* @param margin
* @return NA
*/
public float left(int margin) {
throw new UnsupportedOperationException("Dimensions of a Cell can't be calculated. See the FAQ.");
}
/**
* This method throws an UnsupportedOperationException.
* @param margin NA
* @return NA
*/
public float right(int margin) {
throw new UnsupportedOperationException("Dimensions of a Cell can't be calculated. See the FAQ.");
}
/**
* This method throws an UnsupportedOperationException.
* @param value NA
*/
public void setTop(int value) {
throw new UnsupportedOperationException("Dimensions of a Cell are attributed automagically. See the FAQ.");
}
/**
* This method throws an UnsupportedOperationException.
* @param value NA
*/
public void setBottom(int value) {
throw new UnsupportedOperationException("Dimensions of a Cell are attributed automagically. See the FAQ.");
}
/**
* This method throws an UnsupportedOperationException.
* @param value NA
*/
public void setLeft(int value) {
throw new UnsupportedOperationException("Dimensions of a Cell are attributed automagically. See the FAQ.");
}
/**
* This method throws an UnsupportedOperationException.
* @param value NA
*/
public void setRight(int value) {
throw new UnsupportedOperationException("Dimensions of a Cell are attributed automagically. See the FAQ.");
}
/**
* Checks if a given tag corresponds with this object.
*
* @param tag the given tag
* @return true if the tag corresponds
*/
public static boolean isTag(String tag) {
return ElementTags.CELL.equals(tag);
}
/** Does this Cell force a group change? */
protected boolean groupChange = true;
/**
* Does this Cell force a group change?
*
* @return a value
*/
public boolean getGroupChange() {
return groupChange;
}
/**
* Sets group change.
*
* @param value the new value
*/
public void setGroupChange(boolean value) {
groupChange = value;
}
/**
* Getter for {@link #maxLines}
* @return the maxLines value
*/
public int getMaxLines() {
return maxLines;
}
/**
* Setter for {@link #maxLines}
* @param value the maximum number of lines
*/
public void setMaxLines(int value) {
maxLines = value;
}
/**
* Maximum number of lines allowed in the cell.
* The default value of this property is not to limit the maximum number of lines
* (contributed by dperezcar@fcc.es)
*/
protected int maxLines = Integer.MAX_VALUE;
/**Setter for {@link #showTruncation}
* @param value Can be null for avoiding marking the truncation.*/
public void setShowTruncation(String value) {
showTruncation = value;
}
/**
* Getter for {@link #showTruncation}
* @return the showTruncation value
*/
public String getShowTruncation() {
return showTruncation;
}
/**
* If a truncation happens due to the {@link #maxLines} property, then this text will
* be added to indicate a truncation has happened.
* Default value is null, and means avoiding marking the truncation.
* A useful value of this property could be e.g. "..."
* (contributed by dperezcar@fcc.es)
*/
String showTruncation;
/**
* Sets the value of {@link #useAscender}.
* @param use use ascender height if true
*/
public void setUseAscender(boolean use) {
useAscender = use;
}
/**
* Gets the value of {@link #useAscender}
* @return useAscender
*/
public boolean isUseAscender() {
return useAscender;
}
/**
* Sets the value of {@link #useDescender}.
* @param use use descender height if true
*/
public void setUseDescender(boolean use) {
useDescender = use;
}
/**
* gets the value of {@link #useDescender }
* @return useDescender
*/
public boolean isUseDescender() {
return useDescender;
}
/**
* Sets the value of {@link #useBorderPadding}.
* @param use adjust layour for borders if true
*/
public void setUseBorderPadding(boolean use) {
useBorderPadding = use;
}
/**
* Gets the value of {@link #useBorderPadding}.
* @return useBorderPadding
*/
public boolean isUseBorderPadding() {
return useBorderPadding;
}
/**
* Creates a PdfPCell based on this Cell object.
* @return a PdfPCell
* @throws BadElementException
*/
public PdfPCell createPdfPCell() throws BadElementException {
if (rowspan > 1) throw new BadElementException("PdfPCells can't have a rowspan > 1");
if (isTable()) return new PdfPCell(((Table)arrayList.get(0)).createPdfPTable());
PdfPCell cell = new PdfPCell();
cell.setVerticalAlignment(verticalAlignment);
cell.setHorizontalAlignment(horizontalAlignment);
cell.setColspan(colspan);
cell.setUseBorderPadding(useBorderPadding);
cell.setUseDescender(useDescender);
cell.setLeading(leading(), 0);
cell.cloneNonPositionParameters(this);
cell.setNoWrap(noWrap());
for (Iterator i = getElements(); i.hasNext(); ) {
Element e = (Element)i.next();
if (e.type() == Element.PHRASE || e.type() == Element.PARAGRAPH) {
Paragraph p = new Paragraph((Phrase)e);
p.setAlignment(horizontalAlignment);
e = p;
}
cell.addElement(e);
}
return cell;
}
}