EclipseCon 2007 Data Binding Long Talk

If you have an interest in learning about binding some data, being data bound, being bound and... I got nothing... please vote for the Introduction to Eclipse Data Binding long talk being proposed for EclipseCon.

Straight from the horse's mouth:

"It’s new, it’s cool, and it helps you write better code!"

I soooooo want to write better code; I'm game. Please vote!

Master Detail Sequence Diagram

One of the new packages in HEAD is org.eclipse.core.databinding.observable.masterdetail. It contains observable implementations that provide master detail behavior. This can be a little confusing at first glance so I thought I'd take a shot at creating a sequence diagram to describe the inner workings. Possibly this, or some form of it, will get worked into our documentation but I thought I'd throw it out there for anyone looking at the latest API.



Comments are greatly appreciated. Also if someone knows where I can get a higher resolution Eclipse logo I'd appreciate the tip.

Project renaming and removal of provisional API

On Friday the concurrency branch, Bug116920_investigation, was merged into HEAD and the projects have also been renamed. This means that Realms are now in HEAD and most provisional API has been removed. What that means is that with HEAD your code probably doesn't compile.

Project Renaming

• org.eclipse.jface.databinding -> org.eclipse.core.databinding


• org.eclipse.jface.databinding.beans -> org.eclipse.core.databinding.beans


• org.eclipse.jface.databinding.ui -> org.eclipse.jface.databinding


• org.eclipse.jface.examples.databinding


• org.eclipse.jface.tests.databinding

Realms

Realms deserve more than a blog post so I'm going to leave this until later; there will be documentation on the subject. To see what has led us down this path see bug 116920. Take a look at the examples and tests projects for usage. There's also a ThreadRealm and LockRealm implementation in the tests projects.

Provisonal API Removal

The majority of the consumer code that could be broken is the result of the removal of the provisional API. The majority of that API existed to allow for the binding of viewers to a model. Previously the only API that the consumer had for this was a builder that then took care of creating the label and content providers. We don't yet have replacements for the builders but we have API for content providers and label providers which can be used to bind viewers without a builder. By exposing these classes this allows for flexibility that we didn't previously have. Consumers now have access to the label provider and can create a decorator to provide colors, fonts, images, etc. as well as the text. Below is a quick example of the creation of the label and content providers for a ComboViewer.

    1 //Create the observable for the domain list.
    2 IObservableList lodgings = BeansObservables.observeList(Realm
    3     .getDefault(), catalog, "lodgings");
    4 //Create the content provider that corresponds to the observable list.
    5 ObservableListContentProvider contentProvider = new ObservableListContentProvider();
    6 
    7 //Create a mapping for the attribute to display.
    8 IObservableMap[] attributeMaps = BeansObservables.observeMaps(
    9     contentProvider.getKnownElements(), Lodging.class,
   10     new String[] { "name" });
   11 
   12 cviewer.setContentProvider(contentProvider);
   13 cviewer.setLabelProvider(new ObservableMapLabelProvider(attributeMaps));
   14 cviewer.setInput(lodgings);

The key to this is the creation of the attributeMaps (line 8). In this case we're only specifying one attribute, name (line 10), because it's a Combo. In the map returned the key will be the element and the value will be the display value of the name attribute of the element.

Stay tuned, it's going to be a busy next couple of months.

A Focus on Data Structures

HEAD hasn't had many changes lately for data binding because of the 3.3M3 release. But this doesn't mean that nothing has been happening. Changes have been occurring in the concurrency branch (Bug116920_investigation) for, you guessed it, concurrency. But the branch has also been used for removing provisional packages and the refactoring of some of the provisional code into API. But before I get into the other changes it's very important to us that we get as many eyes on the concurrency approach as possible. If you're a concurrency guru or just someone with a interest please read through bug 116920 and provide feedback if you have any.

The other changes that have been occurring are interesting. If you are vaguely familiar with JFace Data Binding you probably know that data binding is comprised of two parts: observables and bindings. The idea behind bindings is pretty straight forward and what you would expect from the name. They bind two entities and provides a MVC-esque flow of data to keep the 2 in sync. This is normally applied in the context of a graphical user interface in order to keep the UI in sync with a model. But there's more that needs to be implemented in order to make this synchronization and this is where observables come in. Observables are an implementation of the observer pattern and they create a common abstraction that allows for the observing of changes in an object. This all begins with IObservable but branches out into:

IObservableValue

Interface for the observing of a single value.

IObservableList

Interface for observing changes in a List. The notifications are notifications of when items are added or removed from the List. If an object being maintained in the List changes events are not fired from the IObservableList implementation.

IObservableSet

Interface for observing changes in a Set. Like IObservableList the change events are for items being added and removed from the Set.

IObservableMap

Interface for observing changes in a Map. And you guess it, same type of behavior as the previous interfaces but for a Map.

For all of the above interfaces there are default mutable, or writable, implementations.

• WritableValue


• WritableList


• WritableSet


• WritableMap

By providing these implementations we, and any consumer, can use the observable implementations for any need that arises. The need doesn't have to be for binding a widget to a model, it can be any use case that you're wanting to provide notifications for a data structure. The idea is that the abstraction should feel common and also provide building blocks, just like the Collections Framework, for application needs.

In order to drive home the idea that the core of data binding doesn't necessarily have anything to do with UI the core interfaces and implementations that are UI unaware will reside in plug-in org.eclipse.core.databinding. The project is currently named org.eclipse.jface.databinding but will soon be renamed, see bug 153630 for details.