Developing Rich Client Apps with Eclipse

Most developers would be familiar with the Eclipse IDE, which is a powerful
development environment for building JEE and Web applications. Eclipse is
available as an integrated development environment for Java, Java EE developers
and also for C/C++ developers as a separate package that includes the IDE along
with the necessary tools and support for frameworks that any developer would
need. Again here is a package dedicated for RCP/Plug-in developers, who want to
create either Eclipse Plug-ins or Rich Client Applications. This distribution
includes the complete SDK, developer tools, XML editors, and the Eclipse
Communication Framework. The Eclipse Rich Client Platform (RCP) empower the
developers to create applications that will be based on Eclipse framework and
will be re-using functionalities and coding patterns which are inherent to
Eclipse. The important characteristic of Eclipse is that it's based on a Plug-in
architecture. Plug-ins themselves are the smallest deployable and installable
software components of Eclipse. The whole Eclipse IDE itself is built as a
number of plug-ins that are dependent on each other. The minimal set of plug-ins
required to build a rich client application is collectively known as the Rich
Client Platform (RCP).

Getting Started

To start developing plug-ins for Eclipse or for creating Rich Client
applications, one must download Eclipse for RCP/Plug-in Developers form the
Eclipse website. The only prerequisite before installing Eclipse RCP is that
Java SE6 must be installed before Eclipse RCP installation. To build an RCP
application in Eclipse, it requires a main program, perspective and a Workbench
Advisor. The RCP application extends the class org.eclipse.core.runtime
.application, and this represents the main program for the application. While
the perspective is extended from org.eclipse .ui.perspective class. The
Workbench Advisor is the component which controls the appearance of the
application. We used the latest Eclipse Ganymede for this article but the same
procedure can also be used for earlier versions of Eclipse like Europa. Once the
Eclipse RCP installation is done, you can start creating your first RCP
application. Start Eclipse RCP and assign directory to be used as the Workbench.
Now in Eclipse, select File > New Project and from the list, select the option
'Plug-in Project' and click on 'Next'. On the new Plug-in Project window, name
the project as 'DemoRcpApp' and after clicking Next on the following screen
select the 'Yes' option for Rich Client Application question. After clicking
'Next' button, select the 'Hello RCP' as the template for the project and click
on 'Next'. For the Hello RCP Project window, check the option for 'Add branding'
and click on 'Finish'. As a result, a complete project structure will be
created. Now when you click on the 'Launch an Eclipse Application' link from the
Overview page, the DemoRcpApp is displayed after a initial splash screen. The
splash screen appears as we have opted for adding branding to the application.

Adding commands and menu to app

Here, we will add a menu to the blank application and a command that will
close the application. And for that, the application would require two more
extensions, one each for command and other for the menu. For adding the
extensions, open the Extensions tab of the plugins.xml view. When you click on
the 'Add' button, a New Extension wizard opens where you have to select the
org.eclipse.ui.commands plugin as the Extension Point and click on 'Finish'.
You'll notice that a new extension is added to the Extensions list. Right click
on the newly added extension, select New > command, and set the ID as exit.com
mand, give name as 'Exit' and most important of all, set the defaultHandler as
demorcpapp.handler. ExitHandler. When you click on the defaultHandler link, a
New Java Class window opens which will create the Handler class for the
application. For this Handler class, set the superclass as
org.eclipse.core.comma nds.AbstractHandler. From the Package Explorer view,
expand the DemoRcpApp project and open the ExitHandler.java class. We'll
override the execute() which will perform the action of closing the application.
Change the execute method as follows:

To create a Rich Client application, you should ensure that the option highlighted in the above visual is selected as Yes.

public Object execute(ExecutionEvent event) throws
ExecutionException {

HandlerUtil.getActiveWorkbenchWindow(event).close();

return null;

}

When the DemoRcpApp project is created by wizard, the overview of plugins.xml is displayed and the app can be tested by clicking on Launch hyperlink.

Now we'll add a menu where we will use this command. Following the previous
steps again, add the org.eclipse.ui.menus as a new Extension Point. Right-click
on this menu extension in the Extensions list, and select New > menuContribution.
Set the locationURI as menu:org.eclipse.ui. main.menu and then again right-click
on menuContribution and select New > menu and label the menu as 'File' and give
id as “mymenu”. Now we can add command to the menu file by right-clicking on the
menu File and selecting New > Command. Pass the command Id as exit.command and
give label as 'Exit'.

To add extensions, select the Extensions tab of the plugins.xml file from the project tree and add Exit command to the File menu.

Running the RCP app

To execute the application, right click on the plugin.xml under the
DemoRcpApp project in the Package Explorer pane and select Run As > Eclipse
Application. The blank application which appeared earlier will now be having a
File menu in the toolbar strip. And when you click on 'File', another sub-menu
appears as 'Exit', and clicking on Exit option closes the application.This was
how we can start using Eclipse for Rich Client application building using most
of the in-built features of Eclipse framework itself.