JavaFX provides a lot of interesting capabilities for developing rich client applications in Java, but what if you are working on an existing Swing application and you want to take advantage of these new features?  Maybe you want to use one or two controls like the LineChart or a MediaView.  Maybe you want to embed a large Scene Graph as an initial step in porting your application to FX.  A hybrid Swing/FX application might just be the answer.

Developing a hybrid Swing + JavaFX application is not terribly difficult, but until recently the deployment of hybrid applications has not simple as a "pure" JavaFX application.  The existing tools focused on packaging FX Applications, or Swing applications - they did not account for hybrid applications.

But with JavaFX 2.2 the tools include support for this hybrid application use case. 

Solution 

In JavaFX 2.2 we extended the packaging ant tasks to greatly simplify deploying hybrid applications.  You now use the same deployment approach as you would for pure JavaFX applications.  Just bundle your main application jar with the fx:jar ant task and then generate html/jnlp files using fx:deploy.  The only difference is setting toolkit attribute for the fx:application tag as shown below:

<fx:application id="swingFXApp" mainClass="${main.class}" toolkit="swing"/> 

The value of ${main.class} in the example above is your application class which has a main method.  It does not need to extend JavaFX Application class.

The resulting package provides support for the same set of execution modes as a package for a JavaFX application, although the packages which are created are not identical to the packages created for a pure FX application.  You will see two JNLP files generated in the case of a hybrid application - one for use from Swing applet and another for the webstart launch. 

Note that these improvements do not alter the set of features available to Swing applications. The packaging tools just make it easier to use the advanced features of JavaFX in your Swing application. The same limits still apply, for example a Swing application can not use JavaFX Preloaders and code changes are necessary to support HTML splash screens.

Why should I use the JavaFX ant tasks for packaging my Swing application? 

While using FX packaging tool for a Swing application may seem like a mismatch at face value, there are some really good reasons to use this approach.  The primary justification for our packaging tools is to simplify the creation of your application artifacts, and to reduce manual errors.  Plus, no one should have to write JNLP by hand.

Some specific benefits include:

• Your application jar will include a launcher program.  This improves your standalone launch by:
• checking for the JavaFX runtime
• guiding the user through any necessary installations
• setting the system proxy for Java
• The ant tasks will generate JNLP and HTML files for your swing app:
• avoids learning unnecessary details about JNLP, and eliminates the error-prone hand editing of JNLP files
• simplifies using advanced features like embedding JNLP and signing jars as BLOBs to improve launch performance.you can also embed the signing certificate details to improve the user's experience 
• allows the use of web page templates to inject the generated code directly into your actual web page instead of being forced to copy/paste the generated code snippets.

What about native packing?

Absolutely!  The very same ant task can generate a native bundle for a Swing application with JavaFX content.  Try running one of these sample native bundles for the "SwingInterop" FX example: exe and dmg.   I also used another feature on these examples: a click-through license agreement for .exe installers and OS X DMG drag installers.

Here is the full ant code used to package SwingInterop.  You can grab latest JavaFX samples and try it yourself: 

    <target name="-post-jar"> 
        <taskdef resource="com/sun/javafx/tools/ant/antlib.xml"  
                uri="javafx:com.sun.javafx.tools.ant" 
                classpath="${javafx.tools.ant.jar}"/> 

        <!-- Mark application as Swing-based --> 
        <fx:application id="swingFXApp" mainClass="${main.class}" toolkit="swing"/> 

        <!-- Create doubleclickable jar file with embedded launcher --> 
        <fx:jar destfile="${dist.jar}"> 
            <fileset dir="${build.classes.dir}"/> 
            <fx:application refid="swingFXApp" name="SwingInterop"/> 
            <manifest> 
                <attribute name="Implementation-Vendor" value="${application.vendor}"/>
                <attribute name="Implementation-Title" value="${application.title}"/> 
                <attribute name="Implementation-Version" value="1.0"/> 
            </manifest> 
        </fx:jar> 

        <!-- sign application jar. Use new self signed certificate -->
        <delete file="${build.dir}/test.keystore"/> 
        <genkey alias="TestAlias"  
           storepass="xyz123" keystore="${build.dir}/test.keystore" 
           dname="CN=Samples, OU=JavaFX Dev, O=Oracle, C=US"/> 
        <fx:signjar keystore="${build.dir}/test.keystore"  
                          alias="TestAlias" storepass="xyz123"> 
            <fileset file="${dist.jar}"/> 
        </fx:signjar> 

       <!-- generate JNLPs, HTML and native bundles --> 
       <fx:deploy width="960" height="720" includeDT="true" 
                  nativeBundles="all" 
                  outdir="${basedir}/${dist.dir}" embedJNLP="true" 
                  outfile="${application.title}"> 
            <fx:application refId="swingFXApp"/> 
            <fx:resources> 
                <fx:fileset dir="${basedir}/${dist.dir}" includes="SwingInterop.jar"/> 
            </fx:resources>
            <fx:permissions/> 
            <info title="Sample app: ${application.title}" 
                  vendor="${application.vendor}"/>
        </fx:deploy> 
    </target>