MainAdvantages

Advantages of using RCPForms

Eclipse was not originally built with Forms-based applications in mind; in fact a lot of the advanced features just showed up with Eclipse 3.3. Programming Forms using pure Eclipse API is tedious and error-prone; a lot of problems will show up e.g. handling a null value in combo boxes, managing radio groups, setting up a simple table editing a bean. RCPForms has already solved all these problems for you, you will have a fast ramp-up phase in your project and ensure that all developers use the same way of creating forms and all hacks and workarounds around internal Eclipse problems will be hidden in the framework.

Anyway, it is pure Eclipse, so if the framework does not offer a solution for your fancy UI problem, you can still fall back on Eclipse API's without colliding with framework concepts.

RCPForms offers several advantages over directly using JFace, SWT, Databinding, and Eclipse UI Forms:

• well documented, all documentation targeted at getting your forms up and running fast and clean
• much more compact code: since most repetitive code is hidden in the framework, source code lines are reduced by up to 80% to code a form
• example code and snippets: Delevopers learn fastest by example code; thus emphasis is put on examples demonstrating different complex forms
• run with SWT and RCP: you can jump-start your form parts as java application, thus improving edit-compile-link cycle, test performance and later embed them into an RCP application running on the OSGI runtime
• best practices: JFace offers lot of different ways to achieve the same thing, RCPForms encourages you to use only one way, which is best practice to do it. A lot of experience from big software projects has gone into the decision which practice is best
• less bugs: since all forms use the same way to create widgets, bind them, and so on, most error-prone code is hidden in the framework; thus there are less bugs in your forms
• 100% Eclipse Standard: it is all built on Eclipse Standard; widgets are wrapped SWT widgets, Viewers are JFace viewers, Binding is done using standard eclipse data binding
• enhanced features: rcpforms fixes several bugs or difficult to use API from Eclipse by wrapping it into an easier to use method or class. Still all Eclipse API is accessible and can be used to get all the features
• model independence: you can use any data model with your forms by creating a suitable model adapter. For Java Beans and EMF standard adapters are provided
• enriched models: if your models contain additional information which can be used by the UI, you can make it accessible via a model adapter; e.g. field lengths to be used by validators or mandatory
• proven code base: rcpforms is created from the experience of several big projects using RCP and EMF, thus you get all the solutions for problems which were solved in these projects for free

Example Application

The picture shows the example application which comes with rcpforms; all controls are bound to a bean and will sync data in both directions when they are changed.
The table is editable, there are mandatory field markers, and error markers will show up if validation rules are violated.

All controls support null value handling, combos and radio groups will automatically be filled if you are using enum-like datatypes in the model via range adapters.
Interested in the source code ? The package containing all models and form parts (each section is a separate part) can be found here;
the source for the sections: Section 1, Model Section 1, Sandbox3Section, Sandbox Table Section.