e(fx)clipse 2.1.0 released

I’m happy to announce that e(fx)clipse 2.1.0 has been released today and it has a heap of new features and bugfixes (in total 49 tickets have been resolved).

The project

Starting with this release I’d like to publicly document the amount of time we spend on the project. For this 2.1.0 we spend ~150 work hours and another ~60 private hours. So if you appreciate all this we certainly welcome all donations.

In the next release cycle we’ll also setup bug bounties for often requested features like Min/Max support or detach through DnD. In case you miss something don’t be shy get in touch with us.

Where do you get it

  • Tooling:
  • Runtime:
  • Core libraries published on maven central

    As many of our components don’t require to run in an OSGi-Environment and can be used in any application we started to publish them on maven-central.

    • Eclipse Platform
      • com.ibm.icu.base
      • org.eclipse.e4.core.di.annotations
      • org.eclipse.equinox.common
      • org.eclipse.jdt.annotation
    • e(fx)clipse
      • org.eclipse.text
      • org.eclipse.fx.core
      • org.eclipse.fx.ui.panes
      • org.eclipse.fx.ui.animation
      • org.eclipse.fx.ui.controls
      • org.eclipse.fx.core.di
      • org.eclipse.fx.text
      • org.eclipse.fx.text.ui
      • org.eclipse.fx.code.editor
      • org.eclipse.fx.code.editor.fx

    Smart Code editing

    If you follow this blog regularly it should not be a surprise that one of the main working areas has been to extract components from our research projects and make them available as loosely coupled components allowing one to implement code editors in a very simple way (nothing is bound to OSGi and e4!).


    We ship lexical highlighters you can use in your own applications for the following languages by default:

    • go
    • dart
    • groovy
    • java
    • js
    • kotlin
    • php
    • python
    • rust
    • swift
    • xml

    In case you are interested in using the APIs there’s a series of blogs who introduce the APIs and the tooling who makes it very easy for you to develop an editor for your favorite language or DSL:

    and more blogs on this topic will follow soon. Finally it is important to understand that all the code editing APIs are declared as provisional because we need to get feedback from adopters and maybe adjust them here and there.

    New APIs

    There’s a bunch of new APIs available and I won’t describe all of them but the most interesting are:

    @Preference / Value

    While there’s a preference annotation in the e4 platform we ship our own one because the current implementation available from the platform is not working the way we expect you to develop components (hint: we expect you to write components without any dependency on OSGi and eclipse platform APIs).

    Usage is straight forward:

    import org.eclipse.fx.core.preferences.Preference;
    import org.eclipse.fx.core.preferences.Value;
    class MyComponent {
      Value<String> sValue;
      Value<Integer> iValue;

    And because the the annotation can make use of the adapter services who are part of the core platform you can exchange Value through javafx.beans.property.Property<T>. Read more at the wiki.


    A similar problem you face with publishing preferences or context values is to publish informations on the IEventBroker who has a compile time dependency on the OSGi-Event-Interface.

    Starting with 2.1.0 we provide our own simple EventBus-API you can use instead of the IEventBroker when publishing events. In an e4 application we simply wrap the IEventBroker and none OSGi users we provide a default implementation org.eclipse.fx.core.event.SimpleEventBus.

    Usage is straight forward

    import static org.eclipse.fx.core.event.EventBus.data;
    class MyComponent {
      private final EventBus bus;
      public MyComponent(EventBus bus) {
        this.bus = bus;
        this.bus.subscribe( "my/app/config/changed", 
          e -> { handleConfigChange(e.getData()) } );
        // or for the cool kids
        this.bus.subscribe( "my/app/config/changed", 
          data(this::handleConfigChange) );
      public void publishSelection(Person p) {
        bus.publish("my/app/person/changed", p, true);
      public void handleConfigChange(Config c) {
        // ...

    Adornment Graphics Node

    While a similar API has been / is available as part of the e(fx)clipse e4 APIs we introduce in 2.1.0 a very similar on as part of our controls component so it can be used by none OSGi applications as well.

    For those who ask themselves what adornments are good for the following screenshot of the dart code editor might help


    The graphics shown in next to the bottom entry is not a single image but made up from

    • methpub_obj
    • property

    Usage is straight forward:

    Image b = new Image(getClass().getResource("methpub_obj.png").toExternalForm());
    Image p = new Image(getClass().getResource("property.png").toExternalForm());
    AdornedGraphicNode node = new AdornedGraphicNode( b, 
      Adornment.create(Location.LEFT_TOP, p) );

e(fx)clipse 2.0 – Is released

I’m a bit late to announce the release of e(fx)clipse 2.0 but I’ve been heads down in e4/JavaFX projects so I did not yet have time to blog about the release in detail.

Where to get it from

Naturally we provide p2 update sites:

We also updated our All-In-One builds where we also bundled:

New Features / APIs

The main focus of the release clearly was on the runtime layer where we fixed 119 Bugzilla-Tickets (most of the enhancements). Below is a list of the more interesting ones.

Updateing your application got a lot easier

To put it in kind words the p2-API is a very low-level and noisy one allowing you to do crazy stuff but frankly all you really want is to request an update for your application. So this should be damn easy. With 2.0 we made it dead simple for you:

  • Tooling: The new application wizard allows you to directly bootstrap an application who has all necessary bits to update through p2
  • Runtime: We have had a unfunctional implementation which we revised (big thank to Dirk Fauth)
    import org.eclipse.e4.core.di.annotations.Execute
    import org.eclipse.fx.core.update.UpdateService;
    import org.eclipse.fx.core.update.UpdateService.UpdatePlan;
    import org.eclipse.fx.core.update.UpdateService.UpdateResult;
    import java.util.Optional;
    import org.eclipse.fx.core.ProgressReporter;
    import org.eclipse.fx.core.StatusException;
    public class RequestUpdate {
    	public void update(UpdateService service) {
    	private void onCheckComplete(Optional<UpdatePlan> updatePlan) {
    		if (updatePlan.isPresent()) {
    		} else {
    			// Show nothing to update
    	private void onUpdateSuccess(UpdateResult result) {
    		// Inform that the update has finished
    	private void onException(StatusException updatePlan) {
    		// Show info that status update failed

New styled text APIs

In case you’ve seen me at demo camps, EclipseCon and XtextCon you noticed that we have put a lot of time into the StyledTextArea which we reworked internally a lot and so things like selection, … are working properly now! The nice side effect of the reworking of StyledTextArea internals is that we managed to factor out internal into reuseable small APIs.

  • StyledString: A java.lang.CharSequence who is made up of StyledStringSegments who have style classes associated with them
  • StyledLabel: Similar API to javafx.scene.control.Label allowing you to represent a StyledString in the scenegraph
  • StyledTextNode: A scenegraph node who is able to show arbitary decorations on a text string
  • StyledTextLayoutContainer: A scenegraph node who is able to display selections
  • SimpleTreeCell & SimpleListCell: Got enhanced to supported StyledString if the CharSequence provided by the labelExtractorFunction is a StyledString

The following screenshots shows some of them working together to present an Dart-Editor

In the center is the StyledTextArea, the autocompletion dialog uses SimpleListCell and the outline view the SimpleTreeCell.

FilterableTreeItem & SortableTreeItem

Our UI-Library got 2 now TreeItem implementations who support filtering and sorting! The most remarkable thing is that they have not been developed by BestSolution.at but Christoph Keimel has contributed them!

Get in control of the e4 window WITHOUT providing a custom renderer

Previous version had very limited support for controling your window. Starting with 2.0 we provide a (provisional) API who allows you to control almost anything from your window! For that we developed an abstract window API (org.eclipse.fx.ui.controls.stage.Frame) and also ship some default implementations (eg org.eclipse.fx.ui.controls.stage.DefaultTrimmedWindowPane).

In the screenshot below we’ve relocated the MenuBar into a HBox with a search field at the end to save vertical space


Lightweight dialogs

Based on the Frame/Window API who is used in the renderer code in a heavy weight fashion we also have a new lightweight dialog system who is built around this API beside a base org.eclipse.fx.ui.controls.dialog.Dialog class we ship 2 implementations people we most likely use very frequently:

  • TitleAreaDialog
  • MessageDialog

e4 supports lightweight dialogs

While the lightweight dialog API can be used by any application, e4 applications can make use of lightweight dialogs through a new service named org.eclipse.fx.ui.services.dialog.LightWeightDialogService so opening a dialog who takes the complete window can be done with:

public void openDialog(LightWeightDialogService service) {
    MyDialog d = new MyDialog();
    service.openDialog(d, ModalityScope.WINDOW);

While the dialog service allows to open a dialog and control it’s modality there’s a 2nd service who is able to control how a dialog is shown/hidden. By default the dialog is simply show and hidden but you can for example add some nice animations like shown in the video below.

e(fx)clipse 1.0 released

The release

I’m happy to announce the 1.0 release of e(fx)clipse tooling and runtime. I’ve already introduced the most interesting new features in the last 2 weeks

… but there are many many other small improvements, bugfixes, … .

We resolved more the 100 Bug/Feature-Tickets, started to see commercial adoption of our runtime and a vibrant community who started contributing back fixes, filed world class bug reports.

As with any release I’d like to thank some people/organizations:

  • BestSolution.at for sponsoring the development
  • External contributors like Christoph Keimel & Sun Volland for their excellent contributions to the runtime platform
  • the OpenJFX-Team to fix bugs affecting e(fx)clipse and accept contributions so that we could implement missing features

The final bits are in place for you to consume:


I hope you all enjoy the work we’ve done and continue to provide in the next releases to come. Still we could need some help: You might consider sponsoring the project, so that we can provide the services you are used to and provide a reliable tooling & runtime platform you can build your business applications on.

For more information on sponsoring and the packages available take a look at http://efxclipse.bestsolution.at/sponsoring.html or if you need commercial support see http://efxclipse.bestsolution.at/services.html.

JavaFX in Eclipse Magazin 02/2013

The Eclipse magazin has published an interview with me about JavaFX, Eclipse and e(fx)clipse.

For those of you interested in JavaFX & Eclipse the next issue (2/2013) holds a lot of information on the topic:

The content of the interview is in German, I’ll publish a translation in about a month on this blog if google translate doesn’t do its job good enough😉

UUID-Generator Plugin

Today it once more was the time where I had to generate Test-Data and for this purpose I had to create UUIDs. My first reaction was to write a small program which was generating some UUIDs i could use like Lars is showing in one of his blog entries which was what I had done before already number-times.

Today I decided against and to fix this problem for all times. So I wrote a highly sophisticated Plug-In🙂 for my favorite IDE named Eclipse:

Though the Plug-In Code holds a lot of my personal know how I finally decided to make it available to everyone under EPL and upload the code to to EclipseLabs.org in a new project. If you are in need of generating UUIDs inside your Eclipse Env you can simply install the Plug-In using this update-site.

I’m using Flattr.com

For many of you this might not be new but I’ve just found out about flattr.com which allows me to support blogs, software, … I find useful.

In case you find my blog useful you’ll find the the flattr-button
Flattr this

on the upper right on my blog. It’s a bit unfortunate that I’m not able to use the dynamic one on my wordpress.com-blog because it needs JavaScript.