001: /*
002: * $Id: RtfTable.java 2776 2007-05-23 20:01:40Z hallm $
003: * $Name$
004: *
005: * Copyright 2001, 2002, 2003, 2004 by Mark Hall
006: *
007: * The contents of this file are subject to the Mozilla Public License Version 1.1
008: * (the "License"); you may not use this file except in compliance with the License.
009: * You may obtain a copy of the License at http://www.mozilla.org/MPL/
010: *
011: * Software distributed under the License is distributed on an "AS IS" basis,
012: * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
013: * for the specific language governing rights and limitations under the License.
014: *
015: * The Original Code is 'iText, a free JAVA-PDF library'.
016: *
017: * The Initial Developer of the Original Code is Bruno Lowagie. Portions created by
018: * the Initial Developer are Copyright (C) 1999, 2000, 2001, 2002 by Bruno Lowagie.
019: * All Rights Reserved.
020: * Co-Developer of the code is Paulo Soares. Portions created by the Co-Developer
021: * are Copyright (C) 2000, 2001, 2002 by Paulo Soares. All Rights Reserved.
022: *
023: * Contributor(s): all the names of the contributors are added in the source code
024: * where applicable.
025: *
026: * Alternatively, the contents of this file may be used under the terms of the
027: * LGPL license (the ?GNU LIBRARY GENERAL PUBLIC LICENSE?), in which case the
028: * provisions of LGPL are applicable instead of those above. If you wish to
029: * allow use of your version of this file only under the terms of the LGPL
030: * License and not to allow others to use your version of this file under
031: * the MPL, indicate your decision by deleting the provisions above and
032: * replace them with the notice and other provisions required by the LGPL.
033: * If you do not delete the provisions above, a recipient may use your version
034: * of this file under either the MPL or the GNU LIBRARY GENERAL PUBLIC LICENSE.
035: *
036: * This library is free software; you can redistribute it and/or modify it
037: * under the terms of the MPL as stated above or under the terms of the GNU
038: * Library General Public License as published by the Free Software Foundation;
039: * either version 2 of the License, or any later version.
040: *
041: * This library is distributed in the hope that it will be useful, but WITHOUT
042: * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
043: * FOR A PARTICULAR PURPOSE. See the GNU Library general Public License for more
044: * details.
045: *
046: * If you didn't download this code from the following link, you should check if
047: * you aren't using an obsolete version:
048: * http://www.lowagie.com/iText/
049: */
050:
051: package com.lowagie.text.rtf.table;
052:
053: import java.io.ByteArrayOutputStream;
054: import java.io.IOException;
055: import java.io.OutputStream;
056: import java.util.ArrayList;
057: import java.util.Iterator;
058:
059: import com.lowagie.text.Element;
060: import com.lowagie.text.Row;
061: import com.lowagie.text.Table;
062: import com.lowagie.text.rtf.RtfElement;
063: import com.lowagie.text.rtf.document.RtfDocument;
064: import com.lowagie.text.rtf.text.RtfParagraph;
065:
066: /**
067: * The RtfTable wraps a Table.
068: * INTERNAL USE ONLY
069: *
070: * @version $Id: RtfTable.java 2776 2007-05-23 20:01:40Z hallm $
071: * @author Mark Hall (mhall@edu.uni-klu.ac.at)
072: * @author Steffen Stundzig
073: * @author Benoit Wiart
074: * @author Thomas Bickel (tmb99@inode.at)
075: */
076: public class RtfTable extends RtfElement {
077:
078: /**
079: * The rows of this RtfTable
080: */
081: private ArrayList rows = null;
082: /**
083: * The percentage of the page width that this RtfTable covers
084: */
085: private float tableWidthPercent = 80;
086: /**
087: * An array with the proportional widths of the cells in each row
088: */
089: private float[] proportionalWidths = null;
090: /**
091: * The cell padding
092: */
093: private float cellPadding = 0;
094: /**
095: * The cell spacing
096: */
097: private float cellSpacing = 0;
098: /**
099: * The border style of this RtfTable
100: */
101: private RtfBorderGroup borders = null;
102: /**
103: * The alignment of this RtfTable
104: */
105: private int alignment = Element.ALIGN_CENTER;
106: /**
107: * Whether the cells in this RtfTable must fit in a page
108: */
109: private boolean cellsFitToPage = false;
110: /**
111: * Whether the whole RtfTable must fit in a page
112: */
113: private boolean tableFitToPage = false;
114: /**
115: * The number of header rows in this RtfTable
116: */
117: private int headerRows = 0;
118:
119: /**
120: * Constructs a RtfTable based on a Table for a RtfDocument.
121: *
122: * @param doc The RtfDocument this RtfTable belongs to
123: * @param table The Table that this RtfTable wraps
124: */
125: public RtfTable(RtfDocument doc, Table table) {
126: super (doc);
127: table.complete();
128: importTable(table);
129: }
130:
131: /**
132: * Imports the rows and settings from the Table into this
133: * RtfTable.
134: *
135: * @param table The source Table
136: */
137: private void importTable(Table table) {
138: this .rows = new ArrayList();
139: this .tableWidthPercent = table.getWidth();
140: this .proportionalWidths = table.getProportionalWidths();
141: this .cellPadding = (float) (table.getPadding() * TWIPS_FACTOR);
142: this .cellSpacing = (float) (table.getSpacing() * TWIPS_FACTOR);
143: this .borders = new RtfBorderGroup(this .document,
144: RtfBorder.ROW_BORDER, table.getBorder(), table
145: .getBorderWidth(), table.getBorderColor());
146: this .alignment = table.getAlignment();
147:
148: int i = 0;
149: Iterator rowIterator = table.iterator();
150: while (rowIterator.hasNext()) {
151: this .rows.add(new RtfRow(this .document, this ,
152: (Row) rowIterator.next(), i));
153: i++;
154: }
155: for (i = 0; i < this .rows.size(); i++) {
156: ((RtfRow) this .rows.get(i)).handleCellSpanning();
157: ((RtfRow) this .rows.get(i)).cleanRow();
158: }
159: this .headerRows = table.getLastHeaderRow();
160: this .cellsFitToPage = table.isCellsFitPage();
161: this .tableFitToPage = table.isTableFitsPage();
162: }
163:
164: /**
165: * Writes the content of this RtfTable
166: *
167: * @return A byte array with the content of this RtfTable
168: * @deprecated replaced by {@link #writeContent(OutputStream)}
169: */
170: public byte[] write() {
171: ByteArrayOutputStream result = new ByteArrayOutputStream();
172: try {
173: writeContent(result);
174: } catch (IOException ioe) {
175: ioe.printStackTrace();
176: }
177: return result.toByteArray();
178: }
179:
180: /**
181: * Writes the content of this RtfTable
182: */
183: public void writeContent(final OutputStream result)
184: throws IOException {
185: if (!inHeader) {
186: result.write(RtfParagraph.PARAGRAPH);
187: }
188:
189: for (int i = 0; i < this .rows.size(); i++) {
190: RtfElement re = (RtfElement) this .rows.get(i);
191: //.result.write(re.write());
192: re.writeContent(result);
193: }
194:
195: result.write(RtfParagraph.PARAGRAPH_DEFAULTS);
196: }
197:
198: /**
199: * Gets the alignment of this RtfTable
200: *
201: * @return The alignment of this RtfTable.
202: */
203: protected int getAlignment() {
204: return alignment;
205: }
206:
207: /**
208: * Gets the borders of this RtfTable
209: *
210: * @return The borders of this RtfTable.
211: */
212: protected RtfBorderGroup getBorders() {
213: return this .borders;
214: }
215:
216: /**
217: * Gets the cell padding of this RtfTable
218: *
219: * @return The cell padding of this RtfTable.
220: */
221: protected float getCellPadding() {
222: return cellPadding;
223: }
224:
225: /**
226: * Gets the cell spacing of this RtfTable
227: *
228: * @return The cell spacing of this RtfTable.
229: */
230: protected float getCellSpacing() {
231: return cellSpacing;
232: }
233:
234: /**
235: * Gets the proportional cell widths of this RtfTable
236: *
237: * @return The proportional widths of this RtfTable.
238: */
239: protected float[] getProportionalWidths() {
240: return (float[]) proportionalWidths.clone();
241: }
242:
243: /**
244: * Gets the percentage of the page width this RtfTable covers
245: *
246: * @return The percentage of the page width.
247: */
248: protected float getTableWidthPercent() {
249: return tableWidthPercent;
250: }
251:
252: /**
253: * Gets the rows of this RtfTable
254: *
255: * @return The rows of this RtfTable
256: */
257: protected ArrayList getRows() {
258: return this .rows;
259: }
260:
261: /**
262: * Gets the cellsFitToPage setting of this RtfTable.
263: *
264: * @return The cellsFitToPage setting of this RtfTable.
265: */
266: protected boolean getCellsFitToPage() {
267: return this .cellsFitToPage;
268: }
269:
270: /**
271: * Gets the tableFitToPage setting of this RtfTable.
272: *
273: * @return The tableFitToPage setting of this RtfTable.
274: */
275: protected boolean getTableFitToPage() {
276: return this .tableFitToPage;
277: }
278:
279: /**
280: * Gets the number of header rows of this RtfTable
281: *
282: * @return The number of header rows
283: */
284: protected int getHeaderRows() {
285: return this.headerRows;
286: }
287: }
|