/* -*- 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 recipient = new HashMap(); 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 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 " ); xTable.getCellByName( "D3" ).setFormula( "sum " ); xTable.getCellByName( "D4" ).setFormula( "sum " ); } 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: */