diff options
| author | tknall <tknall@7b5415b0-85f9-ee4d-85bd-d5d0c3b42d1c> | 2006-12-01 12:20:24 +0000 |
|---|---|---|
| committer | tknall <tknall@7b5415b0-85f9-ee4d-85bd-d5d0c3b42d1c> | 2006-12-01 12:20:24 +0000 |
| commit | 6025b6016517c6d898d8957d1d7e03ba71431912 (patch) | |
| tree | b15bd6fa5ffe9588a9bca3f2b8a7e358f83b6eba /src/main/java/com/lowagie/text/rtf | |
| parent | d2c77e820ab4aba8235d71275755021347b3ad10 (diff) | |
| download | pdf-as-3-6025b6016517c6d898d8957d1d7e03ba71431912.tar.gz pdf-as-3-6025b6016517c6d898d8957d1d7e03ba71431912.tar.bz2 pdf-as-3-6025b6016517c6d898d8957d1d7e03ba71431912.zip | |
Initial import of release 2.2.REL-2.2@923
git-svn-id: https://joinup.ec.europa.eu/svn/pdf-as/trunk@4 7b5415b0-85f9-ee4d-85bd-d5d0c3b42d1c
Diffstat (limited to 'src/main/java/com/lowagie/text/rtf')
62 files changed, 16673 insertions, 0 deletions
diff --git a/src/main/java/com/lowagie/text/rtf/AbstractRtfField.java b/src/main/java/com/lowagie/text/rtf/AbstractRtfField.java new file mode 100644 index 0000000..347784d --- /dev/null +++ b/src/main/java/com/lowagie/text/rtf/AbstractRtfField.java @@ -0,0 +1,358 @@ +/**
+ * $Id: AbstractRtfField.java,v 1.17 2006/02/09 17:25:26 hallm Exp $
+ *
+ * Copyright 2002 by
+ * <a href="http://www.smb-tec.com">SMB</a>
+ * <a href="mailto:Dirk.Weigenand@smb-tec.com">Dirk.Weigenand@smb-tec.com</a>
+ *
+ * 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.rtf;
+
+import com.lowagie.text.Chunk;
+import com.lowagie.text.Font;
+import com.lowagie.text.rtf.RtfWriter;
+
+import java.io.OutputStream;
+import java.io.IOException;
+
+
+/**
+ * This class implements an abstract RtfField.
+ *
+ * This class is based on the RtfWriter-package from Mark Hall.
+ *
+ * ONLY FOR USE WITH THE RtfWriter NOT with the RtfWriter2.
+ *
+ * @author <a href="mailto:Dirk.Weigenand@smb-tec.com">Dirk Weigenand</a>
+ * @version $Id: AbstractRtfField.java,v 1.17 2006/02/09 17:25:26 hallm Exp $
+ * @since Mon Aug 19 14:50:39 2002
+ * @deprecated Please move to the RtfWriter2 and associated classes.
+ */
+abstract class AbstractRtfField extends Chunk implements RtfField {
+ private static final byte[] fldDirty = "\\flddirty".getBytes();
+ private static final byte[] fldPriv = "\\fldpriv".getBytes();
+ private static final byte[] fldLock = "\\fldlock".getBytes();
+ private static final byte[] fldEdit = "\\fldedit".getBytes();
+ private static final byte[] fldAlt = "\\fldalt".getBytes();
+
+ /**
+ * public constructor
+ * @param content the content of the field
+ * @param font the font of the field
+ */
+ public AbstractRtfField(String content, Font font) {
+ super(content, font);
+ }
+
+ /**
+ * Determines whether this RtfField is locked, i.e. it cannot be
+ * updated. Defaults to <tt>false</tt>.
+ */
+ private boolean rtfFieldIsLocked = false;
+
+ /**
+ * Determines whether a formatting change has been made since the
+ * field was last updated. Defaults to <tt>false</tt>.
+ */
+ private boolean rtfFieldIsDirty = false;
+
+ /**
+ * Determines whether text has been added, removed from thre field
+ * result since the field was last updated. Defaults to
+ * <tt>false</tt>.
+ */
+ private boolean rtfFieldWasEdited = false;
+
+ /**
+ * Determines whether the field is in suitable form for
+ * display. Defaults to <tt>false</tt>.
+ */
+ private boolean rtfFieldIsPrivate = false;
+
+ /**
+ * Determines whether this RtfField shall refer to an end note.
+ */
+ private boolean rtfFieldIsAlt = false;
+
+ /**
+ * Determines whtether the field is locked, i.e. it cannot be
+ * updated.
+ *
+ * @return <tt>true</tt> iff the field cannot be updated,
+ * <tt>false</tt> otherwise.
+ */
+ public final boolean isLocked() {
+ return this.rtfFieldIsLocked;
+ }
+
+ /**
+ * Set whether the field can be updated.
+ *
+ * @param rtfFieldIsLocked <tt>true</tt> if the field cannot be
+ * updated, <tt>false</tt> otherwise.
+ */
+ public final void setLocked(final boolean rtfFieldIsLocked) {
+ this.rtfFieldIsLocked = rtfFieldIsLocked;
+ }
+
+ /**
+ * Set whether a formatting change has been made since the field
+ * was last updated
+ * @param rtfFieldIsDirty <tt>true</tt> if the field was
+ * changed since the field was last updated, <tt>false</tt>
+ * otherwise.
+ */
+ public final void setDirty(final boolean rtfFieldIsDirty) {
+ this.rtfFieldIsDirty = rtfFieldIsDirty;
+ }
+
+ /**
+ * Determines whether the field was changed since the field was
+ * last updated
+ * @return <tt>true</tt> if the field was changed since the field
+ * was last updated, <tt>false</tt> otherwise.
+ */
+ public final boolean isDirty() {
+ return this.rtfFieldIsDirty;
+ }
+
+ /**
+ * Set whether text has been added, removed from thre field result
+ * since the field was last updated.
+ * @param rtfFieldWasEdited Determines whether text has been
+ * added, removed from the field result since the field was last
+ * updated (<tt>true</tt>, <tt>false</tt> otherwise..
+ */
+ public final void setEdited(final boolean rtfFieldWasEdited) {
+ this.rtfFieldWasEdited = rtfFieldWasEdited;
+ }
+
+ /**
+ * Determines whether text has been added, removed from the field
+ * result since the field was last updated.
+ * @return rtfFieldWasEdited <tt>true</tt> if text has been added,
+ * removed from the field result since the field was last updated,
+ * <tt>false</tt> otherwise.
+ */
+ public final boolean wasEdited() {
+ return this.rtfFieldWasEdited;
+ }
+
+ /**
+ * Set whether the field is in suitable form for
+ * display. I.e. it's not a field with a picture as field result
+ * @param rtfFieldIsPrivate Determines whether the field is in
+ * suitable form for display: <tt>true</tt> it can be displayed,
+ * <tt>false</tt> it cannot be displayed.
+ */
+ public final void setPrivate(final boolean rtfFieldIsPrivate) {
+ this.rtfFieldIsPrivate = rtfFieldIsPrivate;
+ }
+
+ /**
+ * Determines whether the field is in suitable form for display.
+ * @return whether the field is in suitable form for display:
+ * <tt>true</tt> yes, <tt>false</tt> no it cannot be displayed.
+ */
+ public final boolean isPrivate() {
+ return this.rtfFieldIsPrivate;
+ }
+
+ /**
+ * Abstract method for writing custom stuff to the Field
+ * Initialization Stuff part of an RtfField.
+ * @param out
+ * @throws IOException
+ */
+ public abstract void writeRtfFieldInitializationStuff(OutputStream out) throws IOException;
+
+ /**
+ * Abstract method for writing custom stuff to the Field Result
+ * part of an RtfField.
+ * @param out
+ * @throws IOException
+ */
+ public abstract void writeRtfFieldResultStuff(OutputStream out) throws IOException;
+
+ /**
+ * Determines whether this RtfField shall refer to an end note.
+ * @param rtfFieldIsAlt <tt>true</tt> if this RtfField shall refer
+ * to an end note, <tt>false</tt> otherwise
+ */
+ public final void setAlt(final boolean rtfFieldIsAlt) {
+ this.rtfFieldIsAlt = rtfFieldIsAlt;
+ }
+
+ /**
+ * Determines whether this RtfField shall refer to an end
+ * note.
+ * @return <tt>true</tt> if this RtfField shall refer to an end
+ * note, <tt>false</tt> otherwise.
+ */
+ public final boolean isAlt() {
+ return this.rtfFieldIsAlt;
+ }
+
+ /**
+ * empty implementation for Chunk.
+ * @return an empty string
+ */
+ public final String content() {
+ return "";
+ }
+
+ /**
+ * For Interface RtfField.
+ * @param writer
+ * @param out
+ * @throws IOException
+ */
+ public void write( RtfWriter writer, OutputStream out ) throws IOException {
+ writeRtfFieldBegin(out);
+ writeRtfFieldModifiers(out);
+ writeRtfFieldInstBegin(out);
+ writer.writeInitialFontSignature( out, this );
+ writeRtfFieldInitializationStuff(out);
+ writeRtfFieldInstEnd(out);
+ writeRtfFieldResultBegin(out);
+ writer.writeInitialFontSignature( out, this );
+ writeRtfFieldResultStuff(out);
+ writeRtfFieldResultEnd(out);
+ writeRtfFieldEnd(out);
+ }
+
+ /**
+ * Write the beginning of an RtfField to the OutputStream.
+ * @param out
+ * @throws IOException
+ */
+ protected final void writeRtfFieldBegin(OutputStream out) throws IOException {
+ out.write(RtfWriter.openGroup);
+ out.write(RtfWriter.escape);
+ out.write(RtfWriter.field);
+ }
+
+ /**
+ * Write the modifiers defined for a RtfField to the OutputStream.
+ * @param out
+ * @throws IOException
+ */
+ protected final void writeRtfFieldModifiers(OutputStream out) throws IOException {
+ if (isDirty()) {
+ out.write(fldDirty);
+ }
+
+ if (wasEdited()) {
+ out.write(fldEdit);
+ }
+
+ if (isLocked()) {
+ out.write(fldLock);
+ }
+
+ if (isPrivate()) {
+ out.write(fldPriv);
+ }
+ }
+
+ /**
+ * Write RtfField Initialization Stuff to OutputStream.
+ * @param out
+ * @throws IOException
+ */
+ protected final void writeRtfFieldInstBegin(OutputStream out) throws IOException {
+ out.write( RtfWriter.openGroup );
+ out.write( RtfWriter.escape );
+ out.write( RtfWriter.fieldContent );
+ out.write( RtfWriter.delimiter );
+ }
+
+ /**
+ * Write end of RtfField Initialization Stuff to OutputStream.
+ * @param out
+ * @throws IOException
+ */
+ protected final void writeRtfFieldInstEnd(OutputStream out) throws IOException {
+ if (isAlt()) {
+ out.write( fldAlt );
+ out.write( RtfWriter.delimiter );
+ }
+
+ out.write( RtfWriter.closeGroup );
+ }
+
+ /**
+ * Write beginning of RtfField Result to OutputStream.
+ * @param out
+ * @throws IOException
+ */
+ protected final void writeRtfFieldResultBegin(OutputStream out) throws IOException {
+ out.write( RtfWriter.openGroup );
+ out.write( RtfWriter.escape );
+ out.write( RtfWriter.fieldDisplay );
+ out.write( RtfWriter.delimiter );
+ }
+
+ /**
+ * Write end of RtfField Result to OutputStream.
+ * @param out
+ * @throws IOException
+ */
+ protected final void writeRtfFieldResultEnd(OutputStream out) throws IOException {
+ out.write( RtfWriter.delimiter );
+ out.write( RtfWriter.closeGroup );
+ }
+
+ /**
+ * Close the RtfField.
+ * @param out
+ * @throws IOException
+ */
+ protected final void writeRtfFieldEnd(OutputStream out) throws IOException {
+ out.write( RtfWriter.closeGroup );
+ }
+}
diff --git a/src/main/java/com/lowagie/text/rtf/GenericRtfField.java b/src/main/java/com/lowagie/text/rtf/GenericRtfField.java new file mode 100644 index 0000000..23401e4 --- /dev/null +++ b/src/main/java/com/lowagie/text/rtf/GenericRtfField.java @@ -0,0 +1,139 @@ +/**
+ * $Id: GenericRtfField.java,v 1.18 2006/02/09 17:25:25 hallm Exp $
+ *
+ * Copyright 2002 by
+ * <a href="http://www.smb-tec.com">SMB</a>
+ * <a href="mailto:Dirk.Weigenand@smb-tec.com">Dirk.Weigenand@smb-tec.com</a>
+ *
+ * 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.rtf;
+
+import java.io.IOException;
+import java.io.OutputStream;
+
+import com.lowagie.text.Font;
+
+
+/**
+ * This class implements a generic RtfField.
+ *
+ * This class is based on the RtfWriter-package from Mark Hall.
+ *
+ * ONLY FOR USE WITH THE RtfWriter NOT with the RtfWriter2.
+ *
+ * @author <a href="mailto:Dirk.Weigenand@smb-tec.com">Dirk Weigenand</a>
+ * @version $Id: GenericRtfField.java,v 1.18 2006/02/09 17:25:25 hallm Exp $
+ * @since Mon Aug 19 14:50:39 2002
+ * @deprecated Please move to the RtfWriter2 and associated classes.
+ */
+public class GenericRtfField extends AbstractRtfField implements RtfField {
+ /**
+ * Field Initialization Stuff.
+ */
+ protected String fieldInst;
+
+ /**
+ * Field Result Stuff.
+ */
+ protected String fieldResult;
+
+ /**
+ * public constructor, set the data that is to be written into the
+ * Field Initialization Stuff and Field Result parts of the
+ * RtfField.
+ *
+ * @param fieldInst data to be written into the Field
+ * Initialization Stuff part of the RtfField.
+ * @param fieldResult data to be written into the Field Result
+ * part of the RtfField.
+ */
+ public GenericRtfField(final String fieldInst, final String fieldResult) {
+ super("x", new Font());
+ this.fieldInst = fieldInst;
+ this.fieldResult = fieldResult;
+ }
+
+ /**
+ * public constructor, set the data that is to be written into the
+ * Field Initialization Stuff and Field Result parts of the
+ * RtfField.
+ *
+ * @param fieldInst data to be written into the Field
+ * Initialization Stuff part of the RtfField.
+ * @param fieldResult data to be written into the Field Result
+ * part of the RtfField.
+ * @param font
+ */
+ public GenericRtfField(final String fieldInst, final String fieldResult, Font font) {
+ super("x", font);
+ this.fieldInst = fieldInst;
+ this.fieldResult = fieldResult;
+ }
+
+ /**
+ * method for writing custom stuff to the Field Initialization
+ * Stuff part of an RtfField.
+ * @param out
+ * @throws IOException
+ */
+ public void writeRtfFieldInitializationStuff(OutputStream out) throws IOException {
+ out.write(fieldInst.trim().getBytes());
+ out.write(RtfWriter.delimiter);
+ }
+
+ /**
+ * method for writing custom stuff to the Field Result part of an
+ * RtfField.
+ * @param out
+ * @throws IOException
+ */
+ public void writeRtfFieldResultStuff(OutputStream out) throws IOException {
+ if (null != fieldResult) {
+ out.write(fieldResult.trim().getBytes());
+ }
+ }
+}
diff --git a/src/main/java/com/lowagie/text/rtf/RtfAddableElement.java b/src/main/java/com/lowagie/text/rtf/RtfAddableElement.java new file mode 100644 index 0000000..539b647 --- /dev/null +++ b/src/main/java/com/lowagie/text/rtf/RtfAddableElement.java @@ -0,0 +1,127 @@ +/*
+ * $Id: RtfAddableElement.java,v 1.1 2006/06/17 10:02:31 hallm Exp $
+ * $Name: $
+ *
+ * Copyright 2001, 2002, 2003, 2004 by Mark Hall
+ *
+ * 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.
+ * Co-Developer of the code is Mark Hall. Portions created by the Co-Developer are
+ * Copyright (C) 2006 by Mark Hall. 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.rtf;
+
+import com.lowagie.text.Chunk;
+import com.lowagie.text.Font;
+import com.lowagie.text.rtf.document.RtfDocument;
+
+/**
+ * The RtfAddableElement is the superclass for all rtf specific elements
+ * that need to be added to an iText document. It is an extension of Chunk
+ * and it also implements RtfBasicElement. It is an abstract class thus it
+ * cannot be instantiated itself and has to be subclassed to be used.
+ *
+ * @version $Revision: 1.1 $
+ * @author Mark Hall (mhall@edu.uni-klu.ac.at)
+ */
+public abstract class RtfAddableElement extends Chunk implements RtfBasicElement {
+
+ /**
+ * The RtfDocument this RtfAddableElement belongs to.
+ */
+ protected RtfDocument doc = null;
+ /**
+ * Whether this RtfAddableElement is contained in a table.
+ */
+ protected boolean inTable = false;
+ /**
+ * Whether this RtfAddableElement is contained in a header.
+ */
+ protected boolean inHeader = false;
+
+ /**
+ * Constructs a new RtfAddableElement. The Chunk content is
+ * set to an empty string and the font to the default Font().
+ */
+ public RtfAddableElement() {
+ super("", new Font());
+ }
+
+ /**
+ * Subclasses have to implement this method.
+ */
+ public abstract byte[] write();
+
+ /**
+ * Sets the RtfDocument this RtfAddableElement belongs to
+ */
+ public void setRtfDocument(RtfDocument doc) {
+ this.doc = doc;
+ }
+
+ /**
+ * Sets whether this RtfAddableElement is contained in a table.
+ */
+ public void setInTable(boolean inTable) {
+ this.inTable = inTable;
+ }
+
+ /**
+ * Sets whether this RtfAddableElement is contained in a header/footer.
+ */
+ public void setInHeader(boolean inHeader) {
+ this.inHeader = inHeader;
+ }
+
+ /**
+ * Transforms an integer into its String representation and then returns the bytes
+ * of that string.
+ *
+ * @param i The integer to convert
+ * @return A byte array representing the integer
+ */
+ public byte[] intToByteArray(int i) {
+ return Integer.toString(i).getBytes();
+ }
+}
diff --git a/src/main/java/com/lowagie/text/rtf/RtfBasicElement.java b/src/main/java/com/lowagie/text/rtf/RtfBasicElement.java new file mode 100644 index 0000000..8b315ec --- /dev/null +++ b/src/main/java/com/lowagie/text/rtf/RtfBasicElement.java @@ -0,0 +1,110 @@ +/*
+ * $Id: RtfBasicElement.java,v 1.16 2005/05/04 14:33:37 blowagie Exp $
+ * $Name: $
+ *
+ * Copyright 2001, 2002, 2003, 2004 by Mark Hall
+ *
+ * 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.rtf;
+
+import com.lowagie.text.rtf.document.RtfDocument;
+
+/**
+ * The RtfBasicElement interface defines the interface for elements that can
+ * be added to the RtfWriter.
+ *
+ * Version: $Id: RtfBasicElement.java,v 1.16 2005/05/04 14:33:37 blowagie Exp $
+ * @author Mark Hall (mhall@edu.uni-klu.ac.at)
+ */
+public interface RtfBasicElement {
+ /**
+ * Constant for the beginning of a rtf group
+ */
+ public static final byte[] OPEN_GROUP = "{".getBytes();
+ /**
+ * Constant for the end of an rtf group
+ */
+ public static final byte[] CLOSE_GROUP = "}".getBytes();
+ /**
+ * Constant for a delimiter in rtf
+ */
+ public static final byte[] DELIMITER = " ".getBytes();
+ /**
+ * Constant for a comma delimiter in rtf
+ */
+ public static final byte[] COMMA_DELIMITER = ";".getBytes();
+ /**
+ * The factor to use for translating from iText to rtf measurments
+ */
+ public static final double TWIPS_FACTOR = 20;
+
+ /**
+ * Return the content of the Element in a byte array
+ * @return The byte array containing the data
+ */
+ public byte[] write();
+
+ /**
+ * Sets the RtfDocument this RtfElement belongs to
+ *
+ * @param doc The RtfDocument to use
+ */
+ public void setRtfDocument(RtfDocument doc);
+
+ /**
+ * Sets whether this RtfBasicElement is in a table
+ *
+ * @param inTable Whether this RtfBasicElement is in a table
+ */
+ public void setInTable(boolean inTable);
+
+ /**
+ * Sets whether this RtfBasicElement is in a header
+ *
+ * @param inHeader Whether this RtfBasicElement is in a header
+ */
+ public void setInHeader(boolean inHeader);
+}
diff --git a/src/main/java/com/lowagie/text/rtf/RtfCell.java b/src/main/java/com/lowagie/text/rtf/RtfCell.java new file mode 100644 index 0000000..841c25b --- /dev/null +++ b/src/main/java/com/lowagie/text/rtf/RtfCell.java @@ -0,0 +1,549 @@ +/**
+ * $Id: RtfCell.java,v 1.37 2006/02/09 17:25:26 hallm Exp $
+ * $Name: $
+ *
+ * Copyright 2001, 2002 by Mark Hall
+ *
+ * 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.rtf;
+
+import com.lowagie.text.*;
+
+import java.util.Iterator;
+import java.io.*;
+import java.awt.Color;
+
+/**
+ * A Helper Class for the <CODE>RtfWriter</CODE>.
+ * <P>
+ * Do not use it directly
+ *
+ * ONLY FOR USE WITH THE RtfWriter NOT with the RtfWriter2.
+ *
+ * Parts of this Class were contributed by Steffen Stundzig. Many thanks for the
+ * improvements.
+ * Updates by Benoit WIART <b.wiart@proxiad.com>
+ * @deprecated Please move to the RtfWriter2 and associated classes.
+ */
+public class RtfCell {
+ /** Constants for merging Cells */
+
+ /** A possible value for merging */
+ private static final int MERGE_HORIZ_FIRST = 1;
+ /** A possible value for merging */
+ private static final int MERGE_VERT_FIRST = 2;
+ /** A possible value for merging */
+ private static final int MERGE_BOTH_FIRST = 3;
+ /** A possible value for merging */
+ private static final int MERGE_HORIZ_PREV = 4;
+ /** A possible value for merging */
+ private static final int MERGE_VERT_PREV = 5;
+ /** A possible value for merging */
+ private static final int MERGE_BOTH_PREV = 6;
+
+ /**
+ * RTF Tags
+ */
+
+ /** First cell to merge with - Horizontal */
+ private static final byte[] cellMergeFirst = "clmgf".getBytes();
+ /** First cell to merge with - Vertical */
+ private static final byte[] cellVMergeFirst = "clvmgf".getBytes();
+ /** Merge cell with previous horizontal cell */
+ private static final byte[] cellMergePrev = "clmrg".getBytes();
+ /** Merge cell with previous vertical cell */
+ private static final byte[] cellVMergePrev = "clvmrg".getBytes();
+ /** Cell content vertical alignment bottom */
+ private static final byte[] cellVerticalAlignBottom = "clvertalb".getBytes();
+ /** Cell content vertical alignment center */
+ private static final byte[] cellVerticalAlignCenter = "clvertalc".getBytes();
+ /** Cell content vertical alignment top */
+ private static final byte[] cellVerticalAlignTop = "clvertalt".getBytes();
+ /** Cell border left */
+ private static final byte[] cellBorderLeft = "clbrdrl".getBytes();
+ /** Cell border right */
+ private static final byte[] cellBorderRight = "clbrdrr".getBytes();
+ /** Cell border top */
+ private static final byte[] cellBorderTop = "clbrdrt".getBytes();
+ /** Cell border bottom */
+ private static final byte[] cellBorderBottom = "clbrdrb".getBytes();
+ /** Cell background color */
+ private static final byte[] cellBackgroundColor = "clcbpat".getBytes();
+ /** Cell width format */
+ private static final byte[] cellWidthStyle = "clftsWidth3".getBytes();
+ /** Cell width */
+ private static final byte[] cellWidthTag = "clwWidth".getBytes();
+ /** Cell right border position */
+ private static final byte[] cellRightBorder = "cellx".getBytes();
+ /** Cell is part of table */
+ protected static final byte[] cellInTable = "intbl".getBytes();
+ /** End of cell */
+ private static final byte[] cellEnd = "cell".getBytes();
+
+ /** padding top */
+ private static final byte[] cellPaddingTop = "clpadt".getBytes();
+ /** padding top unit */
+ private static final byte[] cellPaddingTopUnit = "clpadft3".getBytes();
+ /** padding bottom */
+ private static final byte[] cellPaddingBottom = "clpadb".getBytes();
+ /** padding bottom unit */
+ private static final byte[] cellPaddingBottomUnit = "clpadfb3".getBytes();
+ /** padding left */
+ private static final byte[] cellPaddingLeft = "clpadl".getBytes();
+ /** padding left unit */
+ private static final byte[] cellPaddingLeftUnit = "clpadfl3".getBytes();
+ /** padding right */
+ private static final byte[] cellPaddingRight = "clpadr".getBytes();
+ /** padding right unit */
+ private static final byte[] cellPaddingRightUnit = "clpadfr3".getBytes();
+
+ /** The <code>RtfWriter</code> to which this <code>RtfCell</code> belongs. */
+ private RtfWriter writer = null;
+ /** The <code>RtfTable</code> to which this <code>RtfCell</code> belongs. */
+ private RtfTable mainTable = null;
+
+ /** Cell width */
+ private int cellWidth = 0;
+ /** Cell right border position */
+ private int cellRight = 0;
+ /** <code>Cell</code> containing the actual data */
+ private Cell store = null;
+ /** Is this an empty cell */
+ private boolean emptyCell = true;
+ /** Type of merging to do */
+ private int mergeType = 0;
+ /** cell padding, because the table only renders the left and right cell padding
+ * and not the top and bottom one
+ */
+ private int cellpadding = 0;
+
+ /**
+ * Create a new <code>RtfCell</code>.
+ *
+ * @param writer The <code>RtfWriter</code> that this <code>RtfCell</code> belongs to
+ * @param mainTable The <code>RtfTable</code> that created the
+ * <code>RtfRow</code> that created the <code>RtfCell</code> :-)
+ */
+ public RtfCell(RtfWriter writer, RtfTable mainTable) {
+ super();
+ this.writer = writer;
+ this.mainTable = mainTable;
+ }
+
+ /**
+ * Import a <code>Cell</code>.
+ * <P>
+ * @param cell The <code>Cell</code> containing the data for this
+ * <code>RtfCell</code>
+ * @param cellLeft The position of the left border
+ * @param cellWidth The default width of a cell
+ * @param x The column index of this <code>RtfCell</code>
+ * @param y The row index of this <code>RtfCell</code>
+ * @param cellpadding the cellpadding
+ * @return the position of the right side of the cell
+ */
+ public int importCell(Cell cell, int cellLeft, int cellWidth, int x, int y, int cellpadding) {
+ this.cellpadding = cellpadding;
+
+ // set this value in any case
+ this.cellWidth = cellWidth;
+ if (cell == null) {
+ cellRight = cellLeft + cellWidth;
+ return cellRight;
+ }
+ if (cell.cellWidth() != null && !cell.cellWidth().equals("")) {
+
+ this.cellWidth = (int) (Integer.parseInt(cell.cellWidth()) * RtfWriter.TWIPSFACTOR);
+ }
+ cellRight = cellLeft + this.cellWidth;
+ store = cell;
+ emptyCell = false;
+ if (cell.colspan() > 1) {
+ if (cell.rowspan() > 1) {
+ mergeType = MERGE_BOTH_FIRST;
+ for (int i = y; i < y + cell.rowspan(); i++) {
+ if (i > y) mainTable.setMerge(x, i, MERGE_VERT_PREV, this);
+ for (int j = x + 1; j < x + cell.colspan(); j++) {
+ mainTable.setMerge(j, i, MERGE_BOTH_PREV, this);
+ }
+ }
+ } else {
+ mergeType = MERGE_HORIZ_FIRST;
+ for (int i = x + 1; i < x + cell.colspan(); i++) {
+ mainTable.setMerge(i, y, MERGE_HORIZ_PREV, this);
+ }
+ }
+ } else if (cell.rowspan() > 1) {
+ mergeType = MERGE_VERT_FIRST;
+ for (int i = y + 1; i < y + cell.rowspan(); i++) {
+ mainTable.setMerge(x, i, MERGE_VERT_PREV, this);
+ }
+ }
+ return cellRight;
+ }
+
+ /**
+ * Write the properties of the <code>RtfCell</code>.
+ *
+ * @param os The <code>OutputStream</code> to which to write the properties
+ * of the <code>RtfCell</code> to.
+ * @return true if writing the cell settings succeeded
+ * @throws DocumentException
+ */
+ public boolean writeCellSettings(ByteArrayOutputStream os) throws DocumentException {
+ try {
+ float lWidth, tWidth, rWidth, bWidth;
+ byte[] lStyle, tStyle, rStyle, bStyle;
+
+ if (store instanceof RtfTableCell) {
+ RtfTableCell c = (RtfTableCell) store;
+ lWidth = c.leftBorderWidth();
+ tWidth = c.topBorderWidth();
+ rWidth = c.rightBorderWidth();
+ bWidth = c.bottomBorderWidth();
+ lStyle = RtfTableCell.getStyleControlWord(c.leftBorderStyle());
+ tStyle = RtfTableCell.getStyleControlWord(c.topBorderStyle());
+ rStyle = RtfTableCell.getStyleControlWord(c.rightBorderStyle());
+ bStyle = RtfTableCell.getStyleControlWord(c.bottomBorderStyle());
+ } else {
+ lWidth = tWidth = rWidth = bWidth = store.borderWidth();
+ lStyle = tStyle = rStyle = bStyle = RtfRow.tableBorder;
+ }
+
+ if (mergeType == MERGE_HORIZ_PREV || mergeType == MERGE_BOTH_PREV) {
+ return true;
+ }
+ switch (mergeType) {
+ case MERGE_VERT_FIRST:
+ os.write(RtfWriter.escape);
+ os.write(cellVMergeFirst);
+ break;
+ case MERGE_BOTH_FIRST:
+ os.write(RtfWriter.escape);
+ os.write(cellVMergeFirst);
+ break;
+ case MERGE_HORIZ_PREV:
+ os.write(RtfWriter.escape);
+ os.write(cellMergePrev);
+ break;
+ case MERGE_VERT_PREV:
+ os.write(RtfWriter.escape);
+ os.write(cellVMergePrev);
+ break;
+ case MERGE_BOTH_PREV:
+ os.write(RtfWriter.escape);
+ os.write(cellMergeFirst);
+ break;
+ }
+ switch (store.verticalAlignment()) {
+ case Element.ALIGN_BOTTOM:
+ os.write(RtfWriter.escape);
+ os.write(cellVerticalAlignBottom);
+ break;
+ case Element.ALIGN_CENTER:
+ case Element.ALIGN_MIDDLE:
+ os.write(RtfWriter.escape);
+ os.write(cellVerticalAlignCenter);
+ break;
+ case Element.ALIGN_TOP:
+ os.write(RtfWriter.escape);
+ os.write(cellVerticalAlignTop);
+ break;
+ }
+
+ if (((store.border() & Rectangle.LEFT) == Rectangle.LEFT) &&
+ (lWidth > 0)) {
+ os.write(RtfWriter.escape);
+ os.write(cellBorderLeft);
+ os.write(RtfWriter.escape);
+ os.write(lStyle);
+ os.write(RtfWriter.escape);
+ os.write(RtfRow.tableBorderWidth);
+ writeInt(os, (int) (lWidth * RtfWriter.TWIPSFACTOR));
+ os.write(RtfWriter.escape);
+ os.write(RtfRow.tableBorderColor);
+ if (store.borderColor() == null)
+ writeInt(os, writer.addColor(new
+ Color(0, 0, 0)));
+ else
+ writeInt(os, writer.addColor(store.borderColor()));
+ os.write((byte) '\n');
+ }
+ if (((store.border() & Rectangle.TOP) == Rectangle.TOP) && (tWidth > 0)) {
+ os.write(RtfWriter.escape);
+ os.write(cellBorderTop);
+ os.write(RtfWriter.escape);
+ os.write(tStyle);
+ os.write(RtfWriter.escape);
+ os.write(RtfRow.tableBorderWidth);
+ writeInt(os, (int) (tWidth * RtfWriter.TWIPSFACTOR));
+ os.write(RtfWriter.escape);
+ os.write(RtfRow.tableBorderColor);
+ if (store.borderColor() == null)
+ writeInt(os, writer.addColor(new
+ Color(0, 0, 0)));
+ else
+ writeInt(os, writer.addColor(store.borderColor()));
+ os.write((byte) '\n');
+ }
+ if (((store.border() & Rectangle.BOTTOM) == Rectangle.BOTTOM) &&
+ (bWidth > 0)) {
+ os.write(RtfWriter.escape);
+ os.write(cellBorderBottom);
+ os.write(RtfWriter.escape);
+ os.write(bStyle);
+ os.write(RtfWriter.escape);
+ os.write(RtfRow.tableBorderWidth);
+ writeInt(os, (int) (bWidth * RtfWriter.TWIPSFACTOR));
+ os.write(RtfWriter.escape);
+ os.write(RtfRow.tableBorderColor);
+ if (store.borderColor() == null)
+ writeInt(os, writer.addColor(new
+ Color(0, 0, 0)));
+ else
+ writeInt(os, writer.addColor(store.borderColor()));
+ os.write((byte) '\n');
+ }
+ if (((store.border() & Rectangle.RIGHT) == Rectangle.RIGHT) &&
+ (rWidth > 0)) {
+ os.write(RtfWriter.escape);
+ os.write(cellBorderRight);
+ os.write(RtfWriter.escape);
+ os.write(rStyle);
+ os.write(RtfWriter.escape);
+ os.write(RtfRow.tableBorderWidth);
+ writeInt(os, (int) (rWidth * RtfWriter.TWIPSFACTOR));
+ os.write(RtfWriter.escape);
+ os.write(RtfRow.tableBorderColor);
+ if (store.borderColor() == null)
+ writeInt(os, writer.addColor(new
+ Color(0, 0, 0)));
+ else
+ writeInt(os, writer.addColor(store.borderColor()));
+ os.write((byte) '\n');
+ }
+ os.write(RtfWriter.escape);
+ os.write(cellBackgroundColor);
+ if (store.backgroundColor() == null) {
+ writeInt(os, writer.addColor(new Color(255, 255, 255)));
+ } else {
+ writeInt(os, writer.addColor(store.backgroundColor()));
+ }
+ os.write((byte) '\n');
+ os.write(RtfWriter.escape);
+ os.write(cellWidthStyle);
+ os.write((byte) '\n');
+ os.write(RtfWriter.escape);
+ os.write(cellWidthTag);
+ writeInt(os, cellWidth);
+ os.write((byte) '\n');
+ if (cellpadding > 0) {
+ // values
+ os.write(RtfWriter.escape);
+ os.write(cellPaddingLeft);
+ writeInt(os, cellpadding / 2);
+ os.write(RtfWriter.escape);
+ os.write(cellPaddingTop);
+ writeInt(os, cellpadding / 2);
+ os.write(RtfWriter.escape);
+ os.write(cellPaddingRight);
+ writeInt(os, cellpadding / 2);
+ os.write(RtfWriter.escape);
+ os.write(cellPaddingBottom);
+ writeInt(os, cellpadding / 2);
+ // unit
+ os.write(RtfWriter.escape);
+ os.write(cellPaddingLeftUnit);
+ os.write(RtfWriter.escape);
+ os.write(cellPaddingTopUnit);
+ os.write(RtfWriter.escape);
+ os.write(cellPaddingRightUnit);
+ os.write(RtfWriter.escape);
+ os.write(cellPaddingBottomUnit);
+ }
+ os.write(RtfWriter.escape);
+ os.write(cellRightBorder);
+ writeInt(os, cellRight);
+ } catch (IOException e) {
+ return false;
+ }
+ return true;
+ }
+
+ /**
+ * Write the content of the <code>RtfCell</code>.
+ *
+ * @param os The <code>OutputStream</code> to which to write the content of
+ * the <code>RtfCell</code> to.
+ * @return true if writing the cell content succeeded
+ * @throws DocumentException
+ */
+ public boolean writeCellContent(ByteArrayOutputStream os) throws DocumentException {
+ try {
+ if (mergeType == MERGE_HORIZ_PREV || mergeType == MERGE_BOTH_PREV) {
+ return true;
+ }
+
+ if (!emptyCell) {
+ Iterator cellIterator = store.getElements();
+ Paragraph container = null;
+ while (cellIterator.hasNext()) {
+ Element element = (Element) cellIterator.next();
+ // should we wrap it in a paragraph
+ if(!(element instanceof Paragraph)) {
+ if(container != null) {
+ container.add(element);
+ } else {
+ container = new Paragraph();
+ container.setAlignment(store.horizontalAlignment());
+ container.add(element);
+ }
+ } else {
+ if(container != null) {
+ writer.addElement(container, os);
+ container =null;
+ container =null;
+ }
+
+
+ // if horizontal alignment is undefined overwrite
+ // with that of enclosing cell
+ if (element instanceof Paragraph && ((Paragraph) element).alignment() == Element.ALIGN_UNDEFINED) {
+ ((Paragraph) element).setAlignment(store.horizontalAlignment());
+ }
+ writer.addElement(element, os);
+ if (element.type() == Element.PARAGRAPH && cellIterator.hasNext()) {
+ os.write(RtfWriter.escape);
+ os.write(RtfWriter.paragraph);
+ }
+ }
+ }
+ if(container != null) {
+ writer.addElement(container, os);
+ container =null;
+ }
+ } else {
+ os.write(RtfWriter.escape);
+ os.write(RtfWriter.paragraphDefaults);
+ os.write(RtfWriter.escape);
+ os.write(cellInTable);
+ }
+ os.write(RtfWriter.escape);
+ os.write(cellEnd);
+ } catch (IOException e) {
+ return false;
+ }
+ return true;
+ }
+
+ /**
+ * Sets the merge type and the <code>RtfCell</code> with which this
+ * <code>RtfCell</code> is to be merged.
+ *
+ * @param mergeType The merge type specifies the kind of merge to be applied
+ * (MERGE_HORIZ_PREV, MERGE_VERT_PREV, MERGE_BOTH_PREV)
+ * @param mergeCell The <code>RtfCell</code> that the cell at x and y is to
+ * be merged with
+ */
+ public void setMerge(int mergeType, RtfCell mergeCell) {
+ this.mergeType = mergeType;
+ store = mergeCell.getStore();
+ }
+
+ /**
+ * Get the <code>Cell</code> with the actual content.
+ *
+ * @return <code>Cell</code> which is contained in the <code>RtfCell</code>
+ */
+ public Cell getStore() {
+ return store;
+ }
+
+ /**
+ * Get the with of this <code>RtfCell</code>
+ *
+ * @return Width of the current <code>RtfCell</code>
+ */
+ public int getCellWidth() {
+ return cellWidth;
+ }
+
+ /**
+ * sets the width of the cell
+ * @param value a width
+ */
+ public void setCellWidth(int value) {
+ cellWidth = value;
+ }
+
+ /**
+ * Get the position of the right border of this <code>RtfCell</code>.
+ * @return position of the right border
+ */
+ public int getCellRight() {
+ return cellRight;
+ }
+
+
+ /**
+ * Sets the right position of the cell
+ * @param value a cell position
+ */
+ public void setCellRight(int value) {
+ cellRight = value;
+ }
+
+ /**
+ * Write an Integer to the Outputstream.
+ *
+ * @param out The <code>OutputStream</code> to be written to.
+ * @param i The int to be written.
+ * @throws IOException
+ */
+ private void writeInt(ByteArrayOutputStream out, int i) throws IOException {
+ out.write(Integer.toString(i).getBytes());
+ }
+}
diff --git a/src/main/java/com/lowagie/text/rtf/RtfElement.java b/src/main/java/com/lowagie/text/rtf/RtfElement.java new file mode 100644 index 0000000..03d05c0 --- /dev/null +++ b/src/main/java/com/lowagie/text/rtf/RtfElement.java @@ -0,0 +1,149 @@ +/*
+ * $Id: RtfElement.java,v 1.8 2004/12/14 15:14:44 blowagie Exp $
+ * $Name: $
+ *
+ * Copyright 2001, 2002, 2003, 2004 by Mark Hall
+ *
+ * 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.rtf;
+
+import com.lowagie.text.rtf.document.RtfDocument;
+
+/**
+ * RtfElement is the base class for all RTF Element classes
+ *
+ * Version: $Id: RtfElement.java,v 1.8 2004/12/14 15:14:44 blowagie Exp $
+ * @author Mark Hall (mhall@edu.uni-klu.ac.at)
+ */
+public class RtfElement implements RtfBasicElement {
+ /**
+ * Constant for a rtf escape
+ */
+ //public static final byte[] ESCAPE = "\\".getBytes();
+ /**
+ * Constant for a rtf extended escape
+ */
+ //public static final byte[] EXTENDED_ESCAPE = "\\*\\".getBytes();
+
+ /**
+ * The RtfDocument this RtfElement belongs to
+ */
+ protected RtfDocument document = null;
+ /**
+ * Whether this RtfElement is in a table
+ */
+ protected boolean inTable = false;
+ /**
+ * Whether this RtfElement is in a header
+ */
+ protected boolean inHeader = false;
+
+ /**
+ * Constructs a RtfElement belonging to the specified RtfDocument.
+ *
+ * @param doc The RtfDocument this RtfElement belongs to
+ */
+ public RtfElement(RtfDocument doc) {
+ super();
+ this.document = doc;
+ }
+
+ /**
+ * Transforms an integer into its String representation and then returns the bytes
+ * of that string.
+ *
+ * @param i The integer to convert
+ * @return A byte array representing the integer
+ */
+ public byte[] intToByteArray(int i) {
+ return Integer.toString(i).getBytes();
+ }
+
+ /**
+ * Returns the content of the RtfElement in a byte array.
+ *
+ * @return An empty byte array
+ */
+ public byte[] write() {
+ return new byte[0];
+ }
+
+ /**
+ * Sets the RtfDocument this RtfElement belongs to
+ *
+ * @param doc The RtfDocument to use
+ */
+ public void setRtfDocument(RtfDocument doc) {
+ this.document = doc;
+ }
+
+ /**
+ * Gets whether this RtfElement is in a table
+ *
+ * @return Whether this RtfElement is in a table
+ */
+ public boolean isInTable() {
+ return inTable;
+ }
+
+ /**
+ * Sets whether this RtfElement is in a table
+ *
+ * @param inTable <code>True</code> if this RtfElement is in a table, <code>false</code> otherwise
+ */
+ public void setInTable(boolean inTable) {
+ this.inTable = inTable;
+ }
+
+ /**
+ * Sets whether this RtfElement is in a header
+ *
+ * @param inHeader <code>True</code> if this RtfElement is in a header, <code>false</code> otherwise
+ */
+ public void setInHeader(boolean inHeader) {
+ this.inHeader = inHeader;
+ }
+}
diff --git a/src/main/java/com/lowagie/text/rtf/RtfExtendedElement.java b/src/main/java/com/lowagie/text/rtf/RtfExtendedElement.java new file mode 100644 index 0000000..39a6efa --- /dev/null +++ b/src/main/java/com/lowagie/text/rtf/RtfExtendedElement.java @@ -0,0 +1,65 @@ +/*
+ * $Id: RtfExtendedElement.java,v 1.16 2005/05/04 14:33:37 blowagie Exp $
+ * $Name: $
+ *
+ * Copyright 2001, 2002, 2003, 2004 by Mark Hall
+ *
+ * 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.rtf;
+
+/**
+ * The RtfExtendedElement interface is to be used for elements that also
+ * write data into the definition part of the rtf document
+ * Version: $Id: RtfExtendedElement.java,v 1.16 2005/05/04 14:33:37 blowagie Exp $
+ * @author Mark Hall (mhall@edu.uni-klu.ac.at)
+ */
+public interface RtfExtendedElement extends RtfBasicElement {
+ /**
+ * Return the definition part of the element in a byte array
+ * @return A byte array containing the definition data of the Element
+ */
+ public byte[] writeDefinition();
+}
diff --git a/src/main/java/com/lowagie/text/rtf/RtfField.java b/src/main/java/com/lowagie/text/rtf/RtfField.java new file mode 100644 index 0000000..a98fb31 --- /dev/null +++ b/src/main/java/com/lowagie/text/rtf/RtfField.java @@ -0,0 +1,84 @@ +/**
+ * $Id: RtfField.java,v 1.18 2006/02/09 17:25:25 hallm Exp $
+ *
+ * Copyright 2002 by
+ * <a href="http://www.smb-tec.com">SMB</a>
+ * <a href="mailto:Steffen.Stundzig@smb-tec.com">Steffen.Stundzig@smb-tec.com</a>
+ *
+ * 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.rtf;
+
+import com.lowagie.text.rtf.RtfWriter;
+
+import java.io.OutputStream;
+import java.io.IOException;
+
+
+/**
+ * This interface should mark classes, that can be represented
+ * as RTF fields, such as pagenumber, toc entries and so on.
+ *
+ * ONLY FOR USE WITH THE RtfWriter NOT with the RtfWriter2.
+ *
+ * This class is based on the RtfWriter-package from Mark Hall.
+ * @author <a href="mailto:Steffen.Stundzig@smb-tec.com">Steffen.Stundzig@smb-tec.com</a>
+ * @version $Revision: 1.18 $Date: 2006/02/09 17:25:25 $
+ * @deprecated Please move to the RtfWriter2 and associated classes.
+ */
+public interface RtfField {
+
+
+ /**
+ * Writes an RTF field.
+ * @param writer
+ * @param out
+ * @throws IOException
+ */
+ public void write( RtfWriter writer, OutputStream out ) throws IOException;
+}
+
+
diff --git a/src/main/java/com/lowagie/text/rtf/RtfFont.java b/src/main/java/com/lowagie/text/rtf/RtfFont.java new file mode 100644 index 0000000..3fd4651 --- /dev/null +++ b/src/main/java/com/lowagie/text/rtf/RtfFont.java @@ -0,0 +1,162 @@ +/*
+ * $Id: RtfFont.java,v 1.25 2006/02/09 17:25:26 hallm Exp $
+ * $Name: $
+ *
+ * Copyright 2001, 2002 by Mark Hall
+ *
+ * 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.rtf;
+
+import com.lowagie.text.Font;
+
+import java.awt.*;
+
+/**
+ * The RtfFont class enables you to add arbitrary Fonts to a rtf document by specifying
+ * the font name you want to have. The font has to be installed on the client for this to
+ * work.
+ *
+ * ONLY FOR USE WITH THE RtfWriter NOT with the RtfWriter2.
+ *
+ * @author <a href="mhall@myrealbox.com">mhall@myrealbox.com</a>
+ * @deprecated Please move to the RtfWriter2 and associated classes. com.lowagie.text.rtf.style.RtfFont replaces the functionality of this class.
+ */
+public class RtfFont extends Font {
+ /**
+ * The font family name of this RtfFont
+ */
+ private String familyName = "";
+
+ /**
+ * Constructs a RtfFont
+ *
+ * @param familyName The family name of this RtfFont
+ */
+ public RtfFont(String familyName) {
+ super(Font.UNDEFINED);
+ this.familyName = familyName;
+ }
+
+ /**
+ * Constructs a RtfFont
+ *
+ * @param familyName The font family name of this RtfFont
+ * @param size The font size of this RtfFont
+ */
+ public RtfFont(String familyName, float size) {
+ super(Font.UNDEFINED, size);
+ this.familyName = familyName;
+ }
+
+ /**
+ * Constructs a RtfFont
+ *
+ * @param familyName The font family name of this RtfFont
+ * @param size The font size of this RtfFont
+ * @param style The font style of this RtfFont
+ */
+ public RtfFont(String familyName, float size, int style) {
+ super(Font.UNDEFINED, size, style);
+ this.familyName = familyName;
+ }
+
+ /**
+ * Constructs a RtfFont
+ *
+ * @param familyName The font family name of this RtfFont
+ * @param size The font size of this RtfFont
+ * @param style The font style of this RtfFont
+ * @param color The font color of this RtfFont
+ */
+ public RtfFont(String familyName, float size, int style, Color color) {
+ super(Font.UNDEFINED, size, style, color);
+ this.familyName = familyName;
+ }
+
+ /**
+ * Gets the familyname as a String.
+ *
+ * @return the familyname
+ */
+ public String getFamilyname() {
+ return this.familyName;
+ }
+
+ /**
+ * Replaces the attributes that are equal to <VAR>null</VAR> with
+ * the attributes of a given font.
+ *
+ * @param font the font of a bigger element class
+ * @return a <CODE>Font</CODE>
+ */
+ public Font difference(Font font) {
+ String dFamilyname = font.getFamilyname();
+ if(dFamilyname == null || dFamilyname.trim().equals("")) {
+ dFamilyname = this.familyName;
+ }
+
+ float dSize = font.size();
+ if(dSize == Font.UNDEFINED) {
+ dSize = this.size();
+ }
+
+ int dStyle = Font.UNDEFINED;
+ if(this.style() != Font.UNDEFINED && font.style() != Font.UNDEFINED) {
+ dStyle = this.style() | font.style();
+ } else if(this.style() != Font.UNDEFINED) {
+ dStyle = this.style();
+ } else if(font.style() != Font.UNDEFINED) {
+ dStyle = font.style();
+ }
+
+ Color dColor = font.color();
+ if(dColor == null) {
+ dColor = this.color();
+ }
+
+ return new RtfFont(dFamilyname, dSize, dStyle, dColor);
+ }
+}
diff --git a/src/main/java/com/lowagie/text/rtf/RtfHeaderFooter.java b/src/main/java/com/lowagie/text/rtf/RtfHeaderFooter.java new file mode 100644 index 0000000..d1f59f5 --- /dev/null +++ b/src/main/java/com/lowagie/text/rtf/RtfHeaderFooter.java @@ -0,0 +1,114 @@ +/**
+ * $Id: RtfHeaderFooter.java,v 1.20 2006/02/09 17:25:25 hallm Exp $
+ *
+ * Copyright 2002 by
+ * <a href="http://www.smb-tec.com">SMB</a>
+ * <a href="mailto:Steffen.Stundzig@smb-tec.com">Steffen.Stundzig@smb-tec.com</a>
+ *
+ * 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 right 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.rtf;
+
+import com.lowagie.text.Element;
+import com.lowagie.text.HeaderFooter;
+import com.lowagie.text.Phrase;
+
+
+/**
+ * This HeaderFooter specialization extends the normal HeaderFooter impl.
+ * by the new ctor with 'Element' param.
+ * So we have the ability to add a table or some moe sophisticated stuff
+ * as header or footer content.
+ *
+ * ONLY FOR USE WITH THE RtfWriter NOT with the RtfWriter2.
+ *
+ * This class is based on the RtfWriter-package from Mark Hall.
+ * @author <a href="mailto:Steffen.Stundzig@smb-tec.com">Steffen.Stundzig@smb-tec.com</a>
+ * @author <a href="mailto:mhall@myrealbox.com">Mark.Hall@myrealbox.com</a>
+ * @version $Revision: 1.20 $Date: 2006/02/09 17:25:25 $
+ * @deprecated Please move to the RtfWriter2 and associated classes. com.lowagie.text.rtf.headerfooter.RtfHeaderFooter replaces the functionality of this class.
+ */
+public class RtfHeaderFooter extends HeaderFooter {
+
+
+ private Element content = null;
+
+
+ /**
+ * Constructs a new header
+ * @param before
+ * @param after
+ */
+ public RtfHeaderFooter( Phrase before, Phrase after ) {
+ super( before, after );
+ }
+
+
+ /**
+ * Constructs a new header
+ * @param before
+ * @param numbered
+ */
+ public RtfHeaderFooter( Phrase before, boolean numbered ) {
+ super( before, numbered );
+ }
+
+
+ /**
+ * Constructs a new header
+ * @param content
+ */
+ public RtfHeaderFooter( Element content ) {
+ super(new Phrase(content.toString()), false);
+ this.content = content;
+ }
+
+
+ /**
+ * @return the element specified in the ctor or null;
+ */
+ public Element content() {
+ return content;
+ }
+}
diff --git a/src/main/java/com/lowagie/text/rtf/RtfHeaderFooters.java b/src/main/java/com/lowagie/text/rtf/RtfHeaderFooters.java new file mode 100644 index 0000000..70d0c83 --- /dev/null +++ b/src/main/java/com/lowagie/text/rtf/RtfHeaderFooters.java @@ -0,0 +1,160 @@ +/**
+ * $Id: RtfHeaderFooters.java,v 1.21 2006/02/09 17:25:25 hallm Exp $
+ *
+ * Copyright 2002 by
+ * <a href="http://www.smb-tec.com">SMB</a>
+ * <a href="mailto:Steffen.Stundzig@smb-tec.com">Steffen.Stundzig@smb-tec.com</a>
+ *
+ * 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 right 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.rtf;
+
+import com.lowagie.text.HeaderFooter;
+import com.lowagie.text.Phrase;
+
+
+/**
+ * This HeaderFooter specialization contains some headers or footers for several
+ * pages. Is a list of headerFooters but also a sub class of header footer, to change
+ * as less as possible of the current API.
+ *
+ * ONLY FOR USE WITH THE RtfWriter NOT with the RtfWriter2.
+ *
+ * This class is based on the RtfWriter-package from Mark Hall.
+ * @author <a href="mailto:Steffen.Stundzig@smb-tec.com">Steffen.Stundzig@smb-tec.com</a>
+ * @author <a href="mailto:mhall@myrealbox.com">Mark.Hall@myrealbox.com</a>
+ * @version $Revision: 1.21 $Date: 2006/02/09 17:25:25 $
+ * @deprecated Please move to the RtfWriter2 and associated classes. com.lowagie.text.rtf.headerfooter.RtfHeaderFooterGroup replaces the functionality of this class.
+ */
+public class RtfHeaderFooters extends HeaderFooter {
+ /** an attribute value */
+ public final static int ALL_PAGES = 0;
+ /** an attribute value */
+ public final static int LEFT_PAGES = 1;
+ /** an attribute value */
+ public final static int RIGHT_PAGES = 2;
+ /** an attribute value */
+ public final static int FIRST_PAGE = 3;
+
+// public int defaultHeader = ALL_PAGES;
+
+ /** header or footer placeholder */
+ private HeaderFooter allPages = null;
+ /** header or footer placeholder */
+ private HeaderFooter leftPages = null;
+ /** header or footer placeholder */
+ private HeaderFooter rightPages = null;
+ /** header or footer placeholder */
+ private HeaderFooter firstPage = null;
+
+ /**
+ * Contructs a HeaderFooters object
+ */
+ public RtfHeaderFooters() {
+ super( new Phrase(""), false );
+ }
+
+ /**
+ * Contructs a HeaderFooters object
+ * @param before
+ * @param after
+ */
+ public RtfHeaderFooters( Phrase before, Phrase after ) {
+ super( before, after );
+ }
+
+ /**
+ * Contructs a HeaderFooters object
+ * @param before
+ * @param numbered
+ */
+ public RtfHeaderFooters( Phrase before, boolean numbered ) {
+ super( before, numbered );
+ }
+
+ /**
+ * Adds a HeaderFooter to this HeaderFooters object
+ * @param type
+ * @param hf
+ */
+ public void set( int type, HeaderFooter hf ) {
+ switch (type) {
+ case ALL_PAGES:
+ allPages = hf;
+ break;
+ case LEFT_PAGES:
+ leftPages = hf;
+ break;
+ case RIGHT_PAGES:
+ rightPages = hf;
+ break;
+ case FIRST_PAGE:
+ firstPage = hf;
+ break;
+ default:
+ throw new IllegalStateException( "unknown type " + type );
+ }
+ }
+
+ /**
+ * Returns a type of HeaderFooter object registered in this HeaderFooters object.
+ * @param type type of the HeaderFooter object
+ * @return a HeaderFooter object
+ */
+ public HeaderFooter get( int type ) {
+ switch (type) {
+ case ALL_PAGES:
+ return allPages;
+ case LEFT_PAGES:
+ return leftPages;
+ case RIGHT_PAGES:
+ return rightPages;
+ case FIRST_PAGE:
+ return firstPage;
+ default:
+ throw new IllegalStateException( "unknown type " + type );
+ }
+ }
+}
diff --git a/src/main/java/com/lowagie/text/rtf/RtfMapper.java b/src/main/java/com/lowagie/text/rtf/RtfMapper.java new file mode 100644 index 0000000..1464c81 --- /dev/null +++ b/src/main/java/com/lowagie/text/rtf/RtfMapper.java @@ -0,0 +1,182 @@ +/*
+ * $Id: RtfMapper.java,v 1.10 2005/05/04 14:41:15 blowagie Exp $
+ * $Name: $
+ *
+ * Copyright 2003, 2004 by Mark Hall
+ *
+ * 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.rtf;
+
+import com.lowagie.text.Anchor;
+import com.lowagie.text.Annotation;
+import com.lowagie.text.Chapter;
+import com.lowagie.text.Chunk;
+import com.lowagie.text.DocumentException;
+import com.lowagie.text.Element;
+import com.lowagie.text.Image;
+import com.lowagie.text.List;
+import com.lowagie.text.ListItem;
+import com.lowagie.text.Meta;
+import com.lowagie.text.Paragraph;
+import com.lowagie.text.Phrase;
+import com.lowagie.text.Section;
+import com.lowagie.text.SimpleTable;
+import com.lowagie.text.Table;
+import com.lowagie.text.rtf.document.RtfDocument;
+import com.lowagie.text.rtf.document.RtfInfoElement;
+import com.lowagie.text.rtf.field.RtfAnchor;
+import com.lowagie.text.rtf.graphic.RtfImage;
+import com.lowagie.text.rtf.list.RtfList;
+import com.lowagie.text.rtf.list.RtfListItem;
+import com.lowagie.text.rtf.table.RtfTable;
+import com.lowagie.text.rtf.text.RtfAnnotation;
+import com.lowagie.text.rtf.text.RtfChapter;
+import com.lowagie.text.rtf.text.RtfChunk;
+import com.lowagie.text.rtf.text.RtfNewPage;
+import com.lowagie.text.rtf.text.RtfParagraph;
+import com.lowagie.text.rtf.text.RtfPhrase;
+import com.lowagie.text.rtf.text.RtfSection;
+
+
+/**
+ * The RtfMapper provides mappings between com.lowagie.text.* classes
+ * and the corresponding com.lowagie.text.rtf.** classes.
+ *
+ * @version $Version:$
+ * @author Mark Hall (mhall@edu.uni-klu.ac.at)
+ */
+public class RtfMapper {
+
+ /**
+ * The RtfDocument this RtfMapper belongs to
+ */
+ RtfDocument rtfDoc;
+
+ /**
+ * Constructs a RtfMapper for a RtfDocument
+ *
+ * @param doc The RtfDocument this RtfMapper belongs to
+ */
+ public RtfMapper(RtfDocument doc) {
+ this.rtfDoc = doc;
+ }
+
+ /**
+ * Takes an Element subclass and returns the correct RtfBasicElement
+ * subclass, that wraps the Element subclass.
+ *
+ * @param element The Element to wrap
+ * @return A RtfBasicElement wrapping the Element
+ * @throws DocumentException
+ */
+ public RtfBasicElement mapElement(Element element) throws DocumentException {
+ RtfBasicElement rtfElement = null;
+
+ if(element instanceof RtfBasicElement) {
+ rtfElement = (RtfBasicElement) element;
+ rtfElement.setRtfDocument(this.rtfDoc);
+ return rtfElement;
+ }
+ switch(element.type()) {
+ case Element.CHUNK:
+ if(((Chunk) element).getImage() != null) {
+ rtfElement = new RtfImage(rtfDoc, ((Chunk) element).getImage());
+ } else if(((Chunk) element).hasAttributes() && ((Chunk) element).getAttributes().containsKey(Chunk.NEWPAGE)) {
+ rtfElement = new RtfNewPage(rtfDoc);
+ } else {
+ rtfElement = new RtfChunk(rtfDoc, (Chunk) element);
+ }
+ break;
+ case Element.PHRASE:
+ rtfElement = new RtfPhrase(rtfDoc, (Phrase) element);
+ break;
+ case Element.PARAGRAPH:
+ rtfElement = new RtfParagraph(rtfDoc, (Paragraph) element);
+ break;
+ case Element.ANCHOR:
+ rtfElement = new RtfAnchor(rtfDoc, (Anchor) element);
+ break;
+ case Element.ANNOTATION:
+ rtfElement = new RtfAnnotation(rtfDoc, (Annotation) element);
+ break;
+ case Element.IMGRAW:
+ case Element.IMGTEMPLATE:
+ case Element.JPEG:
+ rtfElement = new RtfImage(rtfDoc, (Image) element);
+ break;
+ case Element.AUTHOR:
+ case Element.SUBJECT:
+ case Element.KEYWORDS:
+ case Element.TITLE:
+ case Element.PRODUCER:
+ case Element.CREATIONDATE:
+ rtfElement = new RtfInfoElement(rtfDoc, (Meta) element);
+ break;
+ case Element.LIST:
+ rtfElement = new RtfList(rtfDoc, (List) element);
+ break;
+ case Element.LISTITEM:
+ rtfElement = new RtfListItem(rtfDoc, (ListItem) element);
+ break;
+ case Element.SECTION:
+ rtfElement = new RtfSection(rtfDoc, (Section) element);
+ break;
+ case Element.CHAPTER:
+ rtfElement = new RtfChapter(rtfDoc, (Chapter) element);
+ break;
+ case Element.TABLE:
+ try {
+ rtfElement = new RtfTable(rtfDoc, (Table) element);
+ }
+ catch(ClassCastException e) {
+ rtfElement = new RtfTable(rtfDoc, ((SimpleTable) element).createTable());
+ }
+ break;
+ }
+
+ return rtfElement;
+ }
+}
diff --git a/src/main/java/com/lowagie/text/rtf/RtfPageNumber.java b/src/main/java/com/lowagie/text/rtf/RtfPageNumber.java new file mode 100644 index 0000000..1e966a2 --- /dev/null +++ b/src/main/java/com/lowagie/text/rtf/RtfPageNumber.java @@ -0,0 +1,105 @@ +/**
+ * $Id: RtfPageNumber.java,v 1.26 2006/02/09 17:25:25 hallm Exp $
+ *
+ * Copyright 2002 by
+ * <a href="http://www.smb-tec.com">SMB</a>
+ * <a href="mailto:Steffen.Stundzig@smb-tec.com">Steffen.Stundzig@smb-tec.com</a>
+ *
+ * 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.rtf;
+
+import java.io.IOException;
+import java.io.OutputStream;
+
+import com.lowagie.text.Font;
+
+/**
+ * A rtf page number field.
+ *
+ * ONLY FOR USE WITH THE RtfWriter NOT with the RtfWriter2.
+ *
+ * This class is based on the RtfWriter-package from Mark Hall.
+ * @author <a href="mailto:Steffen.Stundzig@smb-tec.com">Steffen.Stundzig@smb-tec.com</a>
+ * @author <a href="mailto:mhall@myrealbox.com">mhall@myrealbox.com</a>
+ * @version $Revision: 1.26 $Date: 2006/02/09 17:25:25 $
+ * @deprecated Please move to the RtfWriter2 and associated classes. com.lowagie.text.rtf.field.RtfPageNumber replaces the functionality of this class.
+ */
+public class RtfPageNumber extends GenericRtfField implements RtfField {
+ private String content;
+
+ /**
+ * construct a RtfPageNumber. The parameter content will be
+ * displayed in front of the page number using the font given as
+ * second argument.
+ * @param content the String that will be displayed in front of the page number
+ * @param contentFont the font to use to display this page number
+ */
+ public RtfPageNumber( String content, Font contentFont ) {
+ super("PAGE", "", contentFont);
+ this.content = content;
+ }
+
+ /**
+ * write this RtfField into a stream using the writer given as
+ * first argument.
+ * @param writer the RtfWriter to use to write this RtfField
+ * @param out the Stream to write this RtfField into.
+ * @throws IOException
+ */
+ public void write( RtfWriter writer, OutputStream out ) throws IOException {
+ writer.writeInitialFontSignature( out, this );
+ out.write(content.getBytes());
+ writer.writeFinishingFontSignature( out, this );
+ super.write(writer, out);
+ }
+
+ /**
+ * @see com.lowagie.text.Element#toString()
+ */
+ public String toString() {
+ return content;
+ }
+}
diff --git a/src/main/java/com/lowagie/text/rtf/RtfRow.java b/src/main/java/com/lowagie/text/rtf/RtfRow.java new file mode 100644 index 0000000..4a68987 --- /dev/null +++ b/src/main/java/com/lowagie/text/rtf/RtfRow.java @@ -0,0 +1,443 @@ +/**
+ * $Id: RtfRow.java,v 1.38 2006/02/09 17:25:25 hallm Exp $
+ * $Name: $
+ *
+ * Copyright 2001, 2002 by Mark Hall
+ *
+ * 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.rtf;
+
+import com.lowagie.text.*;
+
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.io.*;
+import java.awt.Color;
+
+/**
+ * A Helper Class for the <CODE>RtfWriter</CODE>.
+ * <P>
+ * Do not use it directly
+ *
+ * ONLY FOR USE WITH THE RtfWriter NOT with the RtfWriter2.
+ *
+ * Parts of this Class were contributed by Steffen Stundzig. Many thanks for the
+ * improvements.
+ * Code added by c
+ * @deprecated Please move to the RtfWriter2 and associated classes.
+ */
+public class RtfRow {
+ /** Table border solid */
+ public static final byte[] tableBorder = "brdrs".getBytes();
+ /** Table border width */
+ public static final byte[] tableBorderWidth = "brdrw".getBytes();
+ /** Table border color */
+ public static final byte[] tableBorderColor = "brdrcf".getBytes();
+
+ /** Table row defaults */
+ private static final byte[] rowBegin = "trowd".getBytes();
+ /** End of table row */
+ private static final byte[] rowEnd = "row".getBytes();
+ /** Table row autofit */
+ private static final byte[] rowAutofit = "trautofit1".getBytes();
+ private static final byte[] graphLeft = "trgaph".getBytes();
+ /** Row border left */
+ private static final byte[] rowBorderLeft = "trbrdrl".getBytes();
+ /** Row border right */
+ private static final byte[] rowBorderRight = "trbrdrr".getBytes();
+ /** Row border top */
+ private static final byte[] rowBorderTop = "trbrdrt".getBytes();
+ /** Row border bottom */
+ private static final byte[] rowBorderBottom = "trbrdrb".getBytes();
+ /** Row border horiz inline */
+ private static final byte[] rowBorderInlineHorizontal = "trbrdrh".getBytes();
+ /** Row border bottom */
+ private static final byte[] rowBorderInlineVertical = "trbrdrv".getBytes();
+ /** Default cell spacing left */
+ private static final byte[] rowSpacingLeft = "trspdl".getBytes();
+ /** Default cell spacing right */
+ private static final byte[] rowSpacingRight = "trspdr".getBytes();
+ /** Default cell spacing top */
+ private static final byte[] rowSpacingTop = "trspdt".getBytes();
+ /** Default cell spacing bottom */
+ private static final byte[] rowSpacingBottom = "trspdb".getBytes();
+ /** Default cell spacing format left */
+ private static final byte[] rowSpacingLeftStyle = "trspdfl3".getBytes();
+ /** Default cell spacing format right */
+ private static final byte[] rowSpacingRightStyle = "trspdfr3".getBytes();
+ /** Default cell spacing format top */
+ private static final byte[] rowSpacingTopStyle = "trspdft3".getBytes();
+ /** Default cell spacing format bottom */
+ private static final byte[] rowSpacingBottomStyle = "trspdfb3".getBytes();
+ /** Default cell padding left */
+ private static final byte[] rowPaddingLeft = "trpaddl".getBytes();
+ /** Default cell padding right */
+ private static final byte[] rowPaddingRight = "trpaddr".getBytes();
+ /** Default cell padding format left */
+ private static final byte[] rowPaddingLeftStyle = "trpaddfl3".getBytes();
+ /** Default cell padding format right */
+ private static final byte[] rowPaddingRightStyle = "trpaddfr3".getBytes();
+ /** Row width format */
+ private static final byte[] rowWidthStyle = "trftsWidth3".getBytes();
+ /** Row width */
+ private static final byte[] rowWidth = "trwWidth".getBytes();
+ /**
+ * Table row header. This row should appear at the top of every
+ * page the current table appears on.
+ */
+ private static final byte[] rowHeader = "trhdr".getBytes();
+ /**
+ * Table row keep together. This row cannot be split by a page break.
+ * This property is assumed to be off unless the control word is
+ * present.
+ */
+ private static final byte[] rowKeep = "trkeep".getBytes();
+ /** Table alignment left */
+ private static final byte[] rowAlignLeft = "trql".getBytes();
+ /** Table alignment center */
+ private static final byte[] rowAlignCenter = "trqc".getBytes();
+ /** Table alignment right */
+ private static final byte[] rowAlignRight = "trqr".getBytes();
+
+ /** List of <code>RtfCell</code>s in this <code>RtfRow</code> */
+ private ArrayList cells = new ArrayList();
+ /** The <code>RtfWriter</code> to which this <code>RtfRow</code> belongs */
+ private RtfWriter writer = null;
+ /** The <coce>RtfTable</code> to which this <code>RtfRow</code> belongs */
+ private RtfTable mainTable = null;
+
+ /** The width of this <code>RtfRow</code> (in percent) */
+ private int width = 100;
+ /** The default cellpadding of <code>RtfCells</code> in this
+ * <code>RtfRow</code> */
+ private int cellpadding = 115;
+ /** The default cellspacing of <code>RtfCells</code> in this
+ * <code>RtfRow</code> */
+ private int cellspacing = 14;
+ /** The borders of this <code>RtfRow</code> */
+ private int borders = 0;
+ /** The border color of this <code>RtfRow</code> */
+ private java.awt.Color borderColor = null;
+ /** The border width of this <code>RtfRow</code> */
+ private float borderWidth = 0;
+
+ /** Original Row */
+ private Row origRow = null;
+
+ /**
+ * Create a new <code>RtfRow</code>.
+ *
+ * @param writer The <code>RtfWriter</code> that this <code>RtfRow</code> belongs to
+ * @param mainTable The <code>RtfTable</code> that created this
+ * <code>RtfRow</code>
+ */
+ public RtfRow(RtfWriter writer, RtfTable mainTable) {
+ super();
+ this.writer = writer;
+ this.mainTable = mainTable;
+ }
+
+ /**
+ * Pregenerate the <code>RtfCell</code>s in this <code>RtfRow</code>.
+ *
+ * @param columns The number of <code>RtfCell</code>s to be generated.
+ */
+ public void pregenerateRows(int columns) {
+ for (int i = 0; i < columns; i++) {
+ RtfCell rtfCell = new RtfCell(writer, mainTable);
+ cells.add(rtfCell);
+ }
+ }
+
+ /**
+ * Import a <code>Row</code>.
+ * <P>
+ * All the parameters are taken from the <code>RtfTable</code> which contains
+ * this <code>RtfRow</code> and they do exactely what they say
+ * @param row
+ * @param propWidths in percent
+ * @param tableWidth in percent
+ * @param pageWidth
+ * @param cellpadding
+ * @param cellspacing
+ * @param borders
+ * @param borderColor
+ * @param borderWidth
+ * @param y
+ * @return true if importing the row succeeded
+ */
+ public boolean importRow(Row row, float[] propWidths, int tableWidth, int pageWidth, int cellpadding,
+ int cellspacing, int borders, java.awt.Color borderColor, float borderWidth,
+ int y) {
+ // the width of this row is the absolute witdh, calculated from the
+ // proportional with of the table and the total width of the page
+ this.origRow = row;
+ this.width = pageWidth / 100 * tableWidth;
+ this.cellpadding = cellpadding;
+ this.cellspacing = cellspacing;
+ this.borders = borders;
+ this.borderColor = borderColor;
+ this.borderWidth = borderWidth;
+
+ if (this.borderWidth > 2) this.borderWidth = 2;
+
+ int cellLeft = 0;
+ for (int i = 0; i < row.columns(); i++) {
+ Element cell = (Element) row.getCell(i);
+
+ // cellWidth is an absolute argument
+ // it's based on the absolute of this row and the proportional
+ // width of this column
+ int cellWidth = (int) (width / 100 * propWidths[i]);
+ if (cell != null) {
+ if (cell.type() == Element.CELL) {
+ RtfCell rtfCell = (RtfCell) cells.get(i);
+ cellLeft = rtfCell.importCell((Cell) cell, cellLeft, cellWidth, i, y, cellpadding);
+ }
+ } else {
+ RtfCell rtfCell = (RtfCell) cells.get(i);
+ cellLeft = rtfCell.importCell(null, cellLeft, cellWidth, i, y, cellpadding);
+ }
+ }
+
+ // recalculate the cell right border and the cumulative width
+ // on col spanning cells.
+ // col + row spanning cells are also handled by this loop, because the real cell of
+ // the upper left corner in such an col, row matrix is copied as first cell
+ // in each row in this matrix
+ int columns = row.columns();
+ for (int i = 0; i < columns; i++) {
+ RtfCell firstCell = (RtfCell) cells.get(i);
+ Cell cell = firstCell.getStore();
+ int cols = 0;
+ if(cell != null) {
+ cols = cell.colspan();
+ }
+ if (cols > 1) {
+ RtfCell lastCell = (RtfCell) cells.get(i + cols - 1);
+ firstCell.setCellRight(lastCell.getCellRight());
+ int width = firstCell.getCellWidth();
+ for (int j = i + 1; j < i + cols; j++) {
+ RtfCell cCell = (RtfCell) cells.get(j);
+ width += cCell.getCellWidth();
+ }
+ firstCell.setCellWidth(width);
+ i += cols - 1;
+ }
+ }
+ return true;
+ }
+
+ /**
+ * Write the <code>RtfRow</code> to the specified <code>OutputStream</code>.
+ *
+ * @param os The <code>OutputStream</code> to which this <code>RtfRow</code>
+ * should be written to.
+ * @param rowNum The <code>index</code> of this row in the containing table.
+ * @param table The <code>Table</code> which contains the original <code>Row</code>.
+ * @return true if writing the row succeeded
+ * @throws DocumentException
+ * @throws IOException
+ */
+ public boolean writeRow(ByteArrayOutputStream os, int rowNum, Table table) throws DocumentException,
+ IOException {
+ os.write(RtfWriter.escape);
+ os.write(rowBegin);
+ os.write((byte) '\n');
+ os.write(RtfWriter.escape);
+ os.write(rowWidthStyle);
+ os.write(RtfWriter.escape);
+ os.write(rowWidth);
+ writeInt(os, width);
+// os.write(RtfWriter.escape);
+// os.write(rowAutofit);
+ if (mainTable.getOriginalTable().hasToFitPageCells()) {
+ os.write(RtfWriter.escape);
+ os.write(rowKeep);
+ }
+ // check if this row is a header row
+ if (rowNum < table.firstDataRow()) {
+ os.write(RtfWriter.escape);
+ os.write(rowHeader);
+ }
+ os.write(RtfWriter.escape);
+ switch (this.origRow.horizontalAlignment()) {
+ case Element.ALIGN_LEFT:
+ os.write(rowAlignLeft);
+ break;
+ case Element.ALIGN_CENTER:
+ os.write(rowAlignCenter);
+ break;
+ case Element.ALIGN_RIGHT:
+ os.write(rowAlignRight);
+ break;
+ default :
+ os.write(rowAlignLeft);
+ break;
+ }
+ os.write(RtfWriter.escape);
+ os.write(graphLeft);
+ writeInt(os, 10);
+ if (((borders & Rectangle.LEFT) == Rectangle.LEFT) && (borderWidth > 0)) {
+ writeBorder(os, rowBorderLeft);
+ }
+ if (((borders & Rectangle.TOP) == Rectangle.TOP) && (borderWidth > 0)) {
+ writeBorder(os, rowBorderTop);
+ }
+ if (((borders & Rectangle.BOTTOM) == Rectangle.BOTTOM) && (borderWidth > 0)) {
+ writeBorder(os, rowBorderBottom);
+ }
+ if (((borders & Rectangle.RIGHT) == Rectangle.RIGHT) && (borderWidth > 0)) {
+ writeBorder(os, rowBorderRight);
+ }
+ if (((borders & Rectangle.BOX) == Rectangle.BOX) && (borderWidth > 0)) {
+ writeBorder(os, rowBorderInlineHorizontal);
+ writeBorder(os, rowBorderInlineVertical);
+ }
+
+ if (cellspacing > 0) {
+ os.write(RtfWriter.escape);
+ os.write(rowSpacingLeft);
+ writeInt(os, cellspacing / 2);
+ os.write(RtfWriter.escape);
+ os.write(rowSpacingLeftStyle);
+ os.write(RtfWriter.escape);
+ os.write(rowSpacingTop);
+ writeInt(os, cellspacing / 2);
+ os.write(RtfWriter.escape);
+ os.write(rowSpacingTopStyle);
+ os.write(RtfWriter.escape);
+ os.write(rowSpacingBottom);
+ writeInt(os, cellspacing / 2);
+ os.write(RtfWriter.escape);
+ os.write(rowSpacingBottomStyle);
+ os.write(RtfWriter.escape);
+ os.write(rowSpacingRight);
+ writeInt(os, cellspacing / 2);
+ os.write(RtfWriter.escape);
+ os.write(rowSpacingRightStyle);
+ }
+ os.write(RtfWriter.escape);
+ os.write(rowPaddingLeft);
+ writeInt(os, cellpadding / 2);
+ os.write(RtfWriter.escape);
+ os.write(rowPaddingRight);
+ writeInt(os, cellpadding / 2);
+ os.write(RtfWriter.escape);
+ os.write(rowPaddingLeftStyle);
+ os.write(RtfWriter.escape);
+ os.write(rowPaddingRightStyle);
+ os.write((byte) '\n');
+
+ Iterator cellIterator = cells.iterator();
+ while (cellIterator.hasNext()) {
+ RtfCell cell = (RtfCell) cellIterator.next();
+ cell.writeCellSettings(os);
+ }
+
+ os.write(RtfWriter.escape);
+ os.write("intbl".getBytes());
+
+ cellIterator = cells.iterator();
+ while (cellIterator.hasNext()) {
+ RtfCell cell = (RtfCell) cellIterator.next();
+ cell.writeCellContent(os);
+ }
+ os.write(RtfWriter.delimiter);
+ os.write(RtfWriter.escape);
+ os.write(rowEnd);
+ return true;
+ }
+
+
+ private void writeBorder(ByteArrayOutputStream os, byte[] borderType) throws IOException {
+ // horizontal and vertical, top, left, bottom, right
+ os.write(RtfWriter.escape);
+ os.write(borderType);
+ // line style
+ os.write(RtfWriter.escape);
+ os.write(RtfRow.tableBorder);
+ // borderwidth
+ os.write(RtfWriter.escape);
+ os.write(RtfRow.tableBorderWidth);
+ writeInt(os, (int) (borderWidth * RtfWriter.TWIPSFACTOR));
+ // border color
+ os.write(RtfWriter.escape);
+ os.write(RtfRow.tableBorderColor);
+ if (borderColor == null) {
+ writeInt(os, writer.addColor(new Color(0, 0, 0)));
+ } else {
+ writeInt(os, writer.addColor(borderColor));
+ }
+ os.write((byte) '\n');
+ }
+
+
+ /**
+ * <code>RtfTable</code>s call this method from their own setMerge() to
+ * specify that a certain other cell is to be merged with it.
+ *
+ * @param x The column position of the cell to be merged
+ * @param mergeType The merge type specifies the kind of merge to be applied
+ * (MERGE_HORIZ_PREV, MERGE_VERT_PREV, MERGE_BOTH_PREV)
+ * @param mergeCell The <code>RtfCell</code> that the cell at x and y is to
+ * be merged with
+ */
+ public void setMerge(int x, int mergeType, RtfCell mergeCell) {
+ RtfCell cell = (RtfCell) cells.get(x);
+ cell.setMerge(mergeType, mergeCell);
+ }
+
+ /*
+ * Write an Integer to the Outputstream.
+ *
+ * @param out The <code>OutputStream</code> to be written to.
+ * @param i The int to be written.
+ */
+ private void writeInt(ByteArrayOutputStream out, int i) throws IOException {
+ out.write(Integer.toString(i).getBytes());
+ }
+}
diff --git a/src/main/java/com/lowagie/text/rtf/RtfTOC.java b/src/main/java/com/lowagie/text/rtf/RtfTOC.java new file mode 100644 index 0000000..044a871 --- /dev/null +++ b/src/main/java/com/lowagie/text/rtf/RtfTOC.java @@ -0,0 +1,187 @@ +/**
+ * $Id: RtfTOC.java,v 1.23 2006/02/09 17:25:25 hallm Exp $
+ *
+ * Copyright 2002 by
+ * <a href="http://www.smb-tec.com">SMB</a>
+ * <a href="mailto:Steffen.Stundzig@smb-tec.com">Steffen.Stundzig@smb-tec.com</a>
+ *
+ * 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.rtf;
+
+import java.io.IOException;
+import java.io.OutputStream;
+
+import com.lowagie.text.Chunk;
+import com.lowagie.text.DocumentException;
+import com.lowagie.text.Font;
+import com.lowagie.text.ExceptionConverter;
+
+/**
+ * This class can be used to insert a table of contents into
+ * the RTF document.
+ * Therefore the field TOC is used. It works great in Word 2000.
+ * StarOffice doesn't support such fields. Other word version
+ * are not tested yet.
+ *
+ * ONLY FOR USE WITH THE RtfWriter NOT with the RtfWriter2.
+ *
+ * This class is based on the RtfWriter-package from Mark Hall.
+ * @author <a href="mailto:Steffen.Stundzig@smb-tec.com">Steffen.Stundzig@smb-tec.com</a>
+ * @version $Revision: 1.23 $Date: 2006/02/09 17:25:25 $
+ * @deprecated Please move to the RtfWriter2 and associated classes. com.lowagie.text.rtf.field.RtfTableOfContents replaces the functionality of this class.
+ */
+public class RtfTOC extends Chunk implements RtfField {
+
+
+ private String defaultText = "Klicken Sie mit der rechten Maustaste auf diesen Text, um das Inhaltsverzeichnis zu aktualisieren!";
+
+ private boolean addTOCAsTOCEntry = false;
+
+ private Font entryFont = null;
+ private String entryName = null;
+
+
+ /**
+ * @param tocName the headline of the table of contents
+ * @param tocFont the font for the headline
+ */
+ public RtfTOC( String tocName, Font tocFont ) {
+ super( tocName, tocFont );
+ }
+
+ /**
+ * @see com.lowagie.text.rtf.RtfField#write(com.lowagie.text.rtf.RtfWriter, java.io.OutputStream)
+ */
+ public void write( RtfWriter writer, OutputStream out ) throws IOException {
+
+ writer.writeInitialFontSignature( out, this );
+ out.write( RtfWriter.filterSpecialChar( content(), true ).getBytes() );
+ writer.writeFinishingFontSignature( out, this );
+
+ if (addTOCAsTOCEntry) {
+ RtfTOCEntry entry = new RtfTOCEntry( entryName, entryFont );
+ entry.hideText();
+ try {
+ writer.add( entry );
+ } catch ( DocumentException de ) {
+ throw new ExceptionConverter(de);
+ }
+ }
+
+ // line break after headline
+ out.write( RtfWriter.escape );
+ out.write( RtfWriter.paragraph );
+ out.write( RtfWriter.delimiter );
+
+ // toc field entry
+ out.write( RtfWriter.openGroup );
+ out.write( RtfWriter.escape );
+ out.write( RtfWriter.field );
+ // field initialization stuff
+ out.write( RtfWriter.openGroup );
+ out.write( RtfWriter.escape );
+ out.write( RtfWriter.fieldContent );
+ out.write( RtfWriter.delimiter );
+ out.write( "TOC".getBytes() );
+ // create the TOC based on the 'toc entries'
+ out.write( RtfWriter.delimiter );
+ out.write( RtfWriter.escape );
+ out.write( RtfWriter.escape );
+ out.write( "f".getBytes() );
+ out.write( RtfWriter.delimiter );
+ // create Hyperlink TOC Entrie
+ out.write( RtfWriter.escape );
+ out.write( RtfWriter.escape );
+ out.write( "h".getBytes() );
+ out.write( RtfWriter.delimiter );
+ // create the TOC based on the paragraph level
+ out.write( RtfWriter.delimiter );
+ out.write( RtfWriter.escape );
+ out.write( RtfWriter.escape );
+ out.write( "u".getBytes() );
+ out.write( RtfWriter.delimiter );
+ // create the TOC based on the paragraph headlines 1-5
+ out.write( RtfWriter.delimiter );
+ out.write( RtfWriter.escape );
+ out.write( RtfWriter.escape );
+ out.write( "o".getBytes() );
+ out.write( RtfWriter.delimiter );
+ out.write( "\"1-5\"".getBytes() );
+ out.write( RtfWriter.delimiter );
+ out.write( RtfWriter.closeGroup );
+
+ // field default result stuff
+ out.write( RtfWriter.openGroup );
+ out.write( RtfWriter.escape );
+ out.write( RtfWriter.fieldDisplay );
+ out.write( RtfWriter.delimiter );
+ out.write( defaultText.getBytes() );
+ out.write( RtfWriter.delimiter );
+ out.write( RtfWriter.closeGroup );
+ out.write( RtfWriter.closeGroup );
+ }
+
+
+ /**
+ * Add a toc entry
+ * @param entryName the name of the entry
+ * @param entryFont the font to be used for the entry
+ */
+ public void addTOCAsTOCEntry( String entryName, Font entryFont ) {
+ this.addTOCAsTOCEntry = true;
+ this.entryFont = entryFont;
+ this.entryName = entryName;
+ }
+
+
+ /**
+ * Sets the default text of the Table of Contents
+ * @param text the default text
+ */
+ public void setDefaultText( String text ) {
+ this.defaultText = text;
+ }
+}
diff --git a/src/main/java/com/lowagie/text/rtf/RtfTOCEntry.java b/src/main/java/com/lowagie/text/rtf/RtfTOCEntry.java new file mode 100644 index 0000000..c3ceab1 --- /dev/null +++ b/src/main/java/com/lowagie/text/rtf/RtfTOCEntry.java @@ -0,0 +1,174 @@ +/**
+ * $Id: RtfTOCEntry.java,v 1.23 2006/02/09 17:25:26 hallm Exp $
+ *
+ * Copyright 2002 by
+ * <a href="http://www.smb-tec.com">SMB</a>
+ * <a href="mailto:Steffen.Stundzig@smb-tec.com">Steffen.Stundzig@smb-tec.com</a>
+ *
+ * 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.rtf;
+
+import java.io.IOException;
+import java.io.OutputStream;
+
+import com.lowagie.text.Chunk;
+import com.lowagie.text.Font;
+
+/**
+ * This class can be used to insert entries for a table of contents into
+ * the RTF document.
+ *
+ * ONLY FOR USE WITH THE RtfWriter NOT with the RtfWriter2.
+ *
+ * This class is based on the RtfWriter-package from Mark Hall.
+ * @author <a href="mailto:Steffen.Stundzig@smb-tec.com">Steffen.Stundzig@smb-tec.com</a>
+ * @version $Revision: 1.23 $Date: 2006/02/09 17:25:26 $
+ * @deprecated Please move to the RtfWriter2 and associated classes. com.lowagie.text.rtf.field.RtfTOCEntry replaces the functionality of this class.
+ */
+public class RtfTOCEntry extends Chunk implements RtfField {
+
+
+ private boolean hideText = false;
+
+ private boolean hidePageNumber = false;
+
+ private String entryName;
+
+ private Font entryFont;
+
+ private Font contentFont;
+
+
+ /**
+ * Constructs an entry for the Table of Contents
+ * @param content the content of the entry
+ * @param contentFont the font
+ */
+ public RtfTOCEntry( String content, Font contentFont ) {
+ this( content, contentFont, content, contentFont );
+// super( content, font );
+// this.entryName = content;
+// printEntryNameAsText = true;
+ }
+
+
+ /**
+ * Constructs an entry for the Table of Contents
+ * @param content the content of the entry
+ * @param contentFont the font
+ * @param entryName name of the entry
+ * @param entryFont font of the entryname
+ */
+ public RtfTOCEntry( String content, Font contentFont, String entryName, Font entryFont ) {
+ super( content, contentFont );
+ // hide the text of the entry, because it is printed
+ this.entryName = entryName;
+ this.entryFont = entryFont;
+ this.contentFont = contentFont;
+ }
+
+ /**
+ * @see com.lowagie.text.rtf.RtfField#write(com.lowagie.text.rtf.RtfWriter, java.io.OutputStream)
+ */
+ public void write( RtfWriter writer, OutputStream out ) throws IOException {
+
+ if (!hideText) {
+ writer.writeInitialFontSignature( out, new Chunk("", contentFont) );
+ out.write( RtfWriter.filterSpecialChar( content(), true ).getBytes() );
+ writer.writeFinishingFontSignature( out, new Chunk("", contentFont) );
+ }
+
+ if (!entryFont.equals( contentFont )) {
+ writer.writeInitialFontSignature(out, new Chunk("", entryFont) );
+ writeField( out );
+ writer.writeFinishingFontSignature(out, new Chunk("", entryFont) );
+ } else {
+ writer.writeInitialFontSignature(out, new Chunk("", contentFont) );
+ writeField( out );
+ writer.writeFinishingFontSignature(out, new Chunk("", contentFont) );
+ }
+ }
+
+
+ private void writeField( OutputStream out ) throws IOException {
+
+ // always hide the toc entry
+ out.write( RtfWriter.openGroup );
+ out.write( RtfWriter.escape );
+ out.write( "v".getBytes() );
+
+ // tc field entry
+ out.write( RtfWriter.openGroup );
+ out.write( RtfWriter.escape );
+ if (!hidePageNumber) {
+ out.write( "tc".getBytes() );
+ } else {
+ out.write( "tcn".getBytes() );
+ }
+ out.write( RtfWriter.delimiter );
+ out.write( RtfWriter.filterSpecialChar( entryName, true ).getBytes() );
+ out.write( RtfWriter.delimiter );
+ out.write( RtfWriter.closeGroup );
+
+ out.write( RtfWriter.closeGroup );
+ }
+
+ /**
+ * sets the hideText value to true
+ */
+ public void hideText() {
+ hideText = true;
+ }
+
+ /**
+ * sets the hidePageNumber value to true
+ */
+ public void hidePageNumber() {
+ hidePageNumber = true;
+ }
+}
+
+
diff --git a/src/main/java/com/lowagie/text/rtf/RtfTable.java b/src/main/java/com/lowagie/text/rtf/RtfTable.java new file mode 100644 index 0000000..70c403e --- /dev/null +++ b/src/main/java/com/lowagie/text/rtf/RtfTable.java @@ -0,0 +1,201 @@ +/**
+ * $Id: RtfTable.java,v 1.31 2006/02/09 17:25:25 hallm Exp $
+ * $Name: $
+ *
+ * Copyright 2001, 2002 by Mark Hall
+ *
+ * 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.rtf;
+
+import com.lowagie.text.*;
+
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.io.*;
+
+/**
+ * A Helper Class for the <CODE>RtfWriter</CODE>.
+ * <P>
+ * Do not use it directly, except if you want to write a <CODE>DocumentListener</CODE> for Rtf
+ *
+ * ONLY FOR USE WITH THE RtfWriter NOT with the RtfWriter2.
+ *
+ * Parts of this Class were contributed by Steffen Stundzig. Many thanks for the
+ * improvements.
+ * Updates Benoit WIART <b.wiart@proxiad.com>
+ * @deprecated Please move to the RtfWriter2 and associated classes.
+ */
+public class RtfTable {
+ /** Stores the different rows. */
+ private ArrayList rowsList = new ArrayList();
+ /** Stores the RtfWriter, which created this RtfTable. */
+ private RtfWriter writer = null;
+ /** Stores the Table, which this RtfTable is based on. */
+ private Table origTable = null;
+
+
+
+ /**
+ * Create a new <code>RtfTable</code>.
+ *
+ * @param writer The <code>RtfWriter</code> that created this Table
+ */
+ public RtfTable(RtfWriter writer) {
+ super();
+ this.writer = writer;
+ }
+
+ /**
+ * Import a <CODE>Table</CODE> into the <CODE>RtfTable</CODE>.
+ * <P>
+ * @param table A <code>Table</code> specifying the <code>Table</code> to be imported
+ * @param pageWidth An <code>int</code> specifying the page width
+ * @return true if importing the table succeeded
+ */
+ public boolean importTable(Table table, int pageWidth) {
+ origTable = table;
+ // All Cells are pregenerated first, so that cell and rowspanning work
+ Iterator rows = table.iterator();
+ Row row = null;
+
+ int tableWidth = (int) table.widthPercentage();
+ int cellpadding = (int) (table.cellpadding() * RtfWriter.TWIPSFACTOR);
+ int cellspacing = (int) (table.cellspacing() * RtfWriter.TWIPSFACTOR);
+ float[] propWidths = table.getProportionalWidths();
+
+ int borders = table.border();
+ java.awt.Color borderColor = table.borderColor();
+ float borderWidth = table.borderWidth();
+
+ for (int i = 0; i < table.size(); i++) {
+ RtfRow rtfRow = new RtfRow(writer, this);
+ rtfRow.pregenerateRows(table.columns());
+ rowsList.add(rtfRow);
+ }
+ int i = 0;
+ while (rows.hasNext()) {
+ row = (Row) rows.next();
+ row.setHorizontalAlignment(table.alignment());
+ RtfRow rtfRow = (RtfRow) rowsList.get(i);
+ rtfRow.importRow(row, propWidths, tableWidth, pageWidth, cellpadding, cellspacing, borders, borderColor, borderWidth, i);
+ i++;
+ }
+ return true;
+ }
+
+ /**
+ * Output the content of the <CODE>RtfTable</CODE> to an OutputStream.
+ *
+ * @param os The <code>OutputStream</code> that the content of the <code>RtfTable</code> is to be written to
+ * @return true if writing the table succeeded
+ * @throws DocumentException
+ * @throws IOException
+ */
+ public boolean writeTable(ByteArrayOutputStream os) throws DocumentException, IOException {
+
+ if(!this.writer.writingHeaderFooter()) {
+ // Added by Benoit WIART <b.wiart@proxiad.com>
+ // Add a new line before each table
+ os.write(RtfWriter.escape);
+ os.write(RtfWriter.paragraph);
+ }
+
+ int size = rowsList.size();
+ for (int i = 0; i < size; i++) {
+ RtfRow row = (RtfRow) rowsList.get(i);
+ row.writeRow(os, i, origTable);
+ os.write((byte) '\n');
+ }
+ if (!writer.writingHeaderFooter()) {
+ os.write(RtfWriter.escape);
+ os.write(RtfWriter.paragraphDefaults);
+ os.write(RtfWriter.escape);
+ os.write(RtfWriter.paragraph);
+ switch (origTable.alignment()) {
+ case Element.ALIGN_LEFT:
+ os.write(RtfWriter.escape);
+ os.write(RtfWriter.alignLeft);
+ break;
+ case Element.ALIGN_RIGHT:
+ os.write(RtfWriter.escape);
+ os.write(RtfWriter.alignRight);
+ break;
+ case Element.ALIGN_CENTER:
+ os.write(RtfWriter.escape);
+ os.write(RtfWriter.alignCenter);
+ break;
+ case Element.ALIGN_JUSTIFIED:
+ case Element.ALIGN_JUSTIFIED_ALL:
+ os.write(RtfWriter.escape);
+ os.write(RtfWriter.alignJustify);
+ break;
+ }
+ }
+ return true;
+ }
+
+ /**
+ * <code>RtfCell</code>s call this method to specify that a certain other cell is to be merged with it.
+ *
+ * @param x The column position of the cell to be merged
+ * @param y The row position of the cell to be merged
+ * @param mergeType The merge type specifies the kind of merge to be applied (MERGE_HORIZ_PREV, MERGE_VERT_PREV, MERGE_BOTH_PREV)
+ * @param mergeCell The <code>RtfCell</code> that the cell at x and y is to be merged with
+ */
+ public void setMerge(int x, int y, int mergeType, RtfCell mergeCell) {
+ RtfRow row = (RtfRow) rowsList.get(y);
+ row.setMerge(x, mergeType, mergeCell);
+ }
+
+ /**
+ * This method allows access to the original Table that led to this RtfTable.
+ *
+ * @return The Table object that is the basis of this RtfTable.
+ */
+ protected Table getOriginalTable() {
+ return origTable;
+ }
+}
diff --git a/src/main/java/com/lowagie/text/rtf/RtfTableCell.java b/src/main/java/com/lowagie/text/rtf/RtfTableCell.java new file mode 100644 index 0000000..1d9b220 --- /dev/null +++ b/src/main/java/com/lowagie/text/rtf/RtfTableCell.java @@ -0,0 +1,392 @@ +/*
+ * 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.rtf;
+
+import com.lowagie.text.Cell;
+import com.lowagie.text.Element;
+import com.lowagie.text.BadElementException;
+
+import java.util.Properties;
+
+/**
+ * A <code>Cell</code> with extended style attributes
+ *
+ * ONLY FOR USE WITH THE RtfWriter NOT with the RtfWriter2.
+ * @deprecated Please move to the RtfWriter2 and associated classes. com.lowagie.text.rtf.table.RtfCell replaces the functionality of this class.
+ */
+public class RtfTableCell extends Cell
+{
+ /* Table border styles */
+
+ /** Table border solid */
+ public static final int BORDER_UNDEFINED = 0;
+
+ /** Table border solid */
+ public static final int BORDER_SINGLE = 1;
+
+ /** Table border double thickness */
+ public static final int BORDER_DOUBLE_THICK = 2;
+
+ /** Table border shadowed */
+ public static final int BORDER_SHADOWED = 3;
+
+ /** Table border dotted */
+ public static final int BORDER_DOTTED = 4;
+
+ /** Table border dashed */
+ public static final int BORDER_DASHED = 5;
+
+ /** Table border hairline */
+ public static final int BORDER_HAIRLINE = 6;
+
+ /** Table border double line */
+ public static final int BORDER_DOUBLE = 7;
+
+ /** Table border dot dash line */
+ public static final int BORDER_DOT_DASH = 8;
+
+ /** Table border dot dot dash line */
+ public static final int BORDER_DOT_DOT_DASH = 9;
+
+ /** Table border triple line */
+ public static final int BORDER_TRIPLE = 10;
+
+ /** Table border line */
+ public static final int BORDER_THICK_THIN = 11;
+
+ /** Table border line */
+ public static final int BORDER_THIN_THICK = 12;
+
+ /** Table border line */
+ public static final int BORDER_THIN_THICK_THIN = 13;
+
+ /** Table border line */
+ public static final int BORDER_THICK_THIN_MED = 14;
+
+ /** Table border line */
+ public static final int BORDER_THIN_THICK_MED = 15;
+
+ /** Table border line */
+ public static final int BORDER_THIN_THICK_THIN_MED = 16;
+
+ /** Table border line */
+ public static final int BORDER_THICK_THIN_LARGE = 17;
+
+ /** Table border line */
+ public static final int BORDER_THIN_THICK_LARGE = 18;
+
+ /** Table border line */
+ public static final int BORDER_THIN_THICK_THIN_LARGE = 19;
+
+ /** Table border line */
+ public static final int BORDER_WAVY = 20;
+
+ /** Table border line */
+ public static final int BORDER_DOUBLE_WAVY = 21;
+
+ /** Table border line */
+ public static final int BORDER_STRIPED = 22;
+
+ /** Table border line */
+ public static final int BORDER_EMBOSS = 23;
+
+ /** Table border line */
+ public static final int BORDER_ENGRAVE = 24;
+
+ /* Instance variables */
+ private float topBorderWidth;
+ private float leftBorderWidth;
+ private float rightBorderWidth;
+ private float bottomBorderWidth;
+ private int topBorderStyle = 1;
+ private int leftBorderStyle = 1;
+ private int rightBorderStyle = 1;
+ private int bottomBorderStyle = 1;
+
+/**
+ * Constructs an empty <CODE>Cell</CODE> (for internal use only).
+ *
+ * @param dummy a dummy value
+ */
+
+ public RtfTableCell(boolean dummy) {
+ super(dummy);
+ }
+
+/**
+ * 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 RtfTableCell(Element element) throws BadElementException {
+ super(element);
+ }
+
+/**
+ * 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 RtfTableCell(String content) {
+ super(content);
+ }
+
+/**
+ * Returns a <CODE>Cell</CODE> that has been constructed taking in account
+ * the value of some <VAR>attributes</VAR>.
+ *
+ * @param attributes Some attributes
+ */
+
+ public RtfTableCell(Properties attributes) {
+ super(attributes);
+ }
+
+ /**
+ * Set all four borders to <code>f</code> width
+ *
+ * @param f the desired width
+ */
+ public void setBorderWidth(float f) {
+ super.setBorderWidth(f);
+ topBorderWidth = f;
+ leftBorderWidth = f;
+ rightBorderWidth = f;
+ bottomBorderWidth = f;
+ }
+
+ /**
+ * Set the top border to <code>f</code> width
+ *
+ * @param f the desired width
+ */
+ public void setTopBorderWidth(float f) {
+ topBorderWidth = f;
+ }
+
+ /**
+ * Get the top border width
+ * @return a width
+ */
+ public float topBorderWidth() {
+ return topBorderWidth;
+ }
+
+ /**
+ * Set the left border to <code>f</code> width
+ *
+ * @param f the desired width
+ */
+ public void setLeftBorderWidth(float f) {
+ leftBorderWidth = f;
+ }
+
+ /**
+ * Get the left border width
+ * @return a width
+ */
+ public float leftBorderWidth() {
+ return leftBorderWidth;
+ }
+
+ /**
+ * Set the right border to <code>f</code> width
+ *
+ * @param f the desired width
+ */
+ public void setRightBorderWidth(float f) {
+ rightBorderWidth = f;
+ }
+
+ /**
+ * Get the right border width
+ * @return a width
+ */
+ public float rightBorderWidth() {
+ return rightBorderWidth;
+ }
+
+ /**
+ * Set the bottom border to <code>f</code> width
+ *
+ * @param f the desired width
+ */
+ public void setBottomBorderWidth(float f) {
+ bottomBorderWidth = f;
+ }
+
+ /**
+ * Get the bottom border width
+ * @return a width
+ */
+ public float bottomBorderWidth() {
+ return bottomBorderWidth;
+ }
+
+ /**
+ * Set all four borders to style defined by <code>style</code>
+ *
+ * @param style the desired style
+ */
+ public void setBorderStyle(int style) {
+ topBorderStyle = style;
+ leftBorderStyle = style;
+ rightBorderStyle = style;
+ bottomBorderStyle = style;
+ }
+
+ /**
+ * Set the top border to style defined by <code>style</code>
+ *
+ * @param style the desired style
+ */
+ public void setTopBorderStyle(int style) {
+ topBorderStyle = style;
+ }
+
+ /**
+ * Get the top border style
+ * @return a style value
+ */
+ public int topBorderStyle() {
+ return topBorderStyle;
+ }
+
+ /**
+ * Set the left border to style defined by <code>style</code>
+ *
+ * @param style the desired style
+ */
+ public void setLeftBorderStyle(int style) {
+ leftBorderStyle = style;
+ }
+
+ /**
+ * Get the left border style
+ * @return a style value
+ */
+ public int leftBorderStyle() {
+ return leftBorderStyle;
+ }
+
+ /**
+ * Set the right border to style defined by <code>style</code>
+ *
+ * @param style the desired style
+ */
+ public void setRightBorderStyle(int style) {
+ rightBorderStyle = style;
+ }
+
+ /**
+ * Get the right border style
+ * @return a style value
+ */
+ public int rightBorderStyle() {
+ return rightBorderStyle;
+ }
+
+ /**
+ * Set the bottom border to style defined by <code>style</code>
+ *
+ * @param style the desired style
+ */
+ public void setBottomBorderStyle(int style) {
+ bottomBorderStyle = style;
+ }
+
+ /**
+ * Get the bottom border style
+ * @return a style value
+ */
+ public int bottomBorderStyle() {
+ return bottomBorderStyle;
+ }
+
+ /**
+ * Get the RTF control word for <code>style</code>
+ * @param style a style value
+ * @return a byte array corresponding with a style control word
+ */
+ protected static byte[] getStyleControlWord(int style) {
+ switch(style)
+ {
+ case BORDER_UNDEFINED : return "brdrs".getBytes();
+ case BORDER_SINGLE : return "brdrs".getBytes();
+ case BORDER_DOUBLE_THICK : return "brdrth".getBytes();
+ case BORDER_SHADOWED : return "brdrsh".getBytes();
+ case BORDER_DOTTED : return "brdrdot".getBytes();
+ case BORDER_DASHED : return "brdrdash".getBytes();
+ case BORDER_HAIRLINE : return "brdrhair".getBytes();
+ case BORDER_DOUBLE : return "brdrdb".getBytes();
+ case BORDER_DOT_DASH : return "brdrdashd".getBytes();
+ case BORDER_DOT_DOT_DASH : return "brdrdashdd".getBytes();
+ case BORDER_TRIPLE : return "brdrtriple".getBytes();
+ case BORDER_THICK_THIN : return "brdrtnthsg".getBytes();
+ case BORDER_THIN_THICK : return "brdrthtnsg".getBytes();
+ case BORDER_THIN_THICK_THIN : return "brdrtnthtnsg".getBytes();
+ case BORDER_THICK_THIN_MED : return "brdrtnthmg".getBytes();
+ case BORDER_THIN_THICK_MED : return "brdrthtnmg".getBytes();
+ case BORDER_THIN_THICK_THIN_MED : return "brdrtnthtnmg".getBytes();
+ case BORDER_THICK_THIN_LARGE : return "brdrtnthlg".getBytes();
+ case BORDER_THIN_THICK_LARGE : return "brdrthtnlg".getBytes();
+ case BORDER_THIN_THICK_THIN_LARGE : return "brdrtnthtnlg".getBytes();
+ case BORDER_WAVY : return "brdrwavy".getBytes();
+ case BORDER_DOUBLE_WAVY : return "brdrwavydb".getBytes();
+ case BORDER_STRIPED : return "brdrdashdotstr".getBytes();
+ case BORDER_EMBOSS : return "brdremboss".getBytes();
+ case BORDER_ENGRAVE : return "brdrengrave".getBytes();
+ }
+
+ return "brdrs".getBytes();
+ }
+}
diff --git a/src/main/java/com/lowagie/text/rtf/RtfWriter.java b/src/main/java/com/lowagie/text/rtf/RtfWriter.java new file mode 100644 index 0000000..43b47da --- /dev/null +++ b/src/main/java/com/lowagie/text/rtf/RtfWriter.java @@ -0,0 +1,2299 @@ +/*
+ * $Id: RtfWriter.java,v 1.70 2006/02/09 17:25:25 hallm Exp $
+ * $Name: $
+ *
+ * Copyright 2001, 2002 by Mark Hall
+ *
+ * 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.rtf;
+
+import com.lowagie.text.*;
+
+import java.io.*;
+import java.util.ArrayList;
+import java.util.ListIterator;
+import java.util.Iterator;
+import java.util.Calendar;
+import java.util.Date;
+import java.awt.Color;
+import java.text.SimpleDateFormat;
+import java.text.ParsePosition;
+import com.lowagie.text.pdf.codec.wmf.MetaDo;
+
+/**
+ * If you are creating a new project using the rtf part of iText, please
+ * consider using the new RtfWriter2. The RtfWriter is in bug-fix-only mode,
+ * will be deprecated end of 2005 and removed end of 2007.
+ *
+ * A <CODE>DocWriter</CODE> class for Rich Text Files (RTF).
+ * <P>
+ * A <CODE>RtfWriter</CODE> can be added as a <CODE>DocListener</CODE>
+ * to a certain <CODE>Document</CODE> by getting an instance.
+ * Every <CODE>Element</CODE> added to the original <CODE>Document</CODE>
+ * will be written to the <CODE>OutputStream</CODE> of this <CODE>RtfWriter</CODE>.
+ * <P>
+ * Example:
+ * <BLOCKQUOTE><PRE>
+ * // creation of the document with a certain size and certain margins
+ * Document document = new Document(PageSize.A4, 50, 50, 50, 50);
+ * try {
+ * // this will write RTF to the Standard OutputStream
+ * <STRONG>RtfWriter.getInstance(document, System.out);</STRONG>
+ * // this will write Rtf to a file called text.rtf
+ * <STRONG>RtfWriter.getInstance(document, new FileOutputStream("text.rtf"));</STRONG>
+ * // this will write Rtf to for instance the OutputStream of a HttpServletResponse-object
+ * <STRONG>RtfWriter.getInstance(document, response.getOutputStream());</STRONG>
+ * }
+ * catch(DocumentException de) {
+ * System.err.println(de.getMessage());
+ * }
+ * // this will close the document and all the OutputStreams listening to it
+ * <STRONG>document.close();</CODE>
+ * </PRE></BLOCKQUOTE>
+ * <P>
+ * <STRONG>LIMITATIONS</STRONG><BR>
+ * There are currently still a few limitations on what the RTF Writer can do:
+ * <ul>
+ * <li>Watermarks</li>
+ * <li>Viewer preferences</li>
+ * <li>Encryption</li>
+ * <li>Embedded fonts</li>
+ * <li>Phrases with a leading</li>
+ * <li>Lists with non-bullet symbols</li>
+ * <li>Nested tables</li>
+ * <li>Images other than JPEG and PNG</li>
+ * <li>Rotated images</li>
+ * </ul>
+ * <br />
+ *
+ * @author <a href="mailto:mhall@myrealbox.com">Mark.Hall@myrealbox.com</a>
+ * @author Steffen Stundzig
+ * @author <a href="ericmattes@yahoo.com">Eric Mattes</a>
+ * @author <a href="raul.wegmann@uam.es">Raul Wegmann</a>
+ * @deprecated The RtfWriter is deprecated and will be removed from the iText library end of 2007
+ */
+public class RtfWriter extends DocWriter implements DocListener {
+ /**
+ * Static Constants
+ */
+
+ /**
+ * General
+ */
+
+ /** This is the escape character which introduces RTF tags. */
+ public static final byte escape = (byte) '\\';
+
+ /** This is another escape character which introduces RTF tags. */
+ private static final byte[] extendedEscape = "\\*\\".getBytes();
+
+ /** This is the delimiter between RTF tags and normal text. */
+ protected static final byte delimiter = (byte) ' ';
+
+ /** This is another delimiter between RTF tags and normal text. */
+ private static final byte commaDelimiter = (byte) ';';
+
+ /** This is the character for beginning a new group. */
+ public static final byte openGroup = (byte) '{';
+
+ /** This is the character for closing a group. */
+ public static final byte closeGroup = (byte) '}';
+
+ /**
+ * RTF Information
+ */
+
+ /** RTF begin and version. */
+ private static final byte[] docBegin = "rtf1".getBytes();
+
+ /** RTF encoding. */
+ private static final byte[] ansi = "ansi".getBytes();
+
+ /** RTF encoding codepage. */
+ private static final byte[] ansiCodepage = "ansicpg".getBytes();
+
+ /**
+ *Font Data
+ */
+
+ /** Begin the font table tag. */
+ private static final byte[] fontTable = "fonttbl".getBytes();
+
+ /** Font number tag. */
+ protected static final byte fontNumber = (byte) 'f';
+
+ /** Font size tag. */
+ protected static final byte[] fontSize = "fs".getBytes();
+
+ /** Font color tag. */
+ protected static final byte[] fontColor = "cf".getBytes();
+
+ /** Modern font tag. */
+ private static final byte[] fontModern = "fmodern".getBytes();
+
+ /** Swiss font tag. */
+ private static final byte[] fontSwiss = "fswiss".getBytes();
+
+ /** Roman font tag. */
+ private static final byte[] fontRoman = "froman".getBytes();
+
+ /** Tech font tag. */
+ private static final byte[] fontTech = "ftech".getBytes();
+
+ /** Font charset tag. */
+ private static final byte[] fontCharset = "fcharset".getBytes();
+
+ /** Font Courier tag. */
+ private static final byte[] fontCourier = "Courier".getBytes();
+
+ /** Font Arial tag. */
+ private static final byte[] fontArial = "Arial".getBytes();
+
+ /** Font Symbol tag. */
+ private static final byte[] fontSymbol = "Symbol".getBytes();
+
+ /** Font Times New Roman tag. */
+ private static final byte[] fontTimesNewRoman = "Times New Roman".getBytes();
+
+ /** Font Windings tag. */
+ private static final byte[] fontWindings = "Windings".getBytes();
+
+ /** Default Font. */
+ private static final byte[] defaultFont = "deff".getBytes();
+
+ /** First indent tag. */
+ private static final byte[] firstIndent = "fi".getBytes();
+
+ /** Left indent tag. */
+ private static final byte[] listIndent = "li".getBytes();
+
+ /** Right indent tag. */
+ private static final byte[] rightIndent = "ri".getBytes();
+
+ /**
+ * Sections / Paragraphs
+ */
+
+ /** Reset section defaults tag. */
+ private static final byte[] sectionDefaults = "sectd".getBytes();
+
+ /** Begin new section tag. */
+ private static final byte[] section = "sect".getBytes();
+
+ /** Reset paragraph defaults tag. */
+ public static final byte[] paragraphDefaults = "pard".getBytes();
+
+ /** Begin new paragraph tag. */
+ public static final byte[] paragraph = "par".getBytes();
+
+ /** Page width of a section. */
+ public static final byte[] sectionPageWidth = "pgwsxn".getBytes();
+
+ /** Page height of a section. */
+ public static final byte[] sectionPageHeight = "pghsxn".getBytes();
+
+ /**
+ * Lists
+ */
+
+ /** Begin the List Table */
+ private static final byte[] listtableGroup = "listtable".getBytes();
+
+ /** Begin the List Override Table */
+ private static final byte[] listoverridetableGroup = "listoverridetable".getBytes();
+
+ /** Begin a List definition */
+ private static final byte[] listDefinition = "list".getBytes();
+
+ /** List Template ID */
+ private static final byte[] listTemplateID = "listtemplateid".getBytes();
+
+ /** RTF Writer outputs hybrid lists */
+ private static final byte[] hybridList = "hybrid".getBytes();
+
+ /** Current List level */
+ private static final byte[] listLevelDefinition = "listlevel".getBytes();
+
+ /** Level numbering (old) */
+ private static final byte[] listLevelTypeOld = "levelnfc".getBytes();
+
+ /** Level numbering (new) */
+ private static final byte[] listLevelTypeNew = "levelnfcn".getBytes();
+
+ /** Level alignment (old) */
+ private static final byte[] listLevelAlignOld = "leveljc".getBytes();
+
+ /** Level alignment (new) */
+ private static final byte[] listLevelAlignNew = "leveljcn".getBytes();
+
+ /** Level starting number */
+ private static final byte[] listLevelStartAt = "levelstartat".getBytes();
+
+ /** Level text group */
+ private static final byte[] listLevelTextDefinition = "leveltext".getBytes();
+
+ /** Filler for Level Text Length */
+ private static final byte[] listLevelTextLength = "\'0".getBytes();
+
+ /** Level Text Numbering Style */
+ private static final byte[] listLevelTextStyleNumbers = "\'00.".getBytes();
+
+ /** Level Text Bullet Style */
+ private static final byte[] listLevelTextStyleBullet = "u-3913 ?".getBytes();
+
+ /** Level Numbers Definition */
+ private static final byte[] listLevelNumbersDefinition = "levelnumbers".getBytes();
+
+ /** Filler for Level Numbers */
+ private static final byte[] listLevelNumbers = "\\'0".getBytes();
+
+ /** Tab Stop */
+ private static final byte[] tabStop = "tx".getBytes();
+
+ /** Actual list begin */
+ private static final byte[] listBegin = "ls".getBytes();
+
+ /** Current list level */
+ private static final byte[] listCurrentLevel = "ilvl".getBytes();
+
+ /** List text group for older browsers */
+ private static final byte[] listTextOld = "listtext".getBytes();
+
+ /** Tab */
+ private static final byte[] tab = "tab".getBytes();
+
+ /** Old Bullet Style */
+ private static final byte[] listBulletOld = "\'b7".getBytes();
+
+ /** Current List ID */
+ private static final byte[] listID = "listid".getBytes();
+
+ /** List override */
+ private static final byte[] listOverride = "listoverride".getBytes();
+
+ /** Number of overrides */
+ private static final byte[] listOverrideCount = "listoverridecount".getBytes();
+
+ /**
+ * Text Style
+ */
+
+ /** Bold tag. */
+ protected static final byte bold = (byte) 'b';
+
+ /** Italic tag. */
+ protected static final byte italic = (byte) 'i';
+
+ /** Underline tag. */
+ protected static final byte[] underline = "ul".getBytes();
+
+ /** Strikethrough tag. */
+ protected static final byte[] strikethrough = "strike".getBytes();
+
+ /** Text alignment left tag. */
+ public static final byte[] alignLeft = "ql".getBytes();
+
+ /** Text alignment center tag. */
+ public static final byte[] alignCenter = "qc".getBytes();
+
+ /** Text alignment right tag. */
+ public static final byte[] alignRight = "qr".getBytes();
+
+ /** Text alignment justify tag. */
+ public static final byte[] alignJustify = "qj".getBytes();
+
+ /**
+ * Colors
+ */
+
+ /** Begin colour table tag. */
+ private static final byte[] colorTable = "colortbl".getBytes();
+
+ /** Red value tag. */
+ private static final byte[] colorRed = "red".getBytes();
+
+ /** Green value tag. */
+ private static final byte[] colorGreen = "green".getBytes();
+
+ /** Blue value tag. */
+ private static final byte[] colorBlue = "blue".getBytes();
+
+ /**
+ * Information Group
+ */
+
+ /** Begin the info group tag.*/
+ private static final byte[] infoBegin = "info".getBytes();
+
+ /** Author tag. */
+ private static final byte[] metaAuthor = "author".getBytes();
+
+ /** Subject tag. */
+ private static final byte[] metaSubject = "subject".getBytes();
+
+ /** Keywords tag. */
+ private static final byte[] metaKeywords = "keywords".getBytes();
+
+ /** Title tag. */
+ private static final byte[] metaTitle = "title".getBytes();
+
+ /** Producer tag. */
+ private static final byte[] metaProducer = "operator".getBytes();
+
+ /** Creation Date tag. */
+ private static final byte[] metaCreationDate = "creationdate".getBytes();
+
+ /** Year tag. */
+ private static final byte[] year = "yr".getBytes();
+
+ /** Month tag. */
+ private static final byte[] month = "mo".getBytes();
+
+ /** Day tag. */
+ private static final byte[] day = "dy".getBytes();
+
+ /** Hour tag. */
+ private static final byte[] hour = "hr".getBytes();
+
+ /** Minute tag. */
+ private static final byte[] minute = "min".getBytes();
+
+ /** Second tag. */
+ private static final byte[] second = "sec".getBytes();
+
+ /** Start superscript. */
+ private static final byte[] startSuper = "super".getBytes();
+
+ /** Start subscript. */
+ private static final byte[] startSub = "sub".getBytes();
+
+ /** End super/sub script. */
+ private static final byte[] endSuperSub = "nosupersub".getBytes();
+
+ /**
+ * Header / Footer
+ */
+
+ /** Title Page tag */
+ private static final byte[] titlePage = "titlepg".getBytes();
+
+ /** Facing pages tag */
+ private static final byte[] facingPages = "facingp".getBytes();
+
+ /** Begin header group tag. */
+ private static final byte[] headerBegin = "header".getBytes();
+
+ /** Begin footer group tag. */
+ private static final byte[] footerBegin = "footer".getBytes();
+
+ // header footer 'left', 'right', 'first'
+ private static final byte[] headerlBegin = "headerl".getBytes();
+
+ private static final byte[] footerlBegin = "footerl".getBytes();
+
+ private static final byte[] headerrBegin = "headerr".getBytes();
+
+ private static final byte[] footerrBegin = "footerr".getBytes();
+
+ private static final byte[] headerfBegin = "headerf".getBytes();
+
+ private static final byte[] footerfBegin = "footerf".getBytes();
+
+ /**
+ * Paper Properties
+ */
+
+ /** Paper width tag. */
+ private static final byte[] rtfPaperWidth = "paperw".getBytes();
+
+ /** Paper height tag. */
+ private static final byte[] rtfPaperHeight = "paperh".getBytes();
+
+ /** Margin left tag. */
+ private static final byte[] rtfMarginLeft = "margl".getBytes();
+
+ /** Margin right tag. */
+ private static final byte[] rtfMarginRight = "margr".getBytes();
+
+ /** Margin top tag. */
+ private static final byte[] rtfMarginTop = "margt".getBytes();
+
+ /** Margin bottom tag. */
+ private static final byte[] rtfMarginBottom = "margb".getBytes();
+
+ /** New Page tag. */
+ private static final byte[] newPage = "page".getBytes();
+
+ /** Document Landscape tag 1. */
+ private static final byte[] landscapeTag1 = "landscape".getBytes();
+
+ /** Document Landscape tag 2. */
+ private static final byte[] landscapeTag2 = "lndscpsxn".getBytes();
+
+ /**
+ * Annotations
+ */
+
+ /** Annotation ID tag. */
+ private static final byte[] annotationID = "atnid".getBytes();
+
+ /** Annotation Author tag. */
+ private static final byte[] annotationAuthor = "atnauthor".getBytes();
+
+ /** Annotation text tag. */
+ private static final byte[] annotation = "annotation".getBytes();
+
+ /**
+ * Images
+ */
+
+ /** Begin the main Picture group tag */
+ private static final byte[] pictureGroup = "shppict".getBytes();
+
+ /** Begin the picture tag */
+ private static final byte[] picture = "pict".getBytes();
+
+ /** PNG Image */
+ private static final byte[] picturePNG = "pngblip".getBytes();
+
+ /** JPEG Image */
+ private static final byte[] pictureJPEG = "jpegblip".getBytes();
+
+ /** BMP Image */
+ private static final byte[] pictureBMP = "dibitmap0".getBytes();
+
+ /** WMF Image */
+ private static final byte[] pictureWMF = "wmetafile8".getBytes();
+
+ /** Picture width */
+ private static final byte[] pictureWidth = "picw".getBytes();
+
+ /** Picture height */
+ private static final byte[] pictureHeight = "pich".getBytes();
+
+ /** Picture scale horizontal percent */
+ private static final byte[] pictureScaleX = "picscalex".getBytes();
+
+ /** Picture scale vertical percent */
+ private static final byte[] pictureScaleY = "picscaley".getBytes();
+
+ /**
+ * Fields (for page numbering)
+ */
+
+ /** Begin field tag */
+ protected static final byte[] field = "field".getBytes();
+
+ /** Content fo the field */
+ protected static final byte[] fieldContent = "fldinst".getBytes();
+
+ /** PAGE numbers */
+ protected static final byte[] fieldPage = "PAGE".getBytes();
+
+ /** HYPERLINK field */
+ protected static final byte[] fieldHyperlink = "HYPERLINK".getBytes();
+
+ /** Last page number (not used) */
+ protected static final byte[] fieldDisplay = "fldrslt".getBytes();
+
+
+ /** Class variables */
+
+ /**
+ * Because of the way RTF works and the way itext works, the text has to be
+ * stored and is only written to the actual OutputStream at the end.
+ */
+
+ /** This <code>ArrayList</code> contains all fonts used in the document. */
+ private ArrayList fontList = new ArrayList();
+
+ /** This <code>ArrayList</code> contains all colours used in the document. */
+ private ArrayList colorList = new ArrayList();
+
+ /** This <code>ByteArrayOutputStream</code> contains the main body of the document. */
+ private ByteArrayOutputStream content = null;
+
+ /** This <code>ByteArrayOutputStream</code> contains the information group. */
+ private ByteArrayOutputStream info = null;
+
+ /** This <code>ByteArrayOutputStream</code> contains the list table. */
+ private ByteArrayOutputStream listtable = null;
+
+ /** This <code>ByteArrayOutputStream</code> contains the list override table. */
+ private ByteArrayOutputStream listoverride = null;
+
+ /** Document header. */
+ private HeaderFooter header = null;
+
+ /** Document footer. */
+ private HeaderFooter footer = null;
+
+ /** Left margin. */
+ private int marginLeft = 1800;
+
+ /** Right margin. */
+ private int marginRight = 1800;
+
+ /** Top margin. */
+ private int marginTop = 1440;
+
+ /** Bottom margin. */
+ private int marginBottom = 1440;
+
+ /** Page width. */
+ private int pageWidth = 11906;
+
+ /** Page height. */
+ private int pageHeight = 16838;
+
+ /** Factor to use when converting. */
+ public final static double TWIPSFACTOR = 20;//20.57140;
+
+ /** Current list ID. */
+ private int currentListID = 1;
+
+ /** List of current Lists. */
+ private ArrayList listIds = null;
+
+ /** Current List Level. */
+ private int listLevel = 0;
+
+ /** Current maximum List Level. */
+ private int maxListLevel = 0;
+
+ /** Write a TOC */
+ private boolean writeTOC = false;
+
+ /** Special title page */
+ private boolean hasTitlePage = false;
+
+ /** Currently writing either Header or Footer */
+ private boolean inHeaderFooter = false;
+
+ /** Currently writing a Table */
+ private boolean inTable = false;
+
+ /** Landscape or Portrait Document */
+ private boolean landscape = false;
+
+ /** Protected Constructor */
+
+ /**
+ * Constructs a <CODE>RtfWriter</CODE>.
+ *
+ * @param doc The <CODE>Document</CODE> that is to be written as RTF
+ * @param os The <CODE>OutputStream</CODE> the writer has to write to.
+ */
+
+ protected RtfWriter(Document doc, OutputStream os) {
+ super(doc, os);
+ document.addDocListener(this);
+ initDefaults();
+ }
+
+ /** Public functions special to the RtfWriter */
+
+ /**
+ * This method controls whether TOC entries are automatically generated
+ *
+ * @param writeTOC boolean value indicating whether a TOC is to be generated
+ */
+ public void setGenerateTOCEntries(boolean writeTOC) {
+ this.writeTOC = writeTOC;
+ }
+
+ /**
+ * Gets the current setting of writeTOC
+ *
+ * @return boolean value indicating whether a TOC is being generated
+ */
+ public boolean getGeneratingTOCEntries() {
+ return writeTOC;
+ }
+
+ /**
+ * This method controls whether the first page is a title page
+ *
+ * @param hasTitlePage boolean value indicating whether the first page is a title page
+ */
+ public void setHasTitlePage(boolean hasTitlePage) {
+ this.hasTitlePage = hasTitlePage;
+ }
+
+ /**
+ * Gets the current setting of hasTitlePage
+ *
+ * @return boolean value indicating whether the first page is a title page
+ */
+ public boolean getHasTitlePage() {
+ return hasTitlePage;
+ }
+
+ /**
+ * Explicitly sets the page format to use.
+ * Otherwise the RtfWriter will try to guess the format by comparing pagewidth and pageheight
+ *
+ * @param landscape boolean value indicating whether we are using landscape format or not
+ */
+ public void setLandscape(boolean landscape) {
+ this.landscape = landscape;
+ }
+
+ /**
+ * Returns the current landscape setting
+ *
+ * @return boolean value indicating the current page format
+ */
+ public boolean getLandscape() {
+ return landscape;
+ }
+
+ /** Public functions from the DocWriter Interface */
+
+ /**
+ * Gets an instance of the <CODE>RtfWriter</CODE>.
+ *
+ * @param document The <CODE>Document</CODE> that has to be written
+ * @param os The <CODE>OutputStream</CODE> the writer has to write to.
+ * @return a new <CODE>RtfWriter</CODE>
+ */
+ public static RtfWriter getInstance(Document document, OutputStream os) {
+ return (new RtfWriter(document, os));
+ }
+
+ /**
+ * Signals that the <CODE>Document</CODE> has been opened and that
+ * <CODE>Elements</CODE> can be added.
+ */
+ public void open() {
+ super.open();
+ }
+
+ /**
+ * Signals that the <CODE>Document</CODE> was closed and that no other
+ * <CODE>Elements</CODE> will be added.
+ * <p>
+ * The content of the font table, color table, information group, content, header, footer are merged into the final
+ * <code>OutputStream</code>
+ */
+ public void close() {
+ writeDocument();
+ super.close();
+ }
+
+ /**
+ * Adds the footer to the bottom of the <CODE>Document</CODE>.
+ * @param footer
+ */
+ public void setFooter(HeaderFooter footer) {
+ this.footer = footer;
+ processHeaderFooter(this.footer);
+ }
+
+ /**
+ * Adds the header to the top of the <CODE>Document</CODE>.
+ * @param header
+ */
+ public void setHeader(HeaderFooter header) {
+ this.header = header;
+ processHeaderFooter(this.header);
+ }
+
+ /**
+ * Resets the footer.
+ */
+ public void resetFooter() {
+ setFooter(null);
+ }
+
+ /**
+ * Resets the header.
+ */
+ public void resetHeader() {
+ setHeader(null);
+ }
+
+ /**
+ * Tells the <code>RtfWriter</code> that a new page is to be begun.
+ *
+ * @return <code>true</code> if a new Page was begun.
+ * @throws DocumentException if the Document was not open or had been closed.
+ */
+ public boolean newPage() throws DocumentException {
+ try {
+ content.write(escape);
+ content.write(newPage);
+ content.write(escape);
+ content.write(paragraph);
+ } catch (IOException e) {
+ return false;
+ }
+ return true;
+ }
+
+ /**
+ * Sets the page margins
+ *
+ * @param marginLeft The left margin
+ * @param marginRight The right margin
+ * @param marginTop The top margin
+ * @param marginBottom The bottom margin
+ *
+ * @return <code>true</code> if the page margins were set.
+ */
+ public boolean setMargins(float marginLeft, float marginRight, float marginTop, float marginBottom) {
+ this.marginLeft = (int) (marginLeft * TWIPSFACTOR);
+ this.marginRight = (int) (marginRight * TWIPSFACTOR);
+ this.marginTop = (int) (marginTop * TWIPSFACTOR);
+ this.marginBottom = (int) (marginBottom * TWIPSFACTOR);
+ return true;
+ }
+
+ /**
+ * Sets the page size
+ *
+ * @param pageSize A <code>Rectangle</code> specifying the page size
+ *
+ * @return <code>true</code> if the page size was set
+ */
+ public boolean setPageSize(Rectangle pageSize) {
+ if (!parseFormat(pageSize, false)) {
+ pageWidth = (int) (pageSize.width() * TWIPSFACTOR);
+ pageHeight = (int) (pageSize.height() * TWIPSFACTOR);
+ landscape = pageWidth > pageHeight;
+ }
+ return true;
+ }
+
+ /**
+ * Write the table of contents.
+ *
+ * @param tocTitle The title that will be displayed above the TOC
+ * @param titleFont The <code>Font</code> that will be used for the tocTitle
+ * @param showTOCasEntry Set this to true if you want the TOC to appear as an entry in the TOC
+ * @param showTOCEntryFont Use this <code>Font</code> to specify what Font to use when showTOCasEntry is true
+ *
+ * @return <code>true</code> if the TOC was added.
+ */
+ public boolean writeTOC(String tocTitle, Font titleFont, boolean showTOCasEntry, Font showTOCEntryFont) {
+ try {
+ RtfTOC toc = new RtfTOC(tocTitle, titleFont);
+ if (showTOCasEntry) {
+ toc.addTOCAsTOCEntry(tocTitle, showTOCEntryFont);
+ }
+ add(new Paragraph(toc));
+ } catch (DocumentException de) {
+ return false;
+ }
+ return true;
+ }
+
+ /**
+ * Signals that an <CODE>Element</CODE> was added to the <CODE>Document</CODE>.
+ *
+ * @param element A high level object to add
+ * @return <CODE>true</CODE> if the element was added, <CODE>false</CODE> if not.
+ * @throws DocumentException if a document isn't open yet, or has been closed
+ */
+ public boolean add(Element element) throws DocumentException {
+ if (pause) {
+ return false;
+ }
+ return addElement(element, content);
+ }
+
+
+ /** Private functions */
+
+ /**
+ * Adds an <CODE>Element</CODE> to the <CODE>Document</CODE>.
+ * @param element the high level element to add
+ * @param out the outputstream to which the RTF data is sent
+ * @return <CODE>true</CODE> if the element was added, <CODE>false</CODE> if not.
+ * @throws DocumentException if a document isn't open yet, or has been closed
+ */
+ protected boolean addElement(Element element, ByteArrayOutputStream out) throws DocumentException {
+ try {
+ switch (element.type()) {
+ case Element.CHUNK:
+ writeChunk((Chunk) element, out);
+ break;
+ case Element.PARAGRAPH:
+ writeParagraph((Paragraph) element, out);
+ break;
+ case Element.ANCHOR:
+ writeAnchor((Anchor) element, out);
+ break;
+ case Element.PHRASE:
+ writePhrase((Phrase) element, out);
+ break;
+ case Element.CHAPTER:
+ case Element.SECTION:
+ writeSection((Section) element, out);
+ break;
+ case Element.LIST:
+ writeList((com.lowagie.text.List) element, out);
+ break;
+ case Element.TABLE:
+ try {
+ writeTable((Table) element, out);
+ }
+ catch(ClassCastException cce) {
+ writeTable(((SimpleTable)element).createTable(), out);
+ }
+ break;
+ case Element.ANNOTATION:
+ writeAnnotation((Annotation) element, out);
+ break;
+ case Element.IMGRAW:
+ case Element.IMGTEMPLATE:
+ case Element.JPEG:
+ Image img = (Image)element;
+ writeImage(img, out);
+ break;
+
+ case Element.AUTHOR:
+ writeMeta(metaAuthor, (Meta) element);
+ break;
+ case Element.SUBJECT:
+ writeMeta(metaSubject, (Meta) element);
+ break;
+ case Element.KEYWORDS:
+ writeMeta(metaKeywords, (Meta) element);
+ break;
+ case Element.TITLE:
+ writeMeta(metaTitle, (Meta) element);
+ break;
+ case Element.PRODUCER:
+ writeMeta(metaProducer, (Meta) element);
+ break;
+ case Element.CREATIONDATE:
+ writeMeta(metaCreationDate, (Meta) element);
+ break;
+ }
+ } catch (IOException e) {
+ return false;
+ }
+ return true;
+ }
+
+ /**
+ * Write the beginning of a new <code>Section</code>
+ *
+ * @param sectionElement The <code>Section</code> be written
+ * @param out The <code>ByteArrayOutputStream</code> to write to
+ *
+ * @throws IOException
+ * @throws DocumentException
+ */
+ private void writeSection(Section sectionElement, ByteArrayOutputStream out) throws IOException, DocumentException {
+ if (sectionElement.type() == Element.CHAPTER) {
+ out.write(escape);
+ out.write(sectionDefaults);
+ writeSectionDefaults(out);
+ }
+ if (sectionElement.title() != null) {
+ if (writeTOC) {
+ StringBuffer title = new StringBuffer("");
+ for (ListIterator li = sectionElement.title().getChunks().listIterator(); li.hasNext();) {
+ title.append(((Chunk) li.next()).content());
+ }
+ add(new RtfTOCEntry(title.toString(), sectionElement.title().font()));
+ } else {
+ add(sectionElement.title());
+ }
+ out.write(escape);
+ out.write(paragraph);
+ }
+ sectionElement.process(this);
+ if (sectionElement.type() == Element.CHAPTER) {
+ out.write(escape);
+ out.write(section);
+ }
+ if (sectionElement.type() == Element.SECTION) {
+ out.write(escape);
+ out.write(paragraph);
+ }
+ }
+
+ /**
+ * Write the beginning of a new <code>Paragraph</code>
+ *
+ * @param paragraphElement The <code>Paragraph</code> to be written
+ * @param out The <code>ByteArrayOutputStream</code> to write to
+ *
+ * @throws IOException
+ */
+ private void writeParagraph(Paragraph paragraphElement, ByteArrayOutputStream out) throws IOException {
+ out.write(escape);
+ out.write(paragraphDefaults);
+ if (inTable) {
+ out.write(escape);
+ out.write(RtfCell.cellInTable);
+ }
+ switch (paragraphElement.alignment()) {
+ case Element.ALIGN_LEFT:
+ out.write(escape);
+ out.write(alignLeft);
+ break;
+ case Element.ALIGN_RIGHT:
+ out.write(escape);
+ out.write(alignRight);
+ break;
+ case Element.ALIGN_CENTER:
+ out.write(escape);
+ out.write(alignCenter);
+ break;
+ case Element.ALIGN_JUSTIFIED:
+ case Element.ALIGN_JUSTIFIED_ALL:
+ out.write(escape);
+ out.write(alignJustify);
+ break;
+ }
+ out.write(escape);
+ out.write(listIndent);
+ writeInt(out, (int) (paragraphElement.indentationLeft() * TWIPSFACTOR));
+ out.write(escape);
+ out.write(rightIndent);
+ writeInt(out, (int) (paragraphElement.indentationRight() * TWIPSFACTOR));
+ Iterator chunks = paragraphElement.getChunks().iterator();
+ while (chunks.hasNext()) {
+ Chunk ch = (Chunk) chunks.next();
+ ch.setFont(paragraphElement.font().difference(ch.font()));
+ }
+ ByteArrayOutputStream save = content;
+ content = out;
+ paragraphElement.process(this);
+ content = save;
+ if (!inTable) {
+ out.write(escape);
+ out.write(paragraph);
+ }
+ }
+
+ /**
+ * Write a <code>Phrase</code>.
+ *
+ * @param phrase The <code>Phrase</code> item to be written
+ * @param out The <code>ByteArrayOutputStream</code> to write to
+ *
+ * @throws IOException
+ */
+ private void writePhrase(Phrase phrase, ByteArrayOutputStream out) throws IOException {
+ out.write(escape);
+ out.write(paragraphDefaults);
+ if (inTable) {
+ out.write(escape);
+ out.write(RtfCell.cellInTable);
+ }
+ Iterator chunks = phrase.getChunks().iterator();
+ while (chunks.hasNext()) {
+ Chunk ch = (Chunk) chunks.next();
+ ch.setFont(phrase.font().difference(ch.font()));
+ }
+ ByteArrayOutputStream save = content;
+ content = out;
+ phrase.process(this);
+ content = save;
+ }
+
+ /**
+ * Write an <code>Anchor</code>. Anchors are treated like Phrases.
+ *
+ * @param anchor The <code>Chunk</code> item to be written
+ * @param out The <code>ByteArrayOutputStream</code> to write to
+ *
+ * @throws IOException
+ */
+ private void writeAnchor(Anchor anchor, ByteArrayOutputStream out) throws IOException {
+ if (anchor.url() != null) {
+ out.write(openGroup);
+ out.write(escape);
+ out.write(field);
+ out.write(openGroup);
+ out.write(extendedEscape);
+ out.write(fieldContent);
+ out.write(openGroup);
+ out.write(fieldHyperlink);
+ out.write(delimiter);
+ out.write(anchor.url().toString().getBytes());
+ out.write(closeGroup);
+ out.write(closeGroup);
+ out.write(openGroup);
+ out.write(escape);
+ out.write(fieldDisplay);
+ out.write(delimiter);
+ writePhrase(anchor, out);
+ out.write(closeGroup);
+ out.write(closeGroup);
+ } else {
+ writePhrase(anchor, out);
+ }
+ }
+
+ /**
+ * Write a <code>Chunk</code> and all its font properties.
+ *
+ * @param chunk The <code>Chunk</code> item to be written
+ * @param out The <code>ByteArrayOutputStream</code> to write to
+ *
+ * @throws IOException
+ * @throws DocumentException
+ */
+ private void writeChunk(Chunk chunk, ByteArrayOutputStream out) throws IOException, DocumentException {
+ if (chunk instanceof RtfField) {
+ ((RtfField) chunk).write(this, out);
+ } else {
+ if (chunk.getImage() != null) {
+ writeImage(chunk.getImage(), out);
+ } else {
+ writeInitialFontSignature(out, chunk);
+ out.write(filterSpecialChar(chunk.content(), false).getBytes());
+ writeFinishingFontSignature(out, chunk);
+ }
+ }
+ }
+
+
+ protected void writeInitialFontSignature(OutputStream out, Chunk chunk) throws IOException {
+ Font font = chunk.font();
+
+ out.write(escape);
+ out.write(fontNumber);
+ if (!font.getFamilyname().equalsIgnoreCase("unknown")) {
+ writeInt(out, addFont(font));
+ } else {
+ writeInt(out, 0);
+ }
+ out.write(escape);
+ out.write(fontSize);
+ if (font.size() > 0) {
+ writeInt(out, (int) (font.size() * 2));
+ } else {
+ writeInt(out, 20);
+ }
+ out.write(escape);
+ out.write(fontColor);
+ writeInt(out, addColor(font.color()));
+ if (font.isBold()) {
+ out.write(escape);
+ out.write(bold);
+ }
+ if (font.isItalic()) {
+ out.write(escape);
+ out.write(italic);
+ }
+ if (font.isUnderlined()) {
+ out.write(escape);
+ out.write(underline);
+ }
+ if (font.isStrikethru()) {
+ out.write(escape);
+ out.write(strikethrough);
+ }
+
+ /*
+ * Superscript / Subscript added by Scott Dietrich (sdietrich@emlab.com)
+ */
+ if (chunk.getAttributes() != null) {
+ Float f = (Float) chunk.getAttributes().get(Chunk.SUBSUPSCRIPT);
+ if (f != null)
+ if (f.floatValue() > 0) {
+ out.write(escape);
+ out.write(startSuper);
+ } else if (f.floatValue() < 0) {
+ out.write(escape);
+ out.write(startSub);
+ }
+ }
+
+ out.write(delimiter);
+ }
+
+
+ protected void writeFinishingFontSignature(OutputStream out, Chunk chunk) throws IOException {
+ Font font = chunk.font();
+
+ if (font.isBold()) {
+ out.write(escape);
+ out.write(bold);
+ writeInt(out, 0);
+ }
+ if (font.isItalic()) {
+ out.write(escape);
+ out.write(italic);
+ writeInt(out, 0);
+ }
+ if (font.isUnderlined()) {
+ out.write(escape);
+ out.write(underline);
+ writeInt(out, 0);
+ }
+ if (font.isStrikethru()) {
+ out.write(escape);
+ out.write(strikethrough);
+ writeInt(out, 0);
+ }
+
+ /*
+ * Superscript / Subscript added by Scott Dietrich (sdietrich@emlab.com)
+ */
+ if (chunk.getAttributes() != null) {
+ Float f = (Float) chunk.getAttributes().get(Chunk.SUBSUPSCRIPT);
+ if (f != null)
+ if (f.floatValue() != 0) {
+ out.write(escape);
+ out.write(endSuperSub);
+ }
+ }
+ }
+
+ /**
+ * Write a <code>ListItem</code>
+ *
+ * @param listItem The <code>ListItem</code> to be written
+ * @param out The <code>ByteArrayOutputStream</code> to write to
+ *
+ * @throws IOException
+ * @throws DocumentException
+ */
+ private void writeListElement(ListItem listItem, ByteArrayOutputStream out) throws IOException, DocumentException {
+ Iterator chunks = listItem.getChunks().iterator();
+ while (chunks.hasNext()) {
+ Chunk ch = (Chunk) chunks.next();
+ addElement(ch, out);
+ }
+ out.write(escape);
+ out.write(paragraph);
+ }
+
+ /**
+ * Write a <code>List</code>
+ *
+ * @param list The <code>List</code> to be written
+ * @param out The <code>ByteArrayOutputStream</code> to write to
+ *
+ * @throws IOException
+ * @throws DocumentException
+ */
+ private void writeList(com.lowagie.text.List list, ByteArrayOutputStream out) throws IOException, DocumentException {
+ int type = 0;
+ int align = 0;
+ int fontNr = addFont(new Font(Font.SYMBOL, 10, Font.NORMAL, new Color(0, 0, 0)));
+ if (!list.isNumbered()) type = 23;
+ if (listLevel == 0) {
+ maxListLevel = 0;
+ listtable.write(openGroup);
+ listtable.write(escape);
+ listtable.write(listDefinition);
+ int i = getRandomInt();
+ listtable.write(escape);
+ listtable.write(listTemplateID);
+ writeInt(listtable, i);
+ listtable.write(escape);
+ listtable.write(hybridList);
+ listtable.write((byte) '\n');
+ }
+ if (listLevel >= maxListLevel) {
+ maxListLevel++;
+ listtable.write(openGroup);
+ listtable.write(escape);
+ listtable.write(listLevelDefinition);
+ listtable.write(escape);
+ listtable.write(listLevelTypeOld);
+ writeInt(listtable, type);
+ listtable.write(escape);
+ listtable.write(listLevelTypeNew);
+ writeInt(listtable, type);
+ listtable.write(escape);
+ listtable.write(listLevelAlignOld);
+ writeInt(listtable, align);
+ listtable.write(escape);
+ listtable.write(listLevelAlignNew);
+ writeInt(listtable, align);
+ listtable.write(escape);
+ listtable.write(listLevelStartAt);
+ writeInt(listtable, 1);
+ listtable.write(openGroup);
+ listtable.write(escape);
+ listtable.write(listLevelTextDefinition);
+ listtable.write(escape);
+ listtable.write(listLevelTextLength);
+ if (list.isNumbered()) {
+ writeInt(listtable, 2);
+ } else {
+ writeInt(listtable, 1);
+ }
+ listtable.write(escape);
+ if (list.isNumbered()) {
+ listtable.write(listLevelTextStyleNumbers);
+ } else {
+ listtable.write(listLevelTextStyleBullet);
+ }
+ listtable.write(commaDelimiter);
+ listtable.write(closeGroup);
+ listtable.write(openGroup);
+ listtable.write(escape);
+ listtable.write(listLevelNumbersDefinition);
+ if (list.isNumbered()) {
+ listtable.write(delimiter);
+ listtable.write(listLevelNumbers);
+ writeInt(listtable, listLevel + 1);
+ }
+ listtable.write(commaDelimiter);
+ listtable.write(closeGroup);
+ if (!list.isNumbered()) {
+ listtable.write(escape);
+ listtable.write(fontNumber);
+ writeInt(listtable, fontNr);
+ }
+ listtable.write(escape);
+ listtable.write(firstIndent);
+ writeInt(listtable, (int) (list.indentationLeft() * TWIPSFACTOR * -1));
+ listtable.write(escape);
+ listtable.write(listIndent);
+ writeInt(listtable, (int) ((list.indentationLeft() + list.symbolIndent()) * TWIPSFACTOR));
+ listtable.write(escape);
+ listtable.write(rightIndent);
+ writeInt(listtable, (int) (list.indentationRight() * TWIPSFACTOR));
+ listtable.write(escape);
+ listtable.write(tabStop);
+ writeInt(listtable, (int) (list.symbolIndent() * TWIPSFACTOR));
+ listtable.write(closeGroup);
+ listtable.write((byte) '\n');
+ }
+ // Actual List Begin in Content
+ out.write(escape);
+ out.write(paragraphDefaults);
+ out.write(escape);
+ out.write(alignLeft);
+ out.write(escape);
+ out.write(firstIndent);
+ writeInt(out, (int) (list.indentationLeft() * TWIPSFACTOR * -1));
+ out.write(escape);
+ out.write(listIndent);
+ writeInt(out, (int) ((list.indentationLeft() + list.symbolIndent()) * TWIPSFACTOR));
+ out.write(escape);
+ out.write(rightIndent);
+ writeInt(out, (int) (list.indentationRight() * TWIPSFACTOR));
+ out.write(escape);
+ out.write(fontSize);
+ writeInt(out, 20);
+ out.write(escape);
+ out.write(listBegin);
+ writeInt(out, currentListID);
+ if (listLevel > 0) {
+ out.write(escape);
+ out.write(listCurrentLevel);
+ writeInt(out, listLevel);
+ }
+ out.write(openGroup);
+ ListIterator listItems = list.getItems().listIterator();
+ Element listElem;
+ int count = 1;
+ while (listItems.hasNext()) {
+ listElem = (Element) listItems.next();
+ if (listElem.type() == Element.CHUNK) {
+ listElem = new ListItem((Chunk) listElem);
+ }
+ if (listElem.type() == Element.LISTITEM) {
+ out.write(openGroup);
+ out.write(escape);
+ out.write(listTextOld);
+ out.write(escape);
+ out.write(paragraphDefaults);
+ out.write(escape);
+ out.write(fontNumber);
+ if (list.isNumbered()) {
+ writeInt(out, addFont(new Font(Font.TIMES_ROMAN, Font.NORMAL, 10, new Color(0, 0, 0))));
+ } else {
+ writeInt(out, fontNr);
+ }
+ out.write(escape);
+ out.write(firstIndent);
+ writeInt(out, (int) (list.indentationLeft() * TWIPSFACTOR * -1));
+ out.write(escape);
+ out.write(listIndent);
+ writeInt(out, (int) ((list.indentationLeft() + list.symbolIndent()) * TWIPSFACTOR));
+ out.write(escape);
+ out.write(rightIndent);
+ writeInt(out, (int) (list.indentationRight() * TWIPSFACTOR));
+ out.write(delimiter);
+ if (list.isNumbered()) {
+ writeInt(out, count);
+ out.write(".".getBytes());
+ } else {
+ out.write(escape);
+ out.write(listBulletOld);
+ }
+ out.write(escape);
+ out.write(tab);
+ out.write(closeGroup);
+ writeListElement((ListItem) listElem, out);
+ count++;
+ } else if (listElem.type() == Element.LIST) {
+ listLevel++;
+ writeList((com.lowagie.text.List) listElem, out);
+ listLevel--;
+ out.write(escape);
+ out.write(paragraphDefaults);
+ out.write(escape);
+ out.write(alignLeft);
+ out.write(escape);
+ out.write(firstIndent);
+ writeInt(out, (int) (list.indentationLeft() * TWIPSFACTOR * -1));
+ out.write(escape);
+ out.write(listIndent);
+ writeInt(out, (int) ((list.indentationLeft() + list.symbolIndent()) * TWIPSFACTOR));
+ out.write(escape);
+ out.write(rightIndent);
+ writeInt(out, (int) (list.indentationRight() * TWIPSFACTOR));
+ out.write(escape);
+ out.write(fontSize);
+ writeInt(out, 20);
+ out.write(escape);
+ out.write(listBegin);
+ writeInt(out, currentListID);
+ if (listLevel > 0) {
+ out.write(escape);
+ out.write(listCurrentLevel);
+ writeInt(out, listLevel);
+ }
+ }
+ out.write((byte) '\n');
+ }
+ out.write(closeGroup);
+ if (listLevel == 0) {
+ int i = getRandomInt();
+ listtable.write(escape);
+ listtable.write(listID);
+ writeInt(listtable, i);
+ listtable.write(closeGroup);
+ listtable.write((byte) '\n');
+ listoverride.write(openGroup);
+ listoverride.write(escape);
+ listoverride.write(listOverride);
+ listoverride.write(escape);
+ listoverride.write(listID);
+ writeInt(listoverride, i);
+ listoverride.write(escape);
+ listoverride.write(listOverrideCount);
+ writeInt(listoverride, 0);
+ listoverride.write(escape);
+ listoverride.write(listBegin);
+ writeInt(listoverride, currentListID);
+ currentListID++;
+ listoverride.write(closeGroup);
+ listoverride.write((byte) '\n');
+ }
+ out.write(escape);
+ out.write(paragraphDefaults);
+ }
+
+ /**
+ * Write a <code>Table</code>.
+ *
+ * @param table The <code>table</code> to be written
+ * @param out The <code>ByteArrayOutputStream</code> to write to
+ *
+ * Currently no nesting of tables is supported. If a cell contains anything but a Cell Object it is ignored.
+ *
+ * @throws IOException
+ * @throws DocumentException
+ */
+ private void writeTable(Table table, ByteArrayOutputStream out) throws IOException, DocumentException {
+ inTable = true;
+ table.complete();
+ RtfTable rtfTable = new RtfTable(this);
+ rtfTable.importTable(table, pageWidth - marginLeft - marginRight);
+ rtfTable.writeTable(out);
+ inTable = false;
+ }
+
+
+ /**
+ * Write an <code>Image</code>.
+ *
+ * @param image The <code>image</code> to be written
+ * @param out The <code>ByteArrayOutputStream</code> to write to
+ *
+ * At the moment only PNG and JPEG Images are supported.
+ *
+ * @throws IOException
+ * @throws DocumentException
+ */
+ private void writeImage(Image image, ByteArrayOutputStream out) throws IOException, DocumentException {
+ int type = image.getOriginalType();
+ if (!(type == Image.ORIGINAL_JPEG || type == Image.ORIGINAL_BMP
+ || type == Image.ORIGINAL_PNG || type == Image.ORIGINAL_WMF))
+ throw new DocumentException("Only BMP, PNG, WMF and JPEG images are supported by the RTF Writer");
+ switch (image.alignment()) {
+ case Element.ALIGN_LEFT:
+ out.write(escape);
+ out.write(alignLeft);
+ break;
+ case Element.ALIGN_RIGHT:
+ out.write(escape);
+ out.write(alignRight);
+ break;
+ case Element.ALIGN_CENTER:
+ out.write(escape);
+ out.write(alignCenter);
+ break;
+ case Element.ALIGN_JUSTIFIED:
+ out.write(escape);
+ out.write(alignJustify);
+ break;
+ }
+ out.write(openGroup);
+ out.write(extendedEscape);
+ out.write(pictureGroup);
+ out.write(openGroup);
+ out.write(escape);
+ out.write(picture);
+ out.write(escape);
+ switch (type) {
+ case Image.ORIGINAL_JPEG:
+ out.write(pictureJPEG);
+ break;
+ case Image.ORIGINAL_PNG:
+ out.write(picturePNG);
+ break;
+ case Image.ORIGINAL_WMF:
+ case Image.ORIGINAL_BMP:
+ out.write(pictureWMF);
+ break;
+ }
+ out.write(escape);
+ out.write(pictureWidth);
+ writeInt(out, (int) (image.plainWidth() * TWIPSFACTOR));
+ out.write(escape);
+ out.write(pictureHeight);
+ writeInt(out, (int) (image.plainHeight() * TWIPSFACTOR));
+
+
+// For some reason this messes up the intended image size. It makes it too big. Weird
+//
+// out.write(escape);
+// out.write(pictureIntendedWidth);
+// writeInt(out, (int) (image.plainWidth() * twipsFactor));
+// out.write(escape);
+// out.write(pictureIntendedHeight);
+// writeInt(out, (int) (image.plainHeight() * twipsFactor));
+
+
+ if (image.width() > 0) {
+ out.write(escape);
+ out.write(pictureScaleX);
+ writeInt(out, (int) (100 / image.width() * image.plainWidth()));
+ }
+ if (image.height() > 0) {
+ out.write(escape);
+ out.write(pictureScaleY);
+ writeInt(out, (int) (100 / image.height() * image.plainHeight()));
+ }
+ out.write(delimiter);
+ InputStream imgIn;
+ if (type == Image.ORIGINAL_BMP) {
+ imgIn = new ByteArrayInputStream(MetaDo.wrapBMP(image));
+ }
+ else {
+ if (image.getOriginalData() == null) {
+ imgIn = image.url().openStream();
+ } else {
+ imgIn = new ByteArrayInputStream(image.getOriginalData());
+ }
+ if (type == Image.ORIGINAL_WMF) { //remove the placeable header
+ long skipLength = 22;
+ while(skipLength > 0) {
+ skipLength = skipLength - imgIn.skip(skipLength);
+ }
+ }
+ }
+ int buffer = -1;
+ int count = 0;
+ out.write((byte) '\n');
+ while ((buffer = imgIn.read()) != -1) {
+ String helperStr = Integer.toHexString(buffer);
+ if (helperStr.length() < 2) helperStr = "0" + helperStr;
+ out.write(helperStr.getBytes());
+ count++;
+ if (count == 64) {
+ out.write((byte) '\n');
+ count = 0;
+ }
+ }
+ imgIn.close();
+ out.write(closeGroup);
+ out.write(closeGroup);
+ out.write((byte) '\n');
+ }
+
+ /**
+ * Write an <code>Annotation</code>
+ *
+ * @param annotationElement The <code>Annotation</code> to be written
+ * @param out The <code>ByteArrayOutputStream</code> to write to
+ *
+ * @throws IOException
+ */
+ private void writeAnnotation(Annotation annotationElement, ByteArrayOutputStream out) throws IOException {
+ int id = getRandomInt();
+ out.write(openGroup);
+ out.write(extendedEscape);
+ out.write(annotationID);
+ out.write(delimiter);
+ writeInt(out, id);
+ out.write(closeGroup);
+ out.write(openGroup);
+ out.write(extendedEscape);
+ out.write(annotationAuthor);
+ out.write(delimiter);
+ out.write(annotationElement.title().getBytes());
+ out.write(closeGroup);
+ out.write(openGroup);
+ out.write(extendedEscape);
+ out.write(annotation);
+ out.write(escape);
+ out.write(paragraphDefaults);
+ out.write(delimiter);
+ out.write(annotationElement.content().getBytes());
+ out.write(closeGroup);
+ }
+
+ /**
+ * Add a <code>Meta</code> element. It is written to the Inforamtion Group
+ * and merged with the main <code>ByteArrayOutputStream</code> when the
+ * Document is closed.
+ *
+ * @param metaName The type of <code>Meta</code> element to be added
+ * @param meta The <code>Meta</code> element to be added
+ *
+ * Currently only the Meta Elements Author, Subject, Keywords, Title, Producer and CreationDate are supported.
+ *
+ * @throws IOException
+ */
+ private void writeMeta(byte[] metaName, Meta meta) throws IOException {
+ info.write(openGroup);
+ try {
+ info.write(escape);
+ info.write(metaName);
+ info.write(delimiter);
+ if (meta.type() == Meta.CREATIONDATE) {
+ writeFormatedDateTime(meta.content());
+ } else {
+ info.write(meta.content().getBytes());
+ }
+ } finally {
+ info.write(closeGroup);
+ }
+ }
+
+ /**
+ * Writes a date. The date is formated <strong>Year, Month, Day, Hour, Minute, Second</strong>
+ *
+ * @param date The date to be written
+ *
+ * @throws IOException
+ */
+ private void writeFormatedDateTime(String date) throws IOException {
+ Calendar cal = Calendar.getInstance();
+ SimpleDateFormat sdf = new SimpleDateFormat("EEE MMM dd HH:mm:ss zzz yyyy");
+ ParsePosition pp = new ParsePosition(0);
+ Date d = sdf.parse(date, pp);
+ if (d == null) {
+ d = new Date();
+ }
+ cal.setTime(d);
+ info.write(escape);
+ info.write(year);
+ writeInt(info, cal.get(Calendar.YEAR));
+ info.write(escape);
+ info.write(month);
+ writeInt(info, cal.get(Calendar.MONTH));
+ info.write(escape);
+ info.write(day);
+ writeInt(info, cal.get(Calendar.DAY_OF_MONTH));
+ info.write(escape);
+ info.write(hour);
+ writeInt(info, cal.get(Calendar.HOUR_OF_DAY));
+ info.write(escape);
+ info.write(minute);
+ writeInt(info, cal.get(Calendar.MINUTE));
+ info.write(escape);
+ info.write(second);
+ writeInt(info, cal.get(Calendar.SECOND));
+ }
+
+ /**
+ * Add a new <code>Font</code> to the list of fonts. If the <code>Font</code>
+ * already exists in the list of fonts, then it is not added again.
+ *
+ * @param newFont The <code>Font</code> to be added
+ *
+ * @return The index of the <code>Font</code> in the font list
+ */
+ protected int addFont(Font newFont) {
+ int fn = -1;
+
+ for (int i = 0; i < fontList.size(); i++) {
+ if (newFont.getFamilyname().equals(((Font) fontList.get(i)).getFamilyname())) {
+ fn = i;
+ }
+ }
+ if (fn == -1) {
+ fontList.add(newFont);
+ return fontList.size() - 1;
+ }
+ return fn;
+ }
+
+ /**
+ * Add a new <code>Color</code> to the list of colours. If the <code>Color</code>
+ * already exists in the list of colours, then it is not added again.
+ *
+ * @param newColor The <code>Color</code> to be added
+ *
+ * @return The index of the <code>color</code> in the colour list
+ */
+ protected int addColor(Color newColor) {
+ int cn = 0;
+ if (newColor == null) {
+ return cn;
+ }
+ cn = colorList.indexOf(newColor);
+ if (cn == -1) {
+ colorList.add(newColor);
+ return colorList.size() - 1;
+ }
+ return cn;
+ }
+
+ /**
+ * Merge all the different <code>ArrayList</code>s and <code>ByteArrayOutputStream</code>s
+ * to the final <code>ByteArrayOutputStream</code>
+ *
+ * @return <code>true</code> if all information was sucessfully written to the <code>ByteArrayOutputStream</code>
+ */
+ private boolean writeDocument() {
+ try {
+ writeDocumentIntro();
+ writeFontList();
+ os.write((byte) '\n');
+ writeColorList();
+ os.write((byte) '\n');
+ writeList();
+ os.write((byte) '\n');
+ writeInfoGroup();
+ os.write((byte) '\n');
+ writeDocumentFormat();
+ os.write((byte) '\n');
+ ByteArrayOutputStream hf = new ByteArrayOutputStream();
+ writeSectionDefaults(hf);
+ hf.writeTo(os);
+ content.writeTo(os);
+ os.write(closeGroup);
+ return true;
+ } catch (IOException e) {
+ System.err.println(e.getMessage());
+ return false;
+ }
+
+ }
+
+ /** Write the Rich Text file settings
+ * @throws IOException
+ */
+ private void writeDocumentIntro() throws IOException {
+ os.write(openGroup);
+ os.write(escape);
+ os.write(docBegin);
+ os.write(escape);
+ os.write(ansi);
+ os.write(escape);
+ os.write(ansiCodepage);
+ writeInt(os, 1252);
+ os.write((byte)'\n');
+ os.write(escape);
+ os.write(defaultFont);
+ writeInt(os, 0);
+ }
+
+ /**
+ * Write the font list to the final <code>ByteArrayOutputStream</code>
+ * @throws IOException
+ */
+ private void writeFontList() throws IOException {
+ Font fnt;
+
+ os.write(openGroup);
+ os.write(escape);
+ os.write(fontTable);
+ for (int i = 0; i < fontList.size(); i++) {
+ fnt = (Font) fontList.get(i);
+ os.write(openGroup);
+ os.write(escape);
+ os.write(fontNumber);
+ writeInt(os, i);
+ os.write(escape);
+ switch (Font.getFamilyIndex(fnt.getFamilyname())) {
+ case Font.COURIER:
+ os.write(fontModern);
+ os.write(escape);
+ os.write(fontCharset);
+ writeInt(os, 0);
+ os.write(delimiter);
+ os.write(fontCourier);
+ break;
+ case Font.HELVETICA:
+ os.write(fontSwiss);
+ os.write(escape);
+ os.write(fontCharset);
+ writeInt(os, 0);
+ os.write(delimiter);
+ os.write(fontArial);
+ break;
+ case Font.SYMBOL:
+ os.write(fontRoman);
+ os.write(escape);
+ os.write(fontCharset);
+ writeInt(os, 2);
+ os.write(delimiter);
+ os.write(fontSymbol);
+ break;
+ case Font.TIMES_ROMAN:
+ os.write(fontRoman);
+ os.write(escape);
+ os.write(fontCharset);
+ writeInt(os, 0);
+ os.write(delimiter);
+ os.write(fontTimesNewRoman);
+ break;
+ case Font.ZAPFDINGBATS:
+ os.write(fontTech);
+ os.write(escape);
+ os.write(fontCharset);
+ writeInt(os, 0);
+ os.write(delimiter);
+ os.write(fontWindings);
+ break;
+ default:
+ os.write(fontRoman);
+ os.write(escape);
+ os.write(fontCharset);
+ writeInt(os, 0);
+ os.write(delimiter);
+ os.write(filterSpecialChar(fnt.getFamilyname(), true).getBytes());
+ }
+ os.write(commaDelimiter);
+ os.write(closeGroup);
+ }
+ os.write(closeGroup);
+ }
+
+ /**
+ * Write the colour list to the final <code>ByteArrayOutputStream</code>
+ * @throws IOException
+ */
+ private void writeColorList() throws IOException {
+ Color color = null;
+
+ os.write(openGroup);
+ os.write(escape);
+ os.write(colorTable);
+ for (int i = 0; i < colorList.size(); i++) {
+ color = (Color) colorList.get(i);
+ os.write(escape);
+ os.write(colorRed);
+ writeInt(os, color.getRed());
+ os.write(escape);
+ os.write(colorGreen);
+ writeInt(os, color.getGreen());
+ os.write(escape);
+ os.write(colorBlue);
+ writeInt(os, color.getBlue());
+ os.write(commaDelimiter);
+ }
+ os.write(closeGroup);
+ }
+
+ /**
+ * Write the Information Group to the final <code>ByteArrayOutputStream</code>
+ * @throws IOException
+ */
+ private void writeInfoGroup() throws IOException {
+ os.write(openGroup);
+ os.write(escape);
+ os.write(infoBegin);
+ info.writeTo(os);
+ os.write(closeGroup);
+ }
+
+ /**
+ * Write the listtable and listoverridetable to the final <code>ByteArrayOutputStream</code>
+ * @throws IOException
+ */
+ private void writeList() throws IOException {
+ listtable.write(closeGroup);
+ listoverride.write(closeGroup);
+ listtable.writeTo(os);
+ os.write((byte) '\n');
+ listoverride.writeTo(os);
+ }
+
+ /**
+ * Write an integer
+ *
+ * @param out The <code>OuputStream</code> to which the <code>int</code> value is to be written
+ * @param i The <code>int</code> value to be written
+ * @throws IOException
+ */
+ public final static void writeInt(OutputStream out, int i) throws IOException {
+ out.write(Integer.toString(i).getBytes());
+ }
+
+ /**
+ * Get a random integer.
+ * This returns a <b>unique</b> random integer to be used with listids.
+ *
+ * @return Random <code>int</code> value.
+ */
+ private int getRandomInt() {
+ boolean ok = false;
+ Integer newInt = null;
+ Integer oldInt = null;
+ while (!ok) {
+ newInt = new Integer((int) (Math.random() * Integer.MAX_VALUE));
+ ok = true;
+ for (int i = 0; i < listIds.size(); i++) {
+ oldInt = (Integer) listIds.get(i);
+ if (oldInt.equals(newInt)) {
+ ok = true;
+ }
+ }
+ }
+ listIds.add(newInt);
+ return newInt.intValue();
+ }
+
+ /**
+ * Write the current header and footer to a <code>ByteArrayOutputStream</code>
+ *
+ * @param os The <code>ByteArrayOutputStream</code> to which the header and footer will be written.
+ * @throws IOException
+ */
+ public void writeHeadersFooters(ByteArrayOutputStream os) throws IOException {
+ if (this.footer instanceof RtfHeaderFooters) {
+ RtfHeaderFooters rtfHf = (RtfHeaderFooters) this.footer;
+ HeaderFooter hf = rtfHf.get(RtfHeaderFooters.ALL_PAGES);
+ if (hf != null) {
+ writeHeaderFooter(hf, footerBegin, os);
+ }
+ hf = rtfHf.get(RtfHeaderFooters.LEFT_PAGES);
+ if (hf != null) {
+ writeHeaderFooter(hf, footerlBegin, os);
+ }
+ hf = rtfHf.get(RtfHeaderFooters.RIGHT_PAGES);
+ if (hf != null) {
+ writeHeaderFooter(hf, footerrBegin, os);
+ }
+ hf = rtfHf.get(RtfHeaderFooters.FIRST_PAGE);
+ if (hf != null) {
+ writeHeaderFooter(hf, footerfBegin, os);
+ }
+ } else {
+ writeHeaderFooter(this.footer, footerBegin, os);
+ }
+ if (this.header instanceof RtfHeaderFooters) {
+ RtfHeaderFooters rtfHf = (RtfHeaderFooters) this.header;
+ HeaderFooter hf = rtfHf.get(RtfHeaderFooters.ALL_PAGES);
+ if (hf != null) {
+ writeHeaderFooter(hf, headerBegin, os);
+ }
+ hf = rtfHf.get(RtfHeaderFooters.LEFT_PAGES);
+ if (hf != null) {
+ writeHeaderFooter(hf, headerlBegin, os);
+ }
+ hf = rtfHf.get(RtfHeaderFooters.RIGHT_PAGES);
+ if (hf != null) {
+ writeHeaderFooter(hf, headerrBegin, os);
+ }
+ hf = rtfHf.get(RtfHeaderFooters.FIRST_PAGE);
+ if (hf != null) {
+ writeHeaderFooter(hf, headerfBegin, os);
+ }
+ } else {
+ writeHeaderFooter(this.header, headerBegin, os);
+ }
+ }
+
+ /**
+ * Write a <code>HeaderFooter</code> to a <code>ByteArrayOutputStream</code>
+ *
+ * @param headerFooter The <code>HeaderFooter</code> object to be written.
+ * @param hfType The type of header or footer to be added.
+ * @param target The <code>ByteArrayOutputStream</code> to which the <code>HeaderFooter</code> will be written.
+ * @throws IOException
+ */
+ private void writeHeaderFooter(HeaderFooter headerFooter, byte[] hfType, ByteArrayOutputStream target) throws IOException {
+ inHeaderFooter = true;
+ try {
+ target.write(openGroup);
+ target.write(escape);
+ target.write(hfType);
+ target.write(delimiter);
+ if (headerFooter != null) {
+ if (headerFooter instanceof RtfHeaderFooter && ((RtfHeaderFooter) headerFooter).content() != null) {
+ this.addElement(((RtfHeaderFooter) headerFooter).content(), target);
+ } else {
+ Paragraph par = new Paragraph();
+ par.setAlignment(headerFooter.alignment());
+ if (headerFooter.getBefore() != null) {
+ par.add(headerFooter.getBefore());
+ }
+ if (headerFooter.isNumbered()) {
+ par.add(new RtfPageNumber("", headerFooter.getBefore().font()));
+ }
+ if (headerFooter.getAfter() != null) {
+ par.add(headerFooter.getAfter());
+ }
+ this.addElement(par, target);
+ }
+ }
+ target.write(closeGroup);
+ } catch (DocumentException e) {
+ throw new IOException("DocumentException - " + e.getMessage());
+ }
+ inHeaderFooter = false;
+ }
+
+ /**
+ * Write the <code>Document</code>'s Paper and Margin Size
+ * to the final <code>ByteArrayOutputStream</code>
+ * @throws IOException
+ */
+ private void writeDocumentFormat() throws IOException {
+// os.write(openGroup);
+ os.write(escape);
+ os.write(rtfPaperWidth);
+ writeInt(os, pageWidth);
+ os.write(escape);
+ os.write(rtfPaperHeight);
+ writeInt(os, pageHeight);
+ os.write(escape);
+ os.write(rtfMarginLeft);
+ writeInt(os, marginLeft);
+ os.write(escape);
+ os.write(rtfMarginRight);
+ writeInt(os, marginRight);
+ os.write(escape);
+ os.write(rtfMarginTop);
+ writeInt(os, marginTop);
+ os.write(escape);
+ os.write(rtfMarginBottom);
+ writeInt(os, marginBottom);
+// os.write(closeGroup);
+ }
+
+ /**
+ * Initialise all helper classes.
+ * Clears alls lists, creates new <code>ByteArrayOutputStream</code>'s
+ */
+ private void initDefaults() {
+ fontList.clear();
+ colorList.clear();
+ info = new ByteArrayOutputStream();
+ content = new ByteArrayOutputStream();
+ listtable = new ByteArrayOutputStream();
+ listoverride = new ByteArrayOutputStream();
+ document.addProducer();
+ document.addCreationDate();
+ addFont(new Font(Font.TIMES_ROMAN, 10, Font.NORMAL));
+ addColor(new Color(0, 0, 0));
+ addColor(new Color(255, 255, 255));
+ listIds = new ArrayList();
+ try {
+ listtable.write(openGroup);
+ listtable.write(extendedEscape);
+ listtable.write(listtableGroup);
+ listtable.write((byte) '\n');
+ listoverride.write(openGroup);
+ listoverride.write(extendedEscape);
+ listoverride.write(listoverridetableGroup);
+ listoverride.write((byte) '\n');
+ } catch (IOException e) {
+ System.err.println("InitDefaultsError" + e);
+ }
+ }
+
+ /**
+ * Writes the default values for the current Section
+ *
+ * @param out The <code>ByteArrayOutputStream</code> to be written to
+ * @throws IOException
+ */
+ private void writeSectionDefaults(ByteArrayOutputStream out) throws IOException {
+ if (header instanceof RtfHeaderFooters || footer instanceof RtfHeaderFooters) {
+ RtfHeaderFooters rtfHeader = (RtfHeaderFooters) header;
+ RtfHeaderFooters rtfFooter = (RtfHeaderFooters) footer;
+ if ((rtfHeader != null && (rtfHeader.get(RtfHeaderFooters.LEFT_PAGES) != null || rtfHeader.get(RtfHeaderFooters.RIGHT_PAGES) != null)) || (rtfFooter != null && (rtfFooter.get(RtfHeaderFooters.LEFT_PAGES) != null || rtfFooter.get(RtfHeaderFooters.RIGHT_PAGES) != null))) {
+ out.write(escape);
+ out.write(facingPages);
+ }
+ }
+ if (hasTitlePage) {
+ out.write(escape);
+ out.write(titlePage);
+ }
+ writeHeadersFooters(out);
+ if (landscape) {
+ //out.write(escape);
+ //out.write(landscapeTag1);
+ out.write(escape);
+ out.write(landscapeTag2);
+ out.write(escape);
+ out.write(sectionPageWidth);
+ writeInt(out, pageWidth);
+ out.write(escape);
+ out.write(sectionPageHeight);
+ writeInt(out, pageHeight);
+ } else {
+ out.write(escape);
+ out.write(sectionPageWidth);
+ writeInt(out, pageWidth);
+ out.write(escape);
+ out.write(sectionPageHeight);
+ writeInt(out, pageHeight);
+ }
+ }
+
+ /**
+ * This method tries to fit the <code>Rectangle pageSize</code> to one of the predefined PageSize rectangles.
+ * If a match is found the pageWidth and pageHeight will be set according to values determined from files
+ * generated by MS Word2000 and OpenOffice 641. If no match is found the method will try to match the rotated
+ * Rectangle by calling itself with the parameter rotate set to true.
+ * @param pageSize a rectangle defining the size of the page
+ * @param rotate portrait or lanscape?
+ * @return true if the format parsing succeeded
+ */
+ private boolean parseFormat(Rectangle pageSize, boolean rotate) {
+ if (rotate) {
+ pageSize = pageSize.rotate();
+ }
+ if (rectEquals(pageSize, PageSize.A3)) {
+ pageWidth = 16837;
+ pageHeight = 23811;
+ landscape = rotate;
+ return true;
+ }
+ if (rectEquals(pageSize, PageSize.A4)) {
+ pageWidth = 11907;
+ pageHeight = 16840;
+ landscape = rotate;
+ return true;
+ }
+ if (rectEquals(pageSize, PageSize.A5)) {
+ pageWidth = 8391;
+ pageHeight = 11907;
+ landscape = rotate;
+ return true;
+ }
+ if (rectEquals(pageSize, PageSize.A6)) {
+ pageWidth = 5959;
+ pageHeight = 8420;
+ landscape = rotate;
+ return true;
+ }
+ if (rectEquals(pageSize, PageSize.B4)) {
+ pageWidth = 14570;
+ pageHeight = 20636;
+ landscape = rotate;
+ return true;
+ }
+ if (rectEquals(pageSize, PageSize.B5)) {
+ pageWidth = 10319;
+ pageHeight = 14572;
+ landscape = rotate;
+ return true;
+ }
+ if (rectEquals(pageSize, PageSize.HALFLETTER)) {
+ pageWidth = 7927;
+ pageHeight = 12247;
+ landscape = rotate;
+ return true;
+ }
+ if (rectEquals(pageSize, PageSize.LETTER)) {
+ pageWidth = 12242;
+ pageHeight = 15842;
+ landscape = rotate;
+ return true;
+ }
+ if (rectEquals(pageSize, PageSize.LEGAL)) {
+ pageWidth = 12252;
+ pageHeight = 20163;
+ landscape = rotate;
+ return true;
+ }
+ if (!rotate && parseFormat(pageSize, true)) {
+ int x = pageWidth;
+ pageWidth = pageHeight;
+ pageHeight = x;
+ return true;
+ }
+ return false;
+ }
+
+ /**
+ * This method compares to Rectangles. They are considered equal if width and height are the same
+ * @param rect1
+ * @param rect2
+ * @return true if rect1 and rect2 represent the same rectangle
+ */
+ private boolean rectEquals(Rectangle rect1, Rectangle rect2) {
+ return (rect1.width() == rect2.width()) && (rect1.height() == rect2.height());
+ }
+
+ /**
+ * Returns whether we are currently writing a header or footer
+ *
+ * @return the value of inHeaderFooter
+ */
+ public boolean writingHeaderFooter() {
+ return inHeaderFooter;
+ }
+
+ /**
+ * Replaces special characters with their unicode values
+ *
+ * @param str The original <code>String</code>
+ * @param useHex
+ * @return The converted String
+ */
+ public final static String filterSpecialChar(String str, boolean useHex) {
+ int length = str.length();
+ int z = (int) 'z';
+ StringBuffer ret = new StringBuffer(length);
+ for (int i = 0; i < length; i++) {
+ char ch = str.charAt(i);
+
+ if (ch == '\\') {
+ ret.append("\\\\");
+ } else if (ch == '\n') {
+ ret.append("\\par ");
+ } else if (((int) ch) > z) {
+ if(useHex) {
+ ret.append("\\\'").append(Long.toHexString((long) ch));
+ } else {
+ ret.append("\\u").append((long) ch).append('?');
+ }
+ } else {
+ ret.append(ch);
+ }
+ }
+ String s = ret.toString();
+ if(s.indexOf("$newpage$") >= 0) {
+ String before = s.substring(0, s.indexOf("$newpage$"));
+ String after = s.substring(s.indexOf("$newpage$") + 9);
+ ret = new StringBuffer(before);
+ ret.append("\\page\\par ");
+ ret.append(after);
+ return ret.toString();
+ }
+ return s;
+ }
+
+ private void addHeaderFooterFontColor(HeaderFooter hf) {
+ if(hf instanceof RtfHeaderFooter) {
+ RtfHeaderFooter rhf = (RtfHeaderFooter) hf;
+ if(rhf.content() instanceof Chunk) {
+ addFont(((Chunk) rhf.content()).font());
+ addColor(((Chunk) rhf.content()).font().color());
+ } else if(rhf.content() instanceof Phrase) {
+ addFont(((Phrase) rhf.content()).font());
+ addColor(((Phrase) rhf.content()).font().color());
+ }
+ }
+ if(hf.getBefore() != null) {
+ addFont(hf.getBefore().font());
+ addColor(hf.getBefore().font().color());
+ }
+ if(hf.getAfter() != null) {
+ addFont(hf.getAfter().font());
+ addColor(hf.getAfter().font().color());
+ }
+ }
+
+ private void processHeaderFooter(HeaderFooter hf) {
+ if(hf != null) {
+ if(hf instanceof RtfHeaderFooters) {
+ RtfHeaderFooters rhf = (RtfHeaderFooters) hf;
+ if(rhf.get(RtfHeaderFooters.ALL_PAGES) != null) {
+ addHeaderFooterFontColor(rhf.get(RtfHeaderFooters.ALL_PAGES));
+ }
+ if(rhf.get(RtfHeaderFooters.LEFT_PAGES) != null) {
+ addHeaderFooterFontColor(rhf.get(RtfHeaderFooters.LEFT_PAGES));
+ }
+ if(rhf.get(RtfHeaderFooters.RIGHT_PAGES) != null) {
+ addHeaderFooterFontColor(rhf.get(RtfHeaderFooters.RIGHT_PAGES));
+ }
+ if(rhf.get(RtfHeaderFooters.FIRST_PAGE) != null) {
+ addHeaderFooterFontColor(rhf.get(RtfHeaderFooters.FIRST_PAGE));
+ }
+ } else {
+ addHeaderFooterFontColor(hf);
+ }
+ }
+ }
+
+ /**
+ * @see com.lowagie.text.DocListener#setMarginMirroring(boolean)
+ */
+ public boolean setMarginMirroring(boolean MarginMirroring) {
+ return false;
+ }
+
+}
+
diff --git a/src/main/java/com/lowagie/text/rtf/RtfWriter2.java b/src/main/java/com/lowagie/text/rtf/RtfWriter2.java new file mode 100644 index 0000000..40040df --- /dev/null +++ b/src/main/java/com/lowagie/text/rtf/RtfWriter2.java @@ -0,0 +1,268 @@ +/*
+ * $Id: RtfWriter2.java,v 1.11 2005/09/11 19:09:57 hallm Exp $
+ * $Name: $
+ *
+ * Copyright 2001, 2002, 2003, 2004 by Mark Hall
+ *
+ * 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.rtf;
+
+import com.lowagie.text.*;
+import com.lowagie.text.rtf.document.RtfDocument;
+import com.lowagie.text.rtf.document.RtfDocumentSettings;
+import com.lowagie.text.rtf.text.RtfNewPage;
+
+import java.io.IOException;
+import java.io.OutputStream;
+
+/**
+ * The RtfWriter allows the creation of rtf documents via the iText system
+ *
+ * Version: $Id: RtfWriter2.java,v 1.11 2005/09/11 19:09:57 hallm Exp $
+ * @author Mark Hall (mhall@edu.uni-klu.ac.at)
+ */
+public class RtfWriter2 extends DocWriter implements DocListener {
+ /**
+ * The RtfDocument this RtfWriter is creating
+ */
+ RtfDocument rtfDoc = null;
+
+ /**
+ * Constructs a new RtfWriter that listens to the specified Document and
+ * writes its output to the OutputStream.
+ *
+ * @param doc The Document that this RtfWriter listens to
+ * @param os The OutputStream to write to
+ */
+ protected RtfWriter2(Document doc, OutputStream os) {
+ super(doc, os);
+ doc.addDocListener(this);
+ rtfDoc = new RtfDocument();
+ }
+
+ /**
+ * Static method to generate RtfWriters
+ *
+ * @param doc The Document that this RtfWriter listens to
+ * @param os The OutputStream to write to
+ * @return The new RtfWriter
+ */
+ public static RtfWriter2 getInstance(Document doc, OutputStream os) {
+ return new RtfWriter2(doc, os);
+ }
+
+ /**
+ * Sets the header to use
+ *
+ * @param hf The HeaderFooter to use
+ */
+ public void setHeader(HeaderFooter hf) {
+ this.rtfDoc.getDocumentHeader().setHeader(hf);
+ }
+
+ /**
+ * Resets the header
+ */
+ public void resetHeader() {
+ this.rtfDoc.getDocumentHeader().setHeader(null);
+ }
+
+ /**
+ * Sets the footer to use
+ *
+ * @param hf The HeaderFooter to use
+ */
+ public void setFooter(HeaderFooter hf) {
+ this.rtfDoc.getDocumentHeader().setFooter(hf);
+ }
+
+ /**
+ * Resets the footer
+ */
+ public void resetFooter() {
+ this.rtfDoc.getDocumentHeader().setFooter(null);
+ }
+
+ /**
+ * This method is not supported in the RtfWriter
+ * @param i Unused
+ */
+ public void setPageCount(int i) {}
+
+ /**
+ * This method is not supported in the RtfWriter
+ */
+ public void resetPageCount() {}
+
+ /**
+ * This method is not supported in the RtfWriter
+ *
+ * @param wm Unused
+ * @return <code>false</code>
+ */
+ public boolean add(Watermark wm) { return false; }
+
+ /**
+ * This method is not supported in the RtfWriter
+ */
+ public void removeWatermark() {}
+
+ /**
+ * This method is not supported in the RtfWriter
+ */
+ public void clearTextWrap() {}
+
+ /**
+ * Opens the RtfDocument
+ */
+ public void open() {
+ }
+
+ /**
+ * Closes the RtfDocument. This causes the document to be written
+ * to the specified OutputStream
+ */
+ public void close() {
+ try {
+ os.write(rtfDoc.writeDocument());
+ if(this.closeStream) {
+ os.close();
+ }
+ } catch(IOException ioe) {
+ ioe.printStackTrace();
+ }
+ this.rtfDoc = new RtfDocument();
+ }
+
+ /**
+ * Adds an Element to the Document
+ *
+ * @param element The element to be added
+ * @return <code>false</code>
+ * @throws DocumentException
+ */
+ public boolean add(Element element) throws DocumentException {
+ if (pause) {
+ return false;
+ }
+ RtfBasicElement rtfElement = rtfDoc.getMapper().mapElement(element);
+ if(rtfElement != null) {
+ rtfDoc.add(rtfElement);
+ return true;
+ } else {
+ return false;
+ }
+ }
+
+ /**
+ * Adds a page break
+ *
+ * @return <code>false</code>
+ */
+ public boolean newPage() {
+ rtfDoc.add(new RtfNewPage(rtfDoc));
+ return true;
+ }
+
+ /**
+ * Sets the page margins
+ *
+ * @param left The left margin
+ * @param right The right margin
+ * @param top The top margin
+ * @param bottom The bottom margin
+ * @return <code>false</code>
+ */
+ public boolean setMargins(float left, float right, float top, float bottom) {
+ rtfDoc.getDocumentHeader().getPageSetting().setMarginLeft((int) (left * RtfElement.TWIPS_FACTOR));
+ rtfDoc.getDocumentHeader().getPageSetting().setMarginRight((int) (right * RtfElement.TWIPS_FACTOR));
+ rtfDoc.getDocumentHeader().getPageSetting().setMarginTop((int) (top * RtfElement.TWIPS_FACTOR));
+ rtfDoc.getDocumentHeader().getPageSetting().setMarginBottom((int) (bottom * RtfElement.TWIPS_FACTOR));
+ return true;
+ }
+
+ /**
+ * Sets the size of the page
+ *
+ * @param rect A Rectangle representing the page
+ * @return <code>false</code>
+ */
+ public boolean setPageSize(Rectangle rect) {
+ rtfDoc.getDocumentHeader().getPageSetting().setPageSize(rect);
+ return true;
+ }
+
+ /**
+ * Whether to automagically generate table of contents entries when
+ * adding Chapters or Sections.
+ *
+ * @param autogenerate Whether to automatically generate TOC entries
+ */
+ public void setAutogenerateTOCEntries(boolean autogenerate) {
+ this.rtfDoc.setAutogenerateTOCEntries(autogenerate);
+ }
+
+ /**
+ * Sets the rtf data cache style to use. Valid values are given in the
+ * RtfDataCache class.
+ *
+ * @param dataCacheStyle The style to use.
+ * @throws DocumentException If data has already been written into the data cache.
+ * @throws IOException If the disk cache could not be initialised.
+ */
+ public void setDataCacheStyle(int dataCacheStyle) throws DocumentException, IOException {
+ this.rtfDoc.setDataCacheStyle(dataCacheStyle);
+ }
+
+ /**
+ * Gets the RtfDocumentSettings that specify how the rtf document is generated.
+ *
+ * @return The current RtfDocumentSettings.
+ */
+ public RtfDocumentSettings getDocumentSettings() {
+ return this.rtfDoc.getDocumentSettings();
+ }
+}
diff --git a/src/main/java/com/lowagie/text/rtf/document/RtfCodePage.java b/src/main/java/com/lowagie/text/rtf/document/RtfCodePage.java new file mode 100644 index 0000000..e88a942 --- /dev/null +++ b/src/main/java/com/lowagie/text/rtf/document/RtfCodePage.java @@ -0,0 +1,102 @@ +/*
+ * $Id: RtfCodePage.java,v 1.16 2005/05/04 14:33:53 blowagie Exp $
+ * $Name: $
+ *
+ * Copyright 2003, 2004 by Mark Hall
+ *
+ * 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.rtf.document;
+
+import com.lowagie.text.rtf.RtfElement;
+import com.lowagie.text.rtf.RtfExtendedElement;
+
+import java.io.IOException;
+import java.io.ByteArrayOutputStream;
+
+/**
+ * The RtfCodePage class allows different code pages to be used in the rtf document.
+ * Currently always ansi / ansicpg1252
+ *
+ * Version: $Id: RtfCodePage.java,v 1.16 2005/05/04 14:33:53 blowagie Exp $
+ * @author Mark Hall (mhall@edu.uni-klu.ac.at)
+ */
+public class RtfCodePage extends RtfElement implements RtfExtendedElement {
+ /**
+ * Constant for ansi encoded rtf documents
+ */
+ private static final byte[] ANSI = "\\ansi".getBytes();
+ /**
+ * Constant for the ansi codepage
+ */
+ private static final byte[] ANSI_CODEPAGE = "\\ansicpg".getBytes();
+
+ /**
+ * Construct an RtfCodePage
+ *
+ * @param doc The RtfDocument this RtfCodePage belongs to
+ */
+ public RtfCodePage(RtfDocument doc) {
+ super(doc);
+ }
+
+ /**
+ * Writes the selected codepage to a byte array
+ *
+ * @return Byte array with the current codepage
+ */
+ public byte[] writeDefinition() {
+ ByteArrayOutputStream result = new ByteArrayOutputStream();
+ try {
+ result.write(ANSI);
+ result.write(ANSI_CODEPAGE);
+ result.write(intToByteArray(1252));
+ result.write((byte)'\n');
+ } catch(IOException ioe) {
+ ioe.printStackTrace();
+ }
+ return result.toByteArray();
+ }
+}
diff --git a/src/main/java/com/lowagie/text/rtf/document/RtfDocument.java b/src/main/java/com/lowagie/text/rtf/document/RtfDocument.java new file mode 100644 index 0000000..63f0321 --- /dev/null +++ b/src/main/java/com/lowagie/text/rtf/document/RtfDocument.java @@ -0,0 +1,301 @@ +/*
+ * $Id: RtfDocument.java,v 1.16 2005/12/24 13:14:59 hallm Exp $
+ * $Name: $
+ *
+ * Copyright 2003, 2004, 2005 by Mark Hall
+ *
+ * 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.rtf.document;
+
+import com.lowagie.text.DocumentException;
+import com.lowagie.text.rtf.RtfBasicElement;
+import com.lowagie.text.rtf.RtfElement;
+import com.lowagie.text.rtf.RtfMapper;
+import com.lowagie.text.rtf.document.output.RtfDataCache;
+import com.lowagie.text.rtf.document.output.RtfDiskCache;
+import com.lowagie.text.rtf.document.output.RtfMemoryCache;
+import com.lowagie.text.rtf.graphic.RtfImage;
+
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.util.ArrayList;
+
+/**
+ * The RtfDocument stores all document related data and also the main data stream.
+ * INTERNAL CLASS - NOT TO BE USED DIRECTLY
+ *
+ * Version: $Id: RtfDocument.java,v 1.16 2005/12/24 13:14:59 hallm Exp $
+ * @author Mark Hall (mhall@edu.uni-klu.ac.at)
+ * @author Todd Bush (Todd.Bush@canopysystems.com) [Tab support]
+ */
+public class RtfDocument extends RtfElement {
+ /**
+ * Stores the actual document data
+ */
+ private RtfDataCache data = null;
+ /**
+ * The RtfMapper to use in this RtfDocument
+ */
+ private RtfMapper mapper = null;
+ /**
+ * The RtfDocumentHeader that handles all document header methods
+ */
+ private RtfDocumentHeader documentHeader = null;
+ /**
+ * Stores integers that have been generated as unique random numbers
+ */
+ private ArrayList previousRandomInts = null;
+ /**
+ * Whether to automatically generate TOC entries for Chapters and Sections. Defaults to false
+ */
+ private boolean autogenerateTOCEntries = false;
+ /**
+ * Whether data has been written to the RtfDataCache.
+ */
+ private boolean dataWritten = false;
+ /**
+ * The RtfDocumentSettings for this RtfDocument.
+ */
+ private RtfDocumentSettings documentSettings = null;
+ /**
+ * The last RtfBasicElement that was added directly to the RtfDocument.
+ */
+ private RtfBasicElement lastElementWritten = null;
+
+ /**
+ * Constant for the Rtf document start
+ */
+ private static final byte[] RTF_DOCUMENT = "\\rtf1".getBytes();
+
+ /**
+ * The default constructor for a RtfDocument
+ */
+ public RtfDocument() {
+ super(null);
+ data = new RtfMemoryCache();
+ mapper = new RtfMapper(this);
+ documentHeader = new RtfDocumentHeader(this);
+ documentHeader.init();
+ previousRandomInts = new ArrayList();
+ this.documentSettings = new RtfDocumentSettings(this);
+ }
+
+ /**
+ * Writes the document
+ *
+ * @return A byte array containing the complete rtf document
+ */
+ public byte[] writeDocument() {
+ ByteArrayOutputStream docStream = new ByteArrayOutputStream();
+ try {
+ docStream.write(OPEN_GROUP);
+ docStream.write(RtfDocument.RTF_DOCUMENT);
+ docStream.write(documentHeader.write());
+ data.writeTo(docStream);
+ docStream.write(CLOSE_GROUP);
+ } catch(IOException ioe) {
+ ioe.printStackTrace();
+ }
+ return docStream.toByteArray();
+ }
+
+ /**
+ * Adds an element to the rtf document
+ *
+ * @param element The element to add
+ */
+ public void add(RtfBasicElement element) {
+ try {
+ if(element instanceof RtfInfoElement) {
+ this.documentHeader.addInfoElement((RtfInfoElement) element);
+ } else {
+ this.dataWritten = true;
+ if(element instanceof RtfImage) {
+ ((RtfImage) element).setTopLevelElement(true);
+ }
+ data.getOutputStream().write(element.write());
+ this.lastElementWritten = element;
+ }
+ } catch(IOException ioe) {
+ ioe.printStackTrace();
+ }
+ }
+
+ /**
+ * Gets the RtfMapper object of this RtfDocument
+ *
+ * @return The RtfMapper
+ */
+ public RtfMapper getMapper() {
+ return mapper;
+ }
+
+ /**
+ * Generates a random integer that is unique with respect to the document.
+ *
+ * @return A random int
+ */
+ public int getRandomInt() {
+ Integer newInt = null;
+ do {
+ newInt = new Integer((int) (Math.random() * Integer.MAX_VALUE));
+ } while(previousRandomInts.contains(newInt));
+ previousRandomInts.add(newInt);
+ return newInt.intValue();
+ }
+
+ /**
+ * Gets the RtfDocumentHeader of this RtfDocument
+ *
+ * @return The RtfDocumentHeader of this RtfDocument
+ */
+ public RtfDocumentHeader getDocumentHeader() {
+ return this.documentHeader;
+ }
+
+ /**
+ * Replaces special characters with their unicode values
+ * @param str The original <code>String</code>
+ * @param useHex indicated if the hexadecimal value has to be used
+ * @param softLineBreaks whether to use soft line breaks instead of default hard ones.
+ *
+ * @return The converted String
+ */
+ public String filterSpecialChar(String str, boolean useHex, boolean softLineBreaks) {
+ int length = str.length();
+ int z = (int) 'z';
+ StringBuffer ret = new StringBuffer(length);
+ for (int i = 0; i < length; i++) {
+ char ch = str.charAt(i);
+
+ if (ch == '\\') {
+ ret.append("\\\\");
+ } else if (ch == '\n') {
+ if(softLineBreaks) {
+ ret.append("\\line ");
+ } else {
+ ret.append("\\par ");
+ }
+ } else if (ch == '\t') {
+ ret.append("\\tab ");
+ } else if (((int) ch) > z && this.documentSettings.isAlwaysUseUnicode()) {
+ if(useHex) {
+ ret.append("\\\'").append(Long.toHexString((long) ch));
+ } else {
+ ret.append("\\u").append((long) ch).append('?');
+ }
+ } else {
+ ret.append(ch);
+ }
+ }
+ String s = ret.toString();
+ if(s.indexOf("$newpage$") >= 0) {
+ String before = s.substring(0, s.indexOf("$newpage$"));
+ String after = s.substring(s.indexOf("$newpage$") + 9);
+ ret = new StringBuffer(before);
+ ret.append("\\page\\par ");
+ ret.append(after);
+ return ret.toString();
+ }
+ return s;
+ }
+
+ /**
+ * Whether to automagically generate table of contents entries when
+ * adding Chapters or Sections.
+ *
+ * @param autogenerate Whether to automatically generate TOC entries
+ */
+ public void setAutogenerateTOCEntries(boolean autogenerate) {
+ this.autogenerateTOCEntries = autogenerate;
+ }
+
+ /**
+ * Get whether to autmatically generate table of contents entries
+ *
+ * @return Wheter to automatically generate TOC entries
+ */
+ public boolean getAutogenerateTOCEntries() {
+ return this.autogenerateTOCEntries;
+ }
+
+ /**
+ * Sets the rtf data cache style to use. Valid values are given in the
+ * RtfDataCache class.
+ *
+ * @param dataCacheStyle The style to use.
+ * @throws DocumentException If data has already been written into the data cache.
+ * @throws IOException If the disk cache could not be initialised.
+ */
+ public void setDataCacheStyle(int dataCacheStyle) throws DocumentException, IOException {
+ if(dataWritten) {
+ throw new DocumentException("Data has already been written into the data cache. You can not change the cache style anymore.");
+ }
+ switch(dataCacheStyle) {
+ case RtfDataCache.CACHE_MEMORY : this.data = new RtfMemoryCache(); break;
+ case RtfDataCache.CACHE_DISK : this.data = new RtfDiskCache(); break;
+ default : this.data = new RtfMemoryCache(); break;
+ }
+ }
+
+ /**
+ * Gets the RtfDocumentSettings that specify how the rtf document is generated.
+ *
+ * @return The current RtfDocumentSettings.
+ */
+ public RtfDocumentSettings getDocumentSettings() {
+ return this.documentSettings;
+ }
+
+ /**
+ * Gets the last RtfBasicElement that was directly added to the RtfDocument.
+ *
+ * @return The last RtfBasicElement that was directly added to the RtfDocument.
+ */
+ public RtfBasicElement getLastElementWritten() {
+ return this.lastElementWritten;
+ }
+}
diff --git a/src/main/java/com/lowagie/text/rtf/document/RtfDocumentHeader.java b/src/main/java/com/lowagie/text/rtf/document/RtfDocumentHeader.java new file mode 100644 index 0000000..1ae8027 --- /dev/null +++ b/src/main/java/com/lowagie/text/rtf/document/RtfDocumentHeader.java @@ -0,0 +1,310 @@ +/*
+ * $Id: RtfDocumentHeader.java,v 1.16 2005/12/24 13:14:59 hallm Exp $
+ * $Name: $
+ *
+ * Copyright 2003, 2004 by Mark Hall
+ *
+ * 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.rtf.document;
+
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+
+import com.lowagie.text.HeaderFooter;
+import com.lowagie.text.rtf.RtfElement;
+import com.lowagie.text.rtf.headerfooter.RtfHeaderFooter;
+import com.lowagie.text.rtf.headerfooter.RtfHeaderFooterGroup;
+import com.lowagie.text.rtf.list.RtfList;
+import com.lowagie.text.rtf.list.RtfListTable;
+import com.lowagie.text.rtf.style.RtfColor;
+import com.lowagie.text.rtf.style.RtfColorList;
+import com.lowagie.text.rtf.style.RtfFont;
+import com.lowagie.text.rtf.style.RtfFontList;
+import com.lowagie.text.rtf.style.RtfParagraphStyle;
+import com.lowagie.text.rtf.style.RtfStylesheetList;
+
+
+/**
+ * The RtfDocumentHeader contains all classes required for the generation of
+ * the document header area.
+ *
+ * @version $Version:$
+ * @author Mark Hall (mhall@edu.uni-klu.ac.at)
+ */
+public class RtfDocumentHeader extends RtfElement {
+ /**
+ * Constant for the title page
+ */
+ private static final byte[] TITLE_PAGE = "\\titlepg".getBytes();
+ /**
+ * Constant for facing pages
+ */
+ private static final byte[] FACING_PAGES = "\\facingp".getBytes();
+
+ /**
+ * The code page to use
+ */
+ private RtfCodePage codePage = null;
+ /**
+ * Stores all the colors used in the document
+ */
+ private RtfColorList colorList = null;
+ /**
+ * Stores all the fonts used in the document
+ */
+ private RtfFontList fontList = null;
+ /**
+ * Manages List tables
+ */
+ private RtfListTable listTable = null;
+ /**
+ * Stores all paragraph styles used in the document.
+ */
+ private RtfStylesheetList stylesheetList = null;
+ /**
+ * The information group with author/subject/keywords/title/producer/creationdate data
+ */
+ private RtfInfoGroup infoGroup = null;
+ /**
+ * The page settings
+ */
+ private RtfPageSetting pageSetting = null;
+ /**
+ * The current RtfHeaderFooterGroup for the header
+ */
+ private RtfHeaderFooterGroup header = null;
+ /**
+ * The current RtfHeaderFooterGroup for the footer
+ */
+ private RtfHeaderFooterGroup footer = null;
+
+ /**
+ * Constructs a RtfDocumentHeader for a RtfDocument
+ *
+ * @param doc The RtfDocument this RtfDocumentHeader belongs to
+ */
+ protected RtfDocumentHeader(RtfDocument doc) {
+ super(doc);
+ }
+
+ /**
+ * Initialises the RtfDocumentHeader.
+ */
+ protected void init() {
+ this.codePage = new RtfCodePage(this.document);
+ this.colorList = new RtfColorList(this.document);
+ this.fontList = new RtfFontList(this.document);
+ this.listTable = new RtfListTable(this.document);
+ this.stylesheetList = new RtfStylesheetList(this.document);
+ this.infoGroup = new RtfInfoGroup(this.document);
+ this.pageSetting = new RtfPageSetting(this.document);
+ this.header = new RtfHeaderFooterGroup(this.document, RtfHeaderFooter.TYPE_HEADER);
+ this.footer = new RtfHeaderFooterGroup(this.document, RtfHeaderFooter.TYPE_FOOTER);
+ }
+
+ /**
+ * Write the contents of the document header area.
+ *
+ * @return A byte array with the contents of the document header area
+ */
+ public byte[] write() {
+ ByteArrayOutputStream result = new ByteArrayOutputStream();
+ try {
+ result.write(this.codePage.writeDefinition());
+ result.write(this.fontList.writeDefinition());
+ result.write(this.colorList.writeDefinition());
+ result.write(this.stylesheetList.writeDefinition());
+ result.write(this.listTable.writeDefinition());
+ result.write(this.infoGroup.write());
+ result.write(this.pageSetting.writeDefinition());
+ result.write(writeSectionDefinition());
+ } catch(IOException ioe) {
+ ioe.printStackTrace();
+ }
+ return result.toByteArray();
+ }
+
+ /**
+ * Writes the section definition data
+ *
+ * @return A byte array with the section definition data
+ */
+ public byte[] writeSectionDefinition() {
+ ByteArrayOutputStream result = new ByteArrayOutputStream();
+ try {
+ if(header.hasTitlePage() || footer.hasTitlePage()) {
+ result.write(TITLE_PAGE);
+ header.setHasTitlePage();
+ footer.setHasTitlePage();
+ }
+ if(header.hasFacingPages() || footer.hasFacingPages()) {
+ result.write(FACING_PAGES);
+ header.setHasFacingPages();
+ footer.setHasFacingPages();
+ }
+ result.write(footer.write());
+ result.write(header.write());
+ result.write(pageSetting.writeSectionDefinition());
+ } catch(IOException ioe) {
+ ioe.printStackTrace();
+ }
+ return result.toByteArray();
+ }
+
+ /**
+ * Gets the number of the specified RtfFont
+ *
+ * @param font The RtfFont for which to get the number
+ * @return The number of the font
+ */
+ public int getFontNumber(RtfFont font) {
+ return this.fontList.getFontNumber(font);
+ }
+
+ /**
+ * Gets the number of the specified RtfColor
+ *
+ * @param color The RtfColor for which to get the number
+ * @return The number of the color
+ */
+ public int getColorNumber(RtfColor color) {
+ return this.colorList.getColorNumber(color);
+ }
+
+ /**
+ * Gets the number of the specified RtfList
+ *
+ * @param list The RtfList for which to get the number
+ * @return The number of the list
+ */
+ public int getListNumber(RtfList list) {
+ return this.listTable.getListNumber(list);
+ }
+
+ /**
+ * Gets the RtfParagraphStyle with the given style name.
+ *
+ * @param styleName The style name of the RtfParagraphStyle to get.
+ * @return The RtfParagraphStyle with the given style name or null.
+ */
+ public RtfParagraphStyle getRtfParagraphStyle(String styleName) {
+ return this.stylesheetList.getRtfParagraphStyle(styleName);
+ }
+
+ /**
+ * Removes a RtfList from the list table
+ *
+ * @param list The RtfList to remove
+ */
+ public void freeListNumber(RtfList list) {
+ this.listTable.freeListNumber(list);
+ }
+
+ /**
+ * Gets the RtfPageSetting object of this RtfDocument
+ *
+ * @return The RtfPageSetting object
+ */
+ public RtfPageSetting getPageSetting() {
+ return this.pageSetting;
+ }
+
+ /**
+ * Adds an RtfInfoElement to the list of RtfInfoElements
+ *
+ * @param rtfInfoElement The RtfInfoElement to add
+ */
+ public void addInfoElement(RtfInfoElement rtfInfoElement) {
+ this.infoGroup.add(rtfInfoElement);
+ }
+
+ /**
+ * Sets the current header to use
+ *
+ * @param header The HeaderFooter to use as header
+ */
+ public void setHeader(HeaderFooter header) {
+ if(header != null) {
+ if(header instanceof RtfHeaderFooterGroup) {
+ this.header = new RtfHeaderFooterGroup(this.document, (RtfHeaderFooterGroup) header, RtfHeaderFooter.TYPE_HEADER);
+ } else if(header instanceof RtfHeaderFooter) {
+ this.header = new RtfHeaderFooterGroup(this.document, (RtfHeaderFooter) header, RtfHeaderFooter.TYPE_HEADER);
+ } else {
+ this.header = new RtfHeaderFooterGroup(this.document, header, RtfHeaderFooter.TYPE_HEADER);
+ }
+ } else {
+ this.header = new RtfHeaderFooterGroup(this.document, RtfHeaderFooter.TYPE_HEADER);
+ }
+ }
+
+ /**
+ * Sets the current footer to use
+ *
+ * @param footer The HeaderFooter to use as footer
+ */
+ public void setFooter(HeaderFooter footer) {
+ if(footer != null) {
+ if(footer instanceof RtfHeaderFooterGroup) {
+ this.footer = new RtfHeaderFooterGroup(this.document, (RtfHeaderFooterGroup) footer, RtfHeaderFooter.TYPE_FOOTER);
+ } else if(footer instanceof RtfHeaderFooter) {
+ this.footer = new RtfHeaderFooterGroup(this.document, (RtfHeaderFooter) footer, RtfHeaderFooter.TYPE_FOOTER);
+ } else {
+ this.footer = new RtfHeaderFooterGroup(this.document, footer, RtfHeaderFooter.TYPE_FOOTER);
+ }
+ } else {
+ this.footer = new RtfHeaderFooterGroup(this.document, RtfHeaderFooter.TYPE_FOOTER);
+ }
+ }
+
+ /**
+ * Registers the RtfParagraphStyle for further use in the document.
+ *
+ * @param rtfParagraphStyle The RtfParagraphStyle to register.
+ */
+ public void registerParagraphStyle(RtfParagraphStyle rtfParagraphStyle) {
+ this.stylesheetList.registerParagraphStyle(rtfParagraphStyle);
+ }
+}
diff --git a/src/main/java/com/lowagie/text/rtf/document/RtfDocumentSettings.java b/src/main/java/com/lowagie/text/rtf/document/RtfDocumentSettings.java new file mode 100644 index 0000000..15b5b92 --- /dev/null +++ b/src/main/java/com/lowagie/text/rtf/document/RtfDocumentSettings.java @@ -0,0 +1,182 @@ +/*
+ * $Id: RtfDocumentSettings.java,v 1.4 2005/12/24 13:14:59 hallm Exp $
+ * $Name: $
+ *
+ * Copyright 2003, 2004, 2005 by Mark Hall
+ *
+ * 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.rtf.document;
+
+import com.lowagie.text.rtf.style.RtfParagraphStyle;
+
+
+/**
+ * The RtfDocumentSettings contains output specific settings. These settings modify
+ * how the actual document is then generated and some settings may mean that some
+ * RTF readers can't read the document or render it wrongly.
+ *
+ * @version $Revision: 1.4 $
+ * @author Mark Hall (mhall@edu.uni-klu.ac.at)
+ */
+public class RtfDocumentSettings {
+
+ /**
+ * The RtfDocument this RtfDocumentSettings belongs to.
+ */
+ private RtfDocument document = null;
+ /**
+ * Whether to also output the table row definition after the cell content.
+ */
+ private boolean outputTableRowDefinitionAfter = true;
+ /**
+ * Whether to output the line breaks that make the rtf document source more readable.
+ */
+ private boolean outputDebugLineBreaks = true;
+ /**
+ * Whether to always generate soft linebreaks for \n in Chunks.
+ */
+ private boolean alwaysGenerateSoftLinebreaks = false;
+ /**
+ * Whether to always translate characters past 'z' into unicode representations.
+ */
+ private boolean alwaysUseUnicode = true;
+
+
+ /**
+ * Constructs a new RtfDocumentSettings object.
+ *
+ * @param document The RtfDocument this RtfDocumentSettings belong to.
+ */
+ public RtfDocumentSettings(RtfDocument document) {
+ this.document = document;
+ }
+
+ /**
+ * Gets whether to output the line breaks for increased rtf document readability.
+ *
+ * @return Whether to output line breaks.
+ */
+ public boolean isOutputDebugLineBreaks() {
+ return outputDebugLineBreaks;
+ }
+
+ /**
+ * Sets whether to output the line breaks for increased rtf document readability.
+ * Some line breaks may be added where the rtf specification demands it.
+ *
+ * @param outputDebugLineBreaks The outputDebugLineBreaks to set.
+ */
+ public void setOutputDebugLineBreaks(boolean outputDebugLineBreaks) {
+ this.outputDebugLineBreaks = outputDebugLineBreaks;
+ }
+
+ /**
+ * Gets whether the table row definition should also be written after the cell content.
+ *
+ * @return Returns the outputTableRowDefinitionAfter.
+ */
+ public boolean isOutputTableRowDefinitionAfter() {
+ return outputTableRowDefinitionAfter;
+ }
+
+ /**
+ * Sets whether the table row definition should also be written after the cell content.
+ * This is recommended to be set to <code>true</code> if you need Word2000 compatiblity and
+ * <code>false</code> if the document should be opened in OpenOffice.org Writer.
+ *
+ * @param outputTableRowDefinitionAfter The outputTableRowDefinitionAfter to set.
+ */
+ public void setOutputTableRowDefinitionAfter(
+ boolean outputTableRowDefinitionAfter) {
+ this.outputTableRowDefinitionAfter = outputTableRowDefinitionAfter;
+ }
+
+ /**
+ * Gets whether all linebreaks inside Chunks are generated as soft linebreaks.
+ *
+ * @return <code>True</code> if soft linebreaks are generated, <code>false</code> for hard linebreaks.
+ */
+ public boolean isAlwaysGenerateSoftLinebreaks() {
+ return this.alwaysGenerateSoftLinebreaks;
+ }
+
+ /**
+ * Sets whether to always generate soft linebreaks.
+ *
+ * @param alwaysGenerateSoftLinebreaks Whether to always generate soft linebreaks.
+ */
+ public void setAlwaysGenerateSoftLinebreaks(boolean alwaysGenerateSoftLinebreaks) {
+ this.alwaysGenerateSoftLinebreaks = alwaysGenerateSoftLinebreaks;
+ }
+
+ /**
+ * Gets whether all characters bigger than 'z' are represented as unicode.
+ *
+ * @return <code>True</code> if unicode representation is used, <code>false</code> otherwise.
+ */
+ public boolean isAlwaysUseUnicode() {
+ return this.alwaysUseUnicode;
+ }
+
+ /**
+ * Sets whether to represent all characters bigger than 'z' as unicode.
+ *
+ * @param alwaysUseUnicode <code>True</code> to use unicode representation, <code>false</code> otherwise.
+ */
+ public void setAlwaysUseUnicode(boolean alwaysUseUnicode) {
+ this.alwaysUseUnicode = alwaysUseUnicode;
+ }
+
+ /**
+ * Registers the RtfParagraphStyle for further use in the document. This does not need to be
+ * done for the default styles in the RtfParagraphStyle object. Those are added automatically.
+ *
+ * @param rtfParagraphStyle The RtfParagraphStyle to register.
+ */
+ public void registerParagraphStyle(RtfParagraphStyle rtfParagraphStyle) {
+ this.document.getDocumentHeader().registerParagraphStyle(rtfParagraphStyle);
+ }
+}
diff --git a/src/main/java/com/lowagie/text/rtf/document/RtfInfoElement.java b/src/main/java/com/lowagie/text/rtf/document/RtfInfoElement.java new file mode 100644 index 0000000..5549684 --- /dev/null +++ b/src/main/java/com/lowagie/text/rtf/document/RtfInfoElement.java @@ -0,0 +1,181 @@ +/*
+ * $Id: RtfInfoElement.java,v 1.16 2005/05/04 14:33:53 blowagie Exp $
+ * $Name: $
+ *
+ * Copyright 2003, 2004 by Mark Hall
+ *
+ * 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.rtf.document;
+
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.text.ParseException;
+import java.text.SimpleDateFormat;
+import java.util.Date;
+
+import com.lowagie.text.Meta;
+import com.lowagie.text.rtf.RtfElement;
+
+
+/**
+ * Stores one information group element. Valid elements are
+ * author, title, subject, keywords, producer and creationdate.
+ *
+ * @version $Version:$
+ * @author Mark Hall (mhall@edu.uni-klu.ac.at)
+ */
+public class RtfInfoElement extends RtfElement {
+
+ /**
+ * Constant for the author element
+ */
+ private static final byte[] INFO_AUTHOR = "\\author".getBytes();
+ /**
+ * Constant for the subject element
+ */
+ private static final byte[] INFO_SUBJECT = "\\subject".getBytes();
+ /**
+ * Constant for the keywords element
+ */
+ private static final byte[] INFO_KEYWORDS = "\\keywords".getBytes();
+ /**
+ * Constant for the title element
+ */
+ private static final byte[] INFO_TITLE = "\\title".getBytes();
+ /**
+ * Constant for the producer element
+ */
+ private static final byte[] INFO_PRODUCER = "\\operator".getBytes();
+ /**
+ * Constant for the creationdate element
+ */
+ private static final byte[] INFO_CREATION_DATE = "\\creationdate".getBytes();
+
+ /**
+ * The type of this RtfInfoElement. The values from Element.INFO_ELEMENT_NAME are used.
+ */
+ private int infoType = -1;
+ /**
+ * The content of this RtfInfoElement
+ */
+ private String content = "";
+
+ /**
+ * Constructs a RtfInfoElement based on the given Meta object
+ *
+ * @param doc The RtfDocument this RtfInfoElement belongs to
+ * @param meta The Meta object this RtfInfoElement is based on
+ */
+ public RtfInfoElement(RtfDocument doc, Meta meta) {
+ super(doc);
+ infoType = meta.type();
+ content = meta.content();
+ }
+
+ /**
+ * Writes this RtfInfoElement
+ *
+ * @return A byte array containing the RtfInfoElement data
+ */
+ public byte[] write() {
+ ByteArrayOutputStream result = new ByteArrayOutputStream();
+ try {
+ result.write(OPEN_GROUP);
+ switch(infoType) {
+ case Meta.AUTHOR:
+ result.write(INFO_AUTHOR);
+ break;
+ case Meta.SUBJECT:
+ result.write(INFO_SUBJECT);
+ break;
+ case Meta.KEYWORDS:
+ result.write(INFO_KEYWORDS);
+ break;
+ case Meta.TITLE:
+ result.write(INFO_TITLE);
+ break;
+ case Meta.PRODUCER:
+ result.write(INFO_PRODUCER);
+ break;
+ case Meta.CREATIONDATE:
+ result.write(INFO_CREATION_DATE);
+ break;
+ default:
+ result.write(INFO_AUTHOR);
+ break;
+ }
+ result.write(DELIMITER);
+ if(infoType == Meta.CREATIONDATE) {
+ result.write(convertDate(content).getBytes());
+ } else {
+ result.write(content.getBytes());
+ }
+ result.write(CLOSE_GROUP);
+ } catch(IOException ioe) {
+ ioe.printStackTrace();
+ }
+ return result.toByteArray();
+ }
+
+ /**
+ * Converts a date from the format used by iText to the format required by
+ * rtf.<br>iText: EEE MMM dd HH:mm:ss zzz yyyy - rtf: \\'yr'yyyy\\'mo'MM\\'dy'dd\\'hr'HH\\'min'mm\\'sec'ss
+ *
+ * @param date The date formated by iText
+ * @return The date formated for rtf
+ */
+ private String convertDate(String date) {
+ SimpleDateFormat sdf = new SimpleDateFormat("EEE MMM dd HH:mm:ss zzz yyyy");
+ try {
+ Date creationDate = sdf.parse(date);
+ sdf = new SimpleDateFormat("\\'yr'yyyy\\'mo'MM\\'dy'dd\\'hr'HH\\'min'mm\\'sec'ss");
+ return sdf.format(creationDate);
+ } catch(ParseException pe) {
+ pe.printStackTrace();
+ return "";
+ }
+ }
+}
diff --git a/src/main/java/com/lowagie/text/rtf/document/RtfInfoGroup.java b/src/main/java/com/lowagie/text/rtf/document/RtfInfoGroup.java new file mode 100644 index 0000000..fc6c46a --- /dev/null +++ b/src/main/java/com/lowagie/text/rtf/document/RtfInfoGroup.java @@ -0,0 +1,117 @@ +/*
+ * $Id: RtfInfoGroup.java,v 1.16 2005/05/04 14:33:52 blowagie Exp $
+ * $Name: $
+ *
+ * Copyright 2003, 2004 by Mark Hall
+ *
+ * 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.rtf.document;
+
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.util.ArrayList;
+
+import com.lowagie.text.rtf.RtfElement;
+
+
+/**
+ * The RtfInfoGroup stores information group elements.
+ *
+ * @version $Version:$
+ * @author Mark Hall (mhall@edu.uni-klu.ac.at)
+ */
+public class RtfInfoGroup extends RtfElement {
+ /**
+ * Information group starting tag
+ */
+ private static final byte[] INFO_GROUP = "\\info".getBytes();
+
+ /**
+ * The RtfInfoElements that belong to this RtfInfoGroup
+ */
+ ArrayList infoElements = null;
+
+ /**
+ * Constructs a RtfInfoGroup belonging to a RtfDocument
+ *
+ * @param doc The RtfDocument this RtfInfoGroup belongs to
+ */
+ public RtfInfoGroup(RtfDocument doc) {
+ super(doc);
+ infoElements = new ArrayList();
+ }
+
+ /**
+ * Adds an RtfInfoElement to the RtfInfoGroup
+ *
+ * @param infoElement The RtfInfoElement to add
+ */
+ public void add(RtfInfoElement infoElement) {
+ this.infoElements.add(infoElement);
+ }
+
+ /**
+ * Writes the RtfInfoGroup and its RtfInfoElement elements.
+ *
+ * @return A byte array containing the group and its elements
+ */
+ public byte[] write() {
+ ByteArrayOutputStream result = new ByteArrayOutputStream();
+ try {
+ result.write(OPEN_GROUP);
+ result.write(INFO_GROUP);
+ for(int i = 0; i < infoElements.size(); i++) {
+ RtfInfoElement infoElement = (RtfInfoElement) infoElements.get(i);
+ result.write(infoElement.write());
+ }
+ result.write(CLOSE_GROUP);
+ result.write((byte)'\n');
+ } catch(IOException ioe) {
+ ioe.printStackTrace();
+ }
+ return result.toByteArray();
+ }
+}
diff --git a/src/main/java/com/lowagie/text/rtf/document/RtfPageSetting.java b/src/main/java/com/lowagie/text/rtf/document/RtfPageSetting.java new file mode 100644 index 0000000..fd456e4 --- /dev/null +++ b/src/main/java/com/lowagie/text/rtf/document/RtfPageSetting.java @@ -0,0 +1,435 @@ +/*
+ * $Id: RtfPageSetting.java,v 1.15 2005/02/23 16:57:45 hallm Exp $
+ * $Name: $
+ *
+ * Copyright 2003, 2004 by Mark Hall
+ *
+ * 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.rtf.document;
+
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+
+import com.lowagie.text.PageSize;
+import com.lowagie.text.Rectangle;
+import com.lowagie.text.rtf.RtfElement;
+import com.lowagie.text.rtf.RtfExtendedElement;
+
+
+/**
+ * The RtfPageSetting stores the page size / page margins for a RtfDocument.
+ * INTERNAL CLASS - NOT TO BE USED DIRECTLY
+ *
+ * @version $Version:$
+ * @author Mark Hall (mhall@edu.uni-klu.ac.at)
+ */
+public class RtfPageSetting extends RtfElement implements RtfExtendedElement {
+
+ /**
+ * Constant for the page height
+ */
+ private static final byte[] PAGE_WIDTH = "\\paperw".getBytes();
+ /**
+ * Constant for the page width
+ */
+ private static final byte[] PAGE_HEIGHT = "\\paperh".getBytes();
+ /**
+ * Constant for the left margin
+ */
+ private static final byte[] MARGIN_LEFT = "\\margl".getBytes();
+ /**
+ * Constant for the right margin
+ */
+ private static final byte[] MARGIN_RIGHT = "\\margr".getBytes();
+ /**
+ * Constant for the top margin
+ */
+ private static final byte[] MARGIN_TOP = "\\margt".getBytes();
+ /**
+ * Constant for the bottom margin
+ */
+ private static final byte[] MARGIN_BOTTOM = "\\margb".getBytes();
+ /**
+ * Constant for landscape
+ */
+ private static final byte[] LANDSCAPE = "\\lndscpsxn".getBytes();
+ /**
+ * Constant for the section page width
+ */
+ private static final byte[] SECTION_PAGE_WIDTH = "\\pgwsxn".getBytes();
+ /**
+ * Constant for the section page height
+ */
+ private static final byte[] SECTION_PAGE_HEIGHT = "\\pghsxn".getBytes();
+ /**
+ * Constant for the section left margin
+ */
+ private static final byte[] SECTION_MARGIN_LEFT = "\\marglsxn".getBytes();
+ /**
+ * Constant for the section right margin
+ */
+ private static final byte[] SECTION_MARGIN_RIGHT = "\\margrsxn".getBytes();
+ /**
+ * Constant for the section top margin
+ */
+ private static final byte[] SECTION_MARGIN_TOP = "\\margtsxn".getBytes();
+ /**
+ * Constant for the section bottom margin
+ */
+ private static final byte[] SECTION_MARGIN_BOTTOM = "\\margbsxn".getBytes();
+
+ /**
+ * The page width to use
+ */
+ private int pageWidth = 11906;
+ /**
+ * The page height to use
+ */
+ private int pageHeight = 16840;
+ /**
+ * The left margin to use
+ */
+ private int marginLeft = 1800;
+ /**
+ * The right margin to use
+ */
+ private int marginRight = 1800;
+ /**
+ * The top margin to use
+ */
+ private int marginTop = 1440;
+ /**
+ * The bottom margin to use
+ */
+ private int marginBottom = 1440;
+ /**
+ * Whether the page is portrait or landscape
+ */
+ private boolean landscape = false;
+
+ /**
+ * Constructs a new RtfPageSetting object belonging to a RtfDocument.
+ *
+ * @param doc The RtfDocument this RtfPageSetting belongs to
+ */
+ public RtfPageSetting(RtfDocument doc) {
+ super(doc);
+ }
+
+ /**
+ * Writes the page size / page margin definition
+ *
+ * @return A byte array with the page size / page margin definition
+ */
+ public byte[] writeDefinition() {
+ ByteArrayOutputStream result = new ByteArrayOutputStream();
+ try {
+ result.write(PAGE_WIDTH);
+ result.write(intToByteArray(pageWidth));
+ result.write(PAGE_HEIGHT);
+ result.write(intToByteArray(pageHeight));
+ result.write(MARGIN_LEFT);
+ result.write(intToByteArray(marginLeft));
+ result.write(MARGIN_RIGHT);
+ result.write(intToByteArray(marginRight));
+ result.write(MARGIN_TOP);
+ result.write(intToByteArray(marginTop));
+ result.write(MARGIN_BOTTOM);
+ result.write(intToByteArray(marginBottom));
+ result.write((byte)'\n');
+ } catch(IOException ioe) {
+ ioe.printStackTrace();
+ }
+ return result.toByteArray();
+ }
+
+ /**
+ * Writes the definition part for a new section
+ *
+ * @return A byte array containing the definition for a new section
+ */
+ public byte[] writeSectionDefinition() {
+ ByteArrayOutputStream result = new ByteArrayOutputStream();
+ try {
+ if(landscape) {
+ result.write(LANDSCAPE);
+ result.write(SECTION_PAGE_WIDTH);
+ result.write(intToByteArray(pageWidth));
+ result.write(SECTION_PAGE_HEIGHT);
+ result.write(intToByteArray(pageHeight));
+ result.write((byte)'\n');
+ } else {
+ result.write(SECTION_PAGE_WIDTH);
+ result.write(intToByteArray(pageWidth));
+ result.write(SECTION_PAGE_HEIGHT);
+ result.write(intToByteArray(pageHeight));
+ result.write((byte)'\n');
+ }
+ result.write(SECTION_MARGIN_LEFT);
+ result.write(intToByteArray(marginLeft));
+ result.write(SECTION_MARGIN_RIGHT);
+ result.write(intToByteArray(marginRight));
+ result.write(SECTION_MARGIN_TOP);
+ result.write(intToByteArray(marginTop));
+ result.write(SECTION_MARGIN_BOTTOM);
+ result.write(intToByteArray(marginBottom));
+ } catch(IOException ioe) {
+ ioe.printStackTrace();
+ }
+ return result.toByteArray();
+ }
+
+ /**
+ * Gets the bottom margin
+ *
+ * @return Returns the bottom margin
+ */
+ public int getMarginBottom() {
+ return marginBottom;
+ }
+
+ /**
+ * Sets the bottom margin
+ *
+ * @param marginBottom The bottom margin to use
+ */
+ public void setMarginBottom(int marginBottom) {
+ this.marginBottom = marginBottom;
+ }
+
+ /**
+ * Gets the left margin
+ *
+ * @return Returns the left margin
+ */
+ public int getMarginLeft() {
+ return marginLeft;
+ }
+
+ /**
+ * Sets the left margin to use
+ *
+ * @param marginLeft The left margin to use
+ */
+ public void setMarginLeft(int marginLeft) {
+ this.marginLeft = marginLeft;
+ }
+
+ /**
+ * Gets the right margin
+ *
+ * @return Returns the right margin
+ */
+ public int getMarginRight() {
+ return marginRight;
+ }
+
+ /**
+ * Sets the right margin to use
+ *
+ * @param marginRight The right margin to use
+ */
+ public void setMarginRight(int marginRight) {
+ this.marginRight = marginRight;
+ }
+
+ /**
+ * Gets the top margin
+ *
+ * @return Returns the top margin
+ */
+ public int getMarginTop() {
+ return marginTop;
+ }
+
+ /**
+ * Sets the top margin to use
+ *
+ * @param marginTop The top margin to use
+ */
+ public void setMarginTop(int marginTop) {
+ this.marginTop = marginTop;
+ }
+
+ /**
+ * Gets the page height
+ *
+ * @return Returns the page height
+ */
+ public int getPageHeight() {
+ return pageHeight;
+ }
+
+ /**
+ * Sets the page height to use
+ *
+ * @param pageHeight The page height to use
+ */
+ public void setPageHeight(int pageHeight) {
+ this.pageHeight = pageHeight;
+ }
+
+ /**
+ * Gets the page width
+ *
+ * @return Returns the page width
+ */
+ public int getPageWidth() {
+ return pageWidth;
+ }
+
+ /**
+ * Sets the page width to use
+ *
+ * @param pageWidth The page width to use
+ */
+ public void setPageWidth(int pageWidth) {
+ this.pageWidth = pageWidth;
+ }
+
+ /**
+ * Set the page size to use. This method will use guessFormat to try to guess the correct
+ * page format. If no format could be guessed, the sizes from the pageSize are used and
+ * the landscape setting is determined by comparing width and height;
+ *
+ * @param pageSize The pageSize to use
+ */
+ public void setPageSize(Rectangle pageSize) {
+ if(!guessFormat(pageSize, false)) {
+ this.pageWidth = (int) (pageSize.width() * RtfElement.TWIPS_FACTOR);
+ this.pageHeight = (int) (pageSize.height() * RtfElement.TWIPS_FACTOR);
+ this.landscape = pageWidth > pageHeight;
+ }
+ }
+
+ /**
+ * This method tries to fit the <code>Rectangle pageSize</code> to one of the predefined PageSize rectangles.
+ * If a match is found the pageWidth and pageHeight will be set according to values determined from files
+ * generated by MS Word2000 and OpenOffice 641. If no match is found the method will try to match the rotated
+ * Rectangle by calling itself with the parameter rotate set to true.
+ *
+ * @param pageSize the page size for which to guess the correct format
+ * @param rotate Whether we should try to rotate the size befor guessing the format
+ * @return <code>True</code> if the format was guessed, <code>false/<code> otherwise
+ */
+ private boolean guessFormat(Rectangle pageSize, boolean rotate) {
+ if (rotate) {
+ pageSize = pageSize.rotate();
+ }
+ if (rectEquals(pageSize, PageSize.A3)) {
+ pageWidth = 16837;
+ pageHeight = 23811;
+ landscape = rotate;
+ return true;
+ }
+ if (rectEquals(pageSize, PageSize.A4)) {
+ pageWidth = 11907;
+ pageHeight = 16840;
+ landscape = rotate;
+ return true;
+ }
+ if (rectEquals(pageSize, PageSize.A5)) {
+ pageWidth = 8391;
+ pageHeight = 11907;
+ landscape = rotate;
+ return true;
+ }
+ if (rectEquals(pageSize, PageSize.A6)) {
+ pageWidth = 5959;
+ pageHeight = 8420;
+ landscape = rotate;
+ return true;
+ }
+ if (rectEquals(pageSize, PageSize.B4)) {
+ pageWidth = 14570;
+ pageHeight = 20636;
+ landscape = rotate;
+ return true;
+ }
+ if (rectEquals(pageSize, PageSize.B5)) {
+ pageWidth = 10319;
+ pageHeight = 14572;
+ landscape = rotate;
+ return true;
+ }
+ if (rectEquals(pageSize, PageSize.HALFLETTER)) {
+ pageWidth = 7927;
+ pageHeight = 12247;
+ landscape = rotate;
+ return true;
+ }
+ if (rectEquals(pageSize, PageSize.LETTER)) {
+ pageWidth = 12242;
+ pageHeight = 15842;
+ landscape = rotate;
+ return true;
+ }
+ if (rectEquals(pageSize, PageSize.LEGAL)) {
+ pageWidth = 12252;
+ pageHeight = 20163;
+ landscape = rotate;
+ return true;
+ }
+ if (!rotate && guessFormat(pageSize, true)) {
+ int x = pageWidth;
+ pageWidth = pageHeight;
+ pageHeight = x;
+ return true;
+ }
+ return false;
+ }
+
+ /**
+ * This method compares to Rectangles. They are considered equal if width and height are the same
+ *
+ * @param rect1 The first Rectangle to compare
+ * @param rect2 The second Rectangle to compare
+ * @return <code>True</code> if the Rectangles equal, <code>false</code> otherwise
+ */
+ private boolean rectEquals(Rectangle rect1, Rectangle rect2) {
+ return (rect1.width() == rect2.width()) && (rect1.height() == rect2.height());
+ }
+}
diff --git a/src/main/java/com/lowagie/text/rtf/document/output/RtfDataCache.java b/src/main/java/com/lowagie/text/rtf/document/output/RtfDataCache.java new file mode 100644 index 0000000..f9b3e9d --- /dev/null +++ b/src/main/java/com/lowagie/text/rtf/document/output/RtfDataCache.java @@ -0,0 +1,86 @@ +/*
+ * $Id: RtfDataCache.java,v 1.1 2005/02/02 18:09:32 hallm Exp $
+ * $Name: $
+ *
+ * Copyright 2005 by Mark Hall
+ *
+ * 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.rtf.document.output;
+
+import java.io.IOException;
+import java.io.OutputStream;
+
+
+/**
+ * The RtfDataCache interface must be implemented by classes wishing to
+ * act as caches for the rtf document data.
+ *
+ * @version $Revision: 1.1 $
+ * @author Mark Hall (mhall@edu.uni-klu.ac.at)
+ */
+public interface RtfDataCache {
+ /**
+ * Constant for caching into memory.
+ */
+ public static final int CACHE_MEMORY = 2;
+ /**
+ * Constant for caching to the disk.
+ */
+ public static final int CACHE_DISK = 1;
+ /**
+ * Get the OutputStream that the RtfDocument can write to.
+ *
+ * @return The OutputStream the RtfDocument can use.
+ */
+ public OutputStream getOutputStream();
+ /**
+ * Write the content of the cache into the OutputStream.
+ *
+ * @param target The OutputStream to write the content into.
+ * @throws IOException If an error occurs reading/writing.
+ */
+ public void writeTo(OutputStream target) throws IOException;
+}
diff --git a/src/main/java/com/lowagie/text/rtf/document/output/RtfDiskCache.java b/src/main/java/com/lowagie/text/rtf/document/output/RtfDiskCache.java new file mode 100644 index 0000000..77053ac --- /dev/null +++ b/src/main/java/com/lowagie/text/rtf/document/output/RtfDiskCache.java @@ -0,0 +1,113 @@ +/*
+ * $Id: RtfDiskCache.java,v 1.1 2005/02/02 18:09:32 hallm Exp $
+ * $Name: $
+ *
+ * Copyright 2005 by Mark Hall
+ *
+ * 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.rtf.document.output;
+
+import java.io.BufferedInputStream;
+import java.io.BufferedOutputStream;
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.io.OutputStream;
+
+
+/**
+ * The RtfFileCache is a RtfDataCache that uses a temporary file
+ * to store the rtf document data. Not so fast, but doesn't use any
+ * memory (just disk space).
+ *
+ * @version $Revision: 1.1 $
+ * @author Mark Hall (mhall@edu.uni-klu.ac.at)
+ */
+public class RtfDiskCache implements RtfDataCache {
+
+ /**
+ * The BufferedOutputStream that stores the cache data.
+ */
+ private BufferedOutputStream data = null;
+ /**
+ * The temporary file to store the data in.
+ */
+ private File tempFile = null;
+
+ /**
+ * Constructs a RtfFileCache. Creates the temp file.
+ *
+ * @throws IOException If the temporary file could not be created.
+ */
+ public RtfDiskCache() throws IOException {
+ this.tempFile = File.createTempFile("iText", null);
+ this.data = new BufferedOutputStream(new FileOutputStream(tempFile));
+ }
+
+ /**
+ * Gets the BufferedOutputStream to write to.
+ */
+ public OutputStream getOutputStream() {
+ return this.data;
+ }
+
+ /**
+ * Writes the content of the temporary file into the OutputStream.
+ */
+ public void writeTo(OutputStream target) throws IOException {
+ this.data.close();
+ BufferedInputStream tempIn = new BufferedInputStream(new FileInputStream(this.tempFile));
+ byte[] buffer = new byte[8192];
+ int bytesRead = -1;
+ while((bytesRead = tempIn.read(buffer)) >= 0) {
+ target.write(buffer, 0, bytesRead);
+ }
+ tempIn.close();
+ this.tempFile.delete();
+ }
+
+}
diff --git a/src/main/java/com/lowagie/text/rtf/document/output/RtfMemoryCache.java b/src/main/java/com/lowagie/text/rtf/document/output/RtfMemoryCache.java new file mode 100644 index 0000000..002355f --- /dev/null +++ b/src/main/java/com/lowagie/text/rtf/document/output/RtfMemoryCache.java @@ -0,0 +1,93 @@ +/*
+ * $Id: RtfMemoryCache.java,v 1.1 2005/02/02 18:09:31 hallm Exp $
+ * $Name: $
+ *
+ * Copyright 2005 by Mark Hall
+ *
+ * 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.rtf.document.output;
+
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.io.OutputStream;
+
+
+/**
+ * The RtfMemoryCache is an RtfDataCache that keeps the whole rtf document
+ * data in memory. Fast but memory intensive.
+ *
+ * @version $Revision: 1.1 $
+ * @author Mark Hall (mhall@edu.uni-klu.ac.at)
+ */
+public class RtfMemoryCache implements RtfDataCache {
+
+ /**
+ * The buffer for the rtf document data.
+ */
+ private ByteArrayOutputStream data = null;
+
+ /**
+ * Constructs a RtfMemoryCache.
+ */
+ public RtfMemoryCache() {
+ this.data = new ByteArrayOutputStream();
+ }
+
+ /**
+ * Gets the ByteArrayOutputStream.
+ */
+ public OutputStream getOutputStream() {
+ return this.data;
+ }
+
+ /**
+ * Writes the content of the ByteArrayOutputStream into the OutputStream.
+ */
+ public void writeTo(OutputStream target) throws IOException {
+ this.data.writeTo(target);
+ }
+
+}
diff --git a/src/main/java/com/lowagie/text/rtf/field/RtfAnchor.java b/src/main/java/com/lowagie/text/rtf/field/RtfAnchor.java new file mode 100644 index 0000000..3823c3d --- /dev/null +++ b/src/main/java/com/lowagie/text/rtf/field/RtfAnchor.java @@ -0,0 +1,122 @@ +/*
+ * $Id: RtfAnchor.java,v 1.9 2005/07/07 14:44:47 hallm Exp $
+ * $Name: $
+ *
+ * Copyright 2004 by Mark Hall
+ *
+ * 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.rtf.field;
+
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+
+import com.lowagie.text.Anchor;
+import com.lowagie.text.rtf.document.RtfDocument;
+import com.lowagie.text.rtf.text.RtfPhrase;
+
+
+/**
+ *
+ * @version $Version:$
+ * @author Mark Hall (mhall@edu.uni-klu.ac.at)
+ * @author Werner Daehn (Werner.Daehn@BusinessObjects.com)
+ */
+public class RtfAnchor extends RtfField {
+
+ /**
+ * Constant for a hyperlink
+ */
+ private static final byte[] HYPERLINK = "HYPERLINK".getBytes();
+
+ /**
+ * The url of this RtfAnchor
+ */
+ private String url = "";
+ /**
+ * The RtfPhrase to display for the url
+ */
+ private RtfPhrase content = null;
+
+ /**
+ * Constructs a RtfAnchor based on a RtfField
+ *
+ * @param doc The RtfDocument this RtfAnchor belongs to
+ * @param anchor The Anchor this RtfAnchor is based on
+ */
+ public RtfAnchor(RtfDocument doc, Anchor anchor) {
+ super(doc);
+ this.url = anchor.reference();
+ this.content = new RtfPhrase(doc, anchor);
+ }
+
+ /**
+ * Write the field instructions for this RtfAnchor. Sets the field
+ * type to HYPERLINK and then writes the url.
+ *
+ * @return The field instructions for this RtfAnchor
+ * @throws IOException
+ */
+ protected byte[] writeFieldInstContent() throws IOException {
+ ByteArrayOutputStream result = new ByteArrayOutputStream();
+
+ result.write(HYPERLINK);
+ result.write(DELIMITER);
+ result.write(url.getBytes());
+
+ return result.toByteArray();
+ }
+
+ /**
+ * Write the field result for this RtfAnchor. Writes the content
+ * of the RtfPhrase.
+ *
+ * @return The field result for this RtfAnchor
+ * @throws IOException
+ */
+ protected byte[] writeFieldResultContent() throws IOException {
+ return content.write();
+ }
+}
diff --git a/src/main/java/com/lowagie/text/rtf/field/RtfField.java b/src/main/java/com/lowagie/text/rtf/field/RtfField.java new file mode 100644 index 0000000..6eaa525 --- /dev/null +++ b/src/main/java/com/lowagie/text/rtf/field/RtfField.java @@ -0,0 +1,445 @@ +/*
+ * $Id: RtfField.java,v 1.11 2005/09/05 16:02:40 hallm Exp $
+ * $Name: $
+ *
+ * Copyright 2004 by Mark Hall
+ * Uses code Copyright 2002
+ * <a href="http://www.smb-tec.com">SMB</a>
+ * <a href="mailto:Dirk.Weigenand@smb-tec.com">Dirk.Weigenand@smb-tec.com</a>
+ *
+ * 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.rtf.field;
+
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+
+import com.lowagie.text.Chunk;
+import com.lowagie.text.Font;
+import com.lowagie.text.rtf.RtfBasicElement;
+import com.lowagie.text.rtf.document.RtfDocument;
+import com.lowagie.text.rtf.style.RtfFont;
+
+
+/**
+ * The RtfField class is an abstract base class for all rtf field functionality.
+ * Subclasses only need to implement the two abstract methods writeFieldInstContent
+ * and writeFieldResultContent. All other field functionality is handled by the
+ * RtfField class.
+ *
+ * @version $Version:$
+ * @author Mark Hall (mhall@edu.uni-klu.ac.at)
+ * @author <a href="mailto:Dirk.Weigenand@smb-tec.com">Dirk Weigenand</a>
+ */
+public abstract class RtfField extends Chunk implements RtfBasicElement {
+
+ /**
+ * Constant for a rtf field
+ */
+ private static final byte[] FIELD = "\\field".getBytes();
+ /**
+ * Constant for a dirty field
+ */
+ private static final byte[] FIELD_DIRTY = "\\flddirty".getBytes();
+ /**
+ * Constant for a private field
+ */
+ private static final byte[] FIELD_PRIVATE = "\\fldpriv".getBytes();
+ /**
+ * Constant for a locked field
+ */
+ private static final byte[] FIELD_LOCKED = "\\fldlock".getBytes();
+ /**
+ * Constant for a edited field
+ */
+ private static final byte[] FIELD_EDIT = "\\fldedit".getBytes();
+ /**
+ * Constant for an alt field
+ */
+ private static final byte[] FIELD_ALT = "\\fldalt".getBytes();
+ /**
+ * Constant for the field instructions
+ */
+ private static final byte[] FIELD_INSTRUCTIONS = "\\*\\fldinst".getBytes();
+ /**
+ * Constant for the field result
+ */
+ private static final byte[] FIELD_RESULT = "\\fldrslt".getBytes();
+
+ /**
+ * Is the field dirty
+ */
+ private boolean fieldDirty = false;
+ /**
+ * Is the field edited
+ */
+ private boolean fieldEdit = false;
+ /**
+ * Is the field locked
+ */
+ private boolean fieldLocked = false;
+ /**
+ * Is the field private
+ */
+ private boolean fieldPrivate = false;
+ /**
+ * Is it an alt field
+ */
+ private boolean fieldAlt = false;
+ /**
+ * Whether this RtfField is in a table
+ */
+ private boolean inTable = false;
+ /**
+ * Whether this RtfElement is in a header
+ */
+ private boolean inHeader = false;
+ /**
+ * The RtfDocument this RtfField belongs to
+ */
+ protected RtfDocument document = null;
+ /**
+ * The RtfFont of this RtfField
+ */
+ private RtfFont font = null;
+
+ /**
+ * Constructs a RtfField for a RtfDocument. This is not very usefull,
+ * since the RtfField by itself does not do anything. Use one of the
+ * subclasses instead.
+ *
+ * @param doc The RtfDocument this RtfField belongs to.
+ */
+ protected RtfField(RtfDocument doc) {
+ this(doc, new Font());
+ }
+
+ /**
+ * Constructs a RtfField for a RtfDocument. This is not very usefull,
+ * since the RtfField by itself does not do anything. Use one of the
+ * subclasses instead.
+ *
+ * @param doc The RtfDocument this RtfField belongs to.
+ * @param font The Font this RtfField should use
+ */
+ protected RtfField(RtfDocument doc, Font font) {
+ super("", font);
+ this.document = doc;
+ this.font = new RtfFont(this.document, font);
+ }
+
+ /**
+ * Sets the RtfDocument this RtfElement belongs to
+ *
+ * @param doc The RtfDocument to use
+ */
+ public void setRtfDocument(RtfDocument doc) {
+ this.document = doc;
+ this.font.setRtfDocument(this.document);
+ }
+
+ /**
+ * Writes the field beginning. Also writes field properties.
+ *
+ * @return A byte array with the field beginning.
+ * @throws IOException
+ */
+ private byte[] writeFieldBegin() throws IOException {
+ ByteArrayOutputStream result = new ByteArrayOutputStream();
+
+ result.write(OPEN_GROUP);
+ result.write(FIELD);
+
+ if (fieldDirty) {
+ result.write(FIELD_DIRTY);
+ }
+ if (fieldEdit) {
+ result.write(FIELD_EDIT);
+ }
+ if (fieldLocked) {
+ result.write(FIELD_LOCKED);
+ }
+ if (fieldPrivate) {
+ result.write(FIELD_PRIVATE);
+ }
+
+ return result.toByteArray();
+ }
+
+ /**
+ * Writes the beginning of the field instruction area.
+ *
+ * @return The beginning of the field instruction area
+ * @throws IOException
+ */
+ private byte[] writeFieldInstBegin() throws IOException {
+ ByteArrayOutputStream result = new ByteArrayOutputStream();
+
+ result.write(OPEN_GROUP);
+ result.write(FIELD_INSTRUCTIONS);
+ result.write(DELIMITER);
+
+ return result.toByteArray();
+ }
+
+ /**
+ * Writes the content of the field instruction area. Override this
+ * method in your subclasses.
+ *
+ * @return The content of the field instruction area
+ * @throws IOException If an error occurs.
+ */
+ protected abstract byte[] writeFieldInstContent() throws IOException;
+
+ /**
+ * Writes the end of the field instruction area.
+ *
+ * @return A byte array containing the end of the field instruction area
+ * @throws IOException
+ */
+ private byte[] writeFieldInstEnd() throws IOException {
+ ByteArrayOutputStream result = new ByteArrayOutputStream();
+
+ if (fieldAlt) {
+ result.write(DELIMITER);
+ result.write(FIELD_ALT);
+ }
+ result.write(CLOSE_GROUP);
+
+ return result.toByteArray();
+ }
+
+ /**
+ * Writes the beginning of the field result area
+ *
+ * @return A byte array containing the beginning of the field result area
+ * @throws IOException
+ */
+ private byte[] writeFieldResultBegin() throws IOException {
+ ByteArrayOutputStream result = new ByteArrayOutputStream();
+
+ result.write(OPEN_GROUP);
+ result.write(FIELD_RESULT);
+ result.write(DELIMITER);
+
+ return result.toByteArray();
+ }
+
+ /**
+ * Writes the content of the pre-calculated field result. Override this
+ * method in your subclasses.
+ *
+ * @return A byte array containing the field result
+ * @throws IOException If an error occurs
+ */
+ protected abstract byte[] writeFieldResultContent() throws IOException;
+
+ /**
+ * Writes the end of the field result area
+ *
+ * @return A byte array containing the end of the field result area
+ * @throws IOException
+ */
+ private byte[] writeFieldResultEnd() throws IOException {
+ ByteArrayOutputStream result = new ByteArrayOutputStream();
+
+ result.write(DELIMITER);
+ result.write(CLOSE_GROUP);
+
+ return result.toByteArray();
+ }
+
+ /**
+ * Writes the end of the field
+ *
+ * @return A byte array containing the end of the field
+ * @throws IOException
+ */
+ private byte[] writeFieldEnd() throws IOException {
+ ByteArrayOutputStream result = new ByteArrayOutputStream();
+
+ result.write(CLOSE_GROUP);
+
+ return result.toByteArray();
+ }
+
+ /**
+ * Write the content of this RtfField.
+ *
+ * @return A byte array containing the content of this RtfField
+ */
+ public byte[] write() {
+ ByteArrayOutputStream result = new ByteArrayOutputStream();
+ try {
+ result.write(this.font.writeBegin());
+ result.write(writeFieldBegin());
+ result.write(writeFieldInstBegin());
+ result.write(writeFieldInstContent());
+ result.write(writeFieldInstEnd());
+ result.write(writeFieldResultBegin());
+ result.write(writeFieldResultContent());
+ result.write(writeFieldResultEnd());
+ result.write(writeFieldEnd());
+ result.write(this.font.writeEnd());
+ } catch(IOException ioe) {
+ ioe.printStackTrace();
+ }
+ return result.toByteArray();
+ }
+
+ /**
+ * Get whether this field is an alt field
+ *
+ * @return Returns whether this field is an alt field
+ */
+ public boolean isFieldAlt() {
+ return fieldAlt;
+ }
+
+ /**
+ * Set whether this field is an alt field
+ *
+ * @param fieldAlt The value to use
+ */
+ public void setFieldAlt(boolean fieldAlt) {
+ this.fieldAlt = fieldAlt;
+ }
+
+ /**
+ * Get whether this field is dirty
+ *
+ * @return Returns whether this field is dirty
+ */
+ public boolean isFieldDirty() {
+ return fieldDirty;
+ }
+
+ /**
+ * Set whether this field is dirty
+ *
+ * @param fieldDirty The value to use
+ */
+ public void setFieldDirty(boolean fieldDirty) {
+ this.fieldDirty = fieldDirty;
+ }
+
+ /**
+ * Get whether this field is edited
+ *
+ * @return Returns whether this field is edited
+ */
+ public boolean isFieldEdit() {
+ return fieldEdit;
+ }
+
+ /**
+ * Set whether this field is edited.
+ *
+ * @param fieldEdit The value to use
+ */
+ public void setFieldEdit(boolean fieldEdit) {
+ this.fieldEdit = fieldEdit;
+ }
+
+ /**
+ * Get whether this field is locked
+ *
+ * @return Returns the fieldLocked.
+ */
+ public boolean isFieldLocked() {
+ return fieldLocked;
+ }
+
+ /**
+ * Set whether this field is locked
+ * @param fieldLocked The value to use
+ */
+ public void setFieldLocked(boolean fieldLocked) {
+ this.fieldLocked = fieldLocked;
+ }
+
+ /**
+ * Get whether this field is private
+ *
+ * @return Returns the fieldPrivate.
+ */
+ public boolean isFieldPrivate() {
+ return fieldPrivate;
+ }
+
+ /**
+ * Set whether this field is private
+ *
+ * @param fieldPrivate The value to use
+ */
+ public void setFieldPrivate(boolean fieldPrivate) {
+ this.fieldPrivate = fieldPrivate;
+ }
+
+ /**
+ * Sets whether this RtfField is in a table
+ *
+ * @param inTable <code>True</code> if this RtfField is in a table, <code>false</code> otherwise
+ */
+ public void setInTable(boolean inTable) {
+ this.inTable = inTable;
+ }
+
+ /**
+ * Sets whether this RtfField is in a header
+ *
+ * @param inHeader <code>True</code> if this RtfField is in a header, <code>false</code> otherwise
+ */
+ public void setInHeader(boolean inHeader) {
+ this.inHeader = inHeader;
+ }
+
+ /**
+ * An RtfField is never empty.
+ */
+ public boolean isEmpty() {
+ return false;
+ }
+}
diff --git a/src/main/java/com/lowagie/text/rtf/field/RtfPageNumber.java b/src/main/java/com/lowagie/text/rtf/field/RtfPageNumber.java new file mode 100644 index 0000000..3b69295 --- /dev/null +++ b/src/main/java/com/lowagie/text/rtf/field/RtfPageNumber.java @@ -0,0 +1,83 @@ +/*
+ * Created on Aug 10, 2004
+ *
+ * To change the template for this generated file go to
+ * Window - Preferences - Java - Code Generation - Code and Comments
+ */
+package com.lowagie.text.rtf.field;
+
+import java.io.IOException;
+
+import com.lowagie.text.Font;
+import com.lowagie.text.rtf.document.RtfDocument;
+
+
+/**
+ * The RtfPageNumber provides the page number field in rtf documents.
+ *
+ * @version $Revision: 1.7 $
+ * @author Mark Hall (mhall@edu.uni-klu.ac.at)
+ * @author <a href="mailto:Steffen.Stundzig@smb-tec.com">Steffen.Stundzig@smb-tec.com</a>
+ */
+public class RtfPageNumber extends RtfField {
+
+ /**
+ * Constant for the page number
+ */
+ private static final byte[] PAGE_NUMBER = "PAGE".getBytes();
+
+ /**
+ * Constructs a RtfPageNumber. This can be added anywhere to add a page number field.
+ */
+ public RtfPageNumber() {
+ super(null);
+ }
+
+ /**
+ * Constructs a RtfPageNumber with a specified Font. This can be added anywhere to
+ * add a page number field.
+ * @param font
+ */
+ public RtfPageNumber(Font font) {
+ super(null, font);
+ }
+
+ /**
+ * Constructs a RtfPageNumber object.
+ *
+ * @param doc The RtfDocument this RtfPageNumber belongs to
+ */
+ public RtfPageNumber(RtfDocument doc) {
+ super(doc);
+ }
+
+ /**
+ * Constructs a RtfPageNumber object with a specific font.
+ *
+ * @param doc The RtfDocument this RtfPageNumber belongs to
+ * @param font The Font to use
+ */
+ public RtfPageNumber(RtfDocument doc, Font font) {
+ super(doc, font);
+ }
+
+ /**
+ * Writes the field instruction content
+ *
+ * @return A byte array containing "PAGE"
+ * @throws IOException
+ */
+ protected byte[] writeFieldInstContent() throws IOException {
+ return PAGE_NUMBER;
+ }
+
+ /**
+ * Writes the field result content
+ *
+ * @return An empty byte array
+ * @throws IOException
+ */
+ protected byte[] writeFieldResultContent() throws IOException {
+ return new byte[0];
+ }
+}
diff --git a/src/main/java/com/lowagie/text/rtf/field/RtfTOCEntry.java b/src/main/java/com/lowagie/text/rtf/field/RtfTOCEntry.java new file mode 100644 index 0000000..f65e424 --- /dev/null +++ b/src/main/java/com/lowagie/text/rtf/field/RtfTOCEntry.java @@ -0,0 +1,163 @@ +/*
+ * $Id: RtfTOCEntry.java,v 1.9 2004/12/25 10:18:11 hallm Exp $
+ * $Name: $
+ *
+ * Copyright 2004 by Mark Hall
+ * Uses code Copyright 2002
+ * <a href="mailto:Steffen.Stundzig@smb-tec.com">Steffen.Stundzig@smb-tec.com</a>
+ *
+ * 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.rtf.field;
+
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+
+import com.lowagie.text.Font;
+
+
+/**
+ * The RtfTOCEntry is used together with the RtfTableOfContents to generate a table of
+ * contents. Add the RtfTOCEntry in those locations in the document where table of
+ * contents entries should link to
+ *
+ * @version $Version:$
+ * @author Mark Hall (mhall@edu.uni-klu.ac.at)
+ * @author <a href="mailto:Steffen.Stundzig@smb-tec.com">Steffen.Stundzig@smb-tec.com</a>
+ */
+public class RtfTOCEntry extends RtfField {
+
+ /**
+ * Constant for the beginning of hidden text
+ */
+ private static final byte[] TEXT_HIDDEN_ON = "\\v".getBytes();
+ /**
+ * Constant for the end of hidden text
+ */
+ private static final byte[] TEXT_HIDDEN_OFF = "\\v0".getBytes();
+ /**
+ * Constant for a TOC entry with page numbers
+ */
+ private static final byte[] TOC_ENTRY_PAGE_NUMBER = "\\tc".getBytes();
+ /**
+ * Constant for a TOC entry without page numbers
+ */
+ private static final byte[] TOC_ENTRY_NO_PAGE_NUMBER = "\\tcn".getBytes();
+
+ /**
+ * The entry text of this RtfTOCEntry
+ */
+ private String entry = "";
+ /**
+ * Whether to show page numbers in the table of contents
+ */
+ private boolean showPageNumber = true;
+
+ /**
+ * Constructs a RtfTOCEntry with a certain entry text.
+ *
+ * @param entry The entry text to display
+ * @param font The Font to use
+ */
+ public RtfTOCEntry(String entry, Font font) {
+ super(null, font);
+ if(entry != null) {
+ this.entry = entry;
+ }
+ }
+
+ /**
+ * Writes the content of the RtfTOCEntry
+ *
+ * @return A byte array with the contents of the RtfTOCEntry
+ */
+ public byte[] write() {
+ ByteArrayOutputStream result = new ByteArrayOutputStream();
+ try {
+ result.write(TEXT_HIDDEN_ON);
+ result.write(OPEN_GROUP);
+ if(this.showPageNumber) {
+ result.write(TOC_ENTRY_PAGE_NUMBER);
+ } else {
+ result.write(TOC_ENTRY_NO_PAGE_NUMBER);
+ }
+ result.write(DELIMITER);
+ result.write(this.document.filterSpecialChar(this.entry, true, false).getBytes());
+ result.write(CLOSE_GROUP);
+ result.write(TEXT_HIDDEN_OFF);
+ } catch(IOException ioe) {
+ ioe.printStackTrace();
+ }
+ return result.toByteArray();
+ }
+
+ /**
+ * Sets whether to display a page number in the table of contents, or not
+ *
+ * @param showPageNumber Whether to display a page number or not
+ */
+ public void setShowPageNumber(boolean showPageNumber) {
+ this.showPageNumber = showPageNumber;
+ }
+
+ /**
+ * UNUSED
+ * @return null
+ * @throws IOException never thrown
+ */
+ protected byte[] writeFieldInstContent() throws IOException {
+ return null;
+ }
+
+ /**
+ * UNUSED
+ * @return null
+ * @throws IOException never thrown
+ */
+ protected byte[] writeFieldResultContent() throws IOException {
+ return null;
+ }
+
+}
diff --git a/src/main/java/com/lowagie/text/rtf/field/RtfTableOfContents.java b/src/main/java/com/lowagie/text/rtf/field/RtfTableOfContents.java new file mode 100644 index 0000000..b6738c1 --- /dev/null +++ b/src/main/java/com/lowagie/text/rtf/field/RtfTableOfContents.java @@ -0,0 +1,109 @@ +/*
+ * $Id: RtfTableOfContents.java,v 1.8 2004/12/14 12:51:54 blowagie Exp $
+ * $Name: $
+ *
+ * Copyright 2004 by Mark Hall
+ * Uses code Copyright 2002
+ * <a href="mailto:Steffen.Stundzig@smb-tec.com">Steffen.Stundzig@smb-tec.com</a>
+ *
+ * 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.rtf.field;
+
+import java.io.IOException;
+
+import com.lowagie.text.Font;
+
+
+
+/**
+ * The RtfTableOfContents together with multiple RtfTOCEntry objects generates a table
+ * of contents. The table of contents will display no entries in the viewing program
+ * and the user will have to update it first. A text to inform the user of this is
+ * displayed instead.
+ *
+ * @version $Version:$
+ * @author Mark Hall (mhall@edu.uni-klu.ac.at)
+ * @author <a href="mailto:Steffen.Stundzig@smb-tec.com">Steffen.Stundzig@smb-tec.com</a>
+ */
+public class RtfTableOfContents extends RtfField {
+
+ /**
+ * The default text to display
+ */
+ private String defaultText = "Table of Contents - Click to update";
+
+ /**
+ * Constructs a RtfTableOfContents. The default text is the text that is displayed
+ * before the user updates the table of contents
+ *
+ * @param defaultText The default text to display
+ * @param font The Font to use
+ */
+ public RtfTableOfContents(String defaultText, Font font) {
+ super(null, font);
+ this.defaultText = defaultText;
+ }
+
+ /**
+ * Writes the field instruction content
+ *
+ * @return A byte array containing with the field instructions
+ * @throws IOException
+ */
+ protected byte[] writeFieldInstContent() throws IOException {
+ return "TOC \\\\f \\\\h \\\\u \\\\o \"1-5\" ".getBytes();
+ }
+
+ /**
+ * Writes the field result content
+ *
+ * @return An byte array containing the default text
+ * @throws IOException
+ */
+ protected byte[] writeFieldResultContent() throws IOException {
+ return defaultText.getBytes();
+ }
+}
diff --git a/src/main/java/com/lowagie/text/rtf/field/RtfTotalPageNumber.java b/src/main/java/com/lowagie/text/rtf/field/RtfTotalPageNumber.java new file mode 100644 index 0000000..a776fd6 --- /dev/null +++ b/src/main/java/com/lowagie/text/rtf/field/RtfTotalPageNumber.java @@ -0,0 +1,128 @@ +/*
+ * $Id: RtfTotalPageNumber.java,v 1.3 2005/05/13 12:09:14 hallm Exp $
+ * $Name: $
+ *
+ * Copyright 2005 Jose Hurtado <a href="mailto:jose.hurtado@gft.com">jose.hurtado@gft.com</a>
+ * Parts Copyright 2005 Mark Hall
+ *
+ * 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.rtf.field;
+
+import java.io.IOException;
+
+import com.lowagie.text.Font;
+import com.lowagie.text.rtf.document.RtfDocument;
+import com.lowagie.text.rtf.field.RtfField;
+
+/**
+ * The RtfTotalPageNumber provides the total number of pages field in rtf documents.
+ *
+ * @version $Version:$
+ * @author Jose Hurtado (jose.hurtado@gft.com)
+ * @author Mark Hall (mhall@edu.uni-klu.ac.at)
+ */
+public class RtfTotalPageNumber extends RtfField {
+
+ /**
+ * Constant for arabic total page numbers.
+ */
+ private static final byte[] ARABIC_TOTAL_PAGES = "NUMPAGES \\\\* Arabic".getBytes();
+
+ /**
+ * Constructs a RtfTotalPageNumber. This can be added anywhere to add a total number of pages field.
+ */
+ public RtfTotalPageNumber() {
+ super(null);
+ }
+
+ /**
+ * Constructs a RtfTotalPageNumber with a specified Font. This can be added anywhere
+ * to add a total number of pages field.
+ * @param font
+ */
+ public RtfTotalPageNumber(Font font) {
+ super(null, font);
+ }
+
+ /**
+ * Constructs a RtfTotalPageNumber object.
+ *
+ * @param doc The RtfDocument this RtfTotalPageNumber belongs to
+ */
+ public RtfTotalPageNumber(RtfDocument doc) {
+ super(doc);
+ }
+
+ /**
+ * Constructs a RtfTotalPageNumber object with a specific font.
+ *
+ * @param doc The RtfDocument this RtfTotalPageNumber belongs to
+ * @param font The Font to use
+ */
+ public RtfTotalPageNumber(RtfDocument doc, Font font) {
+ super(doc, font);
+ }
+
+ /**
+ * Writes the field NUMPAGES instruction with Arabic format
+ *
+ * @return A byte array containing "NUMPAGES \\\\* Arabic".
+ * @throws IOException
+ */
+ protected byte[] writeFieldInstContent() throws IOException {
+ return ARABIC_TOTAL_PAGES;
+ }
+
+ /**
+ * Writes the field result content
+ *
+ * @return An byte array containing "1".
+ * @throws IOException
+ */
+ protected byte[] writeFieldResultContent() throws IOException {
+ return "1".getBytes();
+ }
+}
diff --git a/src/main/java/com/lowagie/text/rtf/graphic/RtfImage.java b/src/main/java/com/lowagie/text/rtf/graphic/RtfImage.java new file mode 100644 index 0000000..c0446f8 --- /dev/null +++ b/src/main/java/com/lowagie/text/rtf/graphic/RtfImage.java @@ -0,0 +1,306 @@ +/*
+ * $Id: RtfImage.java,v 1.23 2005/12/24 13:14:28 hallm Exp $
+ * $Name: $
+ *
+ * Copyright 2001, 2002, 2003, 2004 by Mark Hall
+ *
+ * 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.rtf.graphic;
+
+import java.io.ByteArrayInputStream;
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+
+import com.lowagie.text.DocumentException;
+import com.lowagie.text.Element;
+import com.lowagie.text.Image;
+import com.lowagie.text.pdf.codec.wmf.MetaDo;
+import com.lowagie.text.rtf.RtfElement;
+import com.lowagie.text.rtf.document.RtfDocument;
+import com.lowagie.text.rtf.style.RtfParagraphStyle;
+import com.lowagie.text.rtf.text.RtfParagraph;
+
+
+/**
+ * The RtfImage contains one image. Supported image types are jpeg, png, wmf, bmp.
+ *
+ * @version $Revision: 1.23 $
+ * @author Mark Hall (mhall@edu.uni-klu.ac.at)
+ * @author Paulo Soares
+ */
+public class RtfImage extends RtfElement {
+
+ /**
+ * Constant for the shape/picture group
+ */
+ private static final byte[] PICTURE_GROUP = "\\*\\shppict".getBytes();
+ /**
+ * Constant for a picture
+ */
+ private static final byte[] PICTURE = "\\pict".getBytes();
+ /**
+ * Constant for a jpeg image
+ */
+ private static final byte[] PICTURE_JPEG = "\\jpegblip".getBytes();
+ /**
+ * Constant for a png image
+ */
+ private static final byte[] PICTURE_PNG = "\\pngblip".getBytes();
+ /**
+ * Constant for a bmp image
+ */
+ private static final byte[] PICTURE_BMP = "\\dibitmap0".getBytes();
+ /**
+ * Constant for a wmf image
+ */
+ private static final byte[] PICTURE_WMF = "\\wmetafile8".getBytes();
+ /**
+ * Constant for the picture width
+ */
+ private static final byte[] PICTURE_WIDTH = "\\picw".getBytes();
+ /**
+ * Constant for the picture height
+ */
+ private static final byte[] PICTURE_HEIGHT = "\\pich".getBytes();
+ /**
+ * Constant for the picture width scale
+ */
+ private static final byte[] PICTURE_SCALED_WIDTH = "\\picwgoal".getBytes();
+ /**
+ * Constant for the picture height scale
+ */
+ private static final byte[] PICTURE_SCALED_HEIGHT = "\\pichgoal".getBytes();
+
+ /**
+ * The type of image this is.
+ */
+ private int imageType = Image.ORIGINAL_NONE;
+ /**
+ * The actual image. Already formated for direct inclusion in the rtf document
+ */
+ private byte[] image = new byte[0];
+ /**
+ * The alignment of this picture
+ */
+ private int alignment = Element.ALIGN_LEFT;
+ /**
+ * The width of this picture
+ */
+ private float width = 0;
+ /**
+ * The height of this picutre
+ */
+ private float height = 0;
+ /**
+ * The intended display width of this picture
+ */
+ private float plainWidth = 0;
+ /**
+ * The intended display height of this picture
+ */
+ private float plainHeight = 0;
+ /**
+ * Whether this RtfImage is a top level element and should
+ * be an extra paragraph.
+ */
+ private boolean topLevelElement = false;
+
+ /**
+ * Constructs a RtfImage for an Image.
+ *
+ * @param doc The RtfDocument this RtfImage belongs to
+ * @param image The Image that this RtfImage wraps
+ * @throws DocumentException If an error occured accessing the image content
+ */
+ public RtfImage(RtfDocument doc, Image image) throws DocumentException {
+ super(doc);
+ imageType = image.getOriginalType();
+ if (!(imageType == Image.ORIGINAL_JPEG || imageType == Image.ORIGINAL_BMP
+ || imageType == Image.ORIGINAL_PNG || imageType == Image.ORIGINAL_WMF)) {
+ throw new DocumentException("Only BMP, PNG, WMF and JPEG images are supported by the RTF Writer");
+ }
+ alignment = image.alignment();
+ width = image.width();
+ height = image.height();
+ plainWidth = image.plainWidth();
+ plainHeight = image.plainHeight();
+ this.image = getImage(image);
+ }
+
+ /**
+ * Extracts the image data from the Image. The data is formated for direct inclusion
+ * in a rtf document
+ *
+ * @param image The Image for which to extract the content
+ * @return The image data formated for the rtf document
+ * @throws DocumentException If an error occurs accessing the image content
+ */
+ private byte[] getImage(Image image) throws DocumentException {
+ ByteArrayOutputStream imageTemp = new ByteArrayOutputStream();
+ try {
+ InputStream imageIn;
+ if (imageType == Image.ORIGINAL_BMP) {
+ imageIn = new ByteArrayInputStream(MetaDo.wrapBMP(image));
+ } else {
+ if (image.getOriginalData() == null) {
+ imageIn = image.url().openStream();
+ } else {
+ imageIn = new ByteArrayInputStream(image.getOriginalData());
+ }
+ if (imageType == Image.ORIGINAL_WMF) { //remove the placeable header
+ long skipLength = 22;
+ while(skipLength > 0) {
+ skipLength = skipLength - imageIn.skip(skipLength);
+ }
+ }
+ }
+ int buffer = 0;
+ int count = 0;
+ while((buffer = imageIn.read()) != -1) {
+ String helperStr = Integer.toHexString(buffer);
+ if (helperStr.length() < 2) helperStr = "0" + helperStr;
+ imageTemp.write(helperStr.getBytes());
+ count++;
+ if (count == 64) {
+ imageTemp.write((byte) '\n');
+ count = 0;
+ }
+ }
+ } catch(IOException ioe) {
+ throw new DocumentException(ioe.getMessage());
+ }
+ return imageTemp.toByteArray();
+ }
+
+ /**
+ * Writes the RtfImage content
+ *
+ * @return the RtfImage content
+ */
+ public byte[] write() {
+ ByteArrayOutputStream result = new ByteArrayOutputStream();
+ try {
+ if(this.topLevelElement) {
+ result.write(RtfParagraph.PARAGRAPH_DEFAULTS);
+ }
+ switch(alignment) {
+ case Element.ALIGN_LEFT:
+ result.write(RtfParagraphStyle.ALIGN_LEFT);
+ break;
+ case Element.ALIGN_RIGHT:
+ result.write(RtfParagraphStyle.ALIGN_RIGHT);
+ break;
+ case Element.ALIGN_CENTER:
+ result.write(RtfParagraphStyle.ALIGN_CENTER);
+ break;
+ case Element.ALIGN_JUSTIFIED:
+ result.write(RtfParagraphStyle.ALIGN_JUSTIFY);
+ break;
+ }
+ result.write(OPEN_GROUP);
+ result.write(PICTURE_GROUP);
+ result.write(OPEN_GROUP);
+ result.write(PICTURE);
+ switch(imageType) {
+ case Image.ORIGINAL_JPEG:
+ result.write(PICTURE_JPEG);
+ break;
+ case Image.ORIGINAL_PNG:
+ result.write(PICTURE_PNG);
+ break;
+ case Image.ORIGINAL_WMF:
+ case Image.ORIGINAL_BMP:
+ result.write(PICTURE_WMF);
+ break;
+ }
+ result.write(PICTURE_WIDTH);
+ result.write(intToByteArray((int) width));
+ result.write(PICTURE_HEIGHT);
+ result.write(intToByteArray((int) height));
+ if(width != plainWidth || this.imageType == Image.ORIGINAL_BMP) {
+ result.write(PICTURE_SCALED_WIDTH);
+ result.write(intToByteArray((int) (plainWidth * RtfElement.TWIPS_FACTOR)));
+ }
+ if(height != plainHeight || this.imageType == Image.ORIGINAL_BMP) {
+ result.write(PICTURE_SCALED_HEIGHT);
+ result.write(intToByteArray((int) (plainHeight * RtfElement.TWIPS_FACTOR)));
+ }
+ result.write(DELIMITER);
+ result.write((byte) '\n');
+ result.write(image);
+ result.write(CLOSE_GROUP);
+ result.write(CLOSE_GROUP);
+ if(this.topLevelElement) {
+ result.write(RtfParagraph.PARAGRAPH);
+ result.write(RtfParagraph.PARAGRAPH);
+ }
+ result.write((byte) '\n');
+ } catch(IOException ioe) {
+ ioe.printStackTrace();
+ }
+ return result.toByteArray();
+ }
+
+ /**
+ * Sets the alignment of this RtfImage. Uses the alignments from com.lowagie.text.Element.
+ *
+ * @param alignment The alignment to use.
+ */
+ public void setAlignment(int alignment) {
+ this.alignment = alignment;
+ }
+
+ /**
+ * Set whether this RtfImage should behave like a top level element
+ * and enclose itself in a paragraph.
+ *
+ * @param topLevelElement Whether to behave like a top level element.
+ */
+ public void setTopLevelElement(boolean topLevelElement) {
+ this.topLevelElement = topLevelElement;
+ }
+}
diff --git a/src/main/java/com/lowagie/text/rtf/headerfooter/RtfHeaderFooter.java b/src/main/java/com/lowagie/text/rtf/headerfooter/RtfHeaderFooter.java new file mode 100644 index 0000000..d338f71 --- /dev/null +++ b/src/main/java/com/lowagie/text/rtf/headerfooter/RtfHeaderFooter.java @@ -0,0 +1,326 @@ +/*
+ * Created on Aug 10, 2004
+ *
+ * To change the template for this generated file go to
+ * Window - Preferences - Java - Code Generation - Code and Comments
+ */
+package com.lowagie.text.rtf.headerfooter;
+
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+
+import com.lowagie.text.DocumentException;
+import com.lowagie.text.Element;
+import com.lowagie.text.HeaderFooter;
+import com.lowagie.text.Image;
+import com.lowagie.text.Paragraph;
+import com.lowagie.text.Phrase;
+import com.lowagie.text.Table;
+import com.lowagie.text.rtf.RtfBasicElement;
+import com.lowagie.text.rtf.document.RtfDocument;
+import com.lowagie.text.rtf.field.RtfPageNumber;
+
+
+/**
+ * The RtfHeaderFooter represents one header or footer. This class can be used
+ * directly.
+ *
+ * @version $Id: RtfHeaderFooter.java,v 1.9 2005/09/21 15:26:01 hallm Exp $
+ * @author Mark Hall (mhall@edu.uni-klu.ac.at)
+ */
+public class RtfHeaderFooter extends HeaderFooter implements RtfBasicElement {
+
+ /**
+ * Constant for the header type
+ */
+ public static final int TYPE_HEADER = 1;
+ /**
+ * Constant for the footer type
+ */
+ public static final int TYPE_FOOTER = 2;
+ /**
+ * Constant for displaying the header/footer on the first page
+ */
+ public static final int DISPLAY_FIRST_PAGE = 0;
+ /**
+ * Constant for displaying the header/footer on all pages
+ */
+ public static final int DISPLAY_ALL_PAGES = 1;
+ /**
+ * Constant for displaying the header/footer on all left hand pages
+ */
+ public static final int DISPLAY_LEFT_PAGES = 2;
+ /**
+ * Constant for displaying the header/footer on all right hand pages
+ */
+ public static final int DISPLAY_RIGHT_PAGES = 4;
+
+ /**
+ * Constant for a header on all pages
+ */
+ private static final byte[] HEADER_ALL = "\\header".getBytes();
+ /**
+ * Constant for a header on the first page
+ */
+ private static final byte[] HEADER_FIRST = "\\headerf".getBytes();
+ /**
+ * Constant for a header on all left hand pages
+ */
+ private static final byte[] HEADER_LEFT = "\\headerl".getBytes();
+ /**
+ * Constant for a header on all right hand pages
+ */
+ private static final byte[] HEADER_RIGHT = "\\headerr".getBytes();
+ /**
+ * Constant for a footer on all pages
+ */
+ private static final byte[] FOOTER_ALL = "\\footer".getBytes();
+ /**
+ * Constant for a footer on the first page
+ */
+ private static final byte[] FOOTER_FIRST = "\\footerf".getBytes();
+ /**
+ * Constnat for a footer on the left hand pages
+ */
+ private static final byte[] FOOTER_LEFT = "\\footerl".getBytes();
+ /**
+ * Constant for a footer on the right hand pages
+ */
+ private static final byte[] FOOTER_RIGHT = "\\footerr".getBytes();
+
+ /**
+ * The RtfDocument this RtfHeaderFooter belongs to
+ */
+ private RtfDocument document = null;
+ /**
+ * The content of this RtfHeaderFooter
+ */
+ private Object content = null;
+ /**
+ * The display type of this RtfHeaderFooter. TYPE_HEADER or TYPE_FOOTER
+ */
+ private int type = TYPE_HEADER;
+ /**
+ * The display location of this RtfHeaderFooter. DISPLAY_FIRST_PAGE,
+ * DISPLAY_LEFT_PAGES, DISPLAY_RIGHT_PAGES or DISPLAY_ALL_PAGES
+ */
+ private int displayAt = DISPLAY_ALL_PAGES;
+
+ /**
+ * Constructs a RtfHeaderFooter based on a HeaderFooter with a certain type and displayAt
+ * location. For internal use only.
+ *
+ * @param doc The RtfDocument this RtfHeaderFooter belongs to
+ * @param headerFooter The HeaderFooter to base this RtfHeaderFooter on
+ * @param type The type of RtfHeaderFooter
+ * @param displayAt The display location of this RtfHeaderFooter
+ */
+ protected RtfHeaderFooter(RtfDocument doc, HeaderFooter headerFooter, int type, int displayAt) {
+ super(new Phrase(""), false);
+ this.document = doc;
+ this.type = type;
+ this.displayAt = displayAt;
+ Paragraph par = new Paragraph();
+ par.setAlignment(headerFooter.alignment());
+ if (headerFooter.getBefore() != null) {
+ par.add(headerFooter.getBefore());
+ }
+ if (headerFooter.isNumbered()) {
+ par.add(new RtfPageNumber(this.document));
+ }
+ if (headerFooter.getAfter() != null) {
+ par.add(headerFooter.getAfter());
+ }
+ try {
+ if(this.document != null) {
+ content = this.document.getMapper().mapElement(par);
+ ((RtfBasicElement) this.content).setInHeader(true);
+ } else {
+ content = par;
+ }
+ } catch(DocumentException de) {
+ de.printStackTrace();
+ }
+ }
+
+ /**
+ * Constructs a RtfHeaderFooter as a copy of an existing RtfHeaderFooter.
+ * For internal use only.
+ *
+ * @param doc The RtfDocument this RtfHeaderFooter belongs to
+ * @param headerFooter The RtfHeaderFooter to copy
+ * @param displayAt The display location of this RtfHeaderFooter
+ */
+ protected RtfHeaderFooter(RtfDocument doc, RtfHeaderFooter headerFooter, int displayAt) {
+ super(new Phrase(""), false);
+ this.document = doc;
+ this.content = headerFooter.getContent();
+ this.displayAt = displayAt;
+ if(this.content instanceof Element) {
+ try {
+ this.content = this.document.getMapper().mapElement((Element) this.content);
+ } catch(DocumentException de) {
+ de.printStackTrace();
+ }
+ }
+ ((RtfBasicElement) this.content).setInHeader(true);
+ }
+
+ /**
+ * Constructs a RtfHeaderFooter for a HeaderFooter.
+ *
+ * @param doc The RtfDocument this RtfHeaderFooter belongs to
+ * @param headerFooter The HeaderFooter to base this RtfHeaderFooter on
+ */
+ protected RtfHeaderFooter(RtfDocument doc, HeaderFooter headerFooter) {
+ super(new Phrase(""), false);
+ this.document = doc;
+ Paragraph par = new Paragraph();
+ par.setAlignment(headerFooter.alignment());
+ if (headerFooter.getBefore() != null) {
+ par.add(headerFooter.getBefore());
+ }
+ if (headerFooter.isNumbered()) {
+ par.add(new RtfPageNumber(this.document));
+ }
+ if (headerFooter.getAfter() != null) {
+ par.add(headerFooter.getAfter());
+ }
+ try {
+ content = doc.getMapper().mapElement(par);
+ ((RtfBasicElement) this.content).setInHeader(true);
+ } catch(DocumentException de) {
+ de.printStackTrace();
+ }
+ }
+
+ /**
+ * Constructs a RtfHeaderFooter for any Element.
+ *
+ * @param element The Element to display as content of this RtfHeaderFooter
+ */
+ public RtfHeaderFooter(Element element) {
+ super(new Phrase(""), false);
+ this.content = element;
+ }
+
+ /**
+ * Sets the RtfDocument this RtfElement belongs to
+ *
+ * @param doc The RtfDocument to use
+ */
+ public void setRtfDocument(RtfDocument doc) {
+ this.document = doc;
+ if(this.document != null) {
+ try {
+ if(this.content instanceof Element) {
+ this.content = this.document.getMapper().mapElement((Element) this.content);
+ ((RtfBasicElement) this.content).setInHeader(true);
+ } else if(this.content instanceof RtfBasicElement){
+ ((RtfBasicElement) this.content).setRtfDocument(this.document);
+ ((RtfBasicElement) this.content).setInHeader(true);
+ }
+ } catch(DocumentException de) {
+ de.printStackTrace();
+ }
+ }
+ }
+
+ /**
+ * Writes the content of this RtfHeaderFooter
+ *
+ * @return A byte array with the content of this RtfHeaderFooter
+ */
+ public byte[] write() {
+ ByteArrayOutputStream result = new ByteArrayOutputStream();
+ try {
+ result.write(OPEN_GROUP);
+ if(this.type == TYPE_HEADER) {
+ if(this.displayAt == DISPLAY_ALL_PAGES) {
+ result.write(HEADER_ALL);
+ } else if(this.displayAt == DISPLAY_FIRST_PAGE) {
+ result.write(HEADER_FIRST);
+ } else if(this.displayAt == DISPLAY_LEFT_PAGES) {
+ result.write(HEADER_LEFT);
+ } else if(this.displayAt == DISPLAY_RIGHT_PAGES) {
+ result.write(HEADER_RIGHT);
+ }
+ } else {
+ if(this.displayAt == DISPLAY_ALL_PAGES) {
+ result.write(FOOTER_ALL);
+ } else if(this.displayAt == DISPLAY_FIRST_PAGE) {
+ result.write(FOOTER_FIRST);
+ } else if(this.displayAt == DISPLAY_LEFT_PAGES) {
+ result.write(FOOTER_LEFT);
+ } else if(this.displayAt == DISPLAY_RIGHT_PAGES) {
+ result.write(FOOTER_RIGHT);
+ }
+ }
+ result.write(DELIMITER);
+ if(content instanceof RtfBasicElement) {
+ result.write(((RtfBasicElement) this.content).write());
+ }
+ result.write(CLOSE_GROUP);
+ } catch(IOException ioe) {
+ ioe.printStackTrace();
+ }
+ return result.toByteArray();
+ }
+
+
+ /**
+ * Sets the display location of this RtfHeaderFooter
+ *
+ * @param displayAt The display location to use.
+ */
+ public void setDisplayAt(int displayAt) {
+ this.displayAt = displayAt;
+ }
+
+ /**
+ * Sets the type of this RtfHeaderFooter
+ *
+ * @param type The type to use.
+ */
+ public void setType(int type) {
+ this.type = type;
+ }
+
+ /**
+ * Gets the content of this RtfHeaderFooter
+ *
+ * @return The content of this RtfHeaderFooter
+ */
+ private Object getContent() {
+ return this.content;
+ }
+
+ /**
+ * Unused
+ * @param inTable
+ */
+ public void setInTable(boolean inTable) {
+ }
+
+ /**
+ * Unused
+ * @param inHeader
+ */
+ public void setInHeader(boolean inHeader) {
+ }
+
+ /**
+ * Set the alignment of this RtfHeaderFooter. Passes the setting
+ * on to the contained element.
+ */
+ public void setAlignment(int alignment) {
+ super.setAlignment(alignment);
+ if(this.content instanceof Paragraph) {
+ ((Paragraph) this.content).setAlignment(alignment);
+ } else if(this.content instanceof Table) {
+ ((Table) this.content).setAlignment(alignment);
+ } else if(this.content instanceof Image) {
+ ((Image) this.content).setAlignment(alignment);
+ }
+ }
+}
diff --git a/src/main/java/com/lowagie/text/rtf/headerfooter/RtfHeaderFooterGroup.java b/src/main/java/com/lowagie/text/rtf/headerfooter/RtfHeaderFooterGroup.java new file mode 100644 index 0000000..e0934bf --- /dev/null +++ b/src/main/java/com/lowagie/text/rtf/headerfooter/RtfHeaderFooterGroup.java @@ -0,0 +1,393 @@ +/*
+ * Created on Aug 6, 2004
+ *
+ * To change the template for this generated file go to
+ * Window - Preferences - Java - Code Generation - Code and Comments
+ */
+package com.lowagie.text.rtf.headerfooter;
+
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+
+import com.lowagie.text.HeaderFooter;
+import com.lowagie.text.Phrase;
+import com.lowagie.text.rtf.RtfBasicElement;
+import com.lowagie.text.rtf.document.RtfDocument;
+
+
+/**
+ * The RtfHeaderFooterGroup holds 0 - 3 RtfHeaderFooters that create a group
+ * of headers or footers.
+ *
+ * @version $Version:$
+ * @author Mark Hall (mhall@edu.uni-klu.ac.at)
+ */
+public class RtfHeaderFooterGroup extends HeaderFooter implements RtfBasicElement {
+
+ /**
+ * This RtfHeaderFooterGroup contains no RtfHeaderFooter objects
+ */
+ private static final int MODE_NONE = 0;
+ /**
+ * This RtfHeaderFooterGroup contains one RtfHeaderFooter object
+ */
+ private static final int MODE_SINGLE = 1;
+ /**
+ * This RtfHeaderFooterGroup contains two or three RtfHeaderFooter objects
+ */
+ private static final int MODE_MULTIPLE = 2;
+
+ /**
+ * The current mode of this RtfHeaderFooterGroup. Defaults to MODE_NONE
+ */
+ private int mode = MODE_NONE;
+ /**
+ * The current type of this RtfHeaderFooterGroup. Defaults to RtfHeaderFooter.TYPE_HEADER
+ */
+ private int type = RtfHeaderFooter.TYPE_HEADER;
+
+ /**
+ * The RtfHeaderFooter for all pages
+ */
+ private RtfHeaderFooter headerAll = null;
+ /**
+ * The RtfHeaderFooter for the first page
+ */
+ private RtfHeaderFooter headerFirst = null;
+ /**
+ * The RtfHeaderFooter for the left hand pages
+ */
+ private RtfHeaderFooter headerLeft = null;
+ /**
+ * The RtfHeaderFooter for the right hand pages
+ */
+ private RtfHeaderFooter headerRight = null;
+ /**
+ * The RtfDocument this RtfHeaderFooterGroup belongs to
+ */
+ private RtfDocument document = null;
+
+ /**
+ * Constructs a RtfHeaderGroup to which you add headers/footers using
+ * via the setHeaderFooter method.
+ *
+ */
+ public RtfHeaderFooterGroup() {
+ super(new Phrase(""), false);
+ this.mode = MODE_NONE;
+ }
+
+ /**
+ * Constructs a certain type of RtfHeaderFooterGroup. RtfHeaderFooter.TYPE_HEADER
+ * and RtfHeaderFooter.TYPE_FOOTER are valid values for type.
+ *
+ * @param doc The RtfDocument this RtfHeaderFooter belongs to
+ * @param type The type of RtfHeaderFooterGroup to create
+ */
+ public RtfHeaderFooterGroup(RtfDocument doc, int type) {
+ super(new Phrase(""), false);
+ this.document = doc;
+ this.type = type;
+ }
+
+ /**
+ * Constructs a RtfHeaderFooterGroup by copying the content of the original
+ * RtfHeaderFooterGroup
+ *
+ * @param doc The RtfDocument this RtfHeaderFooter belongs to
+ * @param headerFooter The RtfHeaderFooterGroup to copy
+ * @param type The type of RtfHeaderFooterGroup to create
+ */
+ public RtfHeaderFooterGroup(RtfDocument doc, RtfHeaderFooterGroup headerFooter, int type) {
+ super(new Phrase(""), false);
+ this.document = doc;
+ this.mode = headerFooter.getMode();
+ this.type = type;
+ if(headerFooter.getHeaderAll() != null) {
+ this.headerAll = new RtfHeaderFooter(this.document, headerFooter.getHeaderAll(), RtfHeaderFooter.DISPLAY_ALL_PAGES);
+ }
+ if(headerFooter.getHeaderFirst() != null) {
+ this.headerFirst = new RtfHeaderFooter(this.document, headerFooter.getHeaderFirst(), RtfHeaderFooter.DISPLAY_FIRST_PAGE);
+ }
+ if(headerFooter.getHeaderLeft() != null) {
+ this.headerLeft = new RtfHeaderFooter(this.document, headerFooter.getHeaderLeft(), RtfHeaderFooter.DISPLAY_LEFT_PAGES);
+ }
+ if(headerFooter.getHeaderRight() != null) {
+ this.headerRight = new RtfHeaderFooter(this.document, headerFooter.getHeaderRight(), RtfHeaderFooter.DISPLAY_RIGHT_PAGES);
+ }
+ setType(this.type);
+ }
+
+ /**
+ * Constructs a RtfHeaderFooterGroup for a certain RtfHeaderFooter.
+ *
+ * @param doc The RtfDocument this RtfHeaderFooter belongs to
+ * @param headerFooter The RtfHeaderFooter to display
+ * @param type The typ of RtfHeaderFooterGroup to create
+ */
+ public RtfHeaderFooterGroup(RtfDocument doc, RtfHeaderFooter headerFooter, int type) {
+ super(new Phrase(""), false);
+ this.document = doc;
+ this.type = type;
+ this.mode = MODE_SINGLE;
+ headerAll = new RtfHeaderFooter(doc, headerFooter, RtfHeaderFooter.DISPLAY_ALL_PAGES);
+ headerAll.setType(this.type);
+ }
+
+ /**
+ * Constructs a RtfHeaderGroup for a certain HeaderFooter
+ *
+ * @param doc The RtfDocument this RtfHeaderFooter belongs to
+ * @param headerFooter The HeaderFooter to display
+ * @param type The typ of RtfHeaderFooterGroup to create
+ */
+ public RtfHeaderFooterGroup(RtfDocument doc, HeaderFooter headerFooter, int type) {
+ super(new Phrase(""), false);
+ this.document = doc;
+ this.type = type;
+ this.mode = MODE_SINGLE;
+ headerAll = new RtfHeaderFooter(doc, headerFooter, type, RtfHeaderFooter.DISPLAY_ALL_PAGES);
+ headerAll.setType(this.type);
+ }
+
+ /**
+ * Sets the RtfDocument this RtfElement belongs to
+ *
+ * @param doc The RtfDocument to use
+ */
+ public void setRtfDocument(RtfDocument doc) {
+ this.document = doc;
+ if(headerAll != null) {
+ headerAll.setRtfDocument(this.document);
+ }
+ if(headerFirst != null) {
+ headerFirst.setRtfDocument(this.document);
+ }
+ if(headerLeft != null) {
+ headerLeft.setRtfDocument(this.document);
+ }
+ if(headerRight != null) {
+ headerRight.setRtfDocument(this.document);
+ }
+ }
+
+ /**
+ * Write the content of this RtfHeaderFooterGroup.
+ *
+ * @return A byte array with the content of this RtfHeaderFooterGroup
+ */
+ public byte[] write() {
+ ByteArrayOutputStream result = new ByteArrayOutputStream();
+ try {
+ if(this.mode == MODE_SINGLE) {
+ result.write(headerAll.write());
+ } else if(this.mode == MODE_MULTIPLE) {
+ if(headerFirst != null) {
+ result.write(headerFirst.write());
+ }
+ if(headerLeft != null) {
+ result.write(headerLeft.write());
+ }
+ if(headerRight != null) {
+ result.write(headerRight.write());
+ }
+ if(headerAll != null) {
+ result.write(headerAll.write());
+ }
+ }
+ } catch(IOException ioe) {
+ ioe.printStackTrace();
+ }
+ return result.toByteArray();
+ }
+
+ /**
+ * Set a RtfHeaderFooter to be displayed at a certain position
+ *
+ * @param headerFooter The RtfHeaderFooter to display
+ * @param displayAt The display location to use
+ */
+ public void setHeaderFooter(RtfHeaderFooter headerFooter, int displayAt) {
+ this.mode = MODE_MULTIPLE;
+ headerFooter.setRtfDocument(this.document);
+ headerFooter.setType(this.type);
+ headerFooter.setDisplayAt(displayAt);
+ switch(displayAt) {
+ case RtfHeaderFooter.DISPLAY_ALL_PAGES:
+ headerAll = headerFooter;
+ break;
+ case RtfHeaderFooter.DISPLAY_FIRST_PAGE:
+ headerFirst = headerFooter;
+ break;
+ case RtfHeaderFooter.DISPLAY_LEFT_PAGES:
+ headerLeft = headerFooter;
+ break;
+ case RtfHeaderFooter.DISPLAY_RIGHT_PAGES:
+ headerRight = headerFooter;
+ break;
+ }
+ }
+
+ /**
+ * Set a HeaderFooter to be displayed at a certain position
+ *
+ * @param headerFooter The HeaderFooter to set
+ * @param displayAt The display location to use
+ */
+ public void setHeaderFooter(HeaderFooter headerFooter, int displayAt) {
+ this.mode = MODE_MULTIPLE;
+ switch(displayAt) {
+ case RtfHeaderFooter.DISPLAY_ALL_PAGES:
+ headerAll = new RtfHeaderFooter(this.document, headerFooter, this.type, displayAt);
+ break;
+ case RtfHeaderFooter.DISPLAY_FIRST_PAGE:
+ headerFirst = new RtfHeaderFooter(this.document, headerFooter, this.type, displayAt);
+ break;
+ case RtfHeaderFooter.DISPLAY_LEFT_PAGES:
+ headerLeft = new RtfHeaderFooter(this.document, headerFooter, this.type, displayAt);
+ break;
+ case RtfHeaderFooter.DISPLAY_RIGHT_PAGES:
+ headerRight = new RtfHeaderFooter(this.document, headerFooter, this.type, displayAt);
+ break;
+ }
+ }
+
+ /**
+ * Set that this RtfHeaderFooterGroup should have a title page. If only
+ * a header / footer for all pages exists, then it will be copied to the
+ * first page aswell.
+ */
+ public void setHasTitlePage() {
+ if(this.mode == MODE_SINGLE) {
+ this.mode = MODE_MULTIPLE;
+ headerFirst = new RtfHeaderFooter(this.document, headerAll, RtfHeaderFooter.DISPLAY_FIRST_PAGE);
+ headerFirst.setType(this.type);
+ }
+ }
+
+ /**
+ * Set that this RtfHeaderFooterGroup should have facing pages. If only
+ * a header / footer for all pages exists, then it will be copied to the left
+ * and right pages aswell.
+ */
+ public void setHasFacingPages() {
+ if(this.mode == MODE_SINGLE) {
+ this.mode = MODE_MULTIPLE;
+ this.headerLeft = new RtfHeaderFooter(this.document, this.headerAll, RtfHeaderFooter.DISPLAY_LEFT_PAGES);
+ this.headerLeft.setType(this.type);
+ this.headerRight = new RtfHeaderFooter(this.document, this.headerAll, RtfHeaderFooter.DISPLAY_RIGHT_PAGES);
+ this.headerRight.setType(this.type);
+ this.headerAll = null;
+ } else if(this.mode == MODE_MULTIPLE) {
+ if(this.headerLeft == null && this.headerAll != null) {
+ this.headerLeft = new RtfHeaderFooter(this.document, this.headerAll, RtfHeaderFooter.DISPLAY_LEFT_PAGES);
+ this.headerLeft.setType(this.type);
+ }
+ if(this.headerRight == null && this.headerAll != null) {
+ this.headerRight = new RtfHeaderFooter(this.document, this.headerAll, RtfHeaderFooter.DISPLAY_RIGHT_PAGES);
+ this.headerRight.setType(this.type);
+ }
+ this.headerAll = null;
+ }
+ }
+
+ /**
+ * Get whether this RtfHeaderFooterGroup has a titlepage
+ *
+ * @return Whether this RtfHeaderFooterGroup has a titlepage
+ */
+ public boolean hasTitlePage() {
+ return (headerFirst != null);
+ }
+
+ /**
+ * Get whether this RtfHeaderFooterGroup has facing pages
+ *
+ * @return Whether this RtfHeaderFooterGroup has facing pages
+ */
+ public boolean hasFacingPages() {
+ return (headerLeft != null || headerRight != null);
+ }
+
+ /**
+ * Unused
+ * @param inTable
+ */
+ public void setInTable(boolean inTable) {
+ }
+
+ /**
+ * Unused
+ * @param inHeader
+ */
+ public void setInHeader(boolean inHeader) {
+ }
+
+ /**
+ * Set the type of this RtfHeaderFooterGroup. RtfHeaderFooter.TYPE_HEADER
+ * or RtfHeaderFooter.TYPE_FOOTER. Also sets the type for all RtfHeaderFooters
+ * of this RtfHeaderFooterGroup.
+ *
+ * @param type The type to use
+ */
+ public void setType(int type) {
+ this.type = type;
+ if(headerAll != null) {
+ headerAll.setType(this.type);
+ }
+ if(headerFirst != null) {
+ headerFirst.setType(this.type);
+ }
+ if(headerLeft != null) {
+ headerLeft.setType(this.type);
+ }
+ if(headerRight != null) {
+ headerRight.setType(this.type);
+ }
+ }
+
+ /**
+ * Gets the mode of this RtfHeaderFooterGroup
+ *
+ * @return The mode of this RtfHeaderFooterGroup
+ */
+ protected int getMode() {
+ return this.mode;
+ }
+
+ /**
+ * Gets the RtfHeaderFooter for all pages
+ *
+ * @return The RtfHeaderFooter for all pages
+ */
+ protected RtfHeaderFooter getHeaderAll() {
+ return headerAll;
+ }
+
+ /**
+ * Gets the RtfHeaderFooter for the title page
+ *
+ * @return The RtfHeaderFooter for the title page
+ */
+ protected RtfHeaderFooter getHeaderFirst() {
+ return headerFirst;
+ }
+
+ /**
+ * Gets the RtfHeaderFooter for all left hand pages
+ *
+ * @return The RtfHeaderFooter for all left hand pages
+ */
+ protected RtfHeaderFooter getHeaderLeft() {
+ return headerLeft;
+ }
+
+ /**
+ * Gets the RtfHeaderFooter for all right hand pages
+ *
+ * @return The RtfHeaderFooter for all right hand pages
+ */
+ protected RtfHeaderFooter getHeaderRight() {
+ return headerRight;
+ }
+}
diff --git a/src/main/java/com/lowagie/text/rtf/list/RtfList.java b/src/main/java/com/lowagie/text/rtf/list/RtfList.java new file mode 100644 index 0000000..cfa5c33 --- /dev/null +++ b/src/main/java/com/lowagie/text/rtf/list/RtfList.java @@ -0,0 +1,605 @@ +/*
+ * $Id: RtfList.java,v 1.19 2006/04/05 09:30:47 hallm Exp $
+ * $Name: $
+ *
+ * Copyright 2001, 2002, 2003, 2004, 2005 by Mark Hall
+ *
+ * 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.rtf.list;
+
+import java.awt.Color;
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.util.ArrayList;
+
+import com.lowagie.text.Chunk;
+import com.lowagie.text.DocumentException;
+import com.lowagie.text.Element;
+import com.lowagie.text.Font;
+import com.lowagie.text.List;
+import com.lowagie.text.ListItem;
+import com.lowagie.text.rtf.RtfBasicElement;
+import com.lowagie.text.rtf.RtfElement;
+import com.lowagie.text.rtf.RtfExtendedElement;
+import com.lowagie.text.rtf.style.RtfFont;
+import com.lowagie.text.rtf.style.RtfFontList;
+import com.lowagie.text.rtf.style.RtfParagraphStyle;
+import com.lowagie.text.rtf.text.RtfParagraph;
+import com.lowagie.text.rtf.document.RtfDocument;
+
+
+/**
+ * The RtfList stores one List. It also provides the methods to write the
+ * list declaration and the list data.
+ *
+ * @version $Version:$
+ * @author Mark Hall (mhall@edu.uni-klu.ac.at)
+ */
+public class RtfList extends RtfElement implements RtfExtendedElement {
+
+ /**
+ * Constant for list level
+ */
+ private static final byte[] LIST_LEVEL = "\\listlevel".getBytes();
+ /**
+ * Constant for list level style old
+ */
+ private static final byte[] LIST_LEVEL_TYPE = "\\levelnfc".getBytes();
+ /**
+ * Constant for list level style new
+ */
+ private static final byte[] LIST_LEVEL_TYPE_NEW = "\\levelnfcn".getBytes();
+ /**
+ * Constant for list level alignment old
+ */
+ private static final byte[] LIST_LEVEL_ALIGNMENT = "\\leveljc".getBytes();
+ /**
+ * Constant for list level alignment new
+ */
+ private static final byte[] LIST_LEVEL_ALIGNMENT_NEW = "\\leveljcn".getBytes();
+ /**
+ * Constant for list level start at
+ */
+ private static final byte[] LIST_LEVEL_START_AT = "\\levelstartat".getBytes();
+ /**
+ * Constant for list level text
+ */
+ private static final byte[] LIST_LEVEL_TEXT = "\\leveltext".getBytes();
+ /**
+ * Constant for the beginning of the list level numbered style
+ */
+ private static final byte[] LIST_LEVEL_STYLE_NUMBERED_BEGIN = "\\\'02\\\'".getBytes();
+ /**
+ * Constant for the end of the list level numbered style
+ */
+ private static final byte[] LIST_LEVEL_STYLE_NUMBERED_END = ".;".getBytes();
+ /**
+ * Constant for the list level bulleted style
+ */
+ private static final byte[] LIST_LEVEL_STYLE_BULLETED = "\\\'01\\u-3913 ?;".getBytes();
+ /**
+ * Constant for the beginning of the list level numbers
+ */
+ private static final byte[] LIST_LEVEL_NUMBERS_BEGIN = "\\levelnumbers".getBytes();
+ /**
+ * Constant for the list level numbers
+ */
+ private static final byte[] LIST_LEVEL_NUMBERS_NUMBERED = "\\\'01".getBytes();
+ /**
+ * Constant for the end of the list level numbers
+ */
+ private static final byte[] LIST_LEVEL_NUMBERS_END = ";".getBytes();
+ /**
+ * Constant for the first indentation
+ */
+ private static final byte[] LIST_LEVEL_FIRST_INDENT = "\\fi".getBytes();
+ /**
+ * Constant for the symbol indentation
+ */
+ private static final byte[] LIST_LEVEL_SYMBOL_INDENT = "\\tx".getBytes();
+ /**
+ * Constant for the list level value
+ */
+ private static final byte[] LIST_LEVEL_NUMBER = "\\ilvl".getBytes();
+ /**
+ * Constant for a tab character
+ */
+ private static final byte[] TAB = "\\tab".getBytes();
+ /**
+ * Constant for the old list text
+ */
+ private static final byte[] LIST_TEXT = "\\listtext".getBytes();
+ /**
+ * Constant for the old list number end
+ */
+ private static final byte[] LIST_NUMBER_END = ".".getBytes();
+ /**
+ * Constant for the old bulleted list
+ */
+ private static final byte[] LIST_BULLET = "\\\'b7".getBytes();
+
+ /**
+ * The subitems of this RtfList
+ */
+ private ArrayList items;
+ /**
+ * The level of this RtfList
+ */
+ private int listLevel = 0;
+ /**
+ * The first indentation of this RtfList
+ */
+ private int firstIndent = 0;
+ /**
+ * The left indentation of this RtfList
+ */
+ private int leftIndent = 0;
+ /**
+ * The right indentation of this RtfList
+ */
+ private int rightIndent = 0;
+ /**
+ * The symbol indentation of this RtfList
+ */
+ private int symbolIndent = 0;
+ /**
+ * The list number of this RtfList
+ */
+ private int listNumber = 1;
+ /**
+ * Whether this RtfList is numbered
+ */
+ private boolean numbered = true;
+ /**
+ * The RtfFont for numbered lists
+ */
+ private RtfFont fontNumber;
+ /**
+ * The RtfFont for bulleted lists
+ */
+ private RtfFont fontBullet;
+ /**
+ * The alignment of this RtfList
+ */
+ private int alignment = Element.ALIGN_LEFT;
+ /**
+ * The parent List in multi-level lists.
+ */
+ private RtfList parentList = null;
+
+ /**
+ * Constructs a new RtfList for the specified List.
+ *
+ * @param doc The RtfDocument this RtfList belongs to
+ * @param list The List this RtfList is based on
+ */
+ public RtfList(RtfDocument doc, List list) {
+ super(doc);
+
+ this.listNumber = document.getDocumentHeader().getListNumber(this);
+
+ this.items = new ArrayList();
+ if(list.symbolIndent() > 0 && list.indentationLeft() > 0) {
+ this.firstIndent = (int) (list.symbolIndent() * RtfElement.TWIPS_FACTOR * -1);
+ this.leftIndent = (int) ((list.indentationLeft() + list.symbolIndent()) * RtfElement.TWIPS_FACTOR);
+ } else if(list.symbolIndent() > 0) {
+ this.firstIndent = (int) (list.symbolIndent() * RtfElement.TWIPS_FACTOR * -1);
+ this.leftIndent = (int) (list.symbolIndent() * RtfElement.TWIPS_FACTOR);
+ } else if(list.indentationLeft() > 0) {
+ this.firstIndent = 0;
+ this.leftIndent = (int) (list.indentationLeft() * RtfElement.TWIPS_FACTOR);
+ } else {
+ this.firstIndent = 0;
+ this.leftIndent = 0;
+ }
+ this.rightIndent = (int) (list.indentationRight() * RtfElement.TWIPS_FACTOR);
+ this.symbolIndent = (int) ((list.symbolIndent() + list.indentationLeft()) * RtfElement.TWIPS_FACTOR);
+ this.numbered = list.isNumbered();
+
+ for(int i = 0; i < list.getItems().size(); i++) {
+ try {
+ Element element = (Element) list.getItems().get(i);
+ if(element.type() == Element.CHUNK) {
+ element = new ListItem((Chunk) element);
+ }
+ if(element instanceof ListItem) {
+ this.alignment = ((ListItem) element).alignment();
+ }
+ RtfBasicElement rtfElement = doc.getMapper().mapElement(element);
+ if(rtfElement instanceof RtfList) {
+ ((RtfList) rtfElement).setListNumber(listNumber);
+ ((RtfList) rtfElement).setListLevel(listLevel + 1);
+ ((RtfList) rtfElement).setParent(this);
+ } else if(rtfElement instanceof RtfListItem) {
+ ((RtfListItem) rtfElement).setParent(this);
+ ((RtfListItem) rtfElement).inheritListSettings(listNumber, listLevel + 1);
+ }
+ items.add(rtfElement);
+ } catch(DocumentException de) {
+ de.printStackTrace();
+ }
+ }
+
+ if(this.listLevel == 0) {
+ correctIndentation();
+ }
+
+ fontNumber = new RtfFont(document, new Font(Font.TIMES_ROMAN, 10, Font.NORMAL, new Color(0, 0, 0)));
+ fontBullet = new RtfFont(document, new Font(Font.SYMBOL, 10, Font.NORMAL, new Color(0, 0, 0)));
+ }
+
+ private byte[] writeIndentations() {
+ ByteArrayOutputStream result = new ByteArrayOutputStream();
+ try {
+ result.write(LIST_LEVEL_FIRST_INDENT);
+ result.write(intToByteArray(firstIndent));
+ result.write(RtfParagraphStyle.INDENT_LEFT);
+ result.write(intToByteArray(leftIndent));
+ result.write(RtfParagraphStyle.INDENT_RIGHT);
+ result.write(intToByteArray(rightIndent));
+ } catch(IOException ioe) {
+ ioe.printStackTrace();
+ }
+ return result.toByteArray();
+ }
+
+ /**
+ * Writes the definition part of this list level
+ *
+ * @return A byte array containing the definition of this list level
+ */
+ public byte[] writeDefinition() {
+ ByteArrayOutputStream result = new ByteArrayOutputStream();
+ try {
+ result.write(OPEN_GROUP);
+ result.write(LIST_LEVEL);
+ result.write(LIST_LEVEL_TYPE);
+ if(numbered) {
+ result.write(intToByteArray(0));
+ } else {
+ result.write(intToByteArray(23));
+ }
+ result.write(LIST_LEVEL_TYPE_NEW);
+ if(numbered) {
+ result.write(intToByteArray(0));
+ } else {
+ result.write(intToByteArray(23));
+ }
+ result.write(LIST_LEVEL_ALIGNMENT);
+ result.write(intToByteArray(0));
+ result.write(LIST_LEVEL_ALIGNMENT_NEW);
+ result.write(intToByteArray(0));
+ result.write(LIST_LEVEL_START_AT);
+ result.write(intToByteArray(1));
+ result.write(OPEN_GROUP);
+ result.write(LIST_LEVEL_TEXT);
+ if(numbered) {
+ result.write(LIST_LEVEL_STYLE_NUMBERED_BEGIN);
+ if(listLevel < 10) {
+ result.write(intToByteArray(0));
+ }
+ result.write(intToByteArray(listLevel));
+ result.write(LIST_LEVEL_STYLE_NUMBERED_END);
+ } else {
+ result.write(LIST_LEVEL_STYLE_BULLETED);
+ }
+ result.write(CLOSE_GROUP);
+ result.write(OPEN_GROUP);
+ result.write(LIST_LEVEL_NUMBERS_BEGIN);
+ if(numbered) {
+ result.write(LIST_LEVEL_NUMBERS_NUMBERED);
+ }
+ result.write(LIST_LEVEL_NUMBERS_END);
+ result.write(CLOSE_GROUP);
+ result.write(RtfFontList.FONT_NUMBER);
+ if(numbered) {
+ result.write(intToByteArray(fontNumber.getFontNumber()));
+ } else {
+ result.write(intToByteArray(fontBullet.getFontNumber()));
+ }
+ result.write(writeIndentations());
+ result.write(LIST_LEVEL_SYMBOL_INDENT);
+ result.write(intToByteArray(this.leftIndent));
+ result.write(CLOSE_GROUP);
+ result.write("\n".getBytes());
+ for(int i = 0; i < items.size(); i++) {
+ RtfElement rtfElement = (RtfElement) items.get(i);
+ if(rtfElement instanceof RtfList) {
+ result.write(((RtfList) rtfElement).writeDefinition());
+ break;
+ } else if(rtfElement instanceof RtfListItem) {
+ byte[] data = ((RtfListItem) rtfElement).writeDefinition();
+ if(data.length > 0) {
+ result.write(data);
+ break;
+ }
+ }
+ }
+ } catch(IOException ioe) {
+ ioe.printStackTrace();
+ }
+ return result.toByteArray();
+ }
+
+ /**
+ * Writes the initialisation part of the RtfList
+ *
+ * @return A byte array containing the initialisation part
+ */
+ protected byte[] writeListBeginning() {
+ ByteArrayOutputStream result = new ByteArrayOutputStream();
+ try {
+ result.write(RtfParagraph.PARAGRAPH_DEFAULTS);
+ if(this.inTable) {
+ result.write(RtfParagraph.IN_TABLE);
+ }
+ switch (this.alignment) {
+ case Element.ALIGN_LEFT:
+ result.write(RtfParagraphStyle.ALIGN_LEFT);
+ break;
+ case Element.ALIGN_RIGHT:
+ result.write(RtfParagraphStyle.ALIGN_RIGHT);
+ break;
+ case Element.ALIGN_CENTER:
+ result.write(RtfParagraphStyle.ALIGN_CENTER);
+ break;
+ case Element.ALIGN_JUSTIFIED:
+ case Element.ALIGN_JUSTIFIED_ALL:
+ result.write(RtfParagraphStyle.ALIGN_JUSTIFY);
+ break;
+ }
+ result.write(writeIndentations());
+ result.write(RtfFont.FONT_SIZE);
+ result.write(intToByteArray(fontNumber.getFontSize() * 2));
+ if(this.symbolIndent > 0) { // TODO This is a slight hack. Replace with a call to tab support when implemented.
+ result.write("\\tx".getBytes());
+ result.write(intToByteArray(this.leftIndent));
+ }
+ } catch(IOException ioe) {
+ ioe.printStackTrace();
+ }
+ return result.toByteArray();
+ }
+
+ /**
+ * Writes only the list number and list level number.
+ *
+ * @return The list number and list level number of this RtfList.
+ */
+ protected byte[] writeListNumbers() {
+ ByteArrayOutputStream result = new ByteArrayOutputStream();
+ try {
+ result.write(RtfListTable.LIST_NUMBER);
+ result.write(intToByteArray(listNumber));
+ if(listLevel > 0) {
+ result.write(LIST_LEVEL_NUMBER);
+ result.write(intToByteArray(listLevel));
+ }
+ } catch(IOException ioe) {
+ ioe.printStackTrace();
+ }
+ return result.toByteArray();
+ }
+
+ /**
+ * Writes the content of the RtfList
+ *
+ * @return A byte array containing the actual content of the RtfList
+ */
+ public byte[] write() {
+ ByteArrayOutputStream result = new ByteArrayOutputStream();
+ try {
+ result.write(writeListBeginning());
+ result.write(writeListNumbers());
+ result.write(OPEN_GROUP);
+ int itemNr = 0;
+ for(int i = 0; i < items.size(); i++) {
+ RtfElement rtfElement = (RtfElement) items.get(i);
+ if(rtfElement instanceof RtfListItem) {
+ itemNr++;
+ result.write(OPEN_GROUP);
+ result.write(LIST_TEXT);
+ result.write(RtfParagraph.PARAGRAPH_DEFAULTS);
+ if(this.inTable) {
+ result.write(RtfParagraph.IN_TABLE);
+ }
+ result.write(RtfFontList.FONT_NUMBER);
+ if(numbered) {
+ result.write(intToByteArray(fontNumber.getFontNumber()));
+ } else {
+ result.write(intToByteArray(fontBullet.getFontNumber()));
+ }
+ result.write(writeIndentations());
+ result.write(DELIMITER);
+ if(numbered) {
+ result.write(this.intToByteArray(itemNr));
+ result.write(LIST_NUMBER_END);
+ } else {
+ result.write(LIST_BULLET);
+ }
+ result.write(TAB);
+ result.write(CLOSE_GROUP);
+ result.write(rtfElement.write());
+ result.write(RtfParagraph.PARAGRAPH);
+ if(((RtfListItem) rtfElement).isContainsInnerList()) {
+ result.write(writeListNumbers());
+ }
+ result.write("\n".getBytes());
+ } else if(rtfElement instanceof RtfList) {
+ result.write(rtfElement.write());
+ result.write(writeListBeginning());
+ result.write("\n".getBytes());
+ }
+ }
+ result.write(CLOSE_GROUP);
+ if(!this.inTable) {
+ result.write(RtfParagraph.PARAGRAPH_DEFAULTS);
+ }
+ } catch(IOException ioe) {
+ ioe.printStackTrace();
+ }
+ return result.toByteArray();
+ }
+
+
+ /**
+ * Gets the list level of this RtfList
+ *
+ * @return Returns the list level.
+ */
+ public int getListLevel() {
+ return listLevel;
+ }
+
+ /**
+ * Sets the list level of this RtfList. A list level > 0 will
+ * unregister this RtfList from the RtfListTable
+ *
+ * @param listLevel The list level to set.
+ */
+ public void setListLevel(int listLevel) {
+ this.listLevel = listLevel;
+ if(this.listLevel != 0) {
+ document.getDocumentHeader().freeListNumber(this);
+ for(int i = 0; i < this.items.size(); i++) {
+ if(this.items.get(i) instanceof RtfList) {
+ ((RtfList) this.items.get(i)).setListNumber(this.listNumber);
+ ((RtfList) this.items.get(i)).setListLevel(this.listLevel + 1);
+ }
+ }
+ } else {
+ this.listNumber = document.getDocumentHeader().getListNumber(this);
+ }
+ }
+
+ /**
+ * Sets the parent RtfList of this RtfList
+ *
+ * @param parent The parent RtfList to use.
+ */
+ protected void setParent(RtfList parent) {
+ this.parentList = parent;
+ }
+
+ /**
+ * Gets the id of this list
+ *
+ * @return Returns the list number.
+ */
+ public int getListNumber() {
+ return listNumber;
+ }
+
+ /**
+ * Sets the id of this list
+ *
+ * @param listNumber The list number to set.
+ */
+ public void setListNumber(int listNumber) {
+ this.listNumber = listNumber;
+ }
+
+ /**
+ * Sets whether this RtfList is in a table. Sets the correct inTable setting for all
+ * child elements.
+ *
+ * @param inTable <code>True</code> if this RtfList is in a table, <code>false</code> otherwise
+ */
+ public void setInTable(boolean inTable) {
+ super.setInTable(inTable);
+ for(int i = 0; i < this.items.size(); i++) {
+ ((RtfBasicElement) this.items.get(i)).setInTable(inTable);
+ }
+ }
+
+ /**
+ * Sets whether this RtfList is in a header. Sets the correct inTable setting for all
+ * child elements.
+ *
+ * @param inHeader <code>True</code> if this RtfList is in a header, <code>false</code> otherwise
+ */
+ public void setInHeader(boolean inHeader) {
+ super.setInHeader(inHeader);
+ for(int i = 0; i < this.items.size(); i++) {
+ ((RtfBasicElement) this.items.get(i)).setInHeader(inHeader);
+ }
+ }
+
+ /**
+ * Correct the indentation of this RtfList by adding left/first line indentation
+ * from the parent RtfList. Also calls correctIndentation on all child RtfLists.
+ */
+ protected void correctIndentation() {
+ if(this.parentList != null) {
+ this.leftIndent = this.leftIndent + this.parentList.getLeftIndent() + this.parentList.getFirstIndent();
+ }
+ for(int i = 0; i < this.items.size(); i++) {
+ if(this.items.get(i) instanceof RtfList) {
+ ((RtfList) this.items.get(i)).correctIndentation();
+ } else if(this.items.get(i) instanceof RtfListItem) {
+ ((RtfListItem) this.items.get(i)).correctIndentation();
+ }
+ }
+ }
+
+ /**
+ * Get the left indentation of this RtfList.
+ *
+ * @return The left indentation.
+ */
+ private int getLeftIndent() {
+ return this.leftIndent;
+ }
+
+ /**
+ * Get the first line indentation of this RtfList.
+ *
+ * @return The first line indentation.
+ */
+ private int getFirstIndent() {
+ return this.firstIndent;
+ }
+}
diff --git a/src/main/java/com/lowagie/text/rtf/list/RtfListItem.java b/src/main/java/com/lowagie/text/rtf/list/RtfListItem.java new file mode 100644 index 0000000..9e5b184 --- /dev/null +++ b/src/main/java/com/lowagie/text/rtf/list/RtfListItem.java @@ -0,0 +1,182 @@ +/*
+ * $Id: RtfListItem.java,v 1.11 2006/04/05 09:30:47 hallm Exp $
+ * $Name: $
+ *
+ * Copyright 2001, 2002, 2003, 2004, 2005 by Mark Hall
+ *
+ * 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.rtf.list;
+
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+
+import com.lowagie.text.ListItem;
+import com.lowagie.text.rtf.RtfBasicElement;
+import com.lowagie.text.rtf.document.RtfDocument;
+import com.lowagie.text.rtf.text.RtfChunk;
+import com.lowagie.text.rtf.text.RtfParagraph;
+
+
+/**
+ * The RtfListItem acts as a wrapper for a ListItem.
+ *
+ * @version $Version:$
+ * @author Mark Hall (mhall@edu.uni-klu.ac.at)
+ */
+public class RtfListItem extends RtfParagraph {
+
+ /**
+ * The RtfList this RtfListItem belongs to.
+ */
+ private RtfList parentList = null;
+ /**
+ * Whether this RtfListItem contains further RtfLists.
+ */
+ private boolean containsInnerList = false;
+
+ /**
+ * Constructs a RtfListItem for a ListItem belonging to a RtfDocument.
+ *
+ * @param doc The RtfDocument this RtfListItem belongs to.
+ * @param listItem The ListItem this RtfListItem is based on.
+ */
+ public RtfListItem(RtfDocument doc, ListItem listItem) {
+ super(doc, listItem);
+ }
+
+ /**
+ * Writes the content of this RtfListItem.
+ *
+ * @return A byte array with the content of this RtfListItem.
+ */
+ public byte[] write() {
+ ByteArrayOutputStream result = new ByteArrayOutputStream();
+ try {
+ for(int i = 0; i < chunks.size(); i++) {
+ RtfBasicElement rtfElement = (RtfBasicElement) chunks.get(i);
+ if(rtfElement instanceof RtfChunk) {
+ ((RtfChunk) rtfElement).setSoftLineBreaks(true);
+ } else if(rtfElement instanceof RtfList) {
+ result.write(RtfParagraph.PARAGRAPH);
+ this.containsInnerList = true;
+ }
+ result.write(rtfElement.write());
+ if(rtfElement instanceof RtfList) {
+ result.write(this.parentList.writeListBeginning());
+ result.write("\\tab".getBytes());
+ }
+ }
+ } catch(IOException ioe) {
+ ioe.printStackTrace();
+ }
+ return result.toByteArray();
+ }
+
+ /**
+ * Returns the definition of the first list contained in this RtfListItem or
+ * an empty byte array if no inner RtfLists exist.
+ *
+ * @return The definition of the first inner RtfList or an empty byte array.
+ */
+ public byte[] writeDefinition() {
+ for(int i = 0; i < chunks.size(); i++) {
+ RtfBasicElement rtfElement = (RtfBasicElement) chunks.get(i);
+ if(rtfElement instanceof RtfList) {
+ return ((RtfList) rtfElement).writeDefinition();
+ }
+ }
+ return new byte[0];
+ }
+
+ /**
+ * Inherit the list settings from the parent list to RtfLists that
+ * are contained in this RtfListItem.
+ *
+ * @param listNumber The list number to inherit.
+ * @param listLevel The list level to inherit.
+ */
+ public void inheritListSettings(int listNumber, int listLevel) {
+ for(int i = 0; i < chunks.size(); i++) {
+ RtfBasicElement rtfElement = (RtfBasicElement) chunks.get(i);
+ if(rtfElement instanceof RtfList) {
+ ((RtfList) rtfElement).setListNumber(listNumber);
+ ((RtfList) rtfElement).setListLevel(listLevel);
+ ((RtfList) rtfElement).setParent(this.parentList);
+ }
+ }
+ }
+
+ /**
+ * Correct the indentation of RtfLists in this RtfListItem by adding left/first line indentation
+ * from the parent RtfList. Also calls correctIndentation on all child RtfLists.
+ */
+ protected void correctIndentation() {
+ for(int i = 0; i < chunks.size(); i++) {
+ RtfBasicElement rtfElement = (RtfBasicElement) chunks.get(i);
+ if(rtfElement instanceof RtfList) {
+ ((RtfList) rtfElement).correctIndentation();
+ }
+ }
+ }
+
+ /**
+ * Set the parent RtfList.
+ *
+ * @param parentList The parent RtfList to use.
+ */
+ public void setParent(RtfList parentList) {
+ this.parentList = parentList;
+ }
+
+ /**
+ * Gets whether this RtfListItem contains further RtfLists.
+ *
+ * @return Whether this RtfListItem contains further RtfLists.
+ */
+ public boolean isContainsInnerList() {
+ return this.containsInnerList;
+ }
+}
diff --git a/src/main/java/com/lowagie/text/rtf/list/RtfListTable.java b/src/main/java/com/lowagie/text/rtf/list/RtfListTable.java new file mode 100644 index 0000000..ee10c94 --- /dev/null +++ b/src/main/java/com/lowagie/text/rtf/list/RtfListTable.java @@ -0,0 +1,202 @@ +/*
+ * $Id: RtfListTable.java,v 1.16 2005/05/04 14:33:45 blowagie Exp $
+ * $Name: $
+ *
+ * Copyright 2001, 2002, 2003, 2004 by Mark Hall
+ *
+ * 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.rtf.list;
+
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.util.ArrayList;
+
+import com.lowagie.text.rtf.RtfElement;
+import com.lowagie.text.rtf.RtfExtendedElement;
+import com.lowagie.text.rtf.document.RtfDocument;
+
+
+/**
+ * The RtfListTable manages all RtfLists in one RtfDocument. It also generates
+ * the list and list override tables in the document header.
+ *
+ * @version $Version:$
+ * @author Mark Hall (mhall@edu.uni-klu.ac.at)
+ */
+public class RtfListTable extends RtfElement implements RtfExtendedElement {
+
+ /**
+ * Constant for the list number
+ */
+ protected static final byte[] LIST_NUMBER = "\\ls".getBytes();
+ /**
+ * Constant for the list table
+ */
+ private static final byte[] LIST_TABLE = "\\*\\listtable".getBytes();
+ /**
+ * Constant for the list
+ */
+ private static final byte[] LIST = "\\list".getBytes();
+ /**
+ * Constant for the list template id
+ */
+ private static final byte[] LIST_TEMPLATE_ID = "\\listtemplateid".getBytes();
+ /**
+ * Constant for the hybrid list
+ */
+ private static final byte[] LIST_HYBRID = "\\hybrid".getBytes();
+ /**
+ * Constant for the list id
+ */
+ private static final byte[] LIST_ID = "\\listid".getBytes();
+ /**
+ * Constant for the list override table
+ */
+ private static final byte[] LIST_OVERRIDE_TABLE = "\\*\\listoverridetable".getBytes();
+ /**
+ * Constant for the list override
+ */
+ private static final byte[] LIST_OVERRIDE = "\\listoverride".getBytes();
+ /**
+ * Constant for the list override count
+ */
+ private static final byte[] LIST_OVERRIDE_COUNT = "\\listoverridecount".getBytes();
+
+ /**
+ * The RtfLists managed by this RtfListTable
+ */
+ private ArrayList lists;
+
+ /**
+ * Constructs a RtfListTable for a RtfDocument
+ *
+ * @param doc The RtfDocument this RtfListTable belongs to
+ */
+ public RtfListTable(RtfDocument doc) {
+ super(doc);
+
+ this.lists = new ArrayList();
+ }
+
+ /**
+ * Writes the list and list override tables.
+ *
+ * @return A byte array with the list and list override tables.
+ */
+ public byte[] writeDefinition() {
+ ByteArrayOutputStream result = new ByteArrayOutputStream();
+ int[] listIds = new int[lists.size()];
+ try {
+ result.write(OPEN_GROUP);
+ result.write(LIST_TABLE);
+ result.write("\n".getBytes());
+ for(int i = 0; i < lists.size(); i++) {
+ result.write(OPEN_GROUP);
+ result.write(LIST);
+ result.write(LIST_TEMPLATE_ID);
+ result.write(intToByteArray(document.getRandomInt()));
+ result.write(LIST_HYBRID);
+ result.write("\n".getBytes());
+ result.write(((RtfList) lists.get(i)).writeDefinition());
+ result.write(LIST_ID);
+ listIds[i] = document.getRandomInt();
+ result.write(intToByteArray(listIds[i]));
+ result.write(CLOSE_GROUP);
+ result.write("\n".getBytes());
+ }
+ result.write(CLOSE_GROUP);
+ result.write("\n".getBytes());
+ result.write(OPEN_GROUP);
+ result.write(LIST_OVERRIDE_TABLE);
+ result.write("\n".getBytes());
+ for(int i = 0; i < lists.size(); i++) {
+ result.write(OPEN_GROUP);
+ result.write(LIST_OVERRIDE);
+ result.write(LIST_ID);
+ result.write(intToByteArray(listIds[i]));
+ result.write(LIST_OVERRIDE_COUNT);
+ result.write(intToByteArray(0));
+ result.write(LIST_NUMBER);
+ result.write(intToByteArray(((RtfList) lists.get(i)).getListNumber()));
+ result.write(CLOSE_GROUP);
+ result.write("\n".getBytes());
+ }
+ result.write(CLOSE_GROUP);
+ result.write("\n".getBytes());
+ } catch(IOException ioe) {
+ ioe.printStackTrace();
+ }
+ return result.toByteArray();
+ }
+
+ /**
+ * Gets the id of the specified RtfList. If the RtfList is not yet in the
+ * list of RtfLists, then it is added.
+ *
+ * @param list The RtfList for which to get the id.
+ * @return The id of the RtfList.
+ */
+ public int getListNumber(RtfList list) {
+ if(lists.contains(list)) {
+ return lists.indexOf(list);
+ } else {
+ lists.add(list);
+ return lists.size();
+ }
+ }
+
+ /**
+ * Remove a RtfList from the list of RtfLists
+ *
+ * @param list The RtfList to remove.
+ */
+ public void freeListNumber(RtfList list) {
+ int i = lists.indexOf(list);
+ if(i >= 0) {
+ lists.remove(i);
+ }
+ }
+}
diff --git a/src/main/java/com/lowagie/text/rtf/style/RtfColor.java b/src/main/java/com/lowagie/text/rtf/style/RtfColor.java new file mode 100644 index 0000000..aca4ea2 --- /dev/null +++ b/src/main/java/com/lowagie/text/rtf/style/RtfColor.java @@ -0,0 +1,302 @@ +/*
+ * $Id: RtfColor.java,v 1.7 2004/12/14 12:51:59 blowagie Exp $
+ * $Name: $
+ *
+ * Copyright 2001, 2002, 2003, 2004 by Mark Hall
+ *
+ * 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.rtf.style;
+
+import java.awt.Color;
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+
+import com.lowagie.text.rtf.RtfElement;
+import com.lowagie.text.rtf.RtfExtendedElement;
+import com.lowagie.text.rtf.document.RtfDocument;
+
+
+/**
+ * The RtfColor stores one rtf color value for a rtf document
+ *
+ * @version $Version:$
+ * @author Mark Hall (mhall@edu.uni-klu.ac.at)
+ */
+public class RtfColor extends RtfElement implements RtfExtendedElement {
+
+ /**
+ * Constant for RED value
+ */
+ private static final byte[] COLOR_RED = "\\red".getBytes();
+ /**
+ * Constant for GREEN value
+ */
+ private static final byte[] COLOR_GREEN = "\\green".getBytes();
+ /**
+ * Constant for BLUE value
+ */
+ private static final byte[] COLOR_BLUE = "\\blue".getBytes();
+ /**
+ * Constant for the end of one color entry
+ */
+ private static final byte COLON = (byte) ';';
+ /**
+ * Constant for the number of the colour in the list of colours
+ */
+ private static final byte[] COLOR_NUMBER = "\\cf".getBytes();
+
+ /**
+ * The number of the colour in the list of colours
+ */
+ private int colorNumber = 0;
+ /**
+ * The red value
+ */
+ private int red = 0;
+ /**
+ * The green value
+ */
+ private int green = 0;
+ /**
+ * The blue value
+ */
+ private int blue = 0;
+
+ /**
+ * Constructor only for use when initializing the RtfColorList
+ *
+ * @param doc The RtfDocument this RtfColor belongs to
+ * @param red The red value to use
+ * @param green The green value to use
+ * @param blue The blue value to use
+ * @param colorNumber The number of the colour in the colour list
+ */
+ protected RtfColor(RtfDocument doc, int red, int green, int blue, int colorNumber) {
+ super(doc);
+ this.red = red;
+ this.blue = blue;
+ this.green = green;
+ this.colorNumber = colorNumber;
+ }
+
+ /**
+ * Constructs a RtfColor as a clone of an existing RtfColor
+ *
+ * @param doc The RtfDocument this RtfColor belongs to
+ * @param col The RtfColor to use as a base
+ */
+ public RtfColor(RtfDocument doc, RtfColor col) {
+ super(doc);
+ if(col != null) {
+ this.red = col.getRed();
+ this.green = col.getGreen();
+ this.blue = col.getBlue();
+ }
+ if(this.document != null) {
+ this.colorNumber = this.document.getDocumentHeader().getColorNumber(this);
+ }
+ }
+
+ /**
+ * Constructs a RtfColor based on the Color
+ *
+ * @param doc The RtfDocument this RtfColor belongs to
+ * @param col The Color to base this RtfColor on
+ */
+ public RtfColor(RtfDocument doc, Color col) {
+ super(doc);
+ if(col != null) {
+ this.red = col.getRed();
+ this.blue = col.getBlue();
+ this.green = col.getGreen();
+ }
+ if(this.document != null) {
+ this.colorNumber = this.document.getDocumentHeader().getColorNumber(this);
+ }
+ }
+
+ /**
+ * Constructs a RtfColor based on the red/green/blue values
+ *
+ * @param doc The RtfDocument this RtfColor belongs to
+ * @param red The red value to use
+ * @param green The green value to use
+ * @param blue The blue value to use
+ */
+ public RtfColor(RtfDocument doc, int red, int green, int blue) {
+ super(doc);
+ this.red = red;
+ this.blue = blue;
+ this.green = green;
+ if(this.document != null) {
+ this.colorNumber = this.document.getDocumentHeader().getColorNumber(this);
+ }
+ }
+
+ /**
+ * Write the definition part of this RtfColor.
+ *
+ * @return A byte array with the definition of this colour
+ */
+ public byte[] writeDefinition() {
+ ByteArrayOutputStream result = new ByteArrayOutputStream();
+ try {
+ result.write(COLOR_RED);
+ result.write(intToByteArray(red));
+ result.write(COLOR_GREEN);
+ result.write(intToByteArray(green));
+ result.write(COLOR_BLUE);
+ result.write(intToByteArray(blue));
+ result.write(COLON);
+ } catch(IOException ioe) {
+ ioe.printStackTrace();
+ }
+ return result.toByteArray();
+ }
+
+ /**
+ * Writes the beginning of this RtfColor
+ *
+ * @return A byte array with the colour start data
+ */
+ public byte[] writeBegin() {
+ ByteArrayOutputStream result = new ByteArrayOutputStream();
+ try {
+ result.write(COLOR_NUMBER);
+ result.write(intToByteArray(colorNumber));
+ } catch(IOException ioe) {
+ ioe.printStackTrace();
+ }
+ return result.toByteArray();
+ }
+
+ /**
+ * Unused
+ *
+ * @return An empty (<code>byte[0]</code>) byte array
+ */
+ public byte[] writeEnd() {
+ return new byte[0];
+ }
+
+ /**
+ * Tests if this RtfColor is equal to another RtfColor.
+ *
+ * @param obj another RtfColor
+ * @return <code>True</code> if red, green and blue values of the two colours match,
+ * <code>false</code> otherwise.
+ */
+ public boolean equals(Object obj) {
+ if(!(obj instanceof RtfColor)) {
+ return false;
+ }
+ RtfColor color = (RtfColor) obj;
+ if(this.red == color.getRed() && this.green == color.getGreen() && this.blue == color.getBlue()) {
+ return true;
+ } else {
+ return false;
+ }
+ }
+
+ /**
+ * Returns the hash code of this RtfColor. The hash code is
+ * an integer with the lowest three bytes containing the values
+ * of red, green and blue.
+ *
+ * @return The hash code of this RtfColor
+ */
+ public int hashCode() {
+ return (this.red << 16) | (this.green << 8) | this.blue;
+ }
+
+ /**
+ * Get the blue value of this RtfColor
+ *
+ * @return The blue value
+ */
+ public int getBlue() {
+ return blue;
+ }
+
+ /**
+ * Get the green value of this RtfColor
+ *
+ * @return The green value
+ */
+ public int getGreen() {
+ return green;
+ }
+
+ /**
+ * Get the red value of this RtfColor
+ *
+ * @return The red value
+ */
+ public int getRed() {
+ return red;
+ }
+
+ /**
+ * Gets the number of this RtfColor in the list of colours
+ *
+ * @return Returns the colorNumber.
+ */
+ public int getColorNumber() {
+ return colorNumber;
+ }
+
+ /**
+ * Sets the RtfDocument this RtfColor belongs to
+ *
+ * @param doc The RtfDocument to use
+ */
+ public void setRtfDocument(RtfDocument doc) {
+ super.setRtfDocument(doc);
+ if(document != null) {
+ this.colorNumber = document.getDocumentHeader().getColorNumber(this);
+ }
+ }
+}
diff --git a/src/main/java/com/lowagie/text/rtf/style/RtfColorList.java b/src/main/java/com/lowagie/text/rtf/style/RtfColorList.java new file mode 100644 index 0000000..ddb71d1 --- /dev/null +++ b/src/main/java/com/lowagie/text/rtf/style/RtfColorList.java @@ -0,0 +1,137 @@ +/*
+ * $Id: RtfColorList.java,v 1.16 2005/05/04 14:33:52 blowagie Exp $
+ * $Name: $
+ *
+ * Copyright 2001, 2002, 2003, 2004 by Mark Hall
+ *
+ * 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.rtf.style;
+
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.util.ArrayList;
+
+import com.lowagie.text.rtf.RtfElement;
+import com.lowagie.text.rtf.RtfExtendedElement;
+import com.lowagie.text.rtf.document.RtfDocument;
+
+
+/**
+ * The RtfColorList stores all colours that appear in the document. Black
+ * and White are always added
+ *
+ * @version $Version:$
+ * @author Mark Hall (mhall@edu.uni-klu.ac.at)
+ */
+public class RtfColorList extends RtfElement implements RtfExtendedElement {
+
+ /**
+ * Constant for the beginning of the colour table
+ */
+ private static final byte[] COLOR_TABLE = "\\colortbl".getBytes();
+
+ /**
+ * ArrayList containing all colours of this RtfColorList
+ */
+ ArrayList colorList = new ArrayList();
+
+ /**
+ * Constructs a new RtfColorList for the RtfDocument. Will add the default
+ * black and white colours.
+ *
+ * @param doc The RtfDocument this RtfColorList belongs to
+ */
+ public RtfColorList(RtfDocument doc) {
+ super(doc);
+ colorList.add(new RtfColor(doc, 0, 0, 0, 0));
+ colorList.add(new RtfColor(doc, 255, 255, 255, 1));
+ }
+
+ /**
+ * Returns the index of the given RtfColor in the colour list. If the RtfColor
+ * is not in the list of colours, then it is added.
+ *
+ * @param color The RtfColor for which to get the index
+ * @return The index of the RtfColor
+ */
+ public int getColorNumber(RtfColor color) {
+ int colorIndex = -1;
+ for(int i = 0; i < colorList.size(); i++) {
+ if(colorList.get(i).equals(color)) {
+ colorIndex = i;
+ }
+ }
+ if(colorIndex == -1) {
+ colorIndex = colorList.size();
+ colorList.add(color);
+ }
+ return colorIndex;
+ }
+
+ /**
+ * Write the definition part of the colour list. Calls the writeDefinition
+ * methods of the RtfColors in the colour list.
+ *
+ * @return A byte array with the definition colour list
+ */
+ public byte[] writeDefinition() {
+ ByteArrayOutputStream result = new ByteArrayOutputStream();
+ try {
+ result.write(OPEN_GROUP);
+ result.write(COLOR_TABLE);
+ for(int i = 0; i < colorList.size(); i++) {
+ RtfColor color = (RtfColor) colorList.get(i);
+ result.write(color.writeDefinition());
+ }
+ result.write(CLOSE_GROUP);
+ result.write((byte)'\n');
+ } catch(IOException ioe) {
+ ioe.printStackTrace();
+ }
+ return result.toByteArray();
+ }
+
+}
diff --git a/src/main/java/com/lowagie/text/rtf/style/RtfFont.java b/src/main/java/com/lowagie/text/rtf/style/RtfFont.java new file mode 100644 index 0000000..150b0b2 --- /dev/null +++ b/src/main/java/com/lowagie/text/rtf/style/RtfFont.java @@ -0,0 +1,681 @@ +/*
+ * $Id: RtfFont.java,v 1.23 2006/02/09 17:11:31 hallm Exp $
+ * $Name: $
+ *
+ * Copyright 2001, 2002, 2003, 2004 by Mark Hall
+ *
+ * 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.rtf.style;
+
+import com.lowagie.text.rtf.RtfExtendedElement;
+import com.lowagie.text.rtf.document.RtfDocument;
+import com.lowagie.text.Font;
+
+import java.awt.Color;
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+
+/**
+ * The RtfFont class stores one font for an rtf document. It extends Font,
+ * so can be set as a font, to allow adding of fonts with arbitrary names.
+ * BaseFont fontname handling contributed by Craig Fleming. Various fixes
+ * Renaud Michel, Werner Daehn.
+ *
+ * Version: $Id: RtfFont.java,v 1.23 2006/02/09 17:11:31 hallm Exp $
+ * @author Mark Hall (mhall@edu.uni-klu.ac.at)
+ * @author Craig Fleming (rythos@rhana.dhs.org)
+ * @author Renaud Michel (r.michel@immedia.be)
+ * @author Werner Daehn (Werner.Daehn@BusinessObjects.com)
+ */
+public class RtfFont extends Font implements RtfExtendedElement {
+ /**
+ * Constant for the font family to use ("froman")
+ */
+ private static final byte[] FONT_FAMILY = "\\froman".getBytes();
+ /**
+ * Constant for the charset
+ */
+ private static final byte[] FONT_CHARSET = "\\fcharset".getBytes();
+ /**
+ * Constant for the font size
+ */
+ public static final byte[] FONT_SIZE = "\\fs".getBytes();
+ /**
+ * Constant for the bold flag
+ */
+ private static final byte[] FONT_BOLD = "\\b".getBytes();
+ /**
+ * Constant for the italic flag
+ */
+ private static final byte[] FONT_ITALIC = "\\i".getBytes();
+ /**
+ * Constant for the underline flag
+ */
+ private static final byte[] FONT_UNDERLINE = "\\ul".getBytes();
+ /**
+ * Constant for the strikethrough flag
+ */
+ private static final byte[] FONT_STRIKETHROUGH = "\\strike".getBytes();
+ /**
+ * Constant for the double strikethrough flag
+ */
+ private static final byte[] FONT_DOUBLE_STRIKETHROUGH = "\\striked".getBytes();
+ /**
+ * Constant for the shadow flag
+ */
+ private static final byte[] FONT_SHADOW = "\\shad".getBytes();
+ /**
+ * Constant for the outline flag
+ */
+ private static final byte[] FONT_OUTLINE = "\\outl".getBytes();
+ /**
+ * Constant for the embossed flag
+ */
+ private static final byte[] FONT_EMBOSSED = "\\embo".getBytes();
+ /**
+ * Constant for the engraved flag
+ */
+ private static final byte[] FONT_ENGRAVED = "\\impr".getBytes();
+ /**
+ * Constant for hidden text flag
+ */
+ private static final byte[] FONT_HIDDEN = "\\v".getBytes();
+
+ /**
+ * Constant for a plain font
+ */
+ public static final int STYLE_NONE = 0;
+ /**
+ * Constant for a bold font
+ */
+ public static final int STYLE_BOLD = 1;
+ /**
+ * Constant for an italic font
+ */
+ public static final int STYLE_ITALIC = 2;
+ /**
+ * Constant for an underlined font
+ */
+ public static final int STYLE_UNDERLINE = 4;
+ /**
+ * Constant for a strikethrough font
+ */
+ public static final int STYLE_STRIKETHROUGH = 8;
+ /**
+ * Constant for a double strikethrough font
+ */
+ public static final int STYLE_DOUBLE_STRIKETHROUGH = 16;
+ /**
+ * Constant for a shadowed font
+ */
+ public static final int STYLE_SHADOW = 32;
+ /**
+ * Constant for an outlined font
+ */
+ public static final int STYLE_OUTLINE = 64;
+ /**
+ * Constant for an embossed font
+ */
+ public static final int STYLE_EMBOSSED = 128;
+ /**
+ * Constant for an engraved font
+ */
+ public static final int STYLE_ENGRAVED = 256;
+ /**
+ * Constant for a font that hides the actual text.
+ */
+ public static final int STYLE_HIDDEN = 512;
+
+ /**
+ * The font name. Defaults to "Times New Roman"
+ */
+ private String fontName = "Times New Roman";
+ /**
+ * The font size. Defaults to 10
+ */
+ private int fontSize = 10;
+ /**
+ * The font style. Defaults to STYLE_NONE
+ */
+ private int fontStyle = STYLE_NONE;
+ /**
+ * The number of this font
+ */
+ private int fontNumber = 0;
+ /**
+ * The colour of this font
+ */
+ private RtfColor color = null;
+ /**
+ * The character set to use for this font
+ */
+ private int charset = 0;
+ /**
+ * The RtfDocument this RtfFont belongs to.
+ */
+ protected RtfDocument document = null;
+
+ /**
+ * Constructs a RtfFont with the given font name and all other properties
+ * at their default values.
+ *
+ * @param fontName The font name to use
+ */
+ public RtfFont(String fontName) {
+ super(Font.UNDEFINED, Font.UNDEFINED, Font.UNDEFINED, null);
+ this.fontName = fontName;
+ }
+
+ /**
+ * Constructs a RtfFont with the given font name and font size and all other
+ * properties at their default values.
+ *
+ * @param fontName The font name to use
+ * @param size The font size to use
+ */
+ public RtfFont(String fontName, float size) {
+ super(Font.UNDEFINED, size, Font.UNDEFINED, null);
+ this.fontName = fontName;
+ }
+
+ /**
+ * Constructs a RtfFont with the given font name, font size and font style and the
+ * default color.
+ *
+ * @param fontName The font name to use
+ * @param size The font size to use
+ * @param style The font style to use
+ */
+ public RtfFont(String fontName, float size, int style) {
+ super(Font.UNDEFINED, size, style, null);
+ this.fontName = fontName;
+ }
+
+ /**
+ * Constructs a RtfFont with the given font name, font size, font style and
+ * color.
+ *
+ * @param fontName The font name to use
+ * @param size the font size to use
+ * @param style The font style to use
+ * @param color The font color to use
+ */
+ public RtfFont(String fontName, float size, int style, Color color) {
+ super(Font.UNDEFINED, size, style, color);
+ this.fontName = fontName;
+ }
+
+ /**
+ * Special constructor for the default font
+ *
+ * @param doc The RtfDocument this font appears in
+ * @param fontNumber The id of this font
+ */
+ protected RtfFont(RtfDocument doc, int fontNumber) {
+ this.document = doc;
+ this.fontNumber = fontNumber;
+ color = new RtfColor(doc, 0, 0, 0);
+ }
+
+ /**
+ * Constructs a RtfFont from a com.lowagie.text.Font
+ * @param doc The RtfDocument this font appears in
+ * @param font The Font to use as a base
+ */
+ public RtfFont(RtfDocument doc, Font font) {
+ this.document = doc;
+ if(font != null) {
+ if(font instanceof RtfFont) {
+ this.fontName = ((RtfFont) font).getFontName();
+ } else {
+ setToDefaultFamily(font.getFamilyname());
+ }
+ if(font.getBaseFont() != null) {
+ String[][] fontNames = font.getBaseFont().getFullFontName();
+ for(int i = 0; i < fontNames.length; i++) {
+ if(fontNames[i][2].equals("0")) {
+ this.fontName = fontNames[i][3];
+ break;
+ } else if(fontNames[i][2].equals("1033") || fontNames[i][2].equals("")) {
+ this.fontName = fontNames[i][3];
+ }
+ }
+ }
+
+ setSize(font.size());
+ setStyle(font.style());
+ setColor(font.color());
+ }
+
+ if(this.fontName.equalsIgnoreCase("unknown")) {
+ return;
+ }
+
+ if(document != null) {
+ setRtfDocument(document);
+ }
+ }
+
+ /**
+ * Writes the font definition
+ *
+ * @return A byte array with the font definition
+ */
+ public byte[] writeDefinition() {
+ ByteArrayOutputStream result = new ByteArrayOutputStream();
+ try {
+ result.write(FONT_FAMILY);
+ result.write(FONT_CHARSET);
+ result.write(intToByteArray(charset));
+ result.write(DELIMITER);
+ result.write(document.filterSpecialChar(fontName, true, false).getBytes());
+ } catch(IOException ioe) {
+ ioe.printStackTrace();
+ }
+ return result.toByteArray();
+ }
+
+ /**
+ * Writes the font beginning
+ *
+ * @return A byte array with the font start data
+ */
+ public byte[] writeBegin() {
+ ByteArrayOutputStream result = new ByteArrayOutputStream();
+ try {
+ if(this.fontNumber != Font.UNDEFINED) {
+ result.write(RtfFontList.FONT_NUMBER);
+ result.write(intToByteArray(fontNumber));
+ }
+ if(this.fontSize != Font.UNDEFINED) {
+ result.write(FONT_SIZE);
+ result.write(intToByteArray(fontSize * 2));
+ }
+ if(this.fontStyle != UNDEFINED) {
+ if((fontStyle & STYLE_BOLD) == STYLE_BOLD) {
+ result.write(FONT_BOLD);
+ }
+ if((fontStyle & STYLE_ITALIC) == STYLE_ITALIC) {
+ result.write(FONT_ITALIC);
+ }
+ if((fontStyle & STYLE_UNDERLINE) == STYLE_UNDERLINE) {
+ result.write(FONT_UNDERLINE);
+ }
+ if((fontStyle & STYLE_STRIKETHROUGH) == STYLE_STRIKETHROUGH) {
+ result.write(FONT_STRIKETHROUGH);
+ }
+ if((fontStyle & STYLE_HIDDEN) == STYLE_HIDDEN) {
+ result.write(FONT_HIDDEN);
+ }
+ if((fontStyle & STYLE_DOUBLE_STRIKETHROUGH) == STYLE_DOUBLE_STRIKETHROUGH) {
+ result.write(FONT_DOUBLE_STRIKETHROUGH);
+ result.write(intToByteArray(1));
+ }
+ if((fontStyle & STYLE_SHADOW) == STYLE_SHADOW) {
+ result.write(FONT_SHADOW);
+ }
+ if((fontStyle & STYLE_OUTLINE) == STYLE_OUTLINE) {
+ result.write(FONT_OUTLINE);
+ }
+ if((fontStyle & STYLE_EMBOSSED) == STYLE_EMBOSSED) {
+ result.write(FONT_EMBOSSED);
+ }
+ if((fontStyle & STYLE_ENGRAVED) == STYLE_ENGRAVED) {
+ result.write(FONT_ENGRAVED);
+ }
+ }
+ if(color != null) {
+ result.write(color.writeBegin());
+ }
+ } catch(IOException ioe) {
+ ioe.printStackTrace();
+ }
+ return result.toByteArray();
+ }
+
+ /**
+ * Write the font end
+ *
+ * @return A byte array with the end of font data
+ */
+ public byte[] writeEnd() {
+ ByteArrayOutputStream result = new ByteArrayOutputStream();
+ try {
+ if(this.fontStyle != UNDEFINED) {
+ if((fontStyle & STYLE_BOLD) == STYLE_BOLD) {
+ result.write(FONT_BOLD);
+ result.write(intToByteArray(0));
+ }
+ if((fontStyle & STYLE_ITALIC) == STYLE_ITALIC) {
+ result.write(FONT_ITALIC);
+ result.write(intToByteArray(0));
+ }
+ if((fontStyle & STYLE_UNDERLINE) == STYLE_UNDERLINE) {
+ result.write(FONT_UNDERLINE);
+ result.write(intToByteArray(0));
+ }
+ if((fontStyle & STYLE_STRIKETHROUGH) == STYLE_STRIKETHROUGH) {
+ result.write(FONT_STRIKETHROUGH);
+ result.write(intToByteArray(0));
+ }
+ if((fontStyle & STYLE_HIDDEN) == STYLE_HIDDEN) {
+ result.write(FONT_HIDDEN);
+ result.write(intToByteArray(0));
+ }
+ if((fontStyle & STYLE_DOUBLE_STRIKETHROUGH) == STYLE_DOUBLE_STRIKETHROUGH) {
+ result.write(FONT_DOUBLE_STRIKETHROUGH);
+ result.write(intToByteArray(0));
+ }
+ if((fontStyle & STYLE_SHADOW) == STYLE_SHADOW) {
+ result.write(FONT_SHADOW);
+ result.write(intToByteArray(0));
+ }
+ if((fontStyle & STYLE_OUTLINE) == STYLE_OUTLINE) {
+ result.write(FONT_OUTLINE);
+ result.write(intToByteArray(0));
+ }
+ if((fontStyle & STYLE_EMBOSSED) == STYLE_EMBOSSED) {
+ result.write(FONT_EMBOSSED);
+ result.write(intToByteArray(0));
+ }
+ if((fontStyle & STYLE_ENGRAVED) == STYLE_ENGRAVED) {
+ result.write(FONT_ENGRAVED);
+ result.write(intToByteArray(0));
+ }
+ }
+ } catch(IOException ioe) {
+ ioe.printStackTrace();
+ }
+ return result.toByteArray();
+ }
+
+ /**
+ * Unused
+ * @return an empty byte array
+ */
+ public byte[] write() {
+ return new byte[0];
+ }
+
+ /**
+ * Tests for equality of RtfFonts. RtfFonts are equal if their fontName,
+ * fontSize, fontStyle and fontSuperSubscript are equal
+ *
+ * @param obj The RtfFont to compare with this RtfFont
+ * @return <code>True</code> if the RtfFonts are equal, <code>false</code> otherwise
+ */
+ public boolean equals(Object obj) {
+ if(!(obj instanceof RtfFont)) {
+ return false;
+ }
+ RtfFont font = (RtfFont) obj;
+ boolean result = true;
+ result = result & this.fontName.equals(font.getFontName());
+
+ return result;
+ }
+
+ /**
+ * Returns the hash code of this RtfFont. The hash code is the hash code of the
+ * string containing the font name + font size + "-" + the font style + "-" + the
+ * font super/supscript value.
+ *
+ * @return The hash code of this RtfFont
+ */
+ public int hashCode() {
+ return (this.fontName + this.fontSize + "-" + this.fontStyle).hashCode();
+ }
+
+ /**
+ * Gets the font name of this RtfFont
+ *
+ * @return The font name
+ */
+ public String getFontName() {
+ return this.fontName;
+ }
+
+ /**
+ * Sets the font name of this RtfFont.
+ *
+ * @param fontName The font name to use
+ */
+ protected void setFontName(String fontName) {
+ this.fontName = fontName;
+ if(document != null) {
+ this.fontNumber = document.getDocumentHeader().getFontNumber(this);
+ }
+ }
+
+ /**
+ * @see com.lowagie.text.Font#getFamilyname()
+ */
+ public String getFamilyname() {
+ return this.fontName;
+ }
+
+ /**
+ * @see com.lowagie.text.Font#setFamily(String)
+ */
+ public void setFamily(String family){
+ super.setFamily(family);
+ setToDefaultFamily(family);
+ }
+
+ /**
+ * Sets the correct font name from the family name.
+ *
+ * @param familyname The family name to set the name to.
+ */
+ private void setToDefaultFamily(String familyname){
+ switch (Font.getFamilyIndex(familyname)) {
+ case Font.COURIER:
+ this.fontName = "Courier";
+ break;
+ case Font.HELVETICA:
+ this.fontName = "Arial";
+ break;
+ case Font.SYMBOL:
+ this.fontName = "Symbol";
+ this.charset = 2;
+ break;
+ case Font.TIMES_ROMAN:
+ this.fontName = "Times New Roman";
+ break;
+ case Font.ZAPFDINGBATS:
+ this.fontName = "Windings";
+ break;
+ default:
+ this.fontName = familyname;
+ }
+ }
+
+ /**
+ * Gets the font size of this RtfFont
+ *
+ * @return The font size
+ */
+ public int getFontSize() {
+ return this.fontSize;
+ }
+
+ /**
+ * @see com.lowagie.text.Font#setSize(float)
+ */
+ public void setSize(float size){
+ super.setSize(size);
+ this.fontSize = (int) size();
+ }
+
+ /**
+ * Gets the font style of this RtfFont
+ *
+ * @return The font style
+ */
+ public int getFontStyle() {
+ return this.fontStyle;
+ }
+
+ /**
+ * @see com.lowagie.text.Font#setStyle(int)
+ */
+ public void setStyle(int style){
+ super.setStyle(style);
+ this.fontStyle = style();
+ }
+
+ /**
+ * @see com.lowagie.text.Font#setStyle(String)
+ */
+ public void setStyle(String style) {
+ super.setStyle(style);
+ fontStyle = style();
+ }
+
+ /**
+ * Gets the font number of this RtfFont
+ *
+ * @return The font number
+ */
+ public int getFontNumber() {
+ return fontNumber;
+ }
+
+ /**
+ * Sets the RtfDocument this RtfFont belongs to
+ *
+ * @param doc The RtfDocument to use
+ */
+ public void setRtfDocument(RtfDocument doc) {
+ this.document = doc;
+ if(document != null) {
+ this.fontNumber = document.getDocumentHeader().getFontNumber(this);
+ }
+ if(this.color != null) {
+ this.color.setRtfDocument(this.document);
+ }
+ }
+
+ /**
+ * Unused
+ * @param inTable
+ */
+ public void setInTable(boolean inTable) {
+ }
+
+ /**
+ * Unused
+ * @param inHeader
+ */
+ public void setInHeader(boolean inHeader) {
+ }
+
+ /**
+ * @see com.lowagie.text.Font#setColor(Color)
+ */
+ public void setColor(Color color) {
+ super.setColor(color);
+ if(color != null) {
+ this.color = new RtfColor(document, color);
+ } else {
+ this.color = null;
+ }
+ }
+
+ /**
+ * @see com.lowagie.text.Font#setColor(int, int, int)
+ */
+ public void setColor(int red, int green, int blue) {
+ super.setColor(red,green,blue);
+ this.color = new RtfColor(document, red, green, blue);
+ }
+
+ /**
+ * Transforms an integer into its String representation and then returns the bytes
+ * of that string.
+ *
+ * @param i The integer to convert
+ * @return A byte array representing the integer
+ */
+ protected byte[] intToByteArray(int i) {
+ return Integer.toString(i).getBytes();
+ }
+
+ /**
+ * Replaces the attributes that are equal to <VAR>null</VAR> with
+ * the attributes of a given font.
+ *
+ * @param font The surrounding font
+ * @return A RtfFont
+ */
+ public Font difference(Font font) {
+ String dFamilyname = font.getFamilyname();
+ if(dFamilyname == null || dFamilyname.trim().equals("") || dFamilyname.trim().equalsIgnoreCase("unknown")) {
+ dFamilyname = this.fontName;
+ }
+
+ float dSize = font.size();
+ if(dSize == Font.UNDEFINED) {
+ dSize = this.size();
+ }
+
+ int dStyle = Font.UNDEFINED;
+ if(this.style() != Font.UNDEFINED && font.style() != Font.UNDEFINED) {
+ dStyle = this.style() | font.style();
+ } else if(this.style() != Font.UNDEFINED) {
+ dStyle = this.style();
+ } else if(font.style() != Font.UNDEFINED) {
+ dStyle = font.style();
+ }
+
+ Color dColor = font.color();
+ if(dColor == null) {
+ dColor = this.color();
+ }
+
+ return new RtfFont(dFamilyname, dSize, dStyle, dColor);
+ }
+}
diff --git a/src/main/java/com/lowagie/text/rtf/style/RtfFontList.java b/src/main/java/com/lowagie/text/rtf/style/RtfFontList.java new file mode 100644 index 0000000..6e90371 --- /dev/null +++ b/src/main/java/com/lowagie/text/rtf/style/RtfFontList.java @@ -0,0 +1,149 @@ +/*
+ * $Id: RtfFontList.java,v 1.17 2005/12/24 13:10:37 hallm Exp $
+ * $Name: $
+ *
+ * Copyright 2001, 2002, 2003, 2004 by Mark Hall
+ *
+ * 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.rtf.style;
+
+import com.lowagie.text.rtf.RtfElement;
+import com.lowagie.text.rtf.RtfExtendedElement;
+import com.lowagie.text.rtf.document.RtfDocument;
+
+import java.util.ArrayList;
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+
+/**
+ * The RtfFontList stores the list of fonts used in the rtf document. It also
+ * has methods for writing this list to the document
+ *
+ * Version: $Id: RtfFontList.java,v 1.17 2005/12/24 13:10:37 hallm Exp $
+ * @author Mark Hall (mhall@edu.uni-klu.ac.at)
+ */
+public class RtfFontList extends RtfElement implements RtfExtendedElement {
+
+ /**
+ * Constant for the default font
+ */
+ private static final byte[] DEFAULT_FONT = "\\deff".getBytes();
+ /**
+ * Constant for the font table
+ */
+ private static final byte[] FONT_TABLE = "\\fonttbl".getBytes();
+ /**
+ * Constant for the font number
+ */
+ public static final byte[] FONT_NUMBER = "\\f".getBytes();
+
+ /**
+ * The list of fonts
+ */
+ private ArrayList fontList = new ArrayList();
+
+ /**
+ * Creates a RtfFontList
+ *
+ * @param doc The RtfDocument this RtfFontList belongs to
+ */
+ public RtfFontList(RtfDocument doc) {
+ super(doc);
+ fontList.add(new RtfFont(document, 0));
+ }
+
+ /**
+ * Gets the index of the font in the list of fonts. If the font does not
+ * exist in the list, it is added.
+ *
+ * @param font The font to get the id for
+ * @return The index of the font
+ */
+ public int getFontNumber(RtfFont font) {
+ if(font instanceof RtfParagraphStyle) {
+ font = new RtfFont(this.document, (RtfParagraphStyle) font);
+ }
+ int fontIndex = -1;
+ for(int i = 0; i < fontList.size(); i++) {
+ if(fontList.get(i).equals(font)) {
+ fontIndex = i;
+ }
+ }
+ if(fontIndex == -1) {
+ fontIndex = fontList.size();
+ fontList.add(font);
+ }
+ return fontIndex;
+ }
+
+ /**
+ * Writes the definition of the font list
+ *
+ * @return A byte array with the definition of the font list
+ */
+ public byte[] writeDefinition() {
+ ByteArrayOutputStream result = new ByteArrayOutputStream();
+ try {
+ result.write(DEFAULT_FONT);
+ result.write(intToByteArray(0));
+ result.write(OPEN_GROUP);
+ result.write(FONT_TABLE);
+ for(int i = 0; i < fontList.size(); i++) {
+ result.write(OPEN_GROUP);
+ result.write(FONT_NUMBER);
+ result.write(intToByteArray(i));
+ result.write(((RtfFont) fontList.get(i)).writeDefinition());
+ result.write(COMMA_DELIMITER);
+ result.write(CLOSE_GROUP);
+ }
+ result.write(CLOSE_GROUP);
+ result.write((byte)'\n');
+ } catch(IOException ioe) {
+ ioe.printStackTrace();
+ }
+ return result.toByteArray();
+ }
+}
diff --git a/src/main/java/com/lowagie/text/rtf/style/RtfParagraphStyle.java b/src/main/java/com/lowagie/text/rtf/style/RtfParagraphStyle.java new file mode 100644 index 0000000..d8c582c --- /dev/null +++ b/src/main/java/com/lowagie/text/rtf/style/RtfParagraphStyle.java @@ -0,0 +1,665 @@ +package com.lowagie.text.rtf.style;
+
+import java.awt.Color;
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+
+import com.lowagie.text.Element;
+import com.lowagie.text.Font;
+import com.lowagie.text.rtf.RtfBasicElement;
+import com.lowagie.text.rtf.document.RtfDocument;
+import com.lowagie.text.rtf.text.RtfParagraph;
+
+/**
+ * The RtfParagraphStyle stores all style/formatting attributes of a RtfParagraph.
+ * Additionally it also supports the style name system available in RTF. The RtfParagraphStyle
+ * is a Font and can thus be used as such. To use the stylesheet functionality
+ * it needs to be set as the font of a Paragraph. Otherwise it will work like a
+ * RtfFont. It also supports inheritance of styles.
+ *
+ * @version $Revision: 1.4 $
+ * @author Mark Hall (mhall@edu.uni-klu.ac.at)
+ */
+public class RtfParagraphStyle extends RtfFont {
+
+ /**
+ * Constant for left alignment
+ */
+ public static final byte[] ALIGN_LEFT = "\\ql".getBytes();
+ /**
+ * Constant for right alignment
+ */
+ public static final byte[] ALIGN_RIGHT = "\\qr".getBytes();
+ /**
+ * Constant for center alignment
+ */
+ public static final byte[] ALIGN_CENTER = "\\qc".getBytes();
+ /**
+ * Constant for justified alignment
+ */
+ public static final byte[] ALIGN_JUSTIFY = "\\qj".getBytes();
+ /**
+ * Constant for left indentation
+ */
+ public static final byte[] INDENT_LEFT = "\\li".getBytes();
+ /**
+ * Constant for right indentation
+ */
+ public static final byte[] INDENT_RIGHT = "\\ri".getBytes();
+ /**
+ * Constant for keeping the paragraph together on one page
+ */
+ public static final byte[] KEEP_TOGETHER = "\\keep".getBytes();
+ /**
+ * Constant for keeping the paragraph toghether with the next one on one page
+ */
+ public static final byte[] KEEP_TOGETHER_WITH_NEXT = "\\keepn".getBytes();
+ /**
+ * Constant for the space after the paragraph.
+ */
+ public static final byte[] SPACING_AFTER = "\\sa".getBytes();
+ /**
+ * Constant for the space before the paragraph.
+ */
+ public static final byte[] SPACING_BEFORE = "\\sb".getBytes();
+
+ /**
+ * The NORMAL/STANDARD style.
+ */
+ public static final RtfParagraphStyle STYLE_NORMAL = new RtfParagraphStyle("Normal", "Arial", 12, Font.NORMAL, Color.black);
+ /**
+ * The style for level 1 headings.
+ */
+ public static final RtfParagraphStyle STYLE_HEADING_1 = new RtfParagraphStyle("heading 1", "Normal");
+ /**
+ * The style for level 2 headings.
+ */
+ public static final RtfParagraphStyle STYLE_HEADING_2 = new RtfParagraphStyle("heading 2", "Normal");
+ /**
+ * The style for level 3 headings.
+ */
+ public static final RtfParagraphStyle STYLE_HEADING_3 = new RtfParagraphStyle("heading 3", "Normal");
+
+ /**
+ * Initialises the properties of the styles.
+ */
+ static {
+ STYLE_HEADING_1.setSize(16);
+ STYLE_HEADING_1.setStyle(Font.BOLD);
+ STYLE_HEADING_2.setSize(14);
+ STYLE_HEADING_2.setStyle(Font.BOLDITALIC);
+ STYLE_HEADING_3.setSize(13);
+ STYLE_HEADING_3.setStyle(Font.BOLD);
+ }
+
+ /**
+ * No modification has taken place when compared to the RtfParagraphStyle this RtfParagraphStyle
+ * is based on. These modification markers are used to determine what needs to be
+ * inherited and what not from the parent RtfParagraphStyle.
+ */
+ private static final int MODIFIED_NONE = 0;
+ /**
+ * The alignment has been modified.
+ */
+ private static final int MODIFIED_ALIGNMENT = 1;
+ /**
+ * The left indentation has been modified.
+ */
+ private static final int MODIFIED_INDENT_LEFT = 2;
+ /**
+ * The right indentation has been modified.
+ */
+ private static final int MODIFIED_INDENT_RIGHT = 4;
+ /**
+ * The spacing before a paragraph has been modified.
+ */
+ private static final int MODIFIED_SPACING_BEFORE = 8;
+ /**
+ * The spacing after a paragraph has been modified.
+ */
+ private static final int MODIFIED_SPACING_AFTER = 16;
+ /**
+ * The font name has been modified.
+ */
+ private static final int MODIFIED_FONT_NAME = 32;
+ /**
+ * The font style has been modified.
+ */
+ private static final int MODIFIED_FONT_SIZE = 64;
+ /**
+ * The font size has been modified.
+ */
+ private static final int MODIFIED_FONT_STYLE = 128;
+ /**
+ * The font colour has been modified.
+ */
+ private static final int MODIFIED_FONT_COLOR = 256;
+ /**
+ * The line leading has been modified.
+ */
+ private static final int MODIFIED_LINE_LEADING = 512;
+ /**
+ * The paragraph keep together setting has been modified.
+ */
+ private static final int MODIFIED_KEEP_TOGETHER = 1024;
+ /**
+ * The paragraph keep together with next setting has been modified.
+ */
+ private static final int MODIFIED_KEEP_TOGETHER_WITH_NEXT = 2048;
+
+ /**
+ * The alignment of the paragraph.
+ */
+ private int alignment = Element.ALIGN_LEFT;
+ /**
+ * The left indentation of the paragraph.
+ */
+ private int indentLeft = 0;
+ /**
+ * The right indentation of the paragraph.
+ */
+ private int indentRight = 0;
+ /**
+ * The spacing before a paragraph.
+ */
+ private int spacingBefore = 0;
+ /**
+ * The spacing after a paragraph.
+ */
+ private int spacingAfter = 0;
+ /**
+ * The line leading of the paragraph.
+ */
+ private int lineLeading = 0;
+ /**
+ * Whether this RtfParagraph must stay on one page.
+ */
+ private boolean keepTogether = false;
+ /**
+ * Whether this RtfParagraph must stay on the same page as the next paragraph.
+ */
+ private boolean keepTogetherWithNext = false;
+ /**
+ * The name of this RtfParagraphStyle.
+ */
+ private String styleName = "";
+ /**
+ * The name of the RtfParagraphStyle this RtfParagraphStyle is based on.
+ */
+ private String basedOnName = null;
+ /**
+ * The RtfParagraphStyle this RtfParagraphStyle is based on.
+ */
+ private RtfParagraphStyle baseStyle = null;
+ /**
+ * Which properties have been modified when compared to the base style.
+ */
+ private int modified = MODIFIED_NONE;
+ /**
+ * The number of this RtfParagraphStyle in the stylesheet list.
+ */
+ private int styleNumber = -1;
+
+ /**
+ * Constructs a new RtfParagraphStyle with the given attributes.
+ *
+ * @param styleName The name of this RtfParagraphStyle.
+ * @param fontName The name of the font to use for this RtfParagraphStyle.
+ * @param fontSize The size of the font to use for this RtfParagraphStyle.
+ * @param fontStyle The style of the font to use for this RtfParagraphStyle.
+ * @param fontColor The colour of the font to use for this RtfParagraphStyle.
+ */
+ public RtfParagraphStyle(String styleName, String fontName, int fontSize, int fontStyle, Color fontColor) {
+ super(null, new RtfFont(fontName, fontSize, fontStyle, fontColor));
+ this.styleName = styleName;
+ }
+
+ /**
+ * Constructs a new RtfParagraphStyle that is based on an existing RtfParagraphStyle.
+ *
+ * @param styleName The name of this RtfParagraphStyle.
+ * @param basedOnName The name of the RtfParagraphStyle this RtfParagraphStyle is based on.
+ */
+ public RtfParagraphStyle(String styleName, String basedOnName) {
+ super(null, new Font());
+ this.styleName = styleName;
+ this.basedOnName = basedOnName;
+ }
+
+ /**
+ * Constructs a RtfParagraphStyle from another RtfParagraphStyle.
+ *
+ * INTERNAL USE ONLY
+ *
+ * @param doc The RtfDocument this RtfParagraphStyle belongs to.
+ * @param style The RtfParagraphStyle to copy settings from.
+ */
+ public RtfParagraphStyle(RtfDocument doc, RtfParagraphStyle style) {
+ super(doc, style);
+ this.document = doc;
+ this.styleName = style.getStyleName();
+ this.alignment = style.getAlignment();
+ this.indentLeft = (int) (style.getIndentLeft() * RtfBasicElement.TWIPS_FACTOR);
+ this.indentRight = (int) (style.getIndentRight() * RtfBasicElement.TWIPS_FACTOR);
+ this.spacingBefore = (int) (style.getSpacingBefore() * RtfBasicElement.TWIPS_FACTOR);
+ this.spacingAfter = (int) (style.getSpacingAfter() * RtfBasicElement.TWIPS_FACTOR);
+ this.lineLeading = (int) (style.getLineLeading() * RtfBasicElement.TWIPS_FACTOR);
+ this.keepTogether = style.getKeepTogether();
+ this.keepTogetherWithNext = style.getKeepTogetherWithNext();
+ this.basedOnName = style.basedOnName;
+ this.modified = style.modified;
+ this.styleNumber = style.getStyleNumber();
+
+ if(this.document != null) {
+ setRtfDocument(this.document);
+ }
+ }
+
+ /**
+ * Gets the name of this RtfParagraphStyle.
+ *
+ * @return The name of this RtfParagraphStyle.
+ */
+ public String getStyleName() {
+ return this.styleName;
+ }
+
+ /**
+ * Gets the name of the RtfParagraphStyle this RtfParagraphStyle is based on.
+ *
+ * @return The name of the base RtfParagraphStyle.
+ */
+ public String getBasedOnName() {
+ return this.basedOnName;
+ }
+
+ /**
+ * Gets the alignment of this RtfParagraphStyle.
+ *
+ * @return The alignment of this RtfParagraphStyle.
+ */
+ public int getAlignment() {
+ return this.alignment;
+ }
+
+ /**
+ * Sets the alignment of this RtfParagraphStyle.
+ *
+ * @param alignment The alignment to use.
+ */
+ public void setAlignment(int alignment) {
+ this.modified = this.modified | MODIFIED_ALIGNMENT;
+ this.alignment = alignment;
+ }
+
+ /**
+ * Gets the left indentation of this RtfParagraphStyle.
+ *
+ * @return The left indentation of this RtfParagraphStyle.
+ */
+ public int getIndentLeft() {
+ return this.indentLeft;
+ }
+
+ /**
+ * Sets the left indentation of this RtfParagraphStyle.
+ *
+ * @param indentLeft The left indentation to use.
+ */
+ public void setIndentLeft(int indentLeft) {
+ this.modified = this.modified | MODIFIED_INDENT_LEFT;
+ this.indentLeft = indentLeft;
+ }
+
+ /**
+ * Gets the right indentation of this RtfParagraphStyle.
+ *
+ * @return The right indentation of this RtfParagraphStyle.
+ */
+ public int getIndentRight() {
+ return this.indentRight;
+ }
+
+ /**
+ * Sets the right indentation of this RtfParagraphStyle.
+ *
+ * @param indentRight The right indentation to use.
+ */
+ public void setIndentRight(int indentRight) {
+ this.modified = this.modified | MODIFIED_INDENT_RIGHT;
+ this.indentRight = indentRight;
+ }
+
+ /**
+ * Gets the space before the paragraph of this RtfParagraphStyle..
+ *
+ * @return The space before the paragraph.
+ */
+ public int getSpacingBefore() {
+ return this.spacingBefore;
+ }
+
+ /**
+ * Sets the space before the paragraph of this RtfParagraphStyle.
+ *
+ * @param spacingBefore The space before to use.
+ */
+ public void setSpacingBefore(int spacingBefore) {
+ this.modified = this.modified | MODIFIED_SPACING_BEFORE;
+ this.spacingBefore = spacingBefore;
+ }
+
+ /**
+ * Gets the space after the paragraph of this RtfParagraphStyle.
+ *
+ * @return The space after the paragraph.
+ */
+ public int getSpacingAfter() {
+ return this.spacingAfter;
+ }
+
+ /**
+ * Sets the space after the paragraph of this RtfParagraphStyle.
+ *
+ * @param spacingAfter The space after to use.
+ */
+ public void setSpacingAfter(int spacingAfter) {
+ this.modified = this.modified | MODIFIED_SPACING_AFTER;
+ this.spacingAfter = spacingAfter;
+ }
+
+ /**
+ * Sets the font name of this RtfParagraphStyle.
+ *
+ * @param fontName The font name to use
+ */
+ public void setFontName(String fontName) {
+ this.modified = this.modified | MODIFIED_FONT_NAME;
+ super.setFontName(fontName);
+ }
+
+ /**
+ * Sets the font size of this RtfParagraphStyle.
+ *
+ * @param fontSize The font size to use.
+ */
+ public void setSize(float fontSize) {
+ this.modified = this.modified | MODIFIED_FONT_SIZE;
+ super.setSize(fontSize);
+ }
+
+ /**
+ * Sets the font style of this RtfParagraphStyle.
+ *
+ * @param fontStyle The font style to use.
+ */
+ public void setStyle(int fontStyle) {
+ this.modified = this.modified | MODIFIED_FONT_STYLE;
+ super.setStyle(fontStyle);
+ }
+
+ /**
+ * Sets the colour of this RtfParagraphStyle.
+ *
+ * @param color The Color to use.
+ */
+ public void setColor(Color color) {
+ this.modified = this.modified | MODIFIED_FONT_COLOR;
+ super.setColor(color);
+ }
+
+ /**
+ * Gets the line leading of this RtfParagraphStyle.
+ *
+ * @return The line leading of this RtfParagraphStyle.
+ */
+ public int getLineLeading() {
+ return this.lineLeading;
+ }
+
+ /**
+ * Sets the line leading of this RtfParagraphStyle.
+ *
+ * @param lineLeading The line leading to use.
+ */
+ public void setLineLeading(int lineLeading) {
+ this.lineLeading = lineLeading;
+ this.modified = this.modified | MODIFIED_LINE_LEADING;
+ }
+
+ /**
+ * Gets whether the lines in the paragraph should be kept together in
+ * this RtfParagraphStyle.
+ *
+ * @return Whether the lines in the paragraph should be kept together.
+ */
+ public boolean getKeepTogether() {
+ return this.keepTogether;
+ }
+
+ /**
+ * Sets whether the lines in the paragraph should be kept together in
+ * this RtfParagraphStyle.
+ *
+ * @param keepTogether Whether the lines in the paragraph should be kept together.
+ */
+ public void setKeepTogether(boolean keepTogether) {
+ this.keepTogether = keepTogether;
+ this.modified = this.modified | MODIFIED_KEEP_TOGETHER;
+ }
+
+ /**
+ * Gets whether the paragraph should be kept toggether with the next in
+ * this RtfParagraphStyle.
+ *
+ * @return Whether the paragraph should be kept together with the next.
+ */
+ public boolean getKeepTogetherWithNext() {
+ return this.keepTogetherWithNext;
+ }
+
+ /**
+ * Sets whether the paragraph should be kept together with the next in
+ * this RtfParagraphStyle.
+ *
+ * @param keepTogetherWithNext Whether the paragraph should be kept together with the next.
+ */
+ public void setKeepTogetherWithNext(boolean keepTogetherWithNext) {
+ this.keepTogetherWithNext = keepTogetherWithNext;
+ this.modified = this.modified | MODIFIED_KEEP_TOGETHER_WITH_NEXT;
+ }
+
+ /**
+ * Handles the inheritance of paragraph style settings. All settings that
+ * have not been modified will be inherited from the base RtfParagraphStyle.
+ * If this RtfParagraphStyle is not based on another one, then nothing happens.
+ */
+ public void handleInheritance() {
+ if(this.basedOnName != null && this.document.getDocumentHeader().getRtfParagraphStyle(this.basedOnName) != null) {
+ this.baseStyle = this.document.getDocumentHeader().getRtfParagraphStyle(this.basedOnName);
+ this.baseStyle.handleInheritance();
+ if(!((this.modified & MODIFIED_ALIGNMENT) == MODIFIED_ALIGNMENT)) {
+ this.alignment = this.baseStyle.getAlignment();
+ }
+ if(!((this.modified & MODIFIED_INDENT_LEFT) == MODIFIED_INDENT_LEFT)) {
+ this.indentLeft = this.baseStyle.getIndentLeft();
+ }
+ if(!((this.modified & MODIFIED_INDENT_RIGHT) == MODIFIED_INDENT_RIGHT)) {
+ this.indentRight = this.baseStyle.getIndentRight();
+ }
+ if(!((this.modified & MODIFIED_SPACING_BEFORE) == MODIFIED_SPACING_BEFORE)) {
+ this.spacingBefore = this.baseStyle.getSpacingBefore();
+ }
+ if(!((this.modified & MODIFIED_SPACING_AFTER) == MODIFIED_SPACING_AFTER)) {
+ this.spacingAfter = this.baseStyle.getSpacingAfter();
+ }
+ if(!((this.modified & MODIFIED_FONT_NAME) == MODIFIED_FONT_NAME)) {
+ setFontName(this.baseStyle.getFontName());
+ }
+ if(!((this.modified & MODIFIED_FONT_SIZE) == MODIFIED_FONT_SIZE)) {
+ setSize(this.baseStyle.getFontSize());
+ }
+ if(!((this.modified & MODIFIED_FONT_STYLE) == MODIFIED_FONT_STYLE)) {
+ setStyle(this.baseStyle.getFontStyle());
+ }
+ if(!((this.modified & MODIFIED_FONT_COLOR) == MODIFIED_FONT_COLOR)) {
+ setColor(this.baseStyle.color());
+ }
+ if(!((this.modified & MODIFIED_LINE_LEADING) == MODIFIED_LINE_LEADING)) {
+ setLineLeading(this.baseStyle.getLineLeading());
+ }
+ if(!((this.modified & MODIFIED_KEEP_TOGETHER) == MODIFIED_KEEP_TOGETHER)) {
+ setKeepTogether(this.baseStyle.getKeepTogether());
+ }
+ if(!((this.modified & MODIFIED_KEEP_TOGETHER_WITH_NEXT) == MODIFIED_KEEP_TOGETHER_WITH_NEXT)) {
+ setKeepTogetherWithNext(this.baseStyle.getKeepTogetherWithNext());
+ }
+ }
+ }
+
+ /**
+ * Writes the settings of this RtfParagraphStyle.
+ *
+ * @return A byte array with the settings of this RtfParagraphStyle.
+ */
+ private byte[] writeParagraphSettings() {
+ ByteArrayOutputStream result = new ByteArrayOutputStream();
+ try {
+ if(this.keepTogether) {
+ result.write(RtfParagraphStyle.KEEP_TOGETHER);
+ }
+ if(this.keepTogetherWithNext) {
+ result.write(RtfParagraphStyle.KEEP_TOGETHER_WITH_NEXT);
+ }
+ switch (alignment) {
+ case Element.ALIGN_LEFT:
+ result.write(RtfParagraphStyle.ALIGN_LEFT);
+ break;
+ case Element.ALIGN_RIGHT:
+ result.write(RtfParagraphStyle.ALIGN_RIGHT);
+ break;
+ case Element.ALIGN_CENTER:
+ result.write(RtfParagraphStyle.ALIGN_CENTER);
+ break;
+ case Element.ALIGN_JUSTIFIED:
+ case Element.ALIGN_JUSTIFIED_ALL:
+ result.write(RtfParagraphStyle.ALIGN_JUSTIFY);
+ break;
+ }
+ result.write(RtfParagraphStyle.INDENT_LEFT);
+ result.write(intToByteArray(indentLeft));
+ result.write(RtfParagraphStyle.INDENT_RIGHT);
+ result.write(intToByteArray(indentRight));
+ if(this.spacingBefore > 0) {
+ result.write(RtfParagraphStyle.SPACING_BEFORE);
+ result.write(intToByteArray(this.spacingBefore));
+ }
+ if(this.spacingAfter > 0) {
+ result.write(RtfParagraphStyle.SPACING_AFTER);
+ result.write(intToByteArray(this.spacingAfter));
+ }
+ if(this.lineLeading > 0) {
+ result.write(RtfParagraph.LINE_SPACING);
+ result.write(intToByteArray(this.lineLeading));
+ }
+ } catch(IOException ioe) {
+ ioe.printStackTrace();
+ }
+ return result.toByteArray();
+ }
+
+ /**
+ * Writes the definition of this RtfParagraphStyle for the stylesheet list.
+ */
+ public byte[] writeDefinition() {
+ ByteArrayOutputStream result = new ByteArrayOutputStream();
+ try {
+ result.write("{".getBytes());
+ result.write("\\style".getBytes());
+ result.write("\\s".getBytes());
+ result.write(intToByteArray(this.styleNumber));
+ result.write(RtfBasicElement.DELIMITER);
+ result.write(writeParagraphSettings());
+ result.write(super.writeBegin());
+ result.write(RtfBasicElement.DELIMITER);
+ result.write(this.styleName.getBytes());
+ result.write(";".getBytes());
+ result.write("}".getBytes());
+ if(this.document.getDocumentSettings().isOutputDebugLineBreaks()) {
+ result.write('\n');
+ }
+ } catch(IOException ioe) {
+ ioe.printStackTrace();
+ }
+ return result.toByteArray();
+ }
+
+ /**
+ * Writes the start information of this RtfParagraphStyle.
+ */
+ public byte[] writeBegin() {
+ ByteArrayOutputStream result = new ByteArrayOutputStream();
+ try {
+ result.write("\\s".getBytes());
+ result.write(intToByteArray(this.styleNumber));
+ result.write(writeParagraphSettings());
+ } catch(IOException ioe) {
+ ioe.printStackTrace();
+ }
+ return result.toByteArray();
+ }
+
+ /**
+ * Unused
+ * @return An empty byte array.
+ */
+ public byte[] writeEnd() {
+ return new byte[0];
+ }
+
+ /**
+ * Unused
+ * @return An empty byte array.
+ */
+ public byte[] write() {
+ return new byte[0];
+ }
+
+ /**
+ * Tests whether two RtfParagraphStyles are equal. Equality
+ * is determined via the name.
+ */
+ public boolean equals(Object o) {
+ if(o == null || !(o instanceof RtfParagraphStyle)) {
+ return false;
+ }
+ RtfParagraphStyle paragraphStyle = (RtfParagraphStyle) o;
+ boolean result = this.getStyleName().equals(paragraphStyle.getStyleName());
+ return result;
+ }
+
+ /**
+ * Gets the hash code of this RtfParagraphStyle.
+ */
+ public int hashCode() {
+ return this.styleName.hashCode();
+ }
+
+ /**
+ * Gets the number of this RtfParagraphStyle in the stylesheet list.
+ *
+ * @return The number of this RtfParagraphStyle in the stylesheet list.
+ */
+ private int getStyleNumber() {
+ return this.styleNumber;
+ }
+
+ /**
+ * Sets the number of this RtfParagraphStyle in the stylesheet list.
+ *
+ * @param styleNumber The number to use.
+ */
+ protected void setStyleNumber(int styleNumber) {
+ this.styleNumber = styleNumber;
+ }
+}
diff --git a/src/main/java/com/lowagie/text/rtf/style/RtfStylesheetList.java b/src/main/java/com/lowagie/text/rtf/style/RtfStylesheetList.java new file mode 100644 index 0000000..edb04ea --- /dev/null +++ b/src/main/java/com/lowagie/text/rtf/style/RtfStylesheetList.java @@ -0,0 +1,121 @@ +/*
+ * Created on Sep 22, 2005
+ *
+ * To change the template for this generated file go to
+ * Window - Preferences - Java - Code Generation - Code and Comments
+ */
+package com.lowagie.text.rtf.style;
+
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.util.HashMap;
+import java.util.Iterator;
+
+import com.lowagie.text.rtf.RtfBasicElement;
+import com.lowagie.text.rtf.RtfElement;
+import com.lowagie.text.rtf.RtfExtendedElement;
+import com.lowagie.text.rtf.document.RtfDocument;
+
+/**
+ * The RtfStylesheetList stores the RtfParagraphStyles that are used in the document.
+ *
+ * @version $Revision: 1.1 $
+ * @author Mark Hall (mhall@edu.uni-klu.ac.at)
+ */
+public class RtfStylesheetList extends RtfElement implements RtfExtendedElement {
+
+ /**
+ * The HashMap containing the RtfParagraphStyles.
+ */
+ private HashMap styleMap = null;
+ /**
+ * Whether the default settings have been loaded.
+ */
+ private boolean defaultsLoaded = false;
+
+ /**
+ * Constructs a new RtfStylesheetList for the RtfDocument.
+ *
+ * @param doc The RtfDocument this RtfStylesheetList belongs to.
+ */
+ public RtfStylesheetList(RtfDocument doc) {
+ super(doc);
+ this.styleMap = new HashMap();
+ }
+
+ /**
+ * Register a RtfParagraphStyle with this RtfStylesheetList.
+ *
+ * @param rtfParagraphStyle The RtfParagraphStyle to add.
+ */
+ public void registerParagraphStyle(RtfParagraphStyle rtfParagraphStyle) {
+ RtfParagraphStyle tempStyle = new RtfParagraphStyle(this.document, rtfParagraphStyle);
+ tempStyle.setStyleNumber(this.styleMap.size());
+ tempStyle.handleInheritance();
+ this.styleMap.put(tempStyle.getStyleName(), tempStyle);
+ }
+
+ /**
+ * Registers all default styles. If styles with the given name have already been registered,
+ * then they are NOT overwritten.
+ */
+ private void registerDefaultStyles() {
+ defaultsLoaded = true;
+ if(!this.styleMap.containsKey(RtfParagraphStyle.STYLE_NORMAL.getStyleName())) {
+ registerParagraphStyle(RtfParagraphStyle.STYLE_NORMAL);
+ }
+ if(!this.styleMap.containsKey(RtfParagraphStyle.STYLE_HEADING_1.getStyleName())) {
+ registerParagraphStyle(RtfParagraphStyle.STYLE_HEADING_1);
+ }
+ if(!this.styleMap.containsKey(RtfParagraphStyle.STYLE_HEADING_2.getStyleName())) {
+ registerParagraphStyle(RtfParagraphStyle.STYLE_HEADING_2);
+ }
+ if(!this.styleMap.containsKey(RtfParagraphStyle.STYLE_HEADING_3.getStyleName())) {
+ registerParagraphStyle(RtfParagraphStyle.STYLE_HEADING_3);
+ }
+ }
+
+ /**
+ * Gets the RtfParagraphStyle with the given name. Makes sure that the defaults
+ * have been loaded.
+ *
+ * @param styleName The name of the RtfParagraphStyle to get.
+ * @return The RtfParagraphStyle with the given name or null.
+ */
+ public RtfParagraphStyle getRtfParagraphStyle(String styleName) {
+ if(!defaultsLoaded) {
+ registerDefaultStyles();
+ }
+ if(this.styleMap.containsKey(styleName)) {
+ return (RtfParagraphStyle) this.styleMap.get(styleName);
+ } else {
+ return null;
+ }
+ }
+
+ /**
+ * Writes the definition of the stylesheet list.
+ */
+ public byte[] writeDefinition() {
+ ByteArrayOutputStream result = new ByteArrayOutputStream();
+ try {
+ result.write("{".getBytes());
+ result.write("\\stylesheet".getBytes());
+ result.write(RtfBasicElement.DELIMITER);
+ if(this.document.getDocumentSettings().isOutputDebugLineBreaks()) {
+ result.write("\n".getBytes());
+ }
+ Iterator it = this.styleMap.values().iterator();
+ while(it.hasNext()) {
+ result.write(((RtfParagraphStyle) it.next()).writeDefinition());
+ }
+ result.write("}".getBytes());
+ if(this.document.getDocumentSettings().isOutputDebugLineBreaks()) {
+ result.write('\n');
+ }
+ } catch(IOException ioe) {
+ ioe.printStackTrace();
+ }
+ return result.toByteArray();
+ }
+}
diff --git a/src/main/java/com/lowagie/text/rtf/table/RtfBorder.java b/src/main/java/com/lowagie/text/rtf/table/RtfBorder.java new file mode 100644 index 0000000..8a35867 --- /dev/null +++ b/src/main/java/com/lowagie/text/rtf/table/RtfBorder.java @@ -0,0 +1,577 @@ +/*
+ * $Id: RtfBorder.java,v 1.16 2005/05/04 14:33:54 blowagie Exp $
+ * $Name: $
+ *
+ * Copyright 2001, 2002, 2003, 2004 by Mark Hall
+ *
+ * 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.rtf.table;
+
+import java.awt.Color;
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+
+import com.lowagie.text.rtf.RtfElement;
+import com.lowagie.text.rtf.document.RtfDocument;
+import com.lowagie.text.rtf.style.RtfColor;
+
+
+/**
+ * The RtfBorder handle one row or cell border.
+ * INTERNAL USE ONLY
+ *
+ * @version $Version:$
+ * @author Mark Hall (mhall@edu.uni-klu.ac.at)
+ * @author Unknown
+ */
+public class RtfBorder extends RtfElement {
+
+ /**
+ * Constant for the left row border
+ */
+ protected static final byte[] ROW_BORDER_LEFT = "\\trbrdrl".getBytes();
+ /**
+ * Constant for the top row border
+ */
+ protected static final byte[] ROW_BORDER_TOP = "\\trbrdrt".getBytes();
+ /**
+ * Constant for the right row border
+ */
+ protected static final byte[] ROW_BORDER_RIGHT = "\\trbrdrr".getBytes();
+ /**
+ * Constant for the bottom row border
+ */
+ protected static final byte[] ROW_BORDER_BOTTOM = "\\trbrdrb".getBytes();
+ /**
+ * Constant for the horizontal line
+ */
+ protected static final byte[] ROW_BORDER_HORIZONTAL = "\\trbrdrh".getBytes();
+ /**
+ * Constant for the vertical line
+ */
+ protected static final byte[] ROW_BORDER_VERTICAL = "\\trbrdrv".getBytes();
+ /**
+ * Constant for the left cell border
+ */
+ protected static final byte[] CELL_BORDER_LEFT = "\\clbrdrl".getBytes();
+ /**
+ * Constant for the top cell border
+ */
+ protected static final byte[] CELL_BORDER_TOP = "\\clbrdrt".getBytes();
+ /**
+ * Constant for the right cell border
+ */
+ protected static final byte[] CELL_BORDER_RIGHT = "\\clbrdrr".getBytes();
+ /**
+ * Constant for the bottom cell border
+ */
+ protected static final byte[] CELL_BORDER_BOTTOM = "\\clbrdrb".getBytes();
+ /**
+ * Constant for the border width
+ */
+ protected static final byte[] BORDER_WIDTH = "\\brdrw".getBytes();
+ /**
+ * Constant for the border colour number
+ */
+ protected static final byte[] BORDER_COLOR_NUMBER = "\\brdrcf".getBytes();
+ /**
+ * Constant for the single border style
+ */
+ protected static final byte[] BORDER_STYLE_SINGLE = "\\brdrs".getBytes();
+ /**
+ * Constant for the double thick border style
+ */
+ protected static final byte[] BORDER_STYLE_DOUBLE_THICK = "\\brdrth".getBytes();
+ /**
+ * Constant for the shadowed border style
+ */
+ protected static final byte[] BORDER_STYLE_SHADOWED = "\\brdrsh".getBytes();
+ /**
+ * Constant for the dotted border style
+ */
+ protected static final byte[] BORDER_STYLE_DOTTED = "\\brdrdot".getBytes();
+ /**
+ * Constant for the dashed border style
+ */
+ protected static final byte[] BORDER_STYLE_DASHED = "\\brdrdash".getBytes();
+ /**
+ * Constant for the hairline border style
+ */
+ protected static final byte[] BORDER_STYLE_HAIRLINE = "\\brdrhair".getBytes();
+ /**
+ * Constant for the double border style
+ */
+ protected static final byte[] BORDER_STYLE_DOUBLE = "\\brdrdb".getBytes();
+ /**
+ * Constant for the dot dash border style
+ */
+ protected static final byte[] BORDER_STYLE_DOT_DASH = "\\brdrdashd".getBytes();
+ /**
+ * Constant for the dot dot dash border style
+ */
+ protected static final byte[] BORDER_STYLE_DOT_DOT_DASH = "\\brdrdashdd".getBytes();
+ /**
+ * Constant for the triple border style
+ */
+ protected static final byte[] BORDER_STYLE_TRIPLE = "\\brdrtriple".getBytes();
+ /**
+ * Constant for the thick thin border style
+ */
+ protected static final byte[] BORDER_STYLE_THICK_THIN = "\\brdrtnthsg".getBytes();
+ /**
+ * Constant for the thin thick border style
+ */
+ protected static final byte[] BORDER_STYLE_THIN_THICK = "\\brdrthtnsg".getBytes();
+ /**
+ * Constant for the thin thick thin border style
+ */
+ protected static final byte[] BORDER_STYLE_THIN_THICK_THIN = "\\brdrtnthtnsg".getBytes();
+ /**
+ * Constant for the thick thin medium border style
+ */
+ protected static final byte[] BORDER_STYLE_THICK_THIN_MED = "\\brdrtnthmg".getBytes();
+ /**
+ * Constant for the thin thick medium border style
+ */
+ protected static final byte[] BORDER_STYLE_THIN_THICK_MED = "\\brdrthtnmg".getBytes();
+ /**
+ * Constant for the thin thick thin medium border style
+ */
+ protected static final byte[] BORDER_STYLE_THIN_THICK_THIN_MED = "\\brdrtnthtnmg".getBytes();
+ /**
+ * Constant for the thick thin large border style
+ */
+ protected static final byte[] BORDER_STYLE_THICK_THIN_LARGE = "\\brdrtnthlg".getBytes();
+ /**
+ * Constant for the thin thick large border style
+ */
+ protected static final byte[] BORDER_STYLE_THIN_THICK_LARGE = "\\brdrthtnlg".getBytes();
+ /**
+ * Constant for the thin thick thin large border style
+ */
+ protected static final byte[] BORDER_STYLE_THIN_THICK_THIN_LARGE = "\\brdrtnthtnlg".getBytes();
+ /**
+ * Constant for the wavy border style
+ */
+ protected static final byte[] BORDER_STYLE_WAVY = "\\brdrwavy".getBytes();
+ /**
+ * Constant for the double wavy border style
+ */
+ protected static final byte[] BORDER_STYLE_DOUBLE_WAVY = "\\brdrwavydb".getBytes();
+ /**
+ * Constant for the striped border style
+ */
+ protected static final byte[] BORDER_STYLE_STRIPED = "\\brdrdashdotstr".getBytes();
+ /**
+ * Constant for the embossed border style
+ */
+ protected static final byte[] BORDER_STYLE_EMBOSS = "\\brdremboss".getBytes();
+ /**
+ * Constant for the engraved border style
+ */
+ protected static final byte[] BORDER_STYLE_ENGRAVE = "\\brdrengrave".getBytes();
+
+ /**
+ * Constant for a row border
+ */
+ protected static final int ROW_BORDER = 1;
+ /**
+ * Constant for a cell border
+ */
+ protected static final int CELL_BORDER = 2;
+
+ /**
+ * This border is no border :-)
+ */
+ protected static final int NO_BORDER = 0;
+ /**
+ * Constant for a left border
+ */
+ protected static final int LEFT_BORDER = 1;
+ /**
+ * Constant for a top border
+ */
+ protected static final int TOP_BORDER = 2;
+ /**
+ * Constant for a right border
+ */
+ protected static final int RIGHT_BORDER = 4;
+ /**
+ * Constant for a bottom border
+ */
+ protected static final int BOTTOM_BORDER = 8;
+ /**
+ * Constant for a box (left, top, right, bottom) border
+ */
+ protected static final int BOX_BORDER = 15;
+ /**
+ * Constant for a vertical line
+ */
+ protected static final int VERTICAL_BORDER = 16;
+ /**
+ * Constant for a horizontal line
+ */
+ protected static final int HORIZONTAL_BORDER = 32;
+
+ /**
+ * Constant for a border with no border
+ */
+ public static final int BORDER_NONE = 0;
+ /**
+ * Constant for a single border
+ */
+ public static final int BORDER_SINGLE = 1;
+ /**
+ * Constant for a double thick border
+ */
+ public static final int BORDER_DOUBLE_THICK = 2;
+ /**
+ * Constant for a shadowed border
+ */
+ public static final int BORDER_SHADOWED = 3;
+ /**
+ * Constant for a dotted border
+ */
+ public static final int BORDER_DOTTED = 4;
+ /**
+ * Constant for a dashed border
+ */
+ public static final int BORDER_DASHED = 5;
+ /**
+ * Constant for a hairline border
+ */
+ public static final int BORDER_HAIRLINE = 6;
+ /**
+ * Constant for a double border
+ */
+ public static final int BORDER_DOUBLE = 7;
+ /**
+ * Constant for a dot dash border
+ */
+ public static final int BORDER_DOT_DASH = 8;
+ /**
+ * Constant for a dot dot dash border
+ */
+ public static final int BORDER_DOT_DOT_DASH = 9;
+ /**
+ * Constant for a triple border
+ */
+ public static final int BORDER_TRIPLE = 10;
+ /**
+ * Constant for a thick thin border
+ */
+ public static final int BORDER_THICK_THIN = 11;
+ /**
+ * Constant for a thin thick border
+ */
+ public static final int BORDER_THIN_THICK = 12;
+ /**
+ * Constant for a thin thick thin border
+ */
+ public static final int BORDER_THIN_THICK_THIN = 13;
+ /**
+ * Constant for a thick thin medium border
+ */
+ public static final int BORDER_THICK_THIN_MED = 14;
+ /**
+ * Constant for a thin thick medium border
+ */
+ public static final int BORDER_THIN_THICK_MED = 15;
+ /**
+ * Constant for a thin thick thin medium border
+ */
+ public static final int BORDER_THIN_THICK_THIN_MED = 16;
+ /**
+ * Constant for a thick thin large border
+ */
+ public static final int BORDER_THICK_THIN_LARGE = 17;
+ /**
+ * Constant for a thin thick large border
+ */
+ public static final int BORDER_THIN_THICK_LARGE = 18;
+ /**
+ * Constant for a thin thick thin large border
+ */
+ public static final int BORDER_THIN_THICK_THIN_LARGE = 19;
+ /**
+ * Constant for a wavy border
+ */
+ public static final int BORDER_WAVY = 20;
+ /**
+ * Constant for a double wavy border
+ */
+ public static final int BORDER_DOUBLE_WAVY = 21;
+ /**
+ * Constant for a striped border
+ */
+ public static final int BORDER_STRIPED = 22;
+ /**
+ * Constant for an embossed border
+ */
+ public static final int BORDER_EMBOSS = 23;
+ /**
+ * Constant for an engraved border
+ */
+ public static final int BORDER_ENGRAVE = 24;
+
+ /**
+ * The type of this RtfBorder
+ */
+ private int borderType = ROW_BORDER;
+ /**
+ * The position of this RtfBorder
+ */
+ private int borderPosition = NO_BORDER;
+ /**
+ * The style of this RtfBorder
+ */
+ private int borderStyle = BORDER_NONE;
+ /**
+ * The width of this RtfBorder
+ */
+ private int borderWidth = 20;
+ /**
+ * The colour of this RtfBorder
+ */
+ private RtfColor borderColor = null;
+
+ /**
+ * Makes a copy of the given RtfBorder
+ *
+ * @param doc The RtfDocument this RtfBorder belongs to
+ * @param borderType The border type of this RtfBorder
+ * @param border The RtfBorder to copy
+ */
+ protected RtfBorder(RtfDocument doc, int borderType, RtfBorder border) {
+ super(doc);
+ this.borderType = borderType;
+ this.borderPosition = border.getBorderPosition();
+ this.borderStyle = border.getBorderStyle();
+ this.borderWidth = border.getBorderWidth();
+ this.borderColor = new RtfColor(this.document, border.getBorderColor());
+ }
+
+ /**
+ * Constructs a RtfBorder
+ *
+ * @param doc The RtfDocument this RtfBorder belongs to
+ * @param borderType The type of border this RtfBorder is
+ * @param borderPosition The position of this RtfBorder
+ * @param borderStyle The style of this RtfBorder
+ * @param borderWidth The width of this RtfBorder
+ * @param borderColor The colour of this RtfBorder
+ */
+ protected RtfBorder(RtfDocument doc, int borderType, int borderPosition, int borderStyle, float borderWidth, Color borderColor) {
+ super(doc);
+ this.borderType = borderType;
+ this.borderPosition = borderPosition;
+ this.borderStyle = borderStyle;
+ if(borderWidth > 2) {
+ borderWidth = 2;
+ }
+ this.borderWidth = (int) (borderWidth * TWIPS_FACTOR);
+ if(this.borderWidth == 0) {
+ this.borderStyle = BORDER_NONE;
+ }
+ if(borderColor == null) {
+ this.borderColor = new RtfColor(this.document, new Color(0, 0, 0));
+ } else {
+ this.borderColor = new RtfColor(this.document, borderColor);
+ }
+ }
+
+ /**
+ * Writes the RtfBorder settings
+ *
+ * @return A byte array with the RtfBorder settings
+ */
+ public byte[] write() {
+ if(this.borderStyle == BORDER_NONE || this.borderPosition == NO_BORDER || this.borderWidth == 0) {
+ return new byte[0];
+ }
+
+ ByteArrayOutputStream result = new ByteArrayOutputStream();
+ try {
+ if(this.borderType == ROW_BORDER) {
+ switch(this.borderPosition) {
+ case LEFT_BORDER:
+ result.write(ROW_BORDER_LEFT);
+ break;
+ case TOP_BORDER:
+ result.write(ROW_BORDER_TOP);
+ break;
+ case RIGHT_BORDER:
+ result.write(ROW_BORDER_RIGHT);
+ break;
+ case BOTTOM_BORDER:
+ result.write(ROW_BORDER_BOTTOM);
+ break;
+ case HORIZONTAL_BORDER:
+ result.write(ROW_BORDER_HORIZONTAL);
+ break;
+ case VERTICAL_BORDER:
+ result.write(ROW_BORDER_VERTICAL);
+ break;
+ default:
+ return new byte[0];
+ }
+ result.write(writeBorderStyle());
+ result.write(BORDER_WIDTH);
+ result.write(intToByteArray(this.borderWidth));
+ result.write(BORDER_COLOR_NUMBER);
+ result.write(intToByteArray(this.borderColor.getColorNumber()));
+ result.write('\n');
+ } else if(this.borderType == CELL_BORDER) {
+ switch(this.borderPosition) {
+ case LEFT_BORDER:
+ result.write(CELL_BORDER_LEFT);
+ break;
+ case TOP_BORDER:
+ result.write(CELL_BORDER_TOP);
+ break;
+ case RIGHT_BORDER:
+ result.write(CELL_BORDER_RIGHT);
+ break;
+ case BOTTOM_BORDER:
+ result.write(CELL_BORDER_BOTTOM);
+ break;
+ default:
+ return new byte[0];
+ }
+ result.write(writeBorderStyle());
+ result.write(BORDER_WIDTH);
+ result.write(intToByteArray(this.borderWidth));
+ result.write(BORDER_COLOR_NUMBER);
+ result.write(intToByteArray(this.borderColor.getColorNumber()));
+ result.write('\n');
+ }
+ } catch(IOException ioe) {
+ ioe.printStackTrace();
+ }
+
+ return result.toByteArray();
+ }
+
+ /**
+ * Writes the style of this RtfBorder
+ *
+ * @return A byte array containing the style of this RtfBorder
+ */
+ private byte[] writeBorderStyle() {
+ switch(this.borderStyle) {
+ case BORDER_NONE : return new byte[0];
+ case BORDER_SINGLE : return BORDER_STYLE_SINGLE;
+ case BORDER_DOUBLE_THICK : return BORDER_STYLE_DOUBLE_THICK;
+ case BORDER_SHADOWED : return BORDER_STYLE_SHADOWED;
+ case BORDER_DOTTED : return BORDER_STYLE_DOTTED;
+ case BORDER_DASHED : return BORDER_STYLE_DASHED;
+ case BORDER_HAIRLINE : return BORDER_STYLE_HAIRLINE;
+ case BORDER_DOUBLE : return BORDER_STYLE_DOUBLE;
+ case BORDER_DOT_DASH : return BORDER_STYLE_DOT_DASH;
+ case BORDER_DOT_DOT_DASH : return BORDER_STYLE_DOT_DOT_DASH;
+ case BORDER_TRIPLE : return BORDER_STYLE_TRIPLE;
+ case BORDER_THICK_THIN : return BORDER_STYLE_THICK_THIN;
+ case BORDER_THIN_THICK : return BORDER_STYLE_THIN_THICK;
+ case BORDER_THIN_THICK_THIN : return BORDER_STYLE_THIN_THICK_THIN;
+ case BORDER_THICK_THIN_MED : return BORDER_STYLE_THICK_THIN_MED;
+ case BORDER_THIN_THICK_MED : return BORDER_STYLE_THIN_THICK_MED;
+ case BORDER_THIN_THICK_THIN_MED : return BORDER_STYLE_THIN_THICK_THIN_MED;
+ case BORDER_THICK_THIN_LARGE : return BORDER_STYLE_THICK_THIN_LARGE;
+ case BORDER_THIN_THICK_LARGE : return BORDER_STYLE_THIN_THICK_LARGE;
+ case BORDER_THIN_THICK_THIN_LARGE : return BORDER_STYLE_THIN_THICK_THIN_LARGE;
+ case BORDER_WAVY : return BORDER_STYLE_WAVY;
+ case BORDER_DOUBLE_WAVY : return BORDER_STYLE_DOUBLE_WAVY;
+ case BORDER_STRIPED : return BORDER_STYLE_STRIPED;
+ case BORDER_EMBOSS : return BORDER_STYLE_EMBOSS;
+ case BORDER_ENGRAVE : return BORDER_STYLE_ENGRAVE;
+ default : return BORDER_STYLE_SINGLE;
+ }
+ }
+
+ /**
+ * Gets the colour of this RtfBorder
+ *
+ * @return Returns RtfColor of this RtfBorder
+ */
+ protected RtfColor getBorderColor() {
+ return borderColor;
+ }
+
+ /**
+ * Gets the position of this RtfBorder
+ * @return Returns the position of this RtfBorder
+ */
+ protected int getBorderPosition() {
+ return borderPosition;
+ }
+
+ /**
+ * Gets the style of this RtfBorder
+ *
+ * @return Returns the style of this RtfBorder
+ */
+ protected int getBorderStyle() {
+ return borderStyle;
+ }
+
+ /**
+ * Gets the type of this RtfBorder
+ *
+ * @return Returns the type of this RtfBorder
+ */
+ protected int getBorderType() {
+ return borderType;
+ }
+
+ /**
+ * Gets the width of this RtfBorder
+ *
+ * @return Returns the width of this RtfBorder
+ */
+ protected int getBorderWidth() {
+ return borderWidth;
+ }
+}
diff --git a/src/main/java/com/lowagie/text/rtf/table/RtfBorderGroup.java b/src/main/java/com/lowagie/text/rtf/table/RtfBorderGroup.java new file mode 100644 index 0000000..5b8904f --- /dev/null +++ b/src/main/java/com/lowagie/text/rtf/table/RtfBorderGroup.java @@ -0,0 +1,232 @@ +/*
+ * $Id: RtfBorderGroup.java,v 1.8 2004/12/14 12:51:39 blowagie Exp $
+ * $Name: $
+ *
+ * Copyright 2001, 2002, 2003, 2004 by Mark Hall
+ *
+ * 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.rtf.table;
+
+import java.awt.Color;
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.util.Enumeration;
+import java.util.Hashtable;
+
+import com.lowagie.text.Rectangle;
+import com.lowagie.text.rtf.RtfElement;
+import com.lowagie.text.rtf.document.RtfDocument;
+
+
+/**
+ * The RtfBorderGroup represents a collection of RtfBorders to use in a RtfCell
+ * or RtfTable.
+ *
+ * @version $Version:$
+ * @author Mark Hall (mhall@edu.uni-klu.ac.at)
+ */
+public class RtfBorderGroup extends RtfElement {
+ /**
+ * The type of borders this RtfBorderGroup contains.
+ * RtfBorder.ROW_BORDER or RtfBorder.CELL_BORDER
+ */
+ private int borderType = RtfBorder.ROW_BORDER;
+ /**
+ * The borders in this RtfBorderGroup
+ */
+ private Hashtable borders = null;
+
+ /**
+ * Constructs an empty RtfBorderGroup.
+ */
+ public RtfBorderGroup() {
+ super(null);
+ this.borders = new Hashtable();
+ }
+
+ /**
+ * Constructs a RtfBorderGroup with on border style for multiple borders.
+ *
+ * @param bordersToAdd The borders to add (Rectangle.LEFT, Rectangle.RIGHT, Rectangle.TOP, Rectangle.BOTTOM, Rectangle.BOX)
+ * @param borderStyle The style of border to add (from RtfBorder)
+ * @param borderWidth The border width to use
+ * @param borderColor The border color to use
+ */
+ public RtfBorderGroup(int bordersToAdd, int borderStyle, float borderWidth, Color borderColor) {
+ super(null);
+ this.borders = new Hashtable();
+ addBorder(bordersToAdd, borderStyle, borderWidth, borderColor);
+ }
+
+ /**
+ * Constructs a RtfBorderGroup based on another RtfBorderGroup.
+ *
+ * @param doc The RtfDocument this RtfBorderGroup belongs to
+ * @param borderType The type of borders this RtfBorderGroup contains
+ * @param borderGroup The RtfBorderGroup to use as a base
+ */
+ protected RtfBorderGroup(RtfDocument doc, int borderType, RtfBorderGroup borderGroup) {
+ super(doc);
+ this.borders = new Hashtable();
+ this.borderType = borderType;
+ if(borderGroup != null) {
+ Enumeration borderEnum = borderGroup.getBorders().keys();
+ while(borderEnum.hasMoreElements()) {
+ Integer borderPos = (Integer) borderEnum.nextElement();
+ RtfBorder border = (RtfBorder) borderGroup.getBorders().get(borderPos);
+ this.borders.put(borderPos, new RtfBorder(this.document, this.borderType, border));
+ }
+ }
+ }
+
+ /**
+ * Constructs a RtfBorderGroup with certain borders
+ *
+ * @param doc The RtfDocument this RtfBorderGroup belongs to
+ * @param borderType The type of borders this RtfBorderGroup contains
+ * @param bordersToUse The borders to add (Rectangle.LEFT, Rectangle.RIGHT, Rectangle.TOP, Rectangle.BOTTOM, Rectangle.BOX)
+ * @param borderWidth The border width to use
+ * @param borderColor The border color to use
+ */
+ protected RtfBorderGroup(RtfDocument doc, int borderType, int bordersToUse, float borderWidth, Color borderColor) {
+ super(doc);
+ this.borderType = borderType;
+ this.borders = new Hashtable();
+ addBorder(bordersToUse, RtfBorder.BORDER_SINGLE, borderWidth, borderColor);
+ }
+
+ /**
+ * Sets a border in the Hashtable of borders
+ *
+ * @param borderPosition The position of this RtfBorder
+ * @param borderStyle The type of borders this RtfBorderGroup contains
+ * @param borderWidth The border width to use
+ * @param borderColor The border color to use
+ */
+ private void setBorder(int borderPosition, int borderStyle, float borderWidth, Color borderColor) {
+ RtfBorder border = new RtfBorder(this.document, this.borderType, borderPosition, borderStyle, borderWidth, borderColor);
+ this.borders.put(new Integer(borderPosition), border);
+ }
+
+ /**
+ * Adds borders to the RtfBorderGroup
+ *
+ * @param bordersToAdd The borders to add (Rectangle.LEFT, Rectangle.RIGHT, Rectangle.TOP, Rectangle.BOTTOM, Rectangle.BOX)
+ * @param borderStyle The style of border to add (from RtfBorder)
+ * @param borderWidth The border width to use
+ * @param borderColor The border color to use
+ */
+ public void addBorder(int bordersToAdd, int borderStyle, float borderWidth, Color borderColor) {
+ if((bordersToAdd & Rectangle.LEFT) == Rectangle.LEFT) {
+ setBorder(RtfBorder.LEFT_BORDER, borderStyle, borderWidth, borderColor);
+ }
+ if((bordersToAdd & Rectangle.TOP) == Rectangle.TOP) {
+ setBorder(RtfBorder.TOP_BORDER, borderStyle, borderWidth, borderColor);
+ }
+ if((bordersToAdd & Rectangle.RIGHT) == Rectangle.RIGHT) {
+ setBorder(RtfBorder.RIGHT_BORDER, borderStyle, borderWidth, borderColor);
+ }
+ if((bordersToAdd & Rectangle.BOTTOM) == Rectangle.BOTTOM) {
+ setBorder(RtfBorder.BOTTOM_BORDER, borderStyle, borderWidth, borderColor);
+ }
+ if((bordersToAdd & Rectangle.BOX) == Rectangle.BOX && this.borderType == RtfBorder.ROW_BORDER) {
+ setBorder(RtfBorder.VERTICAL_BORDER, borderStyle, borderWidth, borderColor);
+ setBorder(RtfBorder.HORIZONTAL_BORDER, borderStyle, borderWidth, borderColor);
+ }
+ }
+
+ /**
+ * Removes borders from the list of borders
+ *
+ * @param bordersToRemove The borders to remove (from Rectangle)
+ */
+ public void removeBorder(int bordersToRemove) {
+ if((bordersToRemove & Rectangle.LEFT) == Rectangle.LEFT) {
+ this.borders.remove(new Integer(RtfBorder.LEFT_BORDER));
+ }
+ if((bordersToRemove & Rectangle.TOP) == Rectangle.TOP) {
+ this.borders.remove(new Integer(RtfBorder.TOP_BORDER));
+ }
+ if((bordersToRemove & Rectangle.RIGHT) == Rectangle.RIGHT) {
+ this.borders.remove(new Integer(RtfBorder.RIGHT_BORDER));
+ }
+ if((bordersToRemove & Rectangle.BOTTOM) == Rectangle.BOTTOM) {
+ this.borders.remove(new Integer(RtfBorder.BOTTOM_BORDER));
+ }
+ if((bordersToRemove & Rectangle.BOX) == Rectangle.BOX && this.borderType == RtfBorder.ROW_BORDER) {
+ this.borders.remove(new Integer(RtfBorder.VERTICAL_BORDER));
+ this.borders.remove(new Integer(RtfBorder.HORIZONTAL_BORDER));
+ }
+ }
+
+ /**
+ * Writes the borders of this RtfBorderGroup
+ *
+ * @return A byte array with the borders of this RtfBorderGroup
+ */
+ public byte[] write() {
+ ByteArrayOutputStream result = new ByteArrayOutputStream();
+ try {
+ Enumeration borderEnum = this.borders.keys();
+ while(borderEnum.hasMoreElements()) {
+ result.write(((RtfBorder) this.borders.get(borderEnum.nextElement())).write());
+ }
+ } catch(IOException ioe) {
+ ioe.printStackTrace();
+ }
+
+ return result.toByteArray();
+ }
+
+ /**
+ * Gets the RtfBorders of this RtfBorderGroup
+ *
+ * @return The RtfBorders of this RtfBorderGroup
+ */
+ protected Hashtable getBorders() {
+ return this.borders;
+ }
+}
diff --git a/src/main/java/com/lowagie/text/rtf/table/RtfCell.java b/src/main/java/com/lowagie/text/rtf/table/RtfCell.java new file mode 100644 index 0000000..abfee02 --- /dev/null +++ b/src/main/java/com/lowagie/text/rtf/table/RtfCell.java @@ -0,0 +1,534 @@ +/*
+ * $Id: RtfCell.java,v 1.15 2006/02/09 17:13:11 hallm Exp $
+ * $Name: $
+ *
+ * Copyright 2001, 2002, 2003, 2004 by Mark Hall
+ *
+ * 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.rtf.table;
+
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.util.Iterator;
+import java.util.Properties;
+import java.util.ArrayList;
+
+import com.lowagie.text.BadElementException;
+import com.lowagie.text.Cell;
+import com.lowagie.text.DocumentException;
+import com.lowagie.text.Element;
+import com.lowagie.text.List;
+import com.lowagie.text.Paragraph;
+import com.lowagie.text.rtf.RtfBasicElement;
+import com.lowagie.text.rtf.RtfExtendedElement;
+import com.lowagie.text.rtf.document.RtfDocument;
+import com.lowagie.text.rtf.style.RtfColor;
+import com.lowagie.text.rtf.style.RtfParagraphStyle;
+import com.lowagie.text.rtf.text.RtfParagraph;
+
+
+/**
+ * The RtfCell wraps a Cell, but can also be added directly to a Table.
+ * The RtfCell is an extension of Cell, that supports a multitude of different
+ * borderstyles.
+ *
+ * @version $Id: RtfCell.java,v 1.15 2006/02/09 17:13:11 hallm Exp $
+ * @author Mark Hall (mhall@edu.uni-klu.ac.at)
+ * @author Steffen Stundzig
+ * @author Benoit WIART <b.wiart@proxiad.com>
+ * @see com.lowagie.text.rtf.table.RtfBorder
+ */
+public class RtfCell extends Cell implements RtfExtendedElement {
+
+ /**
+ * This cell is not merged
+ */
+ private static final int MERGE_NONE = 0;
+ /**
+ * This cell is the parent cell of a vertical merge operation
+ */
+ private static final int MERGE_VERT_PARENT = 1;
+ /**
+ * This cell is a child cell of a vertical merge operation
+ */
+ private static final int MERGE_VERT_CHILD = 2;
+
+ /**
+ * The parent RtfRow of this RtfCell
+ */
+ private RtfRow parentRow = null;
+ /**
+ * The content of this RtfCell
+ */
+ private ArrayList content = null;
+ /**
+ * The right margin of this RtfCell
+ */
+ private int cellRight = 0;
+ /**
+ * The width of this RtfCell
+ */
+ private int cellWidth = 0;
+ /**
+ * The borders of this RtfCell
+ */
+ private RtfBorderGroup borders = null;
+ /**
+ * The vertical alignment of this RtfCell
+ */
+ private int verticalAlignment = Cell.ALIGN_MIDDLE;
+ /**
+ * The background color of this RtfCell
+ */
+ private RtfColor backgroundColor = null;
+ /**
+ * The padding of this RtfCell
+ */
+ private int cellPadding = 0;
+ /**
+ * The merge type of this RtfCell
+ */
+ private int mergeType = MERGE_NONE;
+ /**
+ * The number of columns spanned by this RtfCell
+ */
+ private int colspan = 1;
+ /**
+ * The number of rows spanned by this RtfCell
+ */
+ private int rowspan = 1;
+ /**
+ * The RtfDocument this RtfCell belongs to
+ */
+ private RtfDocument document = null;
+ /**
+ * Whether this RtfCell is in a header
+ */
+ private boolean inHeader = false;
+
+ /**
+ * Constructs an empty RtfCell
+ */
+ public RtfCell() {
+ super();
+ this.borders = new RtfBorderGroup();
+ }
+
+ /**
+ * Constructs a RtfCell based upon a String
+ *
+ * @param content The String to base the RtfCell on
+ */
+ public RtfCell(String content) {
+ super(content);
+ this.borders = new RtfBorderGroup();
+ }
+
+ /**
+ * Constructs a RtfCell based upon an Element
+ *
+ * @param element The Element to base the RtfCell on
+ * @throws BadElementException If the Element is not valid
+ */
+ public RtfCell(Element element) throws BadElementException {
+ super(element);
+ this.borders = new RtfBorderGroup();
+ }
+
+ /**
+ * Constructs a RtfCell based upon certain Properties
+ *
+ * @param properties The Properties for this RtfCell
+ */
+ public RtfCell(Properties properties) {
+ super(properties);
+ this.borders = new RtfBorderGroup();
+ }
+
+ /**
+ * Constructs a RtfCell based on a Cell.
+ *
+ * @param doc The RtfDocument this RtfCell belongs to
+ * @param row The RtfRow this RtfCell lies in
+ * @param cell The Cell to base this RtfCell on
+ */
+ protected RtfCell(RtfDocument doc, RtfRow row, Cell cell) {
+ this.document = doc;
+ this.parentRow = row;
+ importCell(cell);
+ }
+
+ /**
+ * Imports the Cell properties into the RtfCell
+ *
+ * @param cell The Cell to import
+ */
+ private void importCell(Cell cell) {
+ this.content = new ArrayList();
+
+ if(cell == null) {
+ this.borders = new RtfBorderGroup(this.document, RtfBorder.CELL_BORDER, this.parentRow.getParentTable().getBorders());
+ return;
+ }
+
+ this.colspan = cell.colspan();
+ this.rowspan = cell.rowspan();
+ if(cell.rowspan() > 1) {
+ this.mergeType = MERGE_VERT_PARENT;
+ }
+ if(cell instanceof RtfCell) {
+ this.borders = new RtfBorderGroup(this.document, RtfBorder.CELL_BORDER, ((RtfCell) cell).getBorders());
+ } else {
+ this.borders = new RtfBorderGroup(this.document, RtfBorder.CELL_BORDER, cell.border(), cell.borderWidth(), cell.borderColor());
+ }
+ this.verticalAlignment = cell.verticalAlignment();
+ if(cell.backgroundColor() == null) {
+ this.backgroundColor = new RtfColor(this.document, 255, 255, 255);
+ } else {
+ this.backgroundColor = new RtfColor(this.document, cell.backgroundColor());
+ }
+
+ this.cellPadding = (int) this.parentRow.getParentTable().getCellPadding();
+
+ if(cell != null) {
+ Iterator cellIterator = cell.getElements();
+ Paragraph container = null;
+ while(cellIterator.hasNext()) {
+ try {
+ Element element = (Element) cellIterator.next();
+ // should we wrap it in a paragraph
+ if(!(element instanceof Paragraph) && !(element instanceof List)) {
+ if(container != null) {
+ container.add(element);
+ } else {
+ container = new Paragraph();
+ container.setAlignment(cell.horizontalAlignment());
+ container.add(element);
+ }
+ } else {
+ if(container != null) {
+ RtfBasicElement rtfElement = this.document.getMapper().mapElement(container);
+ rtfElement.setInTable(true);
+ this.content.add(rtfElement);
+ container = null;
+ }
+ // if horizontal alignment is undefined overwrite
+ // with that of enclosing cell
+ if (element instanceof Paragraph && ((Paragraph) element).alignment() == Element.ALIGN_UNDEFINED) {
+ ((Paragraph) element).setAlignment(cell.horizontalAlignment());
+ }
+
+ RtfBasicElement rtfElement = this.document.getMapper().mapElement(element);
+ rtfElement.setInTable(true);
+ this.content.add(rtfElement);
+ }
+ } catch(DocumentException de) {
+ de.printStackTrace();
+ }
+ }
+ if(container != null) {
+ try {
+ RtfBasicElement rtfElement = this.document.getMapper().mapElement(container);
+ rtfElement.setInTable(true);
+ this.content.add(rtfElement);
+ } catch(DocumentException de) {
+ de.printStackTrace();
+ }
+ }
+ }
+ }
+
+ /**
+ * Write the cell definition part of this RtfCell
+ *
+ * @return A byte array with the cell definition
+ */
+ public byte[] writeDefinition() {
+ ByteArrayOutputStream result = new ByteArrayOutputStream();
+ try {
+ if(this.mergeType == MERGE_VERT_PARENT) {
+ result.write("\\clvmgf".getBytes());
+ } else if(this.mergeType == MERGE_VERT_CHILD) {
+ result.write("\\clvmrg".getBytes());
+ }
+ switch (verticalAlignment) {
+ case Element.ALIGN_BOTTOM:
+ result.write("\\clvertalb".getBytes());
+ break;
+ case Element.ALIGN_CENTER:
+ case Element.ALIGN_MIDDLE:
+ result.write("\\clvertalc".getBytes());
+ break;
+ case Element.ALIGN_TOP:
+ result.write("\\clvertalt".getBytes());
+ break;
+ }
+ result.write(this.borders.write());
+
+ if(this.backgroundColor != null) {
+ result.write("\\clcbpat".getBytes());
+ result.write(intToByteArray(this.backgroundColor.getColorNumber()));
+ }
+ result.write('\n');
+
+ result.write("\\clftsWidth3".getBytes());
+ result.write('\n');
+
+ result.write("\\clwWidth".getBytes());
+ result.write(intToByteArray(this.cellWidth));
+ result.write('\n');
+
+ if(this.cellPadding > 0) {
+ result.write("\\clpadl".getBytes());
+ result.write(intToByteArray(this.cellPadding / 2));
+ result.write("\\clpadt".getBytes());
+ result.write(intToByteArray(this.cellPadding / 2));
+ result.write("\\clpadr".getBytes());
+ result.write(intToByteArray(this.cellPadding / 2));
+ result.write("\\clpadb".getBytes());
+ result.write(intToByteArray(this.cellPadding / 2));
+ result.write("\\clpadfl3".getBytes());
+ result.write("\\clpadft3".getBytes());
+ result.write("\\clpadfr3".getBytes());
+ result.write("\\clpadfb3".getBytes());
+ }
+ result.write("\\cellx".getBytes());
+ result.write(intToByteArray(this.cellRight));
+
+ } catch(IOException ioe) {
+ ioe.printStackTrace();
+ }
+
+ return result.toByteArray();
+ }
+
+ /**
+ * Write the content of this RtfCell
+ *
+ * @return A byte array with the content of this RtfCell
+ */
+ public byte[] write() {
+ ByteArrayOutputStream result = new ByteArrayOutputStream();
+ try {
+ if(this.content.size() == 0) {
+ result.write(RtfParagraph.PARAGRAPH_DEFAULTS);
+ if(this.parentRow.getParentTable().getTableFitToPage()) {
+ result.write(RtfParagraphStyle.KEEP_TOGETHER_WITH_NEXT);
+ }
+ result.write(RtfParagraph.IN_TABLE);
+ } else {
+ for(int i = 0; i < this.content.size(); i++) {
+ RtfBasicElement rtfElement = (RtfBasicElement) this.content.get(i);
+ if(rtfElement instanceof RtfParagraph) {
+ ((RtfParagraph) rtfElement).setKeepTogetherWithNext(this.parentRow.getParentTable().getTableFitToPage());
+ }
+ result.write(rtfElement.write());
+ if(rtfElement instanceof RtfParagraph && i < (this.content.size() - 1)) {
+ result.write(RtfParagraph.PARAGRAPH);
+ }
+ }
+ }
+ result.write("\\cell".getBytes());
+ } catch(IOException ioe) {
+ ioe.printStackTrace();
+ }
+
+ return result.toByteArray();
+ }
+
+ /**
+ * Sets the right margin of this cell. Used in merge operations
+ *
+ * @param cellRight The right margin to use
+ */
+ protected void setCellRight(int cellRight) {
+ this.cellRight = cellRight;
+ }
+
+ /**
+ * Gets the right margin of this RtfCell
+ *
+ * @return The right margin of this RtfCell.
+ */
+ protected int getCellRight() {
+ return this.cellRight;
+ }
+
+ /**
+ * Sets the cell width of this RtfCell. Used in merge operations.
+ *
+ * @param cellWidth The cell width to use
+ */
+ protected void setCellWidth(int cellWidth) {
+ this.cellWidth = cellWidth;
+ }
+
+ /**
+ * Gets the cell width of this RtfCell
+ *
+ * @return The cell width of this RtfCell
+ */
+ protected int getCellWidth() {
+ return this.cellWidth;
+ }
+
+ /**
+ * Gets the number of columns this RtfCell spans
+ *
+ * @return The number of columns this RtfCell spans
+ */
+ protected int getColspan() {
+ return this.colspan;
+ }
+
+ /**
+ * Gets the number of rows this RtfCell spans
+ *
+ * @return The number of rows this RtfCell spans
+ */
+ protected int getRowspan() {
+ return this.rowspan;
+ }
+
+ /**
+ * Gets the cell padding of this RtfCell
+ *
+ * @return The cell padding of this RtfCell
+ */
+ protected int getCellpadding() {
+ return this.cellPadding;
+ }
+
+ /**
+ * Gets the borders of this RtfCell
+ *
+ * @return The borders of this RtfCell
+ */
+ protected RtfBorderGroup getBorders() {
+ return this.borders;
+ }
+
+ /**
+ * Set the borders of this RtfCell
+ *
+ * @param borderGroup The RtfBorderGroup to use as borders
+ */
+ public void setBorders(RtfBorderGroup borderGroup) {
+ this.borders = new RtfBorderGroup(this.document, RtfBorder.CELL_BORDER, borderGroup);
+ }
+
+ /**
+ * Get the vertical alignment of this RtfCell
+ *
+ * @return The vertical alignment of this RtfCell
+ */
+ protected int getVerticalAlignment() {
+ return this.verticalAlignment;
+ }
+
+ /**
+ * Get the background color of this RtfCell
+ *
+ * @return The background color of this RtfCell
+ */
+ protected RtfColor getBackgroundColor() {
+ return this.backgroundColor;
+ }
+
+ /**
+ * Merge this cell into the parent cell.
+ *
+ * @param mergeParent The RtfCell to merge with
+ */
+ protected void setCellMergeChild(RtfCell mergeParent) {
+ this.mergeType = MERGE_VERT_CHILD;
+ this.cellWidth = mergeParent.getCellWidth();
+ this.cellRight = mergeParent.getCellRight();
+ this.cellPadding = mergeParent.getCellpadding();
+ this.borders = mergeParent.getBorders();
+ this.verticalAlignment = mergeParent.getVerticalAlignment();
+ this.backgroundColor = mergeParent.getBackgroundColor();
+ }
+
+ /**
+ * Sets the RtfDocument this RtfCell belongs to
+ *
+ * @param doc The RtfDocument to use
+ */
+ public void setRtfDocument(RtfDocument doc) {
+ this.document = doc;
+ }
+
+ /**
+ * Unused
+ * @param inTable
+ */
+ public void setInTable(boolean inTable) {
+ }
+
+ /**
+ * Sets whether this RtfCell is in a header
+ *
+ * @param inHeader <code>True</code> if this RtfCell is in a header, <code>false</code> otherwise
+ */
+ public void setInHeader(boolean inHeader) {
+ this.inHeader = inHeader;
+ for(int i = 0; i < this.content.size(); i++) {
+ ((RtfBasicElement) this.content.get(i)).setInHeader(inHeader);
+ }
+ }
+
+ /**
+ * Transforms an integer into its String representation and then returns the bytes
+ * of that string.
+ *
+ * @param i The integer to convert
+ * @return A byte array representing the integer
+ */
+ private byte[] intToByteArray(int i) {
+ return Integer.toString(i).getBytes();
+ }
+}
diff --git a/src/main/java/com/lowagie/text/rtf/table/RtfRow.java b/src/main/java/com/lowagie/text/rtf/table/RtfRow.java new file mode 100644 index 0000000..4075ed2 --- /dev/null +++ b/src/main/java/com/lowagie/text/rtf/table/RtfRow.java @@ -0,0 +1,377 @@ +/*
+ * $Id: RtfRow.java,v 1.16 2005/05/24 16:30:53 hallm Exp $
+ * $Name: $
+ *
+ * Copyright 2001, 2002, 2003, 2004, 2005 by Mark Hall
+ *
+ * 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.rtf.table;
+
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.util.ArrayList;
+
+import com.lowagie.text.Cell;
+import com.lowagie.text.Element;
+import com.lowagie.text.Row;
+import com.lowagie.text.rtf.RtfElement;
+import com.lowagie.text.rtf.document.RtfDocument;
+
+
+/**
+ * The RtfRow wraps one Row for a RtfTable.
+ * INTERNAL USE ONLY
+ *
+ * @version $Version:$
+ * @author Mark Hall (mhall@edu.uni-klu.ac.at)
+ * @author Steffen Stundzig
+ * @author Lorenz Maierhofer <larry@sbox.tugraz.at>
+ */
+public class RtfRow extends RtfElement {
+
+ /**
+ * Constant for the RtfRow beginning
+ */
+ private static final byte[] ROW_BEGIN = "\\trowd".getBytes();
+ /**
+ * Constant for the RtfRow width style
+ */
+ private static final byte[] ROW_WIDTH_STYLE = "\\trftsWidth3".getBytes();
+ /**
+ * Constant for the RtfRow width
+ */
+ private static final byte[] ROW_WIDTH = "\\trwWidth".getBytes();
+ /**
+ * Constant to specify that this RtfRow are not to be broken across pages
+ */
+ private static final byte[] ROW_KEEP_TOGETHER = "\\trkeep".getBytes();
+ /**
+ * Constant to specify that this is a header RtfRow
+ */
+ private static final byte[] ROW_HEADER_ROW = "\\trhdr".getBytes();
+ /**
+ * Constant for left alignment of this RtfRow
+ */
+ private static final byte[] ROW_ALIGN_LEFT = "\\trql".getBytes();
+ /**
+ * Constant for right alignment of this RtfRow
+ */
+ private static final byte[] ROW_ALIGN_RIGHT = "\\trqr".getBytes();
+ /**
+ * Constant for center alignment of this RtfRow
+ */
+ private static final byte[] ROW_ALIGN_CENTER = "\\trqc".getBytes();
+ /**
+ * Constant for justified alignment of this RtfRow
+ */
+ private static final byte[] ROW_ALIGN_JUSTIFIED = "\\trqj".getBytes();
+ /**
+ * Constant for the graph style of this RtfRow
+ */
+ private static final byte[] ROW_GRAPH = "\\trgaph10".getBytes();
+ /**
+ * Constant for the cell left spacing
+ */
+ private static final byte[] ROW_CELL_SPACING_LEFT = "\\trspdl".getBytes();
+ /**
+ * Constant for the cell top spacing
+ */
+ private static final byte[] ROW_CELL_SPACING_TOP = "\\trspdt".getBytes();
+ /**
+ * Constant for the cell right spacing
+ */
+ private static final byte[] ROW_CELL_SPACING_RIGHT = "\\trspdr".getBytes();
+ /**
+ * Constant for the cell bottom spacing
+ */
+ private static final byte[] ROW_CELL_SPACING_BOTTOM = "\\trspdb".getBytes();
+ /**
+ * Constant for the cell left spacing style
+ */
+ private static final byte[] ROW_CELL_SPACING_LEFT_STYLE = "\\trspdfl3".getBytes();
+ /**
+ * Constant for the cell top spacing style
+ */
+ private static final byte[] ROW_CELL_SPACING_TOP_STYLE = "\\trspdft3".getBytes();
+ /**
+ * Constant for the cell right spacing style
+ */
+ private static final byte[] ROW_CELL_SPACING_RIGHT_STYLE = "\\trspdfr3".getBytes();
+ /**
+ * Constant for the cell bottom spacing style
+ */
+ private static final byte[] ROW_CELL_SPACING_BOTTOM_STYLE = "\\trspdfb3".getBytes();
+ /**
+ * Constant for the cell left padding
+ */
+ private static final byte[] ROW_CELL_PADDING_LEFT = "\\trpaddl".getBytes();
+ /**
+ * Constant for the cell right padding
+ */
+ private static final byte[] ROW_CELL_PADDING_RIGHT = "\\trpaddr".getBytes();
+ /**
+ * Constant for the cell left padding style
+ */
+ private static final byte[] ROW_CELL_PADDING_LEFT_STYLE = "\\trpaddfl3".getBytes();
+ /**
+ * Constant for the cell right padding style
+ */
+ private static final byte[] ROW_CELL_PADDING_RIGHT_STYLE = "\\trpaddfr3".getBytes();
+ /**
+ * Constant for the end of a row
+ */
+ private static final byte[] ROW_END = "\\row".getBytes();
+
+ /**
+ * The RtfTable this RtfRow belongs to
+ */
+ private RtfTable parentTable = null;
+ /**
+ * The cells of this RtfRow
+ */
+ private ArrayList cells = null;
+ /**
+ * The width of this row
+ */
+ private int width = 0;
+ /**
+ * The row number
+ */
+ private int rowNumber = 0;
+
+ /**
+ * Constructs a RtfRow for a Row.
+ *
+ * @param doc The RtfDocument this RtfRow belongs to
+ * @param rtfTable The RtfTable this RtfRow belongs to
+ * @param row The Row this RtfRow is based on
+ * @param rowNumber The number of this row
+ */
+ protected RtfRow(RtfDocument doc, RtfTable rtfTable, Row row, int rowNumber) {
+ super(doc);
+ this.parentTable = rtfTable;
+ this.rowNumber = rowNumber;
+ importRow(row);
+ }
+
+ /**
+ * Imports a Row and copies all settings
+ *
+ * @param row The Row to import
+ */
+ private void importRow(Row row) {
+ this.cells = new ArrayList();
+ this.width = this.document.getDocumentHeader().getPageSetting().getPageWidth() - this.document.getDocumentHeader().getPageSetting().getMarginLeft() - this.document.getDocumentHeader().getPageSetting().getMarginRight();
+ this.width = (int) (this.width / 100 * this.parentTable.getTableWidthPercent());
+
+ int cellRight = 0;
+ int cellWidth = 0;
+ for(int i = 0; i < row.columns(); i++) {
+ cellWidth = (int) (this.width / 100 * this.parentTable.getProportionalWidths()[i]);
+ cellRight = cellRight + cellWidth;
+
+ Cell cell = (Cell) row.getCell(i);
+ RtfCell rtfCell = new RtfCell(this.document, this, cell);
+ rtfCell.setCellRight(cellRight);
+ rtfCell.setCellWidth(cellWidth);
+ this.cells.add(rtfCell);
+ }
+ }
+
+ /**
+ * Performs a second pass over all cells to handle cell row/column spanning.
+ */
+ protected void handleCellSpanning() {
+ int realCellIndex = 0;
+ for(int i = 0; i < this.cells.size(); i++) {
+ RtfCell rtfCell = (RtfCell) this.cells.get(i);
+ if(rtfCell.getColspan() > 1) {
+ int j = rtfCell.getColspan();
+ while(j > 1) {
+ if(i + 1 < this.cells.size()) {
+ RtfCell rtfCellMerge = (RtfCell) this.cells.get(i + 1);
+ rtfCell.setCellRight(rtfCell.getCellRight() + rtfCellMerge.getCellWidth());
+ rtfCell.setCellWidth(rtfCell.getCellWidth() + rtfCellMerge.getCellWidth());
+ this.cells.remove(i + 1);
+ j--;
+ }
+ }
+ }
+ if(rtfCell.getRowspan() > 1) {
+ ArrayList rows = this.parentTable.getRows();
+ for(int j = 1; j < rtfCell.getRowspan(); j++) {
+ RtfRow mergeRow = (RtfRow) rows.get(this.rowNumber + j);
+ if(this.rowNumber + j < rows.size()) {
+ RtfCell rtfCellMerge = (RtfCell) mergeRow.getCells().get(realCellIndex);
+ rtfCellMerge.setCellMergeChild(rtfCell);
+ }
+ if(rtfCell.getColspan() > 1) {
+ int k = rtfCell.getColspan();
+ while(k > 1 && (realCellIndex + 1 < mergeRow.getCells().size())) {
+ mergeRow.getCells().remove(realCellIndex + 1);
+ k--;
+ }
+ }
+ }
+ }
+ realCellIndex = realCellIndex + rtfCell.getColspan();
+ }
+ }
+
+ private byte[] writeRowDefinitions() {
+ ByteArrayOutputStream result = new ByteArrayOutputStream();
+ try {
+ result.write(ROW_BEGIN);
+ result.write('\n');
+ result.write(ROW_WIDTH_STYLE);
+ result.write(ROW_WIDTH);
+ result.write(intToByteArray(this.width));
+ if(this.parentTable.getCellsFitToPage()) {
+ result.write(ROW_KEEP_TOGETHER);
+ }
+ if(this.rowNumber <= this.parentTable.getHeaderRows()) {
+ result.write(ROW_HEADER_ROW);
+ }
+ switch (this.parentTable.getAlignment()) {
+ case Element.ALIGN_LEFT:
+ result.write(ROW_ALIGN_LEFT);
+ break;
+ case Element.ALIGN_RIGHT:
+ result.write(ROW_ALIGN_RIGHT);
+ break;
+ case Element.ALIGN_CENTER:
+ result.write(ROW_ALIGN_CENTER);
+ break;
+ case Element.ALIGN_JUSTIFIED:
+ case Element.ALIGN_JUSTIFIED_ALL:
+ result.write(ROW_ALIGN_JUSTIFIED);
+ break;
+ }
+ result.write(ROW_GRAPH);
+
+ result.write(this.parentTable.getBorders().write());
+
+ if(this.parentTable.getCellSpacing() > 0) {
+ result.write(ROW_CELL_SPACING_LEFT);
+ result.write(intToByteArray((int) (this.parentTable.getCellSpacing() / 2)));
+ result.write(ROW_CELL_SPACING_LEFT_STYLE);
+ result.write(ROW_CELL_SPACING_TOP);
+ result.write(intToByteArray((int) (this.parentTable.getCellSpacing() / 2)));
+ result.write(ROW_CELL_SPACING_TOP_STYLE);
+ result.write(ROW_CELL_SPACING_RIGHT);
+ result.write(intToByteArray((int) (this.parentTable.getCellSpacing() / 2)));
+ result.write(ROW_CELL_SPACING_RIGHT_STYLE);
+ result.write(ROW_CELL_SPACING_BOTTOM);
+ result.write(intToByteArray((int) (this.parentTable.getCellSpacing() / 2)));
+ result.write(ROW_CELL_SPACING_BOTTOM_STYLE);
+ }
+
+ result.write(ROW_CELL_PADDING_LEFT);
+ result.write(intToByteArray((int) (this.parentTable.getCellPadding() / 2)));
+ result.write(ROW_CELL_PADDING_RIGHT);
+ result.write(intToByteArray((int) (this.parentTable.getCellPadding() / 2)));
+ result.write(ROW_CELL_PADDING_LEFT_STYLE);
+ result.write(ROW_CELL_PADDING_RIGHT_STYLE);
+
+ result.write('\n');
+
+ for(int i = 0; i < this.cells.size(); i++) {
+ RtfCell rtfCell = (RtfCell) this.cells.get(i);
+ result.write(rtfCell.writeDefinition());
+ }
+ } catch(IOException ioe) {
+ ioe.printStackTrace();
+ }
+ return result.toByteArray();
+ }
+
+ /**
+ * Writes the content of this RtfRow
+ *
+ * @return A byte array with the content of this RtfRow
+ */
+ public byte[] write() {
+ ByteArrayOutputStream result = new ByteArrayOutputStream();
+ try {
+ result.write(writeRowDefinitions());
+
+ for(int i = 0; i < this.cells.size(); i++) {
+ RtfCell rtfCell = (RtfCell) this.cells.get(i);
+ result.write(rtfCell.write());
+ }
+
+ result.write(DELIMITER);
+
+ if(this.document.getDocumentSettings().isOutputTableRowDefinitionAfter()) {
+ result.write(writeRowDefinitions());
+ }
+
+ result.write(ROW_END);
+ result.write("\n".getBytes());
+ } catch(IOException ioe) {
+ ioe.printStackTrace();
+ }
+ return result.toByteArray();
+ }
+
+ /**
+ * Gets the parent RtfTable of this RtfRow
+ *
+ * @return The parent RtfTable of this RtfRow
+ */
+ protected RtfTable getParentTable() {
+ return this.parentTable;
+ }
+
+ /**
+ * Gets the cells of this RtfRow
+ *
+ * @return The cells of this RtfRow
+ */
+ protected ArrayList getCells() {
+ return this.cells;
+ }
+}
diff --git a/src/main/java/com/lowagie/text/rtf/table/RtfTable.java b/src/main/java/com/lowagie/text/rtf/table/RtfTable.java new file mode 100644 index 0000000..285d9e0 --- /dev/null +++ b/src/main/java/com/lowagie/text/rtf/table/RtfTable.java @@ -0,0 +1,271 @@ +/*
+ * $Id: RtfTable.java,v 1.11 2005/07/16 11:39:30 hallm Exp $
+ * $Name: $
+ *
+ * Copyright 2001, 2002, 2003, 2004 by Mark Hall
+ *
+ * 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.rtf.table;
+
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.util.Iterator;
+import java.util.ArrayList;
+
+import com.lowagie.text.Element;
+import com.lowagie.text.Row;
+import com.lowagie.text.Table;
+import com.lowagie.text.rtf.RtfElement;
+import com.lowagie.text.rtf.document.RtfDocument;
+import com.lowagie.text.rtf.text.RtfParagraph;
+
+
+/**
+ * The RtfTable wraps a Table.
+ * INTERNAL USE ONLY
+ *
+ * @version $Version:$
+ * @author Mark Hall (mhall@edu.uni-klu.ac.at)
+ * @author Steffen Stundzig
+ * @author Benoit WIART <b.wiart@proxiad.com>
+ */
+public class RtfTable extends RtfElement {
+
+ /**
+ * The rows of this RtfTable
+ */
+ private ArrayList rows = null;
+ /**
+ * The percentage of the page width that this RtfTable covers
+ */
+ private float tableWidthPercent = 80;
+ /**
+ * An array with the proportional widths of the cells in each row
+ */
+ private float[] proportionalWidths = null;
+ /**
+ * The cell padding
+ */
+ private float cellPadding = 0;
+ /**
+ * The cell spacing
+ */
+ private float cellSpacing = 0;
+ /**
+ * The border style of this RtfTable
+ */
+ private RtfBorderGroup borders = null;
+ /**
+ * The alignment of this RtfTable
+ */
+ private int alignment = Element.ALIGN_CENTER;
+ /**
+ * Whether the cells in this RtfTable must fit in a page
+ */
+ private boolean cellsFitToPage = false;
+ /**
+ * Whether the whole RtfTable must fit in a page
+ */
+ private boolean tableFitToPage = false;
+ /**
+ * The number of header rows in this RtfTable
+ */
+ private int headerRows = 0;
+
+ /**
+ * Constructs a RtfTable based on a Table for a RtfDocument.
+ *
+ * @param doc The RtfDocument this RtfTable belongs to
+ * @param table The Table that this RtfTable wraps
+ */
+ public RtfTable(RtfDocument doc, Table table) {
+ super(doc);
+ table.complete();
+ importTable(table);
+ }
+
+ /**
+ * Imports the rows and settings from the Table into this
+ * RtfTable.
+ *
+ * @param table The source Table
+ */
+ private void importTable(Table table) {
+ this.rows = new ArrayList();
+ this.tableWidthPercent = table.widthPercentage();
+ this.proportionalWidths = table.getProportionalWidths();
+ this.cellPadding = (float) (table.cellpadding() * TWIPS_FACTOR);
+ this.cellSpacing = (float) (table.cellspacing() * TWIPS_FACTOR);
+ this.borders = new RtfBorderGroup(this.document, RtfBorder.ROW_BORDER, table.border(), table.borderWidth(), table.borderColor());
+ this.alignment = table.alignment();
+
+ int i = 0;
+ Iterator rowIterator = table.iterator();
+ while(rowIterator.hasNext()) {
+ this.rows.add(new RtfRow(this.document, this, (Row) rowIterator.next(), i));
+ i++;
+ }
+ for(i = 0; i < this.rows.size(); i++) {
+ ((RtfRow) this.rows.get(i)).handleCellSpanning();
+ }
+ this.headerRows = table.lastHeaderRow();
+ this.cellsFitToPage = table.hasToFitPageCells();
+ this.tableFitToPage = table.hasToFitPageTable();
+ }
+
+ /**
+ * Writes the content of this RtfTable
+ *
+ * @return A byte array with the content of this RtfTable
+ */
+ public byte[] write() {
+ ByteArrayOutputStream result = new ByteArrayOutputStream();
+ try {
+ if(!inHeader) {
+ result.write(RtfParagraph.PARAGRAPH);
+ }
+
+ for(int i = 0; i < this.rows.size(); i++) {
+ result.write(((RtfElement) this.rows.get(i)).write());
+ }
+
+ result.write(RtfParagraph.PARAGRAPH_DEFAULTS);
+ } catch(IOException ioe) {
+ ioe.printStackTrace();
+ }
+ return result.toByteArray();
+ }
+
+ /**
+ * Gets the alignment of this RtfTable
+ *
+ * @return The alignment of this RtfTable.
+ */
+ protected int getAlignment() {
+ return alignment;
+ }
+
+ /**
+ * Gets the borders of this RtfTable
+ *
+ * @return The borders of this RtfTable.
+ */
+ protected RtfBorderGroup getBorders() {
+ return this.borders;
+ }
+
+ /**
+ * Gets the cell padding of this RtfTable
+ *
+ * @return The cell padding of this RtfTable.
+ */
+ protected float getCellPadding() {
+ return cellPadding;
+ }
+
+ /**
+ * Gets the cell spacing of this RtfTable
+ *
+ * @return The cell spacing of this RtfTable.
+ */
+ protected float getCellSpacing() {
+ return cellSpacing;
+ }
+
+ /**
+ * Gets the proportional cell widths of this RtfTable
+ *
+ * @return The proportional widths of this RtfTable.
+ */
+ protected float[] getProportionalWidths() {
+ return (float[]) proportionalWidths.clone();
+ }
+
+ /**
+ * Gets the percentage of the page width this RtfTable covers
+ *
+ * @return The percentage of the page width.
+ */
+ protected float getTableWidthPercent() {
+ return tableWidthPercent;
+ }
+
+ /**
+ * Gets the rows of this RtfTable
+ *
+ * @return The rows of this RtfTable
+ */
+ protected ArrayList getRows() {
+ return this.rows;
+ }
+
+ /**
+ * Gets the cellsFitToPage setting of this RtfTable.
+ *
+ * @return The cellsFitToPage setting of this RtfTable.
+ */
+ protected boolean getCellsFitToPage() {
+ return this.cellsFitToPage;
+ }
+
+ /**
+ * Gets the tableFitToPage setting of this RtfTable.
+ *
+ * @return The tableFitToPage setting of this RtfTable.
+ */
+ protected boolean getTableFitToPage() {
+ return this.tableFitToPage;
+ }
+
+ /**
+ * Gets the number of header rows of this RtfTable
+ *
+ * @return The number of header rows
+ */
+ protected int getHeaderRows() {
+ return this.headerRows;
+ }
+}
diff --git a/src/main/java/com/lowagie/text/rtf/text/RtfAnnotation.java b/src/main/java/com/lowagie/text/rtf/text/RtfAnnotation.java new file mode 100644 index 0000000..f7c02c2 --- /dev/null +++ b/src/main/java/com/lowagie/text/rtf/text/RtfAnnotation.java @@ -0,0 +1,133 @@ +/*
+ * $Id: RtfAnnotation.java,v 1.16 2005/05/04 14:33:46 blowagie Exp $
+ * $Name: $
+ *
+ * Copyright 2001, 2002, 2003, 2004 by Mark Hall
+ *
+ * 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.rtf.text;
+
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+
+import com.lowagie.text.Annotation;
+import com.lowagie.text.rtf.RtfElement;
+import com.lowagie.text.rtf.document.RtfDocument;
+
+
+/**
+ * The RtfAnnotation provides support for adding Annotations to the rtf document.
+ * Only simple Annotations with Title / Content are supported.
+ *
+ * @version $Version:$
+ * @author Mark Hall (mhall@edu.uni-klu.ac.at)
+ */
+public class RtfAnnotation extends RtfElement {
+
+ /**
+ * Constant for the id of the annotation
+ */
+ private static final byte[] ANNOTATION_ID = "\\*\\atnid".getBytes();
+ /**
+ * Constant for the author of the annotation
+ */
+ private static final byte[] ANNOTATION_AUTHOR = "\\*\\atnauthor".getBytes();
+ /**
+ * Constant for the actual annotation
+ */
+ private static final byte[] ANNOTATION = "\\*\\annotation".getBytes();
+
+ /**
+ * The title of this RtfAnnotation
+ */
+ private String title = "";
+ /**
+ * The content of this RtfAnnotation
+ */
+ private String content = "";
+
+ /**
+ * Constructs a RtfAnnotation based on an Annotation.
+ *
+ * @param doc The RtfDocument this RtfAnnotation belongs to
+ * @param annotation The Annotation this RtfAnnotation is based off
+ */
+ public RtfAnnotation(RtfDocument doc, Annotation annotation) {
+ super(doc);
+ title = annotation.title();
+ content = annotation.content();
+ }
+
+ /**
+ * Writes the content of the RtfAnnotation
+ *
+ * @return The content of this RtfAnnotation
+ */
+ public byte[] write() {
+ ByteArrayOutputStream result = new ByteArrayOutputStream();
+ try {
+ result.write(OPEN_GROUP);
+ result.write(ANNOTATION_ID);
+ result.write(DELIMITER);
+ result.write(intToByteArray(document.getRandomInt()));
+ result.write(CLOSE_GROUP);
+ result.write(OPEN_GROUP);
+ result.write(ANNOTATION_AUTHOR);
+ result.write(DELIMITER);
+ result.write(title.getBytes());
+ result.write(CLOSE_GROUP);
+ result.write(OPEN_GROUP);
+ result.write(ANNOTATION);
+ result.write(RtfParagraph.PARAGRAPH_DEFAULTS);
+ result.write(DELIMITER);
+ result.write(content.getBytes());
+ result.write(CLOSE_GROUP);
+ } catch(IOException ioe) {
+ ioe.printStackTrace();
+ }
+ return result.toByteArray();
+ }
+}
diff --git a/src/main/java/com/lowagie/text/rtf/text/RtfChapter.java b/src/main/java/com/lowagie/text/rtf/text/RtfChapter.java new file mode 100644 index 0000000..df176ca --- /dev/null +++ b/src/main/java/com/lowagie/text/rtf/text/RtfChapter.java @@ -0,0 +1,105 @@ +/*
+ * $Id: RtfChapter.java,v 1.18 2005/09/11 20:17:41 hallm Exp $
+ * $Name: $
+ *
+ * Copyright 2001, 2002 by Mark Hall
+ *
+ * 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.rtf.text;
+
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+
+import com.lowagie.text.Chapter;
+import com.lowagie.text.rtf.RtfBasicElement;
+import com.lowagie.text.rtf.document.RtfDocument;
+
+
+/**
+ * The RtfChapter wraps a Chapter element.
+ * INTERNAL CLASS
+ *
+ * @version $Revision: 1.18 $
+ * @author Mark Hall (mhall@edu.uni-klu.ac.at)
+ */
+public class RtfChapter extends RtfSection {
+
+ /**
+ * Constructs a RtfChapter for a given Chapter
+ *
+ * @param doc The RtfDocument this RtfChapter belongs to
+ * @param chapter The Chapter this RtfChapter is based on
+ */
+ public RtfChapter(RtfDocument doc, Chapter chapter) {
+ super(doc, chapter);
+ }
+
+ /**
+ * Writes the RtfChapter and its contents
+ *
+ * @return A byte array containing the RtfChapter and its contents
+ */
+ public byte[] write() {
+ ByteArrayOutputStream result = new ByteArrayOutputStream();
+ try {
+ if(this.document.getLastElementWritten() != null && !(this.document.getLastElementWritten() instanceof RtfChapter)) {
+ result.write("\\page".getBytes());
+ }
+ result.write("\\sectd".getBytes());
+ result.write(document.getDocumentHeader().writeSectionDefinition());
+ if(this.title != null) {
+ result.write(this.title.write());
+ }
+ for(int i = 0; i < items.size(); i++) {
+ result.write(((RtfBasicElement) items.get(i)).write());
+ }
+ result.write("\\sect".getBytes());
+ } catch(IOException ioe) {
+ ioe.printStackTrace();
+ }
+ return result.toByteArray();
+ }
+}
diff --git a/src/main/java/com/lowagie/text/rtf/text/RtfChunk.java b/src/main/java/com/lowagie/text/rtf/text/RtfChunk.java new file mode 100644 index 0000000..7368c48 --- /dev/null +++ b/src/main/java/com/lowagie/text/rtf/text/RtfChunk.java @@ -0,0 +1,202 @@ +/*
+ * $Id: RtfChunk.java,v 1.12 2005/07/23 10:57:32 hallm Exp $
+ * $Name: $
+ *
+ * Copyright 2001, 2002, 2003, 2004 by Mark Hall
+ *
+ * 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.rtf.text;
+
+import java.awt.Color;
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+
+import com.lowagie.text.Chunk;
+import com.lowagie.text.rtf.RtfElement;
+import com.lowagie.text.rtf.document.RtfDocument;
+import com.lowagie.text.rtf.style.RtfColor;
+import com.lowagie.text.rtf.style.RtfFont;
+
+
+/**
+ * The RtfChunk contains one piece of text. The smallest text element available
+ * in iText.
+ *
+ * @version $Version:$
+ * @author Mark Hall (mhall@edu.uni-klu.ac.at)
+ */
+public class RtfChunk extends RtfElement {
+
+ /**
+ * Constant for the subscript flag
+ */
+ private static final byte[] FONT_SUBSCRIPT = "\\sub".getBytes();
+ /**
+ * Constant for the superscript flag
+ */
+ private static final byte[] FONT_SUPERSCRIPT = "\\super".getBytes();
+ /**
+ * Constant for the end of sub / superscript flag
+ */
+ private static final byte[] FONT_END_SUPER_SUBSCRIPT = "\\nosupersub".getBytes();
+ /**
+ * Constant for background colour.
+ */
+ private static final byte[] HIGHLIGHT = "\\highlight".getBytes();
+
+ /**
+ * The font of this RtfChunk
+ */
+ private RtfFont font = null;
+ /**
+ * The actual content of this RtfChunk
+ */
+ private String content = "";
+ /**
+ * Whether to use soft line breaks instead of hard ones.
+ */
+ private boolean softLineBreaks = false;
+ /**
+ * The super / subscript of this RtfChunk
+ */
+ private float superSubScript = 0;
+ /**
+ * An optional background colour.
+ */
+ private RtfColor background = null;
+
+ /**
+ * Constructs a RtfChunk based on the content of a Chunk
+ *
+ * @param doc The RtfDocument that this Chunk belongs to
+ * @param chunk The Chunk that this RtfChunk is based on
+ */
+ public RtfChunk(RtfDocument doc, Chunk chunk) {
+ super(doc);
+
+ if(chunk == null) {
+ return;
+ }
+
+ if(chunk.getAttributes() != null && chunk.getAttributes().get(Chunk.SUBSUPSCRIPT) != null) {
+ this.superSubScript = ((Float)chunk.getAttributes().get(Chunk.SUBSUPSCRIPT)).floatValue();
+ }
+ if(chunk.getAttributes() != null && chunk.getAttributes().get(Chunk.BACKGROUND) != null) {
+ this.background = new RtfColor(this.document, (Color) ((Object[]) chunk.getAttributes().get(Chunk.BACKGROUND))[0]);
+ }
+ font = new RtfFont(doc, chunk.font());
+ content = chunk.content();
+ }
+
+ /**
+ * Writes the content of this RtfChunk. First the font information
+ * is written, then the content, and then more font information
+ *
+ * @return A byte array with the content of this RtfChunk
+ */
+ public byte[] write() {
+ ByteArrayOutputStream result = new ByteArrayOutputStream();
+ try {
+ if(this.background != null) {
+ result.write(OPEN_GROUP);
+ }
+
+ result.write(font.writeBegin());
+ if(superSubScript < 0) {
+ result.write(FONT_SUBSCRIPT);
+ } else if(superSubScript > 0) {
+ result.write(FONT_SUPERSCRIPT);
+ }
+ if(this.background != null) {
+ result.write(HIGHLIGHT);
+ result.write(intToByteArray(this.background.getColorNumber()));
+ }
+ result.write(DELIMITER);
+
+ result.write(document.filterSpecialChar(content, false, softLineBreaks || this.document.getDocumentSettings().isAlwaysGenerateSoftLinebreaks()).getBytes());
+
+ if(superSubScript != 0) {
+ result.write(FONT_END_SUPER_SUBSCRIPT);
+ }
+ result.write(font.writeEnd());
+
+ if(this.background != null) {
+ result.write(CLOSE_GROUP);
+ }
+ } catch(IOException ioe) {
+ ioe.printStackTrace();
+ }
+ return result.toByteArray();
+ }
+
+ /**
+ * Sets the RtfDocument this RtfChunk belongs to.
+ *
+ * @param doc The RtfDocument to use
+ */
+ public void setRtfDocument(RtfDocument doc) {
+ super.setRtfDocument(doc);
+ this.font.setRtfDocument(this.document);
+ }
+
+ /**
+ * Sets whether to use soft line breaks instead of default hard ones.
+ *
+ * @param softLineBreaks whether to use soft line breaks instead of default hard ones.
+ */
+ public void setSoftLineBreaks(boolean softLineBreaks) {
+ this.softLineBreaks = softLineBreaks;
+ }
+
+ /**
+ * Gets whether to use soft line breaks instead of default hard ones.
+ *
+ * @return whether to use soft line breaks instead of default hard ones.
+ */
+ public boolean getSoftLineBreaks() {
+ return this.softLineBreaks;
+ }
+}
diff --git a/src/main/java/com/lowagie/text/rtf/text/RtfNewPage.java b/src/main/java/com/lowagie/text/rtf/text/RtfNewPage.java new file mode 100644 index 0000000..3bb7a88 --- /dev/null +++ b/src/main/java/com/lowagie/text/rtf/text/RtfNewPage.java @@ -0,0 +1,53 @@ +/*
+ * Created on Aug 12, 2004
+ *
+ * To change the template for this generated file go to
+ * Window - Preferences - Java - Code Generation - Code and Comments
+ */
+package com.lowagie.text.rtf.text;
+
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+
+import com.lowagie.text.rtf.RtfElement;
+import com.lowagie.text.rtf.document.RtfDocument;
+
+
+/**
+ * The RtfNewPage creates a new page. INTERNAL CLASS
+ *
+ * @version $Version:$
+ * @author Mark Hall (mhall@edu.uni-klu.ac.at)
+ */
+public class RtfNewPage extends RtfElement {
+
+ /**
+ * Constant for a new page
+ */
+ private static final byte[] NEW_PAGE = "\\page".getBytes();
+
+ /**
+ * Constructs a RtfNewPage
+ *
+ * @param doc The RtfDocument this RtfNewPage belongs to
+ */
+ public RtfNewPage(RtfDocument doc) {
+ super(doc);
+ }
+
+ /**
+ * Writes a new page
+ *
+ * @return A byte array with the new page set
+ */
+ public byte[] write() {
+ ByteArrayOutputStream result = new ByteArrayOutputStream();
+ try {
+ result.write(NEW_PAGE);
+ result.write(RtfParagraph.PARAGRAPH_DEFAULTS);
+ } catch(IOException ioe) {
+ ioe.printStackTrace();
+ }
+ return result.toByteArray();
+ }
+}
diff --git a/src/main/java/com/lowagie/text/rtf/text/RtfParagraph.java b/src/main/java/com/lowagie/text/rtf/text/RtfParagraph.java new file mode 100644 index 0000000..c600069 --- /dev/null +++ b/src/main/java/com/lowagie/text/rtf/text/RtfParagraph.java @@ -0,0 +1,211 @@ +/*
+ * $Id: RtfParagraph.java,v 1.20 2005/12/24 13:12:43 hallm Exp $
+ * $Name: $
+ *
+ * Copyright 2001, 2002, 2003, 2004 by Mark Hall
+ *
+ * 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.rtf.text;
+
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+
+import com.lowagie.text.Chunk;
+import com.lowagie.text.DocumentException;
+import com.lowagie.text.Element;
+import com.lowagie.text.Paragraph;
+import com.lowagie.text.rtf.RtfBasicElement;
+import com.lowagie.text.rtf.RtfElement;
+import com.lowagie.text.rtf.document.RtfDocument;
+import com.lowagie.text.rtf.graphic.RtfImage;
+import com.lowagie.text.rtf.style.RtfFont;
+import com.lowagie.text.rtf.style.RtfParagraphStyle;
+
+
+/**
+ * The RtfParagraph is an extension of the RtfPhrase that adds alignment and
+ * indentation properties. It wraps a Paragraph.
+ *
+ * @version $Revision: 1.20 $
+ * @author Mark Hall (mhall@edu.uni-klu.ac.at)
+ */
+public class RtfParagraph extends RtfPhrase {
+
+ /**
+ * Constant for the end of a paragraph
+ */
+ public static final byte[] PARAGRAPH = "\\par".getBytes();
+
+ /**
+ * An optional RtfParagraphStyle to use for styling.
+ */
+ private RtfParagraphStyle paragraphStyle = null;
+
+ /**
+ * Constructs a RtfParagraph belonging to a RtfDocument based on a Paragraph.
+ *
+ * @param doc The RtfDocument this RtfParagraph belongs to
+ * @param paragraph The Paragraph that this RtfParagraph is based on
+ */
+ public RtfParagraph(RtfDocument doc, Paragraph paragraph) {
+ super(doc);
+
+ RtfFont baseFont = null;
+ if(paragraph.font() instanceof RtfParagraphStyle) {
+ this.paragraphStyle = this.document.getDocumentHeader().getRtfParagraphStyle(((RtfParagraphStyle) paragraph.font()).getStyleName());
+ baseFont = this.paragraphStyle;
+ } else {
+ baseFont = new RtfFont(this.document, paragraph.font());
+ this.paragraphStyle = new RtfParagraphStyle(this.document, this.document.getDocumentHeader().getRtfParagraphStyle("Normal"));
+ this.paragraphStyle.setAlignment(paragraph.alignment());
+ this.paragraphStyle.setIndentLeft((int) (paragraph.indentationLeft() * RtfElement.TWIPS_FACTOR));
+ this.paragraphStyle.setIndentRight((int) (paragraph.indentationRight() * RtfElement.TWIPS_FACTOR));
+ this.paragraphStyle.setSpacingBefore((int) (paragraph.spacingBefore() * RtfElement.TWIPS_FACTOR));
+ this.paragraphStyle.setSpacingAfter((int) (paragraph.spacingAfter() * RtfElement.TWIPS_FACTOR));
+ if(paragraph.leadingDefined()) {
+ this.paragraphStyle.setLineLeading((int) (paragraph.leading() * RtfElement.TWIPS_FACTOR));
+ }
+ this.paragraphStyle.setKeepTogether(paragraph.getKeepTogether());
+ }
+
+ for(int i = 0; i < paragraph.size(); i++) {
+ Element chunk = (Element) paragraph.get(i);
+ if(chunk instanceof Chunk) {
+ ((Chunk) chunk).setFont(baseFont.difference(((Chunk) chunk).font()));
+ } else if(chunk instanceof RtfImage) {
+ ((RtfImage) chunks.get(i)).setAlignment(this.paragraphStyle.getAlignment());
+ }
+ try {
+ chunks.add(doc.getMapper().mapElement(chunk));
+ } catch(DocumentException de) {
+ }
+ }
+ }
+
+ /**
+ * Set whether this RtfParagraph must stay on the same page as the next one.
+ *
+ * @param keepTogetherWithNext Whether this RtfParagraph must keep together with the next.
+ */
+ public void setKeepTogetherWithNext(boolean keepTogetherWithNext) {
+ this.paragraphStyle.setKeepTogetherWithNext(keepTogetherWithNext);
+ }
+
+ /**
+ * Writes the content of this RtfParagraph. First paragraph specific data is written
+ * and then the RtfChunks of this RtfParagraph are added.
+ *
+ * @return The content of this RtfParagraph
+ */
+ public byte[] write() {
+ ByteArrayOutputStream result = new ByteArrayOutputStream();
+ try {
+ result.write(PARAGRAPH_DEFAULTS);
+
+ if(inTable) {
+ result.write(IN_TABLE);
+ }
+
+ if(this.paragraphStyle != null) {
+ result.write(this.paragraphStyle.writeBegin());
+ }
+
+ for(int i = 0; i < chunks.size(); i++) {
+ result.write(((RtfBasicElement) chunks.get(i)).write());
+ }
+
+ if(this.paragraphStyle != null) {
+ result.write(this.paragraphStyle.writeEnd());
+ }
+
+ if(!inTable) {
+ result.write(PARAGRAPH);
+ }
+ if(this.document.getDocumentSettings().isOutputDebugLineBreaks()) {
+ result.write('\n');
+ }
+ } catch(IOException ioe) {
+ ioe.printStackTrace();
+ }
+ return result.toByteArray();
+ }
+
+ /**
+ * Gets the left indentation of this RtfParagraph.
+ *
+ * @return The left indentation.
+ */
+ public int getIndentLeft() {
+ return this.paragraphStyle.getIndentLeft();
+ }
+
+ /**
+ * Sets the left indentation of this RtfParagraph.
+ *
+ * @param indentLeft The left indentation to use.
+ */
+ public void setIndentLeft(int indentLeft) {
+ this.paragraphStyle.setIndentLeft(indentLeft);
+ }
+
+ /**
+ * Gets the right indentation of this RtfParagraph.
+ *
+ * @return The right indentation.
+ */
+ public int getIndentRight() {
+ return this.paragraphStyle.getIndentRight();
+ }
+
+ /**
+ * Sets the right indentation of this RtfParagraph.
+ *
+ * @param indentRight The right indentation to use.
+ */
+ public void setIndentRight(int indentRight) {
+ this.paragraphStyle.setIndentRight(indentRight);
+ }
+}
diff --git a/src/main/java/com/lowagie/text/rtf/text/RtfPhrase.java b/src/main/java/com/lowagie/text/rtf/text/RtfPhrase.java new file mode 100644 index 0000000..f5d79a9 --- /dev/null +++ b/src/main/java/com/lowagie/text/rtf/text/RtfPhrase.java @@ -0,0 +1,203 @@ +/*
+ * $Id: RtfPhrase.java,v 1.14 2006/02/09 17:13:35 hallm Exp $
+ * $Name: $
+ *
+ * Copyright 2001, 2002, 2003, 2004 by Mark Hall
+ *
+ * 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.rtf.text;
+
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.util.ArrayList;
+
+import com.lowagie.text.Chunk;
+import com.lowagie.text.DocumentException;
+import com.lowagie.text.Element;
+import com.lowagie.text.Phrase;
+import com.lowagie.text.rtf.RtfBasicElement;
+import com.lowagie.text.rtf.RtfElement;
+import com.lowagie.text.rtf.document.RtfDocument;
+import com.lowagie.text.rtf.style.RtfFont;
+
+
+/**
+ * The RtfPhrase contains multiple RtfChunks
+ *
+ * @version $Id: RtfPhrase.java,v 1.14 2006/02/09 17:13:35 hallm Exp $
+ * @author Mark Hall (mhall@edu.uni-klu.ac.at)
+ */
+public class RtfPhrase extends RtfElement {
+
+ /**
+ * Constant for the resetting of the paragraph defaults
+ */
+ public static final byte[] PARAGRAPH_DEFAULTS = "\\pard".getBytes();
+ /**
+ * Constant for phrase in a table indication
+ */
+ public static final byte[] IN_TABLE = "\\intbl".getBytes();
+ /**
+ * Constant for the line spacing.
+ */
+ public static final byte[] LINE_SPACING = "\\sl".getBytes();
+
+ /**
+ * ArrayList containing the RtfChunks of this RtfPhrase
+ */
+ protected ArrayList chunks = new ArrayList();
+ /**
+ * The height of each line.
+ */
+ private int lineLeading = 0;
+
+ /**
+ * A basically empty constructor that is used by the RtfParagraph.
+ *
+ * @param doc The RtfDocument this RtfPhrase belongs to.
+ */
+ protected RtfPhrase(RtfDocument doc) {
+ super(doc);
+ }
+
+ /**
+ * Constructs a new RtfPhrase for the RtfDocument with the given Phrase
+ *
+ * @param doc The RtfDocument this RtfPhrase belongs to
+ * @param phrase The Phrase this RtfPhrase is based on
+ */
+ public RtfPhrase(RtfDocument doc, Phrase phrase) {
+ super(doc);
+
+ if(phrase == null) {
+ return;
+ }
+
+ if(phrase.leadingDefined()) {
+ this.lineLeading = (int) (phrase.leading() * RtfElement.TWIPS_FACTOR);
+ } else {
+ this.lineLeading = 0;
+ }
+
+ RtfFont phraseFont = new RtfFont(null, phrase.font());
+ for(int i = 0; i < phrase.size(); i++) {
+ Element chunk = (Element) phrase.get(i);
+ if(chunk instanceof Chunk) {
+ ((Chunk) chunk).setFont(phraseFont.difference(((Chunk) chunk).font()));
+ }
+ try {
+ chunks.add(doc.getMapper().mapElement(chunk));
+ } catch(DocumentException de) {
+ }
+ }
+ }
+
+ /**
+ * Write the content of this RtfPhrase. First resets to the paragraph defaults
+ * then if the RtfPhrase is in a RtfCell a marker for this is written and finally
+ * the RtfChunks of this RtfPhrase are written.
+ *
+ * @return The content of this RtfPhrase
+ */
+ public byte[] write() {
+ ByteArrayOutputStream result = new ByteArrayOutputStream();
+ try {
+ result.write(PARAGRAPH_DEFAULTS);
+ if(inTable) {
+ result.write(IN_TABLE);
+ }
+ if(this.lineLeading > 0) {
+ result.write(LINE_SPACING);
+ result.write(intToByteArray(this.lineLeading));
+ }
+ for(int i = 0; i < chunks.size(); i++) {
+ result.write(((RtfBasicElement) chunks.get(i)).write());
+ }
+ } catch(IOException ioe) {
+ ioe.printStackTrace();
+ }
+ return result.toByteArray();
+ }
+
+ /**
+ * Sets whether this RtfPhrase is in a table. Sets the correct inTable setting for all
+ * child elements.
+ *
+ * @param inTable <code>True</code> if this RtfPhrase is in a table, <code>false</code> otherwise
+ */
+ public void setInTable(boolean inTable) {
+ super.setInTable(inTable);
+ for(int i = 0; i < this.chunks.size(); i++) {
+ ((RtfBasicElement) this.chunks.get(i)).setInTable(inTable);
+ }
+ }
+
+ /**
+ * Sets whether this RtfPhrase is in a header. Sets the correct inTable setting for all
+ * child elements.
+ *
+ * @param inHeader <code>True</code> if this RtfPhrase is in a header, <code>false</code> otherwise
+ */
+ public void setInHeader(boolean inHeader) {
+ super.setInHeader(inHeader);
+ for(int i = 0; i < this.chunks.size(); i++) {
+ ((RtfBasicElement) this.chunks.get(i)).setInHeader(inHeader);
+ }
+ }
+
+ /**
+ * Sets the RtfDocument this RtfPhrase belongs to. Also sets the RtfDocument for all child
+ * elements.
+ *
+ * @param doc The RtfDocument to use
+ */
+ public void setRtfDocument(RtfDocument doc) {
+ super.setRtfDocument(doc);
+ for(int i = 0; i < this.chunks.size(); i++) {
+ ((RtfBasicElement) this.chunks.get(i)).setRtfDocument(this.document);
+ }
+ }
+}
diff --git a/src/main/java/com/lowagie/text/rtf/text/RtfSection.java b/src/main/java/com/lowagie/text/rtf/text/RtfSection.java new file mode 100644 index 0000000..2b5ad86 --- /dev/null +++ b/src/main/java/com/lowagie/text/rtf/text/RtfSection.java @@ -0,0 +1,201 @@ +/*
+ * $Id: RtfSection.java,v 1.11 2005/08/19 21:17:04 hallm Exp $
+ * $Name: $
+ *
+ * Copyright 2001, 2002, 2003, 2004 by Mark Hall
+ *
+ * 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.rtf.text;
+
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.util.Iterator;
+import java.util.ArrayList;
+
+import com.lowagie.text.Chunk;
+import com.lowagie.text.DocumentException;
+import com.lowagie.text.Element;
+import com.lowagie.text.Section;
+import com.lowagie.text.rtf.RtfBasicElement;
+import com.lowagie.text.rtf.RtfElement;
+import com.lowagie.text.rtf.document.RtfDocument;
+import com.lowagie.text.rtf.field.RtfTOCEntry;
+
+
+/**
+ * The RtfSection wraps a Section element.
+ * INTERNAL CLASS
+ *
+ * @version $Revision: 1.11 $
+ * @author Mark Hall (mhall@edu.uni-klu.ac.at)
+ */
+public class RtfSection extends RtfElement {
+
+ /**
+ * The title paragraph of this RtfSection
+ */
+ protected RtfParagraph title = null;
+ /**
+ * The sub-items of this RtfSection
+ */
+ protected ArrayList items = null;
+
+ /**
+ * Constructs a RtfSection for a given Section. If the autogenerateTOCEntries
+ * property of the RtfDocument is set and the title is not empty then a TOC entry
+ * is generated for the title.
+ *
+ * @param doc The RtfDocument this RtfSection belongs to
+ * @param section The Section this RtfSection is based on
+ */
+ public RtfSection(RtfDocument doc, Section section) {
+ super(doc);
+ items = new ArrayList();
+ try {
+ if(section.title() != null) {
+ this.title = (RtfParagraph) doc.getMapper().mapElement(section.title());
+ }
+ if(document.getAutogenerateTOCEntries()) {
+ StringBuffer titleText = new StringBuffer();
+ Iterator it = section.title().iterator();
+ while(it.hasNext()) {
+ Element element = (Element) it.next();
+ if(element.type() == Element.CHUNK) {
+ titleText.append(((Chunk) element).content());
+ }
+ }
+ if(titleText.toString().trim().length() > 0) {
+ RtfTOCEntry tocEntry = new RtfTOCEntry(titleText.toString(), section.title().font());
+ tocEntry.setRtfDocument(this.document);
+ this.items.add(tocEntry);
+ }
+ }
+ Iterator iterator = section.iterator();
+ while(iterator.hasNext()) {
+ Element element = (Element) iterator.next();
+ RtfBasicElement rtfElement = doc.getMapper().mapElement(element);
+ if(rtfElement != null) {
+ items.add(rtfElement);
+ }
+ }
+
+ updateIndentation(section.indentationLeft(), section.indentationRight(), section.indentation());
+ } catch(DocumentException de) {
+ de.printStackTrace();
+ }
+ }
+
+ /**
+ * Write this RtfSection and its contents
+ *
+ * @return A byte array with the RtfSection and its contents
+ */
+ public byte[] write() {
+ ByteArrayOutputStream result = new ByteArrayOutputStream();
+ try {
+ result.write(RtfParagraph.PARAGRAPH);
+ if(this.title != null) {
+ result.write(this.title.write());
+ }
+ for(int i = 0; i < items.size(); i++) {
+ result.write(((RtfBasicElement) items.get(i)).write());
+ }
+ } catch(IOException ioe) {
+ ioe.printStackTrace();
+ }
+ return result.toByteArray();
+ }
+
+ /**
+ * Sets whether this RtfSection is in a table. Sets the correct inTable setting for all
+ * child elements.
+ *
+ * @param inTable <code>True</code> if this RtfSection is in a table, <code>false</code> otherwise
+ */
+ public void setInTable(boolean inTable) {
+ super.setInTable(inTable);
+ for(int i = 0; i < this.items.size(); i++) {
+ ((RtfBasicElement) this.items.get(i)).setInTable(inTable);
+ }
+ }
+
+ /**
+ * Sets whether this RtfSection is in a header. Sets the correct inTable setting for all
+ * child elements.
+ *
+ * @param inHeader <code>True</code> if this RtfSection is in a header, <code>false</code> otherwise
+ */
+ public void setInHeader(boolean inHeader) {
+ super.setInHeader(inHeader);
+ for(int i = 0; i < this.items.size(); i++) {
+ ((RtfBasicElement) this.items.get(i)).setInHeader(inHeader);
+ }
+ }
+
+ /**
+ * Updates the left, right and content indentation of all RtfParagraph and RtfSection
+ * elements that this RtfSection contains.
+ *
+ * @param indentLeft The left indentation to add.
+ * @param indentRight The right indentation to add.
+ * @param indentContent The content indentation to add.
+ */
+ private void updateIndentation(float indentLeft, float indentRight, float indentContent) {
+ if(this.title != null) {
+ this.title.setIndentLeft((int) (this.title.getIndentLeft() + indentLeft * RtfElement.TWIPS_FACTOR));
+ this.title.setIndentRight((int) (this.title.getIndentRight() + indentRight * RtfElement.TWIPS_FACTOR));
+ }
+ for(int i = 0; i < this.items.size(); i++) {
+ RtfBasicElement rtfElement = (RtfBasicElement) this.items.get(i);
+ if(rtfElement instanceof RtfSection) {
+ ((RtfSection) rtfElement).updateIndentation(indentLeft + indentContent, indentRight, 0);
+ } else if(rtfElement instanceof RtfParagraph) {
+ ((RtfParagraph) rtfElement).setIndentLeft((int) (((RtfParagraph) rtfElement).getIndentLeft() + (indentLeft + indentContent) * RtfElement.TWIPS_FACTOR));
+ ((RtfParagraph) rtfElement).setIndentRight((int) (((RtfParagraph) rtfElement).getIndentRight() + indentRight * RtfElement.TWIPS_FACTOR));
+ }
+ }
+ }
+}
diff --git a/src/main/java/com/lowagie/text/rtf/text/RtfTab.java b/src/main/java/com/lowagie/text/rtf/text/RtfTab.java new file mode 100644 index 0000000..1041ae6 --- /dev/null +++ b/src/main/java/com/lowagie/text/rtf/text/RtfTab.java @@ -0,0 +1,140 @@ +/*
+ * $Id: RtfTab.java,v 1.1 2006/06/17 09:51:30 hallm Exp $
+ * $Name: $
+ *
+ * Copyright 2001, 2002, 2003, 2004 by Mark Hall
+ *
+ * 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.
+ * Co-Developer of the code is Mark Hall. Portions created by the Co-Developer are
+ * Copyright (C) 2006 by Mark Hall. 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.rtf.text;
+
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+
+import com.lowagie.text.rtf.RtfAddableElement;
+
+/**
+ * The RtfTab encapsulates a tab position and tab type in a paragraph.
+ * To add tabs to a paragraph construct new RtfTab objects with the desired
+ * tab position and alignment and then add them to the paragraph. In the actual
+ * text the tabs are then defined as standard \t characters.<br /><br />
+ *
+ * <code>RtfTab tab = new RtfTab(300, RtfTab.TAB_LEFT_ALIGN);<br />
+ * Paragraph para = new Paragraph();<br />
+ * para.add(tab);<br />
+ * para.add("This paragraph has a\ttab defined.");</code>
+ *
+ * @version $Revision: 1.1 $
+ * @author Mark Hall (mhall@edu.uni-klu.ac.at)
+ */
+public class RtfTab extends RtfAddableElement {
+
+ /**
+ * A tab where the text is left aligned.
+ */
+ public static final int TAB_LEFT_ALIGN = 0;
+ /**
+ * A tab where the text is centre aligned.
+ */
+ public static final int TAB_CENTER_ALIGN = 1;
+ /**
+ * A tab where the text is right aligned.
+ */
+ public static final int TAB_RIGHT_ALIGN = 2;
+ /**
+ * A tab where the text is aligned on the decimal character. Which
+ * character that is depends on the language settings of the viewer.
+ */
+ public static final int TAB_DECIMAL_ALIGN = 3;
+
+ /**
+ * The tab position in twips.
+ */
+ private int position = 0;
+ /**
+ * The tab alignment.
+ */
+ private int type = TAB_LEFT_ALIGN;
+
+ /**
+ * Constructs a new RtfTab with the given position and type. The position
+ * is in standard iText points. The type is one of the tab alignment
+ * constants defined in the RtfTab.
+ *
+ * @param position The position of the tab in points.
+ * @param type The tab type constant.
+ */
+ public RtfTab(float position, int type) {
+ this.position = (int) Math.round(position * TWIPS_FACTOR);
+ switch(type) {
+ case TAB_LEFT_ALIGN: this.type = TAB_LEFT_ALIGN; break;
+ case TAB_CENTER_ALIGN: this.type = TAB_CENTER_ALIGN; break;
+ case TAB_RIGHT_ALIGN: this.type = TAB_RIGHT_ALIGN; break;
+ case TAB_DECIMAL_ALIGN: this.type = TAB_DECIMAL_ALIGN; break;
+ default: this.type = TAB_LEFT_ALIGN; break;
+ }
+ }
+
+ /**
+ * Writes the tab settings.
+ */
+ public byte[] write() {
+ ByteArrayOutputStream result = new ByteArrayOutputStream();
+ try {
+ switch(this.type) {
+ case TAB_CENTER_ALIGN: result.write("\\tqc".getBytes()); break;
+ case TAB_RIGHT_ALIGN: result.write("\\tqr".getBytes()); break;
+ case TAB_DECIMAL_ALIGN: result.write("\\tqdec".getBytes()); break;
+ }
+ result.write("\\tx".getBytes());
+ result.write(intToByteArray(this.position));
+ } catch(IOException ioe) {
+ ioe.printStackTrace();
+ }
+ return result.toByteArray();
+ }
+}
diff --git a/src/main/java/com/lowagie/text/rtf/text/RtfTabGroup.java b/src/main/java/com/lowagie/text/rtf/text/RtfTabGroup.java new file mode 100644 index 0000000..e298221 --- /dev/null +++ b/src/main/java/com/lowagie/text/rtf/text/RtfTabGroup.java @@ -0,0 +1,127 @@ +/*
+ * $Id: RtfTabGroup.java,v 1.1 2006/06/17 09:51:30 hallm Exp $
+ * $Name: $
+ *
+ * Copyright 2001, 2002, 2003, 2004 by Mark Hall
+ *
+ * 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.
+ * Co-Developer of the code is Mark Hall. Portions created by the Co-Developer are
+ * Copyright (C) 2006 by Mark Hall. 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.rtf.text;
+
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.util.ArrayList;
+
+import com.lowagie.text.rtf.RtfAddableElement;
+
+/**
+ * The RtfTabGroup is a convenience class if the same tabs are to be added
+ * to multiple paragraphs.<br /><br />
+ *
+ * <code>RtfTabGroup tabs = new RtfTabGroup();<br />
+ * tabs.add(new RtfTab(70, RtfTab.TAB_LEFT_ALIGN));<br />
+ * tabs.add(new RtfTab(160, RtfTab.TAB_CENTER_ALIGN));<br />
+ * tabs.add(new RtfTab(250, RtfTab.TAB_DECIMAL_ALIGN));<br />
+ * tabs.add(new RtfTab(500, RtfTab.TAB_RIGHT_ALIGN));<br />
+ * Paragraph para = new Paragraph();<br />
+ * para.add(tabs);<br />
+ * para.add("\tLeft aligned\tCentre aligned\t12,45\tRight aligned");</code>
+ *
+ * @version $Revision: 1.1 $
+ * @author Mark Hall (mhall@edu.uni-klu.ac.at)
+ */
+public class RtfTabGroup extends RtfAddableElement {
+ /**
+ * The tabs to add.
+ */
+ private ArrayList tabs = null;
+
+ /**
+ * Constructs an empty RtfTabGroup.
+ */
+ public RtfTabGroup() {
+ this.tabs = new ArrayList();
+ }
+
+ /**
+ * Constructs a RtfTabGroup with a set of tabs.
+ *
+ * @param tabs An ArrayList with the RtfTabs to group in this RtfTabGroup.
+ */
+ public RtfTabGroup(ArrayList tabs) {
+ this.tabs = new ArrayList();
+ for(int i = 0; i < tabs.size(); i++) {
+ if(tabs.get(i) instanceof RtfTab) {
+ this.tabs.add(tabs.get(i));
+ }
+ }
+ }
+
+ /**
+ * Adds a RtfTab to the list of grouped tabs.
+ *
+ * @param tab The RtfTab to add.
+ */
+ public void add(RtfTab tab) {
+ this.tabs.add(tab);
+ }
+
+ /**
+ * Combines the tab output form all grouped tabs.
+ */
+ public byte[] write() {
+ ByteArrayOutputStream result = new ByteArrayOutputStream();
+ try {
+ for(int i = 0; i < this.tabs.size(); i++) {
+ result.write(((RtfTab) this.tabs.get(i)).write());
+ }
+ } catch(IOException ioe) {
+ ioe.printStackTrace();
+ }
+ return result.toByteArray();
+ }
+}
|