Apache OpenOffice Wiki - User contributions [en]

Extensions trouble shooting

2008-04-30T14:12:48Z

Exactt: added work-arounds as mentioned in http://www.oooforum.org/forum/viewtopic.phtml?t=42403

{{Extensions}}
[[Category:Extensions]]

Collection of pitfalls and solutions regarding the extension development

<ol>
<li>Could not create Java implementation loader
When installing an extension containing a java service, then a message box may appear reading "Could not create Java implementation loader". This usually happens when one wants to debug Java in the office process and therefore has provided the debug options for Java in the options dialog. The Java service of the extension will be registered in a separate process (uno.exe) which also needs to start Java. This Java uses the same settings from the options dialog. For example:
<pre>
-agentlib:jdwp=transport=dt_socket,server=y,suspend=n,address=8100
</pre>
If there is also a Java running in the office process, then the creation of the virtual machine in the second process will fail. The reason is, that the latter receives the same debug settings. It appears that two virtual machines, although in separate processes, cannot use the same port for debugging. If one changes the port number before adding the extension (and after the Java has been created in the office process), then the extension will be installed properly.

The same effect can be seen when running "unopkg gui". When installing the second Java component then a second uno.exe is created and the creation of the virtual machine in this process will fail.

</li>
<li>
Possible Work-Arounds

If you receive this message and think it is not related to the above mentioned problem the following work-arounds might help:

- Rename/Remove your openoffice.org user folder. (e.g. in Ubuntu it is .openoffice.org2/user in your home directory)


- Go into Options and uncheck Java/"Use a Java runtime environment."
Restart OpenOffice and try to enable the extension again. Receive the same error.
Return the check to the "Use a Java runtime environment" box.

</li>
</ol>
[[Category:Extensions]]

OpenOffice Add-On Project Type

2007-07-27T16:06:41Z

Exactt:

Back to [[OpenOffice_NetBeans_Integration|OpenOffice.org NetBeans Integration]]

= Overview =

The Add-On wizard will enable users to create an OpenOffice.org component that including support of UI extensions. The component is based on a on a J2SE class library project and supports additional targets to create and deploy the package into the office installation.
All interface methods are default implemented and do nothing. In a second step you can insert your implementation in the generated skeleton, rebuild the extension and deploy it again to see the effect in your office.

= Project Wizard =
The project wizard is quite simple to use, you simply choose
*'' '''File -> New Project -> StarOffice/OpenOffice.org -> StarOffice/OpenOffice.org Add-On''' ''
and follow the wizard.

* '''Step 1''': Select the project type
 [[Image:AddOn1.png|center]] 
* '''Step 2''': Define the project name, Add-On name, an optional package and the project location
 [[Image:AddOn2.png|center]] 
The necessary xcu files are generated and become part of the final '''oxt''' package. These xcu files can be easily adapted later to extend the initial project to a more complex Add-On example. The generated Add-On skeleton implements a simple [http://api.openoffice.org/docs/common/ref/com/sun/star/frame/ProtocolHandler.html com.sun.star.frame.ProtocolHandler] Add-On. 
* '''Step 3''': Defining the new commands
 [[Image:AddOn3-1.png|center]] 
This part is missing. See also discussion.
* '''Step 4''': Defining the new toplevel menu
 [[Image:AddOn3.png|center]] 
 [[Image:AddOn4.png|center]] 
On this panel you can define new toplevel menus with submenus on a higher abstraction level. You will not have to deal with xcu files directly. You can modify the default menu and commands, add new menus and commands, and you can insert localized displaynames. For more detailed descriptions of the different fields simply press the help button or read the appropriate chapter in the [http://api.openoffice.org/docs/DevelopersGuide/Components/Components.xhtml#1_7_1_Protocol_Handler Developer's Guide - Writing UNO components - Integrating Components into OpenOffice.org - Protocol Handler] 

When you add a new language you can select languages from a list of supported languages. When you delete a language, you can only delete the languages you have added. 
 [[Image:Calc_AddIn3a.png|center]] 
 [[Image:Calc_AddIn3b.png|center]] 
* '''Step 5''': Deploying the extension package
 [[Image:Calc_AddIn4.png|center]] 
You can simply create or deploy the '''oxt''' extension package by choosing: 
::'''Project View -> Project Node -> Context Menu -> Create OXT | Deploy Office Extension''' 

When you have deployed the package, the newly defined menus are visible in the specified context. For example, if you choose the context '''Writer''', the menu is visible when you open or create a text document.

 [[Image:AddOn5.png|center]] 

= Generated Code =
Two (.xcu) files for the Add-On are created that describe the Add-On commands with descriptions, displaynames etc., (Addons.xcu) and the protocol that is used to access these commands (ProtocolHandler.xcu). For the example shown above, the following files are generated:

* '''Addons.xcu''' xcu file defining the new menus with submenus and commands. This file can be easily extended to support toolbars as well (toolbar support will be added later to the wizard).
<code>[xml]
<?xml version='1.0' encoding='UTF-8'?>

<oor:component-data xmlns:oor="http://openoffice.org/2001/registry" xmlns:xs="http://www.w3.org/2001/XMLSchema" oor:name="Addons" oor:package="org.openoffice.Office">
<node oor:name="AddonUI">
<node oor:name="OfficeMenuBar">
<node oor:name="org.openoffice.testaddon.testaddon" oor:op="replace">
<prop oor:name="Title" oor:type="xs:string">
<value/>
<value xml:lang="en">My Menu</value>
</prop>
<prop oor:name="Target" oor:type="xs:string">
<value>_self</value>
</prop>
<prop oor:name="ImageIdentifier" oor:type="xs:string">
<value/>
</prop>
<node oor:name="Submenu">
<node oor:name="m1" oor:op="replace">
<prop oor:name="URL" oor:type="xs:string">
<value>org.openoffice.testaddon.testaddon:mycommands</value>
</prop>
<prop oor:name="ImageIdentifier" oor:type="xs:string">
<value/>
</prop>
<prop oor:name="Target" oor:type="xs:string">
<value>_self</value>
</prop>
<prop oor:name="Context" oor:type="xs:string">
<value/>
</prop>
<prop oor:name="Title" oor:type="xs:string">
<value/>
<value xml:lang="en">Hello World</value>
</prop>
</node>
</node>
</node>
</node>
<node oor:name="Images">
<node oor:name="org.openoffice.testaddon.testaddon.mycommands.images" oor:op="replace">
<prop oor:name="URL" oor:type="xs:string">
<value>org.openoffice.testaddon.testaddon:mycommands</value>
</prop>
<node oor:name="UserDefinedImages">
<prop oor:name="ImageSmallURL">
<value/>
</prop>
</node>
</node>
</node>
</node>
</oor:component-data>
</code>

* '''ProtocolHandler.xcu''' xcu file defining the automatically generated protocol. The protocol is generated based on the package name and Add-On name.
<code>[xml]
<?xml version='1.0' encoding='UTF-8'?>

<oor:component-data oor:name="ProtocolHandler" oor:package="org.openoffice.Office" xmlns:oor="http://openoffice.org/2001/registry" xmlns:xs="http://www.w3.org/2001/XMLSchema" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
<node oor:name="HandlerSet">
<node oor:name="org.openoffice.testaddon.TestAddOn" oor:op="replace">
<prop oor:name="Protocols" oor:type="oor:string-list">
<value>org.openoffice.testaddon.testaddon:*</value>
</prop>
</node>
</node>
</oor:component-data>
</code>
* '''uno-extension-manifest.xml''' the package descriptor, will be packed as "META-INF/manifest.xml"
<code>[xml]
<?xml version="1.0" encoding="UTF-8"?>
<manifest:manifest xmlns:manifest="http://openoffice.org/2001/manifest">
<manifest:file-entry manifest:media-type="application/vnd.sun.star.configuration-data"
manifest:full-path="ProtocolHandler.xcu"/>
<manifest:file-entry manifest:media-type="application/vnd.sun.star.configuration-data"
manifest:full-path="Addons.xcu"/>
<manifest:file-entry manifest:media-type="application/vnd.sun.star.uno-component;type=Java"
manifest:full-path="TestAddOn.jar"/>
</manifest:manifest>
</code>

* '''org/openoffice/testaddon/TestAddOn.java''' the generated Add-On code skeleton where the generated class acts itself as the dispatch object (can be easily changed to support more complex Add-Ons). Most of the methods are already implemented and you simply have to add your own code in the dispatch method in the right place for each specified command.
<code>[java]
package org.openoffice.testaddon;

import com.sun.star.uno.UnoRuntime;
import com.sun.star.uno.XComponentContext;
import com.sun.star.lib.uno.helper.Factory;
import com.sun.star.lang.XSingleComponentFactory;
import com.sun.star.registry.XRegistryKey;
import com.sun.star.lib.uno.helper.WeakBase;

public final class TestAddOn extends WeakBase
implements com.sun.star.lang.XServiceInfo,
com.sun.star.frame.XDispatchProvider,
com.sun.star.lang.XInitialization,
com.sun.star.frame.XDispatch
{
private final XComponentContext m_xContext;
private com.sun.star.frame.XFrame m_xFrame;
private static final String m_implementationName = TestAddOn.class.getName();
private static final String[] m_serviceNames = {
"com.sun.star.frame.ProtocolHandler" };

public TestAddOn( XComponentContext context )
{
m_xContext = context;
};

public static XSingleComponentFactory __getComponentFactory( String sImplementationName ) {
XSingleComponentFactory xFactory = null;

if ( sImplementationName.equals( m_implementationName ) )
xFactory = Factory.createComponentFactory(TestAddOn.class, m_serviceNames);
return xFactory;
}

public static boolean __writeRegistryServiceInfo( XRegistryKey xRegistryKey ) {
return Factory.writeRegistryServiceInfo(m_implementationName,
m_serviceNames,
xRegistryKey);
}

// com.sun.star.lang.XServiceInfo:
public String getImplementationName() {
return m_implementationName;
}

public boolean supportsService( String sService ) {
int len = m_serviceNames.length;

for( int i=0; i < len; i++) {
if (sService.equals(m_serviceNames[i]))
return true;
}
return false;
}

public String[] getSupportedServiceNames() {
return m_serviceNames;
}

// com.sun.star.frame.XDispatchProvider:
public com.sun.star.frame.XDispatch queryDispatch( com.sun.star.util.URL aURL,
String sTargetFrameName,
int iSearchFlags )
{
if ( aURL.Protocol.compareTo("org.openoffice.testaddon.testaddon:") == 0 )
{
if ( aURL.Path.compareTo("mycommands") == 0 )
return this;
}
return null;
}

// com.sun.star.frame.XDispatchProvider:
public com.sun.star.frame.XDispatch[] queryDispatches(
com.sun.star.frame.DispatchDescriptor[] seqDescriptors )
{
int nCount = seqDescriptors.length;
com.sun.star.frame.XDispatch[] seqDispatcher =
new com.sun.star.frame.XDispatch[seqDescriptors.length];

for( int i=0; i < nCount; ++i )
{
seqDispatcher[i] = queryDispatch(seqDescriptors[i].FeatureURL,
seqDescriptors[i].FrameName,
seqDescriptors[i].SearchFlags );
}
return seqDispatcher;
}

// com.sun.star.lang.XInitialization:
public void initialize( Object[] object )
throws com.sun.star.uno.Exception
{
if ( object.length > 0 )
{
m_xFrame = (com.sun.star.frame.XFrame)UnoRuntime.queryInterface(
com.sun.star.frame.XFrame.class, object[0]);
}
}

// com.sun.star.frame.XDispatch:
public void dispatch( com.sun.star.util.URL aURL,
com.sun.star.beans.PropertyValue[] aArguments )
{
if ( aURL.Protocol.compareTo("org.openoffice.testaddon.testaddon:") == 0 )
{
if ( aURL.Path.compareTo("mycommands") == 0 )
{
// add your own code here
return;
}
}
}

public void addStatusListener( com.sun.star.frame.XStatusListener xControl,
com.sun.star.util.URL aURL )
{
// add your own code here
}

public void removeStatusListener( com.sun.star.frame.XStatusListener xControl,
com.sun.star.util.URL aURL )
{
// add your own code here
}

}
</code>

[[Category:Uno]]
[[Category:Development]]
[[Category:Add-Ons]]
[[Category:API]]

OpenOffice Add-On Project Type

2007-07-27T16:01:36Z

Exactt: added an image for step 3

Back to [[OpenOffice_NetBeans_Integration|OpenOffice.org NetBeans Integration]]

= Overview =

The Add-On wizard will enable users to create an OpenOffice.org component that including support of UI extensions. The component is based on a on a J2SE class library project and supports additional targets to create and deploy the package into the office installation.
All interface methods are default implemented and do nothing. In a second step you can insert your implementation in the generated skeleton, rebuild the extension and deploy it again to see the effect in your office.

= Project Wizard =
The project wizard is quite simple to use, you simply choose
*'' '''File -> New Project -> StarOffice/OpenOffice.org -> StarOffice/OpenOffice.org Add-On''' ''
and follow the wizard.

* '''Step 1''': Select the project type
 [[Image:AddOn1.png|center]] 
* '''Step 2''': Define the project name, Add-On name, an optional package and the project location
 [[Image:AddOn2.png|center]] 
The necessary xcu files are generated and become part of the final '''oxt''' package. These xcu files can be easily adapted later to extend the initial project to a more complex Add-On example. The generated Add-On skeleton implements a simple [http://api.openoffice.org/docs/common/ref/com/sun/star/frame/ProtocolHandler.html com.sun.star.frame.ProtocolHandler] Add-On. 
* '''Step 3''': Defining Functions and Description with Localization
 [[Image:AddOn3-1.png|center]] 
This part is missing. See also discussion.
* '''Step 4''': Defining the new toplevel menu
 [[Image:AddOn3.png|center]] 
 [[Image:AddOn4.png|center]] 
On this panel you can define new toplevel menus with submenus on a higher abstraction level. You will not have to deal with xcu files directly. You can modify the default menu and commands, add new menus and commands, and you can insert localized displaynames. For more detailed descriptions of the different fields simply press the help button or read the appropriate chapter in the [http://api.openoffice.org/docs/DevelopersGuide/Components/Components.xhtml#1_7_1_Protocol_Handler Developer's Guide - Writing UNO components - Integrating Components into OpenOffice.org - Protocol Handler] 

When you add a new language you can select languages from a list of supported languages. When you delete a language, you can only delete the languages you have added. 
 [[Image:Calc_AddIn3a.png|center]] 
 [[Image:Calc_AddIn3b.png|center]] 
* '''Step 5''': Deploying the extension package
 [[Image:Calc_AddIn4.png|center]] 
You can simply create or deploy the '''oxt''' extension package by choosing: 
::'''Project View -> Project Node -> Context Menu -> Create OXT | Deploy Office Extension''' 

When you have deployed the package, the newly defined menus are visible in the specified context. For example, if you choose the context '''Writer''', the menu is visible when you open or create a text document.

 [[Image:AddOn5.png|center]] 

= Generated Code =
Two (.xcu) files for the Add-On are created that describe the Add-On commands with descriptions, displaynames etc., (Addons.xcu) and the protocol that is used to access these commands (ProtocolHandler.xcu). For the example shown above, the following files are generated:

* '''Addons.xcu''' xcu file defining the new menus with submenus and commands. This file can be easily extended to support toolbars as well (toolbar support will be added later to the wizard).
<code>[xml]
<?xml version='1.0' encoding='UTF-8'?>

<oor:component-data xmlns:oor="http://openoffice.org/2001/registry" xmlns:xs="http://www.w3.org/2001/XMLSchema" oor:name="Addons" oor:package="org.openoffice.Office">
<node oor:name="AddonUI">
<node oor:name="OfficeMenuBar">
<node oor:name="org.openoffice.testaddon.testaddon" oor:op="replace">
<prop oor:name="Title" oor:type="xs:string">
<value/>
<value xml:lang="en">My Menu</value>
</prop>
<prop oor:name="Target" oor:type="xs:string">
<value>_self</value>
</prop>
<prop oor:name="ImageIdentifier" oor:type="xs:string">
<value/>
</prop>
<node oor:name="Submenu">
<node oor:name="m1" oor:op="replace">
<prop oor:name="URL" oor:type="xs:string">
<value>org.openoffice.testaddon.testaddon:mycommands</value>
</prop>
<prop oor:name="ImageIdentifier" oor:type="xs:string">
<value/>
</prop>
<prop oor:name="Target" oor:type="xs:string">
<value>_self</value>
</prop>
<prop oor:name="Context" oor:type="xs:string">
<value/>
</prop>
<prop oor:name="Title" oor:type="xs:string">
<value/>
<value xml:lang="en">Hello World</value>
</prop>
</node>
</node>
</node>
</node>
<node oor:name="Images">
<node oor:name="org.openoffice.testaddon.testaddon.mycommands.images" oor:op="replace">
<prop oor:name="URL" oor:type="xs:string">
<value>org.openoffice.testaddon.testaddon:mycommands</value>
</prop>
<node oor:name="UserDefinedImages">
<prop oor:name="ImageSmallURL">
<value/>
</prop>
</node>
</node>
</node>
</node>
</oor:component-data>
</code>

* '''ProtocolHandler.xcu''' xcu file defining the automatically generated protocol. The protocol is generated based on the package name and Add-On name.
<code>[xml]
<?xml version='1.0' encoding='UTF-8'?>

<oor:component-data oor:name="ProtocolHandler" oor:package="org.openoffice.Office" xmlns:oor="http://openoffice.org/2001/registry" xmlns:xs="http://www.w3.org/2001/XMLSchema" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
<node oor:name="HandlerSet">
<node oor:name="org.openoffice.testaddon.TestAddOn" oor:op="replace">
<prop oor:name="Protocols" oor:type="oor:string-list">
<value>org.openoffice.testaddon.testaddon:*</value>
</prop>
</node>
</node>
</oor:component-data>
</code>
* '''uno-extension-manifest.xml''' the package descriptor, will be packed as "META-INF/manifest.xml"
<code>[xml]
<?xml version="1.0" encoding="UTF-8"?>
<manifest:manifest xmlns:manifest="http://openoffice.org/2001/manifest">
<manifest:file-entry manifest:media-type="application/vnd.sun.star.configuration-data"
manifest:full-path="ProtocolHandler.xcu"/>
<manifest:file-entry manifest:media-type="application/vnd.sun.star.configuration-data"
manifest:full-path="Addons.xcu"/>
<manifest:file-entry manifest:media-type="application/vnd.sun.star.uno-component;type=Java"
manifest:full-path="TestAddOn.jar"/>
</manifest:manifest>
</code>

* '''org/openoffice/testaddon/TestAddOn.java''' the generated Add-On code skeleton where the generated class acts itself as the dispatch object (can be easily changed to support more complex Add-Ons). Most of the methods are already implemented and you simply have to add your own code in the dispatch method in the right place for each specified command.
<code>[java]
package org.openoffice.testaddon;

import com.sun.star.uno.UnoRuntime;
import com.sun.star.uno.XComponentContext;
import com.sun.star.lib.uno.helper.Factory;
import com.sun.star.lang.XSingleComponentFactory;
import com.sun.star.registry.XRegistryKey;
import com.sun.star.lib.uno.helper.WeakBase;

public final class TestAddOn extends WeakBase
implements com.sun.star.lang.XServiceInfo,
com.sun.star.frame.XDispatchProvider,
com.sun.star.lang.XInitialization,
com.sun.star.frame.XDispatch
{
private final XComponentContext m_xContext;
private com.sun.star.frame.XFrame m_xFrame;
private static final String m_implementationName = TestAddOn.class.getName();
private static final String[] m_serviceNames = {
"com.sun.star.frame.ProtocolHandler" };

public TestAddOn( XComponentContext context )
{
m_xContext = context;
};

public static XSingleComponentFactory __getComponentFactory( String sImplementationName ) {
XSingleComponentFactory xFactory = null;

if ( sImplementationName.equals( m_implementationName ) )
xFactory = Factory.createComponentFactory(TestAddOn.class, m_serviceNames);
return xFactory;
}

public static boolean __writeRegistryServiceInfo( XRegistryKey xRegistryKey ) {
return Factory.writeRegistryServiceInfo(m_implementationName,
m_serviceNames,
xRegistryKey);
}

// com.sun.star.lang.XServiceInfo:
public String getImplementationName() {
return m_implementationName;
}

public boolean supportsService( String sService ) {
int len = m_serviceNames.length;

for( int i=0; i < len; i++) {
if (sService.equals(m_serviceNames[i]))
return true;
}
return false;
}

public String[] getSupportedServiceNames() {
return m_serviceNames;
}

// com.sun.star.frame.XDispatchProvider:
public com.sun.star.frame.XDispatch queryDispatch( com.sun.star.util.URL aURL,
String sTargetFrameName,
int iSearchFlags )
{
if ( aURL.Protocol.compareTo("org.openoffice.testaddon.testaddon:") == 0 )
{
if ( aURL.Path.compareTo("mycommands") == 0 )
return this;
}
return null;
}

// com.sun.star.frame.XDispatchProvider:
public com.sun.star.frame.XDispatch[] queryDispatches(
com.sun.star.frame.DispatchDescriptor[] seqDescriptors )
{
int nCount = seqDescriptors.length;
com.sun.star.frame.XDispatch[] seqDispatcher =
new com.sun.star.frame.XDispatch[seqDescriptors.length];

for( int i=0; i < nCount; ++i )
{
seqDispatcher[i] = queryDispatch(seqDescriptors[i].FeatureURL,
seqDescriptors[i].FrameName,
seqDescriptors[i].SearchFlags );
}
return seqDispatcher;
}

// com.sun.star.lang.XInitialization:
public void initialize( Object[] object )
throws com.sun.star.uno.Exception
{
if ( object.length > 0 )
{
m_xFrame = (com.sun.star.frame.XFrame)UnoRuntime.queryInterface(
com.sun.star.frame.XFrame.class, object[0]);
}
}

// com.sun.star.frame.XDispatch:
public void dispatch( com.sun.star.util.URL aURL,
com.sun.star.beans.PropertyValue[] aArguments )
{
if ( aURL.Protocol.compareTo("org.openoffice.testaddon.testaddon:") == 0 )
{
if ( aURL.Path.compareTo("mycommands") == 0 )
{
// add your own code here
return;
}
}
}

public void addStatusListener( com.sun.star.frame.XStatusListener xControl,
com.sun.star.util.URL aURL )
{
// add your own code here
}

public void removeStatusListener( com.sun.star.frame.XStatusListener xControl,
com.sun.star.util.URL aURL )
{
// add your own code here
}

}
</code>

[[Category:Uno]]
[[Category:Development]]
[[Category:Add-Ons]]
[[Category:API]]

File:AddOn3-1.png

2007-07-27T16:00:54Z

Exactt: AddOn screen 3

AddOn screen 3

OpenOffice Add-On Project Type

2007-07-27T15:52:26Z

Exactt: Added empty missing step 3

Back to [[OpenOffice_NetBeans_Integration|OpenOffice.org NetBeans Integration]]

= Overview =

The Add-On wizard will enable users to create an OpenOffice.org component that including support of UI extensions. The component is based on a on a J2SE class library project and supports additional targets to create and deploy the package into the office installation.
All interface methods are default implemented and do nothing. In a second step you can insert your implementation in the generated skeleton, rebuild the extension and deploy it again to see the effect in your office.

= Project Wizard =
The project wizard is quite simple to use, you simply choose
*'' '''File -> New Project -> StarOffice/OpenOffice.org -> StarOffice/OpenOffice.org Add-On''' ''
and follow the wizard.

* '''Step 1''': Select the project type
 [[Image:AddOn1.png|center]] 
* '''Step 2''': Define the project name, Add-On name, an optional package and the project location
 [[Image:AddOn2.png|center]] 
The necessary xcu files are generated and become part of the final '''oxt''' package. These xcu files can be easily adapted later to extend the initial project to a more complex Add-On example. The generated Add-On skeleton implements a simple [http://api.openoffice.org/docs/common/ref/com/sun/star/frame/ProtocolHandler.html com.sun.star.frame.ProtocolHandler] Add-On. 
* '''Step 3''': Defining Functions and Description with Localization
This part is missing. See also discussion.
* '''Step 4''': Defining the new toplevel menu
 [[Image:AddOn3.png|center]] 
 [[Image:AddOn4.png|center]] 
On this panel you can define new toplevel menus with submenus on a higher abstraction level. You will not have to deal with xcu files directly. You can modify the default menu and commands, add new menus and commands, and you can insert localized displaynames. For more detailed descriptions of the different fields simply press the help button or read the appropriate chapter in the [http://api.openoffice.org/docs/DevelopersGuide/Components/Components.xhtml#1_7_1_Protocol_Handler Developer's Guide - Writing UNO components - Integrating Components into OpenOffice.org - Protocol Handler] 

When you add a new language you can select languages from a list of supported languages. When you delete a language, you can only delete the languages you have added. 
 [[Image:Calc_AddIn3a.png|center]] 
 [[Image:Calc_AddIn3b.png|center]] 
* '''Step 5''': Deploying the extension package
 [[Image:Calc_AddIn4.png|center]] 
You can simply create or deploy the '''oxt''' extension package by choosing: 
::'''Project View -> Project Node -> Context Menu -> Create OXT | Deploy Office Extension''' 

When you have deployed the package, the newly defined menus are visible in the specified context. For example, if you choose the context '''Writer''', the menu is visible when you open or create a text document.

 [[Image:AddOn5.png|center]] 

= Generated Code =
Two (.xcu) files for the Add-On are created that describe the Add-On commands with descriptions, displaynames etc., (Addons.xcu) and the protocol that is used to access these commands (ProtocolHandler.xcu). For the example shown above, the following files are generated:

* '''Addons.xcu''' xcu file defining the new menus with submenus and commands. This file can be easily extended to support toolbars as well (toolbar support will be added later to the wizard).
<code>[xml]
<?xml version='1.0' encoding='UTF-8'?>

<oor:component-data xmlns:oor="http://openoffice.org/2001/registry" xmlns:xs="http://www.w3.org/2001/XMLSchema" oor:name="Addons" oor:package="org.openoffice.Office">
<node oor:name="AddonUI">
<node oor:name="OfficeMenuBar">
<node oor:name="org.openoffice.testaddon.testaddon" oor:op="replace">
<prop oor:name="Title" oor:type="xs:string">
<value/>
<value xml:lang="en">My Menu</value>
</prop>
<prop oor:name="Target" oor:type="xs:string">
<value>_self</value>
</prop>
<prop oor:name="ImageIdentifier" oor:type="xs:string">
<value/>
</prop>
<node oor:name="Submenu">
<node oor:name="m1" oor:op="replace">
<prop oor:name="URL" oor:type="xs:string">
<value>org.openoffice.testaddon.testaddon:mycommands</value>
</prop>
<prop oor:name="ImageIdentifier" oor:type="xs:string">
<value/>
</prop>
<prop oor:name="Target" oor:type="xs:string">
<value>_self</value>
</prop>
<prop oor:name="Context" oor:type="xs:string">
<value/>
</prop>
<prop oor:name="Title" oor:type="xs:string">
<value/>
<value xml:lang="en">Hello World</value>
</prop>
</node>
</node>
</node>
</node>
<node oor:name="Images">
<node oor:name="org.openoffice.testaddon.testaddon.mycommands.images" oor:op="replace">
<prop oor:name="URL" oor:type="xs:string">
<value>org.openoffice.testaddon.testaddon:mycommands</value>
</prop>
<node oor:name="UserDefinedImages">
<prop oor:name="ImageSmallURL">
<value/>
</prop>
</node>
</node>
</node>
</node>
</oor:component-data>
</code>

* '''ProtocolHandler.xcu''' xcu file defining the automatically generated protocol. The protocol is generated based on the package name and Add-On name.
<code>[xml]
<?xml version='1.0' encoding='UTF-8'?>

<oor:component-data oor:name="ProtocolHandler" oor:package="org.openoffice.Office" xmlns:oor="http://openoffice.org/2001/registry" xmlns:xs="http://www.w3.org/2001/XMLSchema" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
<node oor:name="HandlerSet">
<node oor:name="org.openoffice.testaddon.TestAddOn" oor:op="replace">
<prop oor:name="Protocols" oor:type="oor:string-list">
<value>org.openoffice.testaddon.testaddon:*</value>
</prop>
</node>
</node>
</oor:component-data>
</code>
* '''uno-extension-manifest.xml''' the package descriptor, will be packed as "META-INF/manifest.xml"
<code>[xml]
<?xml version="1.0" encoding="UTF-8"?>
<manifest:manifest xmlns:manifest="http://openoffice.org/2001/manifest">
<manifest:file-entry manifest:media-type="application/vnd.sun.star.configuration-data"
manifest:full-path="ProtocolHandler.xcu"/>
<manifest:file-entry manifest:media-type="application/vnd.sun.star.configuration-data"
manifest:full-path="Addons.xcu"/>
<manifest:file-entry manifest:media-type="application/vnd.sun.star.uno-component;type=Java"
manifest:full-path="TestAddOn.jar"/>
</manifest:manifest>
</code>

* '''org/openoffice/testaddon/TestAddOn.java''' the generated Add-On code skeleton where the generated class acts itself as the dispatch object (can be easily changed to support more complex Add-Ons). Most of the methods are already implemented and you simply have to add your own code in the dispatch method in the right place for each specified command.
<code>[java]
package org.openoffice.testaddon;

import com.sun.star.uno.UnoRuntime;
import com.sun.star.uno.XComponentContext;
import com.sun.star.lib.uno.helper.Factory;
import com.sun.star.lang.XSingleComponentFactory;
import com.sun.star.registry.XRegistryKey;
import com.sun.star.lib.uno.helper.WeakBase;

public final class TestAddOn extends WeakBase
implements com.sun.star.lang.XServiceInfo,
com.sun.star.frame.XDispatchProvider,
com.sun.star.lang.XInitialization,
com.sun.star.frame.XDispatch
{
private final XComponentContext m_xContext;
private com.sun.star.frame.XFrame m_xFrame;
private static final String m_implementationName = TestAddOn.class.getName();
private static final String[] m_serviceNames = {
"com.sun.star.frame.ProtocolHandler" };

public TestAddOn( XComponentContext context )
{
m_xContext = context;
};

public static XSingleComponentFactory __getComponentFactory( String sImplementationName ) {
XSingleComponentFactory xFactory = null;

if ( sImplementationName.equals( m_implementationName ) )
xFactory = Factory.createComponentFactory(TestAddOn.class, m_serviceNames);
return xFactory;
}

public static boolean __writeRegistryServiceInfo( XRegistryKey xRegistryKey ) {
return Factory.writeRegistryServiceInfo(m_implementationName,
m_serviceNames,
xRegistryKey);
}

// com.sun.star.lang.XServiceInfo:
public String getImplementationName() {
return m_implementationName;
}

public boolean supportsService( String sService ) {
int len = m_serviceNames.length;

for( int i=0; i < len; i++) {
if (sService.equals(m_serviceNames[i]))
return true;
}
return false;
}

public String[] getSupportedServiceNames() {
return m_serviceNames;
}

// com.sun.star.frame.XDispatchProvider:
public com.sun.star.frame.XDispatch queryDispatch( com.sun.star.util.URL aURL,
String sTargetFrameName,
int iSearchFlags )
{
if ( aURL.Protocol.compareTo("org.openoffice.testaddon.testaddon:") == 0 )
{
if ( aURL.Path.compareTo("mycommands") == 0 )
return this;
}
return null;
}

// com.sun.star.frame.XDispatchProvider:
public com.sun.star.frame.XDispatch[] queryDispatches(
com.sun.star.frame.DispatchDescriptor[] seqDescriptors )
{
int nCount = seqDescriptors.length;
com.sun.star.frame.XDispatch[] seqDispatcher =
new com.sun.star.frame.XDispatch[seqDescriptors.length];

for( int i=0; i < nCount; ++i )
{
seqDispatcher[i] = queryDispatch(seqDescriptors[i].FeatureURL,
seqDescriptors[i].FrameName,
seqDescriptors[i].SearchFlags );
}
return seqDispatcher;
}

// com.sun.star.lang.XInitialization:
public void initialize( Object[] object )
throws com.sun.star.uno.Exception
{
if ( object.length > 0 )
{
m_xFrame = (com.sun.star.frame.XFrame)UnoRuntime.queryInterface(
com.sun.star.frame.XFrame.class, object[0]);
}
}

// com.sun.star.frame.XDispatch:
public void dispatch( com.sun.star.util.URL aURL,
com.sun.star.beans.PropertyValue[] aArguments )
{
if ( aURL.Protocol.compareTo("org.openoffice.testaddon.testaddon:") == 0 )
{
if ( aURL.Path.compareTo("mycommands") == 0 )
{
// add your own code here
return;
}
}
}

public void addStatusListener( com.sun.star.frame.XStatusListener xControl,
com.sun.star.util.URL aURL )
{
// add your own code here
}

public void removeStatusListener( com.sun.star.frame.XStatusListener xControl,
com.sun.star.util.URL aURL )
{
// add your own code here
}

}
</code>

[[Category:Uno]]
[[Category:Development]]
[[Category:Add-Ons]]
[[Category:API]]

Talk:OpenOffice Add-On Project Type

2007-07-27T15:50:18Z

Exactt:

What happened to Step 3?
This somehow is a crucial point. It adds the commands...

OpenOffice Add-On Project Type

2007-07-27T15:33:41Z

Exactt: just a typo

Back to [[OpenOffice_NetBeans_Integration|OpenOffice.org NetBeans Integration]]

= Overview =

The Add-On wizard will enable users to create an OpenOffice.org component that including support of UI extensions. The component is based on a on a J2SE class library project and supports additional targets to create and deploy the package into the office installation.
All interface methods are default implemented and do nothing. In a second step you can insert your implementation in the generated skeleton, rebuild the extension and deploy it again to see the effect in your office.

= Project Wizard =
The project wizard is quite simple to use, you simply choose
*'' '''File -> New Project -> StarOffice/OpenOffice.org -> StarOffice/OpenOffice.org Add-On''' ''
and follow the wizard.

* '''Step 1''': Select the project type
 [[Image:AddOn1.png|center]] 
* '''Step 2''': Define the project name, Add-On name, an optional package and the project location
 [[Image:AddOn2.png|center]] 
The necessary xcu files are generated and become part of the final '''oxt''' package. These xcu files can be easily adapted later to extend the initial project to a more complex Add-On example. The generated Add-On skeleton implements a simple [http://api.openoffice.org/docs/common/ref/com/sun/star/frame/ProtocolHandler.html com.sun.star.frame.ProtocolHandler] Add-On. 
* '''Step 4''': Defining the new toplevel menu
 [[Image:AddOn3.png|center]] 
 [[Image:AddOn4.png|center]] 
On this panel you can define new toplevel menus with submenus on a higher abstraction level. You will not have to deal with xcu files directly. You can modify the default menu and commands, add new menus and commands, and you can insert localized displaynames. For more detailed descriptions of the different fields simply press the help button or read the appropriate chapter in the [http://api.openoffice.org/docs/DevelopersGuide/Components/Components.xhtml#1_7_1_Protocol_Handler Developer's Guide - Writing UNO components - Integrating Components into OpenOffice.org - Protocol Handler] 

When you add a new language you can select languages from a list of supported languages. When you delete a language, you can only delete the languages you have added. 
 [[Image:Calc_AddIn3a.png|center]] 
 [[Image:Calc_AddIn3b.png|center]] 
* '''Step 5''': Deploying the extension package
 [[Image:Calc_AddIn4.png|center]] 
You can simply create or deploy the '''oxt''' extension package by choosing: 
::'''Project View -> Project Node -> Context Menu -> Create OXT | Deploy Office Extension''' 

When you have deployed the package, the newly defined menus are visible in the specified context. For example, if you choose the context '''Writer''', the menu is visible when you open or create a text document.

 [[Image:AddOn5.png|center]] 

= Generated Code =
Two (.xcu) files for the Add-On are created that describe the Add-On commands with descriptions, displaynames etc., (Addons.xcu) and the protocol that is used to access these commands (ProtocolHandler.xcu). For the example shown above, the following files are generated:

* '''Addons.xcu''' xcu file defining the new menus with submenus and commands. This file can be easily extended to support toolbars as well (toolbar support will be added later to the wizard).
<code>[xml]
<?xml version='1.0' encoding='UTF-8'?>

<oor:component-data xmlns:oor="http://openoffice.org/2001/registry" xmlns:xs="http://www.w3.org/2001/XMLSchema" oor:name="Addons" oor:package="org.openoffice.Office">
<node oor:name="AddonUI">
<node oor:name="OfficeMenuBar">
<node oor:name="org.openoffice.testaddon.testaddon" oor:op="replace">
<prop oor:name="Title" oor:type="xs:string">
<value/>
<value xml:lang="en">My Menu</value>
</prop>
<prop oor:name="Target" oor:type="xs:string">
<value>_self</value>
</prop>
<prop oor:name="ImageIdentifier" oor:type="xs:string">
<value/>
</prop>
<node oor:name="Submenu">
<node oor:name="m1" oor:op="replace">
<prop oor:name="URL" oor:type="xs:string">
<value>org.openoffice.testaddon.testaddon:mycommands</value>
</prop>
<prop oor:name="ImageIdentifier" oor:type="xs:string">
<value/>
</prop>
<prop oor:name="Target" oor:type="xs:string">
<value>_self</value>
</prop>
<prop oor:name="Context" oor:type="xs:string">
<value/>
</prop>
<prop oor:name="Title" oor:type="xs:string">
<value/>
<value xml:lang="en">Hello World</value>
</prop>
</node>
</node>
</node>
</node>
<node oor:name="Images">
<node oor:name="org.openoffice.testaddon.testaddon.mycommands.images" oor:op="replace">
<prop oor:name="URL" oor:type="xs:string">
<value>org.openoffice.testaddon.testaddon:mycommands</value>
</prop>
<node oor:name="UserDefinedImages">
<prop oor:name="ImageSmallURL">
<value/>
</prop>
</node>
</node>
</node>
</node>
</oor:component-data>
</code>

* '''ProtocolHandler.xcu''' xcu file defining the automatically generated protocol. The protocol is generated based on the package name and Add-On name.
<code>[xml]
<?xml version='1.0' encoding='UTF-8'?>

<oor:component-data oor:name="ProtocolHandler" oor:package="org.openoffice.Office" xmlns:oor="http://openoffice.org/2001/registry" xmlns:xs="http://www.w3.org/2001/XMLSchema" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
<node oor:name="HandlerSet">
<node oor:name="org.openoffice.testaddon.TestAddOn" oor:op="replace">
<prop oor:name="Protocols" oor:type="oor:string-list">
<value>org.openoffice.testaddon.testaddon:*</value>
</prop>
</node>
</node>
</oor:component-data>
</code>
* '''uno-extension-manifest.xml''' the package descriptor, will be packed as "META-INF/manifest.xml"
<code>[xml]
<?xml version="1.0" encoding="UTF-8"?>
<manifest:manifest xmlns:manifest="http://openoffice.org/2001/manifest">
<manifest:file-entry manifest:media-type="application/vnd.sun.star.configuration-data"
manifest:full-path="ProtocolHandler.xcu"/>
<manifest:file-entry manifest:media-type="application/vnd.sun.star.configuration-data"
manifest:full-path="Addons.xcu"/>
<manifest:file-entry manifest:media-type="application/vnd.sun.star.uno-component;type=Java"
manifest:full-path="TestAddOn.jar"/>
</manifest:manifest>
</code>

* '''org/openoffice/testaddon/TestAddOn.java''' the generated Add-On code skeleton where the generated class acts itself as the dispatch object (can be easily changed to support more complex Add-Ons). Most of the methods are already implemented and you simply have to add your own code in the dispatch method in the right place for each specified command.
<code>[java]
package org.openoffice.testaddon;

import com.sun.star.uno.UnoRuntime;
import com.sun.star.uno.XComponentContext;
import com.sun.star.lib.uno.helper.Factory;
import com.sun.star.lang.XSingleComponentFactory;
import com.sun.star.registry.XRegistryKey;
import com.sun.star.lib.uno.helper.WeakBase;

public final class TestAddOn extends WeakBase
implements com.sun.star.lang.XServiceInfo,
com.sun.star.frame.XDispatchProvider,
com.sun.star.lang.XInitialization,
com.sun.star.frame.XDispatch
{
private final XComponentContext m_xContext;
private com.sun.star.frame.XFrame m_xFrame;
private static final String m_implementationName = TestAddOn.class.getName();
private static final String[] m_serviceNames = {
"com.sun.star.frame.ProtocolHandler" };

public TestAddOn( XComponentContext context )
{
m_xContext = context;
};

public static XSingleComponentFactory __getComponentFactory( String sImplementationName ) {
XSingleComponentFactory xFactory = null;

if ( sImplementationName.equals( m_implementationName ) )
xFactory = Factory.createComponentFactory(TestAddOn.class, m_serviceNames);
return xFactory;
}

public static boolean __writeRegistryServiceInfo( XRegistryKey xRegistryKey ) {
return Factory.writeRegistryServiceInfo(m_implementationName,
m_serviceNames,
xRegistryKey);
}

// com.sun.star.lang.XServiceInfo:
public String getImplementationName() {
return m_implementationName;
}

public boolean supportsService( String sService ) {
int len = m_serviceNames.length;

for( int i=0; i < len; i++) {
if (sService.equals(m_serviceNames[i]))
return true;
}
return false;
}

public String[] getSupportedServiceNames() {
return m_serviceNames;
}

// com.sun.star.frame.XDispatchProvider:
public com.sun.star.frame.XDispatch queryDispatch( com.sun.star.util.URL aURL,
String sTargetFrameName,
int iSearchFlags )
{
if ( aURL.Protocol.compareTo("org.openoffice.testaddon.testaddon:") == 0 )
{
if ( aURL.Path.compareTo("mycommands") == 0 )
return this;
}
return null;
}

// com.sun.star.frame.XDispatchProvider:
public com.sun.star.frame.XDispatch[] queryDispatches(
com.sun.star.frame.DispatchDescriptor[] seqDescriptors )
{
int nCount = seqDescriptors.length;
com.sun.star.frame.XDispatch[] seqDispatcher =
new com.sun.star.frame.XDispatch[seqDescriptors.length];

for( int i=0; i < nCount; ++i )
{
seqDispatcher[i] = queryDispatch(seqDescriptors[i].FeatureURL,
seqDescriptors[i].FrameName,
seqDescriptors[i].SearchFlags );
}
return seqDispatcher;
}

// com.sun.star.lang.XInitialization:
public void initialize( Object[] object )
throws com.sun.star.uno.Exception
{
if ( object.length > 0 )
{
m_xFrame = (com.sun.star.frame.XFrame)UnoRuntime.queryInterface(
com.sun.star.frame.XFrame.class, object[0]);
}
}

// com.sun.star.frame.XDispatch:
public void dispatch( com.sun.star.util.URL aURL,
com.sun.star.beans.PropertyValue[] aArguments )
{
if ( aURL.Protocol.compareTo("org.openoffice.testaddon.testaddon:") == 0 )
{
if ( aURL.Path.compareTo("mycommands") == 0 )
{
// add your own code here
return;
}
}
}

public void addStatusListener( com.sun.star.frame.XStatusListener xControl,
com.sun.star.util.URL aURL )
{
// add your own code here
}

public void removeStatusListener( com.sun.star.frame.XStatusListener xControl,
com.sun.star.util.URL aURL )
{
// add your own code here
}

}
</code>

[[Category:Uno]]
[[Category:Development]]
[[Category:Add-Ons]]
[[Category:API]]

Calc/Add-In/Simple Calc Add-In

2007-06-22T17:20:50Z

Exactt: /* Requirements */ more ubuntu stuff

This is a step by step guide on how to write a simple component (a Calc add-in) for [[OpenOffice.org]] (OOo) in C++. Even though the instructions are for [[Linux]], this guide should give an idea on how to write components on other operating systems as well.

==Requirements==
Make sure you have a C++ compiler and standard C library development files, preferably GNU C++ and GNU C library development files. Most Linux distributions either come with them or have them in their repositories. For example in Ubuntu 5.10-7.04 the package names are g++ and libc6-dev.

You need to install OOo version 2.0 or above if you do not already have it. Most Linux distributions come with it. For Ubuntu 7.04 the package name is openoffice.org, and it is installed at /usr/lib/openoffice.

Our major reference will be the OOo SDK, so go ahead download it from http://download.openoffice.org/680/sdk.html or install the package named openoffice.org-dev. Extract the SDK to somewhere you have write access to. You can delete the .tar.gz file after the extraction. The index.html file in the SDK directory is the main page of the OOo SDK documentation. Reading the SDK documentation fully or major parts of it would be a very good practice before trying to write code for OOo (For now ignore the "Installation Guide" part). You will use "Developer's Guide", "IDL Reference" and "C++ Reference" parts the most.

Open a terminal, go to the extracted SDK directory with cd command and type (replace /usr/lib/openoffice2 with your full OOo installation directory)

<tt>
echo export OOoSDK='"'`pwd`'"' > OOoSetenv

echo export PATH='"$OOoSDK/linux/bin:$PATH"' >> OOoSetenv

echo export OOo='"/usr/lib/openoffice2/program"' >> OOoSetenv

echo export LD_LIBRARY_PATH='"$OOo:$LD_LIBRARY_PATH"' >> OOoSetenv
</tt>

This will prepare a script named OOoSetenv (for environment parameters). You will need to type "source OOoSetenv" in a terminal every time you want to use the SDK (For each terminal session it is enough to do it once), so go ahead and type it.

Later we will link against libcppuhelpergcc3.so which should be in $OOo directory. In your terminal type "ls $OOo/*cppuhelper*". If you see libcppuhelpergcc3.so file listed, then everything is fine. If not then you should see something like libcppuhelpergcc3.so.3, and you should type "sudo ln -s $OOo/libcppuhelpergcc3.so.3 $OOo/libcppuhelpergcc3.so" in your terminal, enter your password if asked (This requires a user that can do super user tasks with sudo, a sudoer). This just creates a symbolic link named libcppuhelpergcc3.so to the original file libcppuhelpergcc3.so.3 in the same directory. If your Linux distribution does not have sudo command then become super user with su command, type the previous command without sudo at the beginning (you may need to write $OOo explicitly) and return to your user account (by typing exit).

In your terminal type "mkdir myProjects". This will create a directory named "myProjects" in the SDK directory. We will put our projects here. Close the terminal window now.

==Introduction==
A component is an add-on (Merriam-Webster says "add-on : something (as an accessory or added feature) that enhances the thing it is added to") for OOo. They are more specifically called UNO components (See "3 Professional UNO" and "4 Writing UNO Components" in the SDK's "Developer's Guide" part). You can write components for OOo in many programming languages, including C++ and [[JavaEclipseTuto|Java]].

Calc is the spreadsheet application of OOo. We will write a Calc add-in, which is a special UNO component, that provides a Random Number Generator (RNG) service. For example, the "RAND()" function of Calc is a RNG that returns a random number between 0 and 1. So let's do something new and write a RNG that returns exponentially distributed (See http://mathworld.wolfram.com/ExponentialDistribution.html and http://en.wikipedia.org/wiki/Exponential_distribution) random numbers. In this guide we will do things that are the same for general UNO components and/or Calc add-ins written in C++, so we will not be doing anything specific to RNGs, it is just something we can implement for Calc. See http://en.wikipedia.org/wiki/Inverse_transform_sampling_method for more information about sampling arbitrary random variables with closed form inverse cumulative distribution functions.

==Preparation==
Open a terminal window, go to the SDK directory and type "source OOoSetenv" and then "cd myProjects". Keep the terminal window open. Then download the [[Media:MyRNG.tar.gz|MyRNG.tar.gz]] file, extract it into the myProjects directory, and type "cd myRNG" in the terminal. There should be six files in the myRNG directory.

==IDL==
Writing a component for OOo starts with writing its "Interface Specification". Interface Specification is simply defining your component in a way that is independent from whichever implementation language (like C++, Java) you use. For OOo there is a special language called UNOIDL (UNO Interface Definition Language) to write interface specifications (See "4.2 Using UNOIDL to Specify New Components" in the SDK's "Developer's Guide" part). UNOIDL is very simple, and similar to C++. As you may have guessed, RNG.idl file is our interface specification. What is inside it is

<code>[unoidl]
#ifndef _org_openoffice_sheet_addin_RNG_idl_
#define _org_openoffice_sheet_addin_RNG_idl_

#include <com/sun/star/uno/XInterface.idl>

module org { module openoffice { module sheet { module addin {
interface XRNG : com::sun::star::uno::XInterface
{
double expo( [in] double m );
};

service RNG : XRNG;
}; }; }; };
#endif
</code>

First you define an interface. Our interface is XRNG (derived from XInterface which is the base interface for any component) which has the definition for our RNG function (expo) that produces exponentially distributed random numbers. It is a convention that interface names start with X. Then we have a service, RNG, that uses our interface XRNG. Read the 3rd and 4th chapters of the developer's guide for more information about module, interface and service keywords. UNO components are put under org.openoffice module, Calc add-ins are put under org.openoffice.sheet.addin.

==Implementation==
A UNO component must implement XInterface, XTypeProvider, XServiceInfo and XWeak interfaces (See "4.4 Core Interfaces to Implement" of developer's guide). Luckily there are helper template classes for C++ (See "4.6 C++ Component" of developer's guide, and WeakImplHelper* under cppu in "C++ Reference") that take care of XInterface, XTypeProvider, XWeak implementations. In addition to these interfaces that every UNO component should implement, a Calc add-in must implement XAddIn and XServiceName (See "8.6 Spreadsheet Add-Ins" of the developer's guide) interfaces. As you read the SDK documentation more, things will become clearer. The RNG_impl.cxx file is our implementation. In it we have our RNG_impl class' definition with the WeakImplHelper4 helper template

<tt>
:class RNG_impl : public ::cppu::WeakImplHelper4< ::org::openoffice::sheet::addin::XRNG,
::sheet::XAddIn, lang::XServiceName, lang::XServiceInfo > //4-parameter template
</tt>

and implementations of XRNG, XAddIn, XServiceName, XServiceInfo and XLocalizable (just a small detail) classes. In addition to these it has the functions create_RNG_impl (creates a single instance of our RNG service), component_getImplementationEnvironment, component_writeInfo, component_getFactory and the struct s_component_entries (See "4.6 C++ Component" of the developer's guide). After reading the SDK documentation and taking closer looks into RNG_impl.cxx file a few times, everything in RNG_impl.cxx file should be reasonably clear :).

==Other Files==
In order to ease the development there is a build script named "build" in the myRNG directory. What is inside it is

<tt>
rm -rf com org *.rdb *.urd

idlc -C -I$OOoSDK/idl RNG.idl

regmerge RNG.rdb /UCR RNG.urd

cppumaker -BUCR -Torg.openoffice.sheet.addin.XRNG -Tcom.sun.star.sheet.XAddIn -Tcom.sun.star.lang.XServiceName -Tcom.sun.star.lang.XServiceInfo -Tcom.sun.star.lang.XTypeProvider -Tcom.sun.star.uno.XWeak -Tcom.sun.star.uno.XAggregation -Tcom.sun.star.lang.XMultiServiceFactory -Tcom.sun.star.uno.XComponentContext -Tcom.sun.star.lang.XSingleComponentFactory -Tcom.sun.star.lang.XSingleServiceFactory -Tcom.sun.star.registry.XRegistryKey
$OOo/types.rdb RNG.rdb

g++ -O2 -fomit-frame-pointer -c -o RNG_impl.o -DUNX -DGCC -DLINUX -DCPPU_ENV=gcc3 -I. -I$OOoSDK/include RNG_impl.cxx

ld -o libRNG.so -shared -L$OOo --retain-symbols-file symbols.txt RNG_impl.o -lcppuhelpergcc3

rm -rf com org *.urd RNG_impl.o

regcomp -register -r *.rdb -c *.so
</tt>

For details about idlc, regmerge, cppumaker and regcomp tools see "4.2.2 Generating Source Code from UNOIDL Definitions" of the developer's guide and "Development Tools". A component must export only three symbols, the function names which start with "component_", and "--retain-symbols-file symbols.txt" option to the linker ld serves this purpose. In your terminal you can type "man ld" to read about --retain-symbols-file option.

==Building & Testing==
If everything went right typing "./build" in the terminal should produce libRNG.so and RNG.rdb files without any error. If not we have spare ones, _libRNG.so_ and _RNG.rdb_ :). Copy RNG.rdb and libRNG.so into $OOo by typing "sudo cp *.so *.rdb $OOo" in the terminal. Edit the $OOo/unorc file by typing "sudo nano $OOo/unorc" and add "$ORIGIN/RNG.rdb" to the end of lines starting with UNO_TYPES and UNO_SERVICES (See "4.6.10 Building and Testing C++ Components" of the developer's guide). Those two lines should look similar to this 
:UNO_TYPES=$ORIGIN/types.rdb $ORIGIN/RNG.rdb
:UNO_SERVICES=$ORIGIN/services.rdb $ORIGIN/RNG.rdb
Save and exit nano. Now it is time to try our RNG. Open OOo Calc, go to Tools > Macros > Organize Macros > OpenOffice.org Basic menu and click "Edit" in the new window. Then copy-paste the following lines into the Basic code editing window overwriting everything what was there

<code>[oobas]
Sub Main
mgr = getProcessServiceManager()
o = mgr.createInstance("org.openoffice.sheet.addin.RNG")
MsgBox o.expo(10)
End Sub
</code>

Save and run your Basic macro. You should see something like this

[[Image:RNG shot.png]]

==Further==
Dig into the SDK documentation more and study the examples in the SDK, both Java and C++, then you should be ready to write your own UNO component.

A more complete C++ add-in can be found here : [[CompleteAddIn|another Example]]

==See also==
* Using C++ with OOo SDK : [[Using_Cpp_with_the_OOo_SDK | Main Page]]
* [http://perso.wanadoo.fr/moutou/MyUNODoc_HTML/UNOCppAPI14.html Add-in : adding OOoCalc functions] (Chapter 14 from UNO/C++ document)
* [http://www.oooforum.org/forum/viewtopic.phtml?t=29552 Add-In in C++ (OOOForum)]
* [http://sc.openoffice.org/addin_howto.html How to add-in in OpenOffice.org Calc]
* [http://api.openoffice.org/docs/common/ref/com/sun/star/sheet/AddIn.html Service AddIn Documentation]
* [[SDKInstallation | How to install the SDK and compile the C++ examples]]
* [[SDKCppLanguage | The UNO C++ Language]]

==Public Documentation License Notice==
The contents of this Documentation are subject to the Public Documentation License Version 1.0 (the "License"); you may only use this Documentation if you comply with the terms of this License. A copy of the License is available at http://www.openoffice.org/licenses/PDL.html.

Original Author: Serhat Sevki Dincer (C) 2006, jfcgaussATgmail. All rights reserved.

[[Category:Calc]]
[[Category:API]]
[[Category:Add-Ins]]
[[Category:Development]]
[[Category:Cpp]]
[[Category:Uno]]
[[Category:Tutorial]]
[[Category:Extensions]]

Calc/Add-In/Simple Calc Add-In

2007-06-22T17:19:23Z

Exactt: /* Requirements */ some ubuntu updates

This is a step by step guide on how to write a simple component (a Calc add-in) for [[OpenOffice.org]] (OOo) in C++. Even though the instructions are for [[Linux]], this guide should give an idea on how to write components on other operating systems as well.

==Requirements==
Make sure you have a C++ compiler and standard C library development files, preferably GNU C++ and GNU C library development files. Most Linux distributions either come with them or have them in their repositories. For example I have Ubuntu 5.10, and the package names are g++ and libc6-dev.

You need to install OOo version 2.0 or above if you do not already have it. Most Linux distributions come with it. For Ubuntu 7.04 the package name is openoffice.org, and it is installed at /usr/lib/openoffice.

Our major reference will be the OOo SDK, so go ahead download it from http://download.openoffice.org/680/sdk.html or install the package named openoffice.org-dev. Extract the SDK to somewhere you have write access to. You can delete the .tar.gz file after the extraction. The index.html file in the SDK directory is the main page of the OOo SDK documentation. Reading the SDK documentation fully or major parts of it would be a very good practice before trying to write code for OOo (For now ignore the "Installation Guide" part). You will use "Developer's Guide", "IDL Reference" and "C++ Reference" parts the most.

Open a terminal, go to the extracted SDK directory with cd command and type (replace /usr/lib/openoffice2 with your full OOo installation directory)

<tt>
echo export OOoSDK='"'`pwd`'"' > OOoSetenv

echo export PATH='"$OOoSDK/linux/bin:$PATH"' >> OOoSetenv

echo export OOo='"/usr/lib/openoffice2/program"' >> OOoSetenv

echo export LD_LIBRARY_PATH='"$OOo:$LD_LIBRARY_PATH"' >> OOoSetenv
</tt>

This will prepare a script named OOoSetenv (for environment parameters). You will need to type "source OOoSetenv" in a terminal every time you want to use the SDK (For each terminal session it is enough to do it once), so go ahead and type it.

Later we will link against libcppuhelpergcc3.so which should be in $OOo directory. In your terminal type "ls $OOo/*cppuhelper*". If you see libcppuhelpergcc3.so file listed, then everything is fine. If not then you should see something like libcppuhelpergcc3.so.3, and you should type "sudo ln -s $OOo/libcppuhelpergcc3.so.3 $OOo/libcppuhelpergcc3.so" in your terminal, enter your password if asked (This requires a user that can do super user tasks with sudo, a sudoer). This just creates a symbolic link named libcppuhelpergcc3.so to the original file libcppuhelpergcc3.so.3 in the same directory. If your Linux distribution does not have sudo command then become super user with su command, type the previous command without sudo at the beginning (you may need to write $OOo explicitly) and return to your user account (by typing exit).

In your terminal type "mkdir myProjects". This will create a directory named "myProjects" in the SDK directory. We will put our projects here. Close the terminal window now.

==Introduction==
A component is an add-on (Merriam-Webster says "add-on : something (as an accessory or added feature) that enhances the thing it is added to") for OOo. They are more specifically called UNO components (See "3 Professional UNO" and "4 Writing UNO Components" in the SDK's "Developer's Guide" part). You can write components for OOo in many programming languages, including C++ and [[JavaEclipseTuto|Java]].

Calc is the spreadsheet application of OOo. We will write a Calc add-in, which is a special UNO component, that provides a Random Number Generator (RNG) service. For example, the "RAND()" function of Calc is a RNG that returns a random number between 0 and 1. So let's do something new and write a RNG that returns exponentially distributed (See http://mathworld.wolfram.com/ExponentialDistribution.html and http://en.wikipedia.org/wiki/Exponential_distribution) random numbers. In this guide we will do things that are the same for general UNO components and/or Calc add-ins written in C++, so we will not be doing anything specific to RNGs, it is just something we can implement for Calc. See http://en.wikipedia.org/wiki/Inverse_transform_sampling_method for more information about sampling arbitrary random variables with closed form inverse cumulative distribution functions.

==Preparation==
Open a terminal window, go to the SDK directory and type "source OOoSetenv" and then "cd myProjects". Keep the terminal window open. Then download the [[Media:MyRNG.tar.gz|MyRNG.tar.gz]] file, extract it into the myProjects directory, and type "cd myRNG" in the terminal. There should be six files in the myRNG directory.

==IDL==
Writing a component for OOo starts with writing its "Interface Specification". Interface Specification is simply defining your component in a way that is independent from whichever implementation language (like C++, Java) you use. For OOo there is a special language called UNOIDL (UNO Interface Definition Language) to write interface specifications (See "4.2 Using UNOIDL to Specify New Components" in the SDK's "Developer's Guide" part). UNOIDL is very simple, and similar to C++. As you may have guessed, RNG.idl file is our interface specification. What is inside it is

<code>[unoidl]
#ifndef _org_openoffice_sheet_addin_RNG_idl_
#define _org_openoffice_sheet_addin_RNG_idl_

#include <com/sun/star/uno/XInterface.idl>

module org { module openoffice { module sheet { module addin {
interface XRNG : com::sun::star::uno::XInterface
{
double expo( [in] double m );
};

service RNG : XRNG;
}; }; }; };
#endif
</code>

First you define an interface. Our interface is XRNG (derived from XInterface which is the base interface for any component) which has the definition for our RNG function (expo) that produces exponentially distributed random numbers. It is a convention that interface names start with X. Then we have a service, RNG, that uses our interface XRNG. Read the 3rd and 4th chapters of the developer's guide for more information about module, interface and service keywords. UNO components are put under org.openoffice module, Calc add-ins are put under org.openoffice.sheet.addin.

==Implementation==
A UNO component must implement XInterface, XTypeProvider, XServiceInfo and XWeak interfaces (See "4.4 Core Interfaces to Implement" of developer's guide). Luckily there are helper template classes for C++ (See "4.6 C++ Component" of developer's guide, and WeakImplHelper* under cppu in "C++ Reference") that take care of XInterface, XTypeProvider, XWeak implementations. In addition to these interfaces that every UNO component should implement, a Calc add-in must implement XAddIn and XServiceName (See "8.6 Spreadsheet Add-Ins" of the developer's guide) interfaces. As you read the SDK documentation more, things will become clearer. The RNG_impl.cxx file is our implementation. In it we have our RNG_impl class' definition with the WeakImplHelper4 helper template

<tt>
:class RNG_impl : public ::cppu::WeakImplHelper4< ::org::openoffice::sheet::addin::XRNG,
::sheet::XAddIn, lang::XServiceName, lang::XServiceInfo > //4-parameter template
</tt>

and implementations of XRNG, XAddIn, XServiceName, XServiceInfo and XLocalizable (just a small detail) classes. In addition to these it has the functions create_RNG_impl (creates a single instance of our RNG service), component_getImplementationEnvironment, component_writeInfo, component_getFactory and the struct s_component_entries (See "4.6 C++ Component" of the developer's guide). After reading the SDK documentation and taking closer looks into RNG_impl.cxx file a few times, everything in RNG_impl.cxx file should be reasonably clear :).

==Other Files==
In order to ease the development there is a build script named "build" in the myRNG directory. What is inside it is

<tt>
rm -rf com org *.rdb *.urd

idlc -C -I$OOoSDK/idl RNG.idl

regmerge RNG.rdb /UCR RNG.urd

cppumaker -BUCR -Torg.openoffice.sheet.addin.XRNG -Tcom.sun.star.sheet.XAddIn -Tcom.sun.star.lang.XServiceName -Tcom.sun.star.lang.XServiceInfo -Tcom.sun.star.lang.XTypeProvider -Tcom.sun.star.uno.XWeak -Tcom.sun.star.uno.XAggregation -Tcom.sun.star.lang.XMultiServiceFactory -Tcom.sun.star.uno.XComponentContext -Tcom.sun.star.lang.XSingleComponentFactory -Tcom.sun.star.lang.XSingleServiceFactory -Tcom.sun.star.registry.XRegistryKey
$OOo/types.rdb RNG.rdb

g++ -O2 -fomit-frame-pointer -c -o RNG_impl.o -DUNX -DGCC -DLINUX -DCPPU_ENV=gcc3 -I. -I$OOoSDK/include RNG_impl.cxx

ld -o libRNG.so -shared -L$OOo --retain-symbols-file symbols.txt RNG_impl.o -lcppuhelpergcc3

rm -rf com org *.urd RNG_impl.o

regcomp -register -r *.rdb -c *.so
</tt>

For details about idlc, regmerge, cppumaker and regcomp tools see "4.2.2 Generating Source Code from UNOIDL Definitions" of the developer's guide and "Development Tools". A component must export only three symbols, the function names which start with "component_", and "--retain-symbols-file symbols.txt" option to the linker ld serves this purpose. In your terminal you can type "man ld" to read about --retain-symbols-file option.

==Building & Testing==
If everything went right typing "./build" in the terminal should produce libRNG.so and RNG.rdb files without any error. If not we have spare ones, _libRNG.so_ and _RNG.rdb_ :). Copy RNG.rdb and libRNG.so into $OOo by typing "sudo cp *.so *.rdb $OOo" in the terminal. Edit the $OOo/unorc file by typing "sudo nano $OOo/unorc" and add "$ORIGIN/RNG.rdb" to the end of lines starting with UNO_TYPES and UNO_SERVICES (See "4.6.10 Building and Testing C++ Components" of the developer's guide). Those two lines should look similar to this 
:UNO_TYPES=$ORIGIN/types.rdb $ORIGIN/RNG.rdb
:UNO_SERVICES=$ORIGIN/services.rdb $ORIGIN/RNG.rdb
Save and exit nano. Now it is time to try our RNG. Open OOo Calc, go to Tools > Macros > Organize Macros > OpenOffice.org Basic menu and click "Edit" in the new window. Then copy-paste the following lines into the Basic code editing window overwriting everything what was there

<code>[oobas]
Sub Main
mgr = getProcessServiceManager()
o = mgr.createInstance("org.openoffice.sheet.addin.RNG")
MsgBox o.expo(10)
End Sub
</code>

Save and run your Basic macro. You should see something like this

[[Image:RNG shot.png]]

==Further==
Dig into the SDK documentation more and study the examples in the SDK, both Java and C++, then you should be ready to write your own UNO component.

A more complete C++ add-in can be found here : [[CompleteAddIn|another Example]]

==See also==
* Using C++ with OOo SDK : [[Using_Cpp_with_the_OOo_SDK | Main Page]]
* [http://perso.wanadoo.fr/moutou/MyUNODoc_HTML/UNOCppAPI14.html Add-in : adding OOoCalc functions] (Chapter 14 from UNO/C++ document)
* [http://www.oooforum.org/forum/viewtopic.phtml?t=29552 Add-In in C++ (OOOForum)]
* [http://sc.openoffice.org/addin_howto.html How to add-in in OpenOffice.org Calc]
* [http://api.openoffice.org/docs/common/ref/com/sun/star/sheet/AddIn.html Service AddIn Documentation]
* [[SDKInstallation | How to install the SDK and compile the C++ examples]]
* [[SDKCppLanguage | The UNO C++ Language]]

==Public Documentation License Notice==
The contents of this Documentation are subject to the Public Documentation License Version 1.0 (the "License"); you may only use this Documentation if you comply with the terms of this License. A copy of the License is available at http://www.openoffice.org/licenses/PDL.html.

Original Author: Serhat Sevki Dincer (C) 2006, jfcgaussATgmail. All rights reserved.

[[Category:Calc]]
[[Category:API]]
[[Category:Add-Ins]]
[[Category:Development]]
[[Category:Cpp]]
[[Category:Uno]]
[[Category:Tutorial]]
[[Category:Extensions]]

JavaEclipseTuto

2007-06-20T09:23:08Z

Exactt: /* Trouble shooting */ add hint to sdk package

=How to create a Java component with Eclipse=

==Introduction==
This paper is a tutorial to guide UNO newcomers through creating their first Java component. This tutorial will use Eclipse and its plugin for the OpenOffice.org development, and every step will be detailed. If you are an experienced UNO programmer, you can still follow this tutorial to have a better view of how to use the Eclipse plugin.

===UNO Components===
This section will explain some very basic things about UNO components. You can skip it if you already know it. First I will explain what a component is and its main parts. Afterwards, I will explain what is needed to create a UNO component to help you to fully understand the different tools and their use during the tutorial.

====Components anatomy====
''"A component is a system element offering a predefined service and able to communicate with other components"'' explains [http://fr.wikipedia.org/wiki/composant Wikipedia (Fr)] (Even thought there is a definition on the English wikipedia article, I prefer the French one because of its completeness). In UNOs case a component will generally be delivered as a package containing a library (share library in C++ or jar in Java). For UNO, a component is made of two distinct parts: specifications and an implementation.

*'''Specification: '''definition in a common language of what the component should do. For UNO, this language is called UNO-IDL and is more or less similar to [http://en.wikipedia.org/wiki/Corba Corba] IDL. The documented part that will be provided as an API to use the component is the specification. Thus, it should be complete and implementation independent.
*'''Implementation: '''is the code that will realize what is described in the component specifications. This programming language can either be C++, Java, Python or others. This is the internal part of the component and will not be accessible from another component.
In order that UNO knows which implementation corresponds to which specification, the component will use registries. There are two of them: the first one describes all the component specifications (<tt>types.rdb</tt>) and the second translates the implementation into specifications (<tt>services.rdb</tt>) and is generated from the implementation.

====Components creation process====
The following diagram will help you better understand what should be done to get a component from its specification and sources. As shown by the diagram, the specifications are compiled and merged into one <tt>types.rdb</tt> registry. <tt>Class</tt> files are generated from that file to translate the specifications into a Java class definition file which is built with the implementation into a class using the <tt>java</tt> compiler. All the classes are delivered as a <tt>jar</tt> file with a specific manifest as we will see further in this tutorial. This doesn't make a usable OpenOffice.org: the <tt>types.rdb</tt> and <tt>jar</tt> file will have to be zipped into a <tt>.uno.pkg</tt> file described with another manifest.

[[Image:CompilationChain.png|center|UNO component build chain]]

As I will explain later, the Eclipse plugin will hide some of these operations, however you will need to know how they work to fully understand the build process and what we will do in the following steps.

===Installing the development platform===
Now that you know what to do, we will install and configure the development tools. This is quite simple, but you can run into some problems if you do not read the following information carefully. I will now assume that you have none of the development tools. The minimum requirements for OpenOffice.org Eclipse integration are:

*OpenOffice.org 2.0
*OpenOffice.org SDK 2.0.4
*Eclipse 3.2
*Java 1.5 (the GNU Java does not work with the Eclipse integration)

====OpenOffice.org====
First of all, you will need to have a working OpenOffice.org 2.0 and its Software Development Kit (SDK). The latest versions are available on the [http://download.openoffice.org/ OpenOffice.org download pages] for the most current platforms. The OpenOffice.org SDK version 2.0.4 is mandatory to use the plugin correctly. It includes a new tool used by the plugin: the <tt>uno-skeletonmaker</tt>. This tool will generate the implementation skeleton to help you to concentrate only on your code.

'''This tutorial assumes that you used the "Official" OpenOffice.org distribution''' from the project's website. Other distributions may not work with the Eclipse integration (see the trouble shooting section at the end of this page).

====Eclipse and the plugin====
To get Eclipse, just go to their download pages and download the latest Eclipse SDK. You will have Eclipse and its SDK. Of course, you might want to download only the binary runtime, but you will have to follow more links. Once you have Eclipse, unzip it on your computer and that's it: Eclipse has a Java plugin to help you program in Java.

Now we will install the OpenOffice.org development plugin for Eclipse using the Eclipse software update system. '''Do not try to download an archive from somewhere. Eclipse will do it for you when you do the following steps.''' Select the '''Help > Software updates > Find and install''' menu to get the window shown in the following illustration. Check the second option on this window and click on the '''Next''' button.

[[Image:InstallWindow.png|center|"Find & Install" window]]

On the following page, you will see a list of "''update sites''". These are URLs pointing to directories containing plugins informations and archives. Now click on the '''Add remote site''' button to get a small window asking for a name that will be displayed in the list and an URL. The URL of OpenOffice.org plugin update site is http://cedric.bosdonnat.free.fr/ooeclipseintegration.

'''Do not try to download an archive from this URL. This is the plugin update site for Eclipse.'''

Validate the new update site parameters and be sure that the OpenOffice.org site is checked before clicking on the '''Finish''' button. You should now see a window like the one in the following illustration. '''Select the OpenOffice.org plugin Core and Java plugins''', click Next and let the wizard guide you through the end of the process. You will be asked to accept the plugin license and validate the installation archives which are not signed.

[[Image:PluginUpdates.png|center|OpenOffice.org update site contents]]

Congratulations, you have installed the OpenOffice.org plugin successfully. Now you must configure it. The following steps will guide you through this task. Go to the Eclipse options via the '''Window > Preferences...''' menu. In the list on the left, select the '''OpenOffice.org plugin > SDK Configuration''' item to get a window like the one shown in the following illustration.

[[Image:UnoProperties.png|center|SDK configuration window]]

In this window you will have to configure the path to your OpenOffice.org and to its SDK. So, let us begin with the SDK path: click on the '''Add''' button next to the SDKs list. You will have a window like the one shown in following illustration. Browse to your OpenOffice.org 2.0 SDK and validate. Then you will have to do the same for the OpenOffice.org path using the other '''Add''' button.

Note that a URE installation can be selected instead of a complete OpenOffice.org installation. Please refer to the Java URE application tutorial for more details on the plugin's URE support.

'''If you are using Windows, please make sure that the path to the SDK does not contains any spaces. Spaces in the path can cause problems when you build your UNO projects.'''

[[Image:SdkConfig.png|center|New SDK path window]]

Now your OpenOffice.org plugin is ready to work. You can begin to create your new component. If there was any problem during the plugin installation, please report it to the dev@api.openoffice.org [http://api.openoffice.org/servlets/ProjectMailingListList mailing-list].

==Creating a new component==
For the Eclipse plugin, a UNO component is a UNO project. This tutorial will explain how to easily create a new UNO component using the Eclipse plugin. We will now assume that you have very simple needs. The component that will be created is a "Hello world" service and its implementation. Creating a component that defines and implements more services is a bit more complex and requires advanced Java UNO knowledge.

There are several ways to create a UNO component project using the plugin:

*The first one is the '''File > New > Project''' menu entry and choose the '''UNO > UNO-IDL Project''' item as shown by the following illustration.

[[Image:NewUnoProjectsItems.png|center|New UNO-IDL project item]]

*The second one is the icon in the toolbar representing a blue folder with a star as shown by the following illustration.

[[Image:NewUnoProjectIcon.png|center|New UNO-IDL project icon]]

Then you only have to follow the wizard to create your UNO component project, its specification and a skeleton of the implementation. This wizard is composed of several pages:

*The main configuration page to define the general project properties.
*The implementation language configuration page.
*The service configuration page.
*The interface configuration page.
After all these steps you will have a running component... doing nothing. The following sections will describe the different wizard pages and where to place your code.

===The project configuration page===
The first page in the project wizard is the only page containing fields that must be filled in. All the others have default values to help you through the component creation. In our case, we will cover all the pages in the wizard to explain them all and define some new methods and attributes in our component.

[[Image:NewUnoProject.jpg|center|New UNO-IDL project wizard page]]

*'''Project name:''' is the component name, in our case, it will be "''Helloworld''"
*'''Location:''' is the directory on your computer where the project will be created. You can change the default one by deselecting the '''Use default''' check box. The default location of each Eclipse project is a directory with your project name in the current Eclipse workspace. '''Please do not use spaces in this path on Windows. Spaces in the path can prevent your component from being built.'''
*'''Root package:''' is the name of the first module of your component. It is generally composed of two parts: the vendor name (here <tt>org.openoffice</tt>) and the project name (here <tt>helloworld</tt>).
*'''Used SDK:''' selects the OpenOffice.org SDK which will be used to develop the component. You generally will have only one SDK in the list, but you can add others in the preferences or by clicking on the '''Configure SDKs''' button.
*'''Used OOo:''' selects the version of OpenOffice.org to use to develop the component. Just as with the SDK, you will generally have only one entry in the list, but you can add others in the preferences or by clicking on the OOo Installations button.
*'''Programming language:''' selects the programming language for the component implementation. For the moment, there is only Java available, however C++ and python are planned.

===The implementation language configuration page===
This page depends on the chosen language. For Java, the default values should be kept: they define which class is the main class of the component. The component's main class contains some code mapping the services to their implementation.

===The service configuration page===

[[Image:Eclipse_Service_Page.png|center|Service configuration page]]

*'''Module:''' corresponds to the UNO-IDL module where to add the interface. If the text field is left empty, the interface will be added in the root module of the component (filled in the project wizard).
*'''Service name:''' is the service name. By keeping the default value, you will be able to define your own interface using the interface configuration page. Otherwise, you can reuse an existing interface.
*'''Published''': specifies if the interface is published or not. The published notion is translated into a keyword in UNO-IDL language. Declaring a UNO-IDL type as published means that it will not change in future releases. We will keep it unchecked because our component is really far from being a stable API.

===The interface configuration page===

[[Image:NewInterfacePage.png|center|Interface configuration page]]

*'''Module:''' corresponds to the UNO-IDL module where the interface is added. If the text field is left empty, the interface will be added in the root module of the component (filled in the project wizard).
*'''Interface name:''' is the interface name. By convention, we generally name an interface beginning with an "X". In this tutorial, the interface will be named <tt>XHelloworld</tt>.
*'''Inherited interfaces:''' is a list of all the interfaces from which the one that is about to be created will inherit. This is one of the changes in UNO-IDL between OpenOffice.org 1.1.x and 2.0, and why the plugin does not support OpenOffice.org versions prior to 2.0. All the UNO-IDL interfaces are inheriting more or less directly from the <tt>com::sun::star::uno::XInterface</tt> type. As the <tt>XHelloworld</tt> interface is very easy, no super interface will be added. This will implicitly define <tt>XInterface</tt> as the only parent for the new interface.
**'''"?" column:''' specifies if the interface inheritance is mandatory or not. If the box is checked, the interface inheritance is optional and may not be implemented.
**'''"Add" and "Del" buttons:''' allows you to add an interface to the inherited ones or remove the selected interface.
*'''Members:''' is a list of all the methods and properties of the interface. See below for explanations about the members. In this tutorial, just create one <tt>string sayHello([in] boolean isBadBoy)</tt> method and a <tt>LadyName</tt> property.
*'''Published:''' specifies if the interface is published or not. The published notion is translated into a keyword in UNO-IDL language. Declaring a UNO-IDL type as published means that it will not change in future releases. We will keep it unchecked because our component is really far from being a stable API.
A UNO interface can contain two kind of members: methods and properties. When clicking on the '''Add''' button near the members' list, the following window will be shown. When double-clicking on a line in the members' list, you will edit the corresponding member through the same window.

When the window is opened to create a new member, you can choose whether the member will be a property or a method. The name and returned type fields are always present, but the lower part of the dialog is different for a method and a property.

[[Image:Eclipse_Interface_Members_Dialog.png|center|Interface member creation dialog]]

*'''The arguments list:''' defines the name, type and direction of the parameters of the method. Simply click on the cell to edit it.
*'''Read-only and Bound check boxes:''' selecting these boxes sets the corresponding IDL flag on the property.

'''Tip:''' you can use ''<tt>''Ctrl+Space''</tt>'' to complete the type name in the '''Return type''' field and '''Type''' column.

===Writing the implementation===
After having completed the wizard, you need to write the component implementation. Hopefully a skeleton has been generated and opened. You need to complete the code where there are some TODOS. The generated project contains the following directories and files:

*'''source:''' directory containing your Java implementation classes.
*'''build:''' directory containing all the generated temporary files, such as the results of the specification files (<tt>.idl</tt> files) compilation (<tt>.urd</tt> files) or the class files corresponding to the specifications (<tt>.class</tt> files).
*'''idl:''' directory containing the specifications of the component.
*'''types.rdb:''' generated UNO types registry from which the classes files will be generated.
*'''JRE and the jars:''' describe the classpath of the component. They are visible only in the Java package explorer. The OpenOffice.org jars are changed if the OpenOffice.org version associated to the project is changed. ''In a future version, they will be packed in a user library to take less space in the tree.''
The generated skeleton already contains the methods for the implementation registration. The only things to modify are:

*Change the code of the setters and getters for the defined properties.
*Change the code of the defined methods.
The Eclipse integration even manages the libraries needed by your implementation. Let us imagine that we want to use the <tt>Fraction</tt> class from the Apache <tt>common-math</tt> jar. Download this jar from the Apache website, and import the <tt>common-math-1.1.jar</tt> file into your component project, for example in a <tt>lib</tt> directory. Add the jar to the project build path in the same way than in any other Eclipse Java project and use it:

<code>[java]
// org.openoffice.helloworld.XHelloworld:
private String mLadyName = "";

public String getLadyName()
{
return mLadyName;
}

public void setLadyName(String the_value)
{
mLadyName = the_value;
}

public String sayHello(boolean isBadBoy)
{
String hello = "Hello Mrs. " + getLadyName();
if (isBadBoy) {
Fraction f = new Fraction(1, 3);
hello = "A third is " + f.doubleValue();
}
return hello;
}
</code>
The above code shows you what could be an implementation of our component. Now, there is only to package it properly and test it.

==Packaging and testing the component==
Now we will show you how to export your component into an OpenOffice.org package. There is little to do apart from following these steps:

*Select the '''File > Export''' menu. Then choose the '''UNO > OpenOffice.org''' package export type.
*The next page of the wizard asks for the UNO project to export (already selected), the directory where to export the package and the OpenOffice.org minimum compatibility version for the package. Depending of the selected OpenOffice.org version, the package will get a different name and a different structure.
*Click on the Finish button. The wizard will ask you whether to deploy to package or not and asks for the old package removal if needed.
Then we will suppose that the package is deployed on the OpenOffice.org installation and we will test it using the following <tt>OooBasic</tt> macro.

<code>[oobas]
Sub testHelloworld
oHelloworld = createUnoService( "org.openoffice.helloworld.Helloworld" )
oHelloworld.LadyName = "Robinson"
print oHelloworld.sayHello( false )
print oHelloworld.sayHello( True )
End Sub
</code>

This macro should open two message windows with ''"Hello Mrs. Robinson"'' and ''"A third is 0.3333333"''. Your first UNO component is now running, enjoy doing others.

==Going further==
This chapter is only for those who enjoyed this tutorial and want to know more about the UNO component creation in Java or other languages. The following is a list of useful links for any UNO developer:

*[http://api.openoffice.org/docs/DevelopersGuide/DevelopersGuide.xhtml OpenOffice.org developer's guide] is a huge source of documentation for any OpenOffice.org developer. You should probably have a look at chapters 3 and 4 for UNO component information.
*[http://api.openoffice.org/docs/java/ref/overview-summary.html OOo Java reference] is the UNO binding for Java reference.
*[http://api.openoffice.org/docs/cpp/ref/names/index.html OOo C++ reference] is the UNO binding for C++ reference.
*[http://wiki.services.openoffice.org/ OOo Developer's Wiki] is the wiki for all the OpenOffice.org developers. It contains useful information even for people who are just starting out with UNO.
*[http://udk.openoffice.org/common/man/draft/multinherit.html http://udk.openoffice.org/common/man/draft/multinherit.html] for further information on what changes have been made in UNO-IDL between OpenOffice.org 1.1.x and 2.0
*[http://tools.openoffice.org/autodoc/HowToWriteDocumentation-Cpp.html Autodoc Java reference] is the reference for <tt>javadoc</tt> like comments in UNO-IDL files.
*[http://tools.openoffice.org/autodoc/HowToWriteDocumentation-Cpp.html Autodoc C++ documentation] is the reference for <tt>javadoc</tt> like comments in C++ components.
*[http://cedric.bosdonnat.free.fr/wordpress/?p=19 URE C++ application tutorial] explains how to create a C++ application based on the URE, that is a UNO C++ component that does not need OpenOffice.org.

==Trouble shooting==
* If you run into trouble it might be helpful to turn the log level to debug mode. This can be done inside Eclipse via Window > Preferences > OpenOffice.org Integration. The log file can be found in ''$YOURWORKSPACEPATH/.metadata/.log'' .
* If you plan to use the OpenOffice version that comes with your distribution try using the according SDK (in Ubuntu it is the package openoffice.org-dev). If there is no such package and you run into trouble not getting the skeletons and opening of an external editor you probably have to create a symbolic link to ''/usr/lib/libstlport_gcc.so'' from the official version of libstlport_gcc.so extracted from an official download of OOo.
* On Unix running ''setsdkenv_unix'' in your SDK directory might helpful as well.

[[Category:Eclipse]]
[[Category:Development]]
[[Category:Tutorial]]
[[Category:Java]]
[[Category:Uno]]

JavaEclipseTuto

2007-03-28T11:12:47Z

Exactt: /* How to create a Java component with Eclipse */

=How to create a Java component with Eclipse=

==Introduction==
This paper is a tutorial to guide UNO newcomers through creating their first Java component. This tutorial will use Eclipse and its plugin for the OpenOffice.org development, and every step will be detailed. If you are an experienced UNO programmer, you can still follow this tutorial to have a better view of how to use the Eclipse plugin.

===UNO Components===
This section will explain some very basic things about UNO components. You can skip it if you already know it. First I will explain what a component is and its main parts. Afterwards, I will explain what is needed to create a UNO component to help you to fully understand the different tools and their use during the tutorial.

====Components anatomy====
''"A component is a system element offering a predefined service and able to communicate with other components"'' explains [http://fr.wikipedia.org/wiki/composant Wikipedia (Fr)] (Even thought there is a definition on the English wikipedia article, I prefer the French one because of its completeness). In UNOs case a component will generally be delivered as a package containing a library (share library in C++ or jar in Java). For UNO, a component is made of two distinct parts: specifications and an implementation.

*'''Specification: '''definition in a common language of what the component should do. For UNO, this language is called UNO-IDL and is more or less similar to [http://en.wikipedia.org/wiki/Corba Corba] IDL. The documented part that will be provided as an API to use the component is the specification. Thus, it should be complete and implementation independent.
*'''Implementation: '''is the code that will realize what is described in the component specifications. This programming language can either be C++, Java, Python or others. This is the internal part of the component and will not be accessible from another component.
In order that UNO knows which implementation corresponds to which specification, the component will use registries. There are two of them: the first one describes all the component specifications (<tt>types.rdb</tt>) and the second translates the implementation into specifications (<tt>services.rdb</tt>) and is generated from the implementation.

====Components creation process====
The following diagram will help you better understand what should be done to get a component from its specification and sources. As shown by the diagram, the specifications are compiled and merged into one <tt>types.rdb</tt> registry. <tt>Class</tt> files are generated from that file to translate the specifications into a Java class definition file which is built with the implementation into a class using the <tt>java</tt> compiler. All the classes are delivered as a <tt>jar</tt> file with a specific manifest as we will see further in this tutorial. This doesn't make a usable OpenOffice.org: the <tt>types.rdb</tt> and <tt>jar</tt> file will have to be zipped into a <tt>.uno.pkg</tt> file described with another manifest.

[[Image:CompilationChain.png|center|UNO component build chain]]

As I will explain later, the Eclipse plugin will hide some of these operations, however you will need to know how they work to fully understand the build process and what we will do in the following steps.

===Installing the development platform===
Now that you know what to do, we will install and configure the development tools. This is quite simple, but you can run into some problems if you do not read the following information carefully. I will now assume that you have none of the development tools. The minimum requirements for OpenOffice.org Eclipse integration are:

*OpenOffice.org 2.0
*OpenOffice.org SDK 2.0.4
*Eclipse 3.2
*Java 1.5 (the GNU Java does not work with the Eclipse integration)

====OpenOffice.org====
First of all, you will need to have a working OpenOffice.org 2.0 and its Software Development Kit (SDK). The latest versions are available on the [http://download.openoffice.org/ OpenOffice.org download pages] for the most current platforms. The OpenOffice.org SDK version 2.0.4 is mandatory to use the plugin correctly. It includes a new tool used by the plugin: the <tt>uno-skeletonmaker</tt>. This tool will generate the implementation skeleton to help you to concentrate only on your code.

'''This tutorial assumes that you used the "Official" OpenOffice.org distribution''' from the project's website. Other distributions may not work with the Eclipse integration (see the trouble shooting section at the end of this page).

====Eclipse and the plugin====
To get Eclipse, just go to their download pages and download the latest Eclipse SDK. You will have Eclipse and its SDK. Of course, you might want to download only the binary runtime, but you will have to follow more links. Once you have Eclipse, unzip it on your computer and that's it: Eclipse has a Java plugin to help you program in Java.

Now we will install the OpenOffice.org development plugin for Eclipse using the Eclipse software update system. '''Do not try to download an archive from somewhere. Eclipse will do it for you when you do the following steps.''' Select the '''Help > Software updates > Find and install''' menu to get the window shown in the following illustration. Check the second option on this window and click on the '''Next''' button.

[[Image:InstallWindow.png|center|"Find & Install" window]]

On the following page, you will see a list of "''update sites''". These are URLs pointing to directories containing plugins informations and archives. Now click on the '''Add remote site''' button to get a small window asking for a name that will be displayed in the list and an URL. The URL of OpenOffice.org plugin update site is http://cedric.bosdonnat.free.fr/ooeclipseintegration.

'''Do not try to download an archive from this URL. This is the plugin update site for Eclipse.'''

Validate the new update site parameters and be sure that the OpenOffice.org site is checked before clicking on the '''Finish''' button. You should now see a window like the one in the following illustration. '''Select the OpenOffice.org plugin Core and Java plugins''', click Next and let the wizard guide you through the end of the process. You will be asked to accept the plugin license and validate the installation archives which are not signed.

[[Image:PluginUpdates.png|center|OpenOffice.org update site contents]]

Congratulations, you have installed the OpenOffice.org plugin successfully. Now you must configure it. The following steps will guide you through this task. Go to the Eclipse options via the '''Window > Preferences...''' menu. In the list on the left, select the '''OpenOffice.org plugin > SDK Configuration''' item to get a window like the one shown in the following illustration.

[[Image:UnoProperties.png|center|SDK configuration window]]

In this window you will have to configure the path to your OpenOffice.org and to its SDK. So, let us begin with the SDK path: click on the '''Add''' button next to the SDKs list. You will have a window like the one shown in following illustration. Browse to your OpenOffice.org 2.0 SDK and validate. Then you will have to do the same for the OpenOffice.org path using the other '''Add''' button.

Note that a URE installation can be selected instead of a complete OpenOffice.org installation. Please refer to the Java URE application tutorial for more details on the plugin's URE support.

'''If you are using Windows, please make sure that the path to the SDK does not contains any spaces. Spaces in the path can cause problems when you build your UNO projects.'''

[[Image:SdkConfig.png|center|New SDK path window]]

Now your OpenOffice.org plugin is ready to work. You can begin to create your new component. If there was any problem during the plugin installation, please report it to the dev@api.openoffice.org [http://api.openoffice.org/servlets/ProjectMailingListList mailing-list].

==Creating a new component==
For the Eclipse plugin, a UNO component is a UNO project. This tutorial will explain how to easily create a new UNO component using the Eclipse plugin. We will now assume that you have very simple needs. The component that will be created is a "Hello world" service and its implementation. Creating a component that defines and implements more services is a bit more complex and requires advanced Java UNO knowledge.

There are several ways to create a UNO component project using the plugin:

*The first one is the '''File > New > Project''' menu entry and choose the '''UNO > UNO-IDL Project''' item as shown by the following illustration.

[[Image:NewUnoProjectsItems.png|center|New UNO-IDL project item]]

*The second one is the icon in the toolbar representing a blue folder with a star as shown by the following illustration.

[[Image:NewUnoProjectIcon.png|center|New UNO-IDL project icon]]

Then you only have to follow the wizard to create your UNO component project, its specification and a skeleton of the implementation. This wizard is composed of several pages:

*The main configuration page to define the general project properties.
*The implementation language configuration page.
*The service configuration page.
*The interface configuration page.
After all these steps you will have a running component... doing nothing. The following sections will describe the different wizard pages and where to place your code.

===The project configuration page===
The first page in the project wizard is the only page containing fields that must be filled in. All the others have default values to help you through the component creation. In our case, we will cover all the pages in the wizard to explain them all and define some new methods and attributes in our component.

[[Image:NewUnoProject.jpg|center|New UNO-IDL project wizard page]]

*'''Project name:''' is the component name, in our case, it will be "''Helloworld''"
*'''Location:''' is the directory on your computer where the project will be created. You can change the default one by deselecting the '''Use default''' check box. The default location of each Eclipse project is a directory with your project name in the current Eclipse workspace. '''Please do not use spaces in this path on Windows. Spaces in the path can prevent your component from being built.'''
*'''Root package:''' is the name of the first module of your component. It is generally composed of two parts: the vendor name (here <tt>org.openoffice</tt>) and the project name (here <tt>helloworld</tt>).
*'''Used SDK:''' selects the OpenOffice.org SDK which will be used to develop the component. You generally will have only one SDK in the list, but you can add others in the preferences or by clicking on the '''Configure SDKs''' button.
*'''Used OOo:''' selects the version of OpenOffice.org to use to develop the component. Just as with the SDK, you will generally have only one entry in the list, but you can add others in the preferences or by clicking on the OOo Installations button.
*'''Programming language:''' selects the programming language for the component implementation. For the moment, there is only Java available, however C++ and python are planned.

===The implementation language configuration page===
This page depends on the chosen language. For Java, the default values should be kept: they define which class is the main class of the component. The component's main class contains some code mapping the services to their implementation.

===The service configuration page===

[[Image:Eclipse_Service_Page.png|center|Service configuration page]]

*'''Module:''' corresponds to the UNO-IDL module where to add the interface. If the text field is left empty, the interface will be added in the root module of the component (filled in the project wizard).
*'''Service name:''' is the service name. By keeping the default value, you will be able to define your own interface using the interface configuration page. Otherwise, you can reuse an existing interface.
*'''Published''': specifies if the interface is published or not. The published notion is translated into a keyword in UNO-IDL language. Declaring a UNO-IDL type as published means that it will not change in future releases. We will keep it unchecked because our component is really far from being a stable API.

===The interface configuration page===

[[Image:NewInterfacePage.png|center|Interface configuration page]]

*'''Module:''' corresponds to the UNO-IDL module where the interface is added. If the text field is left empty, the interface will be added in the root module of the component (filled in the project wizard).
*'''Interface name:''' is the interface name. By convention, we generally name an interface beginning with an "X". In this tutorial, the interface will be named <tt>XHelloworld</tt>.
*'''Inherited interfaces:''' is a list of all the interfaces from which the one that is about to be created will inherit. This is one of the changes in UNO-IDL between OpenOffice.org 1.1.x and 2.0, and why the plugin does not support OpenOffice.org versions prior to 2.0. All the UNO-IDL interfaces are inheriting more or less directly from the <tt>com::sun::star::uno::XInterface</tt> type. As the <tt>XHelloworld</tt> interface is very easy, no super interface will be added. This will implicitly define <tt>XInterface</tt> as the only parent for the new interface.
**'''"?" column:''' specifies if the interface inheritance is mandatory or not. If the box is checked, the interface inheritance is optional and may not be implemented.
**'''"Add" and "Del" buttons:''' allows you to add an interface to the inherited ones or remove the selected interface.
*'''Members:''' is a list of all the methods and properties of the interface. See below for explanations about the members. In this tutorial, just create one <tt>string sayHello([in] boolean isBadBoy)</tt> method and a <tt>LadyName</tt> property.
*'''Published:''' specifies if the interface is published or not. The published notion is translated into a keyword in UNO-IDL language. Declaring a UNO-IDL type as published means that it will not change in future releases. We will keep it unchecked because our component is really far from being a stable API.
A UNO interface can contain two kind of members: methods and properties. When clicking on the '''Add''' button near the members' list, the following window will be shown. When double-clicking on a line in the members' list, you will edit the corresponding member through the same window.

When the window is opened to create a new member, you can choose whether the member will be a property or a method. The name and returned type fields are always present, but the lower part of the dialog is different for a method and a property.

[[Image:Eclipse_Interface_Members_Dialog.png|center|Interface member creation dialog]]

*'''The arguments list:''' defines the name, type and direction of the parameters of the method. Simply click on the cell to edit it.
*'''Read-only and Bound check boxes:''' selecting these boxes sets the corresponding IDL flag on the property.

'''Tip:''' you can use ''<tt>''Ctrl+Space''</tt>'' to complete the type name in the '''Return type''' field and '''Type''' column.

===Writing the implementation===
After having completed the wizard, you need to write the component implementation. Hopefully a skeleton has been generated and opened. You need to complete the code where there are some TODOS. The generated project contains the following directories and files:

*'''source:''' directory containing your Java implementation classes.
*'''build:''' directory containing all the generated temporary files, such as the results of the specification files (<tt>.idl</tt> files) compilation (<tt>.urd</tt> files) or the class files corresponding to the specifications (<tt>.class</tt> files).
*'''idl:''' directory containing the specifications of the component.
*'''types.rdb:''' generated UNO types registry from which the classes files will be generated.
*'''JRE and the jars:''' describe the classpath of the component. They are visible only in the Java package explorer. The OpenOffice.org jars are changed if the OpenOffice.org version associated to the project is changed. ''In a future version, they will be packed in a user library to take less space in the tree.''
The generated skeleton already contains the methods for the implementation registration. The only things to modify are:

*Change the code of the setters and getters for the defined properties.
*Change the code of the defined methods.
The Eclipse integration even manages the libraries needed by your implementation. Let us imagine that we want to use the <tt>Fraction</tt> class from the Apache <tt>common-math</tt> jar. Download this jar from the Apache website, and import the <tt>common-math-1.1.jar</tt> file into your component project, for example in a <tt>lib</tt> directory. Add the jar to the project build path in the same way than in any other Eclipse Java project and use it:

<code>[java]
// org.openoffice.helloworld.XHelloworld:
private String mLadyName = "";

public String getLadyName()
{
return mLadyName;
}

public void setLadyName(String the_value)
{
mLadyName = the_value;
}

public String sayHello(boolean isBadBoy)
{
String hello = "Hello Mrs. " + getLadyName();
if (isBadBoy) {
Fraction f = new Fraction(1, 3);
hello = "A third is " + f.doubleValue();
}
return hello;
}
</code>
The above code shows you what could be an implementation of our component. Now, there is only to package it properly and test it.

==Packaging and testing the component==
Now we will show you how to export your component into an OpenOffice.org package. There is little to do apart from following these steps:

*Select the '''File > Export''' menu. Then choose the '''UNO > OpenOffice.org''' package export type.
*The next page of the wizard asks for the UNO project to export (already selected), the directory where to export the package and the OpenOffice.org minimum compatibility version for the package. Depending of the selected OpenOffice.org version, the package will get a different name and a different structure.
*Click on the Finish button. The wizard will ask you whether to deploy to package or not and asks for the old package removal if needed.
Then we will suppose that the package is deployed on the OpenOffice.org installation and we will test it using the following <tt>OooBasic</tt> macro.

<code>[oobas]
Sub testHelloworld
oHelloworld = createUnoService( "org.openoffice.helloworld.Helloworld" )
oHelloworld.LadyName = "Robinson"
print oHelloworld.sayHello( false )
print oHelloworld.sayHello( True )
End Sub
</code>

This macro should open two message windows with ''"Hello Mrs. Robinson"'' and ''"A third is 0.3333333"''. Your first UNO component is now running, enjoy doing others.

==Going further==
This chapter is only for those who enjoyed this tutorial and want to know more about the UNO component creation in Java or other languages. The following is a list of useful links for any UNO developer:

*[http://api.openoffice.org/docs/DevelopersGuide/DevelopersGuide.xhtml OpenOffice.org developer's guide] is a huge source of documentation for any OpenOffice.org developer. You should probably have a look at chapters 3 and 4 for UNO component information.
*[http://api.openoffice.org/docs/java/ref/overview-summary.html OOo Java reference] is the UNO binding for Java reference.
*[http://api.openoffice.org/docs/cpp/ref/names/index.html OOo C++ reference] is the UNO binding for C++ reference.
*[http://wiki.services.openoffice.org/ OOo Developer's Wiki] is the wiki for all the OpenOffice.org developers. It contains useful information even for people who are just starting out with UNO.
*[http://udk.openoffice.org/common/man/draft/multinherit.html http://udk.openoffice.org/common/man/draft/multinherit.html] for further information on what changes have been made in UNO-IDL between OpenOffice.org 1.1.x and 2.0
*[http://tools.openoffice.org/autodoc/HowToWriteDocumentation-Cpp.html Autodoc Java reference] is the reference for <tt>javadoc</tt> like comments in UNO-IDL files.
*[http://tools.openoffice.org/autodoc/HowToWriteDocumentation-Cpp.html Autodoc C++ documentation] is the reference for <tt>javadoc</tt> like comments in C++ components.
*[http://cedric.bosdonnat.free.fr/wordpress/?p=19 URE C++ application tutorial] explains how to create a C++ application based on the URE, that is a UNO C++ component that does not need OpenOffice.org.

==Trouble shooting==
* If you run into trouble it might be helpful to turn the log level to debug mode. This can be done inside Eclipse via Window > Preferences > OpenOffice.org Integration. The log file can be found in ''$YOURWORKSPACEPATH/.metadata/.log'' .
* If you plan to use the OpenOffice version that comes with your distribution and run into trouble not getting the skeletons and opening of an external editor you probably have to create a symbolic link to ''/usr/lib/libstlport_gcc.so'' from the official version of libstlport_gcc.so extracted from an official download of OOo. (This works at least for Ubuntu Edgy and Feisty)
* The 64-Bit version of OOo that's comes e.g. with Ubuntu AMD64 gives similar errors as the above. As there is no official 64-bit download the above workaround seems not to work. If you get it running please add your solution here.
* On Unix running ''setsdkenv_unix'' in your SDK directory might helpful as well.

[[Category:Eclipse]]
[[Category:Development]]
[[Category:Tutorial]]
[[Category:Java]]
[[Category:Uno]]

JavaEclipseTuto

2007-03-28T10:44:45Z

Exactt: /* OpenOffice.org */

=How to create a Java component with Eclipse=

==Introduction==
This paper is a tutorial to guide UNO newcomers through creating their first Java component. This tutorial will use Eclipse and its plugin for the OpenOffice.org development, and every step will be detailed. If you are an experienced UNO programmer, you can still follow this tutorial to have a better view of how to use the Eclipse plugin.

===UNO Components===
This section will explain some very basic things about UNO components. You can skip it if you already know it. First I will explain what a component is and its main parts. Afterwards, I will explain what is needed to create a UNO component to help you to fully understand the different tools and their use during the tutorial.

====Components anatomy====
''"A component is a system element offering a predefined service and able to communicate with other components"'' explains [http://fr.wikipedia.org/wiki/composant Wikipedia (Fr)] (Even thought there is a definition on the English wikipedia article, I prefer the French one because of its completeness). In UNOs case a component will generally be delivered as a package containing a library (share library in C++ or jar in Java). For UNO, a component is made of two distinct parts: specifications and an implementation.

*'''Specification: '''definition in a common language of what the component should do. For UNO, this language is called UNO-IDL and is more or less similar to [http://en.wikipedia.org/wiki/Corba Corba] IDL. The documented part that will be provided as an API to use the component is the specification. Thus, it should be complete and implementation independent.
*'''Implementation: '''is the code that will realize what is described in the component specifications. This programming language can either be C++, Java, Python or others. This is the internal part of the component and will not be accessible from another component.
In order that UNO knows which implementation corresponds to which specification, the component will use registries. There are two of them: the first one describes all the component specifications (<tt>types.rdb</tt>) and the second translates the implementation into specifications (<tt>services.rdb</tt>) and is generated from the implementation.

====Components creation process====
The following diagram will help you better understand what should be done to get a component from its specification and sources. As shown by the diagram, the specifications are compiled and merged into one <tt>types.rdb</tt> registry. <tt>Class</tt> files are generated from that file to translate the specifications into a Java class definition file which is built with the implementation into a class using the <tt>java</tt> compiler. All the classes are delivered as a <tt>jar</tt> file with a specific manifest as we will see further in this tutorial. This doesn't make a usable OpenOffice.org: the <tt>types.rdb</tt> and <tt>jar</tt> file will have to be zipped into a <tt>.uno.pkg</tt> file described with another manifest.

[[Image:CompilationChain.png|center|UNO component build chain]]

As I will explain later, the Eclipse plugin will hide some of these operations, however you will need to know how they work to fully understand the build process and what we will do in the following steps.

===Installing the development platform===
Now that you know what to do, we will install and configure the development tools. This is quite simple, but you can run into some problems if you do not read the following information carefully. I will now assume that you have none of the development tools. The minimum requirements for OpenOffice.org Eclipse integration are:

*OpenOffice.org 2.0
*OpenOffice.org SDK 2.0.4
*Eclipse 3.2
*Java 1.5 (the GNU Java does not work with the Eclipse integration)

====OpenOffice.org====
First of all, you will need to have a working OpenOffice.org 2.0 and its Software Development Kit (SDK). The latest versions are available on the [http://download.openoffice.org/ OpenOffice.org download pages] for the most current platforms. The OpenOffice.org SDK version 2.0.4 is mandatory to use the plugin correctly. It includes a new tool used by the plugin: the <tt>uno-skeletonmaker</tt>. This tool will generate the implementation skeleton to help you to concentrate only on your code.

'''This tutorial assumes that you used the "Official" OpenOffice.org distribution''' from the project's website. Other distributions may not work with the Eclipse integration.

====Eclipse and the plugin====
To get Eclipse, just go to their download pages and download the latest Eclipse SDK. You will have Eclipse and its SDK. Of course, you might want to download only the binary runtime, but you will have to follow more links. Once you have Eclipse, unzip it on your computer and that's it: Eclipse has a Java plugin to help you program in Java.

Now we will install the OpenOffice.org development plugin for Eclipse using the Eclipse software update system. '''Do not try to download an archive from somewhere. Eclipse will do it for you when you do the following steps.''' Select the '''Help > Software updates > Find and install''' menu to get the window shown in the following illustration. Check the second option on this window and click on the '''Next''' button.

[[Image:InstallWindow.png|center|"Find & Install" window]]

On the following page, you will see a list of "''update sites''". These are URLs pointing to directories containing plugins informations and archives. Now click on the '''Add remote site''' button to get a small window asking for a name that will be displayed in the list and an URL. The URL of OpenOffice.org plugin update site is http://cedric.bosdonnat.free.fr/ooeclipseintegration.

'''Do not try to download an archive from this URL. This is the plugin update site for Eclipse.'''

Validate the new update site parameters and be sure that the OpenOffice.org site is checked before clicking on the '''Finish''' button. You should now see a window like the one in the following illustration. '''Select the OpenOffice.org plugin Core and Java plugins''', click Next and let the wizard guide you through the end of the process. You will be asked to accept the plugin license and validate the installation archives which are not signed.

[[Image:PluginUpdates.png|center|OpenOffice.org update site contents]]

Congratulations, you have installed the OpenOffice.org plugin successfully. Now you must configure it. The following steps will guide you through this task. Go to the Eclipse options via the '''Window > Preferences...''' menu. In the list on the left, select the '''OpenOffice.org plugin > SDK Configuration''' item to get a window like the one shown in the following illustration.

[[Image:UnoProperties.png|center|SDK configuration window]]

In this window you will have to configure the path to your OpenOffice.org and to its SDK. So, let us begin with the SDK path: click on the '''Add''' button next to the SDKs list. You will have a window like the one shown in following illustration. Browse to your OpenOffice.org 2.0 SDK and validate. Then you will have to do the same for the OpenOffice.org path using the other '''Add''' button.

Note that a URE installation can be selected instead of a complete OpenOffice.org installation. Please refer to the Java URE application tutorial for more details on the plugin's URE support.

'''If you are using Windows, please make sure that the path to the SDK does not contains any spaces. Spaces in the path can cause problems when you build your UNO projects.'''

[[Image:SdkConfig.png|center|New SDK path window]]

Now your OpenOffice.org plugin is ready to work. You can begin to create your new component. If there was any problem during the plugin installation, please report it to the dev@api.openoffice.org [http://api.openoffice.org/servlets/ProjectMailingListList mailing-list].

==Creating a new component==
For the Eclipse plugin, a UNO component is a UNO project. This tutorial will explain how to easily create a new UNO component using the Eclipse plugin. We will now assume that you have very simple needs. The component that will be created is a "Hello world" service and its implementation. Creating a component that defines and implements more services is a bit more complex and requires advanced Java UNO knowledge.

There are several ways to create a UNO component project using the plugin:

*The first one is the '''File > New > Project''' menu entry and choose the '''UNO > UNO-IDL Project''' item as shown by the following illustration.

[[Image:NewUnoProjectsItems.png|center|New UNO-IDL project item]]

*The second one is the icon in the toolbar representing a blue folder with a star as shown by the following illustration.

[[Image:NewUnoProjectIcon.png|center|New UNO-IDL project icon]]

Then you only have to follow the wizard to create your UNO component project, its specification and a skeleton of the implementation. This wizard is composed of several pages:

*The main configuration page to define the general project properties.
*The implementation language configuration page.
*The service configuration page.
*The interface configuration page.
After all these steps you will have a running component... doing nothing. The following sections will describe the different wizard pages and where to place your code.

===The project configuration page===
The first page in the project wizard is the only page containing fields that must be filled in. All the others have default values to help you through the component creation. In our case, we will cover all the pages in the wizard to explain them all and define some new methods and attributes in our component.

[[Image:NewUnoProject.jpg|center|New UNO-IDL project wizard page]]

*'''Project name:''' is the component name, in our case, it will be "''Helloworld''"
*'''Location:''' is the directory on your computer where the project will be created. You can change the default one by deselecting the '''Use default''' check box. The default location of each Eclipse project is a directory with your project name in the current Eclipse workspace. '''Please do not use spaces in this path on Windows. Spaces in the path can prevent your component from being built.'''
*'''Root package:''' is the name of the first module of your component. It is generally composed of two parts: the vendor name (here <tt>org.openoffice</tt>) and the project name (here <tt>helloworld</tt>).
*'''Used SDK:''' selects the OpenOffice.org SDK which will be used to develop the component. You generally will have only one SDK in the list, but you can add others in the preferences or by clicking on the '''Configure SDKs''' button.
*'''Used OOo:''' selects the version of OpenOffice.org to use to develop the component. Just as with the SDK, you will generally have only one entry in the list, but you can add others in the preferences or by clicking on the OOo Installations button.
*'''Programming language:''' selects the programming language for the component implementation. For the moment, there is only Java available, however C++ and python are planned.

===The implementation language configuration page===
This page depends on the chosen language. For Java, the default values should be kept: they define which class is the main class of the component. The component's main class contains some code mapping the services to their implementation.

===The service configuration page===

[[Image:Eclipse_Service_Page.png|center|Service configuration page]]

*'''Module:''' corresponds to the UNO-IDL module where to add the interface. If the text field is left empty, the interface will be added in the root module of the component (filled in the project wizard).
*'''Service name:''' is the service name. By keeping the default value, you will be able to define your own interface using the interface configuration page. Otherwise, you can reuse an existing interface.
*'''Published''': specifies if the interface is published or not. The published notion is translated into a keyword in UNO-IDL language. Declaring a UNO-IDL type as published means that it will not change in future releases. We will keep it unchecked because our component is really far from being a stable API.

===The interface configuration page===

[[Image:NewInterfacePage.png|center|Interface configuration page]]

*'''Module:''' corresponds to the UNO-IDL module where the interface is added. If the text field is left empty, the interface will be added in the root module of the component (filled in the project wizard).
*'''Interface name:''' is the interface name. By convention, we generally name an interface beginning with an "X". In this tutorial, the interface will be named <tt>XHelloworld</tt>.
*'''Inherited interfaces:''' is a list of all the interfaces from which the one that is about to be created will inherit. This is one of the changes in UNO-IDL between OpenOffice.org 1.1.x and 2.0, and why the plugin does not support OpenOffice.org versions prior to 2.0. All the UNO-IDL interfaces are inheriting more or less directly from the <tt>com::sun::star::uno::XInterface</tt> type. As the <tt>XHelloworld</tt> interface is very easy, no super interface will be added. This will implicitly define <tt>XInterface</tt> as the only parent for the new interface.
**'''"?" column:''' specifies if the interface inheritance is mandatory or not. If the box is checked, the interface inheritance is optional and may not be implemented.
**'''"Add" and "Del" buttons:''' allows you to add an interface to the inherited ones or remove the selected interface.
*'''Members:''' is a list of all the methods and properties of the interface. See below for explanations about the members. In this tutorial, just create one <tt>string sayHello([in] boolean isBadBoy)</tt> method and a <tt>LadyName</tt> property.
*'''Published:''' specifies if the interface is published or not. The published notion is translated into a keyword in UNO-IDL language. Declaring a UNO-IDL type as published means that it will not change in future releases. We will keep it unchecked because our component is really far from being a stable API.
A UNO interface can contain two kind of members: methods and properties. When clicking on the '''Add''' button near the members' list, the following window will be shown. When double-clicking on a line in the members' list, you will edit the corresponding member through the same window.

When the window is opened to create a new member, you can choose whether the member will be a property or a method. The name and returned type fields are always present, but the lower part of the dialog is different for a method and a property.

[[Image:Eclipse_Interface_Members_Dialog.png|center|Interface member creation dialog]]

*'''The arguments list:''' defines the name, type and direction of the parameters of the method. Simply click on the cell to edit it.
*'''Read-only and Bound check boxes:''' selecting these boxes sets the corresponding IDL flag on the property.

'''Tip:''' you can use ''<tt>''Ctrl+Space''</tt>'' to complete the type name in the '''Return type''' field and '''Type''' column.

===Writing the implementation===
After having completed the wizard, you need to write the component implementation. Hopefully a skeleton has been generated and opened. You need to complete the code where there are some TODOS. The generated project contains the following directories and files:

*'''source:''' directory containing your Java implementation classes.
*'''build:''' directory containing all the generated temporary files, such as the results of the specification files (<tt>.idl</tt> files) compilation (<tt>.urd</tt> files) or the class files corresponding to the specifications (<tt>.class</tt> files).
*'''idl:''' directory containing the specifications of the component.
*'''types.rdb:''' generated UNO types registry from which the classes files will be generated.
*'''JRE and the jars:''' describe the classpath of the component. They are visible only in the Java package explorer. The OpenOffice.org jars are changed if the OpenOffice.org version associated to the project is changed. ''In a future version, they will be packed in a user library to take less space in the tree.''
The generated skeleton already contains the methods for the implementation registration. The only things to modify are:

*Change the code of the setters and getters for the defined properties.
*Change the code of the defined methods.
The Eclipse integration even manages the libraries needed by your implementation. Let us imagine that we want to use the <tt>Fraction</tt> class from the Apache <tt>common-math</tt> jar. Download this jar from the Apache website, and import the <tt>common-math-1.1.jar</tt> file into your component project, for example in a <tt>lib</tt> directory. Add the jar to the project build path in the same way than in any other Eclipse Java project and use it:

<code>[java]
// org.openoffice.helloworld.XHelloworld:
private String mLadyName = "";

public String getLadyName()
{
return mLadyName;
}

public void setLadyName(String the_value)
{
mLadyName = the_value;
}

public String sayHello(boolean isBadBoy)
{
String hello = "Hello Mrs. " + getLadyName();
if (isBadBoy) {
Fraction f = new Fraction(1, 3);
hello = "A third is " + f.doubleValue();
}
return hello;
}
</code>
The above code shows you what could be an implementation of our component. Now, there is only to package it properly and test it.

==Packaging and testing the component==
Now we will show you how to export your component into an OpenOffice.org package. There is little to do apart from following these steps:

*Select the '''File > Export''' menu. Then choose the '''UNO > OpenOffice.org''' package export type.
*The next page of the wizard asks for the UNO project to export (already selected), the directory where to export the package and the OpenOffice.org minimum compatibility version for the package. Depending of the selected OpenOffice.org version, the package will get a different name and a different structure.
*Click on the Finish button. The wizard will ask you whether to deploy to package or not and asks for the old package removal if needed.
Then we will suppose that the package is deployed on the OpenOffice.org installation and we will test it using the following <tt>OooBasic</tt> macro.

<code>[oobas]
Sub testHelloworld
oHelloworld = createUnoService( "org.openoffice.helloworld.Helloworld" )
oHelloworld.LadyName = "Robinson"
print oHelloworld.sayHello( false )
print oHelloworld.sayHello( True )
End Sub
</code>

This macro should open two message windows with ''"Hello Mrs. Robinson"'' and ''"A third is 0.3333333"''. Your first UNO component is now running, enjoy doing others.

==Going further==
This chapter is only for those who enjoyed this tutorial and want to know more about the UNO component creation in Java or other languages. The following is a list of useful links for any UNO developer:

*[http://api.openoffice.org/docs/DevelopersGuide/DevelopersGuide.xhtml OpenOffice.org developer's guide] is a huge source of documentation for any OpenOffice.org developer. You should probably have a look at chapters 3 and 4 for UNO component information.
*[http://api.openoffice.org/docs/java/ref/overview-summary.html OOo Java reference] is the UNO binding for Java reference.
*[http://api.openoffice.org/docs/cpp/ref/names/index.html OOo C++ reference] is the UNO binding for C++ reference.
*[http://wiki.services.openoffice.org/ OOo Developer's Wiki] is the wiki for all the OpenOffice.org developers. It contains useful information even for people who are just starting out with UNO.
*[http://udk.openoffice.org/common/man/draft/multinherit.html http://udk.openoffice.org/common/man/draft/multinherit.html] for further information on what changes have been made in UNO-IDL between OpenOffice.org 1.1.x and 2.0
*[http://tools.openoffice.org/autodoc/HowToWriteDocumentation-Cpp.html Autodoc Java reference] is the reference for <tt>javadoc</tt> like comments in UNO-IDL files.
*[http://tools.openoffice.org/autodoc/HowToWriteDocumentation-Cpp.html Autodoc C++ documentation] is the reference for <tt>javadoc</tt> like comments in C++ components.
*[http://cedric.bosdonnat.free.fr/wordpress/?p=19 URE C++ application tutorial] explains how to create a C++ application based on the URE, that is a UNO C++ component that does not need OpenOffice.org.

[[Category:Eclipse]]
[[Category:Development]]
[[Category:Tutorial]]
[[Category:Java]]
[[Category:Uno]]

JavaEclipseTuto

2007-03-16T23:11:02Z

Exactt: /* Eclipse and the plugin */

=How to create a Java component with Eclipse=

==Introduction==
This paper is a tutorial to guide UNO newcomers to create their first Java component. This tutorial will use Eclipse and it's plugin for the OpenOffice.org development. Of course, every step will be detailed, but if your are still an experienced UNO programmer, you can have a look at the next pages to have a better view of how to use the Eclipse plugin.

===UNO Components===
This section will explain some very basic things about UNO components. You might skip it if you already know it. First I will explain what is a component and it's mains parts. Afterwards, I will explain what is needed to create a UNO component to help you to fully understand the different tools and their use during the tutorial.

====Components anatomy====
''"A component is a system element offering a predefined service and able to communicate with other components"'' explains [http://fr.wikipedia.org/wiki/composant Wikipedia (Fr)] (Even thought there is a definition on the English wikipedia article, I prefer the French one because of it completeness). In UNO case a component will generally be delivered as a package containing a library (share library in C++ or jar in Java). For UNO a component is made of two distinct parts: specifications and an implementation.

*'''Specification: '''definition in a common language of what the component should do. For UNO, this language is called UNO-IDL and is more or less similar to [http://en.wikipedia.org/wiki/Corba Corba] IDL. The documented part that will be provided as an API to use the component is the specification. Thus it should be complete and implementation independent.
*'''Implementation: '''is the code that will realize what is described in the component specifications. This programming language can either be C++, Java, Python or some others. This is the internal part of the component and will not be accessible from another component.
In order UNO knows which implementation corresponds to which specification, the component will use registries. There are two of them: the first one describes all the component specifications (<tt>types.rdb</tt>) and the second translates the implementation into specifications (<tt>services.rdb</tt>) and is generated from the implementation.

====Components creation process====
To help you better understand what should be done to get a component from it's specification and sources, you should have a look at the next illustration. As shown by the diagram, the specifications are compiled and merged into one <tt>types.rdb</tt> registry. <tt>Class</tt> files are generated from that file to translate the specifications into a Java class definition file which is build with the implementation into class using the <tt>java</tt> compiler. All the classes are delivered as a <tt>jar</tt> file with a specific manifest as we will see further in this tutorial. This doesn't make a usable OpenOffice.org: the <tt>types.rdb</tt> and <tt>jar</tt> file will have to be zipped into a <tt>.uno.pkg</tt> file described with another manifest.

[[Image:CompilationChain.png|center|UNO component build chain]]

As I will explain it later, the Eclipse plugin will hide some of these operations, however you will need to know how they work to fully understand the build process and what we will do in the next steps.

===Installing the development platform===
Now that you perfectly know what to do, we will install and configure the development tools. This is quite simple but you might be trapped into some problems if you don't read the next lines carefully. I will now assume that you have none of the development tools. The OpenOffice.org Eclipse integration minimal requirements are the following one:

*OpenOffice.org 2.0
*OpenOffice.org SDK 2.0.4
*Eclipse 3.2
*Java 1.5 (the GNU Java doesn't work with the Eclipse integration)

====OpenOffice.org====
First of all, you will need to have a working OpenOffice.org 2.0 and its Software Development Kit (SDK). The last versions are available on the [http://download.openoffice.org/ OpenOffice.org download pages] for the most current platforms. The OpenOffice.org SDK version 2.0.4 is mandatory to use the plugin correctly. It includes a new tool used by the plugin: the <tt>uno-skeletonmaker</tt>. This tool will generate the implementation skeleton to help you to concentrate only on your code.

This tutorial assumes that you used the "Official" OpenOffice.org distribution from the project's website. Other distributions may not work with the Eclipse integration.

====Eclipse and the plugin====
To get Eclipse, just get to their download pages and download the last Eclipse SDK. You will have Eclipse and it's SDK. Of course, you might want to download only the binary runtime, but you will have to follow more links. Once you have Eclipse, unzip it on your computer and that's it: eclipse has a Java plugin to help you program in Java.

Now we will install the OpenOffice.org development plugin for Eclipse using the Eclipse software update system. '''Do not try to download an archive somewhere: Eclipse will do it for you during the next steps.''' Select the '''Help > Software updates > Find and install''' menu to get the window of the next illustration. Check the second option on this window and click on the '''Next''' button.

[[Image:InstallWindow.png|center|"Find & Install" window]]

On the following page, you will see a list of "''update sites''". These are URLs pointing to directories containing plugins informations and archives. Now click on the '''Add remote site''' button to get a small window asking for a name that will be displayed in the list and an URL. The URL of OpenOffice.org plugin update site is http://cedric.bosdonnat.free.fr/ooeclipseintegration.

'''Do not hope to get an archive to download here: it's the update site for Eclipse.'''

Then validate the new update site parameters and be sure that the OpenOffice.org site is checked before clicking on the '''Finish''' button. You should now see a window like the one of the next illustration. '''Select the OpenOffice.org plugin Core and Java plugins''', click next and let the wizard guide you through the end of the process. You will be asked to accept the plugin licence and validate the installation archives which are not signed.

[[Image:PluginUpdates.png|center|OpenOffice.org update site contents]]

Congratulations, you have installed the OpenOffice.org plugin successfully, there is now to configure it. The following steps will guide you through this task. Go to the Eclipse options via the '''Window > Preferences...''' menu. In the list on the left, select the '''OpenOffice.org plugin > SDK configuration''' item to get a window like the one shown by the next illustration.

[[Image:UnoProperties.png|center|SDK configuration window]]

In this window you will have to configure the path to your OpenOffice.org and to it's SDK. So let us begin with the SDK path: click on the '''Add''' button next to the SDKs list. You will have a window like the next illustration, browse to your OpenOffice.org 2.0 SDK and validate. Then you will have to do the same for the OpenOffice.org path using the other '''Add''' button.

Note that a URE installation can be selected instead of a complete OpenOffice.org installation. Please report to the Java URE application tutorial for more details on the plugin's URE support.

'''Please make sure that the path to the SDK doesn't contains any space on Windows: it could cause some problems when building your UNO projects afterwards.'''

[[Image:SdkConfig.png|center|New SDK path window]]

Now your OpenOffice.org plugin is ready to work: you can begin to create your new component. If there was any problem during the plugin installation, do not hesitate to report it to the dev@api.openoffice.org [http://api.openoffice.org/servlets/ProjectMailingListList mailing-list].

==Creating a new component==
For the Eclipse plugin, a UNO component is a UNO project. This tutorial will explain how to easily create a new UNO component using the Eclipse plugin. We will now assume that you have very simple needs: the component that will be created is a "Hello world" service and its implementation. Creating a component defining and implementing more services is a bit more complex and need advanced Java UNO knowledge.

There are several ways to create a UNO component project using the plugin:

*the first one is the '''File > New > Project''' menu entry and choose the '''UNO > UNO-IDL Project''' item as shown by the next illustration.

[[Image:NewUnoProjectsItems.png|center|New UNO-IDL project item]]

*the second one is the icon in the toolbar representing a blue folder with a star as show by the next illustration.

[[Image:NewUnoProjectIcon.png|center|New UNO-IDL project icon]]

Then you only have to follow the wizard to create your UNO component project, its specification and a skeleton of implementation. This wizard is composed of several pages:

*The main configuration page to define the general project properties
*The implementation language configuration page.
*The service configuration page
*The interface configuration page
After all these steps you can get a running component... doing nothing. The next sections will describe the different wizard pages and where to place your code.

===The project configuration page===
The first page in the project wizard is the only page containing fields that need to be filled. All the others have default values to help you through the component creation. In our case, we will need all the pages to explain them all and define some mew methods and attributes in our component.

[[Image:NewUnoProject.jpg|center|New UNO-IDL project wizard page]]

*'''Project name:''' is the component name, in our case, it will be "''Helloworld''"
*'''Location:''' is the directory on your computer where the project will be created. You can change the default one by deselecting the '''Use default''' check box. The default location of each Eclipse project is a directory with your project name in the current Eclipse workspace. '''Please avoid spaces in this path on Windows: it could prevent your component to be built.'''
*'''Root package:''' is the name of the first module of your component. It generally composed of two parts: the vendor name (here <tt>org.openoffice</tt>) and the project name (here <tt>helloworld</tt>).
*'''Used SDK:''' selects the OpenOffice.org SDK which will be used to develop the component. You generally will have only one SDK in the list, but you can add others in the preferences or by clicking on the '''Configure SDKs''' button.
*'''Used OOo:''' selects the version of OpenOffice.org to use to develop the component. As for the SDK, you will generally have only one entry in the list, but you can add others in the preferences or by clicking on the OOo Installations button.
*'''Programming language:''' selects the programming language for the component implementation. For the moment, there is only Java available, however C++ and python are planned.

===The implementation language configuration page===
This page depends on the chosen language. For Java, the default values should be kept: they define which class is the main class of the component. The component's main class contains some code mapping the services to their implementation.

===The service configuration page===

[[Image:Eclipse_Service_Page.png|center|Service configuration page]]

*'''Module:''' corresponds to the UNO-IDL module where to add the interface. If the text field is left empty, the interface will be added in the root module of the component (filled in the project wizard).
*'''Service name:''' is the service name. By keeping the default value, you will be able to define your own interface using the interface configuration page. Otherwise, you can reuse an existing interface.
*'''Published''': specifies if the interface is published or not. The published notion is translated into a keyword in UNO-IDL language. Declaring a UNO-IDL type as published means that it will not change in future releases: we will keep it unchecked because our component is really far from being a stable API.

===The interface configuration page===

[[Image:NewInterfacePage.png|center|Interface configuration page]]

*'''Module:''' corresponds to the UNO-IDL module where to add the interface. If the text field is left empty, the interface will be added in the root module of the component (filled in the project wizard).
*'''Interface name:''' is the interface name. By convention, we generally name a interface beginning with an "X". In this tutorial case, the interface will be named <tt>XHelloworld</tt>.
*'''Inherited interfaces:''' is a list of all the interfaces from which the one that is about to be created will inherit. This is one of the changes in UNO-IDL between OpenOffice.org 1.1.x and 2.0: that is why the plugin does not support OpenOffice.org version prior to 2.0. All the UNO-IDL interfaces are inheriting more or less directly from the <tt>com::sun::star::uno::XInterface</tt> type. As the <tt>XHelloworld</tt> interface is very easy, no super interface will be added: that will implicitly define <tt>XInterface</tt> as the only parent for the new interface.
**'''"?" column:''' specifies if the interface inheritance is mandatory or not. If the box is checked, thus the interface inheritance is optional and may not be implemented.
**'''"Add" and "''''''Del''''''" buttons:''' allows to add an interface to the inherited ones or removing the selected interface.
*'''Members:''' is a list of all the methods and properties of the interface. See the explanations about the members some lines below. In this tutorial, just create one <tt>string sayHello([in] boolean isBadBoy)</tt> method and a <tt>LadyName</tt> property.
*'''Published:''' specifies if the interface is published or not. The published notion is translated into a keyword in UNO-IDL language. Declaring a UNO-IDL type as published means that it will not change in future releases: we will keep it unchecked because our component is really far from being a stable API.
A UNO interface can contain two kind of members: methods and properties. When clicking on the '''Add''' button near the members' list, the following window will be shown. When double-clicking on a line in the members' list, you will edit the corresponding member through the same window.

When the window is opened to create a new member, you can choose whether the member will be a property or a method. The name and returned type fields are always present, but the lower part of the dialog is different for a method and a property.

[[Image:Eclipse_Interface_Members_Dialog.png|center|Interface member creation dialog]]

*'''The arguments list:''' defines the name, type and direction of the parameters of the method. Simply click on the cell to edit it.
*'''Read-only and Bound check boxes:''' selecting these boxes sets the corresponding IDL flag on the property.

'''Tip:''' you can use ''<tt>''Ctrl+Space''</tt>'' to complete the type name in the '''Return type''' field and '''Type''' column.

===Writing the implementation===
After having completed the wizard, you need to write the component implementation. Hopefully a skeleton has been generated and opened: you just need to complete the code where there are some TODOS. The generated project contains the following directories and files to know:

*'''source:''' directory containing your Java implementation classes
*'''build:''' directory containing all the generated temporary files, such as the results of the specification files (<tt>.idl</tt> files) compilation (<tt>.urd</tt> files) or the class files corresponding to the specifications (<tt>.class</tt> files)
*'''idl:''' directory containing the specifications of the component
*'''types.rdb:''' generated UNO types registry from which the classes files will be generated
*'''JRE and the jars:''' are describing the classpath of the component. They are visible only in the Java package explorer. The OpenOffice.org jars are changed if the OpenOffice.org version associated to the project is changed. ''In a future version, they will be packed in a user library to take less space in the tree.''
The generated skeleton already contains the methods for the implementation registration. The only things to modify are:

*Change the code of the setters and getters for the defined properties
*Change the code of the defined methods.
The Eclipse integration even manages the libraries needed by your implementation. Let us imagine, that we want to use the <tt>Fraction</tt> class from the Apache <tt>common-math</tt> jar. Download this jar from the Apache website, and import the <tt>common-math-1.1.jar</tt> file into your component project: for example in a <tt>lib</tt> directory. Add the jar to the project build path in the same way than in any other Eclipse Java project and use it:

<code>[java]
// org.openoffice.helloworld.XHelloworld:
private String mLadyName = "";

public String getLadyName()
{
return mLadyName;
}

public void setLadyName(String the_value)
{
mLadyName = the_value;
}

public String sayHello(boolean isBadBoy)
{
String hello = "Hello Mrs. " + getLadyName();
if (isBadBoy) {
Fraction f = new Fraction(1, 3);
hello = "A third is " + f.doubleValue();
}
return hello;
}
</code>
The above code show you what could be an implementation of our component. Now, there is only to package it properly and test it.

==Packaging and testing the component==
The next lines will show you how to export your component into an OpenOffice.org package. There is quite nothing to do apart from following these small steps:

*Select the '''File > Export''' menu. Then choose the '''UNO > OpenOffice.org''' package export type.
*The next page of the wizard, asks for the UNO project to export (already selected), the directory where to export the package and the OpenOffice.org minimum compatibility version for the package. Depending of the selected OpenOffice.org version, the package will get a different name and a different structure.
*Then click on the Finish button. The wizard will ask you whether to deploy to package or not and asks for the old package removal if needed.
Then we will suppose that the package is deployed on the OpenOffice.org installation and we will test it using the following <tt>OooBasic</tt> macro.

<code>[oobas]
Sub testHelloworld
oHelloworld = createUnoService( "org.openoffice.helloworld.Helloworld" )
oHelloworld.LadyName = "Robinson"
print oHelloworld.sayHello( false )
print oHelloworld.sayHello( True )
End Sub
</code>

This macro should open two message windows with ''"Hello Mrs. Robinson"'' and ''"A third is 0.3333333"''. Your first UNO component is now running, enjoy doing others.

==Going further==
This chapter is only for those who enjoyed this tutorial and want to know more about the UNO component creation in Java or other languages. You will have a list of useful links for any UNO developer in the next line.

*[http://api.openoffice.org/docs/DevelopersGuide/DevelopersGuide.xhtml OpenOffice.org developer's guide] is a huge source of documentation for any OpenOffice.org developer. You should probably have a look at the chapters 3 and 4 for UNO components informations.
*[http://api.openoffice.org/docs/java/ref/overview-summary.html OOo Java reference] is the UNO binding for Java reference.
*[http://api.openoffice.org/docs/cpp/ref/names/index.html OOo C++ reference] is the UNO binding for C++ reference.
*[http://wiki.services.openoffice.org/ OOo Developer's Wiki] is the wiki for all the OpenOffice.org developers. It contains very useful informations even for people who just begin with UNO.
*[http://udk.openoffice.org/common/man/draft/multinherit.html http://udk.openoffice.org/common/man/draft/multinherit.html] for further informations on what changes in UNO-IDL between OpenOffice.org 1.1.x and 2.0
*[http://tools.openoffice.org/autodoc/HowToWriteDocumentation-Cpp.html Autodoc Java reference] is the reference for <tt>javadoc</tt> like comments in UNO-IDL files.
*[http://tools.openoffice.org/autodoc/HowToWriteDocumentation-Cpp.html Autodoc C++ documentation] is the reference for <tt>javadoc</tt> like comments in C++ components.
*[http://cedric.bosdonnat.free.fr/wordpress/?p=19 URE C++ application tutorial] explains how to create a C++ application based on the URE, that is a UNO C++ component that does not need OpenOffice.org.

[[Category:Eclipse]]
[[Category:Development]]
[[Category:Tutorial]]
[[Category:Java]]
[[Category:Uno]]

JavaEclipseTuto

2007-03-16T23:06:04Z

Exactt: /* The interface configuration page */

=How to create a Java component with Eclipse=

==Introduction==
This paper is a tutorial to guide UNO newcomers to create their first Java component. This tutorial will use Eclipse and it's plugin for the OpenOffice.org development. Of course, every step will be detailed, but if your are still an experienced UNO programmer, you can have a look at the next pages to have a better view of how to use the Eclipse plugin.

===UNO Components===
This section will explain some very basic things about UNO components. You might skip it if you already know it. First I will explain what is a component and it's mains parts. Afterwards, I will explain what is needed to create a UNO component to help you to fully understand the different tools and their use during the tutorial.

====Components anatomy====
''"A component is a system element offering a predefined service and able to communicate with other components"'' explains [http://fr.wikipedia.org/wiki/composant Wikipedia (Fr)] (Even thought there is a definition on the English wikipedia article, I prefer the French one because of it completeness). In UNO case a component will generally be delivered as a package containing a library (share library in C++ or jar in Java). For UNO a component is made of two distinct parts: specifications and an implementation.

*'''Specification: '''definition in a common language of what the component should do. For UNO, this language is called UNO-IDL and is more or less similar to [http://en.wikipedia.org/wiki/Corba Corba] IDL. The documented part that will be provided as an API to use the component is the specification. Thus it should be complete and implementation independent.
*'''Implementation: '''is the code that will realize what is described in the component specifications. This programming language can either be C++, Java, Python or some others. This is the internal part of the component and will not be accessible from another component.
In order UNO knows which implementation corresponds to which specification, the component will use registries. There are two of them: the first one describes all the component specifications (<tt>types.rdb</tt>) and the second translates the implementation into specifications (<tt>services.rdb</tt>) and is generated from the implementation.

====Components creation process====
To help you better understand what should be done to get a component from it's specification and sources, you should have a look at the next illustration. As shown by the diagram, the specifications are compiled and merged into one <tt>types.rdb</tt> registry. <tt>Class</tt> files are generated from that file to translate the specifications into a Java class definition file which is build with the implementation into class using the <tt>java</tt> compiler. All the classes are delivered as a <tt>jar</tt> file with a specific manifest as we will see further in this tutorial. This doesn't make a usable OpenOffice.org: the <tt>types.rdb</tt> and <tt>jar</tt> file will have to be zipped into a <tt>.uno.pkg</tt> file described with another manifest.

[[Image:CompilationChain.png|center|UNO component build chain]]

As I will explain it later, the Eclipse plugin will hide some of these operations, however you will need to know how they work to fully understand the build process and what we will do in the next steps.

===Installing the development platform===
Now that you perfectly know what to do, we will install and configure the development tools. This is quite simple but you might be trapped into some problems if you don't read the next lines carefully. I will now assume that you have none of the development tools. The OpenOffice.org Eclipse integration minimal requirements are the following one:

*OpenOffice.org 2.0
*OpenOffice.org SDK 2.0.4
*Eclipse 3.2
*Java 1.5 (the GNU Java doesn't work with the Eclipse integration)

====OpenOffice.org====
First of all, you will need to have a working OpenOffice.org 2.0 and its Software Development Kit (SDK). The last versions are available on the [http://download.openoffice.org/ OpenOffice.org download pages] for the most current platforms. The OpenOffice.org SDK version 2.0.4 is mandatory to use the plugin correctly. It includes a new tool used by the plugin: the <tt>uno-skeletonmaker</tt>. This tool will generate the implementation skeleton to help you to concentrate only on your code.

This tutorial assumes that you used the "Official" OpenOffice.org distribution from the project's website. Other distributions may not work with the Eclipse integration.

====Eclipse and the plugin====
To get Eclipse, just get to their download pages and download the last Eclipse SDK. You will have Eclipse and it's SDK. Of course, you might want to download only the binary runtime, but you will have to follow more links. Once you have Eclipse, unzip it on your computer and that's it: eclipse has a Java plugin to help you program in Java.

Now we will install the OpenOffice.org development plugin for Eclipse using the Eclipse software update system. '''Do not try to download an archive somewhere: Eclipse will do it for you during the next steps.''' Select the '''Help > Software updates > Find and install''' menu to get the window of the next illustration. Check the second option on this window and click on the '''Next''' button.

[[Image:InstallWindow.png|center|"Find & Install" window]]

On the following page, you will see a list of "''update sites''". These are URLs pointing to directories containing plugins informations and archives. Now click on the '''Add remote site''' button to get a small window asking for a name that will be displayed in the list and an URL. The URL of OpenOffice.org plugin update site is http://cedric.bosdonnat.free.fr/ooeclipseintegration.

'''Do not hope to get an archive to download here: it's the update site for Eclipse.'''

Then validate the new update site parameters and be sure that the OpenOffice.org site is checked before clicking on the '''Finish''' button. You should now see a window like the one of the next illustration. '''Select the OpenOffice.org plugin Core and Java plugins''', click next and let the wizard guide you through the end of the process. You will be asked to accept the plugin licence and validate the installation archives which are not signed.

[[Image:PluginUpdates.png|center|OpenOffice.org update site contents]]

Congratulations, you have installed the OpenOffice.org plugin successfully, there is now to configure it. The following steps will guide you through this task. Go to the Eclipse options via the '''Window > Preferences...''' menu. In the list on the left, select the '''OpenOffice.org plugin > SDK configuration''' item to get a window like the one shown by the next illustration.

[[Image:UnoProperties.png|center|SDK configuration window]]

In this window you will have to configure the path to your OpenOffice.org and to it's SDK. So let us begin with the SDK path: click on the '''Add''' button next to the SDKs list. You will have a window like the next illustration, browse to your OpenOffice.org 2.0 SDK and validate. Then you will have to do the same for the OpenOffice.org path using the other '''Add''' button.

Note that a URE installation can be selected instead of a complete OpenOffice.org installation. Please report to the Java URE application tutorial for more details on the plugin's URE support.

'''Please make sure that the path to the SDK doesn't contains any space on Windows: it could cause some problems when building your UNO projects afterwards.'''

[[Image:SdkConfig.png|center|New SDK path window]]

Now your OpenOffice.org plugin is ready to work: you can begin to create your new component. If there was any problem during the plugin installation, do not hesitate to report it to the dev@api.openoffice.org mailing-list.

==Creating a new component==
For the Eclipse plugin, a UNO component is a UNO project. This tutorial will explain how to easily create a new UNO component using the Eclipse plugin. We will now assume that you have very simple needs: the component that will be created is a "Hello world" service and its implementation. Creating a component defining and implementing more services is a bit more complex and need advanced Java UNO knowledge.

There are several ways to create a UNO component project using the plugin:

*the first one is the '''File > New > Project''' menu entry and choose the '''UNO > UNO-IDL Project''' item as shown by the next illustration.

[[Image:NewUnoProjectsItems.png|center|New UNO-IDL project item]]

*the second one is the icon in the toolbar representing a blue folder with a star as show by the next illustration.

[[Image:NewUnoProjectIcon.png|center|New UNO-IDL project icon]]

Then you only have to follow the wizard to create your UNO component project, its specification and a skeleton of implementation. This wizard is composed of several pages:

*The main configuration page to define the general project properties
*The implementation language configuration page.
*The service configuration page
*The interface configuration page
After all these steps you can get a running component... doing nothing. The next sections will describe the different wizard pages and where to place your code.

===The project configuration page===
The first page in the project wizard is the only page containing fields that need to be filled. All the others have default values to help you through the component creation. In our case, we will need all the pages to explain them all and define some mew methods and attributes in our component.

[[Image:NewUnoProject.jpg|center|New UNO-IDL project wizard page]]

*'''Project name:''' is the component name, in our case, it will be "''Helloworld''"
*'''Location:''' is the directory on your computer where the project will be created. You can change the default one by deselecting the '''Use default''' check box. The default location of each Eclipse project is a directory with your project name in the current Eclipse workspace. '''Please avoid spaces in this path on Windows: it could prevent your component to be built.'''
*'''Root package:''' is the name of the first module of your component. It generally composed of two parts: the vendor name (here <tt>org.openoffice</tt>) and the project name (here <tt>helloworld</tt>).
*'''Used SDK:''' selects the OpenOffice.org SDK which will be used to develop the component. You generally will have only one SDK in the list, but you can add others in the preferences or by clicking on the '''Configure SDKs''' button.
*'''Used OOo:''' selects the version of OpenOffice.org to use to develop the component. As for the SDK, you will generally have only one entry in the list, but you can add others in the preferences or by clicking on the OOo Installations button.
*'''Programming language:''' selects the programming language for the component implementation. For the moment, there is only Java available, however C++ and python are planned.

===The implementation language configuration page===
This page depends on the chosen language. For Java, the default values should be kept: they define which class is the main class of the component. The component's main class contains some code mapping the services to their implementation.

===The service configuration page===

[[Image:Eclipse_Service_Page.png|center|Service configuration page]]

*'''Module:''' corresponds to the UNO-IDL module where to add the interface. If the text field is left empty, the interface will be added in the root module of the component (filled in the project wizard).
*'''Service name:''' is the service name. By keeping the default value, you will be able to define your own interface using the interface configuration page. Otherwise, you can reuse an existing interface.
*'''Published''': specifies if the interface is published or not. The published notion is translated into a keyword in UNO-IDL language. Declaring a UNO-IDL type as published means that it will not change in future releases: we will keep it unchecked because our component is really far from being a stable API.

===The interface configuration page===

[[Image:NewInterfacePage.png|center|Interface configuration page]]

*'''Module:''' corresponds to the UNO-IDL module where to add the interface. If the text field is left empty, the interface will be added in the root module of the component (filled in the project wizard).
*'''Interface name:''' is the interface name. By convention, we generally name a interface beginning with an "X". In this tutorial case, the interface will be named <tt>XHelloworld</tt>.
*'''Inherited interfaces:''' is a list of all the interfaces from which the one that is about to be created will inherit. This is one of the changes in UNO-IDL between OpenOffice.org 1.1.x and 2.0: that is why the plugin does not support OpenOffice.org version prior to 2.0. All the UNO-IDL interfaces are inheriting more or less directly from the <tt>com::sun::star::uno::XInterface</tt> type. As the <tt>XHelloworld</tt> interface is very easy, no super interface will be added: that will implicitly define <tt>XInterface</tt> as the only parent for the new interface.
**'''"?" column:''' specifies if the interface inheritance is mandatory or not. If the box is checked, thus the interface inheritance is optional and may not be implemented.
**'''"Add" and "''''''Del''''''" buttons:''' allows to add an interface to the inherited ones or removing the selected interface.
*'''Members:''' is a list of all the methods and properties of the interface. See the explanations about the members some lines below. In this tutorial, just create one <tt>string sayHello([in] boolean isBadBoy)</tt> method and a <tt>LadyName</tt> property.
*'''Published:''' specifies if the interface is published or not. The published notion is translated into a keyword in UNO-IDL language. Declaring a UNO-IDL type as published means that it will not change in future releases: we will keep it unchecked because our component is really far from being a stable API.
A UNO interface can contain two kind of members: methods and properties. When clicking on the '''Add''' button near the members' list, the following window will be shown. When double-clicking on a line in the members' list, you will edit the corresponding member through the same window.

When the window is opened to create a new member, you can choose whether the member will be a property or a method. The name and returned type fields are always present, but the lower part of the dialog is different for a method and a property.

[[Image:Eclipse_Interface_Members_Dialog.png|center|Interface member creation dialog]]

*'''The arguments list:''' defines the name, type and direction of the parameters of the method. Simply click on the cell to edit it.
*'''Read-only and Bound check boxes:''' selecting these boxes sets the corresponding IDL flag on the property.

'''Tip:''' you can use ''<tt>''Ctrl+Space''</tt>'' to complete the type name in the '''Return type''' field and '''Type''' column.

===Writing the implementation===
After having completed the wizard, you need to write the component implementation. Hopefully a skeleton has been generated and opened: you just need to complete the code where there are some TODOS. The generated project contains the following directories and files to know:

*'''source:''' directory containing your Java implementation classes
*'''build:''' directory containing all the generated temporary files, such as the results of the specification files (<tt>.idl</tt> files) compilation (<tt>.urd</tt> files) or the class files corresponding to the specifications (<tt>.class</tt> files)
*'''idl:''' directory containing the specifications of the component
*'''types.rdb:''' generated UNO types registry from which the classes files will be generated
*'''JRE and the jars:''' are describing the classpath of the component. They are visible only in the Java package explorer. The OpenOffice.org jars are changed if the OpenOffice.org version associated to the project is changed. ''In a future version, they will be packed in a user library to take less space in the tree.''
The generated skeleton already contains the methods for the implementation registration. The only things to modify are:

*Change the code of the setters and getters for the defined properties
*Change the code of the defined methods.
The Eclipse integration even manages the libraries needed by your implementation. Let us imagine, that we want to use the <tt>Fraction</tt> class from the Apache <tt>common-math</tt> jar. Download this jar from the Apache website, and import the <tt>common-math-1.1.jar</tt> file into your component project: for example in a <tt>lib</tt> directory. Add the jar to the project build path in the same way than in any other Eclipse Java project and use it:

<code>[java]
// org.openoffice.helloworld.XHelloworld:
private String mLadyName = "";

public String getLadyName()
{
return mLadyName;
}

public void setLadyName(String the_value)
{
mLadyName = the_value;
}

public String sayHello(boolean isBadBoy)
{
String hello = "Hello Mrs. " + getLadyName();
if (isBadBoy) {
Fraction f = new Fraction(1, 3);
hello = "A third is " + f.doubleValue();
}
return hello;
}
</code>
The above code show you what could be an implementation of our component. Now, there is only to package it properly and test it.

==Packaging and testing the component==
The next lines will show you how to export your component into an OpenOffice.org package. There is quite nothing to do apart from following these small steps:

*Select the '''File > Export''' menu. Then choose the '''UNO > OpenOffice.org''' package export type.
*The next page of the wizard, asks for the UNO project to export (already selected), the directory where to export the package and the OpenOffice.org minimum compatibility version for the package. Depending of the selected OpenOffice.org version, the package will get a different name and a different structure.
*Then click on the Finish button. The wizard will ask you whether to deploy to package or not and asks for the old package removal if needed.
Then we will suppose that the package is deployed on the OpenOffice.org installation and we will test it using the following <tt>OooBasic</tt> macro.

<code>[oobas]
Sub testHelloworld
oHelloworld = createUnoService( "org.openoffice.helloworld.Helloworld" )
oHelloworld.LadyName = "Robinson"
print oHelloworld.sayHello( false )
print oHelloworld.sayHello( True )
End Sub
</code>

This macro should open two message windows with ''"Hello Mrs. Robinson"'' and ''"A third is 0.3333333"''. Your first UNO component is now running, enjoy doing others.

==Going further==
This chapter is only for those who enjoyed this tutorial and want to know more about the UNO component creation in Java or other languages. You will have a list of useful links for any UNO developer in the next line.

*[http://api.openoffice.org/docs/DevelopersGuide/DevelopersGuide.xhtml OpenOffice.org developer's guide] is a huge source of documentation for any OpenOffice.org developer. You should probably have a look at the chapters 3 and 4 for UNO components informations.
*[http://api.openoffice.org/docs/java/ref/overview-summary.html OOo Java reference] is the UNO binding for Java reference.
*[http://api.openoffice.org/docs/cpp/ref/names/index.html OOo C++ reference] is the UNO binding for C++ reference.
*[http://wiki.services.openoffice.org/ OOo Developer's Wiki] is the wiki for all the OpenOffice.org developers. It contains very useful informations even for people who just begin with UNO.
*[http://udk.openoffice.org/common/man/draft/multinherit.html http://udk.openoffice.org/common/man/draft/multinherit.html] for further informations on what changes in UNO-IDL between OpenOffice.org 1.1.x and 2.0
*[http://tools.openoffice.org/autodoc/HowToWriteDocumentation-Cpp.html Autodoc Java reference] is the reference for <tt>javadoc</tt> like comments in UNO-IDL files.
*[http://tools.openoffice.org/autodoc/HowToWriteDocumentation-Cpp.html Autodoc C++ documentation] is the reference for <tt>javadoc</tt> like comments in C++ components.
*[http://cedric.bosdonnat.free.fr/wordpress/?p=19 URE C++ application tutorial] explains how to create a C++ application based on the URE, that is a UNO C++ component that does not need OpenOffice.org.

[[Category:Eclipse]]
[[Category:Development]]
[[Category:Tutorial]]
[[Category:Java]]
[[Category:Uno]]