1 /**************************************************************
2  *
3  * Licensed to the Apache Software Foundation (ASF) under one
4  * or more contributor license agreements.  See the NOTICE file
5  * distributed with this work for additional information
6  * regarding copyright ownership.  The ASF licenses this file
7  * to you under the Apache License, Version 2.0 (the
8  * "License"); you may not use this file except in compliance
9  * with the License.  You may obtain a copy of the License at
10  *
11  *   http://www.apache.org/licenses/LICENSE-2.0
12  *
13  * Unless required by applicable law or agreed to in writing,
14  * software distributed under the License is distributed on an
15  * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
16  * KIND, either express or implied.  See the License for the
17  * specific language governing permissions and limitations
18  * under the License.
19  *
20  *************************************************************/
21 
22 
23 
24 import com.sun.star.awt.Point;
25 import com.sun.star.awt.Size;
26 import com.sun.star.awt.FontWeight;
27 
28 import com.sun.star.beans.PropertyState;
29 import com.sun.star.beans.PropertyValue;
30 import com.sun.star.beans.XPropertySet;
31 import com.sun.star.beans.XPropertyState;
32 
33 import com.sun.star.bridge.XUnoUrlResolver;
34 
35 import com.sun.star.comp.servicemanager.ServiceManager;
36 
37 import com.sun.star.connection.XConnector;
38 import com.sun.star.connection.XConnection;
39 
40 import com.sun.star.container.XNameAccess;
41 import com.sun.star.container.XNameContainer;
42 import com.sun.star.container.XNamed;
43 import com.sun.star.container.XIndexAccess;
44 import com.sun.star.container.XIndexReplace;
45 import com.sun.star.container.XEnumeration;
46 import com.sun.star.container.XEnumerationAccess;
47 
48 import com.sun.star.drawing.XShape;
49 import com.sun.star.drawing.XShapeGrouper;
50 import com.sun.star.drawing.XShapes;
51 import com.sun.star.drawing.XDrawPageSupplier;
52 
53 import com.sun.star.frame.XDesktop;
54 import com.sun.star.frame.XComponentLoader;
55 import com.sun.star.frame.XModel;
56 import com.sun.star.frame.XController;
57 
58 import com.sun.star.lang.XComponent;
59 import com.sun.star.lang.XMultiComponentFactory;
60 import com.sun.star.lang.XMultiServiceFactory;
61 import com.sun.star.lang.XServiceInfo;
62 
63 import com.sun.star.style.NumberingType;
64 import com.sun.star.style.XStyle;
65 import com.sun.star.style.XStyleFamiliesSupplier;
66 
67 import com.sun.star.table.XCell;
68 
69 import com.sun.star.text.ControlCharacter;
70 import com.sun.star.text.ReferenceFieldSource;
71 import com.sun.star.text.ReferenceFieldPart;
72 import com.sun.star.text.TextColumn;
73 import com.sun.star.text.TextContentAnchorType;
74 import com.sun.star.text.XAutoTextContainer;
75 import com.sun.star.text.XAutoTextGroup;
76 import com.sun.star.text.XAutoTextEntry;
77 import com.sun.star.text.XDependentTextField;
78 import com.sun.star.text.XDocumentIndex;
79 import com.sun.star.text.XFootnote;
80 import com.sun.star.text.XFootnotesSupplier;
81 import com.sun.star.text.XParagraphCursor;
82 import com.sun.star.text.XReferenceMarksSupplier;
83 import com.sun.star.text.XRelativeTextContentInsert;
84 import com.sun.star.text.XSentenceCursor;
85 import com.sun.star.text.XSimpleText;
86 import com.sun.star.text.XText;
87 import com.sun.star.text.XTextColumns;
88 import com.sun.star.text.XTextContent;
89 import com.sun.star.text.XTextCursor;
90 import com.sun.star.text.XTextDocument;
91 import com.sun.star.text.XTextField;
92 import com.sun.star.text.XTextFrame;
93 import com.sun.star.text.XTextRange;
94 import com.sun.star.text.XTextSection;
95 import com.sun.star.text.XTextTable;
96 import com.sun.star.text.XTextTableCursor;
97 import com.sun.star.text.XTextTablesSupplier;
98 import com.sun.star.text.XTextFieldsSupplier;
99 import com.sun.star.text.XBookmarksSupplier;
100 import com.sun.star.text.XTextViewCursorSupplier;
101 import com.sun.star.text.XTextViewCursor;
102 import com.sun.star.text.XPageCursor;
103 
104 import com.sun.star.text.XWordCursor;
105 
106 import com.sun.star.uno.AnyConverter;
107 import com.sun.star.uno.UnoRuntime;
108 import com.sun.star.uno.XComponentContext;
109 import com.sun.star.uno.XInterface;
110 import com.sun.star.uno.XNamingService;
111 
112 import com.sun.star.util.XRefreshable;
113 
114 import com.sun.star.frame.XStorable;
115 import com.sun.star.view.XPrintable;
116 
117 import java.lang.Math;
118 import java.util.Random;
119 import java.util.Hashtable;
120 
121 /*
122  * TextDocuments.java
123  *
124  * Created on 11. April 2002, 08:47
125  */
126 
127 /**
128  *
129  * @author  Martin Gallwey, Dietrich Schulten
130  */
131 public class TextDocuments {
132     // adjust these constant to your local printer!
133     private static String sOutputDir;
134 
135     private String aPrinterName = "\\\\so-print\\xml3sof";
136 
137     private XComponentContext mxRemoteContext = null;
138     private XMultiComponentFactory mxRemoteServiceManager = null;
139     private XTextDocument mxDoc = null;
140     private XMultiServiceFactory mxDocFactory = null;
141     private XMultiServiceFactory mxFactory = null;
142     private XPropertySet  mxDocProps = null;
143     private XText mxDocText = null;
144     private XTextCursor mxDocCursor = null;
145     private XTextContent mxFishSection = null;
146     private Random maRandom = null;
147 
148     /** Creates a new instance of TextDocuments */
149     public TextDocuments() {
150     }
151 
152     /**
153      * @param args the command line arguments
154      */
155     public static void main(String[] args) {
156     TextDocuments textDocuments1 = new TextDocuments();
157     try {
158             // output directory for store test;
159             sOutputDir = args[0];
160 
161             textDocuments1.runDemo();
162         }
163         catch (java.lang.Exception e){
164             System.out.println(e.getMessage());
165             e.printStackTrace();
166         }
167         finally {
168             System.exit(0);
169         }
170     }
171 
172     protected void runDemo() throws java.lang.Exception {
173             storePrintExample(); // depends on printer name
174             templateExample();
175             viewCursorExample(); // makes changes to the current document,
176                                  // use with care
177             editingExample();
178     }
179 
180     /** Sample for use of templates
181      *  This sample uses the file TextTemplateWithUserFields.odt from the Samples
182      *  folder. The file contains a number of User text fields (Variables - User)
183      *  and a bookmark which we use to fill in various values
184      */
185     protected void templateExample() throws java.lang.Exception {
186         // create a small hashtable that simulates a rowset
187         Hashtable recipient = new Hashtable();
188         recipient.put("Company", "Manatee Books");
189         recipient.put("Contact", "Rod Martin");
190         recipient.put("ZIP", "34567");
191         recipient.put("City", "Fort Lauderdale");
192         recipient.put("State", "Florida");
193 
194         // load template with User fields and bookmark
195         java.io.File sourceFile = new java.io.File("TextTemplateWithUserFields.odt");
196         StringBuffer sTemplateFileUrl = new StringBuffer("file:///");
197         sTemplateFileUrl.append(sourceFile.getCanonicalPath().replace('\\', '/'));
198 
199         XComponent xTemplateComponent =
200             newDocComponentFromTemplate( sTemplateFileUrl.toString() );
201 
202         // get XTextFieldsSupplier, XBookmarksSupplier interfaces
203         XTextFieldsSupplier xTextFieldsSupplier = (XTextFieldsSupplier)
204             UnoRuntime.queryInterface(XTextFieldsSupplier.class,
205                                       xTemplateComponent);
206         XBookmarksSupplier xBookmarksSupplier = (XBookmarksSupplier)
207             UnoRuntime.queryInterface(XBookmarksSupplier.class, xTemplateComponent);
208 
209         // access the TextFields and the TextFieldMasters collections
210         XNameAccess xNamedFieldMasters = xTextFieldsSupplier.getTextFieldMasters();
211         XEnumerationAccess xEnumeratedFields = xTextFieldsSupplier.getTextFields();
212 
213         // iterate over hashtable and insert values into field masters
214         java.util.Enumeration keys = recipient.keys();
215         while(keys.hasMoreElements()) {
216             // get column name
217             String key = (String)keys.nextElement();
218 
219             // access corresponding field master
220             Object fieldMaster = xNamedFieldMasters.getByName(
221                 "com.sun.star.text.fieldmaster.User." + key);
222 
223             // query the XPropertySet interface, we need to set the Content property
224             XPropertySet xPropertySet = (XPropertySet)UnoRuntime.queryInterface(
225                 XPropertySet.class, fieldMaster);
226 
227             // insert the column value into field master
228             xPropertySet.setPropertyValue("Content", recipient.get(key));
229         }
230         // afterwards we must refresh the textfields collection
231         XRefreshable xRefreshable = (XRefreshable)UnoRuntime.queryInterface(
232             XRefreshable.class, xEnumeratedFields);
233         xRefreshable.refresh();
234 
235         // accessing the Bookmarks collection of the document
236         XNameAccess xNamedBookmarks = xBookmarksSupplier.getBookmarks();
237 
238         // find the bookmark named "Subscription"
239         Object bookmark = xNamedBookmarks.getByName("Subscription");
240         // we need its XTextRange which is available from getAnchor(),
241         // so query for XTextContent
242         XTextContent xBookmarkContent = (XTextContent)UnoRuntime.queryInterface(
243             XTextContent.class, bookmark);
244         // get the anchor of the bookmark (its XTextRange)
245         XTextRange xBookmarkRange = xBookmarkContent.getAnchor();
246         // set string at the bookmark position
247         xBookmarkRange.setString("subscription for the Manatee Journal");
248 
249     }
250 
251     /** Sample for document changes, starting at the current view cursor position
252      *  The sample changes the paragraph style and the character style at the
253      *  current view cursor selection Open the sample file ViewCursorExampleFile,
254      *  select some text and run the example.
255      *  The current paragraph will be set to Quotations paragraph style.
256      *  The selected text will be set to Quotation character style.
257      */
258     private void viewCursorExample() throws java.lang.Exception {
259         // get the remote service manager
260         mxRemoteServiceManager = this.getRemoteServiceManager();
261         // get the Desktop service
262         Object desktop = mxRemoteServiceManager.createInstanceWithContext(
263             "com.sun.star.frame.Desktop", mxRemoteContext);
264         // query its XDesktop interface, we need the current component
265         XDesktop xDesktop = (XDesktop)UnoRuntime.queryInterface(
266             XDesktop.class, desktop);
267         // retrieve the current component and access the controller
268         XComponent xCurrentComponent = xDesktop.getCurrentComponent();
269         XModel xModel = (XModel)UnoRuntime.queryInterface(XModel.class,
270                                                           xCurrentComponent);
271         XController xController = xModel.getCurrentController();
272         // the controller gives us the TextViewCursor
273         XTextViewCursorSupplier xViewCursorSupplier =
274             (XTextViewCursorSupplier)UnoRuntime.queryInterface(
275                 XTextViewCursorSupplier.class, xController);
276         XTextViewCursor xViewCursor = xViewCursorSupplier.getViewCursor();
277 
278         // query its XPropertySet interface, we want to set character and paragraph
279         // properties
280         XPropertySet xCursorPropertySet = (XPropertySet)UnoRuntime.queryInterface(
281             XPropertySet.class, xViewCursor);
282         // set the appropriate properties for character and paragraph style
283         xCursorPropertySet.setPropertyValue("CharStyleName", "Quotation");
284         xCursorPropertySet.setPropertyValue("ParaStyleName", "Quotations");
285         // print the current page number
286         XPageCursor xPageCursor = (XPageCursor)UnoRuntime.queryInterface(
287             XPageCursor.class, xViewCursor);
288         System.out.println("The current page number is " + xPageCursor.getPage());
289         // the model cursor is much more powerful, so
290         // we create a model cursor at the current view cursor position with the
291         // following steps:
292         // get the Text service from the TextViewCursor, it is an XTextRange:
293          XText xDocumentText = xViewCursor.getText();
294         // create a model cursor from the viewcursor
295         XTextCursor xModelCursor = xDocumentText.createTextCursorByRange(
296             xViewCursor.getStart());
297         // now we could query XWordCursor, XSentenceCursor and XParagraphCursor
298         // or XDocumentInsertable, XSortable or XContentEnumerationAccess
299         // and work with the properties of com.sun.star.text.TextCursor
300         // in this case we just go to the end of the paragraph and add some text.
301         XParagraphCursor xParagraphCursor = (XParagraphCursor)
302             UnoRuntime.queryInterface(XParagraphCursor.class, xModelCursor);
303         // goto the end of the paragraph
304         xParagraphCursor.gotoEndOfParagraph(false);
305         xParagraphCursor.setString(" ***** Fin de semana! ******");
306     }
307 
308 
309     /** Sample for the various editing facilities described in the
310      * developer's manual
311      */
312     private void editingExample () throws java.lang.Exception {
313         // create empty swriter document
314         XComponent xEmptyWriterComponent = newDocComponent("swriter");
315         // query its XTextDocument interface to get the text
316         mxDoc = (XTextDocument)UnoRuntime.queryInterface(
317             XTextDocument.class, xEmptyWriterComponent);
318 
319         // get a reference to the body text of the document
320         mxDocText = mxDoc.getText();
321 
322         // Get a reference to the document's property set. This contains document
323         // information like the current word count
324         mxDocProps = (XPropertySet) UnoRuntime.queryInterface(
325             XPropertySet.class, mxDoc );
326 
327         // Simple text insertion example
328         BodyTextExample ();
329         // Example using text ranges to insert strings at the beginning or end
330         // of a text range
331         TextRangeExample ();
332         // Create a document cursor and remember it, it will be used in most
333         // of the following examples
334         mxDocCursor = mxDocText.createTextCursor();
335         // Demonstrate some of the different cursor types (word, sentence)
336         TextCursorExample ();
337 
338         // Access the text document's multi service factory, which we will need
339         // for most of the following examples
340         mxDocFactory = (XMultiServiceFactory) UnoRuntime.queryInterface(
341             XMultiServiceFactory.class, mxDoc );
342 
343         // Examples of text fields, dependent text fields and field masters
344         TextFieldExample ();
345 
346         // Example of using an XEnumerationAccess to iterate over paragraphs and
347         // set properties of each paragraph as we do so
348         ParagraphExample ();
349 
350         // Example of creating and manipulating a text frame
351         TextFrameExample ();
352 
353         // Example of creating and manipulating a text table, text table rows
354         // and text table cells get a new random generator
355         maRandom = new Random();
356         TextTableExample ();
357 
358         // Example of creating, inserting and manipulating text sections, as
359         // well as an example of how to refresh the document
360         TextSectionExample ();
361 
362         // Example of creating a text section over a block of text and formatting
363         // the text section into columns, as well as how to insert an empty
364         // paragraph using the XRelativeTextContentInsert
365         TextColumnsExample ();
366 
367         // Example of creating the NumberingRules service and adjusting
368         // NumberingTypes and NumberingLevels
369         NumberingExample ();
370 
371         // Example of how to use the XStyleFamiliesSupplier interface of the
372         // document and how to create, insert and apply styles
373         StylesExample ();
374         IndexExample ();
375 
376         // Example of how to create and manipulate reference marks and GetReference
377         // text fields
378         ReferenceExample ();
379 
380         // Example of how to create and insert Footnotes and how to use the
381         // XFootnotesSupplier interface of the document
382         FootnoteExample ();
383 
384         // This method demonstrates how to create shapes from the document factory
385         // and how to access the draw page of the document using the
386         // XDrawPageSupplier interface
387         DrawPageExample ();
388 
389         mxFactory = (XMultiServiceFactory)UnoRuntime.queryInterface(
390             XMultiServiceFactory.class, mxRemoteServiceManager);
391         // This example demonstrates the use of the AutoTextContainer,
392         // AutoTextGroup and AutoTextEntry services and shows how to create,
393         // insert and modify auto text blocks
394         AutoTextExample ();
395     }
396 
397     protected void storePrintExample() throws java.lang.Exception {
398         // get the remote service manager
399         mxRemoteServiceManager = this.getRemoteServiceManager();
400         // retrieve the Desktop object, we need its XComponentLoader
401         Object desktop = mxRemoteServiceManager.createInstanceWithContext(
402             "com.sun.star.frame.Desktop", mxRemoteContext);
403         XComponentLoader xComponentLoader = (XComponentLoader)
404             UnoRuntime.queryInterface(XComponentLoader.class, desktop);
405         PropertyValue[] loadProps = new PropertyValue[0];
406 
407         java.io.File sourceFile = new java.io.File("PrintDemo.odt");
408         StringBuffer sLoadFileUrl = new StringBuffer("file:///");
409         sLoadFileUrl.append(sourceFile.getCanonicalPath().replace('\\', '/'));
410 
411         XComponent xDoc = xComponentLoader.loadComponentFromURL(
412             sLoadFileUrl.toString(), "_blank", 0, loadProps);
413 
414         if ( xDoc != null ) {
415             sourceFile = new java.io.File(sOutputDir);
416             StringBuffer sStoreFileUrl = new StringBuffer();
417             sStoreFileUrl.append(sourceFile.toURL().toString());
418             sStoreFileUrl.append("somepopularfileformat.doc");
419 
420             storeDocComponent(xDoc, sStoreFileUrl.toString() );
421             printDocComponent(xDoc);
422         }
423     }
424 
425     private XMultiComponentFactory getRemoteServiceManager()
426         throws java.lang.Exception
427     {
428         if (mxRemoteContext == null && mxRemoteServiceManager == null) {
429             // get the remote office context. If necessary a new office
430             // process is started
431             mxRemoteContext = com.sun.star.comp.helper.Bootstrap.bootstrap();
432             System.out.println("Connected to a running office ...");
433             mxRemoteServiceManager = mxRemoteContext.getServiceManager();
434         }
435         return mxRemoteServiceManager;
436     }
437 
438     protected XComponent newDocComponent(String docType)
439         throws java.lang.Exception
440     {
441         String loadUrl = "private:factory/" + docType;
442         mxRemoteServiceManager = this.getRemoteServiceManager();
443         Object desktop = mxRemoteServiceManager.createInstanceWithContext(
444             "com.sun.star.frame.Desktop", mxRemoteContext);
445         XComponentLoader xComponentLoader = (XComponentLoader)
446             UnoRuntime.queryInterface(XComponentLoader.class, desktop);
447         PropertyValue[] loadProps = new PropertyValue[0];
448         return xComponentLoader.loadComponentFromURL(loadUrl, "_blank",
449                                                      0, loadProps);
450     }
451 
452     /** Load a document as template
453      */
454     protected XComponent newDocComponentFromTemplate(String loadUrl)
455         throws java.lang.Exception
456     {
457         // get the remote service manager
458         mxRemoteServiceManager = this.getRemoteServiceManager();
459         // retrieve the Desktop object, we need its XComponentLoader
460         Object desktop = mxRemoteServiceManager.createInstanceWithContext(
461             "com.sun.star.frame.Desktop", mxRemoteContext);
462         XComponentLoader xComponentLoader = (XComponentLoader)
463             UnoRuntime.queryInterface(XComponentLoader.class, desktop);
464 
465         // define load properties according to com.sun.star.document.MediaDescriptor
466         // the boolean property AsTemplate tells the office to create a new document
467         // from the given file
468         PropertyValue[] loadProps = new PropertyValue[1];
469         loadProps[0] = new PropertyValue();
470         loadProps[0].Name = "AsTemplate";
471         loadProps[0].Value = new Boolean(true);
472         // load
473         return xComponentLoader.loadComponentFromURL(loadUrl, "_blank",
474                                                      0, loadProps);
475     }
476 
477     /** Load a document with arguments (text purposes)
478      */
479     protected void storeDocComponent(XComponent xDoc, String storeUrl)
480         throws java.lang.Exception
481     {
482 
483         XStorable xStorable = (XStorable)UnoRuntime.queryInterface(
484             XStorable.class, xDoc);
485         PropertyValue[] storeProps = new PropertyValue[1];
486         storeProps[0] = new PropertyValue();
487         storeProps[0].Name = "FilterName";
488         storeProps[0].Value = "MS Word 97";
489 
490         System.out.println("... store \"PrintDemo.odt\" to \"" + storeUrl + "\".");
491         xStorable.storeAsURL(storeUrl, storeProps);
492     }
493 
494     protected void printDocComponent(XComponent xDoc) throws java.lang.Exception {
495         XPrintable xPrintable = (XPrintable)UnoRuntime.queryInterface(
496             XPrintable.class, xDoc);
497         PropertyValue[] printerDesc = new PropertyValue[1];
498         printerDesc[0] = new PropertyValue();
499         printerDesc[0].Name = "Name";
500         printerDesc[0].Value = aPrinterName;
501 
502         xPrintable.setPrinter(printerDesc);
503 
504         PropertyValue[] printOpts = new PropertyValue[1];
505         printOpts[0] = new PropertyValue();
506         printOpts[0].Name = "Pages";
507         printOpts[0].Value = "1";
508 
509         xPrintable.print(printOpts);
510     }
511 
512     // Setting the whole text of a document as one string
513     protected void BodyTextExample ()
514     {
515         // Body Text and TextDocument example
516         try
517         {
518             // demonstrate simple text insertion
519             mxDocText.setString ( "This is the new body text of the document."
520                                   + "\n\nThis is on the second line.\n\n" );
521         }
522         catch ( Exception e )
523         {
524             e.printStackTrace();
525         }
526     }
527 
528     // Adding a string at the end or the beginning of text
529     protected void TextRangeExample ()
530     {
531         try
532         {
533             // Get a text range referring to the beginning of the text document
534             XTextRange xStart = mxDocText.getStart();
535             // use setString to insert text at the beginning
536             xStart.setString ( "This is text inserted at the beginning.\n\n" );
537             // Get a text range referring to the end of the text document
538             XTextRange xEnd = mxDocText.getEnd();
539             // use setString to insert text at the end
540             xEnd.setString ( "This is text inserted at the end.\n\n" );
541         }
542         catch ( Exception e )
543         {
544             e.printStackTrace();
545         }
546     }
547 
548     /** moving a text cursor, selecting text and overwriting it
549     */
550     protected void TextCursorExample ()
551     {
552         try
553         {
554             // First, get the XSentenceCursor interface of our text cursor
555             XSentenceCursor xSentenceCursor = (XSentenceCursor)
556                 UnoRuntime.queryInterface(XSentenceCursor.class, mxDocCursor );
557             // Goto the next cursor, without selecting it
558             xSentenceCursor.gotoNextSentence( false );
559             // Get the XWordCursor interface of our text cursor
560             XWordCursor xWordCursor = (XWordCursor) UnoRuntime.queryInterface(
561                 XWordCursor.class, mxDocCursor );
562             // Skip the first four words of this sentence and select the fifth
563             xWordCursor.gotoNextWord( false );
564             xWordCursor.gotoNextWord( false );
565             xWordCursor.gotoNextWord( false );
566             xWordCursor.gotoNextWord( false );
567             xWordCursor.gotoNextWord( true );
568             // Use the XSimpleText interface to insert a word at the current cursor
569             // location, over-writing the current selection (the fifth word
570             // selected above)
571             mxDocText.insertString ( xWordCursor, "old ", true );
572 
573             // Access the property set of the cursor, and set the currently
574             // selected text (which is the string we just inserted) to be bold
575             XPropertySet xCursorProps = (XPropertySet) UnoRuntime.queryInterface(
576                 XPropertySet.class, mxDocCursor );
577             xCursorProps.setPropertyValue ( "CharWeight",
578                              new Float(com.sun.star.awt.FontWeight.BOLD) );
579 
580             // replace the '.' at the end of the sentence with a new string
581             xSentenceCursor.gotoEndOfSentence( false );
582             xWordCursor.gotoPreviousWord( true );
583             mxDocText.insertString (xWordCursor,
584                                     ", which has been changed with text cursors!",
585                                     true);
586         }
587         catch ( Exception e )
588         {
589             e.printStackTrace();
590         }
591     }
592 
593     /** This method inserts both a date field and a user field containing the
594      * number '42'
595      */
596     protected void TextFieldExample ()
597     {
598         try
599         {
600             // Use the text document's factory to create a DateTime text field,
601             // and access it's XTextField interface
602             XTextField xDateField = (XTextField) UnoRuntime.queryInterface (
603                 XTextField.class, mxDocFactory.createInstance (
604                     "com.sun.star.text.TextField.DateTime" ) );
605 
606             // Insert it at the end of the document
607             mxDocText.insertTextContent ( mxDocText.getEnd(), xDateField, false );
608 
609             // Use the text document's factory to create a user text field,
610             // and access it's XDependentTextField interface
611             XDependentTextField xUserField =
612                 (XDependentTextField) UnoRuntime.queryInterface (
613                     XDependentTextField.class, mxDocFactory.createInstance (
614                         "com.sun.star.text.TextField.User" ) );
615 
616             // Create a fieldmaster for our newly created User Text field, and
617             // access it's XPropertySet interface
618             XPropertySet xMasterPropSet = (XPropertySet)UnoRuntime.queryInterface(
619                 XPropertySet.class, mxDocFactory.createInstance (
620                     "com.sun.star.text.fieldmaster.User" ) );
621 
622             // Set the name and value of the FieldMaster
623             xMasterPropSet.setPropertyValue ( "Name", "UserEmperor" );
624             xMasterPropSet.setPropertyValue ( "Value", new Integer ( 42 ) );
625 
626             // Attach the field master to the user field
627             xUserField.attachTextFieldMaster ( xMasterPropSet );
628 
629             // Move the cursor to the end of the document
630             mxDocCursor.gotoEnd( false );
631             // insert a paragraph break using the XSimpleText interface
632             mxDocText.insertControlCharacter (
633                 mxDocCursor, ControlCharacter.PARAGRAPH_BREAK, false );
634 
635             // Insert the user field at the end of the document
636             mxDocText.insertTextContent ( mxDocText.getEnd(), xUserField, false );
637         }
638         catch ( Exception e )
639         {
640             e.printStackTrace();
641         }
642     }
643 
644     /** This method demonstrates how to iterate over paragraphs
645      */
646     protected void ParagraphExample ()
647     {
648         try
649         {
650             // The service 'com.sun.star.text.Text' supports the XEnumerationAccess
651             // interface to provide an enumeration of the paragraphs contained by
652             // the text the service refers to.
653 
654             // Here, we access this interface
655             XEnumerationAccess xParaAccess = (XEnumerationAccess)
656                 UnoRuntime.queryInterface(XEnumerationAccess.class, mxDocText );
657             // Call the XEnumerationAccess's only method to access the actual
658             // Enumeration
659             XEnumeration xParaEnum = xParaAccess.createEnumeration();
660 
661             // While there are paragraphs, do things to them
662             while ( xParaEnum.hasMoreElements() )
663             {
664                 // Get a reference to the next paragraphs XServiceInfo interface.
665                 // TextTables are also part of this enumeration access, so we ask
666                 // the element if it is a TextTable, if it doesn't support the
667                 // com.sun.star.text.TextTable service, then it is safe to assume
668                 // that it really is a paragraph
669                 XServiceInfo xInfo = (XServiceInfo) UnoRuntime.queryInterface(
670                     XServiceInfo.class, xParaEnum.nextElement() );
671                 if ( !xInfo.supportsService ( "com.sun.star.text.TextTable" ) )
672                 {
673                     // Access the paragraph's property set...the properties in this
674                     // property set are listed in:
675                     // com.sun.star.style.ParagraphProperties
676                     XPropertySet xSet = (XPropertySet) UnoRuntime.queryInterface(
677                         XPropertySet.class, xInfo );
678                     // Set the justification to be center justified
679                     xSet.setPropertyValue ( "ParaAdjust",
680                              com.sun.star.style.ParagraphAdjust.CENTER );
681                 }
682             }
683         }
684         catch ( Exception e )
685         {
686             e.printStackTrace();
687         }
688     }
689 
690     /** This method returns a random double which isn't too high or too low
691      */
692     protected double getRandomDouble ()
693     {
694         return ( ( maRandom.nextInt() % 1000 ) * maRandom.nextDouble () );
695     }
696 
697     /** This method sets the text colour of the cell referred to by sCellName to
698         white and inserts the string sText in it
699      */
700     protected static void insertIntoCell(String sCellName, String sText,
701                                          XTextTable xTable)
702     {
703         // Access the XText interface of the cell referred to by sCellName
704         XText xCellText = (XText) UnoRuntime.queryInterface(
705             XText.class, xTable.getCellByName ( sCellName ) );
706 
707         // create a text cursor from the cells XText interface
708         XTextCursor xCellCursor = xCellText.createTextCursor();
709         // Get the property set of the cell's TextCursor
710         XPropertySet xCellCursorProps = (XPropertySet)UnoRuntime.queryInterface(
711             XPropertySet.class, xCellCursor );
712 
713         try
714         {
715             // Set the colour of the text to white
716             xCellCursorProps.setPropertyValue( "CharColor", new Integer(16777215));
717         }
718         catch ( Exception e)
719         {
720             e.printStackTrace();
721         }
722         // Set the text in the cell to sText
723         xCellText.setString( sText );
724     }
725 
726     /** This method shows how to create and insert a text table, as well as insert
727 		text and formulae into the cells of the table
728      */
729     protected void TextTableExample ()
730     {
731         try
732         {
733             // Create a new table from the document's factory
734             XTextTable xTable = (XTextTable) UnoRuntime.queryInterface(
735                 XTextTable.class, mxDocFactory .createInstance(
736                     "com.sun.star.text.TextTable" ) );
737 
738             // Specify that we want the table to have 4 rows and 4 columns
739             xTable.initialize( 4, 4 );
740 
741             // Insert the table into the document
742             mxDocText.insertTextContent( mxDocCursor, xTable, false);
743             // Get an XIndexAccess of the table rows
744             XIndexAccess xRows = xTable.getRows();
745 
746             // Access the property set of the first row (properties listed in
747             // service description: com.sun.star.text.TextTableRow)
748             XPropertySet xRow = (XPropertySet) UnoRuntime.queryInterface(
749                 XPropertySet.class, xRows.getByIndex ( 0 ) );
750             // If BackTransparant is false, then the background color is visible
751             xRow.setPropertyValue( "BackTransparent", new Boolean(false));
752             // Specify the color of the background to be dark blue
753             xRow.setPropertyValue( "BackColor", new Integer(6710932));
754 
755             // Access the property set of the whole table
756             XPropertySet xTableProps = (XPropertySet)UnoRuntime.queryInterface(
757                 XPropertySet.class, xTable );
758             // We want visible background colors
759             xTableProps.setPropertyValue( "BackTransparent", new Boolean(false));
760             // Set the background colour to light blue
761             xTableProps.setPropertyValue( "BackColor", new Integer(13421823));
762 
763             // set the text (and text colour) of all the cells in the first row
764             // of the table
765             insertIntoCell( "A1", "First Column", xTable );
766             insertIntoCell( "B1", "Second Column", xTable );
767             insertIntoCell( "C1", "Third Column", xTable );
768             insertIntoCell( "D1", "Results", xTable );
769 
770             // Insert random numbers into the first this three cells of each
771             // remaining row
772             xTable.getCellByName( "A2" ).setValue( getRandomDouble() );
773             xTable.getCellByName( "B2" ).setValue( getRandomDouble() );
774             xTable.getCellByName( "C2" ).setValue( getRandomDouble() );
775 
776             xTable.getCellByName( "A3" ).setValue( getRandomDouble() );
777             xTable.getCellByName( "B3" ).setValue( getRandomDouble() );
778             xTable.getCellByName( "C3" ).setValue( getRandomDouble() );
779 
780             xTable.getCellByName( "A4" ).setValue( getRandomDouble() );
781             xTable.getCellByName( "B4" ).setValue( getRandomDouble() );
782             xTable.getCellByName( "C4" ).setValue( getRandomDouble() );
783 
784             // Set the last cell in each row to be a formula that calculates
785             // the sum of the first three cells
786             xTable.getCellByName( "D2" ).setFormula( "sum <A2:C2>" );
787             xTable.getCellByName( "D3" ).setFormula( "sum <A3:C3>" );
788             xTable.getCellByName( "D4" ).setFormula( "sum <A4:C4>" );
789         }
790         catch (Exception e)
791         {
792             e.printStackTrace();
793         }
794     }
795     /** This method shows how to create and manipulate text frames
796      */
797     protected void TextFrameExample ()
798     {
799         try
800         {
801             // Use the document's factory to create a new text frame and
802             // immediately access it's XTextFrame interface
803             XTextFrame xFrame = (XTextFrame) UnoRuntime.queryInterface (
804                 XTextFrame.class, mxDocFactory.createInstance (
805                     "com.sun.star.text.TextFrame" ) );
806 
807             // Access the XShape interface of the TextFrame
808             XShape xShape = (XShape)UnoRuntime.queryInterface(XShape.class, xFrame);
809             // Access the XPropertySet interface of the TextFrame
810             XPropertySet xFrameProps = (XPropertySet)UnoRuntime.queryInterface(
811                 XPropertySet.class, xFrame );
812 
813             // Set the size of the new Text Frame using the XShape's 'setSize'
814             // method
815             Size aSize = new Size();
816             aSize.Height = 400;
817             aSize.Width = 15000;
818             xShape.setSize(aSize);
819             // Set the AnchorType to
820             // com.sun.star.text.TextContentAnchorType.AS_CHARACTER
821             xFrameProps.setPropertyValue( "AnchorType",
822                                           TextContentAnchorType.AS_CHARACTER );
823             // Go to the end of the text document
824             mxDocCursor.gotoEnd( false );
825             // Insert a new paragraph
826             mxDocText.insertControlCharacter (
827                 mxDocCursor, ControlCharacter.PARAGRAPH_BREAK, false );
828             // Then insert the new frame
829             mxDocText.insertTextContent(mxDocCursor, xFrame, false);
830 
831             // Access the XText interface of the text contained within the frame
832             XText xFrameText = xFrame.getText();
833             // Create a TextCursor over the frame's contents
834             XTextCursor xFrameCursor = xFrameText.createTextCursor();
835             // Insert some text into the frame
836             xFrameText.insertString(
837                 xFrameCursor, "The first line in the newly created text frame.",
838                 false );
839             xFrameText.insertString(
840                 xFrameCursor, "\nThe second line in the new text frame.", false );
841             // Insert a paragraph break into the document (not the frame)
842             mxDocText.insertControlCharacter (
843                 mxDocCursor, ControlCharacter.PARAGRAPH_BREAK, false );
844         }
845         catch (Exception e)
846         {
847             e.printStackTrace();
848         }
849     }
850 
851     /** This example demonstrates the use of the AutoTextContainer, AutoTextGroup
852         and AutoTextEntry services and shows how to create, insert and modify
853         auto text blocks
854      */
855     protected void AutoTextExample ()
856     {
857         try
858         {
859             // Go to the end of the document
860             mxDocCursor.gotoEnd( false );
861             // Insert two paragraphs
862             mxDocText.insertControlCharacter ( mxDocCursor,
863                           ControlCharacter.PARAGRAPH_BREAK, false );
864             mxDocText.insertControlCharacter ( mxDocCursor,
865                           ControlCharacter.PARAGRAPH_BREAK, false );
866             // Position the cursor in the second paragraph
867             XParagraphCursor xParaCursor = (XParagraphCursor)
868                 UnoRuntime.queryInterface(XParagraphCursor.class, mxDocCursor );
869             xParaCursor.gotoPreviousParagraph ( false );
870 
871             // Get an XNameAccess interface to all auto text groups from the
872             // document factory
873             XNameAccess xContainer = (XNameAccess) UnoRuntime.queryInterface(
874                 XNameAccess.class, mxFactory.createInstance (
875                     "com.sun.star.text.AutoTextContainer" ) );
876 
877             // Create a new table at the document factory
878             XTextTable xTable = (XTextTable) UnoRuntime.queryInterface(
879                 XTextTable.class, mxDocFactory .createInstance(
880                     "com.sun.star.text.TextTable" ) );
881 
882             // Store the names of all auto text groups in an array of strings
883             String[] aGroupNames = xContainer.getElementNames();
884 
885             // Make sure we have at least one group name
886             if ( aGroupNames.length > 0 )
887             {
888                 // initialise the table to have a row for every autotext group
889                 // in a single column + one additional row for a header
890                 xTable.initialize( aGroupNames.length+1,1);
891 
892                 // Access the XPropertySet of the table
893                 XPropertySet xTableProps = (XPropertySet)UnoRuntime.queryInterface(
894                     XPropertySet.class, xTable );
895 
896                 // We want a visible background
897                 xTableProps.setPropertyValue( "BackTransparent",
898                                               new Boolean(false));
899 
900                 // We want the background to be light blue
901                 xTableProps.setPropertyValue( "BackColor", new Integer(13421823));
902 
903                 // Inser the table into the document
904                 mxDocText.insertTextContent( mxDocCursor, xTable, false);
905 
906                 // Get an XIndexAccess to all table rows
907                 XIndexAccess xRows = xTable.getRows();
908 
909                 // Get the first row in the table
910                 XPropertySet xRow = (XPropertySet) UnoRuntime.queryInterface(
911                     XPropertySet.class, xRows.getByIndex ( 0 ) );
912 
913                 // We want the background of the first row to be visible too
914                 xRow.setPropertyValue( "BackTransparent", new Boolean(false));
915 
916                 // And let's make it dark blue
917                 xRow.setPropertyValue( "BackColor", new Integer(6710932));
918 
919                 // Put a description of the table contents into the first cell
920                 insertIntoCell( "A1", "AutoText Groups", xTable);
921 
922                 // Create a table cursor pointing at the second cell in the first
923                 // column
924                 XTextTableCursor xTableCursor = xTable.createCursorByCellName("A2");
925 
926                 // Loop over the group names
927                 for ( int i = 0 ; i < aGroupNames.length ; i ++ )
928                 {
929                     // Get the name of the current cell
930                     String sCellName = xTableCursor.getRangeName ();
931 
932                     // Get the XText interface of the current cell
933                     XText xCellText = (XText) UnoRuntime.queryInterface (
934                         XText.class, xTable.getCellByName ( sCellName ) );
935 
936                     // Set the cell contents of the current cell to be
937                     //the name of the of an autotext group
938                     xCellText.setString ( aGroupNames[i] );
939 
940                     // Access the autotext group with this name
941                     XAutoTextGroup xGroup = (XAutoTextGroup)
942                         UnoRuntime.queryInterface (XAutoTextGroup.class,
943                                        xContainer.getByName(aGroupNames[i]));
944 
945                     // Get the titles of each autotext block in this group
946                     String [] aBlockNames = xGroup.getTitles();
947 
948                     // Make sure that the autotext group contains at least one block
949                     if ( aBlockNames.length > 0 )
950                     {
951                         // Split the current cell vertically into two separate cells
952                         xTableCursor.splitRange ( (short) 1, false );
953 
954                         // Put the cursor in the newly created right hand cell
955                         // and select it
956                         xTableCursor.goRight ( (short) 1, false );
957 
958                         // Split this cell horizontally to make a separate cell
959                         // for each Autotext block
960                         if ( ( aBlockNames.length -1 ) > 0 )
961                             xTableCursor.splitRange (
962                                 (short) (aBlockNames.length - 1), true );
963 
964                         // loop over the block names
965                         for ( int j = 0 ; j < aBlockNames.length ; j ++ )
966                         {
967                             // Get the XText interface of the current cell
968                             xCellText = (XText) UnoRuntime.queryInterface (
969                                 XText.class, xTable.getCellByName (
970                                     xTableCursor.getRangeName() ) );
971 
972                             // Set the text contents of the current cell to the
973                             // title of an Autotext block
974                             xCellText.setString ( aBlockNames[j] );
975 
976                             // Move the cursor down one cell
977                             xTableCursor.goDown( (short)1, false);
978                         }
979                     }
980                     // Go back to the cell we originally split
981                     xTableCursor.gotoCellByName ( sCellName, false );
982 
983                                     // Go down one cell
984                     xTableCursor.goDown( (short)1, false);
985                 }
986 
987                 XAutoTextGroup xGroup;
988                 String [] aBlockNames;
989 
990                 // Add a depth so that we only generate 200 numbers before giving up
991                 // on finding a random autotext group that contains autotext blocks
992                 int nDepth = 0;
993                 do
994                 {
995                     // Generate a random, positive number which is lower than
996                     // the number of autotext groups
997                     int nRandom = Math.abs ( maRandom.nextInt() %
998                                              aGroupNames.length );
999 
1000                     // Get the autotext group at this name
1001                     xGroup 	= ( XAutoTextGroup ) UnoRuntime.queryInterface (
1002                         XAutoTextGroup.class, xContainer.getByName (
1003                             aGroupNames[ nRandom ] ) );
1004 
1005                     // Fill our string array with the names of all the blocks in
1006                     // this group
1007                     aBlockNames = xGroup.getElementNames();
1008 
1009                     // increment our depth counter
1010                     ++nDepth;
1011                 }
1012                 while ( nDepth < 200 && aBlockNames.length == 0 );
1013                 // If we managed to find a group containg blocks...
1014                 if ( aBlockNames.length > 0 )
1015                 {
1016                     // Pick a random block in this group and get it's
1017                     // XAutoTextEntry interface
1018                     int nRandom = Math.abs ( maRandom.nextInt()
1019                                              % aBlockNames.length );
1020                     XAutoTextEntry xEntry = ( XAutoTextEntry )
1021                         UnoRuntime.queryInterface (
1022                             XAutoTextEntry.class, xGroup.getByName (
1023                                 aBlockNames[ nRandom ] ) );
1024                     // insert the modified autotext block at the end of the document
1025                     xEntry.applyTo ( mxDocCursor );
1026 
1027                     // Get the titles of all text blocks in this AutoText group
1028                     String [] aBlockTitles = xGroup.getTitles();
1029 
1030                     // Get the XNamed interface of the autotext group
1031                     XNamed xGroupNamed = ( XNamed ) UnoRuntime.queryInterface (
1032                         XNamed.class, xGroup );
1033 
1034                     // Output the short cut and title of the random block
1035                     //and the name of the group it's from
1036                     System.out.println ( "Inserted the Autotext '" +
1037                                          aBlockTitles[nRandom]
1038                                          + "', shortcut '" + aBlockNames[nRandom]
1039                                          + "' from group '"
1040                                          + xGroupNamed.getName());
1041                 }
1042             }
1043 
1044             // Go to the end of the document
1045             mxDocCursor.gotoEnd( false );
1046             // Insert new paragraph
1047             mxDocText.insertControlCharacter (
1048                 mxDocCursor, ControlCharacter.PARAGRAPH_BREAK, false );
1049 
1050             // Position cursor in new paragraph
1051             xParaCursor.gotoPreviousParagraph ( false );
1052 
1053             // Insert a string in the new paragraph
1054             mxDocText.insertString ( mxDocCursor,
1055                                      "Some text for a new autotext block", false );
1056 
1057             // Go to the end of the document
1058             mxDocCursor.gotoEnd( false );
1059         }
1060         catch (Exception e)
1061         {
1062             e.printStackTrace();
1063         }
1064     }
1065 
1066     /** This method demonstrates how to insert indexes and index marks
1067      */
1068     protected void IndexExample ()
1069     {
1070         try
1071         {
1072             // Go to the end of the document
1073             mxDocCursor.gotoEnd( false );
1074             // Insert a new paragraph and position the cursor in it
1075             mxDocText.insertControlCharacter ( mxDocCursor,
1076                           ControlCharacter.PARAGRAPH_BREAK, false );
1077             XParagraphCursor xParaCursor = (XParagraphCursor)
1078                 UnoRuntime.queryInterface( XParagraphCursor.class, mxDocCursor );
1079             xParaCursor.gotoPreviousParagraph ( false );
1080 
1081             // Create a new ContentIndexMark and get it's XPropertySet interface
1082             XPropertySet xEntry = (XPropertySet)UnoRuntime.queryInterface(
1083                 XPropertySet.class,
1084                 mxDocFactory.createInstance("com.sun.star.text.ContentIndexMark"));
1085 
1086             // Set the text to be displayed in the index
1087             xEntry.setPropertyValue(
1088                 "AlternativeText", "Big dogs! Falling on my head!");
1089 
1090             // The Level property _must_ be set
1091             xEntry.setPropertyValue ( "Level", new Short ( (short) 1 ) );
1092 
1093             // Create a ContentIndex and access it's XPropertySet interface
1094             XPropertySet xIndex = (XPropertySet) UnoRuntime.queryInterface(
1095                 XPropertySet.class,
1096                 mxDocFactory.createInstance ( "com.sun.star.text.ContentIndex" ) );
1097 
1098             // Again, the Level property _must_ be set
1099             xIndex.setPropertyValue ( "Level", new Short ( (short) 10 ) );
1100 
1101             // Access the XTextContent interfaces of both the Index and the
1102             // IndexMark
1103             XTextContent xIndexContent = (XTextContent) UnoRuntime.queryInterface(
1104                 XTextContent.class, xIndex );
1105             XTextContent xEntryContent = (XTextContent) UnoRuntime.queryInterface(
1106                 XTextContent.class, xEntry );
1107 
1108             // Insert both in the document
1109             mxDocText.insertTextContent ( mxDocCursor, xEntryContent, false );
1110             mxDocText.insertTextContent ( mxDocCursor, xIndexContent, false );
1111 
1112             // Get the XDocumentIndex interface of the Index
1113             XDocumentIndex xDocIndex = (XDocumentIndex) UnoRuntime.queryInterface(
1114                 XDocumentIndex.class, xIndex );
1115 
1116             // And call it's update method
1117             xDocIndex.update();
1118         }
1119         catch (Exception e)
1120         {
1121             e.printStackTrace();
1122         }
1123     }
1124 
1125     /** This method demonstrates how to create and insert reference marks, and
1126      * GetReference Text Fields
1127      */
1128     protected void ReferenceExample ()
1129     {
1130         try
1131         {
1132             // Go to the end of the document
1133             mxDocCursor.gotoEnd( false );
1134 
1135             // Insert a paragraph break
1136             mxDocText.insertControlCharacter (
1137                 mxDocCursor, ControlCharacter.PARAGRAPH_BREAK, false );
1138 
1139             // Get the Paragraph cursor
1140             XParagraphCursor xParaCursor = (XParagraphCursor)
1141                 UnoRuntime.queryInterface( XParagraphCursor.class, mxDocCursor );
1142 
1143             // Move the cursor into the new paragraph
1144             xParaCursor.gotoPreviousParagraph ( false );
1145 
1146             // Create a new ReferenceMark and get it's XNamed interface
1147             XNamed xRefMark = (XNamed) UnoRuntime.queryInterface(XNamed.class,
1148                   mxDocFactory.createInstance ("com.sun.star.text.ReferenceMark"));
1149 
1150             // Set the name to TableHeader
1151             xRefMark.setName ( "TableHeader" );
1152 
1153             // Get the TextTablesSupplier interface of the document
1154             XTextTablesSupplier xTableSupplier = ( XTextTablesSupplier )
1155                 UnoRuntime.queryInterface(XTextTablesSupplier.class, mxDoc);
1156 
1157             // Get an XIndexAccess of TextTables
1158             XIndexAccess xTables = (XIndexAccess)UnoRuntime.queryInterface(
1159                 XIndexAccess.class, xTableSupplier.getTextTables());
1160 
1161             // We've only inserted one table, so get the first one from index zero
1162             XTextTable xTable = ( XTextTable ) UnoRuntime.queryInterface (
1163                 XTextTable.class, xTables.getByIndex( 0 ) );
1164 
1165             // Get the first cell from the table
1166             XText xTableText = (XText) UnoRuntime.queryInterface(
1167                 XText.class, xTable.getCellByName ( "A1" ) );
1168 
1169             // Get a text cursor for the first cell
1170             XTextCursor xTableCursor = xTableText.createTextCursor();
1171 
1172             // Get the XTextContent interface of the reference mark so we can
1173             // insert it
1174             XTextContent xContent = ( XTextContent ) UnoRuntime.queryInterface (
1175                 XTextContent.class, xRefMark );
1176 
1177             // Insert the reference mark into the first cell of the table
1178             xTableText.insertTextContent ( xTableCursor, xContent, false );
1179 
1180             // Create a 'GetReference' text field to refer to the reference mark
1181             // we just inserted, and get it's XPropertySet interface
1182             XPropertySet xFieldProps = (XPropertySet) UnoRuntime.queryInterface(
1183                 XPropertySet.class, mxDocFactory.createInstance (
1184                     "com.sun.star.text.TextField.GetReference" ) );
1185 
1186             // Get the XReferenceMarksSupplier interface of the document
1187             XReferenceMarksSupplier xRefSupplier = ( XReferenceMarksSupplier )
1188                 UnoRuntime.queryInterface( XReferenceMarksSupplier.class, mxDoc );
1189 
1190             // Get an XNameAccess which refers to all inserted reference marks
1191             XNameAccess xMarks = ( XNameAccess ) UnoRuntime.queryInterface (
1192                 XNameAccess.class, xRefSupplier.getReferenceMarks() );
1193 
1194             // Put the names of each reference mark into an array of strings
1195             String[] aNames = xMarks.getElementNames();
1196 
1197             // Make sure that at least 1 reference mark actually exists
1198             // (well, we just inserted one!)
1199             if ( aNames.length > 0 )
1200             {
1201                 // Output the name of the first reference mark ('TableHeader')
1202                 System.out.println (
1203                     "GetReference text field inserted for ReferenceMark : "
1204                     + aNames[0] );
1205 
1206                 // Set the SourceName of the GetReference text field to
1207                 // 'TableHeader'
1208                 xFieldProps.setPropertyValue ( "SourceName", aNames[0] );
1209 
1210                 // specify that the source is a reference mark (could also be a
1211                 // footnote, bookmark or sequence field )
1212                 xFieldProps.setPropertyValue ( "ReferenceFieldSource",
1213                                 new Short(ReferenceFieldSource.REFERENCE_MARK));
1214 
1215                 // We want the reference displayed as 'above' or 'below'
1216                 xFieldProps.setPropertyValue ( "ReferenceFieldPart",
1217                                 new Short(ReferenceFieldPart.UP_DOWN));
1218 
1219 
1220                 // Get the XTextContent interface of the GetReference text field
1221                 XTextContent xRefContent = (XTextContent) UnoRuntime.queryInterface(
1222                     XTextContent.class, xFieldProps );
1223 
1224                 // Go to the end of the document
1225                 mxDocCursor.gotoEnd( false );
1226 
1227                 // Make some text to precede the reference
1228                 mxDocText.insertString(mxDocText.getEnd(), "The table ", false);
1229 
1230                 // Insert the text field
1231                 mxDocText.insertTextContent(mxDocText.getEnd(), xRefContent, false);
1232 
1233                 // And some text after the reference..
1234                 mxDocText.insertString(mxDocText.getEnd(),
1235                               " contains the sum of some random numbers.", false );
1236 
1237                 // Refresh the document
1238                 XRefreshable xRefresh = (XRefreshable) UnoRuntime.queryInterface(
1239                     XRefreshable.class, mxDoc );
1240                 xRefresh.refresh();
1241             }
1242         }
1243         catch (Exception e)
1244         {
1245             e.printStackTrace();
1246         }
1247     }
1248 
1249     /** This method demonstrates how to create and insert footnotes, and how to
1250         access the XFootnotesSupplier interface of the document
1251      */
1252     protected void FootnoteExample ()
1253     {
1254         try
1255         {
1256             // Create a new footnote from the document factory and get it's
1257             // XFootnote interface
1258             XFootnote xFootnote = (XFootnote) UnoRuntime.queryInterface(
1259                 XFootnote.class, mxDocFactory.createInstance (
1260                     "com.sun.star.text.Footnote" ) );
1261 
1262             // Set the label to 'Numbers'
1263             xFootnote.setLabel ( "Numbers" );
1264 
1265             // Get the footnotes XTextContent interface so we can...
1266             XTextContent xContent = ( XTextContent ) UnoRuntime.queryInterface (
1267                 XTextContent.class, xFootnote );
1268 
1269             // ...insert it into the document
1270             mxDocText.insertTextContent ( mxDocCursor, xContent, false );
1271 
1272             // Get the XFootnotesSupplier interface of the document
1273             XFootnotesSupplier xFootnoteSupplier = (XFootnotesSupplier)
1274                 UnoRuntime.queryInterface(XFootnotesSupplier.class, mxDoc );
1275 
1276             // Get an XIndexAccess interface to all footnotes
1277             XIndexAccess xFootnotes = ( XIndexAccess ) UnoRuntime.queryInterface (
1278                 XIndexAccess.class, xFootnoteSupplier.getFootnotes() );
1279 
1280             // Get the XFootnote interface to the first footnote inserted ('Numbers')
1281             XFootnote xNumbers = ( XFootnote ) UnoRuntime.queryInterface (
1282                 XFootnote.class, xFootnotes.getByIndex( 0 ) );
1283 
1284             // Get the XSimpleText interface to the Footnote
1285             XSimpleText xSimple = (XSimpleText ) UnoRuntime.queryInterface (
1286                 XSimpleText.class, xNumbers );
1287 
1288             // Create a text cursor for the foot note text
1289             XTextRange xRange = (XTextRange ) UnoRuntime.queryInterface (
1290                 XTextRange.class, xSimple.createTextCursor() );
1291 
1292             // And insert the actual text of the footnote.
1293             xSimple.insertString (
1294                 xRange, "  The numbers were generated by using java.util.Random", false );
1295         }
1296         catch (Exception e)
1297         {
1298             e.printStackTrace();
1299         }
1300     }
1301 
1302     /** This method demonstrates how to create and manipulate shapes, and how to
1303         access the draw page of the document to insert shapes
1304      */
1305     protected void DrawPageExample ()
1306     {
1307         try
1308         {
1309             // Go to the end of the document
1310             mxDocCursor.gotoEnd( false );
1311             // Insert two new paragraphs
1312             mxDocText.insertControlCharacter(mxDocCursor,
1313                           ControlCharacter.PARAGRAPH_BREAK, false);
1314             mxDocText.insertControlCharacter(mxDocCursor,
1315                           ControlCharacter.PARAGRAPH_BREAK, false);
1316 
1317             // Get the XParagraphCursor interface of our document cursor
1318             XParagraphCursor xParaCursor = (XParagraphCursor)
1319                 UnoRuntime.queryInterface( XParagraphCursor.class, mxDocCursor );
1320 
1321             // Position the cursor in the 2nd paragraph
1322             xParaCursor.gotoPreviousParagraph ( false );
1323 
1324             // Create a RectangleShape using the document factory
1325             XShape xRect = (XShape) UnoRuntime.queryInterface(
1326                 XShape.class, mxDocFactory.createInstance (
1327                     "com.sun.star.drawing.RectangleShape" ) );
1328 
1329             // Create an EllipseShape using the document factory
1330             XShape xEllipse = (XShape) UnoRuntime.queryInterface(
1331                 XShape.class, mxDocFactory.createInstance (
1332                     "com.sun.star.drawing.EllipseShape" ) );
1333 
1334             // Set the size of both the ellipse and the rectangle
1335             Size aSize = new Size();
1336             aSize.Height = 4000;
1337             aSize.Width = 10000;
1338             xRect.setSize(aSize);
1339             aSize.Height = 3000;
1340             aSize.Width = 6000;
1341             xEllipse.setSize ( aSize );
1342 
1343             // Set the position of the Rectangle to the right of the ellipse
1344             Point aPoint = new Point();
1345             aPoint.X = 6100;
1346             aPoint.Y = 0;
1347             xRect.setPosition ( aPoint );
1348 
1349             // Get the XPropertySet interfaces of both shapes
1350             XPropertySet xRectProps = (XPropertySet) UnoRuntime.queryInterface(
1351                 XPropertySet.class, xRect );
1352             XPropertySet xEllipseProps = (XPropertySet) UnoRuntime.queryInterface(
1353                 XPropertySet.class, xEllipse );
1354 
1355             // And set the AnchorTypes of both shapes to 'AT_PARAGRAPH'
1356             xRectProps.setPropertyValue ( "AnchorType",
1357                                           TextContentAnchorType.AT_PARAGRAPH );
1358             xEllipseProps.setPropertyValue ( "AnchorType",
1359                                              TextContentAnchorType.AT_PARAGRAPH );
1360 
1361             // Access the XDrawPageSupplier interface of the document
1362             XDrawPageSupplier xDrawPageSupplier = (XDrawPageSupplier)
1363                 UnoRuntime.queryInterface (XDrawPageSupplier.class, mxDoc );
1364 
1365             // Get the XShapes interface of the draw page
1366             XShapes xShapes = ( XShapes ) UnoRuntime.queryInterface (
1367                 XShapes.class, xDrawPageSupplier.getDrawPage () );
1368 
1369             // Add both shapes
1370             xShapes.add ( xEllipse );
1371             xShapes.add ( xRect );
1372 
1373             /*
1374               This doesn't work, I am assured that FME and AMA are fixing it.
1375 
1376               XShapes xGrouper = (XShapes) UnoRuntime.queryInterface(
1377               XShapes.class, mxDocFactory.createInstance (
1378               "com.sun.star.drawing.GroupShape" ) );
1379 
1380               XShape xGrouperShape = (XShape) UnoRuntime.queryInterface(
1381                      XShape.class, xGrouper );
1382               xShapes.add ( xGrouperShape );
1383 
1384               xGrouper.add ( xRect );
1385               xGrouper.add ( xEllipse );
1386 
1387               XShapeGrouper xShapeGrouper = (XShapeGrouper)
1388               UnoRuntime.queryInterface(XShapeGrouper.class, xShapes);
1389               xShapeGrouper.group ( xGrouper );
1390             */
1391 
1392         }
1393         catch (Exception e)
1394         {
1395             e.printStackTrace();
1396         }
1397     }
1398 
1399     /** This method demonstrates how to create, insert and apply styles
1400      */
1401     protected void StylesExample ()
1402     {
1403         try
1404         {
1405             // Go to the end of the document
1406             mxDocCursor.gotoEnd( false );
1407 
1408             // Insert two paragraph breaks
1409             mxDocText.insertControlCharacter (
1410                 mxDocCursor, ControlCharacter.PARAGRAPH_BREAK, false );
1411             mxDocText.insertControlCharacter (
1412                 mxDocCursor, ControlCharacter.PARAGRAPH_BREAK, false );
1413 
1414             // Create a new style from the document's factory
1415             XStyle xStyle = (XStyle) UnoRuntime.queryInterface(
1416                 XStyle.class, mxDocFactory.createInstance(
1417                     "com.sun.star.style.ParagraphStyle" ) );
1418 
1419             // Access the XPropertySet interface of the new style
1420             XPropertySet xStyleProps = (XPropertySet) UnoRuntime.queryInterface(
1421                 XPropertySet.class, xStyle );
1422 
1423             // Give the new style a light blue background
1424             xStyleProps.setPropertyValue ( "ParaBackColor", new Integer (13421823));
1425 
1426             // Get the StyleFamiliesSupplier interface of the document
1427             XStyleFamiliesSupplier xSupplier = (XStyleFamiliesSupplier)
1428                 UnoRuntime.queryInterface(XStyleFamiliesSupplier.class, mxDoc);
1429 
1430             // Use the StyleFamiliesSupplier interface to get the XNameAccess
1431             // interface of the actual style families
1432             XNameAccess xFamilies = ( XNameAccess ) UnoRuntime.queryInterface (
1433                 XNameAccess.class, xSupplier.getStyleFamilies() );
1434 
1435             // Access the 'ParagraphStyles' Family
1436             XNameContainer xFamily = (XNameContainer ) UnoRuntime.queryInterface (
1437                         XNameContainer.class,
1438                         xFamilies.getByName ( "ParagraphStyles" ) );
1439 
1440             // Insert the newly created style into the ParagraphStyles family
1441             xFamily.insertByName ( "All-Singing All-Dancing Style", xStyle );
1442 
1443             // Get the XParagraphCursor interface of the document cursor
1444             XParagraphCursor xParaCursor = (XParagraphCursor)
1445                 UnoRuntime.queryInterface( XParagraphCursor.class, mxDocCursor );
1446 
1447             // Select the first paragraph inserted
1448             xParaCursor.gotoPreviousParagraph ( false );
1449             xParaCursor.gotoPreviousParagraph ( true );
1450 
1451             // Access the property set of the cursor selection
1452             XPropertySet xCursorProps = (XPropertySet) UnoRuntime.queryInterface(
1453                 XPropertySet.class, mxDocCursor );
1454 
1455             // Set the style of the cursor selection to our newly created style
1456             xCursorProps.setPropertyValue ( "ParaStyleName",
1457                                             "All-Singing All-Dancing Style" );
1458 
1459             // Go back to the end
1460             mxDocCursor.gotoEnd ( false );
1461 
1462             // Select the last paragraph in the document
1463             xParaCursor.gotoNextParagraph ( true );
1464 
1465             // And reset it's style to 'Standard' (the programmatic name for
1466             // the default style)
1467             xCursorProps.setPropertyValue ( "ParaStyleName", "Standard" );
1468         }
1469         catch (Exception e)
1470         {
1471             e.printStackTrace();
1472         }
1473     }
1474 
1475     /** This method demonstrates how to set numbering types and numbering levels
1476         using the com.sun.star.text.NumberingRules service
1477      */
1478     protected void NumberingExample ()
1479     {
1480         try
1481         {
1482             // Go to the end of the document
1483             mxDocCursor.gotoEnd( false );
1484             // Get the RelativeTextContentInsert interface of the document
1485             XRelativeTextContentInsert xRelative =
1486                 (XRelativeTextContentInsert ) UnoRuntime.queryInterface (
1487                     XRelativeTextContentInsert.class, mxDocText );
1488 
1489             // Use the document's factory to create the NumberingRules service,
1490             // and get it's XIndexAccess interface
1491             XIndexAccess xNum = (XIndexAccess) UnoRuntime.queryInterface(
1492                 XIndexAccess.class,
1493                 mxDocFactory.createInstance( "com.sun.star.text.NumberingRules" ) );
1494 
1495             // Also get the NumberingRule's XIndexReplace interface
1496             XIndexReplace xReplace = (XIndexReplace) UnoRuntime.queryInterface(
1497                 XIndexReplace.class, xNum );
1498 
1499             // Create an array of XPropertySets, one for each of the three
1500             // paragraphs we're about to create
1501             XPropertySet xParas[] = new XPropertySet [ 3 ];
1502             for ( int i = 0 ; i < 3 ; ++ i )
1503             {
1504                 // Create a new paragraph
1505                 XTextContent xNewPara = (XTextContent) UnoRuntime.queryInterface(
1506                     XTextContent.class, mxDocFactory.createInstance(
1507                         "com.sun.star.text.Paragraph" ) );
1508 
1509                 // Get the XPropertySet interface of the new paragraph and put
1510                 // it in our array
1511                 xParas[i] = (XPropertySet) UnoRuntime.queryInterface(
1512                     XPropertySet.class, xNewPara );
1513 
1514                 // Insert the new paragraph into the document after the fish
1515                 // section. As it is an insert relative to the fish section, the
1516                 // first paragraph inserted will be below the next two
1517                 xRelative.insertTextContentAfter ( xNewPara, mxFishSection );
1518 
1519                 // Separate from the above, but also needs to be done three times
1520 
1521                 // Get the PropertyValue sequence for this numbering level
1522                 PropertyValue [] aProps = (PropertyValue [] ) xNum.getByIndex ( i );
1523 
1524                 // Iterate over the PropertyValue's for this numbering level,
1525                 // looking for the 'NumberingType' property
1526                 for ( int j = 0 ; j < aProps.length ; ++j )
1527                 {
1528                     if ( aProps[j].Name.equals ( "NumberingType" ) )
1529                     {
1530                         // Once we find it, set it's value to a new type,
1531                         // dependent on which numbering level we're currently on
1532                         switch ( i )
1533                         {
1534                         case 0 : aProps[j].Value =
1535                                      new Short(NumberingType.ROMAN_UPPER);
1536                             break;
1537                         case 1 : aProps[j].Value =
1538                                      new Short(NumberingType.CHARS_UPPER_LETTER);
1539                             break;
1540                         case 2 : aProps[j].Value =
1541                                      new Short(NumberingType.ARABIC);
1542                             break;
1543                         }
1544                         // Put the updated PropertyValue sequence back into the
1545                         // NumberingRules service
1546                         xReplace.replaceByIndex ( i, aProps );
1547                         break;
1548                     }
1549                 }
1550             }
1551             // Get the XParagraphCursor interface of our text cursro
1552             XParagraphCursor xParaCursor = (XParagraphCursor)
1553                 UnoRuntime.queryInterface( XParagraphCursor.class, mxDocCursor );
1554             // Go to the end of the document, then select the preceding paragraphs
1555             mxDocCursor.gotoEnd ( false );
1556             xParaCursor.gotoPreviousParagraph ( false );
1557             xParaCursor.gotoPreviousParagraph ( true );
1558             xParaCursor.gotoPreviousParagraph ( true );
1559 
1560             // Get the XPropertySet of the cursor's currently selected text
1561             XPropertySet xCursorProps = (XPropertySet) UnoRuntime.queryInterface(
1562                 XPropertySet.class, mxDocCursor );
1563 
1564             // Set the updated Numbering rules to the cursor's property set
1565             xCursorProps.setPropertyValue ( "NumberingRules", xNum );
1566             mxDocCursor.gotoEnd( false );
1567 
1568             // Set the first paragraph that was inserted to a numbering level of
1569             // 2 (thus it will have Arabic style numbering)
1570             xParas[0].setPropertyValue ( "NumberingLevel", new Short((short) 2));
1571 
1572             // Set the second paragraph that was inserted to a numbering level of
1573             // 1 (thus it will have 'Chars Upper Letter' style numbering)
1574             xParas[1].setPropertyValue ( "NumberingLevel", new Short((short) 1));
1575 
1576             // Set the third paragraph that was inserted to a numbering level of
1577             // 0 (thus it will have 'Chars Upper Letter' style numbering)
1578             xParas[2].setPropertyValue ( "NumberingLevel", new Short((short) 0));
1579             }
1580         catch (Exception e)
1581         {
1582             e.printStackTrace();
1583         }
1584     }
1585 
1586     /** This method demonstrates how to create linked and unlinked sections
1587      */
1588     protected void TextSectionExample ()
1589     {
1590         try
1591         {
1592             // Go to the end of the document
1593             mxDocCursor.gotoEnd( false );
1594             // Insert two paragraph breaks
1595             mxDocText.insertControlCharacter (
1596                 mxDocCursor, ControlCharacter.PARAGRAPH_BREAK, false );
1597             mxDocText.insertControlCharacter (
1598                 mxDocCursor, ControlCharacter.PARAGRAPH_BREAK, true );
1599 
1600             // Create a new TextSection from the document factory and access
1601             // it's XNamed interface
1602             XNamed xChildNamed = (XNamed) UnoRuntime.queryInterface(
1603                 XNamed.class, mxDocFactory.createInstance(
1604                     "com.sun.star.text.TextSection" ) );
1605             // Set the new sections name to 'Child_Section'
1606             xChildNamed.setName ( "Child_Section" );
1607 
1608             // Access the Child_Section's XTextContent interface and insert it
1609             // into the document
1610             XTextContent xChildSection = (XTextContent) UnoRuntime.queryInterface(
1611                 XTextContent.class, xChildNamed );
1612             mxDocText.insertTextContent ( mxDocCursor, xChildSection, false );
1613 
1614             // Access the XParagraphCursor interface of our text cursor
1615             XParagraphCursor xParaCursor = (XParagraphCursor)
1616                 UnoRuntime.queryInterface(XParagraphCursor.class, mxDocCursor);
1617 
1618             // Go back one paragraph (into Child_Section)
1619             xParaCursor.gotoPreviousParagraph ( false );
1620 
1621             // Insert a string into the Child_Section
1622             mxDocText.insertString ( mxDocCursor, "This is a test", false );
1623 
1624             // Go to the end of the document
1625             mxDocCursor.gotoEnd( false );
1626 
1627             // Go back two paragraphs
1628             xParaCursor.gotoPreviousParagraph ( false );
1629             xParaCursor.gotoPreviousParagraph ( false );
1630             // Go to the end of the document, selecting the two paragraphs
1631             mxDocCursor.gotoEnd ( true );
1632 
1633             // Create another text section and access it's XNamed interface
1634             XNamed xParentNamed = (XNamed) UnoRuntime.queryInterface(XNamed.class,
1635                       mxDocFactory.createInstance("com.sun.star.text.TextSection"));
1636 
1637             // Set this text section's name to Parent_Section
1638             xParentNamed.setName ( "Parent_Section" );
1639 
1640             // Access the Parent_Section's XTextContent interface ...
1641             XTextContent xParentSection = (XTextContent) UnoRuntime.queryInterface(
1642                 XTextContent.class, xParentNamed );
1643             // ...and insert it into the document
1644             mxDocText.insertTextContent ( mxDocCursor, xParentSection, false );
1645 
1646             // Go to the end of the document
1647             mxDocCursor.gotoEnd ( false );
1648             // Insert a new paragraph
1649             mxDocText.insertControlCharacter (
1650                 mxDocCursor, ControlCharacter.PARAGRAPH_BREAK, false );
1651             // And select the new pargraph
1652             xParaCursor.gotoPreviousParagraph ( true );
1653 
1654             // Create a new Text Section and access it's XNamed interface
1655             XNamed xLinkNamed = (XNamed) UnoRuntime.queryInterface(XNamed.class,
1656                       mxDocFactory.createInstance("com.sun.star.text.TextSection"));
1657             // Set the new text section's name to Linked_Section
1658             xLinkNamed.setName ( "Linked_Section" );
1659 
1660             // Access the Linked_Section's XTextContent interface
1661             XTextContent xLinkedSection = (XTextContent) UnoRuntime.queryInterface(
1662                 XTextContent.class, xLinkNamed );
1663             // And insert the Linked_Section into the document
1664             mxDocText.insertTextContent ( mxDocCursor, xLinkedSection, false );
1665 
1666             // Access the Linked_Section's XPropertySet interface
1667             XPropertySet xLinkProps = (XPropertySet)UnoRuntime.queryInterface(
1668                 XPropertySet.class, xLinkNamed );
1669             // Set the linked section to be linked to the Child_Section
1670             xLinkProps.setPropertyValue ( "LinkRegion", "Child_Section" );
1671 
1672             // Access the XPropertySet interface of the Child_Section
1673             XPropertySet xChildProps = (XPropertySet) UnoRuntime.queryInterface(
1674                 XPropertySet.class, xChildNamed );
1675             // Set the Child_Section's background colour to blue
1676             xChildProps.setPropertyValue( "BackColor", new Integer(13421823));
1677 
1678             // Refresh the document, so the linked section matches the Child_Section
1679             XRefreshable xRefresh = (XRefreshable) UnoRuntime.queryInterface(
1680                 XRefreshable.class, mxDoc );
1681             xRefresh.refresh();
1682         }
1683         catch (Exception e)
1684         {
1685             e.printStackTrace();
1686         }
1687     }
1688 
1689     /** This method demonstrates the XTextColumns interface and how to insert a
1690         blank paragraph using the XRelativeTextContentInsert interface
1691      */
1692     protected void TextColumnsExample ()
1693     {
1694         try
1695         {
1696             // Go to the end of the doucment
1697             mxDocCursor.gotoEnd( false );
1698             // insert a new paragraph
1699             mxDocText.insertControlCharacter (
1700                 mxDocCursor, ControlCharacter.PARAGRAPH_BREAK, false );
1701 
1702             // insert the string 'I am a fish.' 100 times
1703             for ( int i = 0 ; i < 100 ; ++i )
1704             {
1705                 mxDocText.insertString ( mxDocCursor, "I am a fish.", false );
1706             }
1707             // insert a paragraph break after the text
1708             mxDocText.insertControlCharacter (
1709                 mxDocCursor, ControlCharacter.PARAGRAPH_BREAK, false );
1710 
1711             // Get the XParagraphCursor interface of our text cursor
1712             XParagraphCursor xParaCursor = (XParagraphCursor)
1713                 UnoRuntime.queryInterface( XParagraphCursor.class, mxDocCursor );
1714             // Jump back before all the text we just inserted
1715             xParaCursor.gotoPreviousParagraph ( false );
1716             xParaCursor.gotoPreviousParagraph ( false );
1717 
1718             // Insert a string at the beginning of the block of text
1719             mxDocText.insertString ( mxDocCursor, "Fish section begins:", false );
1720 
1721             // Then select all of the text
1722             xParaCursor.gotoNextParagraph ( true );
1723             xParaCursor.gotoNextParagraph ( true );
1724 
1725             // Create a new text section and get it's XNamed interface
1726             XNamed xSectionNamed = (XNamed) UnoRuntime.queryInterface(XNamed.class,
1727                       mxDocFactory.createInstance("com.sun.star.text.TextSection"));
1728 
1729             // Set the name of our new section (appropriately) to 'Fish'
1730             xSectionNamed.setName ( "Fish" );
1731 
1732             // Create the TextColumns service and get it's XTextColumns interface
1733             XTextColumns xColumns = (XTextColumns) UnoRuntime.queryInterface(
1734                 XTextColumns.class,
1735                 mxDocFactory.createInstance ( "com.sun.star.text.TextColumns" ) );
1736 
1737             // We want three columns
1738             xColumns.setColumnCount ( (short) 3 );
1739 
1740             // Get the TextColumns, and make the middle one narrow with a larger
1741             // margin on the left than the right
1742             TextColumn[]  aSequence = xColumns.getColumns ();
1743             aSequence[1].Width /= 2;
1744             aSequence[1].LeftMargin = 350;
1745             aSequence[1].RightMargin = 200;
1746             // Set the updated TextColumns back to the XTextColumns
1747             xColumns.setColumns ( aSequence );
1748 
1749             // Get the property set interface of our 'Fish' section
1750             XPropertySet xSectionProps = (XPropertySet) UnoRuntime.queryInterface(
1751                 XPropertySet.class, xSectionNamed );
1752 
1753             // Set the columns to the Text Section
1754             xSectionProps.setPropertyValue ( "TextColumns", xColumns );
1755 
1756             // Get the XTextContent interface of our 'Fish' section
1757             mxFishSection = (XTextContent) UnoRuntime.queryInterface(
1758                 XTextContent.class, xSectionNamed );
1759 
1760             // Insert the 'Fish' section over the currently selected text
1761             mxDocText.insertTextContent ( mxDocCursor, mxFishSection, true );
1762 
1763             // Get the wonderful XRelativeTextContentInsert interface
1764             XRelativeTextContentInsert xRelative = (XRelativeTextContentInsert )
1765                 UnoRuntime.queryInterface (
1766                     XRelativeTextContentInsert.class, mxDocText );
1767 
1768             // Create a new empty paragraph and get it's XTextContent interface
1769             XTextContent xNewPara = (XTextContent) UnoRuntime.queryInterface(
1770                 XTextContent.class,
1771                 mxDocFactory.createInstance("com.sun.star.text.Paragraph"));
1772 
1773             // Insert the empty paragraph after the fish Text Section
1774             xRelative.insertTextContentAfter ( xNewPara, mxFishSection );
1775         }
1776         catch (Exception e)
1777         {
1778             e.printStackTrace();
1779         }
1780     }
1781 }
1782