Java tutorial
/* * $Id: Cell.java 3373 2008-05-12 16:21:24Z xlv $ * * 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.util.ArrayList; import java.util.Iterator; import com.lowagie.text.pdf.PdfPCell; /** * A <CODE>Cell</CODE> is a <CODE>Rectangle</CODE> containing other * <CODE>Element</CODE>s. * <P> * A <CODE>Cell</CODE> must be added to a <CODE>Table</CODE>. * The <CODE>Table</CODE> will place the <CODE>Cell</CODE> in * a <CODE>Row</CODE>. * <P> * Example: * <BLOCKQUOTE><PRE> * Table table = new Table(3); * table.setBorderWidth(1); * table.setBorderColor(new Color(0, 0, 255)); * table.setCellpadding(5); * table.setCellspacing(5); * <STRONG>Cell cell = new Cell("header");</STRONG> * <STRONG>cell.setHeader(true);</STRONG> * <STRONG>cell.setColspan(3);</STRONG> * table.addCell(cell); * <STRONG>cell = new Cell("example cell with colspan 1 and rowspan 2");</STRONG> * <STRONG>cell.setRowspan(2);</STRONG> * <STRONG>cell.setBorderColor(new Color(255, 0, 0));</STRONG> * table.addCell(cell); * table.addCell("1.1"); * table.addCell("2.1"); * table.addCell("1.2"); * table.addCell("2.2"); * </PRE></BLOCKQUOTE> * * @see Rectangle * @see Element * @see Table * @see Row */ public class Cell extends Rectangle implements TextElementArray { // membervariables /** * The <CODE>ArrayList</CODE> of <CODE>Element</CODE>s * that are part of the content of the Cell. */ protected ArrayList arrayList = null; /** The horizontal alignment of the cell content. */ protected int horizontalAlignment = Element.ALIGN_UNDEFINED; /** The vertical alignment of the cell content. */ protected int verticalAlignment = Element.ALIGN_UNDEFINED; /** * The width of the cell as a String. * It can be an absolute value "100" or a percentage "20%". */ protected float width; protected boolean percentage = false; /** The colspan of the cell. */ protected int colspan = 1; /** The rowspan of the cell. */ protected int rowspan = 1; /** The leading of the content inside the cell. */ float leading = Float.NaN; /** Is this <CODE>Cell</CODE> a header? */ protected boolean header; /** * 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; /** * If a truncation happens due to the 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; /** * 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; /** Does this <CODE>Cell</CODE> force a group change? */ protected boolean groupChange = true; // constructors /** Constructs an empty <CODE>Cell</CODE>. */ 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 arrayList = new ArrayList(); } /** * Constructs an empty <CODE>Cell</CODE> (for internal use only). * * @param dummy a dummy value */ public Cell(boolean dummy) { this(); arrayList.add(new Paragraph(0)); } /** * Constructs a <CODE>Cell</CODE> with a certain content.<p> * The <CODE>String</CODE> will be converted into a <CODE>Paragraph</CODE>. * @param content a <CODE>String</CODE> */ public Cell(String content) { this(); try { addElement(new Paragraph(content)); } catch (BadElementException bee) { } } /** * Constructs a <CODE>Cell</CODE> with a certain <CODE>Element</CODE>.<p> * if the element is a <CODE>ListItem</CODE>, <CODE>Row</CODE> or * <CODE>Cell</CODE>, an exception will be thrown. * * @param element the element * @throws BadElementException when the creator was called with a <CODE>ListItem</CODE>, <CODE>Row</CODE> or <CODE>Cell</CODE> */ public Cell(Element element) throws BadElementException { this(); if (element instanceof Phrase) { setLeading(((Phrase) element).getLeading()); } addElement(element); } // implementation of the Element-methods /** * Processes the element by adding it (or the different parts) to an * <CODE>ElementListener</CODE>. * * @param listener an <CODE>ElementListener</CODE> * @return <CODE>true</CODE> 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 <CODE>ArrayList</CODE> */ public ArrayList getChunks() { ArrayList tmp = new ArrayList(); for (Iterator i = arrayList.iterator(); i.hasNext();) { tmp.addAll(((Element) i.next()).getChunks()); } return tmp; } // Getters and setters /** * Gets the horizontal alignment. * * @return a value */ public int getHorizontalAlignment() { return horizontalAlignment; } /** * Sets the horizontal alignment. * @param value the new value */ public void setHorizontalAlignment(int value) { horizontalAlignment = value; } /** * Sets the alignment of this cell. * This methods allows you to set the alignment as a String. * @param alignment the new alignment as a <CODE>String</CODE> */ public void setHorizontalAlignment(String alignment) { setHorizontalAlignment(ElementTags.alignmentValue(alignment)); } /** * Gets the vertical alignment. * @return a value */ public int getVerticalAlignment() { return verticalAlignment; } /** * 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 <CODE>String</CODE> */ public void setVerticalAlignment(String alignment) { setVerticalAlignment(ElementTags.alignmentValue(alignment)); } /** * Sets the width. * * @param value the new value */ public void setWidth(float value) { this.width = value; } /** * Sets the width. * It can be an absolute value "100" or a percentage "20%" * * @param value the new value */ public void setWidth(String value) { if (value.endsWith("%")) { value = value.substring(0, value.length() - 1); percentage = true; } width = Integer.parseInt(value); } /** * Gets the width. */ public float getWidth() { return width; } /** * Gets the width as a String. * * @return a value */ public String getWidthAsString() { String w = String.valueOf(width); if (w.endsWith(".0")) w = w.substring(0, w.length() - 2); if (percentage) w += "%"; return w; } /** * Sets the colspan. * * @param value the new value */ public void setColspan(int value) { colspan = value; } /** * Gets the colspan. * @return a value */ public int getColspan() { return colspan; } /** * Sets the rowspan. * * @param value the new value */ public void setRowspan(int value) { rowspan = value; } /** * Gets the rowspan. * @return a value */ public int getRowspan() { return rowspan; } /** * Sets the leading. * * @param value the new value */ public void setLeading(float value) { leading = value; } /** * Gets the leading. * * @return a value */ public float getLeading() { if (Float.isNaN(leading)) { return 16; } return leading; } /** * Sets header. * * @param value the new value */ public void setHeader(boolean value) { header = value; } /** * Is this <CODE>Cell</CODE> a header? * * @return a value */ public boolean isHeader() { return header; } /** * Setter for maxLines * @param value the maximum number of lines */ public void setMaxLines(int value) { maxLines = value; } /** * Getter for maxLines * @return the maxLines value */ public int getMaxLines() { return maxLines; } /** * Setter for showTruncation * @param value Can be null for avoiding marking the truncation. */ public void setShowTruncation(String value) { showTruncation = value; } /** * Getter for showTruncation * @return the showTruncation value */ public String getShowTruncation() { return showTruncation; } /** * Sets the value of useAscender. * @param use use ascender height if true */ public void setUseAscender(boolean use) { useAscender = use; } /** * Gets the value of useAscender * @return useAscender */ public boolean isUseAscender() { return useAscender; } /** * Sets the value of useDescender. * @param use use descender height if true */ public void setUseDescender(boolean use) { useDescender = use; } /** * gets the value of useDescender * @return useDescender */ public boolean isUseDescender() { return useDescender; } /** * Sets the value of useBorderPadding. * @param use adjust layout for borders if true */ public void setUseBorderPadding(boolean use) { useBorderPadding = use; } /** * Gets the value of useBorderPadding. * @return useBorderPadding */ public boolean isUseBorderPadding() { return useBorderPadding; } /** * Does this <CODE>Cell</CODE> 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; } // arraylist stuff /** * Gets the number of <CODE>Element</CODE>s in the Cell. * * @return a <CODE>size</CODE>. */ public int size() { return arrayList.size(); } /** * Gets an iterator of <CODE>Element</CODE>s. * * @return an <CODE>Iterator</CODE>. */ public Iterator getElements() { return arrayList.iterator(); } /** * Clears all the <CODE>Element</CODE>s of this <CODE>Cell</CODE>. */ public void clear() { arrayList.clear(); } /** * Checks if the <CODE>Cell</CODE> is empty. * * @return <CODE>false</CODE> if there are non-empty <CODE>Element</CODE>s in the <CODE>Cell</CODE>. */ 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).isEmpty(); } 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 this <CODE>Cell</CODE> is a placeholder for a (nested) table. * * @return true if the only element in this cell is a table */ public boolean isTable() { return (size() == 1) && (((Element) arrayList.get(0)).type() == Element.TABLE); } /** * Adds an element to this <CODE>Cell</CODE>. * <P> * Remark: you can't add <CODE>ListItem</CODE>s, <CODE>Row</CODE>s, <CODE>Cell</CODE>s, * <CODE>JPEG</CODE>s, <CODE>GIF</CODE>s or <CODE>PNG</CODE>s to a <CODE>Cell</CODE>. * * @param element The <CODE>Element</CODE> to add * @throws BadElementException if the method was called with a <CODE>ListItem</CODE>, <CODE>Row</CODE> or <CODE>Cell</CODE> */ 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.getColumns()); 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: List list = (List) element; if (Float.isNaN(leading)) { setLeading(list.getTotalLeading()); } if (list.isEmpty()) return; arrayList.add(element); return; case Element.ANCHOR: case Element.PARAGRAPH: case Element.PHRASE: Phrase p = (Phrase) element; if (Float.isNaN(leading)) { setLeading(p.getLeading()); } if (p.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).getWidth(); switch (((Table) element).getAlignment()) { 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.isEmpty()) { table.addCell(getDummyCell()); } else { tmp = new Cell(); tmp.setBorder(NO_BORDER); tmp.setColspan(3); for (Iterator i = arrayList.iterator(); i.hasNext();) { tmp.add(i.next()); } table.addCell(tmp); } tmp = new Cell(); tmp.setBorder(NO_BORDER); table.addCell(tmp); table.insertTable((Table) element); tmp = new Cell(); tmp.setBorder(NO_BORDER); table.addCell(tmp); table.addCell(getDummyCell()); clear(); arrayList.add(table); return; default: arrayList.add(element); } } /** * Add an <CODE>Object</CODE> to this cell. * * @param o the object to add * @return always <CODE>true</CODE> */ 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()); } } // helper methods /** * Get dummy cell used when merging inner tables. * @return a cell with colspan 3 and no border */ private static Cell getDummyCell() { Cell cell = new Cell(true); cell.setColspan(3); cell.setBorder(NO_BORDER); return cell; } /** * 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(getLeading(), 0); cell.cloneNonPositionParameters(this); cell.setNoWrap(getMaxLines() == 1); 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; } // unsupported Rectangle methods /** * This method throws an <CODE>UnsupportedOperationException</CODE>. * @return NA */ public float getTop() { throw new UnsupportedOperationException("Dimensions of a Cell can't be calculated. See the FAQ."); } /** * This method throws an <CODE>UnsupportedOperationException</CODE>. * @return NA */ public float getBottom() { throw new UnsupportedOperationException("Dimensions of a Cell can't be calculated. See the FAQ."); } /** * This method throws an <CODE>UnsupportedOperationException</CODE>. * @return NA */ public float getLeft() { throw new UnsupportedOperationException("Dimensions of a Cell can't be calculated. See the FAQ."); } /** * This method throws an <CODE>UnsupportedOperationException</CODE>. * @return NA */ public float getRight() { throw new UnsupportedOperationException("Dimensions of a Cell can't be calculated. See the FAQ."); } /** * This method throws an <CODE>UnsupportedOperationException</CODE>. * @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 <CODE>UnsupportedOperationException</CODE>. * @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 <CODE>UnsupportedOperationException</CODE>. * @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 <CODE>UnsupportedOperationException</CODE>. * @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 <CODE>UnsupportedOperationException</CODE>. * @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 <CODE>UnsupportedOperationException</CODE>. * @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 <CODE>UnsupportedOperationException</CODE>. * @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 <CODE>UnsupportedOperationException</CODE>. * @param value NA */ public void setRight(int value) { throw new UnsupportedOperationException("Dimensions of a Cell are attributed automagically. See the FAQ."); } }