*

*  $RCSfile: TextDocuments.java,v $

*

*  $Revision: 1.5 $

*

*  last change: $Author: rt $ $Date: 2005-01-31 16:56:34 $

*

*  The Contents of this file are made available subject to the terms of

*  the BSD license.

* 

*  Copyright (c) 2003 by Sun Microsystems, Inc.

*  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.

*    

*************************************************************************/

* TextDocuments.java

*

* Created on 11. April 2002, 08:47

*/

*

* @author  Martin Gallwey, Dietrich Schulten

*/

    // adjust these constant to your local printer!

    private static String sOutputDir;

    private 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 XPropertySet  mxDocProps = null;

    private XText mxDocText = null;

    private XTextCursor mxDocCursor = null;

    private XTextContent mxFishSection = null;

    private Random maRandom = null;

   

    /** Creates a new instance of TextDocuments */

    public TextDocuments() {

    }

   

    /**

     * @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

        Hashtable recipient = new Hashtable();

        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 = (XTextFieldsSupplier)

            UnoRuntime.queryInterface(XTextFieldsSupplier.class,

                                      xTemplateComponent);

        XBookmarksSupplier 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

        java.util.Enumeration keys = recipient.keys();

        while(keys.hasMoreElements()) {

            // get column name

            String key = (String)keys.nextElement();

           

            // 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 = (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 = (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 = (XTextContent)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 = (XDesktop)UnoRuntime.queryInterface(

            XDesktop.class, desktop);

        // retrieve the current component and access the controller

        XComponent xCurrentComponent = xDesktop.getCurrentComponent();

        XModel xModel = (XModel)UnoRuntime.queryInterface(XModel.class,

                                                          xCurrentComponent);

        XController xController = xModel.getCurrentController();

        // the controller gives us the TextViewCursor

        XTextViewCursorSupplier xViewCursorSupplier =

            (XTextViewCursorSupplier)UnoRuntime.queryInterface(

                XTextViewCursorSupplier.class, xController);

        XTextViewCursor xViewCursor = xViewCursorSupplier.getViewCursor();

       

        // query its XPropertySet interface, we want to set character and paragraph

        // properties

        XPropertySet xCursorPropertySet = (XPropertySet)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 = (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 = (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 = (XTextDocument)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

        mxDocProps = (XPropertySet) 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 = (XMultiServiceFactory) UnoRuntime.queryInterface(

            XMultiServiceFactory.class, mxDoc );

       

        // Examples of text fields, dependant 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 = (XMultiServiceFactory)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 = (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.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 = (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 = (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 = new 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 = (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 = (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 refering 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 refering 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 = (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 = (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 = (XPropertySet) 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 it's XTextField interface

            XTextField xDateField = (XTextField) 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 it's XDependentTextField interface

            XDependentTextField xUserField =

                (XDependentTextField) UnoRuntime.queryInterface (

                    XDependentTextField.class, mxDocFactory.createInstance (

                        "com.sun.star.text.TextField.User" ) );

            // Create a fieldmaster for our newly created User Text field, and

            // access it's XPropertySet interface

            XPropertySet xMasterPropSet = (XPropertySet)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", new Integer ( 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 = (XEnumerationAccess)

                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 = (XServiceInfo) 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 = (XPropertySet) 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 refered 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 = (XText) 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 = (XPropertySet)UnoRuntime.queryInterface(

            XPropertySet.class, xCellCursor );

       

        try

        {

            // Set the colour of the text to white

            xCellCursorProps.setPropertyValue( "CharColor", new Integer(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 = (XTextTable) 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 = (XPropertySet) UnoRuntime.queryInterface(

                XPropertySet.class, xRows.getByIndex ( 0 ) );

            // If BackTransparant is false, then the background color is visible

            xRow.setPropertyValue( "BackTransparent", new Boolean(false));

            // Specify the color of the background to be dark blue

            xRow.setPropertyValue( "BackColor", new Integer(6710932));

           

            // Access the property set of the whole table

            XPropertySet xTableProps = (XPropertySet)UnoRuntime.queryInterface(

                XPropertySet.class, xTable );

            // We want visible background colors

            xTableProps.setPropertyValue( "BackTransparent", new Boolean(false));

            // Set the background colour to light blue

            xTableProps.setPropertyValue( "BackColor", new Integer(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 it's XTextFrame interface

            XTextFrame xFrame = (XTextFrame) UnoRuntime.queryInterface (

                XTextFrame.class, mxDocFactory.createInstance (

                    "com.sun.star.text.TextFrame" ) );

           

            // Access the XShape interface of the TextFrame

            XShape xShape = (XShape)UnoRuntime.queryInterface(XShape.class, xFrame);

            // Access the XPropertySet interface of the TextFrame

            XPropertySet xFrameProps = (XPropertySet)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 = (XParagraphCursor)

                UnoRuntime.queryInterface(XParagraphCursor.class, mxDocCursor );

            xParaCursor.gotoPreviousParagraph ( false );

            // Get an XNameAccess interface to all auto text groups from the

            // document factory

            XNameAccess xContainer = (XNameAccess) UnoRuntime.queryInterface(

                XNameAccess.class, mxFactory.createInstance (

                    "com.sun.star.text.AutoTextContainer" ) );

            // Create a new table at the document factory 

            XTextTable xTable = (XTextTable) 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 = (XPropertySet)UnoRuntime.queryInterface(

                    XPropertySet.class, xTable );

               

                // We want a visible background

                xTableProps.setPropertyValue( "BackTransparent",

                                              new Boolean(false));

                // We want the background to be light blue

                xTableProps.setPropertyValue( "BackColor", new Integer(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 = (XPropertySet) UnoRuntime.queryInterface(

                    XPropertySet.class, xRows.getByIndex ( 0 ) );

                // We want the background of the first row to be visible too

                xRow.setPropertyValue( "BackTransparent", new Boolean(false));

               

                // And let's make it dark blue

                xRow.setPropertyValue( "BackColor", new Integer(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 = (XText) 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 = (XAutoTextGroup)

                        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 seperate 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 seperate 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 = (XText) 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   = ( XAutoTextGroup ) 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 containg blocks...

                if ( aBlockNames.length > 0 )

                {

                    // Pick a random block in this group and get it's

                    // XAutoTextEntry interface

                    int nRandom = Math.abs ( maRandom.nextInt()

                                             % aBlockNames.length );

                    XAutoTextEntry xEntry = ( XAutoTextEntry )

                        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 = ( XNamed ) 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 = (XParagraphCursor)

                UnoRuntime.queryInterface( XParagraphCursor.class, mxDocCursor );

            xParaCursor.gotoPreviousParagraph ( false );

           

            // Create a new ContentIndexMark and get it's XPropertySet interface

            XPropertySet xEntry = (XPropertySet)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", new Short ( (short) 1 ) );

           

            // Create a ContentIndex and access it's XPropertySet interface

            XPropertySet xIndex = (XPropertySet) UnoRuntime.queryInterface(

                XPropertySet.class,

                mxDocFactory.createInstance ( "com.sun.star.text.ContentIndex" ) );

            // Again, the Level property _must_ be set

            xIndex.setPropertyValue ( "Level", new Short ( (short) 10 ) );

            // Access the XTextContent interfaces of both the Index and the

            // IndexMark

            XTextContent xIndexContent = (XTextContent) UnoRuntime.queryInterface(

                XTextContent.class, xIndex );

            XTextContent xEntryContent = (XTextContent) 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 = (XDocumentIndex) UnoRuntime.queryInterface(

                XDocumentIndex.class, xIndex );

           

            // And call it's 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 = (XParagraphCursor)

                UnoRuntime.queryInterface( XParagraphCursor.class, mxDocCursor );

           

            // Move the cursor into the new paragraph

            xParaCursor.gotoPreviousParagraph ( false );

           

            // Create a new ReferenceMark and get it's XNamed interface

            XNamed xRefMark = (XNamed) 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 = ( XTextTablesSupplier )

                UnoRuntime.queryInterface(XTextTablesSupplier.class, mxDoc);

            // Get an XIndexAccess of TextTables

            XIndexAccess xTables = (XIndexAccess)UnoRuntime.queryInterface(

                XIndexAccess.class, xTableSupplier.getTextTables());

            // We've only inserted one table, so get the first one from index zero

            XTextTable xTable = ( XTextTable ) UnoRuntime.queryInterface (

                XTextTable.class, xTables.getByIndex( 0 ) );

            // Get the first cell from the table

            XText xTableText = (XText) 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 = ( XTextContent ) 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 it's XPropertySet interface

            XPropertySet xFieldProps = (XPropertySet) UnoRuntime.queryInterface(

                XPropertySet.class, mxDocFactory.createInstance (

                    "com.sun.star.text.TextField.GetReference" ) );

            // Get the XReferenceMarksSupplier interface of the document

            XReferenceMarksSupplier xRefSupplier = ( XReferenceMarksSupplier )

                UnoRuntime.queryInterface( XReferenceMarksSupplier.class, mxDoc );

            // Get an XNameAccess which refers to all inserted reference marks

            XNameAccess xMarks = ( XNameAccess ) 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",

                                new Short(ReferenceFieldSource.REFERENCE_MARK));

                // We want the reference displayed as 'above' or 'below'

                xFieldProps.setPropertyValue ( "ReferenceFieldPart",

                                new Short(ReferenceFieldPart.UP_DOWN));

                           

                // Get the XTextContent interface of the GetReference text field

                XTextContent xRefContent = (XTextContent) 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 = (XRefreshable) 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 it's

            // XFootnote interface

            XFootnote 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 = ( XTextContent ) UnoRuntime.queryInterface (

                XTextContent.class, xFootnote );

           

            // ...insert it into the document

            mxDocText.insertTextContent ( mxDocCursor, xContent, false );

           

            // Get the XFootnotesSupplier interface of the document

            XFootnotesSupplier xFootnoteSupplier = (XFootnotesSupplier)

                UnoRuntime.queryInterface(XFootnotesSupplier.class, mxDoc );

            // Get an XIndexAccess interface to all footnotes

            XIndexAccess xFootnotes = ( XIndexAccess ) UnoRuntime.queryInterface (

                XIndexAccess.class, xFootnoteSupplier.getFootnotes() );

            // Get the XFootnote interface to the first footnote inserted ('Numbers')

            XFootnote xNumbers = ( XFootnote ) UnoRuntime.queryInterface (

                XFootnote.class, xFootnotes.getByIndex( 0 ) );

            // Get the XSimpleText interface to the Footnote

            XSimpleText xSimple = (XSimpleText ) UnoRuntime.queryInterface (

                XSimpleText.class, xNumbers );

           

            // Create a text cursor for the foot note text

            XTextRange xRange = (XTextRange ) 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 = (XParagraphCursor)

                UnoRuntime.queryInterface( XParagraphCursor.class, mxDocCursor );

            // Position the cursor in the 2nd paragraph

            xParaCursor.gotoPreviousParagraph ( false );