The goals of this project can be divided into two big parts:

1. Provide an out-of-the box set of bundles that can be installed into an Eclipse instance, for example your IDE, for daily information management. This tooling will be also available as standalone RCP application. There is already a build of a full-blown application built on Remus available, see http://www.remus-software.org.
2. The probably more relevant part is that we want to provide a framework and several APIs for building applications for viewing, editing, catgorizing, searching and synchronizing any datastructures. I’ll show you an example how to build your Hello-Remus bundle in just a few minutes.

The approach

The theoretical apporoach is that we assume that every unit of information can be described with a structure-definition. This definition holds the definition how a specific type of information is organized internally. Based on a structure-definition Remus can create business objects a navigatable information-structure, editing-ui and even a rule engine for manipulating these objects. Every structure-definition is typed, that means it can handled by the framework regarding visualization, indexing or synchronization in a different way.

Example

Ok, we’ve had enough of words, let’s start. Our “Hello World” application will be a RCP application for one single information type: A book review.

Step 1 - Creating the plugin and a structure definition.

We create a bundle using the plugin-wizard for a RCP with a single view. After the bundle was created we define our structure definition. This definition is done by a tree-based editor, but since the underlying technology is emf you can use alternative editing methods, for example with textual plugins like Xtext. A review has the following information-items

1. Title of the Review
2. Date
3. Author
4. Reviewed book
5. Review

We can create now this structure definition (see picture)

Step 2 - Navigation and first start

The first thing we have to do is to tell Remus about this new information type. We create a new extension, defining name and type of this information and point to the structure definition. Thats all for the moment. After that definition we already can add, edit and save information units. These operations are executed by default on a command-stack and can be un- or redone. The underlying data store mechanisms need no customization.

With a few lines you can create your first business objects:

As you can see we aquire an instance of a manager for setting values to an information unit. This manager checks our inputs against the underlying structure definition of this information type. A the end you’ll see that we generate a command and execute it. This command is checked for correctness and is executed on a command stack.

If we start now our RCP application we will see already a good result:

Step 3 - Editor

Remus provides some editor infrastructure to visualize and edit the given information unit. Note that these editors have already the basic functionalitites you know from other applications, like automatic refresh, close, undo-redo,…
Remus has no API for building UI elements you can use your preferred toolkit, but comes with a very handy API for binding UI elements to structure items defined by your information type. Editors are injected by a separate extension-point. For making an information type editable with an editor you have to extend 1 class and overwrite 2 methods (one for generating the ui and one for binding the ui-elements)

Due to the separation between the definition of ui elements and the binding to information structure elements you can use also third-party-tools like SWT designer.

The binding is very easy. You just have to bind a ui control to a structure element of your information type, a 2-liner:

After defining this editor you can now open this information unit from your navigation. As you can see in the screenshot the editor becomes dirty after an edit.

In addition Remus provides some additional API to forward the data of a information unit to a HTML Template Engine for pretty information visualization (if you want to browse through the data, complex forms are not appreciated) and to integrate the HTML Output into an editor.

Step 4 - Search

Integrating a search is also very easy. In general you only have to include the relevant bundles and Remus tries to index your information unit. By defining another extension point you can tell Remus which structure items need to be indexed. If you like you can use the default search view which is shipped with the framework. Also the result listing can be reused (if you like). If you use the search bundles you autmatically get a search history, a search for references, a search context with key bindings to navigate through results, …

By adding the search view to your perspective layout, you see the Search-View

Conclusion

Of course there are many other things you can use, for example linking between information units, support for files, integration of third-party-editors, data-encryption, semantical structures, synchronization with remote information pools,… I’ll post some documentation soon.

The components of Remus can be used to build RCP applications, Eclipse plugins, RAP applications or even a headless information repository running on a server for information distribution. We also provide an ODA Driver to query information structures with the Eclipse Data Tools Platform; this makes especially the BIRT integration very easy.

We are currently in the proposal phase of the Eclipse Development process and need your feedback. If you have questions about features, architecture, use cases, etc don’t hestitate to post your thoughts at the Newsgroup or the Eclipse Community Forums; and if you want to see what we’ve already done with this framework take a look at http://remus-software.org, the projects current home. We’re looking forward hearing from you.

For creating a new connector switch to the “Remote Repositories” tab and create an “Eclipse Marketplace” connector.

Then you can browse through the structure, select the categories you are interested in and select “checkout”

After downloading the data you can open the elements with an editor. The synchronization functionality of Remus keeps your checked out elements always up-to-date and notifies you if the application has downloaded new elements.

A nice feature is the search functionality (see screenshot). In addition you can create now nice BIRT reports based on the downloaded data.

At this moment the REST Interface is a read-only interface, so we cannot provide any functionality for editing e.g. your own submissions.
So if you’re interested, download the latest release, perform an update and you’re ready to use the connector. Feedback is appreciated.

A Report is also information

You can now create new information units which are reports. Therefore your input can be your own BIRT Report file or you choose an installed template from the given list in the wizard.

There are already a few templates installed, I want to show two of them.

Report your worked time on a task

Remus provides functionalities for work time tracking on tasks, e.g. you can synchronize your tasks from Outlook and start working on the tasks. If you want to see how much time you have worked on a specific task you can create a report based on a template. The input of the report is a task with a work-log (see picture).

If we create a report based on that task the application will show the following:

As you can see the report and the reports input are part of your local information pool.

Top posters on twitter

A second example is to report your twitter stream. Remus can be also used as a twitter client and so the data can be processed within a report, See the Top-Poster Report for twitter.

Editing report

By default you cannot edit these reports unless you download via “Extras -> Install new software” the BIRT Editing Capabilities which shows you after the installation a small button under the editor which opens the report in edit mode (see picture).  Again, at the bottom you’ll find a button to jump back to the report in “view” mode.

Create your own reports

If you want to create your own reports the best way is to start either with an empty report or you modify the templates to your needs. It is really simple and the only thing which is Remus specific is the creation of the data sources and datasets. I’ll write some documentations in the next time but the only thing you have to know which nodes within an information-unit you want to show within your report (the picture shows an structure-definition of a task and the relevant nodes for the work-log report)

Conclusion

First I’m very happy that BIRT Reporting could be integrated into Remus that easily. I think it’s an essential feature and gives the user a powerful tool for a customized output of his information data. So try it out - it’s free and open source, see the project-website http://remus-software.org 

Creating a Report about the PlanetEclipse-Feed with BIRT in Remus.

]]> http://www.richclient2.eu/2009_11_23/building-reports-of-your-local-information-pool-with-birt-and-remus/feed/ http://www.richclient2.eu/2009_09_01/extending-rim-with-xtext/ http://www.richclient2.eu/2009_09_01/extending-rim-with-xtext/#comments Tue, 01 Sep 2009 09:39:37 +0000 Tom Seidel Eclipse RCP http://www.richclient2.eu/2009_09_01/extending-rim-with-xtext/ I must admit I’m a big fan of all EMF derivations, so also Xtext, the new framework for developing textual DSLs. Today I want to show you how to use RIM for managing your textual models, consuming the features of both frameworks, RIM and Xtext.

Seamless integration with as less modifications as possible

A challenge is to integrate a generated Xtext editor into RIM. You probably know, for RIM everything is a type specific information unit, so we’re creating a new bundle by defining a new information structure, which has a property where the textual model of our DSL is saved. For the binding of source editors to an information type you can use a separate extension point, the integration of a generated Xtext Editor is very easy (see source).

Xtext Editor in RIM with created information unit (see left)

Get rid of the IDE flavor

A typical feature of RIM is that it behaves under the hood exactly the same way like a Eclipse SDK, but is not intended to be an application only for developers.  The UI is lightweight (relatively), but the way you edit resources is the same.

New Wizard of a textual model

Use your Xtext Model as part of an information unit

Once you have integrated your Xtext Editor in RIM you can use all the features regarding information management that come with RIM in combination with your textual model. If you need synchronization with remote repositories, semantic categorization full indexed search or a desktop integration, it’s all integrated.

Search through a model is also fully integrated

Drawbacks

Ok, there are some drawbacks. RIM delivers at the moment no Problems view, so errors within your model are only visualized within an editor, this will be fixed until 1.0. An additional drawback is that the Xtext guys are binding their Xtext bundles very tightly to the JDT. I had to modify the xtext ui bundle to get rid of all jdt-dependencies; it would be great if the Xtext team could use integration bundles and extension points for a loose coupling of typical ide components.

Conclusion

All in all Xtext integrates very well in RIM. If you want to use Xtext, you could consider RIM as a container for your textual models. Thanks to the Xtext Developers for this wonderful framework. For RIM it’s now very easy to manage and visualize information units which are holding complex datastructures in textual form.

Get started

Want to see RIM and Xtext in Action? Download the latest release of RIM and the Xtext features (see Downloads). Install the unpacked feature via “Install new Software”.

Latest RIM Build
Xtext Integration Feature (Source included)

Links

Xtext Website
RIM Website

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/