/* -*- Mode: Java; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
/*************************************************************************
*
* The Contents of this file are made available subject to the terms of
* the BSD license.
*
* Copyright 2000, 2010 Oracle and/or its affiliates.
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* 3. Neither the name of Sun Microsystems, Inc. nor the names of its
* contributors may be used to endorse or promote products derived
* from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
* OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
* TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
* USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
*************************************************************************/
import java.util.HashMap;
import java.util.Iterator;
import java.util.Random;
import com.sun.star.awt.Point;
import com.sun.star.awt.Size;
import com.sun.star.beans.PropertyValue;
import com.sun.star.beans.XPropertySet;
import com.sun.star.container.XEnumeration;
import com.sun.star.container.XEnumerationAccess;
import com.sun.star.container.XIndexAccess;
import com.sun.star.container.XIndexReplace;
import com.sun.star.container.XNameAccess;
import com.sun.star.container.XNameContainer;
import com.sun.star.container.XNamed;
import com.sun.star.drawing.XDrawPageSupplier;
import com.sun.star.drawing.XShape;
import com.sun.star.drawing.XShapes;
import com.sun.star.frame.XComponentLoader;
import com.sun.star.frame.XController;
import com.sun.star.frame.XDesktop;
import com.sun.star.frame.XModel;
import com.sun.star.frame.XStorable;
import com.sun.star.lang.XComponent;
import com.sun.star.lang.XMultiComponentFactory;
import com.sun.star.lang.XMultiServiceFactory;
import com.sun.star.lang.XServiceInfo;
import com.sun.star.style.NumberingType;
import com.sun.star.style.XStyle;
import com.sun.star.style.XStyleFamiliesSupplier;
import com.sun.star.text.ControlCharacter;
import com.sun.star.text.ReferenceFieldPart;
import com.sun.star.text.ReferenceFieldSource;
import com.sun.star.text.TextColumn;
import com.sun.star.text.TextContentAnchorType;
import com.sun.star.text.XAutoTextEntry;
import com.sun.star.text.XAutoTextGroup;
import com.sun.star.text.XBookmarksSupplier;
import com.sun.star.text.XDependentTextField;
import com.sun.star.text.XDocumentIndex;
import com.sun.star.text.XFootnote;
import com.sun.star.text.XFootnotesSupplier;
import com.sun.star.text.XPageCursor;
import com.sun.star.text.XParagraphCursor;
import com.sun.star.text.XReferenceMarksSupplier;
import com.sun.star.text.XRelativeTextContentInsert;
import com.sun.star.text.XSentenceCursor;
import com.sun.star.text.XSimpleText;
import com.sun.star.text.XText;
import com.sun.star.text.XTextColumns;
import com.sun.star.text.XTextContent;
import com.sun.star.text.XTextCursor;
import com.sun.star.text.XTextDocument;
import com.sun.star.text.XTextField;
import com.sun.star.text.XTextFieldsSupplier;
import com.sun.star.text.XTextFrame;
import com.sun.star.text.XTextRange;
import com.sun.star.text.XTextTable;
import com.sun.star.text.XTextTableCursor;
import com.sun.star.text.XTextTablesSupplier;
import com.sun.star.text.XTextViewCursor;
import com.sun.star.text.XTextViewCursorSupplier;
import com.sun.star.text.XWordCursor;
import com.sun.star.uno.UnoRuntime;
import com.sun.star.uno.XComponentContext;
import com.sun.star.util.XRefreshable;
import com.sun.star.view.XPrintable;
public class TextDocuments {
// adjust these constant to your local printer!
private static String sOutputDir;
private static final String aPrinterName = "\\\\so-print\\xml3sof";
private XComponentContext mxRemoteContext = null;
private XMultiComponentFactory mxRemoteServiceManager = null;
private XTextDocument mxDoc = null;
private XMultiServiceFactory mxDocFactory = null;
private XMultiServiceFactory mxFactory = null;
private XText mxDocText = null;
private XTextCursor mxDocCursor = null;
private XTextContent mxFishSection = null;
private Random maRandom = null;
/**
* @param args the command line arguments
*/
public static void main(String[] args) {
TextDocuments textDocuments1 = new TextDocuments();
try {
// output directory for store test;
sOutputDir = args[0];
textDocuments1.runDemo();
} catch (java.lang.Exception e) {
System.out.println(e.getMessage());
e.printStackTrace();
} finally {
System.exit(0);
}
}
protected void runDemo() throws java.lang.Exception {
storePrintExample(); // depends on printer name
templateExample();
viewCursorExample(); // makes changes to the current document,
// use with care
editingExample();
}
/** Sample for use of templates
* This sample uses the file TextTemplateWithUserFields.odt from the Samples
* folder. The file contains a number of User text fields (Variables - User)
* and a bookmark which we use to fill in various values
*/
protected void templateExample() throws java.lang.Exception {
// create a small hashtable that simulates a rowset
HashMap<String,String> recipient = new HashMap<String,String>();
recipient.put("Company", "Manatee Books");
recipient.put("Contact", "Rod Martin");
recipient.put("ZIP", "34567");
recipient.put("City", "Fort Lauderdale");
recipient.put("State", "Florida");
// load template with User fields and bookmark
java.io.File sourceFile = new java.io.File("TextTemplateWithUserFields.odt");
StringBuffer sTemplateFileUrl = new StringBuffer("file:///");
sTemplateFileUrl.append(sourceFile.getCanonicalPath().replace('\\', '/'));
XComponent xTemplateComponent =
newDocComponentFromTemplate( sTemplateFileUrl.toString() );
// get XTextFieldsSupplier, XBookmarksSupplier interfaces
XTextFieldsSupplier xTextFieldsSupplier = UnoRuntime.queryInterface(XTextFieldsSupplier.class,
xTemplateComponent);
XBookmarksSupplier xBookmarksSupplier = UnoRuntime.queryInterface(XBookmarksSupplier.class, xTemplateComponent);
// access the TextFields and the TextFieldMasters collections
XNameAccess xNamedFieldMasters = xTextFieldsSupplier.getTextFieldMasters();
XEnumerationAccess xEnumeratedFields = xTextFieldsSupplier.getTextFields();
// iterate over hashtable and insert values into field masters
for(Iterator<String> iter = recipient.keySet().iterator(); iter.hasNext(); ) {
// get column name
String key = iter.next();
// access corresponding field master
Object fieldMaster = xNamedFieldMasters.getByName(
"com.sun.star.text.fieldmaster.User." + key);
// query the XPropertySet interface, we need to set the Content property
XPropertySet xPropertySet = UnoRuntime.queryInterface(
XPropertySet.class, fieldMaster);
// insert the column value into field master
xPropertySet.setPropertyValue("Content", recipient.get(key));
}
// afterwards we must refresh the textfields collection
XRefreshable xRefreshable = UnoRuntime.queryInterface(
XRefreshable.class, xEnumeratedFields);
xRefreshable.refresh();
// accessing the Bookmarks collection of the document
XNameAccess xNamedBookmarks = xBookmarksSupplier.getBookmarks();
// find the bookmark named "Subscription"
Object bookmark = xNamedBookmarks.getByName("Subscription");
// we need its XTextRange which is available from getAnchor(),
// so query for XTextContent
XTextContent xBookmarkContent = UnoRuntime.queryInterface(
XTextContent.class, bookmark);
// get the anchor of the bookmark (its XTextRange)
XTextRange xBookmarkRange = xBookmarkContent.getAnchor();
// set string at the bookmark position
xBookmarkRange.setString("subscription for the Manatee Journal");
}
/** Sample for document changes, starting at the current view cursor position
* The sample changes the paragraph style and the character style at the
* current view cursor selection Open the sample file ViewCursorExampleFile,
* select some text and run the example.
* The current paragraph will be set to Quotations paragraph style.
* The selected text will be set to Quotation character style.
*/
private void viewCursorExample() throws java.lang.Exception {
// get the remote service manager
mxRemoteServiceManager = this.getRemoteServiceManager();
// get the Desktop service
Object desktop = mxRemoteServiceManager.createInstanceWithContext(
"com.sun.star.frame.Desktop", mxRemoteContext);
// query its XDesktop interface, we need the current component
XDesktop xDesktop = UnoRuntime.queryInterface(
XDesktop.class, desktop);
// retrieve the current component and access the controller
XComponent xCurrentComponent = xDesktop.getCurrentComponent();
XModel xModel = UnoRuntime.queryInterface(XModel.class,
xCurrentComponent);
XController xController = xModel.getCurrentController();
// the controller gives us the TextViewCursor
XTextViewCursorSupplier xViewCursorSupplier =
UnoRuntime.queryInterface(
XTextViewCursorSupplier.class, xController);
XTextViewCursor xViewCursor = xViewCursorSupplier.getViewCursor();
// query its XPropertySet interface, we want to set character and paragraph
// properties
XPropertySet xCursorPropertySet = UnoRuntime.queryInterface(
XPropertySet.class, xViewCursor);
// set the appropriate properties for character and paragraph style
xCursorPropertySet.setPropertyValue("CharStyleName", "Quotation");
xCursorPropertySet.setPropertyValue("ParaStyleName", "Quotations");
// print the current page number
XPageCursor xPageCursor = UnoRuntime.queryInterface(
XPageCursor.class, xViewCursor);
System.out.println("The current page number is " + xPageCursor.getPage());
// the model cursor is much more powerful, so
// we create a model cursor at the current view cursor position with the
// following steps:
// get the Text service from the TextViewCursor, it is an XTextRange:
XText xDocumentText = xViewCursor.getText();
// create a model cursor from the viewcursor
XTextCursor xModelCursor = xDocumentText.createTextCursorByRange(
xViewCursor.getStart());
// now we could query XWordCursor, XSentenceCursor and XParagraphCursor
// or XDocumentInsertable, XSortable or XContentEnumerationAccess
// and work with the properties of com.sun.star.text.TextCursor
// in this case we just go to the end of the paragraph and add some text.
XParagraphCursor xParagraphCursor = UnoRuntime.queryInterface(XParagraphCursor.class, xModelCursor);
// goto the end of the paragraph
xParagraphCursor.gotoEndOfParagraph(false);
xParagraphCursor.setString(" ***** Fin de semana! ******");
}
/** Sample for the various editing facilities described in the
* developer's manual
*/
private void editingExample () throws java.lang.Exception {
// create empty swriter document
XComponent xEmptyWriterComponent = newDocComponent("swriter");
// query its XTextDocument interface to get the text
mxDoc = UnoRuntime.queryInterface(
XTextDocument.class, xEmptyWriterComponent);
// get a reference to the body text of the document
mxDocText = mxDoc.getText();
// Get a reference to the document's property set. This contains document
// information like the current word count
UnoRuntime.queryInterface(XPropertySet.class, mxDoc );
// Simple text insertion example
BodyTextExample ();
// Example using text ranges to insert strings at the beginning or end
// of a text range
TextRangeExample ();
// Create a document cursor and remember it, it will be used in most
// of the following examples
mxDocCursor = mxDocText.createTextCursor();
// Demonstrate some of the different cursor types (word, sentence)
TextCursorExample ();
// Access the text document's multi service factory, which we will need
// for most of the following examples
mxDocFactory = UnoRuntime.queryInterface(
XMultiServiceFactory.class, mxDoc );
// Examples of text fields, dependent text fields and field masters
TextFieldExample ();
// Example of using an XEnumerationAccess to iterate over paragraphs and
// set properties of each paragraph as we do so
ParagraphExample ();
// Example of creating and manipulating a text frame
TextFrameExample ();
// Example of creating and manipulating a text table, text table rows
// and text table cells get a new random generator
maRandom = new Random();
TextTableExample ();
// Example of creating, inserting and manipulating text sections, as
// well as an example of how to refresh the document
TextSectionExample ();
// Example of creating a text section over a block of text and formatting
// the text section into columns, as well as how to insert an empty
// paragraph using the XRelativeTextContentInsert
TextColumnsExample ();
// Example of creating the NumberingRules service and adjusting
// NumberingTypes and NumberingLevels
NumberingExample ();
// Example of how to use the XStyleFamiliesSupplier interface of the
// document and how to create, insert and apply styles
StylesExample ();
IndexExample ();
// Example of how to create and manipulate reference marks and GetReference
// text fields
ReferenceExample ();
// Example of how to create and insert Footnotes and how to use the
// XFootnotesSupplier interface of the document
FootnoteExample ();
// This method demonstrates how to create shapes from the document factory
// and how to access the draw page of the document using the
// XDrawPageSupplier interface
DrawPageExample ();
mxFactory = UnoRuntime.queryInterface(
XMultiServiceFactory.class, mxRemoteServiceManager);
// This example demonstrates the use of the AutoTextContainer,
// AutoTextGroup and AutoTextEntry services and shows how to create,
// insert and modify auto text blocks
AutoTextExample ();
}
protected void storePrintExample() throws java.lang.Exception {
// get the remote service manager
mxRemoteServiceManager = this.getRemoteServiceManager();
// retrieve the Desktop object, we need its XComponentLoader
Object desktop = mxRemoteServiceManager.createInstanceWithContext(
"com.sun.star.frame.Desktop", mxRemoteContext);
XComponentLoader xComponentLoader = UnoRuntime.queryInterface(XComponentLoader.class, desktop);
PropertyValue[] loadProps = new PropertyValue[0];
java.io.File sourceFile = new java.io.File("PrintDemo.odt");
StringBuffer sLoadFileUrl = new StringBuffer("file:///");
sLoadFileUrl.append(sourceFile.getCanonicalPath().replace('\\', '/'));
XComponent xDoc = xComponentLoader.loadComponentFromURL(
sLoadFileUrl.toString(), "_blank", 0, loadProps);
if ( xDoc != null ) {
sourceFile = new java.io.File(sOutputDir);
StringBuffer sStoreFileUrl = new StringBuffer();
sStoreFileUrl.append(sourceFile.toURI().toURL().toString());
sStoreFileUrl.append("somepopularfileformat.doc");
storeDocComponent(xDoc, sStoreFileUrl.toString() );
printDocComponent(xDoc);
}
}
private XMultiComponentFactory getRemoteServiceManager()
throws java.lang.Exception
{
if (mxRemoteContext == null && mxRemoteServiceManager == null) {
// get the remote office context. If necessary a new office
// process is started
mxRemoteContext = com.sun.star.comp.helper.Bootstrap.bootstrap();
System.out.println("Connected to a running office ...");
mxRemoteServiceManager = mxRemoteContext.getServiceManager();
}
return mxRemoteServiceManager;
}
protected XComponent newDocComponent(String docType)
throws java.lang.Exception
{
String loadUrl = "private:factory/" + docType;
mxRemoteServiceManager = this.getRemoteServiceManager();
Object desktop = mxRemoteServiceManager.createInstanceWithContext(
"com.sun.star.frame.Desktop", mxRemoteContext);
XComponentLoader xComponentLoader = UnoRuntime.queryInterface(XComponentLoader.class, desktop);
PropertyValue[] loadProps = new PropertyValue[0];
return xComponentLoader.loadComponentFromURL(loadUrl, "_blank",
0, loadProps);
}
/** Load a document as template
*/
protected XComponent newDocComponentFromTemplate(String loadUrl)
throws java.lang.Exception
{
// get the remote service manager
mxRemoteServiceManager = this.getRemoteServiceManager();
// retrieve the Desktop object, we need its XComponentLoader
Object desktop = mxRemoteServiceManager.createInstanceWithContext(
"com.sun.star.frame.Desktop", mxRemoteContext);
XComponentLoader xComponentLoader = UnoRuntime.queryInterface(XComponentLoader.class, desktop);
// define load properties according to com.sun.star.document.MediaDescriptor
// the boolean property AsTemplate tells the office to create a new document
// from the given file
PropertyValue[] loadProps = new PropertyValue[1];
loadProps[0] = new PropertyValue();
loadProps[0].Name = "AsTemplate";
loadProps[0].Value = Boolean.TRUE;
// load
return xComponentLoader.loadComponentFromURL(loadUrl, "_blank",
0, loadProps);
}
/** Load a document with arguments (text purposes)
*/
protected void storeDocComponent(XComponent xDoc, String storeUrl)
throws java.lang.Exception
{
XStorable xStorable = UnoRuntime.queryInterface(
XStorable.class, xDoc);
PropertyValue[] storeProps = new PropertyValue[1];
storeProps[0] = new PropertyValue();
storeProps[0].Name = "FilterName";
storeProps[0].Value = "MS Word 97";
System.out.println("... store \"PrintDemo.odt\" to \"" + storeUrl + "\".");
xStorable.storeAsURL(storeUrl, storeProps);
}
protected void printDocComponent(XComponent xDoc) throws java.lang.Exception {
XPrintable xPrintable = UnoRuntime.queryInterface(
XPrintable.class, xDoc);
PropertyValue[] printerDesc = new PropertyValue[1];
printerDesc[0] = new PropertyValue();
printerDesc[0].Name = "Name";
printerDesc[0].Value = aPrinterName;
xPrintable.setPrinter(printerDesc);
PropertyValue[] printOpts = new PropertyValue[1];
printOpts[0] = new PropertyValue();
printOpts[0].Name = "Pages";
printOpts[0].Value = "1";
xPrintable.print(printOpts);
}
// Setting the whole text of a document as one string
protected void BodyTextExample ()
{
// Body Text and TextDocument example
try
{
// demonstrate simple text insertion
mxDocText.setString ( "This is the new body text of the document."
+ "\n\nThis is on the second line.\n\n" );
}
catch ( Exception e )
{
e.printStackTrace();
}
}
// Adding a string at the end or the beginning of text
protected void TextRangeExample ()
{
try
{
// Get a text range referring to the beginning of the text document
XTextRange xStart = mxDocText.getStart();
// use setString to insert text at the beginning
xStart.setString ( "This is text inserted at the beginning.\n\n" );
// Get a text range referring to the end of the text document
XTextRange xEnd = mxDocText.getEnd();
// use setString to insert text at the end
xEnd.setString ( "This is text inserted at the end.\n\n" );
}
catch ( Exception e )
{
e.printStackTrace();
}
}
/** moving a text cursor, selecting text and overwriting it
*/
protected void TextCursorExample ()
{
try
{
// First, get the XSentenceCursor interface of our text cursor
XSentenceCursor xSentenceCursor = UnoRuntime.queryInterface(XSentenceCursor.class, mxDocCursor );
// Goto the next cursor, without selecting it
xSentenceCursor.gotoNextSentence( false );
// Get the XWordCursor interface of our text cursor
XWordCursor xWordCursor = UnoRuntime.queryInterface(
XWordCursor.class, mxDocCursor );
// Skip the first four words of this sentence and select the fifth
xWordCursor.gotoNextWord( false );
xWordCursor.gotoNextWord( false );
xWordCursor.gotoNextWord( false );
xWordCursor.gotoNextWord( false );
xWordCursor.gotoNextWord( true );
// Use the XSimpleText interface to insert a word at the current cursor
// location, over-writing the current selection (the fifth word
// selected above)
mxDocText.insertString ( xWordCursor, "old ", true );
// Access the property set of the cursor, and set the currently
// selected text (which is the string we just inserted) to be bold
XPropertySet xCursorProps = UnoRuntime.queryInterface(
XPropertySet.class, mxDocCursor );
xCursorProps.setPropertyValue ( "CharWeight",
Float.valueOf(com.sun.star.awt.FontWeight.BOLD) );
// replace the '.' at the end of the sentence with a new string
xSentenceCursor.gotoEndOfSentence( false );
xWordCursor.gotoPreviousWord( true );
mxDocText.insertString (xWordCursor,
", which has been changed with text cursors!",
true);
}
catch ( Exception e )
{
e.printStackTrace();
}
}
/** This method inserts both a date field and a user field containing the
* number '42'
*/
protected void TextFieldExample ()
{
try
{
// Use the text document's factory to create a DateTime text field,
// and access its XTextField interface
XTextField xDateField = UnoRuntime.queryInterface (
XTextField.class, mxDocFactory.createInstance (
"com.sun.star.text.TextField.DateTime" ) );
// Insert it at the end of the document
mxDocText.insertTextContent ( mxDocText.getEnd(), xDateField, false );
// Use the text document's factory to create a user text field,
// and access its XDependentTextField interface
XDependentTextField xUserField =
UnoRuntime.queryInterface (
XDependentTextField.class, mxDocFactory.createInstance (
"com.sun.star.text.TextField.User" ) );
// Create a fieldmaster for our newly created User Text field, and
// access its XPropertySet interface
XPropertySet xMasterPropSet = UnoRuntime.queryInterface(
XPropertySet.class, mxDocFactory.createInstance (
"com.sun.star.text.fieldmaster.User" ) );
// Set the name and value of the FieldMaster
xMasterPropSet.setPropertyValue ( "Name", "UserEmperor" );
xMasterPropSet.setPropertyValue ( "Value", Integer.valueOf( 42 ) );
// Attach the field master to the user field
xUserField.attachTextFieldMaster ( xMasterPropSet );
// Move the cursor to the end of the document
mxDocCursor.gotoEnd( false );
// insert a paragraph break using the XSimpleText interface
mxDocText.insertControlCharacter (
mxDocCursor, ControlCharacter.PARAGRAPH_BREAK, false );
// Insert the user field at the end of the document
mxDocText.insertTextContent ( mxDocText.getEnd(), xUserField, false );
}
catch ( Exception e )
{
e.printStackTrace();
}
}
/** This method demonstrates how to iterate over paragraphs
*/
protected void ParagraphExample ()
{
try
{
// The service 'com.sun.star.text.Text' supports the XEnumerationAccess
// interface to provide an enumeration of the paragraphs contained by
// the text the service refers to.
// Here, we access this interface
XEnumerationAccess xParaAccess = UnoRuntime.queryInterface(XEnumerationAccess.class, mxDocText );
// Call the XEnumerationAccess's only method to access the actual
// Enumeration
XEnumeration xParaEnum = xParaAccess.createEnumeration();
// While there are paragraphs, do things to them
while ( xParaEnum.hasMoreElements() )
{
// Get a reference to the next paragraphs XServiceInfo interface.
// TextTables are also part of this enumeration access, so we ask
// the element if it is a TextTable, if it doesn't support the
// com.sun.star.text.TextTable service, then it is safe to assume
// that it really is a paragraph
XServiceInfo xInfo = UnoRuntime.queryInterface(
XServiceInfo.class, xParaEnum.nextElement() );
if ( !xInfo.supportsService ( "com.sun.star.text.TextTable" ) )
{
// Access the paragraph's property set...the properties in this
// property set are listed in:
// com.sun.star.style.ParagraphProperties
XPropertySet xSet = UnoRuntime.queryInterface(
XPropertySet.class, xInfo );
// Set the justification to be center justified
xSet.setPropertyValue ( "ParaAdjust",
com.sun.star.style.ParagraphAdjust.CENTER );
}
}
}
catch ( Exception e )
{
e.printStackTrace();
}
}
/** This method returns a random double which isn't too high or too low
*/
protected double getRandomDouble ()
{
return ( ( maRandom.nextInt() % 1000 ) * maRandom.nextDouble () );
}
/** This method sets the text colour of the cell referred to by sCellName to
white and inserts the string sText in it
*/
protected static void insertIntoCell(String sCellName, String sText,
XTextTable xTable)
{
// Access the XText interface of the cell referred to by sCellName
XText xCellText = UnoRuntime.queryInterface(
XText.class, xTable.getCellByName ( sCellName ) );
// create a text cursor from the cells XText interface
XTextCursor xCellCursor = xCellText.createTextCursor();
// Get the property set of the cell's TextCursor
XPropertySet xCellCursorProps = UnoRuntime.queryInterface(
XPropertySet.class, xCellCursor );
try
{
// Set the colour of the text to white
xCellCursorProps.setPropertyValue( "CharColor", Integer.valueOf(16777215));
}
catch ( Exception e)
{
e.printStackTrace();
}
// Set the text in the cell to sText
xCellText.setString( sText );
}
/** This method shows how to create and insert a text table, as well as insert
text and formulae into the cells of the table
*/
protected void TextTableExample ()
{
try
{
// Create a new table from the document's factory
XTextTable xTable = UnoRuntime.queryInterface(
XTextTable.class, mxDocFactory .createInstance(
"com.sun.star.text.TextTable" ) );
// Specify that we want the table to have 4 rows and 4 columns
xTable.initialize( 4, 4 );
// Insert the table into the document
mxDocText.insertTextContent( mxDocCursor, xTable, false);
// Get an XIndexAccess of the table rows
XIndexAccess xRows = xTable.getRows();
// Access the property set of the first row (properties listed in
// service description: com.sun.star.text.TextTableRow)
XPropertySet xRow = UnoRuntime.queryInterface(
XPropertySet.class, xRows.getByIndex ( 0 ) );
// If BackTransparent is false, then the background color is visible
xRow.setPropertyValue( "BackTransparent", Boolean.FALSE);
// Specify the color of the background to be dark blue
xRow.setPropertyValue( "BackColor", Integer.valueOf(6710932));
// Access the property set of the whole table
XPropertySet xTableProps = UnoRuntime.queryInterface(
XPropertySet.class, xTable );
// We want visible background colors
xTableProps.setPropertyValue( "BackTransparent", Boolean.FALSE);
// Set the background colour to light blue
xTableProps.setPropertyValue( "BackColor", Integer.valueOf(13421823));
// set the text (and text colour) of all the cells in the first row
// of the table
insertIntoCell( "A1", "First Column", xTable );
insertIntoCell( "B1", "Second Column", xTable );
insertIntoCell( "C1", "Third Column", xTable );
insertIntoCell( "D1", "Results", xTable );
// Insert random numbers into the first this three cells of each
// remaining row
xTable.getCellByName( "A2" ).setValue( getRandomDouble() );
xTable.getCellByName( "B2" ).setValue( getRandomDouble() );
xTable.getCellByName( "C2" ).setValue( getRandomDouble() );
xTable.getCellByName( "A3" ).setValue( getRandomDouble() );
xTable.getCellByName( "B3" ).setValue( getRandomDouble() );
xTable.getCellByName( "C3" ).setValue( getRandomDouble() );
xTable.getCellByName( "A4" ).setValue( getRandomDouble() );
xTable.getCellByName( "B4" ).setValue( getRandomDouble() );
xTable.getCellByName( "C4" ).setValue( getRandomDouble() );
// Set the last cell in each row to be a formula that calculates
// the sum of the first three cells
xTable.getCellByName( "D2" ).setFormula( "sum <A2:C2>" );
xTable.getCellByName( "D3" ).setFormula( "sum <A3:C3>" );
xTable.getCellByName( "D4" ).setFormula( "sum <A4:C4>" );
}
catch (Exception e)
{
e.printStackTrace();
}
}
/** This method shows how to create and manipulate text frames
*/
protected void TextFrameExample ()
{
try
{
// Use the document's factory to create a new text frame and
// immediately access its XTextFrame interface
XTextFrame xFrame = UnoRuntime.queryInterface (
XTextFrame.class, mxDocFactory.createInstance (
"com.sun.star.text.TextFrame" ) );
// Access the XShape interface of the TextFrame
XShape xShape = UnoRuntime.queryInterface(XShape.class, xFrame);
// Access the XPropertySet interface of the TextFrame
XPropertySet xFrameProps = UnoRuntime.queryInterface(
XPropertySet.class, xFrame );
// Set the size of the new Text Frame using the XShape's 'setSize'
// method
Size aSize = new Size();
aSize.Height = 400;
aSize.Width = 15000;
xShape.setSize(aSize);
// Set the AnchorType to
// com.sun.star.text.TextContentAnchorType.AS_CHARACTER
xFrameProps.setPropertyValue( "AnchorType",
TextContentAnchorType.AS_CHARACTER );
// Go to the end of the text document
mxDocCursor.gotoEnd( false );
// Insert a new paragraph
mxDocText.insertControlCharacter (
mxDocCursor, ControlCharacter.PARAGRAPH_BREAK, false );
// Then insert the new frame
mxDocText.insertTextContent(mxDocCursor, xFrame, false);
// Access the XText interface of the text contained within the frame
XText xFrameText = xFrame.getText();
// Create a TextCursor over the frame's contents
XTextCursor xFrameCursor = xFrameText.createTextCursor();
// Insert some text into the frame
xFrameText.insertString(
xFrameCursor, "The first line in the newly created text frame.",
false );
xFrameText.insertString(
xFrameCursor, "\nThe second line in the new text frame.", false );
// Insert a paragraph break into the document (not the frame)
mxDocText.insertControlCharacter (
mxDocCursor, ControlCharacter.PARAGRAPH_BREAK, false );
}
catch (Exception e)
{
e.printStackTrace();
}
}
/** This example demonstrates the use of the AutoTextContainer, AutoTextGroup
and AutoTextEntry services and shows how to create, insert and modify
auto text blocks
*/
protected void AutoTextExample ()
{
try
{
// Go to the end of the document
mxDocCursor.gotoEnd( false );
// Insert two paragraphs
mxDocText.insertControlCharacter ( mxDocCursor,
ControlCharacter.PARAGRAPH_BREAK, false );
mxDocText.insertControlCharacter ( mxDocCursor,
ControlCharacter.PARAGRAPH_BREAK, false );
// Position the cursor in the second paragraph
XParagraphCursor xParaCursor = UnoRuntime.queryInterface(XParagraphCursor.class, mxDocCursor );
xParaCursor.gotoPreviousParagraph ( false );
// Get an XNameAccess interface to all auto text groups from the
// document factory
XNameAccess xContainer = UnoRuntime.queryInterface(
XNameAccess.class, mxFactory.createInstance (
"com.sun.star.text.AutoTextContainer" ) );
// Create a new table at the document factory
XTextTable xTable = UnoRuntime.queryInterface(
XTextTable.class, mxDocFactory .createInstance(
"com.sun.star.text.TextTable" ) );
// Store the names of all auto text groups in an array of strings
String[] aGroupNames = xContainer.getElementNames();
// Make sure we have at least one group name
if ( aGroupNames.length > 0 )
{
// initialise the table to have a row for every autotext group
// in a single column + one additional row for a header
xTable.initialize( aGroupNames.length+1,1);
// Access the XPropertySet of the table
XPropertySet xTableProps = UnoRuntime.queryInterface(
XPropertySet.class, xTable );
// We want a visible background
xTableProps.setPropertyValue( "BackTransparent",
Boolean.FALSE);
// We want the background to be light blue
xTableProps.setPropertyValue( "BackColor", Integer.valueOf(13421823));
// Inser the table into the document
mxDocText.insertTextContent( mxDocCursor, xTable, false);
// Get an XIndexAccess to all table rows
XIndexAccess xRows = xTable.getRows();
// Get the first row in the table
XPropertySet xRow = UnoRuntime.queryInterface(
XPropertySet.class, xRows.getByIndex ( 0 ) );
// We want the background of the first row to be visible too
xRow.setPropertyValue( "BackTransparent", Boolean.FALSE);
// And let's make it dark blue
xRow.setPropertyValue( "BackColor", Integer.valueOf(6710932));
// Put a description of the table contents into the first cell
insertIntoCell( "A1", "AutoText Groups", xTable);
// Create a table cursor pointing at the second cell in the first
// column
XTextTableCursor xTableCursor = xTable.createCursorByCellName("A2");
// Loop over the group names
for ( int i = 0 ; i < aGroupNames.length ; i ++ )
{
// Get the name of the current cell
String sCellName = xTableCursor.getRangeName ();
// Get the XText interface of the current cell
XText xCellText = UnoRuntime.queryInterface (
XText.class, xTable.getCellByName ( sCellName ) );
// Set the cell contents of the current cell to be
//the name of the of an autotext group
xCellText.setString ( aGroupNames[i] );
// Access the autotext group with this name
XAutoTextGroup xGroup = UnoRuntime.queryInterface (XAutoTextGroup.class,
xContainer.getByName(aGroupNames[i]));
// Get the titles of each autotext block in this group
String [] aBlockNames = xGroup.getTitles();
// Make sure that the autotext group contains at least one block
if ( aBlockNames.length > 0 )
{
// Split the current cell vertically into two separate cells
xTableCursor.splitRange ( (short) 1, false );
// Put the cursor in the newly created right hand cell
// and select it
xTableCursor.goRight ( (short) 1, false );
// Split this cell horizontally to make a separate cell
// for each Autotext block
if ( ( aBlockNames.length -1 ) > 0 )
xTableCursor.splitRange (
(short) (aBlockNames.length - 1), true );
// loop over the block names
for ( int j = 0 ; j < aBlockNames.length ; j ++ )
{
// Get the XText interface of the current cell
xCellText = UnoRuntime.queryInterface (
XText.class, xTable.getCellByName (
xTableCursor.getRangeName() ) );
// Set the text contents of the current cell to the
// title of an Autotext block
xCellText.setString ( aBlockNames[j] );
// Move the cursor down one cell
xTableCursor.goDown( (short)1, false);
}
}
// Go back to the cell we originally split
xTableCursor.gotoCellByName ( sCellName, false );
// Go down one cell
xTableCursor.goDown( (short)1, false);
}
XAutoTextGroup xGroup;
String [] aBlockNames;
// Add a depth so that we only generate 200 numbers before giving up
// on finding a random autotext group that contains autotext blocks
int nDepth = 0;
do
{
// Generate a random, positive number which is lower than
// the number of autotext groups
int nRandom = Math.abs ( maRandom.nextInt() %
aGroupNames.length );
// Get the autotext group at this name
xGroup = UnoRuntime.queryInterface (
XAutoTextGroup.class, xContainer.getByName (
aGroupNames[ nRandom ] ) );
// Fill our string array with the names of all the blocks in
// this group
aBlockNames = xGroup.getElementNames();
// increment our depth counter
++nDepth;
}
while ( nDepth < 200 && aBlockNames.length == 0 );
// If we managed to find a group containing blocks...
if ( aBlockNames.length > 0 )
{
// Pick a random block in this group and get its
// XAutoTextEntry interface
int nRandom = Math.abs ( maRandom.nextInt()
% aBlockNames.length );
XAutoTextEntry xEntry = UnoRuntime.queryInterface (
XAutoTextEntry.class, xGroup.getByName (
aBlockNames[ nRandom ] ) );
// insert the modified autotext block at the end of the document
xEntry.applyTo ( mxDocCursor );
// Get the titles of all text blocks in this AutoText group
String [] aBlockTitles = xGroup.getTitles();
// Get the XNamed interface of the autotext group
XNamed xGroupNamed = UnoRuntime.queryInterface (
XNamed.class, xGroup );
// Output the short cut and title of the random block
//and the name of the group it's from
System.out.println ( "Inserted the Autotext '" +
aBlockTitles[nRandom]
+ "', shortcut '" + aBlockNames[nRandom]
+ "' from group '"
+ xGroupNamed.getName());
}
}
// Go to the end of the document
mxDocCursor.gotoEnd( false );
// Insert new paragraph
mxDocText.insertControlCharacter (
mxDocCursor, ControlCharacter.PARAGRAPH_BREAK, false );
// Position cursor in new paragraph
xParaCursor.gotoPreviousParagraph ( false );
// Insert a string in the new paragraph
mxDocText.insertString ( mxDocCursor,
"Some text for a new autotext block", false );
// Go to the end of the document
mxDocCursor.gotoEnd( false );
}
catch (Exception e)
{
e.printStackTrace();
}
}
/** This method demonstrates how to insert indexes and index marks
*/
protected void IndexExample ()
{
try
{
// Go to the end of the document
mxDocCursor.gotoEnd( false );
// Insert a new paragraph and position the cursor in it
mxDocText.insertControlCharacter ( mxDocCursor,
ControlCharacter.PARAGRAPH_BREAK, false );
XParagraphCursor xParaCursor = UnoRuntime.queryInterface( XParagraphCursor.class, mxDocCursor );
xParaCursor.gotoPreviousParagraph ( false );
// Create a new ContentIndexMark and get its XPropertySet interface
XPropertySet xEntry = UnoRuntime.queryInterface(
XPropertySet.class,
mxDocFactory.createInstance("com.sun.star.text.ContentIndexMark"));
// Set the text to be displayed in the index
xEntry.setPropertyValue(
"AlternativeText", "Big dogs! Falling on my head!");
// The Level property _must_ be set
xEntry.setPropertyValue ( "Level", Short.valueOf( (short) 1 ) );
// Create a ContentIndex and access its XPropertySet interface
XPropertySet xIndex = UnoRuntime.queryInterface(
XPropertySet.class,
mxDocFactory.createInstance ( "com.sun.star.text.ContentIndex" ) );
// Again, the Level property _must_ be set
xIndex.setPropertyValue ( "Level", Short.valueOf( (short) 10 ) );
// Access the XTextContent interfaces of both the Index and the
// IndexMark
XTextContent xIndexContent = UnoRuntime.queryInterface(
XTextContent.class, xIndex );
XTextContent xEntryContent = UnoRuntime.queryInterface(
XTextContent.class, xEntry );
// Insert both in the document
mxDocText.insertTextContent ( mxDocCursor, xEntryContent, false );
mxDocText.insertTextContent ( mxDocCursor, xIndexContent, false );
// Get the XDocumentIndex interface of the Index
XDocumentIndex xDocIndex = UnoRuntime.queryInterface(
XDocumentIndex.class, xIndex );
// And call its update method
xDocIndex.update();
}
catch (Exception e)
{
e.printStackTrace();
}
}
/** This method demonstrates how to create and insert reference marks, and
* GetReference Text Fields
*/
protected void ReferenceExample ()
{
try
{
// Go to the end of the document
mxDocCursor.gotoEnd( false );
// Insert a paragraph break
mxDocText.insertControlCharacter (
mxDocCursor, ControlCharacter.PARAGRAPH_BREAK, false );
// Get the Paragraph cursor
XParagraphCursor xParaCursor = UnoRuntime.queryInterface( XParagraphCursor.class, mxDocCursor );
// Move the cursor into the new paragraph
xParaCursor.gotoPreviousParagraph ( false );
// Create a new ReferenceMark and get its XNamed interface
XNamed xRefMark = UnoRuntime.queryInterface(XNamed.class,
mxDocFactory.createInstance ("com.sun.star.text.ReferenceMark"));
// Set the name to TableHeader
xRefMark.setName ( "TableHeader" );
// Get the TextTablesSupplier interface of the document
XTextTablesSupplier xTableSupplier = UnoRuntime.queryInterface(XTextTablesSupplier.class, mxDoc);
// Get an XIndexAccess of TextTables
XIndexAccess xTables = UnoRuntime.queryInterface(
XIndexAccess.class, xTableSupplier.getTextTables());
// We've only inserted one table, so get the first one from index zero
XTextTable xTable = UnoRuntime.queryInterface (
XTextTable.class, xTables.getByIndex( 0 ) );
// Get the first cell from the table
XText xTableText = UnoRuntime.queryInterface(
XText.class, xTable.getCellByName ( "A1" ) );
// Get a text cursor for the first cell
XTextCursor xTableCursor = xTableText.createTextCursor();
// Get the XTextContent interface of the reference mark so we can
// insert it
XTextContent xContent = UnoRuntime.queryInterface (
XTextContent.class, xRefMark );
// Insert the reference mark into the first cell of the table
xTableText.insertTextContent ( xTableCursor, xContent, false );
// Create a 'GetReference' text field to refer to the reference mark
// we just inserted, and get its XPropertySet interface
XPropertySet xFieldProps = UnoRuntime.queryInterface(
XPropertySet.class, mxDocFactory.createInstance (
"com.sun.star.text.TextField.GetReference" ) );
// Get the XReferenceMarksSupplier interface of the document
XReferenceMarksSupplier xRefSupplier = UnoRuntime.queryInterface( XReferenceMarksSupplier.class, mxDoc );
// Get an XNameAccess which refers to all inserted reference marks
XNameAccess xMarks = UnoRuntime.queryInterface (
XNameAccess.class, xRefSupplier.getReferenceMarks() );
// Put the names of each reference mark into an array of strings
String[] aNames = xMarks.getElementNames();
// Make sure that at least 1 reference mark actually exists
// (well, we just inserted one!)
if ( aNames.length > 0 )
{
// Output the name of the first reference mark ('TableHeader')
System.out.println (
"GetReference text field inserted for ReferenceMark : "
+ aNames[0] );
// Set the SourceName of the GetReference text field to
// 'TableHeader'
xFieldProps.setPropertyValue ( "SourceName", aNames[0] );
// specify that the source is a reference mark (could also be a
// footnote, bookmark or sequence field )
xFieldProps.setPropertyValue ( "ReferenceFieldSource",
Short.valueOf(ReferenceFieldSource.REFERENCE_MARK));
// We want the reference displayed as 'above' or 'below'
xFieldProps.setPropertyValue ( "ReferenceFieldPart",
Short.valueOf(ReferenceFieldPart.UP_DOWN));
// Get the XTextContent interface of the GetReference text field
XTextContent xRefContent = UnoRuntime.queryInterface(
XTextContent.class, xFieldProps );
// Go to the end of the document
mxDocCursor.gotoEnd( false );
// Make some text to precede the reference
mxDocText.insertString(mxDocText.getEnd(), "The table ", false);
// Insert the text field
mxDocText.insertTextContent(mxDocText.getEnd(), xRefContent, false);
// And some text after the reference...
mxDocText.insertString(mxDocText.getEnd(),
" contains the sum of some random numbers.", false );
// Refresh the document
XRefreshable xRefresh = UnoRuntime.queryInterface(
XRefreshable.class, mxDoc );
xRefresh.refresh();
}
}
catch (Exception e)
{
e.printStackTrace();
}
}
/** This method demonstrates how to create and insert footnotes, and how to
access the XFootnotesSupplier interface of the document
*/
protected void FootnoteExample ()
{
try
{
// Create a new footnote from the document factory and get its
// XFootnote interface
XFootnote xFootnote = UnoRuntime.queryInterface(
XFootnote.class, mxDocFactory.createInstance (
"com.sun.star.text.Footnote" ) );
// Set the label to 'Numbers'
xFootnote.setLabel ( "Numbers" );
// Get the footnotes XTextContent interface so we can...
XTextContent xContent = UnoRuntime.queryInterface (
XTextContent.class, xFootnote );
// ...insert it into the document
mxDocText.insertTextContent ( mxDocCursor, xContent, false );
// Get the XFootnotesSupplier interface of the document
XFootnotesSupplier xFootnoteSupplier = UnoRuntime.queryInterface(XFootnotesSupplier.class, mxDoc );
// Get an XIndexAccess interface to all footnotes
XIndexAccess xFootnotes = UnoRuntime.queryInterface (
XIndexAccess.class, xFootnoteSupplier.getFootnotes() );
// Get the XFootnote interface to the first footnote inserted ('Numbers')
XFootnote xNumbers = UnoRuntime.queryInterface (
XFootnote.class, xFootnotes.getByIndex( 0 ) );
// Get the XSimpleText interface to the Footnote
XSimpleText xSimple = UnoRuntime.queryInterface (
XSimpleText.class, xNumbers );
// Create a text cursor for the foot note text
XTextRange xRange = UnoRuntime.queryInterface (
XTextRange.class, xSimple.createTextCursor() );
// And insert the actual text of the footnote.
xSimple.insertString (
xRange, " The numbers were generated by using java.util.Random", false );
}
catch (Exception e)
{
e.printStackTrace();
}
}
/** This method demonstrates how to create and manipulate shapes, and how to
access the draw page of the document to insert shapes
*/
protected void DrawPageExample ()
{
try
{
// Go to the end of the document
mxDocCursor.gotoEnd( false );
// Insert two new paragraphs
mxDocText.insertControlCharacter(mxDocCursor,
ControlCharacter.PARAGRAPH_BREAK, false);
mxDocText.insertControlCharacter(mxDocCursor,
ControlCharacter.PARAGRAPH_BREAK, false);
// Get the XParagraphCursor interface of our document cursor
XParagraphCursor xParaCursor = UnoRuntime.queryInterface( XParagraphCursor.class, mxDocCursor );
// Position the cursor in the 2nd paragraph
xParaCursor.gotoPreviousParagraph ( false );
// Create a RectangleShape using the document factory
XShape xRect = UnoRuntime.queryInterface(
XShape.class, mxDocFactory.createInstance (
"com.sun.star.drawing.RectangleShape" ) );
// Create an EllipseShape using the document factory
XShape xEllipse = UnoRuntime.queryInterface(
XShape.class, mxDocFactory.createInstance (
"com.sun.star.drawing.EllipseShape" ) );
// Set the size of both the ellipse and the rectangle
Size aSize = new Size();
aSize.Height = 4000;
aSize.Width = 10000;
xRect.setSize(aSize);
aSize.Height = 3000;
aSize.Width = 6000;
xEllipse.setSize ( aSize );
// Set the position of the Rectangle to the right of the ellipse
Point aPoint = new Point();
aPoint.X = 6100;
aPoint.Y = 0;
xRect.setPosition ( aPoint );
// Get the XPropertySet interfaces of both shapes
XPropertySet xRectProps = UnoRuntime.queryInterface(
XPropertySet.class, xRect );
XPropertySet xEllipseProps = UnoRuntime.queryInterface(
XPropertySet.class, xEllipse );
// And set the AnchorTypes of both shapes to 'AT_PARAGRAPH'
xRectProps.setPropertyValue ( "AnchorType",
TextContentAnchorType.AT_PARAGRAPH );
xEllipseProps.setPropertyValue ( "AnchorType",
TextContentAnchorType.AT_PARAGRAPH );
// Access the XDrawPageSupplier interface of the document
XDrawPageSupplier xDrawPageSupplier = UnoRuntime.queryInterface (XDrawPageSupplier.class, mxDoc );
// Get the XShapes interface of the draw page
XShapes xShapes = UnoRuntime.queryInterface (
XShapes.class, xDrawPageSupplier.getDrawPage () );
// Add both shapes
xShapes.add ( xEllipse );
xShapes.add ( xRect );
/*
This doesn't work, I am assured that FME and AMA are fixing it.
XShapes xGrouper = (XShapes) UnoRuntime.queryInterface(
XShapes.class, mxDocFactory.createInstance (
"com.sun.star.drawing.GroupShape" ) );
XShape xGrouperShape = (XShape) UnoRuntime.queryInterface(
XShape.class, xGrouper );
xShapes.add ( xGrouperShape );
xGrouper.add ( xRect );
xGrouper.add ( xEllipse );
XShapeGrouper xShapeGrouper = (XShapeGrouper)
UnoRuntime.queryInterface(XShapeGrouper.class, xShapes);
xShapeGrouper.group ( xGrouper );
*/
}
catch (Exception e)
{
e.printStackTrace();
}
}
/** This method demonstrates how to create, insert and apply styles
*/
protected void StylesExample ()
{
try
{
// Go to the end of the document
mxDocCursor.gotoEnd( false );
// Insert two paragraph breaks
mxDocText.insertControlCharacter (
mxDocCursor, ControlCharacter.PARAGRAPH_BREAK, false );
mxDocText.insertControlCharacter (
mxDocCursor, ControlCharacter.PARAGRAPH_BREAK, false );
// Create a new style from the document's factory
XStyle xStyle = UnoRuntime.queryInterface(
XStyle.class, mxDocFactory.createInstance(
"com.sun.star.style.ParagraphStyle" ) );
// Access the XPropertySet interface of the new style
XPropertySet xStyleProps = UnoRuntime.queryInterface(
XPropertySet.class, xStyle );
// Give the new style a light blue background
xStyleProps.setPropertyValue ( "ParaBackColor", Integer.valueOf(13421823));
// Get the StyleFamiliesSupplier interface of the document
XStyleFamiliesSupplier xSupplier = UnoRuntime.queryInterface(XStyleFamiliesSupplier.class, mxDoc);
// Use the StyleFamiliesSupplier interface to get the XNameAccess
// interface of the actual style families
XNameAccess xFamilies = UnoRuntime.queryInterface (
XNameAccess.class, xSupplier.getStyleFamilies() );
// Access the 'ParagraphStyles' Family
XNameContainer xFamily = UnoRuntime.queryInterface (
XNameContainer.class,
xFamilies.getByName ( "ParagraphStyles" ) );
// Insert the newly created style into the ParagraphStyles family
xFamily.insertByName ( "All-Singing All-Dancing Style", xStyle );
// Get the XParagraphCursor interface of the document cursor
XParagraphCursor xParaCursor = UnoRuntime.queryInterface( XParagraphCursor.class, mxDocCursor );
// Select the first paragraph inserted
xParaCursor.gotoPreviousParagraph ( false );
xParaCursor.gotoPreviousParagraph ( true );
// Access the property set of the cursor selection
XPropertySet xCursorProps = UnoRuntime.queryInterface(
XPropertySet.class, mxDocCursor );
// Set the style of the cursor selection to our newly created style
xCursorProps.setPropertyValue ( "ParaStyleName",
"All-Singing All-Dancing Style" );
// Go back to the end
mxDocCursor.gotoEnd ( false );
// Select the last paragraph in the document
xParaCursor.gotoNextParagraph ( true );
// And reset its style to 'Standard' (the programmatic name for
// the default style)
xCursorProps.setPropertyValue ( "ParaStyleName", "Standard" );
}
catch (Exception e)
{
e.printStackTrace();
}
}
/** This method demonstrates how to set numbering types and numbering levels
using the com.sun.star.text.NumberingRules service
*/
protected void NumberingExample ()
{
try
{
// Go to the end of the document
mxDocCursor.gotoEnd( false );
// Get the RelativeTextContentInsert interface of the document
XRelativeTextContentInsert xRelative =
UnoRuntime.queryInterface (
XRelativeTextContentInsert.class, mxDocText );
// Use the document's factory to create the NumberingRules service,
// and get its XIndexAccess interface
XIndexAccess xNum = UnoRuntime.queryInterface(
XIndexAccess.class,
mxDocFactory.createInstance( "com.sun.star.text.NumberingRules" ) );
// Also get the NumberingRule's XIndexReplace interface
XIndexReplace xReplace = UnoRuntime.queryInterface(
XIndexReplace.class, xNum );
// Create an array of XPropertySets, one for each of the three
// paragraphs we're about to create
XPropertySet xParas[] = new XPropertySet [ 3 ];
for ( int i = 0 ; i < 3 ; ++ i )
{
// Create a new paragraph
XTextContent xNewPara = UnoRuntime.queryInterface(
XTextContent.class, mxDocFactory.createInstance(
"com.sun.star.text.Paragraph" ) );
// Get the XPropertySet interface of the new paragraph and put
// it in our array
xParas[i] = UnoRuntime.queryInterface(
XPropertySet.class, xNewPara );
// Insert the new paragraph into the document after the fish
// section. As it is an insert relative to the fish section, the
// first paragraph inserted will be below the next two
xRelative.insertTextContentAfter ( xNewPara, mxFishSection );
// Separate from the above, but also needs to be done three times
// Get the PropertyValue sequence for this numbering level
PropertyValue [] aProps = (PropertyValue [] ) xNum.getByIndex ( i );
// Iterate over the PropertyValue's for this numbering level,
// looking for the 'NumberingType' property
for ( int j = 0 ; j < aProps.length ; ++j )
{
if ( aProps[j].Name.equals ( "NumberingType" ) )
{
// Once we find it, set its value to a new type,
// dependent on which numbering level we're currently on
switch ( i )
{
case 0 : aProps[j].Value =
Short.valueOf(NumberingType.ROMAN_UPPER);
break;
case 1 : aProps[j].Value =
Short.valueOf(NumberingType.CHARS_UPPER_LETTER);
break;
case 2 : aProps[j].Value =
Short.valueOf(NumberingType.ARABIC);
break;
}
// Put the updated PropertyValue sequence back into the
// NumberingRules service
xReplace.replaceByIndex ( i, aProps );
break;
}
}
}
// Get the XParagraphCursor interface of our text cursor
XParagraphCursor xParaCursor = UnoRuntime.queryInterface( XParagraphCursor.class, mxDocCursor );
// Go to the end of the document, then select the preceding paragraphs
mxDocCursor.gotoEnd ( false );
xParaCursor.gotoPreviousParagraph ( false );
xParaCursor.gotoPreviousParagraph ( true );
xParaCursor.gotoPreviousParagraph ( true );
// Get the XPropertySet of the cursor's currently selected text
XPropertySet xCursorProps = UnoRuntime.queryInterface(
XPropertySet.class, mxDocCursor );
// Set the updated Numbering rules to the cursor's property set
xCursorProps.setPropertyValue ( "NumberingRules", xNum );
mxDocCursor.gotoEnd( false );
// Set the first paragraph that was inserted to a numbering level of
// 2 (thus it will have Arabic style numbering)
xParas[0].setPropertyValue ( "NumberingLevel", Short.valueOf((short) 2));
// Set the second paragraph that was inserted to a numbering level of
// 1 (thus it will have 'Chars Upper Letter' style numbering)
xParas[1].setPropertyValue ( "NumberingLevel", Short.valueOf((short) 1));
// Set the third paragraph that was inserted to a numbering level of
// 0 (thus it will have 'Chars Upper Letter' style numbering)
xParas[2].setPropertyValue ( "NumberingLevel", Short.valueOf((short) 0));
}
catch (Exception e)
{
e.printStackTrace();
}
}
/** This method demonstrates how to create linked and unlinked sections
*/
protected void TextSectionExample ()
{
try
{
// Go to the end of the document
mxDocCursor.gotoEnd( false );
// Insert two paragraph breaks
mxDocText.insertControlCharacter (
mxDocCursor, ControlCharacter.PARAGRAPH_BREAK, false );
mxDocText.insertControlCharacter (
mxDocCursor, ControlCharacter.PARAGRAPH_BREAK, true );
// Create a new TextSection from the document factory and access
// its XNamed interface
XNamed xChildNamed = UnoRuntime.queryInterface(
XNamed.class, mxDocFactory.createInstance(
"com.sun.star.text.TextSection" ) );
// Set the new sections name to 'Child_Section'
xChildNamed.setName ( "Child_Section" );
// Access the Child_Section's XTextContent interface and insert it
// into the document
XTextContent xChildSection = UnoRuntime.queryInterface(
XTextContent.class, xChildNamed );
mxDocText.insertTextContent ( mxDocCursor, xChildSection, false );
// Access the XParagraphCursor interface of our text cursor
XParagraphCursor xParaCursor = UnoRuntime.queryInterface(XParagraphCursor.class, mxDocCursor);
// Go back one paragraph (into Child_Section)
xParaCursor.gotoPreviousParagraph ( false );
// Insert a string into the Child_Section
mxDocText.insertString ( mxDocCursor, "This is a test", false );
// Go to the end of the document
mxDocCursor.gotoEnd( false );
// Go back two paragraphs
xParaCursor.gotoPreviousParagraph ( false );
xParaCursor.gotoPreviousParagraph ( false );
// Go to the end of the document, selecting the two paragraphs
mxDocCursor.gotoEnd ( true );
// Create another text section and access its XNamed interface
XNamed xParentNamed = UnoRuntime.queryInterface(XNamed.class,
mxDocFactory.createInstance("com.sun.star.text.TextSection"));
// Set this text section's name to Parent_Section
xParentNamed.setName ( "Parent_Section" );
// Access the Parent_Section's XTextContent interface ...
XTextContent xParentSection = UnoRuntime.queryInterface(
XTextContent.class, xParentNamed );
// ...and insert it into the document
mxDocText.insertTextContent ( mxDocCursor, xParentSection, false );
// Go to the end of the document
mxDocCursor.gotoEnd ( false );
// Insert a new paragraph
mxDocText.insertControlCharacter (
mxDocCursor, ControlCharacter.PARAGRAPH_BREAK, false );
// And select the new paragraph
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: */