Compile-Error with RAP Target

So I installed the ObjectTeam Development toolkit and created a bundle which has only one purpose: Overriding the #makeActions method in the ApplicationActionBarAdvisor for instantiating an About-Action which is compatible to RAP. Therefore you have to “reimplement” the whole method-body, which can be difficult, especially on complex methods which probably referencing classes that are not visible.

Code for replacing a method

Afterwards created a launch config, set the OT/Equinox flag and voila:

RAP Mail-Example with untouched ApplicationActionBarAdvisor

This approach is probably a bit complicated but has a big advantage: You don’t touch your RCP code. Happy Singlesourcing

Download

Download the Example as Eclipse-Project - OT Development Environment required (130 Kbyte)

Watch the video “RIM in 5 minutes” to get an overview of the application and its current implemented features.

To achieve these goals we’ve chosen the Eclipse Platform and the RCP Framework because of its flexible and extensible behavior, customizing and extending the platform can be done with the standard eclipse mechanisms like extension points and OSGI-Services. Especially the extension of the current feature-set is an important requirement.  Whether you want to add new desktop features, new business specific information-structures or connect RIM to your own proprietary data repository the application should provide minimalistic interfaces to plug-in your functionality.

Roadmap

The development started 1 year ago and you can download a nightly build with a predefined set of information types and repository connectors. The first stable release is scheduled for January 2010, with a stable platform and a well-mixed set of information types and repositories, for an overview see http://remus-software.org/feature-overview.

See RIM @ Eclipse DemoCamp Leipzig

I’ll talk at the Eclipse DemoCamp in Leipzig (June, 23rd) about RIM. If you want to know more about the project this event is a good possibility

Get started

We would be very happy if you could download a nightly build and try RIM. Feedback, Feature-Requests and Bugreports are much appreciated. Here are the links:

Website: http://remus-software.org
Issue-Tracker: http://remus-software.org/jira
Nightly-Builds: http://www.remus-software.org/bamboo/browse/RCP-NIGHTLY/latest/artifact

Team, Resources, Workspace, Filesystems

If you use Eclipse as an IDE you know the general workspace for requesting your data (sourcecode) you want to edit. You need to create a remote repository location, checkout the data, browse through the data in your workspace, open a file, etc. It is worth mentioning that the integration of workspace data is one of the best ways to integrate a domain-specific datamodel in your RCP application and it also is the “eclipse-way” to manage data. Then there is the Resource-API with the ability to implement a virtual filesystem, an excellent ways to notify of Resource changes and finalyy you have the project-builder that allows you to built up your ows RCP - specific data model and validating the state of your model.

On the other hand there is the Team-API. The team API offers you the deep integration of data-synchronization with a remote data store and your IResource-based workspace data. So the Team-API is more of a framework, that handles just the workflow and the integration into a team-provider implementation such as the CVS. The Subversive project has also an implementation for SVN repositories.

Overview Resource & Team API

What has this got to do with RCP?

Perhaps the question is badly worded, to be more specific: “What differs in data handling regarding a Development Tool and your domain specific RCP?” - Not so much really. Instead of editing Java models (Class, Methods,…) you’re editing domain specific data. The rest stay pretty much the same. All models need to be persisted and sometimes models need to be synchronized with a remote repository. So why not using the same mechnanisms to synchronize this data with the Team-API?

Complexity

A common problem of Reusing Eclipse-Components is that the complexity of application workflows cannot be hidden from the user (this should be also an issue while developing e4). From a developers perspective it would be greate to have hundreds of possibilities to customize setting, from an adapter’s perspective who develops a RCP of a limited scope for a non-technical target user (I develop RCPs for marketing & sales people) this is always an issue. The hitch is that in nearly every case of reusing Eclipse components you have to patch the plugins coming from Eclipse. Let’s take a simple example: Update sites in RCPs - There will never be the reqirement that an user can add Update-Sites. A typical user wouldn’t normally know what an update-site is, namely an application internal component regarding RCP development.

The same issue arises when you integrate the team framework. A very good method for obtaining data is to use SVN, but the user has no idea where the data originally comes from. It’s simply unacceptable that the user should have to create repository locations, navigating through trunk and branches, etc. As a RCP developer there is always a consideration of how much complexity should be passed to the user. In the most cases you have to strip the original UI a lot.

The example application

Meant for a prototype I’ve developed a very simple application that allows you to define via Extension points repository providers, which typically come from another remote application, which returns the user specific repositories (e.g. via WS-Call). The data itself is located within a version control system. These repositories are checkedout using an installed team provider implementation and are stored into your local workspace as a project. After checkout you can use the mighty Resource-API to manipulate the data or organize the representation of the raw data to suit your domain specific usecase.

Defining Repository provider via Extension Point

Domain specific representation of different repositories

Editing my Domain specific data

Conclusion

Combining Resource API with Team Integration is an easy and elegant way to handle data synchronizations even for non technical RCP Applications . But it should also be mentioned that the effort fo stripping the UI is immense. In general you can not use the normal Team UI components for your non technical user-group. And then there is a fact that the controlling of accessible data is managed by the application itself or a remote system not by the user.

Appendix

Just to round off this article, I’d like to share a photo I took at the entrance of the Convention Center at EclipseCon for all those who missed the “Netbean-girls”.

Download

Download the CVS Team Project-Set
Download the Example as RCP (23 Mbyte)

Thanks for attending.

Download

Powerpoint presentation (0,7 MByte)
Flash-Eclipse Communication Prototype Source-Code (5,5 MByte)

Installing the Workspace Model

As already mentioned in my last posting we are building an application that uses OSGi bundles to distribute information, i.e. read-only information. The requirement in most cases, however, is to be able to supplement this information. Our example application allows users to append further documents to an information unit defined by an Extension Point. These are saved to the workspace and linked to the information units using the Eclipse Adapter mechanism.

These are the revelant points to consider here:

1. Finished implementations of file operations and their integration in the Eclipse Framework
2. Support for asynchronity and parallelism
3. Listener for file operations, project builder
4. EFS support for alternative file systems

Data model and adaption to Workspace model

Markers

Markers are useful extensions that come in handy to persistently associate meta data with resources, such as files contained in the Workspace. You can find this feature in the org.eclipse.ui.ide plugin. Markers are even more helpful when it comes to storing meta data that cannot be represented in the EMF model. In our example application, markers are created while we overwrite attached documents, and these markers are mapped to the pertaining data model and displayed.
Decorators are used to superimpose the markers on the rendered objects of item providers generated by EMF Edit. The only drawback is that in addition to the EMF notification mechanism, you also have to implement an IResourceChangeListener, which updates the revelant model object in the viewer when the marker is created.

EMF data are mapped to resources and markers (visualized with a tooltip)

These markers don’t differ from the more common markers such as the compilation warning marker – as you may see if you compare them with those in the Warning View that Eclipse SDK developers are familiar with.

Warning View: Often seen in the Eclipse SDK

More Contributions

Another great advantage is that other typical platform plugins can contribute functions by registering the Adapter functions in the context of my application-specific object. A typical example is the org.eclipse.compare plugin which makes available application-specific EMF generated data objects for the adapted objects via a context menu.

Context menu for contributions from other bundles

This contribution of additional function by other plugins – a major attribute of the Eclipse platform – can clearly spoil the desired effect in reduced user interfaces. Essentially, you might have bundles contributing entries, which you want to suppress. How to implement this function interception by writing so-called Transformer Hooks will be explained in a later posting.

Outlook

In my next posting I will be primarily taking a closer look at data management at runtime. A prominent issue will be the synchronization of online data that cannot be distributed as OSGi packages. I will also talk about the Update Manager and – server-side - Extensions. By the way, feedback about the points mentioned here is always more than welcome.

Download

Download the CVS Team Project-Set

]]> http://www.richclient2.eu/2008_03_13/developing-data-centric-rcp-applications-part-iv-%e2%80%93-reuse-of-ide-features/feed/ http://www.richclient2.eu/2008_03_07/developing-data-centric-rcp-applications-part-iii-%e2%80%93-the-model/ http://www.richclient2.eu/2008_03_07/developing-data-centric-rcp-applications-part-iii-%e2%80%93-the-model/#comments Thu, 06 Mar 2008 22:25:33 +0000 Tom Seidel Eclipse RCP http://www.richclient2.eu/2008_03_07/developing-data-centric-rcp-applications-part-iii-%e2%80%93-the-model/ If we want to provide a data structure, we need to create

1. a meta model using the EMF
2. an extension point schema.

Data Structure

After taking a closer look at the data structure, you may want to classify them as follows:

1. Core data (PDF files)
2. Core meta data (meta data describing a PDF file)
3. Data generated by users

Then there is the data needed internally for configuration purposes, such as available update sites, locally installed data vs. data to be accessed online etc.

Thus, the model generated with the EMF is divided up into three logical parts:

1. Application-specific data model
2. Data model for handling content structures
3. Meta data model

EMF Ecore Files

Extension Point Definition

After generating the corresponding classes, you can go on to define the extension points which describe a specific data unit.. This data will be not be editable later and will be distributed via an update server.Note that even at this early stage you are able to generate content units based on PDE tooling. The advantage is that very early on in the process you can generate productive data, and this does not necessarily require the expert knowledge of a programmer.Furthermore, you can flexibly respond to changing data structures.

EMF Edit

In addition, the EMF Edit framework offers adapters that enable developers to represent the generated data model in an Eclipse application. This saves having to implement Jface Viewers, which means enormous time savings compared with the traditional approach to Viewer generation.

Application status

At this point we have an application which allows us to browse the information units registered as extension points.

Content Definition with the PDE (plugin.xml)

First screenshot after Model-Creation

Outlook

In the next sequel we will focus on how to use functionalities which is shipped with the IDE plugins of Eclipse, and how to use several functionalities under the hood; so the next articles become more code orientated.

Download

Download the CVS Team Project-Set

]]> http://www.richclient2.eu/2008_03_07/developing-data-centric-rcp-applications-part-iii-%e2%80%93-the-model/feed/ http://www.richclient2.eu/2008_03_05/developing-data-centric-rcp-applications-part-ii-%e2%80%93-architecture/ http://www.richclient2.eu/2008_03_05/developing-data-centric-rcp-applications-part-ii-%e2%80%93-architecture/#comments Wed, 05 Mar 2008 19:40:07 +0000 Tom Seidel Eclipse RCP http://www.richclient2.eu/2008_03_05/developing-data-centric-rcp-applications-part-ii-%e2%80%93-architecture/ The platform approach has been a major boost for the success of Eclipse. This is mainly due to two key attributes:

1. Eclipse uses an OSGi Runtime (Equinox) which allows platform components to be added, removed or updated. Major advantages compared to traditional Java libraries are improved control mechanisms for dependencies between components, release versioning and the component lifecycle within the OSGi container.
2. The Extension Point Registry: This allows a formal definition of components that can be processed in an application. An interface implemented as an extension point schema is created that enables any developer to contribute and expand it.

These two characteristics will come in handy when we start implementing the example application.
Information units may be bunched together as OSGi bundles and then remotely installed in the application as OSGi bundles. These bundles only contain raw content and application-specific structural descriptions for identifying the content and integrating it in the application context. Identification is accomplished via the extension registry, which essentially means that these content bundles contain extension points with information enabling the application to read the data and make it available to the user.

There are three tremendous benefits to this approach:

1. The bundle lifecycle is the same as the application-specific content lifecycle. In other words, the state of my application-specific data is mapped to that of installed bundles. The OSGi Runtime functionality is also used for installing, uninstalling and updating applications. In addition, content dependencies can be defined at OSGi level.
2. By using extension points to describe information units, you can leverage the advantages of a highly flexible fully implemented “standard” that enables the access as well as the representation and processing of these information units. Implementation efforts remain only minimal.
3. The PDE with its tools for bundle (plug-in) creation provides a complete environment for the creation of new content units. In order to implement this function, the PDE just needs to be supplemented by a content-specific layer.

Example

Ok, let’s cut a long story short. How can this be demonstrated? – We want to create an RCP application for a centralized approach to PDF document distribution as the end point. These PDFs will be visualized in the application for users and tagged with metadata allowing the data to be put in the context of the process currently employed by the user. Although the PDFs will be read-only files, users will be able to create further data associated with the provided files and distribute them. We have also envisioned a basic collaboration tool on the information level.

Outlook

In the next sequel we will get started on the actual implementation. We will start off by generating a model reflecting the requirements, which will be done using the EMF. Then we will go on to create an extension point for PDF documents.

We will also discuss some aspects concerning a specific use case, e.g. information units refer to PDF documents and additional data which can be associated with PDF files. Let me just point out that this will be a simplified implementation.

Stay tuned.

]]> http://www.richclient2.eu/2008_03_05/developing-data-centric-rcp-applications-part-ii-%e2%80%93-architecture/feed/ http://www.richclient2.eu/2008_03_04/developing-data-centric-rcp-applications-part-i-%e2%80%93-intro/ http://www.richclient2.eu/2008_03_04/developing-data-centric-rcp-applications-part-i-%e2%80%93-intro/#comments Tue, 04 Mar 2008 21:48:29 +0000 Tom Seidel Eclipse RCP http://www.richclient2.eu/2008_03_04/developing-data-centric-rcp-applications-part-i-%e2%80%93-intro/ Eclipse-based applications targeted at developers’ tasks and needs are proliferating. But what does Eclipse have to offer to other user groups, to be more precise non-technical user groups in particular in combination with Rich Client Platform applications?
Just take a closer look at your daily work, and you may probably realize that the greater part of your working routine is spent doing the research and gathering information required for your job - no matter how this information is structured.

What’s the idea behind this series?

First and foremost, the intention of the series is to show how an Eclipse RCP can be used to quickly and efficiently provide the staff of an enterprise with the up-to-date information relevant for their work. How easily this can be achieved will be demonstrated using a typical application. Last but not least, writing this article will help me get my thoughts sorted and to compile all the key information on EclipseCon that I will present during a talk at some later stage.

A short overview of the topics to be discussed:

• Preliminary considerations
• General Eclipse-based architecture
• (EMF) data model
• Use of Eclipse IDE components
• Data management
• Data updates and synchronisation
• Data processing
• UI stripping
• Collaboration

Distributed Information Repositories

A surprising number of enterprises on a more web-focused infrastructure consisting of context-dependent web applications and portals that enable users to obtain information. And for these there is an array of applications for almost each topic each with its own user interfaces, operational concepts and data visualisation. What is even more, as a rule this wealth of information belonging to individual systems is not connected in any way. The task of merging all this information is left to users who are responsible for making the connections. Another problem arises then, namely that a user’s view on data structures may differ significantly from that of other users working in different fields. Generally, users have to first explore where to obtain the needed information and how it is structured. Consequently, collaborative activities often sidestep such information distribution applications, they cannot be coordinated or may simply be dropped because the process would be too laborious.

Centralized Data Distribution continues on the Client

Another point to mention is that users often go on to process the information further. If I succeed in my search for a presentation on the web, I may adapt it to my needs, delete some slides, add some more…finally ending up with new information units distinct from the central data pool. Furthermore, management does not know which information has any relevance or qualitative use for a specific user, nor can any other central instance update the information: it is up to users alone to keep them updated. Such scenarios can only be avoided if the information distribution process is carried over to the client by offering possibilities that reflect user-specific applications or processes. This should be considered a valid requirement for any RCP application, since specific bundles (e.g. JDT for Java source code editing) with information editing capabilities are available.

Local Data Processing – natural use only for a few user groups

It is nothing unusual for developers to edit source code on their local machine and update the server system at intermittent intervals. Nobody would even think of distributing each bit of data manipulation separately. Only after the source code has been updated to a repository can the pertaining business process such as deployment, unit testing etc. be started. Alas, as much as this ‘division of labor’ between server and client may make sense, it is not that widespread and many users have no local access to data or are hampered by much shorter synchronisation intervals, which at worst can be a website request response cycle. The necessity of such excessive communication is hardly ever challenged, probably because the benefits of balanced data management during the process itself is often underestimated. And then there is the higher degree of distribution which drives up maintenance and security costs. In most cases, it may safely be assumed that complex data structures, even those with high demands on the UI and user interaction, can be optimally visualised using the graphical powers offered by an Eclipse Rich Client. And integration in the operating system (Desktop-Notification, OLE, FileTransfer, TrayIcon, …) also offers the great advantage of greatly simplified communication with other software applications.

Information from Third-party Suppliers – required, but often underestimated

Sure, there are applications that provide all the information that users need, but most processes have information requirements that force users to leave an application or even complete system landscapes. A client which draws on content from different repositories would provide an optimal connecting link. Information is only connected where this is really needed and in such way that it offers added value to users. Finally, the feature of allowing third-party vendor access to client applications could deliver additional momentum to application development, without the necessity of major changes to the IT environment.

Prospects

The next step now is to lay down some technical aspects focusing on Eclipse-related considerations and lay the foundation for an RCP implemenation. Let me, dear reader, apologize in advance for the in part rudimentary implementation of my software example, as it is not meant to be an application for demonstrating the built-in functionalities of Eclipse. Rather, my intention is to exemplify a specific perspective taken in building RCP applications. Stay tuned!

Distribution via Webapplications (schema)

Distribution via Rich Client (schema)

]]> http://www.richclient2.eu/2008_03_04/developing-data-centric-rcp-applications-part-i-%e2%80%93-intro/feed/ http://www.richclient2.eu/2007_10_18/web-vs-smart-client-%e2%80%93-how-to-sell-eclipse-rcp-technology/ http://www.richclient2.eu/2007_10_18/web-vs-smart-client-%e2%80%93-how-to-sell-eclipse-rcp-technology/#comments Thu, 18 Oct 2007 13:34:39 +0000 Tom Seidel Business http://www.richclient2.eu/2007_10_18/web-vs-smart-client-%e2%80%93-how-to-sell-eclipse-rcp-technology/ With the development of the RCP Framework a new and elegant possibility to develop client applications was created. The Eclipse licensing model allows you to create commercial applications based on the RCP Platform. However, the question must to be asked under which conditions and with which requirements a computer-based solution based on RCP is the best option.

Starting point

Often you’re faced with a software-environment that’s completely based on web-applications, regardless of which business process is mapped with an application. Experience also frequently shows that people have a very different picture in mind, when you’re talking about Java client-applications. A slow ugly swing application or an applet is the most frequently encountered association. At this point, it gets very difficult to convince somebody of a technical RCP-based solution, especially if that technology is still completely unknown.

Possible solution

The approach I use here is not based on listing all the advantages brought about by Eclipse RCP, but rather on the analysis of the requirements you have to meet and which are relevant to opting for a technical solution. Thus, the business specific requirements are the crucial criteria that indicate technical architectures/methods/frameworks/etc, not vice versa, as is often the practice.
Accordingly, the characteristics of RCP and web applications play a comparably important role. Basically, all you have to do is “map” the requirements to the characteristics of technical systems.
This approach will enable you to achieve several goals: First of all, you’ll get a clearer picture of your project goal. Secondly, it’ill force a “re-consideration” of the given requirements.

Poster

The poster, which was also shown at the Eclipse Summit in Ludwigsburg, can be seen as a help for guidance within such a decision-making process. Its focus is on different requirements which are brought into the context of a decision for a system. The important aspects are:

• Target audience (power user, casual user)
• Online/offline capabilities
• Availability
• Existing software systems
• Hybrid applications
• …

Ideally, this should make it easier to decide between a web application or rich client application.

RAP?

Based on the aspects mentioned above, a 1:1 replication of application types, as it is done with the Rich Ajax Platform, is a suboptimal way of modifying applications. This is because there are further aspects which need to be considered when the decision to move an application to the web is made.

Also worth mentioning here are the expectations concerning usability, layout, response time, etc. that are mostly completely different, so that a 1:1 porting from an RCP application to a web application (and also vice versa) will not meet the changed requirements. Please, do not get me wrong, this is no RAP bashing, I think it’s really cool software, but from my experience, I couldn’t find any scenario where a 1:1 porting would deliver a satisfactory result.

Conclusion

With the RCP Framework, you can build an application based on a specified set of business requirements. Pure web applications continue to be first choice for specific requirements.

Download

Download-Site for the poster in high resolution

]]> http://www.richclient2.eu/2007_10_18/web-vs-smart-client-%e2%80%93-how-to-sell-eclipse-rcp-technology/feed/ http://www.richclient2.eu/2007_10_15/extending-quickaccess-or-how-to-implement-my-own-ctrl3/ http://www.richclient2.eu/2007_10_15/extending-quickaccess-or-how-to-implement-my-own-ctrl3/#comments Mon, 15 Oct 2007 07:52:07 +0000 Tom Seidel Eclipse RCP SWT JFace http://www.richclient2.eu/2007_10_15/extending-quickaccess-or-how-to-implement-my-own-ctrl3/ The implementation of the “Ctrl+3″ popup was an undisputed enhancement for more usability. It enables a much faster navigation through all the browsable items you may have in your Workbench. A much more interesting topic is how to adopt this widget in order to be extended, restricted and customized. This is especially usefull for RCP Development to hide and add elements. However, there is currently no way to customize the contents of the quick access popup.
The following article provides instructions for an implementation of a fully customizable popup with the known behaviour. The content is contributed using an extra Extension-Point (no bundle-activation required).

Usage

I have implemented a small bundle with an Extension-Point definition that allows you to create a custom popup with the content other plug-ins contribute using Extension-Point. The implementation is as easy as defining a new command. Just create a new category or a new element in your plugin.xml and that’s it. Unfortunately the code for creating the popup is copied from the platform, see Bug 162006 and Bug 204356.

Screenshots

Defined content in the plugin.xml

Result popup (accessible with Ctrl+4)

Downloads

Download the Example as RCP (12 Mbyte - Source included)
Download the Bundle (50 Kbyte - Source included)
CVS-Checkout (more info)

• de.spiritlink.quickaccess
• de.spiritlink.quickaccess.rcp

]]> http://www.richclient2.eu/2007_10_15/extending-quickaccess-or-how-to-implement-my-own-ctrl3/feed/