Saros Components
Saros, which can be used as the basis for RCP applications, is constantly being further developed and adapted to the latest Eclipse RCP releases. In the following, the components in Saros are explained in greater detail.
Application Lifecycle Support
The Application Lifecycle Support components make it possible to execute
optional or user-defined jobs while the application is being launched or
closing. The action (order, parallelism) can be configured. A job can initiate
the closing or restarting of the application (configuration error, application update).
An example of a lifecycle: (start) – update configuration – update application –
login dialog – (user interaction) – logout - (stop)
Automated Update
The Automated Update components expand the Eclipse update mechanism. It has to
differentiate between an update of the configuration of the application and an
update of the application itself. A concept for updating a configuration (for
example, that of the lifecycle) does not yet exist in Eclipse. Updating is
executed without user interaction in contrast to Eclipse RCP. It must be done
before the first service call and is therefore already configured as a
lifecycle job. The communication parameters of the automated update mechanism
can be configured without having to resort to programming.
Remoting [Client/Server]
The Remoting components are responsible for communication between the client
and the server. These components can be arbitrarily configured and expanded.
For instance, the abstraction layer within the client can be used to harmonise
and make compatible the data flow between any source and the rest of our components.
This is an overview of the most important features:
- synchronous and asynchronous communication
- several communication channels each with its own security level
- configuration of the protocol and handlers in the plug-in
- configuration of communication parameters in configuration files
- session handling with callback fur security components
Security
The Security components provide GUI components for various authentication
processes. Both single-level processes such as user and password, and
multi-level processes such as user-password-secure ID are implemented. The
implementation is fully JAAS compatible.
DataBinding
The DataBinding components are a central element of every modern Java client. Eclipse
RCP provided no assistance for an efficient and practical linking of data and
model in release 3.1 and in 3.2, this was only rudimentary. The better DataBinding
links the model with the widgets, the faster, more error free and maintainable
an application can be developed. The following requirements are fulfilled
through the DataBinding components:
- synchronisation between model attributes and widgets
- conversion between model attributes and the values to be displayed (for example, date to string or string to date)
- formatting of the values to be displayed (for example, the number of decimals for amounts)
- initiated in the validation of the model and marking the erroneous widgets, where validation is handled by the business logic
- showing warnings dependent on the content of the model
- dependencies among widgets (refresh, enable/disable, visibility)
- context dependencies (automatic activation/deactivation of widgets depending on the role of the user)
- consistent separation of the visualisation from the business logic
Custom Widgets
The Custom Widgets components include various complex widgets which are needed
repeatedly. Examples of this are a calendar widget for selecting a date or a
combined text-listen widget, which guarantees on the one hand fast and on
the other secure entry of predefined values.
Data Access Cache
The Data Access Cache (DataStore/Repository) component is an intelligent cache
for model objects. "Intelligent" because it automatically analyzes
the results from service calls and can update itself. If a model object is
changed through a service call, interested observers will be informed. The cache
recognizes model-object trees with references as links (1:1 or 1:n references) and
sends delete, update or add events when the references of a model are changed.
Interested observers can register for such events.
The cache guarantees access at all times to the model object,
which can be uniquely identified with the GUID. Every model object appears in
the cache only once. One can configure the cache in a way that the reading of a
model object or a reference can be triggered from the server (synchronously/asynchronously)
as needed.
Configurable Tree/Table/Treetables
Trees, tables and combined TreeTables are very complex GUI components and thus difficult
to programme. To relieve programmers and guarantee the greatest possible
efficiency in assembling and disassembling these components, Saros offers
configurable trees and tables as well as a combination of the two (TreeTable). This
does not replace the concepts of Eclipse but rather is built on them. For
example, a table can be configured completely in XML with various contents using
the Eclipse extension mechanism. This also applies for trees and TreeTables.
Besides configurability, sorting is also possible across several columns. It is
also possible to hide or show columns via the GUI without additional
programming.
These user-specific modifications are made persistent through an
Eclipse mechanism. Resetting the configuration modification by the user is
possible at all times. If the data must be loaded asynchronously, which is
necessary for a user-friendly GUI particularly when there is a large quantity
of data, these GUI components work together with the data access cache. The
data is loaded from the server asynchronously as needed and visualized. Trees,
tables and TreeTables are areas in Eclipse which will be expanded considerably
in the future. Taking this into consideration, a generic, central
implementation of these GUI components is important in order to keep pace with
the progress of the Eclipse platform with minimum effort.
Role-Based GUI
The concept of a role-dependent GUI is not present in Eclipse. However, one can
use the activity mechanism in Eclipse to implement this concept. Together with
DataBinding, we can activate or deactivate all possible widgets based on their role
with the role-based GUI components.
Configurable Editors/Wizards/Views/Dialogs
The configurable editors, wizards, views and dialogs all have in common their
ability to show random content (composite content), which is generated
independent of the surrounding container and defined as an Eclipse extension in
XML. For example, the contents of wizards, in other words the individual pages,
can be shown in editors along with tabs. The reusability and the simple, very
compact presentation of this content is the focus and thus make it possible to
quickly develop many GUI layouts. Containers such as wizards, editors and views
are still defined as standard Eclipse extensions in XML. This makes it possible
to bring together the potential inherent in Eclipse and the needs for an
efficient and yet still high-quality development.
Plugable Formatters/Converters/Label Providers
These components make it possible to reuse formatters and label providers not
only in Java code but also in other configurable GUI components (such as trees,
tables and TreeTables). This means that you can ensure that the graphic
depiction of a model object or one of its attributes is programmed centrally at
one location even if you are dealing with the title of an editor, a tree node
or an entry in a table.
Error Handling
Error Handling runs through all components and is usually difficult to
implement when it is not planned for from the beginning. With the projectware components
described above, error handling was weighted accordingly and is found again at
various locations. Beginning with remoting, where any number of error handlers
can be inserted, to DataBinding, where the correct text must be shown for a
validation error on an attribute as well as for the corresponding GUI element.
It also must be possible to assign errors, which occur during a service call,
to the corresponding GUI element.
Enterprise Business Object (EBO) Framework Libraries
The EBO Framework Libraries are not dependent on Eclipse and primarily contain
interfaces and base implementations, which guarantee the generic aspects of
model objects. Such generic aspects are, for example:
- generic access to attributes
- generic access to references
- generic access to an attribute, which is only reachable via a reference for example
- generic validation and validation exceptions
