From 6025b6016517c6d898d8957d1d7e03ba71431912 Mon Sep 17 00:00:00 2001 From: tknall Date: Fri, 1 Dec 2006 12:20:24 +0000 Subject: Initial import of release 2.2. git-svn-id: https://joinup.ec.europa.eu/svn/pdf-as/trunk@4 7b5415b0-85f9-ee4d-85bd-d5d0c3b42d1c --- src/main/java/com/lowagie/text/Cell.java | 1013 ++++++++++++++++++++++++++++++ 1 file changed, 1013 insertions(+) create mode 100644 src/main/java/com/lowagie/text/Cell.java (limited to 'src/main/java/com/lowagie/text/Cell.java') diff --git a/src/main/java/com/lowagie/text/Cell.java b/src/main/java/com/lowagie/text/Cell.java new file mode 100644 index 0000000..32d6b70 --- /dev/null +++ b/src/main/java/com/lowagie/text/Cell.java @@ -0,0 +1,1013 @@ +/* + * $Id: Cell.java,v 1.106 2005/11/12 18:00:57 psoares33 Exp $ + * $Name: $ + * + * Copyright 1999, 2000, 2001, 2002 by 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/ + */ + +package com.lowagie.text; + +import java.awt.Color; +import java.util.ArrayList; +import java.util.Iterator; +import java.util.Properties; + +import com.lowagie.text.markup.MarkupParser; +import com.lowagie.text.pdf.PdfPCell; + +/** + * A 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");
+ *
+ * + * @see Rectangle + * @see Element + * @see Table + * @see Row + */ + +public class Cell extends Rectangle implements TextElementArray { + + // static final membervariable + + // This accessor replaces the dangerous static member DUMMY_CELL + /** + * Get dummy cell used when merging inner tables. + * @return a cell with colspan 3 and no border + */ + public static Cell getDummyCell() { + Cell cell = new Cell(true); + cell.setColspan(3); + cell.setBorder(NO_BORDER); + return cell; + } + + // membervariables + +/** This is the 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 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 + if(element instanceof Phrase) { + Phrase p = (Phrase)element; + leading = p.leading(); + } + + // initializes the arraylist and adds an element + arrayList = new ArrayList(); + addElement(element); + } + +/** + * Returns a 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. + *

+ * Remark: you can't add 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; + } +} \ No newline at end of file -- cgit v1.2.3