At last night’s Silicon Valley JavaFX User Group event, I announced a petition to Open Source the JavaFX Platform.  This is a petition from the Java and JavaFX Community directed to the management of Oracle Corporation. The goal of the petition is to increase the viability of the JavaFX platform to the benefit of both the community and Oracle.

To the Leaders, Management, and Board of Directors at Oracle Corporation,

We the undersigned formally request that Oracle Corporation release the entire JavaFX Platform as open source software available for modification and reuse by individuals, educators, and corporations.

…We believe that an essential part of the future success of this platform is to release it as open source software. … In our estimation, the increased adoption of JavaFX will make the platform even more profitable for Oracle than it currently is as a proprietary technology.

…read more

This petition has been embraced by community and industry leaders alike.  Here are some quotes from leaders in the JavaFX community:

Jim Weaver
JavaFX holds the potential of bringing back rich-client Java, after fifteen years of force-fitting the Web to be an application execution environment.   Open-sourcing JavaFX and related deployment technologies will help rescue users and developers from continuing to settle for far less than what could be experienced with rich-client Java.

Peter Pilgrim
JavaFX is still a fantastic solution to be portable, cross-platform, a technology which runs across multiple deployment targets: desktop, mobile and other embedded devices and across multiple operating systems. An Open JavaFX will allow innovation to take place outside of Oracle completely and yet I also believe that the repository, the service / provider owner, intellectual property must be paid or monetised as well. I believe that people, individuals, groups and companies will recognise the work of those who innovate. It is possible to monetise JavaFX.

If you adding your name to the list of signatures, please visit the petition signatory page here:

.
Sign the Petition

.

JavaFX was first announced three years ago at JavaOne 2007.  We would like to be able to present this petition to the management of Oracle at JavaOne on the 3rd event anniversary of this great technology.

I am pleased to announce that we have a couple new videos available on the Silicon Valley JavaFX User Group (SvJugFx) video site. Here is a link to the landing page where you can watch these videos as well as all our previous sessions:

http://web.ubivent.com/svjugfx.html

The first new video is a Hands-On JavaFX Lab given by Stuart Marks, core JavaFX team member, and regular SvJugFx attendee. This was our most successful meeting so far for the local audience, because it filled in the gap between the very technical rich presentations we started with and the experience level of the attendees. The entire flood tutorial was published as an HTML document, but it is much more entertaining to see Stuart do it first hand:

Hands-on JavaFX:  http://jnlp.ubivent.com/jnlp/eventid=10/guest=1/path=doc:129,doc:128,doc:210

The second was the wildly popular Bay Area JUG Round-Up event.  All the Bay Area user groups cooperated to host a massive event with a live recording of the Java Posse.  Oracle sponsored the event, with an introduction by Justin Kestelyn and update on Java.net from Sonya Barry.  And of course the Java Posse did an amazing job working the crowd with some hilarious techie humor.

Justin Kestelyn: http://jnlp.ubivent.com/jnlp/eventid=10/guest=1/path=doc:129,doc:128,doc:217,goto:v:-0

Sonya Barry: http://jnlp.ubivent.com/jnlp/eventid=10/guest=1/path=doc:129,doc:128,doc:217,goto:v:-1

The Java Posse: http://jnlp.ubivent.com/jnlp/eventid=10/guest=1/path=doc:129,doc:128,doc:217,goto:v:-2

For our meeting next month we have the esteemed Max Katz coming to speak on Enterprise JavaFX.  He will demonstrate how to use the open-source Flamingo framework to connect a JavaFX application to an enterprise backend using JBoss Seam.  For those of you who don’t know, Exadel also develops an Eclipse plug-in for JavaFX, which he will be using for all his coding examples.  It should be an exciting event, so please sign-up to attend in person or online:

Enterprise JavaFX with Max Katz:  http://www.svjugfx.org/calendar/13605800/

I had my Jazoon talk this morning on building data rich user interfaces with JavaFX. In an informal poll before the start, it seemed like many of the attendees had not yet tried JavaFX, so hopefully this has encouraged them to give it a spin.

I posted the slides from the talk on Slideshare for the benefit of folks who couldn’t make it out to Zurich this week. The agenda for the talk was as follows:

• JavaFX Technology Stack
• Data Binding
• JavaFX 1.3 Controls
• Control Styling
• JavaFX 1.3 Layouts
• Web Service Integration
• JFXtras Data-driven ControlsApropos Demo

There is a lot of new information here on CSS styling and layouts in JavaFX 1.3 as well as some pre-announcements on some new bind functionality we are working on in the JFXtras project. If you are interested in more details, please let me know in the comments section and I can follow up with subsequent blog posts.

Without further ado, here are the slides from today’s talk:

You can also download the slides as a PDF.

I am honored to be accepted by some great conferences to speak on JavaFX.  Each of the talks I am giving is unique, which means more work for me, but is a great opportunity to talk about some different topics that I think are important for folks using JavaFX.

First up is Jazoon in Zurich, Switzerland on June 1-3.  I have heard great things about this conference from folks who have attended in past years, and have already heard from some folks who will be attending my talk.  The topic for my session will be Building Data Rich Interfaces with JavaFX.  I have some good content lined up from my open source projects (actually too much content), so it should be a great session.

Next I will be speaking at JavaOne in my hometown of San Francisco on September 19-23.  Oracle is pulling out all the stops for this conference, taking over a full block of Mason Street as the JavaOne “Zone”.  They will be putting up a big tent with videostreaming and other festivities, in addition to the 4,000 square feet of space dedicated to talks and sessions.  For those of you who are not aware of the magnitude of Oracle, here is a shot of what they have done in past years for Oracle Open World:

I am fortunate enough to be able to co-present 2 Technical Sessions and 2 BOFs at JavaOne 2010:

Technical Session 1: Pro JavaFX: Developing Enterprise Applications
Co-presented with Jim Weaver

Technical Session 2: Take Control of JavaFX
Co-presented with Jonathan Giles from the JavaFX Control Team

Birds of a Feather Session 1: JFXtras: JavaFX Controls, Layouts, Services, and More
Co-presented with Dean Iverson and the rest of the JFXtras Team

Birds of a Feather Session 2: JavaFX Author JAM
Co-presented with Jim Weaver, Jim Clarke, Dean Iverson, and many other JavaFX authors (to be announced)

If you haven’t already, it is not too late to book your ticket for JavaOne.  This will definitely be a year you won’t want to miss!

At the Lean Software and Systems Conference a week ago, Israel Gat, Erik Huddleston, and I did a presentation on Reformulating the Product Delivery Process.  At the end of this talk, we unveiled an open-source, JavaFX tool called Apropos that we use for Product Portfolio Planning at Inovis.

Note: The data has been blurred to hide corporate information.  The final release will include a test bed of public data, which can be used for display and testing.

What you are seeing in the above screenshot is the Portfolio Kanban View that we use for tracking features through their full lifecycle from proposal through validation.  It is backed by the Rally Agile Lifecycle Management tool, which exposes Web Services for accessing all of our planning data.  The entire UI was written in JavaFX, and makes heavy use of JFXtras features, such as the XTableView.

The plan for this tool is to do the initial launch of a BSD-licensed open-source version on May 22nd.  This will include support for the Rally Community Edition, which is free for up to 10 users.  In future releases we plan to support other Agile Lifecycle Management tools, both commercial and open-source, but will need assistance from the community to do this.

If you are interested in helping out with this project, please contact me.  I will have limited bandwidth until after the initial launch, but after that would love to scale up this project with interested parties.

Here is the full presentation, which includes additional screenshots of Apropos at the end (slides 15-19):

JavaFX 1.3 has just gone live on JavaFX.com.  This release is deceptively small, but has an enormous number of changes under the hood.  In this post I will take you through the Top 10 major features, giving you background information I learned from working with the JavaFX team, and flooding you with details on interesting tidbits you might otherwise miss.

JavaFX 1.3 Top 10 Features

1. New Controls

JavaFX 1.3 comes with several new controls that are extremely useful when designing user interfaces.  For building forms you have the new PasswordBox, ChoiceBox, and Separator classes.  The PasswordBox is similar to the TextBox control, except it automatically hides input as it is typed.  The ChoiceBox control is long overdue, but surprisingly simple to use.  The interface is similar to the ListView control, both of which take a sequence of items.

Speaking of the ListView, this control has received a serious upgrade.  This includes the ability to render horizontally or vertically as well as customizable cell renderers via a cellFactory closure.

In addition, there is a new ScrollView class that simplifies the task of creating a simple scrollable viewport surrounding a collection of nodes.  This has been a feature in JFXtras for a while, so it is nice to see that the JavaFX team thought it was useful enough to add to the core libraries.

Finally, all controls now take a Tooltip that will be displayed on rollover.

To bring it all together, here is a simple example that demonstrates all the new controls in action:

And here is the source code:

import javafx.scene.control.*;
import javafx.scene.layout.VBox;
import javafx.geometry.Insets;

var list = ["apples", "bananas", "oranges", "pears", "cabbage"];

ScrollView {
  width: 250
  height: 250
  managed: false
  node: VBox {
    padding: Insets {top: 10, left: 10, bottom: 10, right: 10}
    spacing: 10
    content: [
      PasswordBox {promptText: "enter password"}
      Separator {}
      ChoiceBox {
        items: list
      }
      ListView {
        vertical: false
        items: list
      }
    ]
  }
}

2. Layout Enhancements

Layout has undergone some serious changes as a result of this release, including the following:

• LayoutInfo and Resizable now include settings for fill, grow, and shrink.  Fill will allow you to specify whether the contents of a layout stop at their preferredSize or take up the maximum allowable space.  Grow and shrink are hints to the container about the relative priority for different nodes to get the available space.
• LayoutInfo also includes a new margin feature, which makes it very easy to add visual padding around your Nodes in a layout!  This is in addition to padding, which appears on all the built-in layouts.
• Container has a new snapToPixel boolean that allows you to create pixel-perfect alignments to avoid unwanted aliasing effects.
• There is a new autoSize feature on Groups. Children will be automatically resized to their preferred width and height, preventing layout bugs when uninitialized components return the wrong bounds initially. You can still disable this feature, but it is strongly recommended that you fix your application to make use of preferred widths and heights instead of setting Node width and height manually.
• Resizable classes automatically have layoutBounds set to [0, 0, width, height], avoiding an additional required declaration.
• New support for baseline layouts via the TextOrigin class.
• The Tile class now automatically sizes the tileWidth and tileHeight by default.
• HPos and VPos have boolean for fillHeight and fillWidth, which rarely should be changed, but allow you to default back to the pre 1.3 behavior.

For the most part, the JavaFX team has done an amazing job of keeping the layout changes backwards compatible.  However, to fully take advantage of the new layout features you will have to update your code.

The layout changes are significant enough that I can’t do them justice in this short blurb.  However, either myself or Amy Fowler (whoever makes it first) will do an in depth article on just this one topic!

3. Performance

There have been some very significant changes in performance in the JavaFX 1.3 release all the way down to the compiler generated code.

Some areas you will notice the largest performance improvement in include:

• Bind performance – All binds in the language are now lazy by default, which means that they will get marked as dirty immediately, but only get re-evaluated when needed (if at all).
• General code performance – With the compiler rewrite, a level of indirection on variable access has been removed, which will significantly improve the overall performance of any application.
• Layout performance – The layout code has been optimized to reduce the number of passes required on each layout cycle, greatly improving the perceived responsiveness of applications.
• Text performance – With the change to logical rather than physical layout bounds, any applications that heavily use Text elements will see a dramatic improvement in overall performance.
• CSS performance – The CSS support has been rewritten from the ground up, greatly improving performance of applied styles.

4. Enhanced CSS

The CSS support in JavaFX 1.3 has been rewritten from the ground up.  This includes some greatly enhanced functionality, especially for the Control classes, and also has a dramatic improvement on performance.

Because the changes are so significant, you may find that a lot of your previous styles do not work correctly on the 1.3 release.  The full set of CSS changes and supported tags is such a large topic that I will provide a link to the full JavaFX CSS specification once it is made available.

Dean Iverson has done an excellent writeup of some of the new CSS capabilties here: Advanced JavaFX Control Styling

5. 3D Support

Via the new, experimental Prism graphics stack you can start experimenting with 3D graphics in your JavaFX applications.  Some of the new APIs that you will see throughout the JavaFX documentation for working with 3D graphics include:

• New Camera classes for changing the viewing perspective of the Scene, including a ParallelCamera that does orthographic projections and a PerspectiveCamera that can be used to see things in full 3D
• Transition changes to accept a three dimensional axis on RotationTransition, ScaleTransition, and TranslateTransition
• A completely revamped set of transform classes that accept z coordinates
• A new Point3D class as well as changes to BoundingBox and Bounds to accept a third dimension
• The addition of rotationAxis, scaleZ, and translateZ on all scene graph Nodes

To use 3D in your applications you will need to enable the prism graphics stack with the following JVM argument:

-Xtoolkit prism

Runtime you can validate whether 3D is enabled or not using the new Platform and ConditionalFeature classes like this:

Platform.isSupported(ConditionalFeature.3D);

The best example of JavaFX 3D in action is Jim Weaver’s new 3D Calendar Cube post.

6. TV Emulator

For the first time, JavaFX 1.3 includes a TV Emulator as part of the distribution.  This gives you the chance to compile and test your applications against the new TV profile, and sometime in the near future deploy it to the big screen!

The easiest way to change your application to run against the TV profile is to select the “Run in TV Emulator” option in the NetBeans Properties dialog.  From the command line you can accomplish the same thing by passing in “-profile TV” to both the compiler and JavaFX runtime.

Here is a screenshot of the TV Emulator in action:

The biggest change you will notice is the different icon in the upper-left hand corner of the screen.  From a development perspective, it feels very similar to the desktop experience, but you need to keep in mind the following constraints:

• Screen Distance – Your end users will be sitting 5 to 6 feet away from the screen, so your entire application has to be designed to be visually distinctive at a distance.
• Remote Interaction – TV viewers do not typically sit on their couches with full QWERTY keyboards, so your UI will need to be designed to be fully operational from a common remote control.  This can make navigation, selection, and text input much more challenging.

If you are interested to see a live demonstration of JavaFX TV, join us in person or for the live web stream of our June SvJugFX meeting with Mikhail Gorshenev from the JavaFX TV development team.

7. Conditional Features

I mentioned a little bit about conditional features in the 3D section above.  However, having conditional features is itself an extremely important feature.

In previous release of JavaFX if you wanted to make use of certain features, such as effects, that were only in the desktop profile, you were required to remove these from your code to compile against mobile.  With the addition of conditional features you can now safely include these features in your application and they will be silently ignored if they are not supported on your platform.

This takes the concept of write once, run anywhere to a new level in JavaFX, greatly simplifying development on platforms that only support the common profile!

Here is a short program that will print out whether or not each of the conditional features is enabled for your platform:

import javafx.runtime.*;

println("Effect enabled: {Platform.isSupported(ConditionalFeature.EFFECT)}");
println("Input Method enabled: {Platform.isSupported(ConditionalFeature.INPUT_METHOD)}");
println("Scene 3D enabled: {Platform.isSupported(ConditionalFeature.SCENE3D)}");
println("Shape Clip enabled: {Platform.isSupported(ConditionalFeature.SHAPE_CLIP)}");

8. Custom Cursors

You are no longer limited to the set of default cursors defined on the Cursor class.  Using the new ImageCursor class you can take any JavaFX Image and turn it into a mouse cursor.

This capability was recently released as a part of the JFXtras 0.6 Release thanks to the hard work of Jeff Friesen, but is a very welcome addition to the core API!  Now all that is needed is an implementation of Jeff’s custom paints.

9. Faster Animation

JavaFX 1.3 has a new cacheHint option on Nodes that allows you to degrade performance while animations are taking place.  Perceptually it is hard for the user to notice the loss of quality, but it can have a very big difference in performance of your application.  This is a staple of other JavaFX scene graph technologies like Piccolo2D, so it is good to see progress on this in the JavaFX 1.3 release.

There is a great example of how to use this new capability right in the JavaFX Node API docs (duplicated here for convenience):

 expensiveNode.cache = true;
 expensiveNode.cacheHint = CacheHint.QUALITY;
 ...
 // Do an animation
 expensiveNode.cacheHint = CacheHint.SPEED;
 Timeline {
     keyFrames: [
         KeyFrame {
             time: 2s
             values: [
                 expensiveNode.scaleX => 2.0,
                 expensiveNode.scaleY => 2.0,
                 expensiveNode.rotate => 360,
                 expensiveNode.cacheHint => CacheHint.QUALITY
             ]
        }
     ]
 }.play();

10. Preview Features

In addition to the public API, JavaFX 1.3 contains a number of top secret new features!  These are features that are not final, but are very usable if you are willing to live with future API changes.  All of the preview features are grouped under the com.javafx.preview package, and include the following:

• Grid – A Grid layout that makes it much simpler to layout nodes in perfectly aligned rows and columns.  The original layout code was donated by the JFXtras team, and productized by the amazing layout skills of Amy Fowler.
• MenuBar/PopupMenu – This is the completed version of Jonathan Giles very popular Menu control.  He is now a core member of the JavaFX Control Team, and plugging away at bringing this and other great controls to the hands of JavaFX developers.
• TreeView – A full implementation of a hierarchical tree in JavaFX complete with TreeItems and TreeCells.
• ToolBar – A palette-like control that lets you create rows of tool buttons with icons and text.  This is the handiwork of Paru Somashekar.

In a future post I will go into more detail on usage of these preview features, which greatly extend the power of JavaFX!

Other Noteworthy Features

Besides the major features mentioned above, there are also thousands of little changes that have made it in to the 1.3 release.  While I don’t have time (or room) to cover all of them in detail, here are some other noteworthy features that you can take advantage of in your applications:

• New Amble font – JavaFX now includes its own high fidelity fonts that are consistent across all platforms.  Since this is the new default font, you may notice that the spacing and alignment of your existing applications may be slightly off.
• Timelines can now be paused.  There is also an evaluateKeyValues that allows you to reevaluate the value portion of your animation (whatever is on the right side of the =>) on demand (normally the value is evaluated once before the first Timeline execution).
• You can get exceptions that occur while processing JSON/XML via the new exception variable on Event.
• PullParsers can now be run asynchronously using the new ParserTask class.
• FXD now supports node selection via an XPath-like syntax and has metadata support on nodes, which is exposed as a map to the application.
• There is a new Bounds class for representing widths and heights.
• Builtins has a new isReadOnly function, which tells you if a variable is bound.  No more catching AssignToBoundException!
• Durations are now Comparable, have new constants for one and zero, and a new static TYPE_INFO variable.
• CustomNode now has a publicly exposed children sequence.  This makes it much easier to work with scenegraph navigation.  It also solves a potentially perplexing issue with object initialization order.  You should definitely make use of the new children sequence rather than overriding the old create function.
• The infernal scene graph warning is gone!  You can now move a node around the scenegraph without worrying about removing it from the previous parent.  Stuart Marks has a great blog post about this.
• Node has a new pickOnBounds variable that lets you change the active hit region to be the logical rather than the physical bounds.
• All container nodes (Group, CustomNode, Container, Control) now extend Parent and have a children sequence, greatly simplifying scene graph traversal.
• Text supports logical and physical bounds.  Big performance improvement with the new default of logical!
• Improved charts…  background lines, shading, and cleaner text.  Here is a before and after picture:

Additional Resources

The JavaFX team did a great job of documenting the new features and migration to JavaFX 1.3 in the following articles:

• What’s New in JavaFX 1.3
• JavaFX 1.3 Migration Guide

And not to be outdone, Jim Weaver had the very first external post about the 1.3 release emphasizing the new 3D capabilities:

• Your Calendar PWN3D: Leveraging the JavaFX SCENE3D ConditionalFeature

Since this post first appeared, some excellent resources have come up:

• Advanced JavaFX Control Styling by Dean Iverson

As additional resource become available, I will continue to update this section.

Conclusion

I hope you enjoyed this whirlwind tour through all the new features of the JavaFX 1.3 release.  There is a lot of goodness here, some of which I might have missed, so please comment on any features of the 1.3 release that you enjoy using!

I am pleased to announce the 0.6 release of the open-source JFXtras project, the largest 3rd party library of JavaFX add-ons.  This release is a very large undertaking that represents the work of several dozen contributors over the past 6 months.

JFXtras 0.6 will work with any JavaFX release in the 1.2 family.  We recommend using the very latest release (currently JavaFX 1.2.3), which can be downloaded from JavaFX.com.

Starting immediately, we will be focusing on developing a JavaFX 1.3 compatible JFXtras release.  Our plan is to release a 1.3 compatible version of JFXtras within 1 week of the official release announcement from Oracle.  To hear about future JFXtras release announcements, make sure to follow my blog.

JFXtras Functionality

To make it easier to see some of the JFXtras capabilities in action, I have included Web Start demos from our component test library.  It may take a minute or two to load the first demo, but after that the rest should launch instantaneously.

Data-Driven Controls

The JFXtras controls include a Table, Tree, Shelf, Calendar, PasswordBox, Picker, Spinner, MultiLineTextBox, ScoreBoard, and Menu.  Many of these controls can be driven off a dynamic data provider that gives back incremental results from an asynchronous operation, such as a Web Service call.

XTableView (browse demo source)

XShelfView (browse demo source)

XPicker (browse demo source)

Advanced Layouts

The JFXtras layouts include the XGrid, XMigLayout, and Resizable versions of Stack, HBox, and VBox.  All of these layouts support dynamic animation and a powerful defaults system.  The JFXtras XGrid has been contributed back to Oracle and will be included in the JavaFX 1.3 release.

XGrid (browse demo source)

Wipe Library

Wipe transitions including: blind, fade-out, fade-reveal, fade, fade-zoom, flip-180, reveal, shape, slide-over, slide, and swing-in as featured in Simon Morris’ JavaFX in Action book.

Wide Demo (browse demo source)

Shapes

JFXtras includes a wide selection of skinnable shapes including: Almond, Arrow, Asterisk, Astroid, Balloon, Cross, Donut, ETriangle, Gear, ITriangle, Lauburu, RTriangle, Rays, RegularPolygon, ResizableEllipse, ResizableRectangle, ReuleauxTriangle, RoundPin, Sphere, and Star.

Shapes Demo (browse demo source)

Borders

We also have a large set of skinnable borders including: bevel, ellipse, empty, etched, frame, image, line, metallic, pipe, raised, rounded, shape, soft, and titled.

Borders Demo (browse demo source)

And a Whole Lot More

Here are some of the other features JFXtras has to offer:

• XStore Data Storage – Simple persistence of JavaFX primitives and sequences with defaults, auto-save, and save-on-exit.
• Asynchronous JavaFX Support (for experts only) – Allows invocation of JavaFX code off the EDT either via a SwingWorker-style callback or a set of closure-driven primitives.
• Swing Integration – Via the original SceneToJComponent wrapper or the new, easier to use, JXScene class.
• Custom Cursors and Paints – Allows you to use custom cursors and custom paints within your JavaFX application via a special Toolkit as featured in Jeff Friesen’s articles.
• Interpolatable and HSB Gradients – Ever wanted to animate a color?  This is the perfect solution, complete with support for an HSB color palette.
• Bindable XMap – A simplified map syntax for use with JavaFX that includes bind support on gets.
• Image Caching – An image caching library that supports high performance, asynchronous loading and sizing of images from URLs.

Documentation

The full API is documented online here:

http://jfxtras.googlecode.com/svn/site/javadoc/release-0.6/index.html

We also have a new documentation wiki on the JFXtras website.  Please browse it for ideas on how to use the JFXtras components and feel free to comment or contribute back to the docs to make them better:

http://jfxtras.org/portal/core

Migrating from Previous Releases

In order to avoid name collisions with the built-in JavaFX classes, we have undergone a fairly aggressive renaming strategy on all scene graph classes.  If you have been using an earlier version of JFXtras, you will have to rename your usages by pre-pending an X before the class name.  Going forward this will reduce the likelihood of collisions with JavaFX built-in classes and make it easier to visually inspect code that uses a mix of JavaFX and JFXtras classes.

Some other migration changes that you need to take into account include:

• The fill layout constraint has been changed from an enumeration to two booleans (hfill, vfill).
• The Grid border feature has been replaced with a general purpose margin on XLayoutInfo
• The Deck class has been renamed to XStack
• All the layout classes starting with Resizable* have changed to X* (when in doubt try the JavaFX class name prepended with an X)

JFXtras Test

There is also a matching release of JFXtras Test so you can do behavior-driven development with a declarative JavaFX syntax.  We use this for all the unit tests in JFXtras and encourage you to do the same on your projects.  Some of the new JFXtras Test features include:

• Asynchronous Testing Support – Test background processes such as HttpRequests
• JUnit Integration – Integrate JFXtras Test in your Ant or Maven build using a standard JUnit runner

Download it and give it at try!

Credits

Some of the folks I would like to thank for making this release possible include:

• Jim Weaver for inspiring me to start this project and being a great mentor.
• Keith Combs for assisting me on various bits and putting up with my perfectionism on everything.
• Jim Clarke for being the most productive JavaFX coder at Oracle who is not on the core team.
• Dean Iverson for bringing MigLayout to JFXtras and being the clean code guru (see his article on code conventions).
• David Armitage for contributing some great controls and making sure our documentation was top notch.
• Tom Eugelink for being our voice of sanity on the mailing list and being polite about my past mistakes in misattributing his work.
• Pedro Duque Vieira for making the world a safer place for Swing developers with JXScene.
• John Freeman for contributing a very high quality JTable wrapper that I always underpromote.
• And also: Peter Pilgrim, Christophe DUFOUR, Joshua Marinacci, Simon Morris, Andres Almiray, Jeff Friesen, Andrew Hughes, and Liu Huasong.

This past month we had a great combined meeting of the Silicon Valley JavaFX User Group (SvJugFx) together with the Silicon Valley Web User Group.  The presenters included Richard Hyde and James Allen from Oracle on the Java Store and Yoav Landman and Fred Simon from JFrog on repository management with Artifactory.

Our April SvJugFx presentation will feature Stuart Marks from the JavaFX Team in Hands on JavaFX – Scripting the Scene Graph.  To attend in person or via our live web stream (and be eligible for great prizes!), please sign-up here: http://www.svjugfx.org/calendar/12863551/

We were also fortunate enough to be contacted by the folks at Ubivent who have developed a JavaFX-based event platform.  Their platform is used by large corporations like SAP, and they have generously offered to host our videos going forward.  Therefore, you can now watch all the SvJugFx videos using JavaFX technology!

To watch the latest videos, you can go to the landing page for the new SvJugFX Video Site:

Registration is optional, but will allow you to comment on the presentations.  Once you launch the application you will be taken to an event hall that lets you choose which presentation you want to watch:

Finally, when you click on a presentation you will be given a virtual theater experience with side-by-side slides and video.  You can click on the double arrows to expand it to full screen, skip around by chapter, and comment on the video as you are watching.

For convenience, here are some links that will take you directly to the two videos and their associated slide shows:

Java Store & Java Warehouse Overview (video) (slides)

Repository Management with JFrog Artifactory (video) (slides)

Also, we have posted the videos on our Parleys SvJugFx Space and will continue to do that for folks who like using this excellent presentation platform.

Creating hyperlinks in JavaFX should be in the category of things that are trivially easy, but is complicated by various factors, such as deployment mode and Java version. First I will go into detail on all the different permutations of how you can launch links in a browser and under what circumstances each will work. Next I will give you a nice packaged solution that you can use as a library (if you are impatient, just skip to The Easy Way Out now).  Finally, I will show how you can do the same thing for JavaFX Mobile applications.

A Tale of 3 APIs

There are 3 different ways that you can launch hyperlinks in Java/JavaFX. It helps to have an internet connection such as broadband to be able to launch this. Unfortunately, none of them work in all circumstances, so you need to know when to call each. Here is a quick reference table:

AppletStageExtension

The first option is to use the JavaFX AppletStageExtension. This is only available if you are running as an Applet, but also gives you the most control over how the hyperlink is launched.  In addition to a URL you can also specify a target, which can be any of the standard HTML targets including the following (excerpted from the AppletStageExtension javadocs):

Web Start BasicService

The second option is to use the Web Start BasicService.  This works from both JavaFX Applets and Web Start applications, but does not let you specify the HTML target.  It is effectively the same as using the AppletStageExtension with a target of “_blank”.

Here is a small code excerpt showing how you would call the Web Start BasicService from your JavaFX code:

def basicService = ServiceManager.lookup("javax.jnlp.BasicService") as BasicService;
basicService.showDocument(new URL(url));

Desktop.browse

The third option is to use the new Desktop class introduced in Java 1.6.  This works from Applet, Web Start applications, and Standard Execution (within a desktop Frame).  Unfortunately, it did not exist in Java 1.5, so it won’t work from JavaFX without a little hacking.

The quick and dirty hack is to modify your JavaFX distribution to include the rt.jar from Java 1.6 as explained in this earlier post.  The only problem with this is you also have to get all the other developers on your project to do the same (and redo this on every upgrade).

The friendlier approach is to use reflection to check and see if the Desktop class is available, and then invoke the methods dynamically.  There is quite a bit more boilerplate code, but it will allow you to compile with a plain vanilla JavaFX installation, and also handle the odd case where someone is trying to run JavaFX under 1.5.  (Which is unsupported on Windows/Unix, and is now even supported on 32-bit Mac systems with the release of Snow Leopard!).

Since the code is easier to follow without reflection, I will show that first:

Desktop.getDesktop().browse(new URI(url));

And here is the munged version with reflection:

try {
    def desktopClazz = Class.forName("java.awt.Desktop");
    def desktop = desktopClazz.getMethod("getDesktop").invoke(null);
    def browseMethod = desktopClazz.getMethod("browse", [URI.class] as java.lang.Class[]);
    browseMethod.invoke(desktop, new URI(url));
} catch (e) {
    println("Upgrade to Java 6 or later to launch hyperlinks: {url}");
}

The Easy Way Out

When things are easy to do, they will get done right.  To make sure that JavaFX applications do not fall prey to broken and inconsistent linking, I put together a library for JFXtras that takes care of all the plumbing for you.

There is a new JFXtras class called BrowserUtil that has a very simple API:

BrowserUtil.browse(url);

or

BrowserUtil.browse(url, target);

It is that simple…  Conversion of string URLs to URL or URI objects, selection of the correct API based on your deployment mode, and failover modes based on the Java version are all included.

In addition, I created an extended Hyperlink called the XHyperlink.  This behaves identically to the built-in control, with the addition of simple configuration of URL navigation (this is what hyperlinks are designed for, right?)  The usage of the XHyperlink class is as follows:

XHyperlink {
    text: "Oracle's Homepage", url: "http://oracle.com/"}
}

All of this functionality will be included in the JFXtras 0.6 release.  If you need it now, you can build off the head of our repo.  Otherwise we are working on a release, which I will announce on this blog shortly which you can follow.

What about JavaFX mobile?

None of these desktop techniques actually work on a mobile device, so this is not a 100% solution yet.

Fortunately, there is also a solution for JavaFX Mobile if you are willing to delve in to the Java ME APIs.  To do this you first need to get a handle to the MIDlet like this:

def midlet = com.sun.javafx.runtime.adapter.MIDletAdapter.getMidlet();

And then you can call platformRequest to launch a browser on the mobile device:

midlet.platformRequest(url);

Note: This requires use of private APIs, so this may not work in future JavaFX releases.

It is not possible to merge this in with the desktop solution, because the JavaFX Mobile libraries do not exist on the desktop platform (and vice versa), but it is relatively easy to use this technique yourself by copying and pasting the above code sample into a helper function in your application.

In case you missed the big event last week, I have finished post-processing and uploading the video.  We took the quality up a notch by getting a direct screen capture from the presenter laptop.  This means that you will not only get crystal clear slides, but also full-screen demos and a nice tight head-shot of the presenter.  This moves our video setup firmly up from a Level 4 to a premium Level 1 operation as detailed in Stephan Janssen’s blog.

Without further ado, here is the Parleys version of Hinkmond’s JavaFX Mobile Dojo talk:

I got a lot of requests for just the slides last time, so I am also making them available here:

Finally, a quick plug for our next SvJugFx event.  We will be doing a double feature with folks from the Java Store and JFrog Artifactory presenting back-to-back.  Even if you plan to attend online, make sure to sign-up here:
http://www.svjugfx.org/calendar/12559455/