Drombler FX: Version 0.7 released

I recently released v0.7 of Drombler FX - the modular application framework for JavaFX.

It has been a while since the last release but a lot of work has been undertaken.

Drombler moved from SourceForge.net to GitHub.
This includes:

• You can find all Drombler repositories on the Drombler GitHub organization site.
• All Drombler repositories have been migrated from Mercurial to Git
• The Gitflow has been configured for all repositories. You can find the current development in the develop branches (default branch) and the released versions in the master branch.
• The static pages as well as the Wiki pages haven been migrated to GitHub Pages.
• The tutorial has been migrated from the Wiki pages to Asciidoc files which are also published to the GitHub Pages. The Asciidoc files allow to
• compile the included samples first, to make sure the correct version of the API is used and that there is no typo
• keep different versions of the tutorial for different releases
• publish the tutorial in different formats
• easily style the tutorial 
• The issues have been migrated to the issue system provided by GitHub.

Experiments with CDI & OSGi

A lot of work has been done in experiments to integrate CDI and OSGi.

Unfortunately, among several issues

• the fact that at the time of writing the specification how CDI should work in an OSGi environment is still not final yet
• the major difference between the dynamic nature of OSGi services and the static nature of CDI bean discovery at startup, which are hard to overcome
• issues when trying to integrate CDI providers with OSGi Dynamic Services

put an end to these experiments for now.

Please join the discussion here how CDI still could be integrated into a future version of Drombler FX.

Dockable selection notification

There are now 2 new method-level annotations: @Select and @Deselect.

The annotated methods get called, if present, when the currently selected Dockable (eg. represented as a Tab) of a Docking Area (eg. represented as a TabPane) changes.

(Every non-empty Docking Area has one selected Dockable - the one which is visible.)

@Select public void select() { System.out.println("Selected sample: " + dockableData.getTitle()); } ... @Deselect public void deselect() { System.out.println("Deselected sample: " + dockableData.getTitle()); }  

Modified Dockables

FXDockableData has a new modified-property to indicate if the data represented by the Dockable has been modified.

The behavior of the default skin is to add/ remove the CSS style class "dockable-modified" to/ from the tab representing the Dockable whenever this flag changes.

The default CSS changes the tab font to bold.

The DockableDataModifiedManager listens for Savable in the local contexts of the Dockables and synchronizes the modified-property of FXDockableData accordingly.

Drombler FX configures this manager out-of-the-box.

The effect is that whenever you add a Savable to the local context of a Dockable, the font of the tab will change to bold indicating that the content of the tab has changed and hasn't been saved yet. Since the "Save" action and the "Save All" actions also listen for Savable in the active/ application context, they get enabled accordingly. When you click on one of these save buttons/ menu items, then they call the according save method of the Savable, which should remove itself from the local context again and thus disable the save actions and changing the tab font back to default.

All this works in a loosely coupled way thanks to the Context Framework. All you have to do is to add/ remove the Savable to/ from the local context of the Dockable.

To inform the application framework that the Dockable provides a local context, the Dockable needs to implement the LocalContextProvider interface eg. by using a SimpleContext.

The save method of the Savable then can be implemented to store the content to a file, to a DB, call an EJB or a webservice, send a JMS message or whatever your application has to do for this kind of data.

Pluggable application layout

The application layout is now pluggable!

Add the following dependency to use a classic desktop application layout with a menubar, a toolbar and a content area as the content of the JavaFX application.
<dependency> <groupId>org.drombler.fx</groupId> <artifactId>drombler-fx-core-standard-desktop-classic</artifactId> <scope>runtime</scope> </dependency>
You can replace this dependency with your own implementation of MainSceneRootProvider, which needs to be registered as an OSGi service.

By providing your own implementation you can make your application look completely different.

Please note that the content of the content area of the default application layout is pluggable, too!

Add the following dependency to use the Docking Framework for the content area.

<dependency> <groupId>org.drombler.fx</groupId> <artifactId>drombler-fx-core-docking</artifactId> <scope>runtime</scope> </dependency>
This dependency also configures the Docking Framework to integrate with the Context Framework.

You can replace this dependency with your own implementation of ApplicationContentProvider, which needs to be registered as an OSGi service.

By providing your own implementation you can make the content area look completely different while keeping the classic desktop application layout, which uses the Action Framework to register menu items and toolbar buttons with annotations.

Please note that several packages have changed.

Several refactorings have been done, which moved classes to different packages.
If a class isn't found anymore try to delete the import statement and re-import the class again using your IDE of choice. Also have a look at the available Maven Coordinates by following the links in the table below.


Concluding remarks

You can find the complete list of fixed issues here: https://github.com/Drombler/drombler-fx/issues?q=milestone%3A0.7


There's a Getting Started page which explains how to create, build and run a Drombler FX sample application with a few simple steps.


The following table provides you an overview of the different Drombler components, links to the modules, which are available from Maven Central, and links to the Javadocs.
  

Name	Modules (incl. Maven Coordinates)	Javadoc	Description
Drombler FX	Modules	Javadoc	Drombler FX, the modular application framework for JavaFX based on: OSGi Maven (POM-first) a declarative programming model Drombler ACP  Drombler Commons.
Drombler ACP	Modules	Javadoc	Drombler Abstract Client Platform (ACP) is an abstract, GUI-toolkit agnostic, modular Rich Client Platform based on: OSGi Maven (POM-first) a declarative programming model Drombler Commons.
Drombler Commons	Modules	Javadoc	Drombler Commons is a collection of reusable libraries and frameworks. They ship with OSGi meta data but don't require an OSGi environment.

If you find issues or have enhancement requests, you can file a ticket here: https://github.com/Drombler/drombler-fx/issues.