diff options
Diffstat (limited to '')
| -rw-r--r-- | odk/examples/DevelopersGuide/Text/TextDocuments.java | 1724 |
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: */ |