Drombler FX: Version 1.0 released

I've recently released the version v1.0 of Drombler FX - the modular application framework for JavaFX.

With this release I changed the version policy. I'm using now the major version part as well to make it easier to distinguish between major requirement changes such as the Java version:

• v1.x: Java SE 8 and JavaFX 8 based
• v2.x (future): Java SE 11 and JavaFX 11 based (likely)

The released JARs contain the Automatic-Module-Name Manifest entry to make the transition to Java SE 11 smoother.

For this v1.0 release I've added Javadoc to all published classes and members of  Drombler FX, Drombler ACP (except the generated JAXB classes) and Drombler Commons. 

There's now also a new Extensions tutorial trail.

Some APIs were fixed and some clean-ups were added as well.

Because some code has been moved, please note that some of the packages and Maven dependencies changed, too.

Please note especially, that localized texts are now expected in a separate properties file in the same package and with the same name as the annotated classes by default, and not in the package Bundle.properties file anymore (this can be configured per annotated class, though).
This makes it easier to move annotated classes to other packages and to see which texts are still in use.

With this v1.0 release out I will now start the work to migrate Drombler FX to Java SE 11 and JavaFX 11.

Additional Information

Projects like this one need to be build by a community working together to be really successful. There are several ways how you can contribute to this project. Contributions are highly welcome! See the "How to Contribute"-page for more information.

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


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.

 

Drombler FX: Version 0.12 and 0.13 released

Since introducing a modular StatusBar and ProgressMonitor earlier this year, I've released v0.12 and v.013 of Drombler FX - the modular application framework for JavaFX.

In this releases some of the Drombler FX/ ACP start-up code has been moved to Drombler Commons.
This allows also non-Drombler FX/ ACP applications, such as the Drombler JStore Client Agent, to reuse start-up code such as:

• distinction between user directory and installation directory
• simple command line arguments / switches support 
• extendable BootServiceStarter framework 
• "single instance" support, which makes sure the application runs only once per user directory and passes the command line arguments to the running single instance

Because the code has been moved, please note that some of the packages and Maven dependencies changed as well.

Please also note that org.drombler.commons.fx.scene.GraphicFactory moved to org.drombler.commons.client.graphic.GraphicFactory with these releases.

 

Small Enhancements

There are small enhancements to work with directories, data handlers, collection bindings and TreeViews. 

Please check the documentation to learn more about them.

Additional Information

Projects like this one need to be build by a community working together to be really successful. There are several ways how you can contribute to this project. Contributions are highly welcome! See the "How to Contribute"-page for more information.

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


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.

 

Drombler FX v0.11: modular StatusBar and ProgressMonitor

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

This release comes with the integration of two new JavaFX controls.

StatusBar

The first is a rather simple one: a StatusBar. It maintains three lists of elements: leftElements, centerElements and rightElements. The elements are layed out accordingly.
The control is Skinnable and Styleable and can also be used in non-OSGi JavaFX applications. As you might guess, the main intention of this control is to show the user additional information at the bottom of your application.

Drombler FX provides declarative, modular integration of this StatusBar:
@StatusBarElement(horizontalAlignment = HorizontalAlignment.CENTER, position = 20) public class SampleStatusBarElement extends BorderPane { }
The annotated Node sub-class will be added to the according StatusBar elements list at the specified position.

If two adjacent StatusBar elements are positioned in different thousand groups (e.g. position = 910 and position = 1120), a Separator gets automatically registered between them.

For more information see the new StatusBar tutorial trail.

ProgressMonitor

The second new JavaFX control is ProgressMonitor.
This control allows to monitor any number of running, cancelable Workers.

[1] a label bound to Worker#titleProperty
[2] a label bound to Worker#messageProperty
[3] a progress bar bound to Worker#progressProperty
[4] a button to execute Worker#cancel
[5] an indicator if there are additional workers being monitored
[6] a popup showing all monitored workers

The control is Skinnable and Styleable and can also be used in non-OSGi JavaFX applications. The main intention of this control is to be added to a StatusBar.

Here is a small sample application showing the ProgressMonitor and the StatusBar in action:

package test; import java.nio.file.Files; import java.nio.file.Path; import java.nio.file.Paths; import java.util.ArrayList; import java.util.List; import java.util.Locale; import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; import javafx.application.Application; import javafx.concurrent.Task; import javafx.concurrent.Worker; import javafx.geometry.HPos; import javafx.scene.Scene; import javafx.scene.control.Button; import javafx.scene.layout.ColumnConstraints; import javafx.scene.layout.GridPane; import javafx.scene.layout.Priority; import javafx.scene.layout.RowConstraints; import javafx.stage.Stage; import org.drombler.commons.fx.concurrent.WorkerUtils; import org.drombler.commons.fx.scene.control.ProgressMonitor; import org.drombler.commons.fx.scene.control.StatusBar; public class ProgressMonitorSampleApplication extends Application { private final List<Worker<?>> workers = new ArrayList<>(); private final ExecutorService executorService = Executors.newCachedThreadPool(runnable -> { Thread thread = new Thread(runnable); thread.setDaemon(true); return thread; }); private long counter = 1; @Override public void start(Stage primaryStage) throws InterruptedException { StatusBar statusBar = new StatusBar(); ProgressMonitor progressMonitor = new ProgressMonitor(); statusBar.getRightElements().add(progressMonitor); addTestWorker(counter++, progressMonitor); Thread.sleep(2000l); addTestWorker(counter++, progressMonitor); Button createButton = new Button("Create Task"); createButton.setOnAction(event -> addTestWorker(counter++, progressMonitor)); GridPane root = new GridPane(); root.add(createButton, 0, 0); root.add(statusBar, 0, 1); ColumnConstraints columnConstraints = new ColumnConstraints(); columnConstraints.setHgrow(Priority.ALWAYS); columnConstraints.setHalignment(HPos.CENTER); root.getColumnConstraints().add(columnConstraints); RowConstraints rowConstraints1 = new RowConstraints(); rowConstraints1.setVgrow(Priority.ALWAYS); rowConstraints1.setFillHeight(false); RowConstraints rowConstraints2 = new RowConstraints(); rowConstraints2.setVgrow(Priority.NEVER); rowConstraints2.setFillHeight(false); root.getRowConstraints().addAll(rowConstraints1, rowConstraints2); GridPane.setFillWidth(createButton, Boolean.FALSE); GridPane.setFillWidth(statusBar, Boolean.TRUE); Scene scene = new Scene(root, 800, 200); primaryStage.setTitle("ProgressMonitorSampleApplication"); primaryStage.setScene(scene); primaryStage.show(); } private void addTestWorker(long id, ProgressMonitor progressMonitor) { final TestWorker testWorker = new TestWorker(id); testWorker.stateProperty().addListener((observable, oldValue, newValue) -> { if (WorkerUtils.getFinishedStates().contains(newValue)) { workers.remove(testWorker); } }); workers.add(testWorker); executorService.execute(testWorker); progressMonitor.getWorkers().add(testWorker); } public static void main(String[] args) { configureLogging(); launch(args); } private static void configureLogging() { Locale.setDefault(Locale.ENGLISH); Path loggingPropertiesPath = Paths.get("src", "test", "resources", "test", "logging.properties"); System.out.println("Logging configuration file: " + loggingPropertiesPath + " exists: " + Files.exists(loggingPropertiesPath)); if (Files.exists(loggingPropertiesPath)) { System.setProperty("java.util.logging.config.file", loggingPropertiesPath.toString()); } } private static class TestWorker extends Task<Long> { private final long id; private long counter = 0; public TestWorker(long id) { this.id = id; updateTitle("Test Worker " + id); updateMessage("Iteration " + counter); updateProgress(-1, 1); } @Override protected Long call() throws Exception { while (!isCancelled()) { counter++; updateMessage("Iteration " + counter); Thread.sleep(1000l); } return counter; } @Override public String toString() { return getTitle(); } } }

You can find the sample application also here.

Drombler FX provides out-of-the-box support for ProgressMonitor (as an optional feature). It registers a StatusBar element and provides a loosely-coupled notification mechanism via the Context Framework.

For more information see the new ProgressBar tutorial trail.

Application Layout

As there is no one-size-fits-all solution, the application layout of a Drombler FX application is pluggable so you can provide your own implementation tailored to your needs. This allows you to get the most out of Drombler FX and JavaFX.

While this feature is available for some time, there is now a new tutorial trail explaining it in more detail.

API Changes

Please note that some APIs have changed, especially the following ones:

• OnExitRequestHandler: this class has been moved from Dromber FX to Drombler Commons. 
• The package changed accordingly:
  org.drombler.fx.core.application -> org.drombler.commons.fx.stage
• Dromber FX provides the following new interface for integration:
  org.drombler.fx.core.application.OnExitRequestHandlerProvider 
• In the package org.drombler.commons.docking.fx.context:
  WindowOnCloseRequestHandler has been replaced with DockingOnExitRequestHandler 
• The two service provider interfaces ApplicationContentProvider, MainSceneRootProvider have moved module/ package:
  org.drombler.fx.startup.main -> org.drombler.fx.core.application
• The service provider interface org.drombler.fx.core.application.WindowOnCloseRequestHandlerProvider: has been replaced with org.drombler.commons.fx.stage.OnExitRequestHandler#createOnWindowCloseRequestEventHandler 
• The service provider interface org.drombler.acp.startup.main.ApplicationExecutorProvider has been moved and renamed to org.drombler.acp.core.commons.util.concurrent.ApplicationThreadExecutorProvider

Additional Information

Projects like this one need to be build by a community working together to be really successful. There are several ways how you can contribute to this project. Contributions are highly welcome! See the "How to Contribute"-page for more information.

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


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.

Drombler FX: Version 0.10 released

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

This version is mainly a bug fix release and especially fixes some issues on Macs.

Please note that the Drombler FX Maven Plugin has been rewritten. The tasks have been split up into several goals, which are bound to the relevant phase of the default lifecycle. The plugin documentation will be updated in the next version.

The project now provides a "How to Contribute"-page. Projects like this one need to be build by a community working together to be really successful. There are several ways how you can contribute to this project.
Contributions are highly welcome!

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


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.

Drombler FX: Version 0.9 released

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

This version is mainly a maintenance release but also provides a new hook for a custom menu item sorting strategy, which can be used for programmatically registered menus.

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


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.

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.

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.

Drombler FX: Version 0.6 released

I recently released Drombler FX v0.6. Drombler FX is a modular Rich Client Platform for JavaFX based on OSGi and Maven (POM-first).

This is mainly a bug fix release.

You can find the complete list of fixed issues here: http://issues.drombler.org/milestone/0.6

Please note that there is currently a critical bug in the Docking Framework because of a bug in JavaFX. That bug should be fixed in the Java SE/ JavaFX 8u40 release however (expected release date: March 2015).

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

Drombler FX uses Apache Felix as its OSGi container by default.
As an application framework it makes sure JavaFX and OSGi will get started properly and it provides the main window.


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 is a modular Rich Client Platform 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.

You can use the Drombler Forum for questions and discussions.

If you find issues or have enhancement requests, you can file a ticket here: http://issues.drombler.org.

Using ControlsFX in a Drombler FX application

Earlier this year I've contributed a patch to ControlsFX to provide OSGi meta data in the Manifest file.

This patch allows ControlsFX to be used more or less out-of-the-box in an OSGi environment such as Drombler FX.

I'm writing "more or less out-of-the-box" since you still need an additional configuration in a Drombler FX application to be able to use ControlsFX.

The latest Drombler FX release provides some documentation in the sample generated by the Drombler FX Maven Archetype about this additional configuration.

You can find this in the generated test-application project in the file src/main/app/conf/config.properties.

You basically have to uncomment some lines there, which looks then like this:

org.osgi.framework.system.packages.extra=${jfx-${jfx.specification.version}}, ${jfx-${jfx.specification.version}-impl} jfx-8-impl=com.sun.javafx, \ com.sun.javafx.collections, \ com.sun.javafx.css, \ com.sun.javafx.css.converters, \ com.sun.javafx.event, \ com.sun.javafx.runtime, \ com.sun.javafx.scene.control, \ com.sun.javafx.scene.control.behavior, \ com.sun.javafx.scene.control.skin, \ com.sun.javafx.scene.traversal, \ com.sun.javafx.tk, \ com.sun.javafx.webkit, \ com.sun.webkit
The reason you need this additional configuration is that ControlsFX uses some non-published, internal JavaFX implementation classes and the OSGi environment with the configuration provided by Drombler FX is hiding these classes by default. Adding the necessary packages to org.osgi.framework.system.packages.extra allows ControlsFX to use these classes as well.

Note however that with this configuration these packages are available not only to ControlsFX but to any OSGi bundle in the application. Generally it's strongly discouraged to rely on non-published internal classes as they can change even with any minor release. Backwards compatibility is not maintained for these classes! Using this configuration the OSGi environment cannot protect your own OSGi bundles from using the classes of these packages.

The configuration has been tested with org.controlsfx:controlsfx:8.0.6 and org.controlsfx:controlsfx:8.0.6_20.

Drombler FX: Version 0.5 released

I recently released Drombler FX v0.5. Drombler FX is a modular Rich Client Platform for JavaFX based on OSGi and Maven (POM-first).

With this release the Docking Framework becomes more lightweight. You don't have to extend any particular Drombler specific class anymore but can extend from any Node such as a layout pane. The DockablePane has been removed from the API.

With this release also icons in Editor Dockings are supported:

The Action Framework has been moved from the OSGi-based RCP Drombler FX to the Drombler Commons library collection, which can be used inside and outside of an OSGi platform.

This allows you to use this framework even if you don't want to use Drombler FX, yet, for some reason.

The Action Framework, keeps the state (enabled/ disabled, selected/ unselected etc.), the information (texts, image etc.) and the logic between menu items and toolbar buttons in sync.

Note that the declarative, annotation based programming model is still only supported by Drombler FX. But there is a sample, which shows how to use this framework from Drombler Commons programmatically.

Please note that because the framework has been moved, some packages have been renamed.


The new Wiki page Logging explains how you can replace the SLF4J binding. The sample application provided by the Drombler FX archetype uses the java.util.logging (JUL) binding by default, because the required jar is very small since java.util.logging is part of the JRE.
The Wiki page shows as a sample how to configure the Log4J 2 binding.


You can find the complete list of fixed issues here: http://issues.drombler.org/milestone/0.5

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

Drombler FX uses Apache Felix as its OSGi container by default.
As an application framework it makes sure JavaFX and OSGi will get started properly and it provides the main window.


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 is a modular Rich Client Platform 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.

You can use the Drombler Forum for questions and discussions.

If you find issues or have enhancement requests, you can file a ticket here: http://issues.drombler.org.
 

Drombler FX: JavaFX 8 support

I recently released Drombler FX v0.4. Drombler FX is a modular Rich Client Platform for JavaFX based on OSGi and Maven (POM-first).

With this release Drombler FX as well as Drombler ACP and Drombler Commons support and require JavaFX 8/ Java SE 8.

You can find the complete list of fixed issues here: http://issues.drombler.org/milestone/0.4

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

Drombler FX uses Apache Felix as its OSGi container by default.
As an application framework it makes sure JavaFX and OSGi will get started properly and it provides the main window.


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	Javadoc	Description
Drombler FX	Modules	Javadoc	Drombler FX is a modular Rich Client Platform 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.

You can use the Drombler Forum for questions and discussions.

If you find issues or have enhancement requests, you can file a ticket here: http://issues.drombler.org.
 

Drombler FX: Version 0.3 released

I recently released Drombler FX v0.3. Drombler FX is a modular Rich Client Platform for JavaFX based on OSGi and Maven (POM-first).

With this release the Docking Framework and the Context Framework have been moved from the OSGi-based RCP Drombler FX to the Drombler Commons library collection, which can be used inside and outside of an OSGi platform.

This allows you to use these frameworks even if you don't want to use Drombler FX, yet, for some reason.

Note that the declarative, annotation based programming model is still only supported by Drombler FX. But using the libraries from Drombler Commons you can use the Docking Framework programmatically like this:

Add a DockingPane to the scene and initialize the ContextManager and the DockingManager.
The DockingPane splits up its content area into any number of Docking Areas. The Docking Areas can be resized using the dividers. Each Docking Area can hold any number of Dockable Panes, which are layed out as Tabs.
The ContextManager and the DockingManager manage the Acitve Context and the Application Context depending on the currently open and active Dockable Panes.
BorderPane borderPane = new BorderPane(); DockingPane dockingPane = new DockingPane(); ContextManager contextManager = new ContextManager(); DockingManager dockingManager = new DockingManager(dockingPane, contextManager); ... borderPane.setCenter(dockingPane);
Register a Docking Area:
DockingAreaDescriptor leftAreaDescriptor = new DockingAreaDescriptor(); leftAreaDescriptor.setId("left"); leftAreaDescriptor.setParentPath(Arrays.asList(20, 20)); leftAreaDescriptor.setPosition(20); leftAreaDescriptor.setPermanent(false); LayoutConstraintsDescriptor leftLayoutConstraintsDescriptor = new LayoutConstraintsDescriptor(); leftLayoutConstraintsDescriptor.setPrefWidth(200.0); leftAreaDescriptor.setLayoutConstraints(leftLayoutConstraintsDescriptor); dockingPane.getDockingAreaDescriptors().add(leftAreaDescriptor);
Initialize the DockablePreferencesManager and register the default DockablePreferences for each Dockable Pane type (here: LeftTestPane which should be docked into the Docking Area with ID "left"):
DockablePreferencesManager<DockablePane> dockablePreferencesManager = new SimpleDockablePreferencesManager<>(); DockablePreferences leftDockablePreferences = new DockablePreferences(); leftDockablePreferences.setAreaId("left"); leftDockablePreferences.setPosition(20); dockablePreferencesManager.registerDefaultDockablePreferences(LeftTestPane.class, leftDockablePreferences);
Add a DockablePane (here: LeftTestPane) to the DockingPane:
LeftTestPane leftTestPane = new LeftTestPane(); leftTestPane.setTitle("Left"); dockingPane.getDockables().add(new DockableEntry<>(leftTestPane, dockablePreferencesManager.getDockablePreferences(leftTestPane)));
You can find a complete sample here.

Note that the Docking Framework is still in its early stages and advanced features such as drag'n'drop Dockable Panes don't work yet. Currently it supports:

• Register Docking Areas and visualize them by adding TabPanes to a custom multi-SplitPane.
• Add Dockable Panes to Docking Areas using a logical Docking Area ID.
• Calculate the minimal required SplitPanes depending on the sparse definition of Docking Areas and the currently open Dockable Panes.

Here you can find a list of currently known issues and enhancement requests.
Especially have a look at the API issues. Although I took the opportunity and invested a lot of effort to clean up the API in the process of moving the framework from Dromber FX, where the programmatic API was in a hidden package, to Drombler Commons, where a part of the programmatic API has now been published, I'm still not 100% satisfied with the current state. Other opinions are highly welcome!

Please feel free to vote, comment and/ or file new issues.

For more information on the Context Framework have a look at the wiki.
And you can find a complete sample here.


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	Javadoc	Description
Drombler FX	Modules	Javadoc	Drombler FX is a modular Rich Client Platform 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.

You can find the complete list of fixed issues here: http://issues.drombler.org/milestone/0.3


Note that since JavaFX 8 isn't 100% backwards compatible with JavaFX 2.x, this release still only works with Java SE 7/ JavaFX 2.x.

I'm already working on upgrading Drombler FX and Drombler Commons to Java SE 8/ JavaFX 8, however, and it will likely make it into the next release. Stay tuned!

3rd-Party Contribution: ez-vcard + OSGi Support

Recently I wanted to use ez-vcard in one of my projects. The project is OSGi-based but unfortunately ez-vcard didn't provide the OSGi meta data in its Manifest file. So what to do?

I decided to go and try to fix ez-vcard itself rather than finding some workaround.

It didn't take too much time to get the sources, add the OSGi meta data generation, fix some other issue which popped up and create a patch. And it didn't take a long time either for the maintainer to accept my patch (with small changes from the maintainer).

Result:

• I have solved the issue the clean way - the library ships now with the OSGi meta data in the Manifest file.
• The patch is now part of the project and is likely to be maintained along with the project. I won't have to apply the patch with every new version of the library.
• I didn't have to create some workaround, which I would have to maintain myself.
• Last but not least: The issue is now solved not only for me but for anyone else who wants to use the library in an OSGi environment as well.

This is one of the real strength of Open Source software: I could quickly fix an issue myself the clean way without having to wait for the maintainer to fix it eventually sometime in the future.

I can only encourage developers not to shy away from getting the sources of 3rd-party Open Source libraries and to fix the issues they have the clean way rather than to search for some workarounds.

Drombler FX: Version 0.2 released

I recently released Drombler FX v0.2. Drombler FX is a modular Rich Client Platform for JavaFX based on OSGi and Maven (POM-first).

For this release, a lot of work has been done in the stabilization of the Docking Framework.

In addition, the icon property gets now respected when registering a Dockable Pane:

 

Note that the icon property only specifies the name pattern. Drombler FX looks for <icon-base-name>16.<icon-extension> for menu items and tabs (expected to be 16x16 pixels).
In the example above Drombler FX would look for left-test-pane16.png.

Note: Maven expects resources to be in a resources directory. If you're using drombler-fx-parent as your parent POM, it's best to put binary files under the resources-bin directory as this directory has been configured not to be filtered for variables.

With this release Drombler FX now expects the '%' prefix rather than the '#' prefix it used before when identifying resouce strings to be looked up in the Bundle.properties file.
With this change the prefix is now aligned with the prefix used by JavaFX/ FXML.
Since this is an incompatible change, please make sure you replace the prefixes in your code!

You can find the complete list of fixed issues here: http://issues.drombler.org/milestone/0.2/

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 artifacts are available from Maven Central.

You can use the Drombler Forum for questions and discussions.

If you find issues or have enhancement requests, you can file a ticket here: http://issues.drombler.org.

Note: As this is an Early Access release, all APIs might be subject to change.

Drombler FX: building modular JavaFX applications with OSGi and Maven

If you have ever learned to use a modular Rich Client Platform such as the NetBeans Platform (Swing based) or Eclipse RCP (SWT based) it's likely you wouldn't want to write rich clients in any other than in a modular way.

And so I'm happy to announce the availabilty of a first Early Access version of Drombler FX. Drombler FX is a modular Rich Client Platform for JavaFX based on:

• OSGi: OSGi is the de facto standard for writing modular software in Java.
• Maven (POM-first): Drombler FX applications can be build with Maven. The build follows the standard POM-first approach (the OSGi meta data will be generated for you). A custom Maven Plugin will help you to easily create JavaFX applications with Maven. A custom Maven Archetype will help you to get started.
• Declarative programming model: Annotations can be used at many places to register elements such as menus, toolbars and GUI components.

The first use case supported by Drombler FX is building standard desktop applications: applications with a menu bar, possibly several toolbars and a content pane with tab panes in nested split panes.

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

In addition, this Early Access release of Drombler FX provides initial versions of the following frameworks:

• Actions, Menus and Toolbars Framework
• Docking Framework
• Context Framework

You can use the Drombler Forum for questions and discussions.

If you find issues or have enhancement requests, you can file a ticket here: http://issues.drombler.org.

Note: As this is an Early Access release, all APIs might be subject to change.

News - OpenJFX: Better Skin support in OSGi-environments

Great news from the OpenJFX project: my patch (with refinements from Oracle and other community members) to load custom Skins in an OSGi-environment has been pushed to the OpenJDK/ OpenJFX/2.2/master/rt repository and integrated into the JavaFX 2.2 Developer Preview .

Here is the according JIRA issue: RT-14177

OpenJFX is Oracle's effort to open source JavaFX, the next-generation GUI toolkit to create Rich Internet Applications (RIA) on top of the Java SE platform.
OpenJFX is a part of the OpenJDK project (Oracle's effort to open source the Java SE platform).

For me, working on this patch not only helped to unblock Skin-loading in OSGi-environments, but also showed that through the OpenJFX project Oracle is working on JavaFX together with the community.

It's not very hard to get started with OpenJFX development, although the Getting Started page is slightly out-dated. You will have to replace '2.1' with '2.2' to get the current development branch. I encourage the community to help to improve JavaFX.