Posts Tagged ‘Vienna’

OSGi and Vaadin – Using ClassResource

June 18, 2015

Using Vaadin’s ClassResource in OSGi environments is pretty straightforward. But you have to know a few basics about the OSGi class loader:

In OSGi, every bundle has its own classloader. And all resources contained in a certain bundle are loaded by this bundle’s classloader only.


For instance, we try to load an image based on Vaadin’s ClassResource.

new Image("Bundle2 exported", 
        new ClassResource(, 

The ClassResource internally will call

 whenever ClassResource#getStream() is called.

The OSGi classloader takes over

After this, the OSGi classloader comes into play. It uses a defined strategy to look for the resource:

  1. If the package starts with “java”, then the request is forwarded to the parent classloader
  2. If the package is in the list of “boot delegation”, the the request is forwarded to the parent classloader
  3. The request is forwarded to “class loading hooks”
  4. The classloader checks whether there is a “import package” for “”.
    1. If so, then the resource is loaded from this imported package (meaning that the request is forwarded to a different bundle classloader). If a package could be found, the lookup will terminate.
    2. If not, proceed with 5.
  5. The classloader checks all “required bundles” whether the resource can be found there.
  6. The classloader checks the “local” resources contained in the classloaders bundle.
  7. The classloader checks the “fragments classpath” resources contained in the fragments.
  8. The classloader checks for “dynamic imports”.

How not to: Something that will never work

Assume we have two bundles.

Bundle A – contains the Vaadin-Servlet, the resource handler and all that stuff required to run Vaadin in OSGi.

Bundle B – just another bundle. “Bundle A” does not have a dependency to “Bundle B”.

Bundle B contains an image and it should be loaded by a ClassResource. If you prepare a ClassResource for the image contained in “Bundle B”, but you do not pass a class contained in “Bundle B” to the ClassResource, OSGi is not able to load the image.

new Image("", 
        new ClassResource("ImageInBundleB.png"))

The reason is that ClassResource internally will use the classloader of the UI class. And this one does not have a dependency to “Bundle B”. And so the resource can not be loaded because it is not visible to the classloader.

Using a BundleResource

I prepared a BundleResource prototype. It is licensed under the Apache License and is available at the Lunifera github repo.

new Image("", 
        new BundleResource(theBundle, 

The path to the resource is the path relative to the bundle. In this sample, the “ImageInBundleB.png” is located in a folder called “resources”.

Feel free to use the BundleResource for your own projects.


If a resource could not be found by the “ClassResource”, one just has to debug the OSGi classloader. If you are using Equinox, take a look at

org.eclipse.osgi.internal.loader.BundleLoader. It is responsible to load the resource.

Eclipse EMF-Xtext – how to fix “feature ‘xmi’ not found”

June 11, 2015

Sometimes strange problems occur out of nowhere when running the MWE2-workflow for an Xtext Grammar.

You are getting the exception “feature ‘xmi’ not found” for ecore.ecore, ecore.genmodel,… We got bitten by that quite a few times. But there was a simple workaround for it: Create a new workspace with only the DSL based on the grammar in question and run the workflow there, and most probably things will work fine again. However, this didn’t help in all cases.

Yesterday in particular, even the “new workspace” approach did not resolve the problem. So we had to start debugging the MWE2-workflow based on two Xtext grammars. Grammar 1 worked fine, but grammar 2 crashed with the exception above.

After some toil, we could figure out that the properly running MWE2-workflow uses the SAXParser from “ xerces.internal.parsers.SAXParser”, whereas the buggy MWE2-workflow somehow uses the “org.apache.xerces.parsers.SAXParser”.

With this in mind, it seems that the simplest workaround for that problem is to add the following to the VM arguments in the launch configuration of the MWE2 workflow:


This property ensures that the proper SaxParser is used, and the problem does not occur anymore.

Best regards,

Klemens and Florian

Eclipse DemoCamp “Mars” Vienna

May 18, 2015

Lunifera GmbH and IoT-Vienna are organizing the Eclipse-DemoCampMars” on 19.6 2015.

With this event, we want to bring people and companies together to share their knowledge, experience with and about Eclipse. This meeting includes six Talks and a quick intro on the Eclipse Foundation’s role by Benjamin Cabé.


  • Tom Schindl: Something cool TBD
  • Werner Keil: Energie Sparen präzise Messwerte bei SmartHome und SmartGrid
  • Philip Langer: EMF Compare
  • Benjamin Cabé: IoT Talk
  • Florian Pirchner: OSGi-IoT-Vaadin

We also provide catering, drinks, beer and cakes as usual.

For details please visit

Hope to see you at the DemoCamp “Mars” Vienna…

the DemoCamp organizers

IoT: Industry 1.0 meets Business 4.0 — with Eclipse Paho

May 7, 2015

On the 9th of April (the “Global IoT Day”), we (Lunifera GmbH) co-organized a free IoT event in Vienna. With over 400 attendees, the Global IoT Day Event was a huge success — one of the biggest IoT events worldwide!

But we not only took part in the organization and hosting of this awesome event: Of course, we just had to do a small demo project and present it — the Lunifera steam engine.

“Industry 4.0” is one of the hottest topics at the moment: The computerization of production processes and the use of connected intelligent devices in production seems to be the future of industrial production. Industry 4.0 will change the way we produce (and use and scrap and recycle) things profoundly. With this “fourth industrial revolution” gaining speed, we at Lunifera GmbH have been toying around with various ideas and concepts of integration between physical world, production and business processes and user interface for some time.

Our newest proof-of-concept project in this area is our steam engine (looking back to “Industry 1.0” that brought the use of steam engines): We bought a working toy steam engine, hooked up sensors to it and set up circuitry (using, among others, an Arduino Uno and a Raspberry Pi) that converts the sensor output to binary data. Then we use the Python incarnation of Eclipse Paho in order to transfer the measurement data across any networks so it can be used pretty much anywhere.

Our steam engine: Heating the water in the boiler causes the pressure to rise (pressure sensor: top right). The steam is used to turn the wheel in the back (cyan rotation sensor above wheel). The temperature is measured by a PT1000 sensor (left side of boiler).


The sensors turn the values of physical properties into voltage levels. We read these voltage levels and convert them into binary data.

Our next step was to transmit the pressure, temperature and RPM values that we measured from the physical engine to any listeners. According to our experience in the IoT area, the most flexible, reliable and easy-to-use solution for this is MQTT. Thus, we set up an MQTT broker and two MQTT clients (one client on the Raspberry Pi that gathers and interprets the measurement data, one on the machine with the business application). Using Eclipse Paho (the Python version on the Raspberry, the Java version on the PC), it took us about three minutes to set up the desired communication.


The push-based communication in our demo project: Sensors S1 to S3 collect data, the Raspberry Pi interprets the values and transmits them to the MQTT broker. Whenever a new value arrives at the broker, it is forwarded to the other client that has registered before.

For our demo purposes, we integrated the measurement data into a simple web-based business application: We displayed the data right inside a business app by using Vaadin UI elements (various charts). In the future, it would be quite easy to integrate the values into additional complex representations such as augmented reality and so on.


In our simple example, the measurement values are displayed in a web-based demo application. Integration into standard business applications and web pages would be straightforward.

Vaadin & OSGi: managing the classloader

April 30, 2015

If you are using Vaadin with OSGi, you need to be aware of an issue related to

Vaadin changed the classloader that is used to load the UI-class. Before this change, the UI-class was loaded by the classloader of the servlet class. Now the “context class loader” is used to load it.

So if you define your UI-class in the VaadinServlet by annotation, you will get a ClassNotFoundException.

It is pretty easy to fix that issue. The solution is to define the proper classloader in ServletService. Afterwards the UI-class can be loaded properly again.

@VaadinServletConfiguration(ui = ECViewSampleUI.class, productionMode = false)
public class SimpleVaadinServlet extends VaadinServlet {
	protected VaadinServletService createServletService(
			DeploymentConfiguration deploymentConfiguration)
			throws ServiceException {
		// see
		ServletService service = new ServletService(this,
		return service;

This snippet shows an implementation of VaadinServlet.

It is used to

  1. define the UI-class by annotation
  2. create a custom VaadinServletService to define the proper classloader.


public class ServletService extends VaadinServletService {

	public ServletService(VaadinServlet servlet,
			DeploymentConfiguration deploymentConfiguration)
			throws ServiceException {
		super(servlet, deploymentConfiguration);

	public ClassLoader getClassLoader() {
		// return the bundle classloader
		// see
		return ServletService.class.getClassLoader();

The highlighted lines in the ServletService ensure that a proper class loader – the classloader of the custom ServletService – is used to load the UI-class.

Things should work properly afterwards …


Florian Pirchner

Eclipse-Databinding for Vaadin

April 10, 2015

A while ago we (Lunifera GmbH) have implemented Eclipse-Databinding for Vaadin. Two different databinding approaches that perfectly work together.

In this blog i’d like to talk about the two different ways of databinding and how these worlds can be tided together.

Vaadin comes with an integrated databinding capability. Databinding in Vaadin means, that UI elements (components) are bound to so called containers, items and properties. So the data of components can be abstracted from the component itself. But Vaadin defines no common way to bind these containers, items and properties to each other.

There the eclipse databinding comes into play. Eclipse databinding provides a common way to bind so called “observable values” to each other. An “observale value” is an abstraction above the “data related to its source”. Eclipse databinding comes with an implementation for POJOs, Beans (POJOs with PropertyChangeSupport), SWT-Widgets, JFace-Components, EObjects (Eclipse Modeling Framework – EMF) and the EMF-Edit-Commands. These implementations allow you to bind “observable values” from different domains (one of mentioned implementations) to each other.

In combination Vaadin databinding and Eclipse databinding are working properly together.

Vaadin Databinding

Vaadin databinding consists of 3 concepts for different use cases:

  • Property – An abstraction for a type and value. Used to bind fields like TextField to the property
  • Item – A collection of properties. It represents a row in a table. Each property inside the item has a unique propertyID
  • Container – A collection of items. It represents a data-table. Each item inside the container has a unique itemID

Property, Item and Container are expressed by interface. And Vaadin comes with a lot of proper implementations for different usecases.


Image: “Book of Vaadin 8.1” – Copyright 2015 Vaadin Ltd [1].


// Create a property
ObjectProperty property =
    new ObjectProperty("Florian", String.class);
// Create a text field
TextField nameField = new TextField("Firstname");
// Bind nameField to data

See also: “Book of Vaadin 8.2.1”

As soon as the property is set to the field, you may use the property to read and write values.


Dealing with items is really similar to properties.

PropertysetItem item = new PropertysetItem();
item.addItemProperty("firstName", new ObjectProperty("Florian"));
item.addItemProperty("age", new ObjectProperty(36));
// create a form
Form form = new Form();

See also: “Book of Vaadin 8.3.1”

In this case an item is prepared and set to a form. Forms are special components that show defined properties of the given item.

There are different ways to define items. The example above uses a PropertysetItem which allows you to define all properties manually. But there are also more comfortable way for pojos.

// Create an instance of the bean
Person bean = new Person();
// Create a bean item configured for type Person.class
BeanItem<Person> item = new BeanItem<Person>(bean);

// Set the item to the form
Form form = new Form();

Sample: “Book of Vaadin 8.3.2”
To automatically create an item for a bean, that holds each bean-property, you just may use the BeanItem.


// set a personContainer to the table
Table table = new Table("Persons");

See also: “Book of Vaadin 8.5”

For containers there is also a generic way to define the container properties (the columns of the container). And also a lot of very useful implementations like the BeanContainer or BeanItemContainer. Based on the JPAContainer you can connect your Vaadin components to JPA really quickly.

For details about BeanItemContainer see: “Book of Vaadin 8.5.4”

Eclipse Databinding

The Eclipse databinding follows a more general way and tries to abstract bindings in general.

Unbenannte Zeichnung (1)If you would like to use Eclipse databinding, you have to deal with some concepts.

  • ObservableValue (ObservableList) – it is defined by an interface and is an abstraction above a data-endpoint.
  • UpdateValueStrategy – defines how source-to-target and target-to-source updates will be processed.
  • Binding – binds the observable values (or lists) to each other. BindingStrategy can be used.
  • DatabindingContext – It is a common state for all contained bindings.
  • Realm – It is responsible to synchronize updates with the environment

Observable Values

Similar to the Vaadin databinding, an obervable value defines the type and value the instance deals with. The observable value knows how to access the underlying “target-element”. This “target-element” may be anything, as far there is an implementation for it. For now the”target-element” may be a pojo, a bean, an EObject, a SWT-widget,… The observable value will register all required listeners at the “target-element” to get notified about changes. If the value of the “target-element” is changed, then the “obervable value” will notify the Binding, which updates the value at the opposite side of the Binding.


The UpdateValueStrategy may be used to define how values are updated.They can be defined for “source-to-target” and “target-to-source” updates. The UpdateValueStrategy is also responsible for data conversion.

It comes with 3 policies:

  • POLICY_NEVER – Values in the “observable value” will never be transferred to the opposite end of the binding.
  • POLICY_ON_REQUEST –  Values in the “observable value” will only be transferred to the opposite end, if requested by a method call.
  • POLICY_UPDATE – If the “observable value” becomes notified about changes in the “target-element”, then the value will be automatically transferred to the opposite of the binding.


The ValueBinding connects the Source-ObservableValue to the Target-ObservableValue according the UpdateValueStrategy-Policy. It also offers methods to validate and update model-to-target or target-to-model (Model is a synonym for Source) operations.


The databinding context manages all bindings. Also List- and Set-Bindings. The granularity about the instances of DatabindingContexts depends on the underlying application. In general i would say, that all bindings that should be validated in a common context, should be added to the sames context. If you have different views as part of your system, each view may get its own context. But it depends on you.


When you are using Eclipse databinding, you need to be aware about its lifecycle. If a view is closed, a timeout occurs,… you must ensure, that the databinding context is #disposed(). There is a method for it. Otherwise the Vaadin components will receive value updates, even if the UI is already closed.


For instance if you are doing a long running operation as an async operation in a different thread and you expect that the async operation updates your UI properly, you need a way to sync your UI with this thread. In SWT you have to update the UI in the SWT-Ui-Thread. In Vaadin you need to call UI#access(…).

The realm is specific for each databinding implementation. The source- and the target-observable-values may have their own Realm. So it would be possible to bind a SWT-UI to a Vaadin-UI. I never tried to do so, but i am pretty sure, that it will work properly.

Eclipse-Databinding for Vaadin

We have prepared an eclipse databinding implementation for Vaadin. You can find it in this github-repo. There is also a P2-Updatesite located here: Lunifera-P2-Repo.


Before you create the DatabindingContext, you need to activate the Realm for VaadinDatabinding.

// Activate the realm

// Create databinding context
DataBindingContext dbc = new DataBindingContext();

Even if you would like to add new Bindings in a different Thread, you need to activate the realm. Otherwise databinding does not know anything about the current UI-instance.

In real projects you won’t have to call the activation on certain places again and again. So there is a perfect place to do so.

You have to override the VaadinServletService and add following method:

public UI findUI(VaadinRequest request) {
	UI instance = super.findUI(request);

	// activate the realm for the current ui and thread

	return instance;

Then every time, Vaadin is looking for the current UI-instance, the realm will be activated automatically.




Now lets start with some examples demonstrating how to use the eclipse databinding for Vaadin.

1 Binding components –> #value

// Activate the realm

// Create databinding context
DataBindingContext dbc = new DataBindingContext();
// Create the Vaadin components
TextField sourceField = new TextField();
Label targetField = new Label();
// Create the observable values
IObservableValue sourceOV = VaadinObservables.observeValue(sourceField);
IObservableValue targetOV = VaadinObservables.observeValue(targetField);

// bind the values to each other
dbc.bindValue(sourceOV, targetOV);

This sample binds the value of the textField to the value of the label. If the value of the textField changes, the label is updated.

2 Binding components –> #enabledState

// Activate the realm

// Create databinding context
DataBindingContext dbc = new DataBindingContext();

// Create the Vaadin components
CheckBox checkbox = new CheckBox();
TextField textField = new TextField();
// Create the observable values
IObservableValue sourceOV = VaadinObservables.observeValue(checkbox);
// observe the enabled state of the textfield
IObservableValue targetOV = VaadinObservables.observeEnabled(textField);

// bind the values to each other
dbc.bindValue(sourceOV, targetOV);

This sample binds the value of the checkBox to the enabled property of the textfield. If the checkbox is checked, then the textField is enabled. Otherwise it is disabled.

3 Bind components to beans

// Activate the realm

// Create databinding context
DataBindingContext dbc = new DataBindingContext();

Person person = new Person();

// Create the text field
TextField textField = new TextField();

// Create the observable values
IObservableValue sourceOV = BeansObservables.observeValue(person, "firstname");
IObservableValue targetOV = VaadinObservables.observeValue(textField);

// bind the values to each other
dbc.bindValue(sourceOV, targetOV);

This sample binds the “firstname”-property of the given bean to the value of the text. If the value of the textField or the value of the bean changes, then the change is updated at the opposite site.

4 Reuse the Vaadin property

// Activate the realm

// Create databinding context
DataBindingContext dbc = new DataBindingContext();

Person person = new Person();

// Create the text field
TextField textField = new TextField();
textField.setPropertyDatasource(new ObjectDatasource());

// Create the observable values
IObservableValue sourceOV = BeansObservables.observeValue(person, "firstname");
textField.setPropertyDataSource(new ObjectProperty<String>("", String.class));

// bind the values to each other
dbc.bindValue(sourceOV, targetOV);

In this sample, an ObjectProperty was set to the textField. The Vaadin databinding implementation internally tries to get the property datasource before binding. If it is available, then the property will be bound. Otherwise the field itself is bound. So it is your choice whether you want to work with properties or not.

5 Bind the multiselection of table-1 to the input of table-2

// Activate the realm

// Create databinding context
DataBindingContext dbc = new DataBindingContext();

// Create the Vaadin components
Table table1 = new Table();
Table table2 = new Table();

// observe the multi selection
IObservableList table1OV = VaadinObservables.observeMultiSelectionAsList(table1, Person.class);
// observe the content
IObservableList table2OV = VaadinObservables.observeContainerItemSetContents(table2, Person.class);
// bind the values to each other
dbc.bindList(table1OV, table2OV);

This sample binds the multi-selection of table1 to the input of table2. So table2 shows the selected items of table1. Note, that this kind of binding uses ObservableLists.


6 Bind a table to a WritableList

// Activate the realm

// Create databinding context
DataBindingContext dbc = new DataBindingContext();

// create a table
Table table = new Table("Persons");
table.setContainerDataSource(new BeanItemContainer<Person>(
// create a writable list as model
final WritableList model = new WritableList();
// observe the table container content
IObservableList tableOV = VaadinObservables
		.observeContainerItemSetContents(table, Person.class);

// bind the lists to each other
dbc.bindList(model, tableOV);

// create a button to add records
Button button = new Button("Add person");
button.addClickListener(new Button.ClickListener() {
	public void buttonClick(ClickEvent event) {
		Person person = new Person();
		person.setName("My first name");
		person.setName2("Another name");
		person.setBirthday(new Date());

This sample binds a WriteableList as a model to the container contents. If a Person is added to the model, the table will update it’s contents.
The Button is used to add new records to the model.

7 Bind a table to a nested list in a bean or pojo

// Activate the realm

final DataBindingContext dbc = new DataBindingContext();

// create a table
Table table = new Table("Persons");
table.setContainerDataSource(new BeanItemContainer<Person>(Person.class));

// create the model
final Person father = createPerson("Father", 43);
father.addToChildren(createPerson("Child 1", 17));
father.addToChildren(createPerson("Child 2", 19));

// observe the table container content
IObservableList tableOV = VaadinObservables
		.observeContainerItemSetContents(table, Person.class);
// observe the nested children list
IObservableList childrenOV = BeansObservables.observeList(father,
		"children", Person.class);

// bind the lists to each other
dbc.bindList(tableOV, childrenOV);

// create a button to add records
Button button = new Button("Add person");
button.addClickListener(new Button.ClickListener() {
	public void buttonClick(Button.ClickEvent event) {
		Person person = new Person();
		person.setName("Child 3");
		// Update the targets

This sample binds a nested children list located in Person.class as a model to the container contents. The Button is used to add new records to the model.

Attention: If a person is added to the children list of the bean, the table is not updated automatically. This happens since the PropertyChangeSupport does not really support notifications for changed collections. So you need to call dbc.updateTargets() or binding.updateModelToTarget().
If you are using the Eclipse Modeling Framework, then also changes in Sets and Lists are automatically transferred to the table, since EMF can deal with notifications for collection changes.

Attention2: If the person bean does not provide PropertyChangeSupport, then you need to use PojoObservables#observeList to create the model observable.


With “Eclipse Databinding for Vaadin” can bind Vaadin components to other components, beans, pojos,… very quickly. The databinding implementation ensures, that values are treated properly. Using “Eclipse Databinding for Vaadin” developers can save a lot of lines of code.

See also

The examples in these additional sources may also be used for the “Eclipse databinding for Vaadin”. The core concepts are always the same.

[1]  Copyright 2015 Vaadin Ltd, licensed under a Creative Commons CC-BY-ND License version 2.0

redVoodo – a good idea to use eclipse databinding

June 29, 2011

Actually i am writing the UI controllers which are connecting the redVoodo UI model with the UI parts that are responsible to visualize the model. After a sleepless night i decided to refactor the whole controller code. The problem was that i had to implement tons of observing code which observes the UI model for a few nodes and causes the UI parts to reflect these changes immediately. Of course, this solutions would have worked really well, but i did not like the way how this solution works.

In this blog i am going to describe why i decided to use eclipse databinding and show some code.

The UI model

RedVoodo offers a functionality called scoped actions and menu items. See post redvoodo-scoped-actions-and-menu-items

Based on this feature actions and menu items are hidden if they are not in the scope of the active framework or sub application. For instance, an action called “delete Item” will only be visible in the “Item Subapplication” but will be hidden for the “Customer Supapplication”. These actions and menu items have “subapplication scope” which means, that they are only visible if a defined sub application is active. But there are also “framework scoped” actions and menu items. Their visibilty depends on the active framework like Sales, Inventory,…

If you want to write an application which tracks the currently active subapplication or framework, perhaps you have to write tons of code if the underlying UI model has a deep structure.

This class diagram shows a simplified version of the redVoodo UI model. The root element of the model is called YUiModel. It can contain exactly one YApplication which is an abstraction of the vaadin application. The YApplication contains many YFrameworks (like Sales, Inventory,…), but only one YFramework can be active at a time. Based on the active framework, different sub applications are shown. So each framework has its own set of YSubapplications. For instance, the framework sales could contain sub applications like Customers, SalesCampains,…

The application, each framework and each sub application can contain their own set of actions. Depending on the active framework and the active sub application, different actions should be visible at the UI.

This image shows what i am talking about:

If the sales framework or a different sub application would be selected, completely different actions and menu items would be shown.

The model shown above is an EMF model. But since redVoodo should be a very extendable framework, using EMF is the default implementation. The core of redVoodo does not have any dependency to EMF. Instead it has a dependency to model controllers. These controllers are called edit parts. The UI parts like the “framework switcher” or the “sub application tree” are using these edit parts to visualize the model but do not have a dependency to the underlying model. So everybody can easily change the default implementation and provide edit parts that are based on a JPA implementation or edit parts that are even hardcoded.

The problem

Yesterday i started to write a lot of code to observe the ui model. I had to fetch the RootModelEditPart which represents YUiModel.

  • I registered a listener at the RootModelEditPart which will be notified if the active application changes.
  • Then i implemented the same issue for the active application and added a listener to the active application which becomes notified if the active framework changes.
  • Then i added a listener to the active framework which becomes notified if the active subapplication changes.
  • Then i added a listener that becomes notified if actions are added or removed.
  • Then i started to handle many different constellations based on parts that become active and deactive.
    • Remove listener from the lower containment structure
    • Switch the parent
    • Add the listener again to the lower contaiment structure
  • Then i detected that each UI part has a different behaviour to the observables. The SubApplicationTabBar has to observe the OpenSupApplications-reference from YFramework too.
  • Then, at 10 p.m. i thought -> Hmmmmmmmmmm, what a boring job!

After a sleepless night, i took all the controller implementations and put it to trash since eclipse databinding can do all that stuff for me. I can heavily reduce the amount of required code and safe a lot of time.

The (really easy) solution

// 1. define a nested property
// 1. define a nested property
String nestedProperties =

// 2. create the observable model value
IObservableValue modelOV = BeansObservables.observeDetailValue(
	new WritableValue(rootModel, IRootEditPart.class),
	nestedProperties, ISubapplicationEditPart.class);

// 3. create the observable target value
IObservableValue targetOV = PojoObservables.observeValue(
	ActionbarPart.this, "subapplicationActions");

// 4. bind model to target
subapplicationActionsBinding = dbContext.bindValue(targetOV,
  modelOV, new UpdateValueStrategy(
  new UpdateValueStrategy(UpdateValueStrategy.POLICY_UPDATE)
	.setConverter(new NotNullConverter()));

1. define a nested property

This nested property will be splitted by the “.” and the reference path starting at the IRootEditPart will be followed for each property.

// "application.activeFramework.activeSubapplication.actions"
// "application.activeFramework.activeSubapplication.actions"
// can be visualized as:

The property “actions” inside the “activeSubapplication” will be observed. Every time it changes – nevertheless why it changes (due to a change of active framework or something) – we are becoming notified.

So we do not have to implement that boring listener hierarchy as described under “the problem”.

2. create the observable model value

Creates an IObservableValue which represents the “actions” property inside the “activeSubapplication” inside the “activeFramework” inside the “application”

3. create the observable target value

Addresses the property “subapplicationActions” of this instance (ActionbarPart.this). Every time the “actions” from “activeSubapplication” changes, the setter this#setSubapplicationActions(IActionEditPart editPart) should be invoked.

4. bind model to target

Therefore the DatabindingContext is used to bind the ObservableValues (model and target) to each other.

And here you can see the implementation of the setSubapplicationActions-method. It stores the subapplicationActions and puts it to the UI.

 * Sets the list of subapplication actions.

 * Called by databinding.
 * @param subapplicationActions
 *            the subapplicationActions to set
public void setSubapplicationActions(
		List subapplicationActions) {


That’s all i had to write to observe a nested property inside my model tree.

I hope you can see the big advantage of eclipse databinding too and hope you give it a try.

Additional informations

Eclipse databinding

06 – Attributes

March 19, 2011

The way how variables are defined in Objective-C is very different to Java. Since Objective-C is dealing with pointers (see (NSString **) value) and developers have to be aware of memory management, the definition of variables is much more complicated and powerful than in Java.

1 – Java attributes

In this blog post I decided to start with the very basics based on Java.

We are deciding between two different kind of variables:

  • instance variables
  • class variables

1.1 – Instance variables

An instance variable is an attribute from a classes instance and exists for each instance. It will be initialized during the creation of the class instance. Instance variables can only be accessed by class instances and not by classes.

Instance variables are accessed like this:

SomeObject object = new SomeObject();
String value = object.value;



1.2 – Class variables

A class variable is an attribute of a class and exists exactly once by class and classloader. It will be initialized at class loading time and can be accessed by classes and class instances. All instances of a class will share this unique state of the variable. If you change the variable, it becomes changed for all instances of this class.

Class variables are accessed like this:

String value = SomeObject.value;


1.3 – Visibility Modifier

Java decides 4 different visibilities:

  • public – visible for all objects
  • protected – visible for all subclasses. Also visbile for classes in the same package
  • private – only visible inside the class
  • default – only visible for classes in the same package

1.4 – Final Modifier

The final modifier defines, that a variable has to be initialized once during the class loading or instance creation, but must never change.

1.4.1 – Final instance variable


Final instance variables are used for different behaviours. Eg to ease the handling of concurreny or to protect the state of a class.

1.4.2 – Final static variable


Final class variables are often used for constant definitions. “static final String” are very common to define constants.


2 – Objective-C attributes

In the second part of this post i am going to define the attributes defined above using Objective-C.

We are going to start with instance variables.

2.1 – Instance variables

Variables are defined in the .h interface file.

If you do not define something special, the attribute has visibility “protected”. You can use it in the .m implementation file and deal with it. Also subclasses of MyClass can access the attribute.

This image shows the attribute access in a subclass of MyClass.

See also:,

2.2 – Class variables

Differing to Java, Objective-C does not allow to use public / protected class variables. If variables are defined as static, they are allways private.

static NSString *anAttribute;

This variable can only be used inside of the class which defines this variable.

Another very confusing behaviour of static attributes is the fact, that they can be defined inside a method and will retain their value during subsequent calls. For instance the singleton pattern uses this very havily.

See for a similar example and a detailed description.


2.3 – Visibility Modifier

If the attribtue should be accessible from other classes, you have to use visibility modifiers.

Please not, that static attributes are always private.

For explanation i changed MyClass and added 3 attribtues with 3 different visibilities.


No i am trying to access them from

  • MyClass.m – should work for all 3 attributes
  • MySubClass.m – should work for protected and public
  • OtherClass.m – should work for public

Everything is fine. No problems reported.




Private attributes can not be accessed by subclasses.



Since OtherClass is not a subclass of MyClass, only public attributes can be accessed. For sure, directly accessing public attributes from classes outside the typehierarchy is not good pratice! But for demonstration it is really well.


2.4 – Final modifier

As you could see, the visibility modifier has a very close semantic to java. But what is about the final modifier?

Actually, Objective-C does not provide a final modifier, but the keyword const (means constant).

But Const offers a much more complex semantic as final does. It allows pointers and / or values of pointers to be defined as “constant”.
“Final” only defines a constant reference which can not be changed, since java does not divide between reference and its value.

Lets compare the different possibilities:


private final Char someString;

The one and only way to define the char as final using java. Final means, that the value of the attribtue can only be assigned once. (During initilization)

It provides 3 different combinations of the const keyword.

// Pointer to constant char
const char* someString;

// Constant Pointer to char
char* const someString;

// Constant Pointer to constant char
const char* const someString;

We are going to use a few lines of code to get a feeling what i am talking about. The following image shows the three combinations of const mentioned above.


  • Example 1“const char* charPtr1” means that the pointer charPtr1 is variable, but “the data the pointer is pointing to” is const. So only the “adress the pointer points to” can be changed. The “value the pointer is pointing to” is constant.


  • Example 2“char* const charPtr2” means that the pointer charPtr2 is constant, but “the data the pointer is pointing to” is variable. So only the value the pointer is pointing to” can be changed. The “adress of the pointer” is constant.


  • Example 3“const char* const charPtr3” means that the pointer charPtr3 is constant, and “value the pointer is pointing to” is constant. Nor the “value or the adress” of the pointer can be changed.

How to define final variables using Objective-C?

I found  a nice discussion about this issue: See

Example 1 : final instance variable

public final String MY_STRING = "MyString";

extern const NSString* const MYSTRING;

const NSString* const MYSTRING = @"myValue";


Example 2 : final static variable

Since static attributes are always private, we do not have to specify anything in the header file. It is enough to specify the attribute in the implementation file.

public static final String MY_STRING = "MyString";

==> Nothing to do. static attribute is always private!

static const NSString* const MYSTRING = @"myValue";

WordPress in google webmaster tools

March 13, 2011

How to register your blog at webmaster tools

The last hours it tried to register this wordpress blog in google webmaster tools.

After several unavailing attempts using the “Upload an HTML file to your server” option, i found a really simple solution.

Some time ago it seemed, that registering a wordpress blog at the google webmaster tooling was performed using the “Upload an HTML file to your server”. But it does not work anymore! I always got the error that the content of the website has wrong format.

The way to do

Assumed you already have a google webmaster account, i am going to explain the steps required to register a wordpress blog.

The first step is to add your site. There is nothing special.

To perform the next step, you have to select the option “Add a meta tag to your home page”. For normal you would have to paste this meta tag to the head section of your html-file.

Since we do not have access to the wordpresssite head tag, we are using a feature provided by wordpress.

Navigate to tools and paste the meta tag to the input field “Google Webmaster Tools”. Accept your input by saving the settings.

Final step – now you can return to “google webmaster tools” and verify your site. Everything should work properly and your wordpress blog had been added to the “google webmaster tools”.

05 – Protocol for Interface

March 10, 2011

Java Interface

Interfaces are used very havily inside of java applications. They allow the programmer to decouple different parts of the code and to make them independent.

Additionally they are used to define a contract which specifies methods which have to be implemented by subclasses. It is very comfortable to code against interfaces, rather than implementations.


Interface implementation

The following syntax is used to implement an interface into a class:

class MyClass implements SomeInterface


Objective-C Protocols

Objective-C provides a similar approach called Protocols. Protocols have a very close semantic as interfaces, but allow you to mark methods as @optional. Optional methods can be implemented by subclasses, but it is not required.

Protocols are defined by the @protocol directive.

@protocol SomeProtocol
    .... methods

The SoundMachine protocol would look like this:

It’s really looks very close to the java declaration. Also the implementation class of this interface is very similar to java.

The .h file

and the .m file



If you would like to test whether a class implements a protocol you can use the conformsToProtocol message. It is similar to the instanceof check from java.

Objective-C: conformsToProtocol

Java: instanceof


@optional methods

In contrast to Java, Objective-C adds an additional semantic feature for protocols. Methods can be defined as optional. This means, that they do not have to be implemented by the class that implements the interface.

Java does not allow unimplemented interface methods. All the methods from an interface have to be declared in the classes type hierarchy.

The following image shows how optional methods can be implemented in Objetive-C:

If a class implements this protocol but does not add a method implementation for the optional methods, the compiler won’t mention this issue.

Therefore i have prepared an MyProtocolImpl.m class which implements MyProtocol. No methods have been implemented in the class before compiling it.

As you can see at the screenshot, the compiler only mentioned the missing required methods.

Calling an optional unimplemented method

If you are providing optional protocol methods, you have to ensure that messages are sent to these classes only if they implement the methods addressed by the message. Otherwise the call will result in an error.

The following image shows an implementation of MyProtocol. The anotherOptional-method is NOT implemented. A call to it would result in an error.

Therefore i have prepared a second class which will call the missing method by sending a message.

During the call of the anotherOptional-method call the Objective-c runtime sends the following error to the message console.

2011-03-10 12:56:02.923 MS4[21571:a0f] -[MyProtocolImpl anotherOptional]:
                        unrecognized selector sent to instance 0x1001611a0

To avoid such errors, the call schould be protected by the respondsToSelector message. This message will return FALSE, if the receiver of the message does not implement a method which responds to the message.

Since the receiver does not implement the method, it will not be called.


Additional informations