Drombler FX: Version 0.8 released

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

This version comes with two new major features: Single Instance Application and an initial version of a Data Framework which integrates with the Docking Framework.

Single Instance Application

Single Instance Application is an optional feature, which ensures that there is only one instance of your application running, even if the user starts the application several times.

This feature is provided out-of-the-box. It is disabled by default, however, but can be enabled by simply specifying the defaultSingleInstancePort property of the Drombler FX Maven Plugin.

<plugin> <groupId>org.drombler.fx</groupId> <artifactId>drombler-fx-maven-plugin</artifactId> <extensions>true</extensions> <configuration> ... <!--Uncomment the following line and specifcy an unused port to create a single instance application --> <!--<defaultSingleInstancePort>some unused port</defaultSingleInstancePort>--> ... </configuration> </plugin>

If this feature is enabled and one instance is aleady running, each other application start will pass all its unnamed parameters to the first instance and shuts itself then down. Drombler FX will register a new instance of AdditionalArgumentsProvider for every application start notification.

Read more about Single Instance Application in the new tutorial trail.

Data Framework

This version introduces an initial version of a Data Framework which integrates with the Docking Framework.

At the core of the Data Framework is the concept of Data Handlers. A Data Handler wraps an instance of a particular kind of data and usually knows how to read, save etc. this particular kind of data.

To register a Data Handler for a business object, which e.g. has been obtained from a web service call, use the @BusinessObjectHandler annotation:

@BusinessObjectHandler(icon = "bar.png") public class BarHandler extends AbstractDataHandler<String> {

To register a Data Handler for a document use the @DocumentHandler annotation:

@DocumentHandler(mimeType = "text/foo", icon = "foo.png") public class FooHandler extends AbstractDocumentHandler {
To associate some file extensions with a MIME type you can register the file extensions using the @FileExtension annotation:

@FileExtension(displayName = "%fooFileExtension.displayName", mimeType = "text/foo", fileExtensions = "foo", position = 10) package tutorial.data;

Read more about the Data Framework in the new tutorial trail.

Docking Framework changes and enhancements

This version comes with some changes and several enhancements of the Docking Framework, especially also to integrate the Docking Framework with the newly introduced Data Framework.

One of the biggest changes is how you register and open an Editor:

A Dockable Pane can still be registered as an Editor by using the @EditorDocking annotation, but this annotation now specifies the contentType:

@EditorDocking(contentType = FooHandler.class) public class DockableEditor extends GridPane {

The annotated Editor is required to have a constructor with a single parameter of type contentType().

This contentType is usually a Data Handler registered either with @BusinessObjectHandler or with @DocumentHandler. The icon of the Data Handler will be used in the tabs of the Editors. You also don't specify the Docking Area for Editors anymore.

The standard "center" Docking Area has been renamed to "editor" and is the default Docking Area for Editors if you're using the standard Docking Areas.

There are several ways to open an Editor for a Data Handler:

• Pass a file path as an argument at application start: based on the registered file extensions, Document Handlers and Editors the corresponding Editor will be opened.
   
• Use the generic Open Files menu entry provided by the org.drombler.acp:drombler-acp-core-standard-action-data-file Maven module: again based on the registered file extensions, Document Handlers and Editors the corresponding Editor will be opened.
   
• Call FileUtils.openFile: again based on the registered file extensions, Document Handlers and Editors the corresponding Editor will be opened. The FileExtensionDescriptorRegistry and the DocumentHandlerDescriptorRegistry can be obtained from the registered OSGi services FileExtensionDescriptorRegistryProvider and  DocumentHandlerDescriptorRegistryProvider respectively.
   
• Call Dockables.openEditorForContent: based on the registered Data Handlers and Editors the corresponding Editor will be opened.

Apart from the integration with the Data Framework, the Docking Framework comes with the following enhancements:

• If the framework detects that there's already an Editor open for the provided content, the existing Editor gets selected rather than a new one opened.
   
• If you close an unsaved Editor or if you close the window/ application while there are still unsaved Editors open, the Docking Framework detects this and provides an according dialog.

Putting all together

The enhancements provided by the Data Framework, Docking Framework and Single Instance Application support allow you for instance to create Single Instance Applications where the user can pass a file path argument to the application and the according Editor will be opened/ selected in the first (single) instance of the application.

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 and have a look at the provided sample application.

Concluding remarks

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


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.

News from the Software Smithy: Version 0.6 released

SoftSmithy news: I recently released a new version of the SoftSmithy Utility Library and the SoftSmithy Development Utility Library.

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

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

• You can find all SoftSmithy repositories on the SoftSmithy GitHub organization site.
• All SoftSmithy 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.

Java SE 8

All modules require now at least Java SE 8.

In addition some small additions, fixes and clean-ups have been added.

Note that for easier version management the version of the SoftSmithy Development Utility Library is aligned with the version of the SoftSmithy Utility Library. As the SoftSmithy Development Utility Library has a dependency on the SoftSmithy Utility Library it's recommended to use the same version of both libraries until the APIs are stable!

You can find the lates Javadoc here: Javadoc

I deployed the artifacts (including the source and javadoc artifacts) to Maven Central.