Below an overview is given about the rich client platform used by MIRA.

RCP in MIRA provides the programmer to rapidly create reusable components that benefit from proven and tested features of the core system. It consists of a workbench with multiple views, editors and perspectives and is built on top of a dynamic plugin management system, that allows to load additional plugins at runtime. Based on a minimal set of plugins the user is able to develop rich client applications.
Before we start let us define some concepts and interfaces that are used by our RCP system.

Components

Workbench - The main window that can hold multiple WorkbenchParts.
WorkbenchPart - A component within the Workbench. There are two main types of WorkbenchParts ViewParts and EditorParts.
ViewPart - A view is typically used to display information or properties. Views are shown as dock windows. Only one instance of a particular view type may exist within the Workbench. This policy is designed to simplify the view management for the user.
EditorPart - An editor is typically used to edit or browse data or objects. Editors are shown as tabbed MDI windows. In contrast to views, there may exist multiple instances of a certain editor type.

Interfaces and communication

There are a few interfaces used for communication between WorkbenchParts and the Workbench itself.

IWorkbenchPart - Each WorkbenchPart gets notified upon activation and de-activation by the user. Additionally, it implements the IAdaptable interface.
IPartListener - Each part can implement the IPartListener interface to get informed about activation/de-activation of other Editor- and ViewParts.
IAdaptable - Adaptable objects can be dynamically extended to provide different interfaces (or "adapters"). Adapters are created by adapter factories. For example, the PropertyView (ViewPart) will be informed via the IPartListener interface about the currently active WorkbenchPart. It will "ask" this part for an adapter to the PropertyView that can be used to edit the part's properties.

View and Editors

As mentioned before, there are two main WorkbenchParts defined - ViewParts and EditorParts.

ViewParts

The ViewPart base class provides basic functionality of a dockable widget. It takes care of informing the Workbench about construction and destruction and provides a context menu in the titlebar where the user can add actions to. When implementing a ViewPart, the user needs to overwrite the createPartControl() method to create the widget that is shown by the view. In addition to the ViewPart members, the PageViewPart base class implements the IPartListener interface. It provides a stacked widget that can show different content based on the currently active/focused WorkbenchPart. When deriving from that class, the user must implement two methods.

createDefaultPage() for creating a default widget that is shown when no WorkbenchPart is selected or the active WorkbenchPart does not implement a suitable adapter.
createPage() - this method is called every time the current WorkbenchPart changes. The active WorkbenchPart can be queried if it implements a particular adapter. If it does, the part's page will be displayed on top of the stacked widget. The PropertyEditor is an example for a PageViewPart. It will show a property editor for the current WorkbenchPart if that one supports the PropertyViewPage adapter.

For more information and examples see ViewParts.

EditorParts

The EditorPart class implements the functionality of an MDI sub-window. The user needs to implement the createPartControl() method where the content is created that is shown in the MDI window.

An example for an EditorPart is the VisualizationView. This part is specialized in the derived classes Visualization2DView, Visualization3DView and VisualizationTextView. These editors can display multiple visualization plugins at once in an editor window. For more details see VisualizationView editors.