Adding upstream version 4:7.4.7.upstream/4%7.4.7upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 1724 insertions, 0 deletions

diff --git a/odk/examples/DevelopersGuide/Text/TextDocuments.java b/odk/examples/DevelopersGuide/Text/TextDocuments.java
new file mode 100644
index 000000000..1a1a82762
--- /dev/null
+++ b/odk/examples/DevelopersGuide/Text/TextDocuments.java
@@ -0,0 +1,1724 @@
+/* -*- Mode: Java; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*************************************************************************
+ *
+ *  The Contents of this file are made available subject to the terms of
+ *  the BSD license.
+ *
+ *  Copyright 2000, 2010 Oracle and/or its affiliates.
+ *  All rights reserved.
+ *
+ *  Redistribution and use in source and binary forms, with or without
+ *  modification, are permitted provided that the following conditions
+ *  are met:
+ *  1. Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *  2. Redistributions in binary form must reproduce the above copyright
+ *     notice, this list of conditions and the following disclaimer in the
+ *     documentation and/or other materials provided with the distribution.
+ *  3. Neither the name of Sun Microsystems, Inc. nor the names of its
+ *     contributors may be used to endorse or promote products derived
+ *     from this software without specific prior written permission.
+ *
+ *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ *  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ *  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+ *  FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+ *  COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+ *  INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+ *  BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
+ *  OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ *  ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
+ *  TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
+ *  USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ *************************************************************************/
+
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.Random;
+
+import com.sun.star.awt.Point;
+import com.sun.star.awt.Size;
+import com.sun.star.beans.PropertyValue;
+import com.sun.star.beans.XPropertySet;
+import com.sun.star.container.XEnumeration;
+import com.sun.star.container.XEnumerationAccess;
+import com.sun.star.container.XIndexAccess;
+import com.sun.star.container.XIndexReplace;
+import com.sun.star.container.XNameAccess;
+import com.sun.star.container.XNameContainer;
+import com.sun.star.container.XNamed;
+import com.sun.star.drawing.XDrawPageSupplier;
+import com.sun.star.drawing.XShape;
+import com.sun.star.drawing.XShapes;
+import com.sun.star.frame.XComponentLoader;
+import com.sun.star.frame.XController;
+import com.sun.star.frame.XDesktop;
+import com.sun.star.frame.XModel;
+import com.sun.star.frame.XStorable;
+import com.sun.star.lang.XComponent;
+import com.sun.star.lang.XMultiComponentFactory;
+import com.sun.star.lang.XMultiServiceFactory;
+import com.sun.star.lang.XServiceInfo;
+import com.sun.star.style.NumberingType;
+import com.sun.star.style.XStyle;
+import com.sun.star.style.XStyleFamiliesSupplier;
+import com.sun.star.text.ControlCharacter;
+import com.sun.star.text.ReferenceFieldPart;
+import com.sun.star.text.ReferenceFieldSource;
+import com.sun.star.text.TextColumn;
+import com.sun.star.text.TextContentAnchorType;
+import com.sun.star.text.XAutoTextEntry;
+import com.sun.star.text.XAutoTextGroup;
+import com.sun.star.text.XBookmarksSupplier;
+import com.sun.star.text.XDependentTextField;
+import com.sun.star.text.XDocumentIndex;
+import com.sun.star.text.XFootnote;
+import com.sun.star.text.XFootnotesSupplier;
+import com.sun.star.text.XPageCursor;
+import com.sun.star.text.XParagraphCursor;
+import com.sun.star.text.XReferenceMarksSupplier;
+import com.sun.star.text.XRelativeTextContentInsert;
+import com.sun.star.text.XSentenceCursor;
+import com.sun.star.text.XSimpleText;
+import com.sun.star.text.XText;
+import com.sun.star.text.XTextColumns;
+import com.sun.star.text.XTextContent;
+import com.sun.star.text.XTextCursor;
+import com.sun.star.text.XTextDocument;
+import com.sun.star.text.XTextField;
+import com.sun.star.text.XTextFieldsSupplier;
+import com.sun.star.text.XTextFrame;
+import com.sun.star.text.XTextRange;
+import com.sun.star.text.XTextTable;
+import com.sun.star.text.XTextTableCursor;
+import com.sun.star.text.XTextTablesSupplier;
+import com.sun.star.text.XTextViewCursor;
+import com.sun.star.text.XTextViewCursorSupplier;
+import com.sun.star.text.XWordCursor;
+import com.sun.star.uno.UnoRuntime;
+import com.sun.star.uno.XComponentContext;
+import com.sun.star.util.XRefreshable;
+import com.sun.star.view.XPrintable;
+
+
+public class TextDocuments {
+    // adjust these constant to your local printer!
+    private static String sOutputDir;
+
+    private static final String aPrinterName = "\\\\so-print\\xml3sof";
+
+    private XComponentContext mxRemoteContext = null;
+    private XMultiComponentFactory mxRemoteServiceManager = null;
+    private XTextDocument mxDoc = null;
+    private XMultiServiceFactory mxDocFactory = null;
+    private XMultiServiceFactory mxFactory = null;
+    private XText mxDocText = null;
+    private XTextCursor mxDocCursor = null;
+    private XTextContent mxFishSection = null;
+    private Random maRandom = null;
+
+    /**
+     * @param args the command line arguments
+     */
+    public static void main(String[] args) {
+        TextDocuments textDocuments1 = new TextDocuments();
+        try {
+            // output directory for store test;
+            sOutputDir = args[0];
+
+            textDocuments1.runDemo();
+        } catch (java.lang.Exception e) {
+            System.out.println(e.getMessage());
+            e.printStackTrace();
+        } finally {
+            System.exit(0);
+        }
+    }
+
+    protected void runDemo() throws java.lang.Exception {
+            storePrintExample(); // depends on printer name
+            templateExample();
+            viewCursorExample(); // makes changes to the current document,
+                                 // use with care
+            editingExample();
+    }
+
+    /** Sample for use of templates
+     *  This sample uses the file TextTemplateWithUserFields.odt from the Samples
+     *  folder. The file contains a number of User text fields (Variables - User)
+     *  and a bookmark which we use to fill in various values
+     */
+    protected void templateExample() throws java.lang.Exception {
+        // create a small hashtable that simulates a rowset
+        HashMap<String,String> recipient = new HashMap<String,String>();
+        recipient.put("Company", "Manatee Books");
+        recipient.put("Contact", "Rod Martin");
+        recipient.put("ZIP", "34567");
+        recipient.put("City", "Fort Lauderdale");
+        recipient.put("State", "Florida");
+
+        // load template with User fields and bookmark
+        java.io.File sourceFile = new java.io.File("TextTemplateWithUserFields.odt");
+        StringBuffer sTemplateFileUrl = new StringBuffer("file:///");
+        sTemplateFileUrl.append(sourceFile.getCanonicalPath().replace('\\', '/'));
+
+        XComponent xTemplateComponent =
+            newDocComponentFromTemplate( sTemplateFileUrl.toString() );
+
+        // get XTextFieldsSupplier, XBookmarksSupplier interfaces
+        XTextFieldsSupplier xTextFieldsSupplier = UnoRuntime.queryInterface(XTextFieldsSupplier.class,
+                                  xTemplateComponent);
+        XBookmarksSupplier xBookmarksSupplier = UnoRuntime.queryInterface(XBookmarksSupplier.class, xTemplateComponent);
+
+        // access the TextFields and the TextFieldMasters collections
+        XNameAccess xNamedFieldMasters = xTextFieldsSupplier.getTextFieldMasters();
+        XEnumerationAccess xEnumeratedFields = xTextFieldsSupplier.getTextFields();
+
+        // iterate over hashtable and insert values into field masters
+        for(Iterator<String> iter = recipient.keySet().iterator(); iter.hasNext(); ) {
+            // get column name
+            String key = iter.next();
+
+            // access corresponding field master
+            Object fieldMaster = xNamedFieldMasters.getByName(
+                "com.sun.star.text.fieldmaster.User." + key);
+
+            // query the XPropertySet interface, we need to set the Content property
+            XPropertySet xPropertySet = UnoRuntime.queryInterface(
+                XPropertySet.class, fieldMaster);
+
+            // insert the column value into field master
+            xPropertySet.setPropertyValue("Content", recipient.get(key));
+        }
+        // afterwards we must refresh the textfields collection
+        XRefreshable xRefreshable = UnoRuntime.queryInterface(
+            XRefreshable.class, xEnumeratedFields);
+        xRefreshable.refresh();
+
+        // accessing the Bookmarks collection of the document
+        XNameAccess xNamedBookmarks = xBookmarksSupplier.getBookmarks();
+
+        // find the bookmark named "Subscription"
+        Object bookmark = xNamedBookmarks.getByName("Subscription");
+        // we need its XTextRange which is available from getAnchor(),
+        // so query for XTextContent
+        XTextContent xBookmarkContent = UnoRuntime.queryInterface(
+            XTextContent.class, bookmark);
+        // get the anchor of the bookmark (its XTextRange)
+        XTextRange xBookmarkRange = xBookmarkContent.getAnchor();
+        // set string at the bookmark position
+        xBookmarkRange.setString("subscription for the Manatee Journal");
+
+    }
+
+    /** Sample for document changes, starting at the current view cursor position
+     *  The sample changes the paragraph style and the character style at the
+     *  current view cursor selection Open the sample file ViewCursorExampleFile,
+     *  select some text and run the example.
+     *  The current paragraph will be set to Quotations paragraph style.
+     *  The selected text will be set to Quotation character style.
+     */
+    private void viewCursorExample() throws java.lang.Exception {
+        // get the remote service manager
+        mxRemoteServiceManager = this.getRemoteServiceManager();
+        // get the Desktop service
+        Object desktop = mxRemoteServiceManager.createInstanceWithContext(
+            "com.sun.star.frame.Desktop", mxRemoteContext);
+        // query its XDesktop interface, we need the current component
+        XDesktop xDesktop = UnoRuntime.queryInterface(
+            XDesktop.class, desktop);
+        // retrieve the current component and access the controller
+        XComponent xCurrentComponent = xDesktop.getCurrentComponent();
+        XModel xModel = UnoRuntime.queryInterface(XModel.class,
+                                                          xCurrentComponent);
+        XController xController = xModel.getCurrentController();
+        // the controller gives us the TextViewCursor
+        XTextViewCursorSupplier xViewCursorSupplier =
+            UnoRuntime.queryInterface(
+            XTextViewCursorSupplier.class, xController);
+        XTextViewCursor xViewCursor = xViewCursorSupplier.getViewCursor();
+
+        // query its XPropertySet interface, we want to set character and paragraph
+        // properties
+        XPropertySet xCursorPropertySet = UnoRuntime.queryInterface(
+            XPropertySet.class, xViewCursor);
+        // set the appropriate properties for character and paragraph style
+        xCursorPropertySet.setPropertyValue("CharStyleName", "Quotation");
+        xCursorPropertySet.setPropertyValue("ParaStyleName", "Quotations");
+        // print the current page number
+        XPageCursor xPageCursor = UnoRuntime.queryInterface(
+            XPageCursor.class, xViewCursor);
+        System.out.println("The current page number is " + xPageCursor.getPage());
+        // the model cursor is much more powerful, so
+        // we create a model cursor at the current view cursor position with the
+        // following steps:
+        // get the Text service from the TextViewCursor, it is an XTextRange:
+         XText xDocumentText = xViewCursor.getText();
+        // create a model cursor from the viewcursor
+        XTextCursor xModelCursor = xDocumentText.createTextCursorByRange(
+            xViewCursor.getStart());
+        // now we could query XWordCursor, XSentenceCursor and XParagraphCursor
+        // or XDocumentInsertable, XSortable or XContentEnumerationAccess
+        // and work with the properties of com.sun.star.text.TextCursor
+        // in this case we just go to the end of the paragraph and add some text.
+        XParagraphCursor xParagraphCursor = UnoRuntime.queryInterface(XParagraphCursor.class, xModelCursor);
+        // goto the end of the paragraph
+        xParagraphCursor.gotoEndOfParagraph(false);
+        xParagraphCursor.setString(" ***** Fin de semana! ******");
+    }
+
+
+    /** Sample for the various editing facilities described in the
+     * developer's manual
+     */
+    private void editingExample () throws java.lang.Exception {
+        // create empty swriter document
+        XComponent xEmptyWriterComponent = newDocComponent("swriter");
+        // query its XTextDocument interface to get the text
+        mxDoc = UnoRuntime.queryInterface(
+            XTextDocument.class, xEmptyWriterComponent);
+
+        // get a reference to the body text of the document
+        mxDocText = mxDoc.getText();
+
+        // Get a reference to the document's property set. This contains document
+        // information like the current word count
+        UnoRuntime.queryInterface(XPropertySet.class, mxDoc );
+
+        // Simple text insertion example
+        BodyTextExample ();
+        // Example using text ranges to insert strings at the beginning or end
+        // of a text range
+        TextRangeExample ();
+        // Create a document cursor and remember it, it will be used in most
+        // of the following examples
+        mxDocCursor = mxDocText.createTextCursor();
+        // Demonstrate some of the different cursor types (word, sentence)
+        TextCursorExample ();
+
+        // Access the text document's multi service factory, which we will need
+        // for most of the following examples
+        mxDocFactory = UnoRuntime.queryInterface(
+            XMultiServiceFactory.class, mxDoc );
+
+        // Examples of text fields, dependent text fields and field masters
+        TextFieldExample ();
+
+        // Example of using an XEnumerationAccess to iterate over paragraphs and
+        // set properties of each paragraph as we do so
+        ParagraphExample ();
+
+        // Example of creating and manipulating a text frame
+        TextFrameExample ();
+
+        // Example of creating and manipulating a text table, text table rows
+        // and text table cells get a new random generator
+        maRandom = new Random();
+        TextTableExample ();
+
+        // Example of creating, inserting and manipulating text sections, as
+        // well as an example of how to refresh the document
+        TextSectionExample ();
+
+        // Example of creating a text section over a block of text and formatting
+        // the text section into columns, as well as how to insert an empty
+        // paragraph using the XRelativeTextContentInsert
+        TextColumnsExample ();
+
+        // Example of creating the NumberingRules service and adjusting
+        // NumberingTypes and NumberingLevels
+        NumberingExample ();
+
+        // Example of how to use the XStyleFamiliesSupplier interface of the
+        // document and how to create, insert and apply styles
+        StylesExample ();
+        IndexExample ();
+
+        // Example of how to create and manipulate reference marks and GetReference
+        // text fields
+        ReferenceExample ();
+
+        // Example of how to create and insert Footnotes and how to use the
+        // XFootnotesSupplier interface of the document
+        FootnoteExample ();
+
+        // This method demonstrates how to create shapes from the document factory
+        // and how to access the draw page of the document using the
+        // XDrawPageSupplier interface
+        DrawPageExample ();
+
+        mxFactory = UnoRuntime.queryInterface(
+            XMultiServiceFactory.class, mxRemoteServiceManager);
+        // This example demonstrates the use of the AutoTextContainer,
+        // AutoTextGroup and AutoTextEntry services and shows how to create,
+        // insert and modify auto text blocks
+        AutoTextExample ();
+    }
+
+    protected void storePrintExample() throws java.lang.Exception {
+        // get the remote service manager
+        mxRemoteServiceManager = this.getRemoteServiceManager();
+        // retrieve the Desktop object, we need its XComponentLoader
+        Object desktop = mxRemoteServiceManager.createInstanceWithContext(
+            "com.sun.star.frame.Desktop", mxRemoteContext);
+        XComponentLoader xComponentLoader = UnoRuntime.queryInterface(XComponentLoader.class, desktop);
+        PropertyValue[] loadProps = new PropertyValue[0];
+
+        java.io.File sourceFile = new java.io.File("PrintDemo.odt");
+        StringBuffer sLoadFileUrl = new StringBuffer("file:///");
+        sLoadFileUrl.append(sourceFile.getCanonicalPath().replace('\\', '/'));
+
+        XComponent xDoc = xComponentLoader.loadComponentFromURL(
+            sLoadFileUrl.toString(), "_blank", 0, loadProps);
+
+        if ( xDoc != null ) {
+            sourceFile = new java.io.File(sOutputDir);
+            StringBuffer sStoreFileUrl = new StringBuffer();
+            sStoreFileUrl.append(sourceFile.toURI().toURL().toString());
+            sStoreFileUrl.append("somepopularfileformat.doc");
+
+            storeDocComponent(xDoc, sStoreFileUrl.toString() );
+            printDocComponent(xDoc);
+        }
+    }
+
+    private XMultiComponentFactory getRemoteServiceManager()
+        throws java.lang.Exception
+    {
+        if (mxRemoteContext == null && mxRemoteServiceManager == null) {
+            // get the remote office context. If necessary a new office
+            // process is started
+            mxRemoteContext = com.sun.star.comp.helper.Bootstrap.bootstrap();
+            System.out.println("Connected to a running office ...");
+            mxRemoteServiceManager = mxRemoteContext.getServiceManager();
+        }
+        return mxRemoteServiceManager;
+    }
+
+    protected XComponent newDocComponent(String docType)
+        throws java.lang.Exception
+    {
+        String loadUrl = "private:factory/" + docType;
+        mxRemoteServiceManager = this.getRemoteServiceManager();
+        Object desktop = mxRemoteServiceManager.createInstanceWithContext(
+            "com.sun.star.frame.Desktop", mxRemoteContext);
+        XComponentLoader xComponentLoader = UnoRuntime.queryInterface(XComponentLoader.class, desktop);
+        PropertyValue[] loadProps = new PropertyValue[0];
+        return xComponentLoader.loadComponentFromURL(loadUrl, "_blank",
+                                                     0, loadProps);
+    }
+
+    /** Load a document as template
+     */
+    protected XComponent newDocComponentFromTemplate(String loadUrl)
+        throws java.lang.Exception
+    {
+        // get the remote service manager
+        mxRemoteServiceManager = this.getRemoteServiceManager();
+        // retrieve the Desktop object, we need its XComponentLoader
+        Object desktop = mxRemoteServiceManager.createInstanceWithContext(
+            "com.sun.star.frame.Desktop", mxRemoteContext);
+        XComponentLoader xComponentLoader = UnoRuntime.queryInterface(XComponentLoader.class, desktop);
+
+        // define load properties according to com.sun.star.document.MediaDescriptor
+        // the boolean property AsTemplate tells the office to create a new document
+        // from the given file
+        PropertyValue[] loadProps = new PropertyValue[1];
+        loadProps[0] = new PropertyValue();
+        loadProps[0].Name = "AsTemplate";
+        loadProps[0].Value = Boolean.TRUE;
+        // load
+        return xComponentLoader.loadComponentFromURL(loadUrl, "_blank",
+                                                     0, loadProps);
+    }
+
+    /** Load a document with arguments (text purposes)
+     */
+    protected void storeDocComponent(XComponent xDoc, String storeUrl)
+        throws java.lang.Exception
+    {
+
+        XStorable xStorable = UnoRuntime.queryInterface(
+            XStorable.class, xDoc);
+        PropertyValue[] storeProps = new PropertyValue[1];
+        storeProps[0] = new PropertyValue();
+        storeProps[0].Name = "FilterName";
+        storeProps[0].Value = "MS Word 97";
+
+        System.out.println("... store \"PrintDemo.odt\" to \"" + storeUrl + "\".");
+        xStorable.storeAsURL(storeUrl, storeProps);
+    }
+
+    protected void printDocComponent(XComponent xDoc) throws java.lang.Exception {
+        XPrintable xPrintable = UnoRuntime.queryInterface(
+            XPrintable.class, xDoc);
+        PropertyValue[] printerDesc = new PropertyValue[1];
+        printerDesc[0] = new PropertyValue();
+        printerDesc[0].Name = "Name";
+        printerDesc[0].Value = aPrinterName;
+
+        xPrintable.setPrinter(printerDesc);
+
+        PropertyValue[] printOpts = new PropertyValue[1];
+        printOpts[0] = new PropertyValue();
+        printOpts[0].Name = "Pages";
+        printOpts[0].Value = "1";
+
+        xPrintable.print(printOpts);
+    }
+
+    // Setting the whole text of a document as one string
+    protected void BodyTextExample ()
+    {
+        // Body Text and TextDocument example
+        try
+        {
+            // demonstrate simple text insertion
+            mxDocText.setString ( "This is the new body text of the document."
+                                  + "\n\nThis is on the second line.\n\n" );
+        }
+        catch ( Exception e )
+        {
+            e.printStackTrace();
+        }
+    }
+
+    // Adding a string at the end or the beginning of text
+    protected void TextRangeExample ()
+    {
+        try
+        {
+            // Get a text range referring to the beginning of the text document
+            XTextRange xStart = mxDocText.getStart();
+            // use setString to insert text at the beginning
+            xStart.setString ( "This is text inserted at the beginning.\n\n" );
+            // Get a text range referring to the end of the text document
+            XTextRange xEnd = mxDocText.getEnd();
+            // use setString to insert text at the end
+            xEnd.setString ( "This is text inserted at the end.\n\n" );
+        }
+        catch ( Exception e )
+        {
+            e.printStackTrace();
+        }
+    }
+
+    /** moving a text cursor, selecting text and overwriting it
+    */
+    protected void TextCursorExample ()
+    {
+        try
+        {
+            // First, get the XSentenceCursor interface of our text cursor
+            XSentenceCursor xSentenceCursor = UnoRuntime.queryInterface(XSentenceCursor.class, mxDocCursor );
+            // Goto the next cursor, without selecting it
+            xSentenceCursor.gotoNextSentence( false );
+            // Get the XWordCursor interface of our text cursor
+            XWordCursor xWordCursor = UnoRuntime.queryInterface(
+                XWordCursor.class, mxDocCursor );
+            // Skip the first four words of this sentence and select the fifth
+            xWordCursor.gotoNextWord( false );
+            xWordCursor.gotoNextWord( false );
+            xWordCursor.gotoNextWord( false );
+            xWordCursor.gotoNextWord( false );
+            xWordCursor.gotoNextWord( true );
+            // Use the XSimpleText interface to insert a word at the current cursor
+            // location, over-writing the current selection (the fifth word
+            // selected above)
+            mxDocText.insertString ( xWordCursor, "old ", true );
+
+            // Access the property set of the cursor, and set the currently
+            // selected text (which is the string we just inserted) to be bold
+            XPropertySet xCursorProps = UnoRuntime.queryInterface(
+                XPropertySet.class, mxDocCursor );
+            xCursorProps.setPropertyValue ( "CharWeight",
+                             new Float(com.sun.star.awt.FontWeight.BOLD) );
+
+            // replace the '.' at the end of the sentence with a new string
+            xSentenceCursor.gotoEndOfSentence( false );
+            xWordCursor.gotoPreviousWord( true );
+            mxDocText.insertString (xWordCursor,
+                                    ", which has been changed with text cursors!",
+                                    true);
+        }
+        catch ( Exception e )
+        {
+            e.printStackTrace();
+        }
+    }
+
+    /** This method inserts both a date field and a user field containing the
+     * number '42'
+     */
+    protected void TextFieldExample ()
+    {
+        try
+        {
+            // Use the text document's factory to create a DateTime text field,
+            // and access its XTextField interface
+            XTextField xDateField = UnoRuntime.queryInterface (
+                XTextField.class, mxDocFactory.createInstance (
+                    "com.sun.star.text.TextField.DateTime" ) );
+
+            // Insert it at the end of the document
+            mxDocText.insertTextContent ( mxDocText.getEnd(), xDateField, false );
+
+            // Use the text document's factory to create a user text field,
+            // and access its XDependentTextField interface
+            XDependentTextField xUserField =
+                UnoRuntime.queryInterface (
+                XDependentTextField.class, mxDocFactory.createInstance (
+                    "com.sun.star.text.TextField.User" ) );
+
+            // Create a fieldmaster for our newly created User Text field, and
+            // access its XPropertySet interface
+            XPropertySet xMasterPropSet = UnoRuntime.queryInterface(
+                XPropertySet.class, mxDocFactory.createInstance (
+                    "com.sun.star.text.fieldmaster.User" ) );
+
+            // Set the name and value of the FieldMaster
+            xMasterPropSet.setPropertyValue ( "Name", "UserEmperor" );
+            xMasterPropSet.setPropertyValue ( "Value", Integer.valueOf( 42 ) );
+
+            // Attach the field master to the user field
+            xUserField.attachTextFieldMaster ( xMasterPropSet );
+
+            // Move the cursor to the end of the document
+            mxDocCursor.gotoEnd( false );
+            // insert a paragraph break using the XSimpleText interface
+            mxDocText.insertControlCharacter (
+                mxDocCursor, ControlCharacter.PARAGRAPH_BREAK, false );
+
+            // Insert the user field at the end of the document
+            mxDocText.insertTextContent ( mxDocText.getEnd(), xUserField, false );
+        }
+        catch ( Exception e )
+        {
+            e.printStackTrace();
+        }
+    }
+
+    /** This method demonstrates how to iterate over paragraphs
+     */
+    protected void ParagraphExample ()
+    {
+        try
+        {
+            // The service 'com.sun.star.text.Text' supports the XEnumerationAccess
+            // interface to provide an enumeration of the paragraphs contained by
+            // the text the service refers to.
+
+            // Here, we access this interface
+            XEnumerationAccess xParaAccess = UnoRuntime.queryInterface(XEnumerationAccess.class, mxDocText );
+            // Call the XEnumerationAccess's only method to access the actual
+            // Enumeration
+            XEnumeration xParaEnum = xParaAccess.createEnumeration();
+
+            // While there are paragraphs, do things to them
+            while ( xParaEnum.hasMoreElements() )
+            {
+                // Get a reference to the next paragraphs XServiceInfo interface.
+                // TextTables are also part of this enumeration access, so we ask
+                // the element if it is a TextTable, if it doesn't support the
+                // com.sun.star.text.TextTable service, then it is safe to assume
+                // that it really is a paragraph
+                XServiceInfo xInfo = UnoRuntime.queryInterface(
+                    XServiceInfo.class, xParaEnum.nextElement() );
+                if ( !xInfo.supportsService ( "com.sun.star.text.TextTable" ) )
+                {
+                    // Access the paragraph's property set...the properties in this
+                    // property set are listed in:
+                    // com.sun.star.style.ParagraphProperties
+                    XPropertySet xSet = UnoRuntime.queryInterface(
+                        XPropertySet.class, xInfo );
+                    // Set the justification to be center justified
+                    xSet.setPropertyValue ( "ParaAdjust",
+                             com.sun.star.style.ParagraphAdjust.CENTER );
+                }
+            }
+        }
+        catch ( Exception e )
+        {
+            e.printStackTrace();
+        }
+    }
+
+    /** This method returns a random double which isn't too high or too low
+     */
+    protected double getRandomDouble ()
+    {
+        return ( ( maRandom.nextInt() % 1000 ) * maRandom.nextDouble () );
+    }
+
+    /** This method sets the text colour of the cell referred to by sCellName to
+        white and inserts the string sText in it
+     */
+    protected static void insertIntoCell(String sCellName, String sText,
+                                         XTextTable xTable)
+    {
+        // Access the XText interface of the cell referred to by sCellName
+        XText xCellText = UnoRuntime.queryInterface(
+            XText.class, xTable.getCellByName ( sCellName ) );
+
+        // create a text cursor from the cells XText interface
+        XTextCursor xCellCursor = xCellText.createTextCursor();
+        // Get the property set of the cell's TextCursor
+        XPropertySet xCellCursorProps = UnoRuntime.queryInterface(
+            XPropertySet.class, xCellCursor );
+
+        try
+        {
+            // Set the colour of the text to white
+            xCellCursorProps.setPropertyValue( "CharColor", Integer.valueOf(16777215));
+        }
+        catch ( Exception e)
+        {
+            e.printStackTrace();
+        }
+        // Set the text in the cell to sText
+        xCellText.setString( sText );
+    }
+
+    /** This method shows how to create and insert a text table, as well as insert
+        text and formulae into the cells of the table
+     */
+    protected void TextTableExample ()
+    {
+        try
+        {
+            // Create a new table from the document's factory
+            XTextTable xTable = UnoRuntime.queryInterface(
+                XTextTable.class, mxDocFactory .createInstance(
+                    "com.sun.star.text.TextTable" ) );
+
+            // Specify that we want the table to have 4 rows and 4 columns
+            xTable.initialize( 4, 4 );
+
+            // Insert the table into the document
+            mxDocText.insertTextContent( mxDocCursor, xTable, false);
+            // Get an XIndexAccess of the table rows
+            XIndexAccess xRows = xTable.getRows();
+
+            // Access the property set of the first row (properties listed in
+            // service description: com.sun.star.text.TextTableRow)
+            XPropertySet xRow = UnoRuntime.queryInterface(
+                XPropertySet.class, xRows.getByIndex ( 0 ) );
+            // If BackTransparent is false, then the background color is visible
+            xRow.setPropertyValue( "BackTransparent", Boolean.FALSE);
+            // Specify the color of the background to be dark blue
+            xRow.setPropertyValue( "BackColor", Integer.valueOf(6710932));
+
+            // Access the property set of the whole table
+            XPropertySet xTableProps = UnoRuntime.queryInterface(
+                XPropertySet.class, xTable );
+            // We want visible background colors
+            xTableProps.setPropertyValue( "BackTransparent", Boolean.FALSE);
+            // Set the background colour to light blue
+            xTableProps.setPropertyValue( "BackColor", Integer.valueOf(13421823));
+
+            // set the text (and text colour) of all the cells in the first row
+            // of the table
+            insertIntoCell( "A1", "First Column", xTable );
+            insertIntoCell( "B1", "Second Column", xTable );
+            insertIntoCell( "C1", "Third Column", xTable );
+            insertIntoCell( "D1", "Results", xTable );
+
+            // Insert random numbers into the first this three cells of each
+            // remaining row
+            xTable.getCellByName( "A2" ).setValue( getRandomDouble() );
+            xTable.getCellByName( "B2" ).setValue( getRandomDouble() );
+            xTable.getCellByName( "C2" ).setValue( getRandomDouble() );
+
+            xTable.getCellByName( "A3" ).setValue( getRandomDouble() );
+            xTable.getCellByName( "B3" ).setValue( getRandomDouble() );
+            xTable.getCellByName( "C3" ).setValue( getRandomDouble() );
+
+            xTable.getCellByName( "A4" ).setValue( getRandomDouble() );
+            xTable.getCellByName( "B4" ).setValue( getRandomDouble() );
+            xTable.getCellByName( "C4" ).setValue( getRandomDouble() );
+
+            // Set the last cell in each row to be a formula that calculates
+            // the sum of the first three cells
+            xTable.getCellByName( "D2" ).setFormula( "sum <A2:C2>" );
+            xTable.getCellByName( "D3" ).setFormula( "sum <A3:C3>" );
+            xTable.getCellByName( "D4" ).setFormula( "sum <A4:C4>" );
+        }
+        catch (Exception e)
+        {
+            e.printStackTrace();
+        }
+    }
+    /** This method shows how to create and manipulate text frames
+     */
+    protected void TextFrameExample ()
+    {
+        try
+        {
+            // Use the document's factory to create a new text frame and
+            // immediately access its XTextFrame interface
+            XTextFrame xFrame = UnoRuntime.queryInterface (
+                XTextFrame.class, mxDocFactory.createInstance (
+                    "com.sun.star.text.TextFrame" ) );
+
+            // Access the XShape interface of the TextFrame
+            XShape xShape = UnoRuntime.queryInterface(XShape.class, xFrame);
+            // Access the XPropertySet interface of the TextFrame
+            XPropertySet xFrameProps = UnoRuntime.queryInterface(
+                XPropertySet.class, xFrame );
+
+            // Set the size of the new Text Frame using the XShape's 'setSize'
+            // method
+            Size aSize = new Size();
+            aSize.Height = 400;
+            aSize.Width = 15000;
+            xShape.setSize(aSize);
+            // Set the AnchorType to
+            // com.sun.star.text.TextContentAnchorType.AS_CHARACTER
+            xFrameProps.setPropertyValue( "AnchorType",
+                                          TextContentAnchorType.AS_CHARACTER );
+            // Go to the end of the text document
+            mxDocCursor.gotoEnd( false );
+            // Insert a new paragraph
+            mxDocText.insertControlCharacter (
+                mxDocCursor, ControlCharacter.PARAGRAPH_BREAK, false );
+            // Then insert the new frame
+            mxDocText.insertTextContent(mxDocCursor, xFrame, false);
+
+            // Access the XText interface of the text contained within the frame
+            XText xFrameText = xFrame.getText();
+            // Create a TextCursor over the frame's contents
+            XTextCursor xFrameCursor = xFrameText.createTextCursor();
+            // Insert some text into the frame
+            xFrameText.insertString(
+                xFrameCursor, "The first line in the newly created text frame.",
+                false );
+            xFrameText.insertString(
+                xFrameCursor, "\nThe second line in the new text frame.", false );
+            // Insert a paragraph break into the document (not the frame)
+            mxDocText.insertControlCharacter (
+                mxDocCursor, ControlCharacter.PARAGRAPH_BREAK, false );
+        }
+        catch (Exception e)
+        {
+            e.printStackTrace();
+        }
+    }
+
+    /** This example demonstrates the use of the AutoTextContainer, AutoTextGroup
+        and AutoTextEntry services and shows how to create, insert and modify
+        auto text blocks
+     */
+    protected void AutoTextExample ()
+    {
+        try
+        {
+            // Go to the end of the document
+            mxDocCursor.gotoEnd( false );
+            // Insert two paragraphs
+            mxDocText.insertControlCharacter ( mxDocCursor,
+                          ControlCharacter.PARAGRAPH_BREAK, false );
+            mxDocText.insertControlCharacter ( mxDocCursor,
+                          ControlCharacter.PARAGRAPH_BREAK, false );
+            // Position the cursor in the second paragraph
+            XParagraphCursor xParaCursor = UnoRuntime.queryInterface(XParagraphCursor.class, mxDocCursor );
+            xParaCursor.gotoPreviousParagraph ( false );
+
+            // Get an XNameAccess interface to all auto text groups from the
+            // document factory
+            XNameAccess xContainer = UnoRuntime.queryInterface(
+                XNameAccess.class, mxFactory.createInstance (
+                    "com.sun.star.text.AutoTextContainer" ) );
+
+            // Create a new table at the document factory
+            XTextTable xTable = UnoRuntime.queryInterface(
+                XTextTable.class, mxDocFactory .createInstance(
+                    "com.sun.star.text.TextTable" ) );
+
+            // Store the names of all auto text groups in an array of strings
+            String[] aGroupNames = xContainer.getElementNames();
+
+            // Make sure we have at least one group name
+            if ( aGroupNames.length > 0 )
+            {
+                // initialise the table to have a row for every autotext group
+                // in a single column + one additional row for a header
+                xTable.initialize( aGroupNames.length+1,1);
+
+                // Access the XPropertySet of the table
+                XPropertySet xTableProps = UnoRuntime.queryInterface(
+                    XPropertySet.class, xTable );
+
+                // We want a visible background
+                xTableProps.setPropertyValue( "BackTransparent",
+                                              Boolean.FALSE);
+
+                // We want the background to be light blue
+                xTableProps.setPropertyValue( "BackColor", Integer.valueOf(13421823));
+
+                // Inser the table into the document
+                mxDocText.insertTextContent( mxDocCursor, xTable, false);
+
+                // Get an XIndexAccess to all table rows
+                XIndexAccess xRows = xTable.getRows();
+
+                // Get the first row in the table
+                XPropertySet xRow = UnoRuntime.queryInterface(
+                    XPropertySet.class, xRows.getByIndex ( 0 ) );
+
+                // We want the background of the first row to be visible too
+                xRow.setPropertyValue( "BackTransparent", Boolean.FALSE);
+
+                // And let's make it dark blue
+                xRow.setPropertyValue( "BackColor", Integer.valueOf(6710932));
+
+                // Put a description of the table contents into the first cell
+                insertIntoCell( "A1", "AutoText Groups", xTable);
+
+                // Create a table cursor pointing at the second cell in the first
+                // column
+                XTextTableCursor xTableCursor = xTable.createCursorByCellName("A2");
+
+                // Loop over the group names
+                for ( int i = 0 ; i < aGroupNames.length ; i ++ )
+                {
+                    // Get the name of the current cell
+                    String sCellName = xTableCursor.getRangeName ();
+
+                    // Get the XText interface of the current cell
+                    XText xCellText = UnoRuntime.queryInterface (
+                        XText.class, xTable.getCellByName ( sCellName ) );
+
+                    // Set the cell contents of the current cell to be
+                    //the name of the of an autotext group
+                    xCellText.setString ( aGroupNames[i] );
+
+                    // Access the autotext group with this name
+                    XAutoTextGroup xGroup = UnoRuntime.queryInterface (XAutoTextGroup.class,
+                                   xContainer.getByName(aGroupNames[i]));
+
+                    // Get the titles of each autotext block in this group
+                    String [] aBlockNames = xGroup.getTitles();
+
+                    // Make sure that the autotext group contains at least one block
+                    if ( aBlockNames.length > 0 )
+                    {
+                        // Split the current cell vertically into two separate cells
+                        xTableCursor.splitRange ( (short) 1, false );
+
+                        // Put the cursor in the newly created right hand cell
+                        // and select it
+                        xTableCursor.goRight ( (short) 1, false );
+
+                        // Split this cell horizontally to make a separate cell
+                        // for each Autotext block
+                        if ( ( aBlockNames.length -1 ) > 0 )
+                            xTableCursor.splitRange (
+                                (short) (aBlockNames.length - 1), true );
+
+                        // loop over the block names
+                        for ( int j = 0 ; j < aBlockNames.length ; j ++ )
+                        {
+                            // Get the XText interface of the current cell
+                            xCellText = UnoRuntime.queryInterface (
+                                XText.class, xTable.getCellByName (
+                                    xTableCursor.getRangeName() ) );
+
+                            // Set the text contents of the current cell to the
+                            // title of an Autotext block
+                            xCellText.setString ( aBlockNames[j] );
+
+                            // Move the cursor down one cell
+                            xTableCursor.goDown( (short)1, false);
+                        }
+                    }
+                    // Go back to the cell we originally split
+                    xTableCursor.gotoCellByName ( sCellName, false );
+
+                                    // Go down one cell
+                    xTableCursor.goDown( (short)1, false);
+                }
+
+                XAutoTextGroup xGroup;
+                String [] aBlockNames;
+
+                // Add a depth so that we only generate 200 numbers before giving up
+                // on finding a random autotext group that contains autotext blocks
+                int nDepth = 0;
+                do
+                {
+                    // Generate a random, positive number which is lower than
+                    // the number of autotext groups
+                    int nRandom = Math.abs ( maRandom.nextInt() %
+                                             aGroupNames.length );
+
+                    // Get the autotext group at this name
+                    xGroup  = UnoRuntime.queryInterface (
+                        XAutoTextGroup.class, xContainer.getByName (
+                            aGroupNames[ nRandom ] ) );
+
+                    // Fill our string array with the names of all the blocks in
+                    // this group
+                    aBlockNames = xGroup.getElementNames();
+
+                    // increment our depth counter
+                    ++nDepth;
+                }
+                while ( nDepth < 200 && aBlockNames.length == 0 );
+                // If we managed to find a group containing blocks...
+                if ( aBlockNames.length > 0 )
+                {
+                    // Pick a random block in this group and get its
+                    // XAutoTextEntry interface
+                    int nRandom = Math.abs ( maRandom.nextInt()
+                                             % aBlockNames.length );
+                    XAutoTextEntry xEntry = UnoRuntime.queryInterface (
+                        XAutoTextEntry.class, xGroup.getByName (
+                            aBlockNames[ nRandom ] ) );
+                    // insert the modified autotext block at the end of the document
+                    xEntry.applyTo ( mxDocCursor );
+
+                    // Get the titles of all text blocks in this AutoText group
+                    String [] aBlockTitles = xGroup.getTitles();
+
+                    // Get the XNamed interface of the autotext group
+                    XNamed xGroupNamed = UnoRuntime.queryInterface (
+                        XNamed.class, xGroup );
+
+                    // Output the short cut and title of the random block
+                    //and the name of the group it's from
+                    System.out.println ( "Inserted the Autotext '" +
+                                         aBlockTitles[nRandom]
+                                         + "', shortcut '" + aBlockNames[nRandom]
+                                         + "' from group '"
+                                         + xGroupNamed.getName());
+                }
+            }
+
+            // Go to the end of the document
+            mxDocCursor.gotoEnd( false );
+            // Insert new paragraph
+            mxDocText.insertControlCharacter (
+                mxDocCursor, ControlCharacter.PARAGRAPH_BREAK, false );
+
+            // Position cursor in new paragraph
+            xParaCursor.gotoPreviousParagraph ( false );
+
+            // Insert a string in the new paragraph
+            mxDocText.insertString ( mxDocCursor,
+                                     "Some text for a new autotext block", false );
+
+            // Go to the end of the document
+            mxDocCursor.gotoEnd( false );
+        }
+        catch (Exception e)
+        {
+            e.printStackTrace();
+        }
+    }
+
+    /** This method demonstrates how to insert indexes and index marks
+     */
+    protected void IndexExample ()
+    {
+        try
+        {
+            // Go to the end of the document
+            mxDocCursor.gotoEnd( false );
+            // Insert a new paragraph and position the cursor in it
+            mxDocText.insertControlCharacter ( mxDocCursor,
+                          ControlCharacter.PARAGRAPH_BREAK, false );
+            XParagraphCursor xParaCursor = UnoRuntime.queryInterface( XParagraphCursor.class, mxDocCursor );
+            xParaCursor.gotoPreviousParagraph ( false );
+
+            // Create a new ContentIndexMark and get its XPropertySet interface
+            XPropertySet xEntry = UnoRuntime.queryInterface(
+                XPropertySet.class,
+                mxDocFactory.createInstance("com.sun.star.text.ContentIndexMark"));
+
+            // Set the text to be displayed in the index
+            xEntry.setPropertyValue(
+                "AlternativeText", "Big dogs! Falling on my head!");
+
+            // The Level property _must_ be set
+            xEntry.setPropertyValue ( "Level", Short.valueOf( (short) 1 ) );
+
+            // Create a ContentIndex and access its XPropertySet interface
+            XPropertySet xIndex = UnoRuntime.queryInterface(
+                XPropertySet.class,
+                mxDocFactory.createInstance ( "com.sun.star.text.ContentIndex" ) );
+
+            // Again, the Level property _must_ be set
+            xIndex.setPropertyValue ( "Level", Short.valueOf( (short) 10 ) );
+
+            // Access the XTextContent interfaces of both the Index and the
+            // IndexMark
+            XTextContent xIndexContent = UnoRuntime.queryInterface(
+                XTextContent.class, xIndex );
+            XTextContent xEntryContent = UnoRuntime.queryInterface(
+                XTextContent.class, xEntry );
+
+            // Insert both in the document
+            mxDocText.insertTextContent ( mxDocCursor, xEntryContent, false );
+            mxDocText.insertTextContent ( mxDocCursor, xIndexContent, false );
+
+            // Get the XDocumentIndex interface of the Index
+            XDocumentIndex xDocIndex = UnoRuntime.queryInterface(
+                XDocumentIndex.class, xIndex );
+
+            // And call its update method
+            xDocIndex.update();
+        }
+        catch (Exception e)
+        {
+            e.printStackTrace();
+        }
+    }
+
+    /** This method demonstrates how to create and insert reference marks, and
+     * GetReference Text Fields
+     */
+    protected void ReferenceExample ()
+    {
+        try
+        {
+            // Go to the end of the document
+            mxDocCursor.gotoEnd( false );
+
+            // Insert a paragraph break
+            mxDocText.insertControlCharacter (
+                mxDocCursor, ControlCharacter.PARAGRAPH_BREAK, false );
+
+            // Get the Paragraph cursor
+            XParagraphCursor xParaCursor = UnoRuntime.queryInterface( XParagraphCursor.class, mxDocCursor );
+
+            // Move the cursor into the new paragraph
+            xParaCursor.gotoPreviousParagraph ( false );
+
+            // Create a new ReferenceMark and get its XNamed interface
+            XNamed xRefMark = UnoRuntime.queryInterface(XNamed.class,
+                  mxDocFactory.createInstance ("com.sun.star.text.ReferenceMark"));
+
+            // Set the name to TableHeader
+            xRefMark.setName ( "TableHeader" );
+
+            // Get the TextTablesSupplier interface of the document
+            XTextTablesSupplier xTableSupplier = UnoRuntime.queryInterface(XTextTablesSupplier.class, mxDoc);
+
+            // Get an XIndexAccess of TextTables
+            XIndexAccess xTables = UnoRuntime.queryInterface(
+                XIndexAccess.class, xTableSupplier.getTextTables());
+
+            // We've only inserted one table, so get the first one from index zero
+            XTextTable xTable = UnoRuntime.queryInterface (
+                XTextTable.class, xTables.getByIndex( 0 ) );
+
+            // Get the first cell from the table
+            XText xTableText = UnoRuntime.queryInterface(
+                XText.class, xTable.getCellByName ( "A1" ) );
+
+            // Get a text cursor for the first cell
+            XTextCursor xTableCursor = xTableText.createTextCursor();
+
+            // Get the XTextContent interface of the reference mark so we can
+            // insert it
+            XTextContent xContent = UnoRuntime.queryInterface (
+                XTextContent.class, xRefMark );
+
+            // Insert the reference mark into the first cell of the table
+            xTableText.insertTextContent ( xTableCursor, xContent, false );
+
+            // Create a 'GetReference' text field to refer to the reference mark
+            // we just inserted, and get its XPropertySet interface
+            XPropertySet xFieldProps = UnoRuntime.queryInterface(
+                XPropertySet.class, mxDocFactory.createInstance (
+                    "com.sun.star.text.TextField.GetReference" ) );
+
+            // Get the XReferenceMarksSupplier interface of the document
+            XReferenceMarksSupplier xRefSupplier = UnoRuntime.queryInterface( XReferenceMarksSupplier.class, mxDoc );
+
+            // Get an XNameAccess which refers to all inserted reference marks
+            XNameAccess xMarks = UnoRuntime.queryInterface (
+                XNameAccess.class, xRefSupplier.getReferenceMarks() );
+
+            // Put the names of each reference mark into an array of strings
+            String[] aNames = xMarks.getElementNames();
+
+            // Make sure that at least 1 reference mark actually exists
+            // (well, we just inserted one!)
+            if ( aNames.length > 0 )
+            {
+                // Output the name of the first reference mark ('TableHeader')
+                System.out.println (
+                    "GetReference text field inserted for ReferenceMark : "
+                    + aNames[0] );
+
+                // Set the SourceName of the GetReference text field to
+                // 'TableHeader'
+                xFieldProps.setPropertyValue ( "SourceName", aNames[0] );
+
+                // specify that the source is a reference mark (could also be a
+                // footnote, bookmark or sequence field )
+                xFieldProps.setPropertyValue ( "ReferenceFieldSource",
+                                Short.valueOf(ReferenceFieldSource.REFERENCE_MARK));
+
+                // We want the reference displayed as 'above' or 'below'
+                xFieldProps.setPropertyValue ( "ReferenceFieldPart",
+                                Short.valueOf(ReferenceFieldPart.UP_DOWN));
+
+
+                // Get the XTextContent interface of the GetReference text field
+                XTextContent xRefContent = UnoRuntime.queryInterface(
+                    XTextContent.class, xFieldProps );
+
+                // Go to the end of the document
+                mxDocCursor.gotoEnd( false );
+
+                // Make some text to precede the reference
+                mxDocText.insertString(mxDocText.getEnd(), "The table ", false);
+
+                // Insert the text field
+                mxDocText.insertTextContent(mxDocText.getEnd(), xRefContent, false);
+
+                // And some text after the reference...
+                mxDocText.insertString(mxDocText.getEnd(),
+                              " contains the sum of some random numbers.", false );
+
+                // Refresh the document
+                XRefreshable xRefresh = UnoRuntime.queryInterface(
+                    XRefreshable.class, mxDoc );
+                xRefresh.refresh();
+            }
+        }
+        catch (Exception e)
+        {
+            e.printStackTrace();
+        }
+    }
+
+    /** This method demonstrates how to create and insert footnotes, and how to
+        access the XFootnotesSupplier interface of the document
+     */
+    protected void FootnoteExample ()
+    {
+        try
+        {
+            // Create a new footnote from the document factory and get its
+            // XFootnote interface
+            XFootnote xFootnote = UnoRuntime.queryInterface(
+                XFootnote.class, mxDocFactory.createInstance (
+                    "com.sun.star.text.Footnote" ) );
+
+            // Set the label to 'Numbers'
+            xFootnote.setLabel ( "Numbers" );
+
+            // Get the footnotes XTextContent interface so we can...
+            XTextContent xContent = UnoRuntime.queryInterface (
+                XTextContent.class, xFootnote );
+
+            // ...insert it into the document
+            mxDocText.insertTextContent ( mxDocCursor, xContent, false );
+
+            // Get the XFootnotesSupplier interface of the document
+            XFootnotesSupplier xFootnoteSupplier = UnoRuntime.queryInterface(XFootnotesSupplier.class, mxDoc );
+
+            // Get an XIndexAccess interface to all footnotes
+            XIndexAccess xFootnotes = UnoRuntime.queryInterface (
+                XIndexAccess.class, xFootnoteSupplier.getFootnotes() );
+
+            // Get the XFootnote interface to the first footnote inserted ('Numbers')
+            XFootnote xNumbers = UnoRuntime.queryInterface (
+                XFootnote.class, xFootnotes.getByIndex( 0 ) );
+
+            // Get the XSimpleText interface to the Footnote
+            XSimpleText xSimple = UnoRuntime.queryInterface (
+                XSimpleText.class, xNumbers );
+
+            // Create a text cursor for the foot note text
+            XTextRange xRange = UnoRuntime.queryInterface (
+                XTextRange.class, xSimple.createTextCursor() );
+
+            // And insert the actual text of the footnote.
+            xSimple.insertString (
+                xRange, "  The numbers were generated by using java.util.Random", false );
+        }
+        catch (Exception e)
+        {
+            e.printStackTrace();
+        }
+    }
+
+    /** This method demonstrates how to create and manipulate shapes, and how to
+        access the draw page of the document to insert shapes
+     */
+    protected void DrawPageExample ()
+    {
+        try
+        {
+            // Go to the end of the document
+            mxDocCursor.gotoEnd( false );
+            // Insert two new paragraphs
+            mxDocText.insertControlCharacter(mxDocCursor,
+                          ControlCharacter.PARAGRAPH_BREAK, false);
+            mxDocText.insertControlCharacter(mxDocCursor,
+                          ControlCharacter.PARAGRAPH_BREAK, false);
+
+            // Get the XParagraphCursor interface of our document cursor
+            XParagraphCursor xParaCursor = UnoRuntime.queryInterface( XParagraphCursor.class, mxDocCursor );
+
+            // Position the cursor in the 2nd paragraph
+            xParaCursor.gotoPreviousParagraph ( false );
+
+            // Create a RectangleShape using the document factory
+            XShape xRect = UnoRuntime.queryInterface(
+                XShape.class, mxDocFactory.createInstance (
+                    "com.sun.star.drawing.RectangleShape" ) );
+
+            // Create an EllipseShape using the document factory
+            XShape xEllipse = UnoRuntime.queryInterface(
+                XShape.class, mxDocFactory.createInstance (
+                    "com.sun.star.drawing.EllipseShape" ) );
+
+            // Set the size of both the ellipse and the rectangle
+            Size aSize = new Size();
+            aSize.Height = 4000;
+            aSize.Width = 10000;
+            xRect.setSize(aSize);
+            aSize.Height = 3000;
+            aSize.Width = 6000;
+            xEllipse.setSize ( aSize );
+
+            // Set the position of the Rectangle to the right of the ellipse
+            Point aPoint = new Point();
+            aPoint.X = 6100;
+            aPoint.Y = 0;
+            xRect.setPosition ( aPoint );
+
+            // Get the XPropertySet interfaces of both shapes
+            XPropertySet xRectProps = UnoRuntime.queryInterface(
+                XPropertySet.class, xRect );
+            XPropertySet xEllipseProps = UnoRuntime.queryInterface(
+                XPropertySet.class, xEllipse );
+
+            // And set the AnchorTypes of both shapes to 'AT_PARAGRAPH'
+            xRectProps.setPropertyValue ( "AnchorType",
+                                          TextContentAnchorType.AT_PARAGRAPH );
+            xEllipseProps.setPropertyValue ( "AnchorType",
+                                             TextContentAnchorType.AT_PARAGRAPH );
+
+            // Access the XDrawPageSupplier interface of the document
+            XDrawPageSupplier xDrawPageSupplier = UnoRuntime.queryInterface (XDrawPageSupplier.class, mxDoc );
+
+            // Get the XShapes interface of the draw page
+            XShapes xShapes = UnoRuntime.queryInterface (
+                XShapes.class, xDrawPageSupplier.getDrawPage () );
+
+            // Add both shapes
+            xShapes.add ( xEllipse );
+            xShapes.add ( xRect );
+
+            /*
+              This doesn't work, I am assured that FME and AMA are fixing it.
+
+              XShapes xGrouper = (XShapes) UnoRuntime.queryInterface(
+              XShapes.class, mxDocFactory.createInstance (
+              "com.sun.star.drawing.GroupShape" ) );
+
+              XShape xGrouperShape = (XShape) UnoRuntime.queryInterface(
+                     XShape.class, xGrouper );
+              xShapes.add ( xGrouperShape );
+
+              xGrouper.add ( xRect );
+              xGrouper.add ( xEllipse );
+
+              XShapeGrouper xShapeGrouper = (XShapeGrouper)
+              UnoRuntime.queryInterface(XShapeGrouper.class, xShapes);
+              xShapeGrouper.group ( xGrouper );
+            */
+
+        }
+        catch (Exception e)
+        {
+            e.printStackTrace();
+        }
+    }
+
+    /** This method demonstrates how to create, insert and apply styles
+     */
+    protected void StylesExample ()
+    {
+        try
+        {
+            // Go to the end of the document
+            mxDocCursor.gotoEnd( false );
+
+            // Insert two paragraph breaks
+            mxDocText.insertControlCharacter (
+                mxDocCursor, ControlCharacter.PARAGRAPH_BREAK, false );
+            mxDocText.insertControlCharacter (
+                mxDocCursor, ControlCharacter.PARAGRAPH_BREAK, false );
+
+            // Create a new style from the document's factory
+            XStyle xStyle = UnoRuntime.queryInterface(
+                XStyle.class, mxDocFactory.createInstance(
+                    "com.sun.star.style.ParagraphStyle" ) );
+
+            // Access the XPropertySet interface of the new style
+            XPropertySet xStyleProps = UnoRuntime.queryInterface(
+                XPropertySet.class, xStyle );
+
+            // Give the new style a light blue background
+            xStyleProps.setPropertyValue ( "ParaBackColor", Integer.valueOf(13421823));
+
+            // Get the StyleFamiliesSupplier interface of the document
+            XStyleFamiliesSupplier xSupplier = UnoRuntime.queryInterface(XStyleFamiliesSupplier.class, mxDoc);
+
+            // Use the StyleFamiliesSupplier interface to get the XNameAccess
+            // interface of the actual style families
+            XNameAccess xFamilies = UnoRuntime.queryInterface (
+                XNameAccess.class, xSupplier.getStyleFamilies() );
+
+            // Access the 'ParagraphStyles' Family
+            XNameContainer xFamily = UnoRuntime.queryInterface (
+                        XNameContainer.class,
+                        xFamilies.getByName ( "ParagraphStyles" ) );
+
+            // Insert the newly created style into the ParagraphStyles family
+            xFamily.insertByName ( "All-Singing All-Dancing Style", xStyle );
+
+            // Get the XParagraphCursor interface of the document cursor
+            XParagraphCursor xParaCursor = UnoRuntime.queryInterface( XParagraphCursor.class, mxDocCursor );
+
+            // Select the first paragraph inserted
+            xParaCursor.gotoPreviousParagraph ( false );
+            xParaCursor.gotoPreviousParagraph ( true );
+
+            // Access the property set of the cursor selection
+            XPropertySet xCursorProps = UnoRuntime.queryInterface(
+                XPropertySet.class, mxDocCursor );
+
+            // Set the style of the cursor selection to our newly created style
+            xCursorProps.setPropertyValue ( "ParaStyleName",
+                                            "All-Singing All-Dancing Style" );
+
+            // Go back to the end
+            mxDocCursor.gotoEnd ( false );
+
+            // Select the last paragraph in the document
+            xParaCursor.gotoNextParagraph ( true );
+
+            // And reset its style to 'Standard' (the programmatic name for
+            // the default style)
+            xCursorProps.setPropertyValue ( "ParaStyleName", "Standard" );
+        }
+        catch (Exception e)
+        {
+            e.printStackTrace();
+        }
+    }
+
+    /** This method demonstrates how to set numbering types and numbering levels
+        using the com.sun.star.text.NumberingRules service
+     */
+    protected void NumberingExample ()
+    {
+        try
+        {
+            // Go to the end of the document
+            mxDocCursor.gotoEnd( false );
+            // Get the RelativeTextContentInsert interface of the document
+            XRelativeTextContentInsert xRelative =
+                UnoRuntime.queryInterface (
+                XRelativeTextContentInsert.class, mxDocText );
+
+            // Use the document's factory to create the NumberingRules service,
+            // and get its XIndexAccess interface
+            XIndexAccess xNum = UnoRuntime.queryInterface(
+                XIndexAccess.class,
+                mxDocFactory.createInstance( "com.sun.star.text.NumberingRules" ) );
+
+            // Also get the NumberingRule's XIndexReplace interface
+            XIndexReplace xReplace = UnoRuntime.queryInterface(
+                XIndexReplace.class, xNum );
+
+            // Create an array of XPropertySets, one for each of the three
+            // paragraphs we're about to create
+            XPropertySet xParas[] = new XPropertySet [ 3 ];
+            for ( int i = 0 ; i < 3 ; ++ i )
+            {
+                // Create a new paragraph
+                XTextContent xNewPara = UnoRuntime.queryInterface(
+                    XTextContent.class, mxDocFactory.createInstance(
+                        "com.sun.star.text.Paragraph" ) );
+
+                // Get the XPropertySet interface of the new paragraph and put
+                // it in our array
+                xParas[i] = UnoRuntime.queryInterface(
+                    XPropertySet.class, xNewPara );
+
+                // Insert the new paragraph into the document after the fish
+                // section. As it is an insert relative to the fish section, the
+                // first paragraph inserted will be below the next two
+                xRelative.insertTextContentAfter ( xNewPara, mxFishSection );
+
+                // Separate from the above, but also needs to be done three times
+
+                // Get the PropertyValue sequence for this numbering level
+                PropertyValue [] aProps = (PropertyValue [] ) xNum.getByIndex ( i );
+
+                // Iterate over the PropertyValue's for this numbering level,
+                // looking for the 'NumberingType' property
+                for ( int j = 0 ; j < aProps.length ; ++j )
+                {
+                    if ( aProps[j].Name.equals ( "NumberingType" ) )
+                    {
+                        // Once we find it, set its value to a new type,
+                        // dependent on which numbering level we're currently on
+                        switch ( i )
+                        {
+                        case 0 : aProps[j].Value =
+                                     Short.valueOf(NumberingType.ROMAN_UPPER);
+                            break;
+                        case 1 : aProps[j].Value =
+                                     Short.valueOf(NumberingType.CHARS_UPPER_LETTER);
+                            break;
+                        case 2 : aProps[j].Value =
+                                     Short.valueOf(NumberingType.ARABIC);
+                            break;
+                        }
+                        // Put the updated PropertyValue sequence back into the
+                        // NumberingRules service
+                        xReplace.replaceByIndex ( i, aProps );
+                        break;
+                    }
+                }
+            }
+            // Get the XParagraphCursor interface of our text cursor
+            XParagraphCursor xParaCursor = UnoRuntime.queryInterface( XParagraphCursor.class, mxDocCursor );
+            // Go to the end of the document, then select the preceding paragraphs
+            mxDocCursor.gotoEnd ( false );
+            xParaCursor.gotoPreviousParagraph ( false );
+            xParaCursor.gotoPreviousParagraph ( true );
+            xParaCursor.gotoPreviousParagraph ( true );
+
+            // Get the XPropertySet of the cursor's currently selected text
+            XPropertySet xCursorProps = UnoRuntime.queryInterface(
+                XPropertySet.class, mxDocCursor );
+
+            // Set the updated Numbering rules to the cursor's property set
+            xCursorProps.setPropertyValue ( "NumberingRules", xNum );
+            mxDocCursor.gotoEnd( false );
+
+            // Set the first paragraph that was inserted to a numbering level of
+            // 2 (thus it will have Arabic style numbering)
+            xParas[0].setPropertyValue ( "NumberingLevel", Short.valueOf((short) 2));
+
+            // Set the second paragraph that was inserted to a numbering level of
+            // 1 (thus it will have 'Chars Upper Letter' style numbering)
+            xParas[1].setPropertyValue ( "NumberingLevel", Short.valueOf((short) 1));
+
+            // Set the third paragraph that was inserted to a numbering level of
+            // 0 (thus it will have 'Chars Upper Letter' style numbering)
+            xParas[2].setPropertyValue ( "NumberingLevel", Short.valueOf((short) 0));
+            }
+        catch (Exception e)
+        {
+            e.printStackTrace();
+        }
+    }
+
+    /** This method demonstrates how to create linked and unlinked sections
+     */
+    protected void TextSectionExample ()
+    {
+        try
+        {
+            // Go to the end of the document
+            mxDocCursor.gotoEnd( false );
+            // Insert two paragraph breaks
+            mxDocText.insertControlCharacter (
+                mxDocCursor, ControlCharacter.PARAGRAPH_BREAK, false );
+            mxDocText.insertControlCharacter (
+                mxDocCursor, ControlCharacter.PARAGRAPH_BREAK, true );
+
+            // Create a new TextSection from the document factory and access
+            // its XNamed interface
+            XNamed xChildNamed = UnoRuntime.queryInterface(
+                XNamed.class, mxDocFactory.createInstance(
+                    "com.sun.star.text.TextSection" ) );
+            // Set the new sections name to 'Child_Section'
+            xChildNamed.setName ( "Child_Section" );
+
+            // Access the Child_Section's XTextContent interface and insert it
+            // into the document
+            XTextContent xChildSection = UnoRuntime.queryInterface(
+                XTextContent.class, xChildNamed );
+            mxDocText.insertTextContent ( mxDocCursor, xChildSection, false );
+
+            // Access the XParagraphCursor interface of our text cursor
+            XParagraphCursor xParaCursor = UnoRuntime.queryInterface(XParagraphCursor.class, mxDocCursor);
+
+            // Go back one paragraph (into Child_Section)
+            xParaCursor.gotoPreviousParagraph ( false );
+
+            // Insert a string into the Child_Section
+            mxDocText.insertString ( mxDocCursor, "This is a test", false );
+
+            // Go to the end of the document
+            mxDocCursor.gotoEnd( false );
+
+            // Go back two paragraphs
+            xParaCursor.gotoPreviousParagraph ( false );
+            xParaCursor.gotoPreviousParagraph ( false );
+            // Go to the end of the document, selecting the two paragraphs
+            mxDocCursor.gotoEnd ( true );
+
+            // Create another text section and access its XNamed interface
+            XNamed xParentNamed = UnoRuntime.queryInterface(XNamed.class,
+                      mxDocFactory.createInstance("com.sun.star.text.TextSection"));
+
+            // Set this text section's name to Parent_Section
+            xParentNamed.setName ( "Parent_Section" );
+
+            // Access the Parent_Section's XTextContent interface ...
+            XTextContent xParentSection = UnoRuntime.queryInterface(
+                XTextContent.class, xParentNamed );
+            // ...and insert it into the document
+            mxDocText.insertTextContent ( mxDocCursor, xParentSection, false );
+
+            // Go to the end of the document
+            mxDocCursor.gotoEnd ( false );
+            // Insert a new paragraph
+            mxDocText.insertControlCharacter (
+                mxDocCursor, ControlCharacter.PARAGRAPH_BREAK, false );
+            // And select the new paragraph
+            xParaCursor.gotoPreviousParagraph ( true );
+
+            // Create a new Text Section and access its XNamed interface
+            XNamed xLinkNamed = UnoRuntime.queryInterface(XNamed.class,
+                      mxDocFactory.createInstance("com.sun.star.text.TextSection"));
+            // Set the new text section's name to Linked_Section
+            xLinkNamed.setName ( "Linked_Section" );
+
+            // Access the Linked_Section's XTextContent interface
+            XTextContent xLinkedSection = UnoRuntime.queryInterface(
+                XTextContent.class, xLinkNamed );
+            // And insert the Linked_Section into the document
+            mxDocText.insertTextContent ( mxDocCursor, xLinkedSection, false );
+
+            // Access the Linked_Section's XPropertySet interface
+            XPropertySet xLinkProps = UnoRuntime.queryInterface(
+                XPropertySet.class, xLinkNamed );
+            // Set the linked section to be linked to the Child_Section
+            xLinkProps.setPropertyValue ( "LinkRegion", "Child_Section" );
+
+            // Access the XPropertySet interface of the Child_Section
+            XPropertySet xChildProps = UnoRuntime.queryInterface(
+                XPropertySet.class, xChildNamed );
+            // Set the Child_Section's background colour to blue
+            xChildProps.setPropertyValue( "BackColor", Integer.valueOf(13421823));
+
+            // Refresh the document, so the linked section matches the Child_Section
+            XRefreshable xRefresh = UnoRuntime.queryInterface(
+                XRefreshable.class, mxDoc );
+            xRefresh.refresh();
+        }
+        catch (Exception e)
+        {
+            e.printStackTrace();
+        }
+    }
+
+    /** This method demonstrates the XTextColumns interface and how to insert a
+        blank paragraph using the XRelativeTextContentInsert interface
+     */
+    protected void TextColumnsExample ()
+    {
+        try
+        {
+            // Go to the end of the document
+            mxDocCursor.gotoEnd( false );
+            // insert a new paragraph
+            mxDocText.insertControlCharacter (
+                mxDocCursor, ControlCharacter.PARAGRAPH_BREAK, false );
+
+            // insert the string 'I am a fish.' 100 times
+            for ( int i = 0 ; i < 100 ; ++i )
+            {
+                mxDocText.insertString ( mxDocCursor, "I am a fish.", false );
+            }
+            // insert a paragraph break after the text
+            mxDocText.insertControlCharacter (
+                mxDocCursor, ControlCharacter.PARAGRAPH_BREAK, false );
+
+            // Get the XParagraphCursor interface of our text cursor
+            XParagraphCursor xParaCursor = UnoRuntime.queryInterface( XParagraphCursor.class, mxDocCursor );
+            // Jump back before all the text we just inserted
+            xParaCursor.gotoPreviousParagraph ( false );
+            xParaCursor.gotoPreviousParagraph ( false );
+
+            // Insert a string at the beginning of the block of text
+            mxDocText.insertString ( mxDocCursor, "Fish section begins:", false );
+
+            // Then select all of the text
+            xParaCursor.gotoNextParagraph ( true );
+            xParaCursor.gotoNextParagraph ( true );
+
+            // Create a new text section and get its XNamed interface
+            XNamed xSectionNamed = UnoRuntime.queryInterface(XNamed.class,
+                      mxDocFactory.createInstance("com.sun.star.text.TextSection"));
+
+            // Set the name of our new section (appropriately) to 'Fish'
+            xSectionNamed.setName ( "Fish" );
+
+            // Create the TextColumns service and get its XTextColumns interface
+            XTextColumns xColumns = UnoRuntime.queryInterface(
+                XTextColumns.class,
+                mxDocFactory.createInstance ( "com.sun.star.text.TextColumns" ) );
+
+            // We want three columns
+            xColumns.setColumnCount ( (short) 3 );
+
+            // Get the TextColumns, and make the middle one narrow with a larger
+            // margin on the left than the right
+            TextColumn[]  aSequence = xColumns.getColumns ();
+            aSequence[1].Width /= 2;
+            aSequence[1].LeftMargin = 350;
+            aSequence[1].RightMargin = 200;
+            // Set the updated TextColumns back to the XTextColumns
+            xColumns.setColumns ( aSequence );
+
+            // Get the property set interface of our 'Fish' section
+            XPropertySet xSectionProps = UnoRuntime.queryInterface(
+                XPropertySet.class, xSectionNamed );
+
+            // Set the columns to the Text Section
+            xSectionProps.setPropertyValue ( "TextColumns", xColumns );
+
+            // Get the XTextContent interface of our 'Fish' section
+            mxFishSection = UnoRuntime.queryInterface(
+                XTextContent.class, xSectionNamed );
+
+            // Insert the 'Fish' section over the currently selected text
+            mxDocText.insertTextContent ( mxDocCursor, mxFishSection, true );
+
+            // Get the wonderful XRelativeTextContentInsert interface
+            XRelativeTextContentInsert xRelative = UnoRuntime.queryInterface (
+                XRelativeTextContentInsert.class, mxDocText );
+
+            // Create a new empty paragraph and get its XTextContent interface
+            XTextContent xNewPara = UnoRuntime.queryInterface(
+                XTextContent.class,
+                mxDocFactory.createInstance("com.sun.star.text.Paragraph"));
+
+            // Insert the empty paragraph after the fish Text Section
+            xRelative.insertTextContentAfter ( xNewPara, mxFishSection );
+        }
+        catch (Exception e)
+        {
+            e.printStackTrace();
+        }
+    }
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */