simple/src/main/java/org/odftoolkit/simple/TextDocument.java

/************************************************************************
 *
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER
 * 
 * Copyright 2008, 2010 Oracle and/or its affiliates. All rights reserved.
 * 
 * Use is subject to license terms.
 * 
 * Licensed under the Apache License, Version 2.0 (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.apache.org/licenses/LICENSE-2.0. You can also
 * obtain a copy of the License at http://odftoolkit.org/docs/license.txt
 * 
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
 * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * 
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 ************************************************************************/
package org.odftoolkit.simple;

import java.awt.Rectangle;
import java.io.File;
import java.io.InputStream;
import java.text.DecimalFormat;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Set;
import java.util.logging.Level;
import java.util.logging.Logger;

import org.odftoolkit.odfdom.dom.OdfContentDom;
import org.odftoolkit.odfdom.dom.OdfDocumentNamespace;
import org.odftoolkit.odfdom.dom.attribute.text.TextAnchorTypeAttribute;
import org.odftoolkit.odfdom.dom.element.draw.DrawControlElement;
import org.odftoolkit.odfdom.dom.element.draw.DrawFrameElement;
import org.odftoolkit.odfdom.dom.element.office.OfficeDocumentStylesElement;
import org.odftoolkit.odfdom.dom.element.office.OfficeFormsElement;
import org.odftoolkit.odfdom.dom.element.office.OfficeMasterStylesElement;
import org.odftoolkit.odfdom.dom.element.office.OfficeTextElement;
import org.odftoolkit.odfdom.dom.element.style.StyleColumnsElement;
import org.odftoolkit.odfdom.dom.element.style.StyleFooterElement;
import org.odftoolkit.odfdom.dom.element.style.StyleHeaderElement;
import org.odftoolkit.odfdom.dom.element.style.StyleMasterPageElement;
import org.odftoolkit.odfdom.dom.element.style.StylePageLayoutPropertiesElement;
import org.odftoolkit.odfdom.dom.element.style.StyleSectionPropertiesElement;
import org.odftoolkit.odfdom.dom.element.table.TableTableElement;
import org.odftoolkit.odfdom.dom.element.text.TextIndexBodyElement;
import org.odftoolkit.odfdom.dom.element.text.TextIndexEntryLinkStartElement;
import org.odftoolkit.odfdom.dom.element.text.TextIndexEntryTabStopElement;
import org.odftoolkit.odfdom.dom.element.text.TextIndexSourceStylesElement;
import org.odftoolkit.odfdom.dom.element.text.TextIndexTitleElement;
import org.odftoolkit.odfdom.dom.element.text.TextIndexTitleTemplateElement;
import org.odftoolkit.odfdom.dom.element.text.TextPElement;
import org.odftoolkit.odfdom.dom.element.text.TextParagraphElementBase;
import org.odftoolkit.odfdom.dom.element.text.TextSectionElement;
import org.odftoolkit.odfdom.dom.element.text.TextSequenceDeclsElement;
import org.odftoolkit.odfdom.dom.element.text.TextTableOfContentElement;
import org.odftoolkit.odfdom.dom.element.text.TextTableOfContentEntryTemplateElement;
import org.odftoolkit.odfdom.dom.element.text.TextTableOfContentSourceElement;
import org.odftoolkit.odfdom.dom.element.text.TextTocMarkElement;
import org.odftoolkit.odfdom.dom.element.text.TextTocMarkStartElement;
import org.odftoolkit.odfdom.dom.style.OdfStyleFamily;
import org.odftoolkit.odfdom.incubator.doc.office.OdfOfficeAutomaticStyles;
import org.odftoolkit.odfdom.incubator.doc.office.OdfOfficeMasterStyles;
import org.odftoolkit.odfdom.incubator.doc.office.OdfOfficeStyles;
import org.odftoolkit.odfdom.incubator.doc.style.OdfStyle;
import org.odftoolkit.odfdom.incubator.doc.style.OdfStylePageLayout;
import org.odftoolkit.odfdom.incubator.doc.text.OdfTextParagraph;
import org.odftoolkit.odfdom.pkg.MediaType;
import org.odftoolkit.odfdom.pkg.OdfElement;
import org.odftoolkit.odfdom.pkg.OdfFileDom;
import org.odftoolkit.odfdom.pkg.OdfPackage;
import org.odftoolkit.odfdom.type.CellRangeAddressList;
import org.odftoolkit.odfdom.type.Length.Unit;
import org.odftoolkit.simple.chart.AbstractChartContainer;
import org.odftoolkit.simple.chart.Chart;
import org.odftoolkit.simple.chart.ChartContainer;
import org.odftoolkit.simple.chart.DataSet;
import org.odftoolkit.simple.common.field.AbstractVariableContainer;
import org.odftoolkit.simple.common.field.VariableContainer;
import org.odftoolkit.simple.common.field.VariableField;
import org.odftoolkit.simple.common.field.VariableField.VariableType;
import org.odftoolkit.simple.draw.Control;
import org.odftoolkit.simple.draw.ControlContainer;
import org.odftoolkit.simple.form.AbstractFormContainer;
import org.odftoolkit.simple.form.Form;
import org.odftoolkit.simple.form.FormContainer;
import org.odftoolkit.simple.style.MasterPage;
import org.odftoolkit.simple.style.TOCStyle;
import org.odftoolkit.simple.table.Table;
import org.odftoolkit.simple.text.AbstractParagraphContainer;
import org.odftoolkit.simple.text.Footer;
import org.odftoolkit.simple.text.Header;
import org.odftoolkit.simple.text.Paragraph;
import org.odftoolkit.simple.text.ParagraphContainer;
import org.odftoolkit.simple.text.Section;
import org.odftoolkit.simple.text.list.AbstractListContainer;
import org.odftoolkit.simple.text.list.List;
import org.odftoolkit.simple.text.list.ListContainer;
import org.odftoolkit.simple.text.list.ListDecorator;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
import org.w3c.dom.Text;

/**
 * This class represents an empty ODF text document.
 * 
 */
public class TextDocument extends Document implements ListContainer,
		ParagraphContainer, VariableContainer, ChartContainer, FormContainer,
		ControlContainer {

	private static final String EMPTY_TEXT_DOCUMENT_PATH = "/OdfTextDocument.odt";
	static final Resource EMPTY_TEXT_DOCUMENT_RESOURCE = new Resource(EMPTY_TEXT_DOCUMENT_PATH);

	private ListContainerImpl listContainerImpl;
	private ParagraphContainerImpl paragraphContainerImpl;
	private VariableContainerImpl variableContainerImpl;
	private ChartContainerImpl chartContainerImpl;
	private FormContainerImpl formContainerImpl = null;
	
	private Header firstPageHeader;
	private Header standardHeader;

	private Footer firstPageFooter;
	private Footer standardFooter;

	/**
	 * This enum contains all possible media types of SpreadsheetDocument
	 * documents.
	 */
	public enum OdfMediaType implements MediaType {

		TEXT(Document.OdfMediaType.TEXT), TEXT_TEMPLATE(Document.OdfMediaType.TEXT_TEMPLATE), TEXT_MASTER(
				Document.OdfMediaType.TEXT_MASTER), TEXT_WEB(Document.OdfMediaType.TEXT_WEB);
		private final Document.OdfMediaType mMediaType;

		OdfMediaType(Document.OdfMediaType mediaType) {
			this.mMediaType = mediaType;
		}

		/**
		 * @return the mediatype of this document
		 */
		public String getMediaTypeString() {
			return mMediaType.getMediaTypeString();
		}

		/**
		 * @return the ODF filesuffix of this document
		 */
		public String getSuffix() {
			return mMediaType.getSuffix();
		}

		/**
		 * 
		 * @param mediaType
		 *            string defining an ODF document
		 * @return the according OdfMediatype encapuslating the given string and
		 *         the suffix
		 */
		public static Document.OdfMediaType getOdfMediaType(String mediaType) {
			return Document.OdfMediaType.getOdfMediaType(mediaType);
		}
	}

	/**
	 * Creates an empty text document.
	 * 
	 * @return ODF text document based on a default template
	 * @throws java.lang.Exception
	 *             - if the document could not be created
	 */
	public static TextDocument newTextDocument() throws Exception {
		return (TextDocument) Document.loadTemplate(EMPTY_TEXT_DOCUMENT_RESOURCE, Document.OdfMediaType.TEXT);
	}

	/**
	 * Creates an empty text document.
	 * 
	 * @return ODF text document based on a default template
	 * @throws java.lang.Exception
	 *             - if the document could not be created
	 */
	public static TextDocument newTextDocument(TextDocument.OdfMediaType mimeType) throws Exception {
		return (TextDocument) Document.loadTemplate(EMPTY_TEXT_DOCUMENT_RESOURCE, Document.OdfMediaType.TEXT);
	}

	/**
	 * Creates an empty text template.
	 * 
	 * @return ODF text template based on a default
	 * @throws java.lang.Exception
	 *             - if the template could not be created
	 */
	public static TextDocument newTextTemplateDocument() throws Exception {
		return (TextDocument) Document.loadTemplate(EMPTY_TEXT_DOCUMENT_RESOURCE, Document.OdfMediaType.TEXT_TEMPLATE);
	}

	/**
	 * Creates an empty text master document.
	 * 
	 * @return ODF text master based on a default
	 * @throws java.lang.Exception
	 *             - if the document could not be created
	 */
	public static TextDocument newTextMasterDocument() throws Exception {
		TextDocument doc = (TextDocument) Document.loadTemplate(EMPTY_TEXT_DOCUMENT_RESOURCE,
				Document.OdfMediaType.TEXT_MASTER);
		doc.changeMode(OdfMediaType.TEXT_MASTER);
		return doc;
	}

	/**
	 * Creates an empty text web.
	 * 
	 * @return ODF text web based on a default
	 * @throws java.lang.Exception
	 *             - if the document could not be created
	 */
	public static TextDocument newTextWebDocument() throws Exception {
		TextDocument doc = (TextDocument) Document.loadTemplate(EMPTY_TEXT_DOCUMENT_RESOURCE,
				Document.OdfMediaType.TEXT_WEB);
		doc.changeMode(OdfMediaType.TEXT_WEB);
		return doc;
	}

	/**
	 * Creates an TextDocument from the OpenDocument provided by a resource
	 * Stream.
	 * 
	 * <p>
	 * Since an InputStream does not provide the arbitrary (non sequentiell)
	 * read access needed by TextDocument, the InputStream is cached. This
	 * usually takes more time compared to the other createInternalDocument
	 * methods. An advantage of caching is that there are no problems
	 * overwriting an input file.
	 * </p>
	 * 
	 * <p>
	 * If the resource stream is not a ODF text document, ClassCastException
	 * might be thrown.
	 * </p>
	 * 
	 * @param inputStream
	 *            - the InputStream of the ODF text document.
	 * @return the text document created from the given InputStream
	 * @throws java.lang.Exception
	 *             - if the document could not be created.
	 */
	public static TextDocument loadDocument(InputStream inputStream) throws Exception {
		return (TextDocument) Document.loadDocument(inputStream);
	}

	/**
	 * Loads an TextDocument from the provided path.
	 * 
	 * <p>
	 * TextDocument relies on the file being available for read access over the
	 * whole lifecycle of TextDocument.
	 * </p>
	 * 
	 * <p>
	 * If the resource stream is not a ODF text document, ClassCastException
	 * might be thrown.
	 * </p>
	 * 
	 * @param documentPath
	 *            - the path from where the document can be loaded
	 * @return the text document from the given path or NULL if the media type
	 *         is not supported by SIMPLE.
	 * @throws java.lang.Exception
	 *             - if the document could not be created.
	 */
	public static TextDocument loadDocument(String documentPath) throws Exception {
		return (TextDocument) Document.loadDocument(documentPath);
	}

	/**
	 * Creates an TextDocument from the OpenDocument provided by a File.
	 * 
	 * <p>
	 * TextDocument relies on the file being available for read access over the
	 * whole lifecycle of TextDocument.
	 * </p>
	 * 
	 * <p>
	 * If the resource stream is not a ODF text document, ClassCastException
	 * might be thrown.
	 * </p>
	 * 
	 * @param file
	 *            - a file representing the ODF text document.
	 * @return the text document created from the given File
	 * @throws java.lang.Exception
	 *             - if the document could not be created.
	 */
	public static TextDocument loadDocument(File file) throws Exception {
		return (TextDocument) Document.loadDocument(file);
	}

	/**
	 * To avoid data duplication a new document is only created, if not already
	 * opened. A document is cached by this constructor using the internalpath
	 * as key.
	 */
	protected TextDocument(OdfPackage pkg, String internalPath, TextDocument.OdfMediaType odfMediaType) {
		super(pkg, internalPath, odfMediaType.mMediaType);
	}

	/**
	 * Get the content root of a text document. Start here to get or create new
	 * elements of a text document like paragraphs, headings, tables or lists.
	 * 
	 * @return content root, representing the office:text tag
	 * @throws Exception
	 *             if the file DOM could not be created.
	 */
	@Override
	public OfficeTextElement getContentRoot() throws Exception {
		return super.getContentRoot(OfficeTextElement.class);
	}

	/**
	 * Creates a new paragraph and append text
	 * 
	 * @param text
	 * @return the new paragraph
	 * @throws Exception
	 *             if the file DOM could not be created.
	 * @deprecated As of Simple version 0.5, replaced by
	 *             <code>addParagraph(String text)</code>
	 * @see #addParagraph(String)
	 */
	public OdfTextParagraph newParagraph(String text) throws Exception {
		OdfTextParagraph para = newParagraph();
		para.addContent(text);
		return para;
	}

	/**
	 * Creates a new paragraph
	 * 
	 * @return The new paragraph
	 * @throws Exception
	 *             if the file DOM could not be created.
	 * @deprecated As of Simple version 0.5, replaced by
	 *             <code>Paragraph.newParagraph(ParagraphContainer)</code>
	 * @see Paragraph#newParagraph(ParagraphContainer)
	 * @see #addParagraph(String)
	 */
	public OdfTextParagraph newParagraph() throws Exception {
		OfficeTextElement odfText = getContentRoot();
		return (OdfTextParagraph) odfText.newTextPElement();
	}

	/**
	 * Append text to the end of a text document. If there is no paragraph at
	 * the end of a document, a new one will be created.
	 * 
	 * @param text
	 *            initial text for the paragraph.
	 * @return The paragraph at the end of the text document, where the text has
	 *         been added to.
	 * @throws Exception
	 *             if the file DOM could not be created.
	 * @deprecated As of Simple version 0.5, replaced by
	 *             <code>Paragraph.appendTextContent(String content)</code>
	 * @see Paragraph#appendTextContent(String)
	 * @see Paragraph#appendTextContentNotCollapsed(String)
	 * @see #getParagraphByIndex(int, boolean)
	 * @see #getParagraphByReverseIndex(int, boolean)
	 */
	public OdfTextParagraph addText(String text) throws Exception {
		OfficeTextElement odfText = getContentRoot();
		Node n = odfText.getLastChild();
		OdfTextParagraph para;
		if (OdfTextParagraph.class.isInstance(n)) {
			para = (OdfTextParagraph) n;
		} else {
			para = newParagraph();
		}
		para.addContent(text);
		return para;
	}

	/**
	 * Changes the document to the given mediatype. This method can only be used
	 * to convert a document to a related mediatype, e.g. template.
	 * 
	 * @param mediaType
	 *            the related ODF mimetype
	 */
	public void changeMode(OdfMediaType mediaType) {
		setOdfMediaType(mediaType.mMediaType);
	}

	/**
	 * Copy a section and append it at the end of the text document, whether the
	 * section is in this document or in a different document.
	 * <p>
	 * The IDs and names in this section would be changed to ensure unique.
	 * <p>
	 * If the section contains a linked resource, <code>isResourceCopied</code>
	 * would specify whether the linked resource would be copied or not, when
	 * the copy and append happens within a same document.
	 * 
	 * @param section
	 *            - the section object
	 * @param isResourceCopied
	 *            - whether the linked resource is copied or not.
	 */
	public Section appendSection(Section section, boolean isResourceCopied) {
		boolean isForeignNode = false;
		try {
			if (section.getOdfElement().getOwnerDocument() != getContentDom())
				isForeignNode = true;
			TextSectionElement oldSectionEle = section.getOdfElement();
			TextSectionElement newSectionEle = (TextSectionElement) oldSectionEle.cloneNode(true);

			if (isResourceCopied || isForeignNode)
				copyLinkedRefInBatch(newSectionEle, section.getOwnerDocument());
			if (isForeignNode)
				copyForeignStyleRef(newSectionEle, section.getOwnerDocument());
			if (isForeignNode) // not in a same document
				newSectionEle = (TextSectionElement) cloneForeignElement(newSectionEle, getContentDom(), true);

			updateNames(newSectionEle);
			updateXMLIds(newSectionEle);
			OfficeTextElement contentRoot = getContentRoot();
			contentRoot.appendChild(newSectionEle);
			return Section.getInstance(newSectionEle);
		} catch (Exception e) {
			Logger.getLogger(TextDocument.class.getName()).log(Level.SEVERE, null, e);
		}
		return null;
	}

	/**
	 * Create an empty section and append it at the end of the text document.
	 * 
	 * @param name
	 *            - specify the section name
	 * @return an instance of the section
	 * @throws RuntimeException
	 *             if content DOM could not be initialized
	 */
	public Section appendSection(String name) {
		TextSectionElement newSectionEle = null;
		try {
			OdfContentDom contentDocument = getContentDom();
			OdfOfficeAutomaticStyles styles = contentDocument
					.getAutomaticStyles();
			OdfStyle style = styles.newStyle(OdfStyleFamily.Section);
			StyleSectionPropertiesElement sProperties = style
					.newStyleSectionPropertiesElement();
			sProperties.setTextDontBalanceTextColumnsAttribute(false);
			sProperties.setStyleEditableAttribute(false);
			StyleColumnsElement columnEle = sProperties
					.newStyleColumnsElement(1);
			columnEle.setFoColumnGapAttribute("0in");

			newSectionEle = getContentRoot()
					.newTextSectionElement("true", name);
			newSectionEle.setStyleName(style.getStyleNameAttribute());
			return Section.getInstance(newSectionEle);

		} catch (Exception e) {
			Logger.getLogger(TextDocument.class.getName()).log(Level.SEVERE,
					null, e);
			throw new RuntimeException(name + "Section appends failed.", e);
		}
	}

	/**
	 * Get the Standard Page header of this text document.
	 * 
	 * @return the Standard Page header of this text document.
	 * @since 0.4.5
	 */
	public Header getHeader() {
		return getHeader(false);
	}

	/**
	 * Get the header of this text document.
	 * 
	 * @param isFirstPage
	 *            if <code>isFirstPage</code> is true, return the First Page
	 *            header, otherwise return Standard Page header.
	 * 
	 * @return the header of this text document.
	 * @since 0.5
	 */
	public Header getHeader(boolean isFirstPage) {
		Header tmpHeader = isFirstPage ? firstPageHeader : standardHeader;
		if (tmpHeader == null) {
			try {
				StyleMasterPageElement masterPageElement = getMasterPage(isFirstPage);
				StyleHeaderElement headerElement = OdfElement.findFirstChildNode(StyleHeaderElement.class,
						masterPageElement);
				if (headerElement == null) {
					headerElement = masterPageElement.newStyleHeaderElement();
				}
				tmpHeader = new Header(headerElement);
			} catch (Exception e) {
				Logger.getLogger(TextDocument.class.getName()).log(Level.SEVERE, null, e);
			}
			if (isFirstPage) {
				firstPageHeader = tmpHeader;
			} else {
				standardHeader = tmpHeader;
			}
		}
		return tmpHeader;
	}

	/**
	 * Get the Standard Page footer of this text document.
	 * 
	 * @return the Standard Page footer of this text document.
	 * @since 0.4.5
	 */
	public Footer getFooter() {
		return getFooter(false);
	}

	/**
	 * Get the footer of this text document.
	 * 
	 * @param isFirstPage
	 *            if <code>isFirstPage</code> is true, return the First Page
	 *            footer, otherwise return Standard Page footer.
	 * 
	 * @return the footer of this text document.
	 * @since 0.5
	 */
	public Footer getFooter(boolean isFirstPage) {
		Footer tmpFooter = isFirstPage ? firstPageFooter : standardFooter;
		if (tmpFooter == null) {
			try {
				StyleMasterPageElement masterPageElement = getMasterPage(isFirstPage);
				StyleFooterElement footerElement = OdfElement.findFirstChildNode(StyleFooterElement.class,
						masterPageElement);
				if (footerElement == null) {
					footerElement = masterPageElement.newStyleFooterElement();
				}
				tmpFooter = new Footer(footerElement);
			} catch (Exception e) {
				Logger.getLogger(TextDocument.class.getName()).log(Level.SEVERE, null, e);
			}
			if (isFirstPage) {
				firstPageFooter = tmpFooter;
			} else {
				standardFooter = tmpFooter;
			}
		}
		return tmpFooter;
	}

	public OdfElement getTableContainerElement() {
		return getTableContainerImpl().getTableContainerElement();
	}

	public OdfElement getListContainerElement() {
		return getListContainerImpl().getListContainerElement();
	}

	public List addList() {
		return getListContainerImpl().addList();
	}

	public List addList(ListDecorator decorator) {
		return getListContainerImpl().addList(decorator);
	}

	public void clearList() {
		getListContainerImpl().clearList();
	}

	public Iterator<List> getListIterator() {
		return getListContainerImpl().getListIterator();
	}

	public boolean removeList(List list) {
		return getListContainerImpl().removeList(list);
	}
	
	/**
	 * Appends a new page break to this document.
	 * 
	 * @since 0.6.5
	 */
	public void addPageBreak() {
		addPageOrColumnBreak(null, "page");
	}
	
	/**
	 * Appends a new page break to this document after the reference paragraph.
	 * 
	 * @param refParagraph
	 *            the reference paragraph after where the page break inserted.
	 * @since 0.6.5
	 */
	public void addPageBreak(Paragraph refParagraph) {
		addPageOrColumnBreak(refParagraph, "page");
	}
	
	/** 
	 * Defines several columns to the page whose style is specified.
	 * 
	 * @param columnsNumber
	 * 			the number of columns (are of width identical)
	 * @param spacing
	 * 			column spacing in cm (ex. 2.40 for 2,4 cm)
	 * 
	 * @since 0.6.6
	 */
	public void setPageColumns(int columnsNumber, double spacing) {
		String vSpacingColumn = (new DecimalFormat("#0.###").format(spacing) + Unit.CENTIMETER.abbr()).replace(",", ".");
		// Get back the name of the style Page wanted Layout
		// (Example of the got back name : pm1 or Mpm1 for the standard style)
		try {
			String stylePageLayoutName = null;
			int pageLayoutNameCount = 0;
			NodeList list = getStylesDom().getElementsByTagName("office:master-styles");
			if (list.getLength() > 0) {
				OdfOfficeMasterStyles officeMasterStyles = (OdfOfficeMasterStyles) list.item(0);
				// Get back the StylePageLayoutName
				for (int i = 0; i < officeMasterStyles.getLength(); i++) {
					StyleMasterPageElement syleMasterPage = (StyleMasterPageElement) officeMasterStyles.item(i);
					if(syleMasterPage.getStyleNameAttribute().equals("Standard")){					
						stylePageLayoutName = syleMasterPage.getStylePageLayoutNameAttribute();
						break;
					}
				}
				// Allows to know if StylePageLayoutName is unique
				for (int i = 0; i < officeMasterStyles.getLength(); i++) {
					StyleMasterPageElement syleMasterPage = (StyleMasterPageElement) officeMasterStyles.item(i);
					if(syleMasterPage.getStylePageLayoutNameAttribute().equals(stylePageLayoutName)){					
						pageLayoutNameCount++;
					}
				}
			}
			
			OdfOfficeAutomaticStyles autoStyles = getStylesDom().getAutomaticStyles();
			int autoStylesCount = autoStyles.getLength();			
			OdfStylePageLayout pageLayout = autoStyles.getPageLayout(stylePageLayoutName);
			if(pageLayout != null) {
				// Clone the OdfStylePageLayout if another master style possesses the same name before modifying its properties
				if(pageLayoutNameCount > 1){
					Node pageLayoutNew = pageLayout.cloneNode(true);					
					// Rename the style of the clone before modifying its properties
					String oldPageLayoutName = pageLayout.getStyleNameAttribute();
					pageLayout.setStyleNameAttribute("Mpm" + (autoStylesCount+1));
					// Allocate the new name of the style to the master style (the cloned style)
					if (list.getLength() > 0) {
						OdfOfficeMasterStyles masterpage = (OdfOfficeMasterStyles) list.item(0);
						for (int i = 0; i < masterpage.getLength(); i++) {
							StyleMasterPageElement vSyleMasterPage = (StyleMasterPageElement) masterpage.item(i);
							if(vSyleMasterPage.getStyleNameAttribute().equals("Standard")){
								if(vSyleMasterPage.getStylePageLayoutNameAttribute().equals(oldPageLayoutName)){					
									vSyleMasterPage.setStylePageLayoutNameAttribute(pageLayout.getStyleNameAttribute());
								}
							}
						}
					}
					autoStyles.appendChild(pageLayoutNew);
				}
				NodeList vListStlePageLprop = pageLayout.getElementsByTagName("style:page-layout-properties");
				StylePageLayoutPropertiesElement vStlePageLprop = (StylePageLayoutPropertiesElement) vListStlePageLprop.item(0);
				StyleColumnsElement vStyleColumnsElement = vStlePageLprop.newStyleColumnsElement(columnsNumber);
				vStyleColumnsElement.setFoColumnGapAttribute(vSpacingColumn);
			}
		} catch (Exception e) {
			Logger.getLogger(TextDocument.class.getName()).log(Level.SEVERE, null, e);
			throw new RuntimeException("Page column sets failed.", e);
		}		
	}
	
	/**
	 * Appends a new column break to this document.
	 * 
	 * @since 0.6.6
	 */
	public void addColumnBreak() {
		addPageOrColumnBreak(null, "column");
	}
	
	/**
	 * Appends a new column break to this document after the reference paragraph.
	 * 
	 * @param refParagraph
	 *            the reference paragraph after where the column break inserted.
	 * @since 0.6.6
	 */
	public void addColumnBreak(Paragraph refParagraph) {
		addPageOrColumnBreak(refParagraph, "column");
	}
	
	/** 
	 * Appends a new column or page break to this document.
	 * 
	 * @param refParagraph
	 * 			the reference paragraph after where the column break inserted.
	 * @param breakAttribute
	 * 			the attribute name (page or column)
	 */
	private void addPageOrColumnBreak(Paragraph refParagraph, String breakAttribute) {
		TextPElement pEle = null;
		try {
			OdfContentDom contentDocument = getContentDom();
			OdfOfficeAutomaticStyles styles = contentDocument.getAutomaticStyles();
			OdfStyle style = styles.newStyle(OdfStyleFamily.Paragraph);
			style.newStyleParagraphPropertiesElement().setFoBreakBeforeAttribute(breakAttribute);
			if(refParagraph == null){
				pEle = getContentRoot().newTextPElement();
			} else {
				OfficeTextElement contentRoot = getContentRoot();
				pEle = contentRoot.newTextPElement();
				OdfElement refEle = refParagraph.getOdfElement();
				contentRoot.insertBefore(pEle, refEle.getNextSibling());
			}
			pEle.setStyleName(style.getStyleNameAttribute());
		} catch (Exception e) {
			Logger.getLogger(TextDocument.class.getName()).log(Level.SEVERE, null, e);
			throw new RuntimeException(breakAttribute + "Break appends failed.", e);
		}
	}

	/**
	 * Appends a new page break to this document after the reference paragraph,
	 * and the master page style will be applied to the new page.
	 * 
	 * @param refParagraph
	 *            the reference paragraph after where the page break inserted.
	 * @param master
	 *            the master page style applied to the new page.
	 * @since 0.8
	 */

	public void addPageBreak(Paragraph refParagraph, MasterPage master) {
		TextPElement pEle = null;
		try {
			OdfContentDom contentDocument = getContentDom();
			OdfOfficeAutomaticStyles styles = contentDocument
					.getAutomaticStyles();
			OdfStyle style = styles.newStyle(OdfStyleFamily.Paragraph);
			style.setStyleMasterPageNameAttribute(master.getName());

			if (refParagraph == null) {
				pEle = getContentRoot().newTextPElement();
			} else {
				OfficeTextElement contentRoot = getContentRoot();
				pEle = contentRoot.newTextPElement();
				OdfElement refEle = refParagraph.getOdfElement();
				contentRoot.insertBefore(pEle, refEle.getNextSibling());
			}
			pEle.setStyleName(style.getStyleNameAttribute());
		} catch (Exception e) {
			Logger.getLogger(TextDocument.class.getName()).log(Level.SEVERE,
					null, e);
			throw new RuntimeException("PageBreak with mater page - "
					+ master.getName() + " - appends failed.", e);
		}
	}

	/**
	 * Creates a new paragraph and append text.
	 * 
	 * @param text
	 *            the text content of this paragraph
	 * @return the new paragraph
	 */
	public Paragraph addParagraph(String text) {
		Paragraph para = getParagraphContainerImpl().addParagraph(text);
		return para;
	}

	/**
	 * Remove paragraph from this document
	 * 
	 * @param para
	 *            the instance of paragraph
	 * @return true if the paragraph is removed successfully, false if errors
	 *         happen.
	 */
	public boolean removeParagraph(Paragraph para) {
		return getParagraphContainerImpl().removeParagraph(para);
	}

	public OdfElement getParagraphContainerElement() {
		return getParagraphContainerImpl().getParagraphContainerElement();
	}

	public Paragraph getParagraphByIndex(int index, boolean isEmptyParagraphSkipped) {
		return getParagraphContainerImpl().getParagraphByIndex(index, isEmptyParagraphSkipped);
	}

	public Paragraph getParagraphByReverseIndex(int reverseIndex, boolean isEmptyParagraphSkipped) {
		return getParagraphContainerImpl().getParagraphByReverseIndex(reverseIndex, isEmptyParagraphSkipped);
	}

	public Iterator<Paragraph> getParagraphIterator() {
		return getParagraphContainerImpl().getParagraphIterator();
	}

	public VariableField declareVariable(String name, VariableType type) {
		return getVariableContainerImpl().declareVariable(name, type);
	}

	public VariableField getVariableFieldByName(String name) {
		return getVariableContainerImpl().getVariableFieldByName(name);
	}

	public OdfElement getVariableContainerElement() {
		return getVariableContainerImpl().getVariableContainerElement();
	}
	
	public Chart createChart(String title, DataSet dataset, Rectangle rect) {
		return getChartContainerImpl().createChart(title, dataset, rect);
	}

	public Chart createChart(String title, SpreadsheetDocument document, CellRangeAddressList cellRangeAddr, boolean firstRowAsLabel,
			boolean firstColumnAsLabel, boolean rowAsDataSeries, Rectangle rect) {
		return getChartContainerImpl().createChart(title, document, cellRangeAddr, firstRowAsLabel, firstColumnAsLabel,
				rowAsDataSeries, rect);
	}

	public Chart createChart(String title, String[] labels, String[] legends, double[][] data, Rectangle rect) {
		return getChartContainerImpl().createChart(title, labels, legends, data, rect);
	}

	public void deleteChartById(String chartId) {
		getChartContainerImpl().deleteChartById(chartId);
	}

	public void deleteChartByTitle(String title) {
		getChartContainerImpl().deleteChartByTitle(title);
	}

	public Chart getChartById(String chartId) {
		return getChartContainerImpl().getChartById(chartId);
	}

	public java.util.List<Chart> getChartByTitle(String title) {
		return getChartContainerImpl().getChartByTitle(title);
	}

	public int getChartCount() {
		return getChartContainerImpl().getChartCount();
	}
	
	private ListContainerImpl getListContainerImpl() {
		if (listContainerImpl == null) {
			listContainerImpl = new ListContainerImpl();
		}
		return listContainerImpl;
	}

	private class ListContainerImpl extends AbstractListContainer {

		public OdfElement getListContainerElement() {
			OdfElement containerElement = null;
			try {
				containerElement = getContentRoot();
			} catch (Exception e) {
				Logger.getLogger(TextDocument.class.getName()).log(Level.SEVERE, null, e);
			}
			return containerElement;
		}
	}

	private StyleMasterPageElement getMasterPage(boolean pFirstPage) throws Exception {
		String pageStyleName = pFirstPage ? "First_20_Page" : "Standard";
		OfficeDocumentStylesElement rootElement = getStylesDom().getRootElement();
		OfficeMasterStylesElement masterStyles = OdfElement.findFirstChildNode(OfficeMasterStylesElement.class,
				rootElement);
		if (masterStyles == null) {
			masterStyles = rootElement.newOfficeMasterStylesElement();
		}
		StyleMasterPageElement masterPageEle = null;
		NodeList lastMasterPages = masterStyles.getElementsByTagNameNS(OdfDocumentNamespace.STYLE.getUri(),
				"master-page");
		if (lastMasterPages != null && lastMasterPages.getLength() > 0) {
			for (int i = 0; i < lastMasterPages.getLength(); i++) {
				StyleMasterPageElement masterPage = (StyleMasterPageElement) lastMasterPages.item(i);
				String styleName = masterPage.getStyleNameAttribute();
				if (pageStyleName.equals(styleName)) {
					masterPageEle = masterPage;
					break;
				}
			}
		}
		if (masterPageEle == null) {
			OdfStylePageLayout layout = OdfElement.findFirstChildNode(OdfStylePageLayout.class, getStylesDom()
					.getAutomaticStyles());
			masterPageEle = masterStyles.newStyleMasterPageElement(pageStyleName, layout.getStyleNameAttribute());
		}
		return masterPageEle;
	}

	private class ParagraphContainerImpl extends AbstractParagraphContainer {
		public OdfElement getParagraphContainerElement() {
			OdfElement containerElement = null;
			try {
				containerElement = getContentRoot();
			} catch (Exception e) {
				Logger.getLogger(TextDocument.class.getName()).log(Level.SEVERE, null, e);
			}
			return containerElement;
		}
	}

	private ParagraphContainerImpl getParagraphContainerImpl() {
		if (paragraphContainerImpl == null)
			paragraphContainerImpl = new ParagraphContainerImpl();
		return paragraphContainerImpl;
	}

	private class VariableContainerImpl extends AbstractVariableContainer {

		public OdfElement getVariableContainerElement() {
			try {
				return getContentRoot();
			} catch (Exception e) {
				Logger.getLogger(TextDocument.class.getName()).log(Level.SEVERE, null, e);
				return null;
			}
		}
	}

	private VariableContainer getVariableContainerImpl() {
		if (variableContainerImpl == null) {
			variableContainerImpl = new VariableContainerImpl();
		}
		return variableContainerImpl;
	}
	
	private ChartContainerImpl getChartContainerImpl() {
		if (chartContainerImpl == null) {
			chartContainerImpl = new ChartContainerImpl(this);
		}
		return chartContainerImpl;
	}
	
	private class ChartContainerImpl extends AbstractChartContainer {
		TextDocument sdoc;

		protected ChartContainerImpl(Document doc) {
			super(doc);
			sdoc = (TextDocument) doc;
		}

		protected DrawFrameElement getChartFrame() throws Exception {
			OdfContentDom contentDom2 = sdoc.getContentDom();
			DrawFrameElement drawFrame = contentDom2.newOdfElement(DrawFrameElement.class);
			TextPElement lastPara = sdoc.getContentRoot().newTextPElement();
			lastPara.appendChild(drawFrame);
			drawFrame.setTextAnchorTypeAttribute(TextAnchorTypeAttribute.Value.PARAGRAPH.toString());
			return drawFrame;
		}
	}

	/**
	 * Create a new Table Of Content to this document before the reference
	 * paragraph. Because until you do a full layout of the document, taking
	 * into account font metrics,line breaking algorithms, hyphenation, image
	 * positioning, "orphan and widow" rules, etc., you don't know what content
	 * is on which page. So all the page numbers in TOC are be set value "1".
	 * Please update the page numbers from AOO Menus: Tools->Update->All Indexes
	 * and Tables
	 * 
	 * @param refParagraph
	 *            the reference paragraph where the TOC be inserted.
	 * @param before
	 *            true:insert TOC before the reference paragraph. false:insert
	 *            TOC after the reference paragraph.
	 * @since 0.8.6
	 */
	public TextTableOfContentElement createDefaultTOC(Paragraph refParagraph, boolean before) {
		
		TextTableOfContentElement textTableOfContent =null;
		if(refParagraph==null){
			Logger.getLogger(TextDocument.class.getName()).log(Level.SEVERE,
					"Failed to create Default TOC, The refParagraph where the TOC be inserted is null");
			throw new RuntimeException("Failed to create Default TOC, The refParagraph where the TOC be inserted is null");
		}
		Node refparagraphNode = refParagraph.getOdfElement();
		Node rootNode = refparagraphNode.getParentNode();		
		try {
			OdfContentDom content = getContentDom();
			textTableOfContent = content
					.newOdfElement(TextTableOfContentElement.class);
			textTableOfContent.setTextNameAttribute("Table of Contents");
			textTableOfContent.setTextProtectedAttribute(true);
			TextTableOfContentSourceElement textTableOfContentSource = textTableOfContent
					.newTextTableOfContentSourceElement();
			textTableOfContentSource.setTextOutlineLevelAttribute(10);
			textTableOfContentSource.setTextUseIndexMarksAttribute(true);
			TextIndexTitleTemplateElement textIndexTitleTemplate = textTableOfContentSource
					.newTextIndexTitleTemplateElement();
			textIndexTitleTemplate
					.setTextStyleNameAttribute("Contents_20_Heading");
			textIndexTitleTemplate.setTextContent("Table of Contents");
			for (int i = 1; i <= 10; i++) {
				TextTableOfContentEntryTemplateElement textTableOfContentEntryTemplate = textTableOfContentSource
						.newTextTableOfContentEntryTemplateElement(i,
								"Contents_20_" + i);
				TextIndexEntryLinkStartElement TextIndexEntryLinkStart = textTableOfContentEntryTemplate
						.newTextIndexEntryLinkStartElement();
				TextIndexEntryLinkStart
						.setTextStyleNameAttribute("Index_20_Link");
				textTableOfContentEntryTemplate
						.newTextIndexEntryChapterElement();
				textTableOfContentEntryTemplate.newTextIndexEntryTextElement();
				TextIndexEntryTabStopElement TextIndexEntryTabStop = textTableOfContentEntryTemplate
						.newTextIndexEntryTabStopElement("right");
				TextIndexEntryTabStop.setStyleLeaderCharAttribute(".");
				textTableOfContentEntryTemplate
						.newTextIndexEntryPageNumberElement();
				textTableOfContentEntryTemplate
						.newTextIndexEntryLinkEndElement();
			}
			TextIndexBodyElement textIndexBody = textTableOfContent
					.newTextIndexBodyElement();
			TextIndexTitleElement TextIndexTitle = textIndexBody
					.newTextIndexTitleElement("Table of Contents_Head");
			TextPElement texp = TextIndexTitle.newTextPElement();
			texp.setTextStyleNameAttribute("Contents_20_Heading");
			texp.setTextContent("Table of Contents");
			Iterator<Paragraph> paragraphIterator = getParagraphIterator();
			while (paragraphIterator.hasNext()) {
				Paragraph paragraph = paragraphIterator.next();
				String text = paragraph.getTextContent();
				String stylename = paragraph.getStyleName();
				// Outline support
				if (paragraph.isHeading()) {
					int headingLevel = paragraph.getHeadingLevel();
					if (stylename.length() <= 0) {
						stylename = "Contents_20_" + headingLevel;
					}
					ceateIndexBodyEntry(textIndexBody, stylename, text);
				}
				// end of Outline support
				// Index Makes support
				TextParagraphElementBase podf = paragraph.getOdfElement();
				NodeList cns = podf.getChildNodes();
				for (int i = 0; i < cns.getLength(); i++) {
					Node node = cns.item(i);
					if (node instanceof TextTocMarkElement) {
						TextTocMarkElement textTocMarkElement = (TextTocMarkElement) node;
						text = textTocMarkElement.getTextStringValueAttribute();
						int headingLevel = textTocMarkElement
								.getTextOutlineLevelAttribute();
						stylename = "Contents_20_" + headingLevel;
						ceateIndexBodyEntry(textIndexBody, stylename, text);
					}
					if (node instanceof TextTocMarkStartElement) {
						TextTocMarkStartElement textTocMarkStartElement = (TextTocMarkStartElement) node;
						Node tmp = node.getNextSibling();
						while (!(tmp instanceof Text)) {
							tmp = node.getNextSibling();
						}
						text = tmp.getTextContent();
						int headingLevel = textTocMarkStartElement
								.getTextOutlineLevelAttribute();
						stylename = "Contents_20_" + headingLevel;
						ceateIndexBodyEntry(textIndexBody, stylename, text);
					}
				}
				// end of Index Makes support
			}
			if (before) {
				rootNode.insertBefore(textTableOfContent, refparagraphNode);
			} else {
				// Insert TOC after the refParagraph
				Node refNextNode = refparagraphNode.getNextSibling();
				if (refNextNode == null) {
					rootNode.appendChild(textTableOfContent);
				} else {
					rootNode.insertBefore(textTableOfContent, refNextNode);
				}
			}
			return textTableOfContent;
		} catch (Exception e) {
			Logger.getLogger(TextDocument.class.getName()).log(Level.SEVERE,
					"Failed to create Default TOC", e);
			throw new RuntimeException("Failed to create Default TOC", e);
		}
	}

	private void ceateIndexBodyEntry(TextIndexBodyElement textIndexBody,
			String stylename, String text) {
		TextPElement textp = textIndexBody.newTextPElement();
		textp.setTextStyleNameAttribute(stylename);
		textp.newTextNode(text);
		textp.newTextTabElement();
		textp.newTextNode("1");
	}

	/**
	 * Create a new Table Of Content to this document before the reference
	 * paragraph. The additional paragraph styles list will be included in the
	 * TOC. Because until you do a full layout of the document, taking into
	 * account font metrics,line breaking algorithms, hyphenation, image
	 * positioning, "orphan and widow" rules, etc., you don't know what content
	 * is on which page. So all the page numbers in TOC are be set value "1".
	 * Please update the page numbers from AOO Menus: Tools->Update->All Indexes
	 * and Tables.  If additionalStyle is null then call createDefaultTOC().
	 * 
	 * @param refParagraph
	 *            the reference paragraph before where the TOC inserted.
	 * @param additionalStyle
	 *            the additional paragraph styles that you want to include in
	 *            the TOC
	 * @param before
	 *            true:insert TOC before the reference paragraph. 
	 *            false:insert TOC after the reference paragraph.
	 * @since 0.8.6
	 */
	public TextTableOfContentElement createTOCwithStyle(Paragraph refParagraph,
			TOCStyle additionalStyle, boolean before) {
		if(refParagraph==null){
			Logger.getLogger(TextDocument.class.getName()).log(Level.SEVERE,
					"Failed to create Default TOC, The refParagraph where the TOC be inserted is null");
			throw new RuntimeException("Failed to create Default TOC, The refParagraph where the TOC be inserted is null");
		}
		if (additionalStyle == null) {
			TextTableOfContentElement textTableOfContentElement = createDefaultTOC(refParagraph, before);
			return textTableOfContentElement;
		}
		HashMap<Integer, String> tocstyleList = additionalStyle.getStyle();
		if (tocstyleList.isEmpty()) {
			TextTableOfContentElement textTableOfContentElement =createDefaultTOC(refParagraph, before);
			return textTableOfContentElement;
		}

		Collection<String> tocvalues = tocstyleList.values();
		OdfOfficeStyles docstyles = getOrCreateDocumentStyles();
		Iterable<OdfStyle> paragraphStyles = docstyles
				.getStylesForFamily(OdfStyleFamily.Paragraph);
		ArrayList<String> pstyle = new ArrayList<String>();
		Iterator<OdfStyle> iterator = paragraphStyles.iterator();
		while (iterator.hasNext()) {
			OdfStyle style = iterator.next();
			String name = style.getStyleNameAttribute();
			pstyle.add(name);
		}
		if (!pstyle.containsAll(tocvalues)) {
			Logger.getLogger(TextDocument.class.getName())
					.log(Level.SEVERE,
							"Failed to create TOC with Styles. Some of addtional Styles that you want to include in the TOC can't be found in the document.\n"
									+ tocvalues.toString());
			throw new RuntimeException(
					"Failed to create TOC Styles.Some of addtional Styles that you want to include in the TOC can't be found in the document.");
		}
		TextTableOfContentElement textTableOfContent =null;
		// Additional Styles support
		HashMap<String, Integer> tmptocstyleList = new HashMap<String, Integer>();
		if (!tocstyleList.isEmpty()) {
			Set<Integer> key = tocstyleList.keySet();
			Iterator<Integer> it = key.iterator();
			while (it.hasNext()) {
				Integer textOutlineLevelValue = it.next();
				String textStyleNameValue = tocstyleList
						.get(textOutlineLevelValue);
				tmptocstyleList.put(textStyleNameValue, textOutlineLevelValue);
			}
		}
		// end of Additional Styles support

		Node refparagraphNode = refParagraph.getOdfElement();
		Node rootNode = refparagraphNode.getParentNode();
		try {
			OdfContentDom content = getContentDom();
			textTableOfContent = content
					.newOdfElement(TextTableOfContentElement.class);
			textTableOfContent.setTextNameAttribute("Table of Contents");
			textTableOfContent.setTextProtectedAttribute(true);

			TextTableOfContentSourceElement textTableOfContentSource = textTableOfContent
					.newTextTableOfContentSourceElement();
			textTableOfContentSource.setTextOutlineLevelAttribute(10);
			textTableOfContentSource.setTextUseIndexMarksAttribute(true);
			textTableOfContentSource.setTextUseIndexSourceStylesAttribute(true);
			TextIndexTitleTemplateElement textIndexTitleTemplate = textTableOfContentSource
					.newTextIndexTitleTemplateElement();
			textIndexTitleTemplate
					.setTextStyleNameAttribute("Contents_20_Heading");
			textIndexTitleTemplate.setTextContent("Table of Contents");
			for (int i = 1; i <= 10; i++) {
				TextTableOfContentEntryTemplateElement textTableOfContentEntryTemplate = textTableOfContentSource
						.newTextTableOfContentEntryTemplateElement(i,
								"Contents_20_" + i);
				TextIndexEntryLinkStartElement TextIndexEntryLinkStart = textTableOfContentEntryTemplate
						.newTextIndexEntryLinkStartElement();
				TextIndexEntryLinkStart
						.setTextStyleNameAttribute("Index_20_Link");
				textTableOfContentEntryTemplate
						.newTextIndexEntryChapterElement();
				textTableOfContentEntryTemplate.newTextIndexEntryTextElement();
				TextIndexEntryTabStopElement TextIndexEntryTabStop = textTableOfContentEntryTemplate
						.newTextIndexEntryTabStopElement("right");
				TextIndexEntryTabStop.setStyleLeaderCharAttribute(".");
				textTableOfContentEntryTemplate
						.newTextIndexEntryPageNumberElement();
				textTableOfContentEntryTemplate
						.newTextIndexEntryLinkEndElement();
			}

			if (!tocstyleList.isEmpty()) {
				Set<Integer> key = tocstyleList.keySet();
				Iterator<Integer> it = key.iterator();
				while (it.hasNext()) {
					Integer textOutlineLevelValue = it.next();
					String textStyleNameValue = tocstyleList
							.get(textOutlineLevelValue);
					TextIndexSourceStylesElement textIndexSourceStyles = textTableOfContentSource
							.newTextIndexSourceStylesElement(textOutlineLevelValue);
					textIndexSourceStyles
							.newTextIndexSourceStyleElement(textStyleNameValue);
				}
			}

			TextIndexBodyElement textIndexBody = textTableOfContent
					.newTextIndexBodyElement();
			TextIndexTitleElement TextIndexTitle = textIndexBody
					.newTextIndexTitleElement("Table of Contents_Head");
			TextPElement texp = TextIndexTitle.newTextPElement();
			texp.setTextStyleNameAttribute("Contents_20_Heading");
			texp.setTextContent("Table of Contents");
			Iterator<Paragraph> paragraphIterator = getParagraphIterator();
			while (paragraphIterator.hasNext()) {
				Paragraph paragraph = paragraphIterator.next();
				String text = paragraph.getTextContent();
				String stylename = paragraph.getStyleName();
				// Outline support
				if (paragraph.isHeading()) {
					int headingLevel = paragraph.getHeadingLevel();
					if (stylename.length() <= 0) {
						stylename = "Contents_20_" + headingLevel;
					}
					ceateIndexBodyEntry(textIndexBody, stylename, text);
				}
				// end of Outline support
				// Additional Styles support
				if (tmptocstyleList.containsKey(stylename)) {
					int headingLevel = tmptocstyleList.get(stylename);
					stylename = "Contents_20_" + headingLevel;
					ceateIndexBodyEntry(textIndexBody, stylename, text);
				}
				// end of Additional Styles support
				// Index Makes support
				TextParagraphElementBase podf = paragraph.getOdfElement();
				NodeList cns = podf.getChildNodes();
				for (int i = 0; i < cns.getLength(); i++) {
					Node node = cns.item(i);
					if (node instanceof TextTocMarkElement) {
						TextTocMarkElement textTocMarkElement = (TextTocMarkElement) node;
						text = textTocMarkElement.getTextStringValueAttribute();
						int headingLevel = textTocMarkElement
								.getTextOutlineLevelAttribute();
						stylename = "Contents_20_" + headingLevel;
						ceateIndexBodyEntry(textIndexBody, stylename, text);
					}
					if (node instanceof TextTocMarkStartElement) {
						TextTocMarkStartElement textTocMarkStartElement = (TextTocMarkStartElement) node;
						Node tmp = node.getNextSibling();
						while (!(tmp instanceof Text)) {
							tmp = node.getNextSibling();
						}
						text = tmp.getTextContent();
						int headingLevel = textTocMarkStartElement
								.getTextOutlineLevelAttribute();
						stylename = "Contents_20_" + headingLevel;
						ceateIndexBodyEntry(textIndexBody, stylename, text);
					}
				}
				// end of Index Makes support
			}
			if (before) {
				rootNode.insertBefore(textTableOfContent, refparagraphNode);
			} else {
				// Insert TOC after the refParagraph
				Node refNextNode = refparagraphNode.getNextSibling();
				if (refNextNode == null) {
					rootNode.appendChild(textTableOfContent);
				} else {
					rootNode.insertBefore(textTableOfContent, refNextNode);
				}
			}
			return textTableOfContent;
			
		} catch (Exception e) {
			Logger.getLogger(TextDocument.class.getName()).log(Level.SEVERE,
					"Failed to create Default TOC", e);
			throw new RuntimeException("Failed to create Default TOC", e);
		}
	}
	
	/**
	 * Copy a Paragraph and insert it before or after the Reference Paragraph in the text document, whether the
	 * Paragraph is in this document or in a different document.
	 * 
	 * @param referenceParagraph
	 *            - where the Paragraph be inserted 
	 * @param sourceParagraph
	 *            - the Paragraph which will be copied
	 * @param before
	 *            true:insert Paragraph before the reference paragraph. 
	 *            false:insert Paragraph after the reference paragraph.       
	 */
	public Paragraph insertParagraph(Paragraph referenceParagraph, Paragraph sourceParagraph,boolean before) {
		boolean isForeignNode = false;
		try {
			Node refparagraphNode = referenceParagraph.getOdfElement();
			if (sourceParagraph.getOdfElement().getOwnerDocument() != getContentDom())
				isForeignNode = true;
			 TextParagraphElementBase oldParagraphEle = sourceParagraph.getOdfElement();
			 TextParagraphElementBase newParagraphEle = (TextParagraphElementBase) oldParagraphEle.cloneNode(true);
			
			if (isForeignNode)
				copyForeignStyleRef(sourceParagraph.getOdfElement(), sourceParagraph.getOwnerDocument());
			if (isForeignNode) // not in a same document
				newParagraphEle = (TextParagraphElementBase) cloneForeignElement(newParagraphEle, getContentDom(), true);
			
			if (before) {
				refparagraphNode.getParentNode().insertBefore(newParagraphEle, refparagraphNode);
			} else {
				// Insert Paragraph after the refParagraph
				Node refNextNode = refparagraphNode.getNextSibling();
				if (refNextNode == null) {
					refparagraphNode.getParentNode().appendChild(newParagraphEle);
				} else {
					refparagraphNode.getParentNode().insertBefore(newParagraphEle, refNextNode);
				}
			}
			
			return Paragraph.getInstanceof(newParagraphEle);
		} catch (Exception e) {
			Logger.getLogger(TextDocument.class.getName()).log(Level.SEVERE, null, e);
		}
		return null;
	}
	/**
	 * Copy a Table and insert it before or after the Reference Paragraph in the text document, whether the
	 * Table is in this TextDocument or in a different Document.
	 * 
	 * @param referenceParagraph
	 *            - where the Paragraph be inserted 
	 * @param sourceParagraph
	 *            - the Paragraph which will be copied
	 * @param before
	 *            true:insert Paragraph before the reference paragraph. 
	 *            false:insert Paragraph after the reference paragraph.       
	 */
	public Table insertTable(Paragraph referenceParagraph, Table sourceTable,boolean before) {
		
		Document ownDocument = sourceTable.getOwnerDocument();
		TableTableElement newTEle = (TableTableElement)insertOdfElement(referenceParagraph.getOdfElement(),ownDocument,sourceTable.getOdfElement(),before);
		Table table = Table.getInstance(newTEle);
		return table;
	}
	/**
	 * Copy a OdfElement and insert it before or after the Reference OdfElement in the TextDocument, whether the
	 * OdfElement is in this TextDocument or in a different Document.
	 * 
	 * @param referenceOdfElement
	 *            - where the OdfElement be inserted 
	 * @param sourceDocument
	 *            - the source Document which contain the sourceOdfElement
	 * @param sourceOdfElement
	 *            - the OdfElement which will be copied
	 * @param before
	 *            true:insert OdfElement before the reference OdfElement. 
	 *            false:insert OdfElement after the reference OdfElement.       
	 */
	public OdfElement insertOdfElement(OdfElement referenceOdfElement,Document sourceDocument ,OdfElement sourceOdfElement,boolean before) {
		boolean isForeignNode = false;
		try {
			
			if (sourceOdfElement.getOwnerDocument() != getContentDom())
				isForeignNode = true;
			 
			OdfElement newOdfElement = (OdfElement) sourceOdfElement.cloneNode(true);
			
			if (isForeignNode) {
				copyForeignStyleRef(newOdfElement, sourceDocument);
				copyLinkedRef(newOdfElement);
				newOdfElement = (OdfElement) cloneForeignElement(newOdfElement,
						getContentDom(), true);
			}
			
			if (before) {
				referenceOdfElement.getParentNode().insertBefore(newOdfElement, referenceOdfElement);
			} else {
				// Insert newOdfElement after the referenceOdfElement
				Node refNextNode = referenceOdfElement.getNextSibling();
				if (refNextNode == null) {
					referenceOdfElement.getParentNode().appendChild(newOdfElement);
				} else {
					referenceOdfElement.getParentNode().insertBefore(newOdfElement, refNextNode);
				}
			}
			return newOdfElement;
		} catch (Exception e) {
			Logger.getLogger(TextDocument.class.getName()).log(Level.SEVERE, null, e);
		}
		return null;
	}
	
	private OdfElement insertOdfElementwithoutstyle(OdfElement referenceOdfElement,Document sourceDocument ,OdfElement sourceOdfElement,boolean before) {
		try {			 
			OdfElement newOdfElement = (OdfElement) sourceOdfElement.cloneNode(true);
			newOdfElement = (OdfElement)  cloneForeignElement(newOdfElement, getContentDom(), true);
			if (before) {
				referenceOdfElement.getParentNode().insertBefore(newOdfElement, referenceOdfElement);
			} else {
				// Insert newOdfElement after the referenceOdfElement
				Node refNextNode = referenceOdfElement.getNextSibling();
				if (refNextNode == null) {
					referenceOdfElement.getParentNode().appendChild(newOdfElement);
				} else {
					referenceOdfElement.getParentNode().insertBefore(newOdfElement, refNextNode);
				}
			}
			return newOdfElement;
		} catch (Exception e) {
			Logger.getLogger(TextDocument.class.getName()).log(Level.SEVERE, null, e);
		}
		return null;
	}
	
	/**
	 * Copy text content of the source TextDocument and insert it to the current TextDocument
	 * after the reference Paragraph, with Styles or without Styles.
	 * 
	 * @param sourceDocument
	 *            the source TextDocument
	 * @param referenceParagraph
	 *  		  where the text content of the source TextDocument be inserted 
	 * @param isCopyStyle
	 *            true:copy the styles in source document to current TextDocment. 
	 *            false:don't copy the styles in source document to current TextDocment. 
	 */
	public void insertContentFromDocumentAfter(TextDocument sourceDocument, Paragraph referenceParagraph, boolean isCopyStyle){
		try {
			OfficeTextElement sroot = sourceDocument.getContentRoot();
			NodeList clist = sroot.getChildNodes();
			for (int i=(clist.getLength()-1); i>=0; i--) {
				OdfElement node = (OdfElement) clist.item(i);
				if(isCopyStyle){
					insertOdfElement(referenceParagraph.getOdfElement(), sourceDocument, node, false);
				}
				else {
					insertOdfElementwithoutstyle(referenceParagraph.getOdfElement(), sourceDocument, node, false);
				}
			}
			
		} catch (Exception e) {
			Logger.getLogger(TextDocument.class.getName()).log(Level.SEVERE, null, e);
		}
	}
	/**
	 * Copy text content of the source TextDocument and insert it to the current TextDocument
	 * before the reference Paragraph, with Styles or without Styles.
	 * 
	 * @param srcDoc
	 *            the source TextDocument
	 * @param referenceParagraph
	 *  		  where the text content of the source TextDocument be inserted 
	 * @param isCopyStyle
	 *            true:copy the styles in source document to current TextDocment. 
	 *            false:don't copy the styles in source document to current TextDocment. 
	 */
	public void insertContentFromDocumentBefore(TextDocument sourceDocument, Paragraph referenceParagraph, boolean isCopyStyle){
		try {
			OfficeTextElement sroot = sourceDocument.getContentRoot();
			NodeList clist = sroot.getChildNodes();
			for (int i = 0; i < clist.getLength(); i++) {
				OdfElement node = (OdfElement) clist.item(i);
				if(isCopyStyle){
					insertOdfElement(referenceParagraph.getOdfElement(), sourceDocument, node, true);
				}
				else {
					insertOdfElementwithoutstyle(referenceParagraph.getOdfElement(), sourceDocument, node, true);
				}
			}
		} catch (Exception e) {
			Logger.getLogger(TextDocument.class.getName()).log(Level.SEVERE, null, e);
		}
	}

	private FormContainerImpl getFormContainerImpl() {
		if (formContainerImpl == null) {
			formContainerImpl = new FormContainerImpl();
		}
		return formContainerImpl;
	}

	private class FormContainerImpl extends AbstractFormContainer {

		public OfficeFormsElement getFormContainerElement() {
			OfficeFormsElement forms = null;
			try {
				OfficeTextElement root = getContentRoot();
				forms = OdfElement.findFirstChildNode(OfficeFormsElement.class,
						root);
				if (forms == null) {
					Node firstChild = root.getFirstChild();
					OfficeFormsElement officeForms = ((OdfFileDom) getContentDom())
							.newOdfElement(OfficeFormsElement.class);
					forms = (OfficeFormsElement) root.insertBefore(officeForms,
							firstChild);
				}
				return forms;
			} catch (Exception e) {
				Logger.getLogger(TextDocument.class.getName()).log(
						Level.SEVERE, null, e);
			}
			return forms;
		}

	}

	/**
	 * Create a form with specified name in this text document.
	 * 
	 * @see FormContainer#createForm(String)
	 */
	public Form createForm(String name) {
		return getFormContainerImpl().createForm(name);
	}

	/**
	 * Get a form iterator to traverse all the forms in this document.
	 * 
	 * @see FormContainer#getFormIterator()
	 */
	public Iterator<Form> getFormIterator() {
		return getFormContainerImpl().getFormIterator();
	}

	/**
	 * Remove a form with the specified name in this document.
	 * 
	 * @see FormContainer#removeForm(Form)
	 */
	public boolean removeForm(Form form) {
		return getFormContainerImpl().removeForm(form);
	}

//	@Override
	public Form getFormByName(String name) {
		return getFormContainerImpl().getFormByName(name);
	}

//	@Override
	public OfficeFormsElement getFormContainerElement() {
		return getFormContainerImpl().getFormContainerElement();
	}

//	@Override
	public boolean getApplyDesignMode() {
		return getFormContainerImpl().getApplyDesignMode();
	}

//	@Override
	public boolean getAutomaticFocus() {
		return getFormContainerImpl().getAutomaticFocus();
	}

//	@Override
	public void setApplyDesignMode(boolean isDesignMode) {
		getFormContainerImpl().setApplyDesignMode(isDesignMode);

	}

//	@Override
	public void setAutomaticFocus(boolean isAutoFocus) {
		getFormContainerImpl().setAutomaticFocus(isAutoFocus);

	}

//	@Override
	public Control createDrawControl() {
		OdfElement parent = this.getDrawControlContainerElement();
		OdfFileDom ownerDom = (OdfFileDom) parent.getOwnerDocument();
		DrawControlElement element = ownerDom
				.newOdfElement(DrawControlElement.class);
		Node refChild = OdfElement.findFirstChildNode(
				TextSequenceDeclsElement.class, parent);
		parent.insertBefore(element, refChild.getNextSibling());
		Control control = new Control(element);
		Component.registerComponent(control, element);
		return control;
	}

//	@Override
	public OdfElement getDrawControlContainerElement() {
		OdfElement element = null;
		try {
			element = this.getContentRoot();
		} catch (Exception e) {
			Logger.getLogger(TextDocument.class.getName()).log(Level.SEVERE,
					null, e);
		}
		return element;
	}

}