On June, 6th I’ll organize together with AVL DiTEST GmbH the first Eclipse DemoCamp in the Nuremberg-Area. I know that AVL is not known to many people (although it’s a very huge company) this company uses a lot of Eclipse technology. Focussing on diagnostic tools for garages and OEMs, AVL uses a model-driven approach to describe the communication of a computer system with a vehicle’s ECU (electronic control unit).

Eclipse-based technology communicating with an Audi

Therefore AVL created an internal toolchain for their product development based on the Eclipse IDE including EMF and Xtext (see pictures) and we want to demo this toolchain beginning from the textual modelling of an ECU communication until the generated OSGi bundle that communicates with the car.

XText Editor to describe communication

Join us

If you live or work in the Nuremberg-area don’t miss this event - just enter your name and company on the wiki page. We’re also looking still for presenters, so if you have something cool to show, enter your name and an abstract of the topic you want to demo.

We’re looking forward to see you.

If you use Eclipse you probably spent a lot of time with gathering information by browsing through the code, reading documentation, etc. Often you have to leave Eclipse and browse through an external system, like a Wiki, an intranet or Sharepoint.

With the Remus IDE integration you’ll be able to attach information units directly to resources in your workspace, that means to any file, folder or project. In addition Remus gives you the possibility to embed an information repository into your project  to share your attached information units with other developers. With this approach all relevant information that are required to edit the source-code you’re working on are directly linked to the piece of code. I hope you find this feature useful, if you have questions feel free to use the official communication channels to get help.

An Eclipse project with linked information units

For a detailed tutorial see the Eclipse Wiki at http://wiki.eclipse.org/Remus/IDE_Integration, there is also a screencast which shows this functionality, see http://www.youtube.com/watch?v=2xeNkAnEzEk. If you are interested, the Eclipse Foundation is hosting a webinar about the Remus project, for details, see http://live.eclipse.org/node/1005.

Remus can be downloaded via the Eclipse Marketplace, see http://marketplace.eclipse.org/content/remus-information-management/.

Whats next?

In the next posting I’ll show you how to connect Remus to your Mylyn task-list to extract data and information from your issue-tracker.

For demo purposes I’ve installed a marketplace server here, which acts as a server endpoint and provides the required listings for the marketplace-client. This server software can be downloaded here.  

The only thing you have to do is to register this server in your RCP application. Therefore you have to add the following dependency:

• org.eclipse.epp.mpc.ui

Now you can create a new extension point which describes your marketplace-server, like:

If you start your RCP application you’ll see a new menu-entry under help, which opens the marketplace client, and lists you all installable components.

Administration panel of the Marketplace server

I’ve created a build of the RCP Mailtemplate with an integrated marketplace, you’ll find the link at the bottom of this page.

There is only one drawback: Due to Bug 313581 the default marketplace is always registered as a service endpoint. Either you remove the entry from the plugin.xml of the marketplace-client bundle or you write some Equinox Transformer Hooks to wipe out this entry from your Extension-Registry.

Downloads

Download the Mailtemplate RCP Build - Windows 32-Bit (22 MB)
Download the Mailtemplate RCP Build - Windows 64-Bit (22 MB)
Download the Marketplace-Server (14MB)

The motivation

The motivation for an own marketplace was that we need for our project Remus Information Management an easy way to install new components. We’re using the underlying framework (which is btw an official Eclipse project) to create an Eclipse-application which does Information management and is extendable in many ways. The problem is that we’re using a lot of third-party-libraries which will change very often and we have a primary user group that is not familiar with Eclipse as IDE and all that IT- and developer-stuff. So we have to provide an easy way to allow the installation of additional components in a very user-friendly way.

I personally was always impressed by the Connector-Discovery from Mylyn and was very happy to read the announcement of a similar tool which can be used for all eclipse based components.

The solution

The marketplace client is using an xml based communication interface to gather information regarding available bundles at a marketplace. So we adapted this interface and wrote a small and simple web-application which can handle all the requests coming from such a client. The result is an Open-Source project called “Marketplace catalog for Eclipse” which is hosted on sourceforge.net. All source-code is licensed under EPL, so feel free to consume this project, integrate your own market in your next RCP project or to provide an “exclusive” marketplace with your bundles.

The future

We reached our main goal, to provide in the next release of Remus IM a simple way of installing new components with a system controlled 100% by our own. The current implementation of the server-software has still no web-interface to add/edit or delete bundles. We’ll extend the existing marketplace connector of Remus IM which is read-only at the moment with editing capabilities to manage your marketplace offline. If you are online, you can commit your changes and all consumers of your marketplace can browse through your updated content.

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.de/2009_11_23/building-reports-of-your-local-information-pool-with-birt-and-remus/feed/ http://www.richclient2.de/2009_09_01/extending-rim-with-xtext/ http://www.richclient2.de/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