A Tutorial based on the Eclipse Rich Client Platform. ( Jean- Michel Lemieux and Jeff McAffer. IBM Rational Software. Rich Client Application . While the Eclipse Platform is designed to serve as an open tools platform, it is architected so that its components can be used to build just about any client. SAVE k. for easy Reference The Eclipse Rich Client Platform ( RCP) is a platform for building and deploying rich client applications. It includes.

Eclipse Rich Client Platform Pdf

Language:English, French, Japanese
Genre:Academic & Education
Published (Last):21.11.2015
ePub File Size:23.66 MB
PDF File Size:8.36 MB
Distribution:Free* [*Sign up for free]
Uploaded by: HARRIS

A Rich Client Platform needs a strong component model with the following major characteristics: ✓ Specified interfaces: a component must declare its public. PDF | SpinRCP is an integrated development environment for the Spin SpinRCP is implemented in Java as an Eclipse Rich Client Platform (RCP) product. Eclipse's Rich Client Platform, Part 1: Getting started. Page 1 of 30 Essentially, the RCP provides a generic Eclipse workbench that developers can extend to construct their own heading graphics, and two PDF files. Our ability to generate.

Usually, plug-in name follow Java's package naming conventions. RCP applications should be targeted to run on a particular version of Eclipse, here we choose to run on Eclipse 3. The next page in the project wizard allows you to set some important attributes of your plug-in. This page allows you to specify whether your plug-in will make contributions to the UI. In the case of RCP plug-ins, this will usually be true. You can choose whether to create your own RCP application, or to create a plug-in that can be integrated with existing Eclipse installations.

The following table summarizes other plug-in settings and what they mean for your application. MF file for your project at any stage. MF file is the centre of your RCP plug-in.

Here you can define the attributes, dependencies and extension points related to your project.

In addition, you may have a plugin. The contents of both these files are show in the plug-in manifest editor. The Overview tab in this editor allows you to change the settings described earlier in the new project wizard.

It also provides a shortcut where you can launch an Eclipse application containing your new RCP plug-in. The Dependencies tab describes how this plug-in interacts with others in the system. All plug-ins which you are dependent on will need to be added here.


The Runtime tab allows you to contribute packages from your own plug-in to others to use or extend. You can also add libraries that don't exist as plug-ins to your own project in the Classpath section. While you may change your build path through the Dependencies or Runtime tab, changing dependent plug-ins in the Java Build Path of the project properties tab will not reflect properly in the plug-ins manifest. The Extensions tab is where you go to define how this plug-in builds on the functionality of other plug-ins in the system, such as for adding menus, views or actions.

We will describe these extension points in more detail in the relevant sections. The Extension Points tab allows you to define your own extensions for other plug-ins to use. This is a layer that wraps around the platform's native controls. JFace provides viewers, in a similar way to Swing, for displaying your data in list, tables, tree and text viewers. One of the first things that you will want to do with your RCP plug-in is to provide a menu, establishing its existence with the Eclipse application that it is built into.

To do this, as with any additions to our plug-in, we start in the Extensions tab of the plug-in manifest editor. Up to Eclipse 3. To do this we use the org. Simply click on the Add First, you will need to associate this command with a category.

Categories are useful for managing large numbers of commands. From the org. The required fields are a unique ID and a readable name. The important attributes for a command are listed below. To create a menu, you will first need to add the org. The required attribute for the menu contribution is it's locationURI, which specifies where the menu should be placed in the UI.

This URI takes the format of [scheme]: The following attributes exist for each command:. Defining a toolbar item is a similar process. Create a new command under the toolbar similar to the menu item approach. The final extension point required for the menu is org. A handler has two vital attributes.

The first is the commandId which should be the same as the command id specified in the beginning. As you can see, this is the glue between all three parts of the menu definition. You will also need to create a concrete class for this handler, which should implement the org. IHandler interface. Clicking on the class hyperlink on the manifest editor will pop up a New Class Wizard with the fields autofilled for this.

Finally, you will need to define when this command is enabled or active.

This can be done programmatically in the isEnabled and isHandled methods. While this is easiest, the recommended approach is to use the activeWhen and enabledWhen expressions in the plug-ins manifest editor which avoids unnecessary plug-in loading.

Once you have added in an extension point plugin. All extension points can be added through the manifest editor, or in XML format through this file. In an RCP applications Views are used to present information to the user. A viewer must implement the org. IViewPart interface, or subclass org. Figure 4: An illustration of the difference between perspective, editor and view.

To create a View, you will need to add the org.

RCP 3 Quickstart + Compatibility Layer Outline

In order to group your views, it is useful to create a category for them. The code behind the view is in a class that extends org. All controls are created programmatically In the createPartControl method in this class. To facilitate lazy loading, a workbench page only holds IViewReference objects, so that you can list out the views without loading the plug-in that contains the view definition.

It's good practice to store the view's id as a public constant in your ViewPart implementation, for easy access. To facilitate loose coupling, your ViewPart should implement org. You will also need to register this as a selection listener for the entire workbench:. An editor is used in an Eclipse RCP application when you want to create or modify files, or other resources. Eclipse already provides some basic text and Java source file editors.

In your plug-in manifest editor, add in the org. Editors implement the org. IEditorPart interface, or subclass org. Like views, to facilitate lazy loading, a workbench page only holds IEditorReference objects, so that you can list out the editors without loading the plug-in that contains the editor definition.

Perspectives are a way of grouping you views and editors together in a way that makes sense to a particular context, such as debugging. To create a perspective, you need to extend the org. The class driving the perspective implements org. To group many views together in a tabbed fashion, rather than side by side, IPageLayout. When running your application you need to ensure that you have all required plug-ins included.

Do this by checking your Run Configurations.

Go to the plugins tab and click Validate Plug-ins. If there are errors click on Add Required Plug-ins to fix the error. Now that you have created a perspective and a view for your RCP application, you will probably want to provide some preference pages.

Getting Started with Eclipse RCP

To provide preference pages you will need to implement the org. While the preference page class will implement org. IWorkbenchPreferencePage, it is useful to extend org. FieldEditorPreferencePage as it provides createFieldEditors method which is all you need to implement, along with the init method in order to display a standard preference page. A complete list of FieldEditors is provided in the org.

Preferences for a plug-in are stored in an org.

IPreferenceStore object. You can access a plug-ins preference through the Activator, which will typically extend org. Each preference you add to the store has to be assigned a key. Preferences are stored as String based values, but methods are provided to access the values in number of formats such as double, int and Boolean.

While preferences are used to display the overall preferences for the plug-in, property sheets are used to display the properties for views, editors or other resources in the Eclipse environments. By hooking into the Properties API, the properties for you object will appear in the Properties view usually displayed at the bottom of your Eclipse application. The Properties view will check if the selected object in the workspace can supports the org.

IPropertySource interface, either through implementation or via the getAdapter method of the object. Each property gets a descriptor and a value through the IPropertySource interface. All good applications should provide some level of user assistance.

Add a number of toc items to this extension point, the only mandatory attribute for each toc entry is the file that contains the table of contents definition.

To see a quick example of what help content should look like, choose the Help Content item from the Extension Wizards tab when adding to the plug-ins manifest.

Each topic entry should have a link to a HTML file with the full content for that topic.

About this book

The above XML extract from a table of contents file illustrates this. There is also the choice to use the definition editor for help content. This will open by default in Eclipse when choosing a toc file.

Another user assistance mechanism used in Eclipse is a cheat sheet, which guides the user through a series of steps to achieve a task. This presents you with an editor to add an Intro and a series of items, with the option to hook in commands to automate the execution of the task. Skip to main content Skip to table of contents. Advertisement Hide.

Front Matter Pages i-xv.

Foundations of Eclipse RCP. Pages A First Glimpse. RCP Basics. User Interface Concepts. Help Support.

Automated Updates. Back Matter Pages The book explains the technical concepts easily and in an engaging way. The text provides plenty of source code and images as learning aids.This method is useful to register any window listeners.

The Character within the label to be assigned as the mnemonic. A complete list of FieldEditors is provided in the org. SAVE Click the Apply button.

MARYLYNN from Las Vegas
I do relish reading comics upliftingly. Look through my other articles. One of my hobbies is mountainboarding.