summaryrefslogtreecommitdiffstats
path: root/odk/examples/DevelopersGuide/Text/TextDocuments.java
diff options
context:
space:
mode:
Diffstat (limited to '')
-rw-r--r--odk/examples/DevelopersGuide/Text/TextDocuments.java1724
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..20e9f7a58
--- /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 pargraph
+ 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: */