Writing UNO Components

OpenOffice.org Developer's Guide

Writing UNO Components

< Previous Section

Next Section >

• Required Files
• Using UNOIDL to Specify New Components

• Writing the Specification

• Preprocessing
• Grouping Definitions in Modules
• Simple Types
• Defining an Interface
• Defining a Service
• Defining a Sequence
• Defining a Struct
• Defining an Exception
• Predefining Values
• Using Comments
• Singleton
• Reserved Types
• Published Entities

• Generating Source Code from UNOIDL Definitions

• Component Architecture
• Core Interfaces to Implement

• XInterface
• XTypeProvider
• XServiceInfo
• XWeak
• XComponent
• XInitialization
• XMain
• XAggregation
• XUnoTunnel

• Simple Component in Java

• Class Definition with Helper Class
• Implementing Your Own Interfaces
• Providing a Single Factory Using a Helper Method
• Write Registration Info Using a Helper Method
• Implementing without Helpers
• Storing the Service Manager for Further Use
• Create Instance with Arguments
• Possible Structures for Java Components
• Running and Debugging Java Components

• Register Component File
• Make Registration Available to OpenOffice.org
• Test the Registration
• Debugging
• The Java Environment in OpenOffice.org
• Troubleshooting

• C++ Component

• Class Definition with Helper Template Classes
• Implementing your own Interfaces
• Providing a Single Factory Using a Helper Method
• Write Registration Info Using a Helper Method
• Provide Implementation Environment
• Implementing without Helpers
• Storing the Service Manager for Further Use
• Create Instance with Arguments
• Multiple Components in One Dynamic Link Library
• Building and Testing C++ Components

• Integrating Components into OpenOffice.org

• Protocol Handler

• Implementation
• Configuration
• Installation

• Jobs

• Execution Environment
• Implementation
• Initialization
• Returning Results
• Configuration
• Installation
• Using the vnd.sun.star.jobs: URL Schema
• List of Supported Events

• Add-Ons

• Guidelines
• Configuration

• Menus
• Toolbars
• Images for Toolbars and Menus
• Help Integration

• Installation

• Disable Commands
• Intercepting Context Menus

• File Naming Conventions
• Deployment Options for Components

• Command Line Registry Tools
• Manual Component Installation
• Bootstrapping a Service Manager
• Special Service Manager Configurations

• The UNO Executable

• Standalone Use Case
• Server Use Case
• Using the UNO Executable

• Accessing Dialogs

• Assigning Component Methods to Control Events
• Using Dialogs in Components

< Previous Page

Next Page >

Download as a PDF or ODT

Apache OpenOffice can be extended by UNO components. UNO components are shared libraries or jar files with the ability to instantiate objects that can integrate themselves into the UNO environment. A UNO component can access existing features of Apache OpenOffice, and it can be used from within Apache OpenOffice through the object communication mechanisms provided by UNO.

Apache OpenOffice provides many entry points for these extensions.

• Arbitrary objects written in Java or C++ can be called from the user interface, display their own GUI, and work with the entire application.
• Calc Add-Ins can be used to create new formula sets that are presented in the formula autopilot.
• Chart Add-Ins can insert new Chart types into the charting tool.
• New database drivers can be installed into the office to extend data access.
• Entire application modules are exchangeable, for instance the linguistics module.
• It is possible to create new document types and add them to the office. For instance, a personal information manager could add message, calendar, task and journal document components, or a project manager could support a new project document.
• Developers can leverage the Apache OpenOffice XML file format to read and write new file formats through components.

From OpenOffice.org 1.1.0 there is comprehensive support for component extensions. The entire product cycle of a component is now covered:

• The design and development of components has been made easier by adding wizards for components to the NetBeans IDE. You can find more detailed info under https://wiki.openoffice.org/wiki/OpenOffice_NetBeans_Integration.

• Components can integrate themselves into the user interface, using simple configuration files. You can add new menus, toolbar items, and help items for a component simply by editing XML configuration files.

• Components are deployed with the Extension Manager. See chapter Extensions.

• Last but not least, this is not the only way to add features to the office. Learning how to write components and how to use the Apache OpenOffice API at the same time teaches you the techniques used in the Apache OpenOffice code base, thus enabling you to work with the existing Apache OpenOffice source code, extend it or introduce bug fixes.

Components are the basis for all of these extensions. This chapter teaches you how to write UNO components. It assumes that you have at least read the chapter First Steps and—depending on your target language—the section about the Java or C++ language binding in Professional UNO.

Content on this page is licensed under the Public Documentation License (PDL).