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.

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):

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.

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.

Happy Thanksgiving from the JFXtras team!  While everyone else is celebrating the holiday with friends and family, we are going to be busy finishing up the 0.6 release.

Wild turkey in LaConner, WA taken by stevevoght

In case you have some spare time between meals and celebration, you can join in the fun too by trying out the JFXtras 0.6 preview release, which can be downloaded here:

http://code.google.com/p/jfxtras/downloads/list

There is a whole slew of new functionality including the following under Common:

• Layouts – Changes to the Grid API in preparation for inclusion in the JavaFX Soma release, and also added animation support to all the layouts.
• Sphere – Pseudo 3D sphere created for the Groovy showdown with Andrey Almiray.
• Gear – New shape from Steve Bixby.
• ManualResizableRectangle – Very useful shape from Yannick’s post.
• JXScene – Pedro’s improved API for Swing integration.
• PaintUtil, HSBColor, new gradients – Liu’s magic paint classes
• Custom Paints – From Jeff Friesen’s excellent article on Custom Paints.
• Custom Cursors – From Jeff Friesen’s excellent article on Custom Cursors.
• Wipe Library – A transition library from Simon Morris’ JavaFX in Action book.
• XMap – A bindable Map implementation for JavaFX.
• XStore – David Armitage’s simple persistence for JavaFX variables using dependency injection.
• ImageCache – Caching of JavaFX images for building high performance applications contributed by Joshua Marinacci.
• XEDT – Simplified event thread mangement for JavaFX infrastructure classes (Warning: Use the JavaFX Task API instead unless you know exactly what you are doing)

And the rest under a new Controls jar:

• XTableView – I am still working on this, but it is very useful already as demonstrated by Jim Weaver’s SpeedReaderFX application.
• XTreeView – Jim Clarke’s Tree Control.
• XCalendarPicker – Tom’s excellent calendar control.
• XPane – A titled region with rounded corners developed by Dean Iverson.
• XPicker – David Armitage did some great work on this…  Check out his demo on the JFXtras website.
• XShelfView – A high performance Display Shelf control implementation with support for reflection, titles, and a scrollbar as showcased on JFXStudio.
• XSpinnerWheel – A prize spinner wheel that makes use of pseudo 3D effects as showcased in the JUG Prize Spinner application.
• XMenu – Pure JavaFX Menu developed by Jonathan Giles (this version will be replaced by the official Sun Menu control when it becomes available).
• XPasswordBox – Control from Liu to create a password field.
• XMultiLineTextBox – Till’s control for editing multiple lines of text.
• XSwingTable – From John Freeman, this gives you all the power of a JTable directly from JavaFX code.

For this release we decided to go with a new naming convention to differentiate our classes from the built-in JavaFX layouts and controls.  Most of the classes are now prefixed with an “X” for jfXtras.  This will make migration slightly more painful now, but prevent future collisions and name changes down the road.

There is also a new version of JFXtras Test.  This is the final version that will be released under this name (it is being merged with FEST-JavaFX), but it required an update to work with the new naming convention and to add some much-needed JUnit Runner support (see my Devoxx Conference Presentation for more details).

I probably missed a few things along the way here.  You can find the definitive list in the online JavaFXDoc:

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

Please feel free to download the jars and give the preview release a try.  We are putting the finishing touches on several of the layouts and controls, so expect a final release in a week or so.

Happy Thanksgiving!

Overall I was very impressed with Devoxx.  Everything including the movie theater venue, quality of the speakers, and professionalism of the attendees was top-notch.  Stephan Janssen definitely puts on quite an amazing show!

As a follow-up to my second Devoxx session, here is the full slide deck I presented:

Both this and the university session will be available on the Parleys.com beta site shortly, so you will be able to watch both sessions from the comfort of your home.

Now back to coding on the JFXtras 0.6 release with an announcement to be posted here very shortly…

Last night I presented at the SDForum Java SIG to a very engaged and enthusiastic crowd.  This was the longest presentation to date, but the audience was great, and even stayed afterwards to ask questions.  Also, Rich Rein was an outstanding host, inviting us out to drink beers until midnight after the event (I hope his wife wasn’t upset!)

This is my last presentation gig until Devoxx at the end of the year, but I was able to get a great screencast recording of the session, which you can watch in full resolution on blip.tv:

Click here to view the embedded video.

Note: The end of the presentation got cut off due to a technical glitch in Camtasia, but to their credit it recovered the bulk of the recording on restart.

You can also browse the slide decks at your own pace in PDF format:

Part A (JFXtras): SuperchargingWithJFXtras-SDForum

Part B (WidgetFX): SuperchargingWithWidgetFX-SDForum

I hope you enjoy the video and slides!

I am proud to announce the official launch of the JFXtras Community Site.  This site is a resource for the entire JavaFX community, and open for participation by all.

Just like the JFXtras open-source library has been helping improve the JavaFX Platform, this site is focused on helping to expand and grow the JavaFX Community.  Some things you can do on the site today include:

Explore -

The JFXtras Samples section is the largest JavaFX example repository outside of Sun, and is specifically focused on teaching JavaFX concepts from beginner to advanced.  Some of the featured samples include:

• Amy Fowler’s Boundisizer – Learn how to transform and manipulate nodes like a champ from Amy Fowler, the acclaimed layout expert on the JavaFX team.
• Music Explorer FX – You may not have won the 25 thousand dollar prize, but you can learn from the expert.  Sten Anderson has posted his winning entry, and promised to share the full source code shortly (no pressure, Sten!)
• Particle-O-Rama – Josh Marinacci, JavaFX evangelist and Rockstar¹, creates another visual extravaganza with his super-customizable particle demo.
• Generating Graphs from Hudson – Mark Macumber posted a great mash-up of the JavaFX 1.2 Charting support to display Hudson build status.

The site is completely self-service, and provides free hosting of open-source JavaFX samples, so create an account and start contributing your own samples to grow the community!

Learn -

Through a collaborative effort from all the JavaFX book authors, we will be able to bring you the full set of samples from all 5 of the JavaFX books.  All the source code will be made available under a commercial-friendly open-source license, and the samples will be easily browseable online categorized by topic.

This includes all of the samples from Pro JavaFX Platform, which is finally out in print! — The full realization that I was an author didn’t come until this morning when my copies arrived… for a brief moment the gaping hole in my life for the past six months seemed (almost) worth it.

The Sun JavaFX and Essential JavaFX books have been out since JavaOne and are great references to get started coding in JavaFX.  These samples should be available within the next couple weeks.

Finally, the JavaFX in Action and JavaFX Developer’s Guide books are both due out later this year, and will post samples as soon as it makes sense to.

Research -

There is also a new section called JFXtras Links brought to you by Jonathan Giles, famous for his weekly desktop links of the week feature on his blog.  The plan is to aggregate and categorize all the best JavaFX links and resources in a single place.

This section is still in its infancy, so please give us feedback and contribute links that you find valuable.

About the Site -

The JFXtras Community Site is built on the principles of collaboration and agility, and is backed by technologies that make this possible.  Everything is 100% Java from the application server (Tomcat) to the portal engine (Liferay).  Also, wherever possible customization and design was done via the online portal user interface so that future changes to the site (both minor and major) can be done by the community.

Most importantly, the JFXtras Community Site will be what you make of it.  Just like everything else we do on the JFXtras project, we are open to new ideas and ways of doing things.  If you have a great idea for how to improve one of the existing sections, or something else we should add to the site, let us know, or better yet, help us make it happen!

I will be presenting at the Oakland Java SIG on July 15th.  The topic is “Supercharging Your JavaFX Programs with WidgetFX and JFXtras,” and will include some brand new content based on the WidgetFX 1.2 and JFXtras 0.5 releases.

As usual, I will incur some significant demo risk for the sake of showing some jaw-dropping demo awesomeness!  You will either be totally impressed or get a good laugh at my expense…

If you are in the SF Bay Area, be sure to drop by and check it out!

I am pleased to announce the 0.5 release of JFXtras.  This release updates the project with JavaFX 1.2 support, plus includes a major overhaul of the Shapes, Borders, and Layouts.

You can grab the latest bits here:
http://code.google.com/p/jfxtras/downloads/list

And browse the Javadoc online.

Pure JavaFX Shapes

Why should you care that we spent months re-implementing all the Shapes from scratch in pure JavaFX code?  Well, here are a few reasons:

1. JavaFX 1.2 Compatibility - The JavaFX scene graph was pretty-much rewritten from the ground up in the 1.2 release, so porting the old Shape code was non-trivial.
2. Mobile Deployment - Yes, you can now draw stars, balloons, and reuleaux triangles on your new HTC Diamond.  (What, you didn’t pick up a JavaFX Mobile device at JavaOne?  Your loss…)
3. Richard Bair said to do it…  Rich isn’t the sort of guy you say no to, and he was pretty adament about the fact that we shouldn’t be hacking the scene graph directly.  Well, now we aren’t.  (although don’t let him know about our new hack to embed JavaFX in Swing…)

You can try out the new shapes by running the DrawJFXtras sample program from the Pro JavaFX Platform book (which has an entire chapter dedicated to the JFXtras project and other JavaFX FOSS):

Draw JFXtras Sample Application

Note:  When playing with the demo be careful using the balloon and rounded rectangle shapes.  They trigger a nasty bounds-detection bug that we still haven’t tracked down.

Thanks to my coworker, Steve Bixby for doing the rewrite in his spare time.  He was looking for a little project to learn JavaFX, and went way above and beyond!

Redesigned Borders

We also redesigned the JFXtras Borders from scratch.  Here are some of the new and noteworthy improvements:

• Improved performance – The borders render much more quickly, because they take advantage of the new layout infrastructure. This means you can layer and nest borders to your heart’s content without worrying about slow rendering or resizing.
• Developer-friendly properties – The border properties are still available via CSS, but can now easily be set using variables on the classes as well.
• Shape-to-Fit support – There is a new property on the border class called shapeToFit that allows you to choose between having the border fill the available width/height or hugging the component.

Layouts Reloaded

What JFXtras release would be complete without at least a partial layout rewrite?  Well, the JavaFX team didn’t leave us much of a choice here, given all the great work they did on layouts in JavaFX 1.2.

The good news is that Amy Fowler and I were mostly on the same wavelength, so the upgrade should be relatively painless.  Here are some of the reasons to use the new JFXtras layout classes:

• Take advantage of JavaFX 1.2 features – All the JFXtras layouts will honor layoutInfo constraints set on Nodes such as hpos, vpos, and managed.
• Plus Extended layout features – JFXtras layers fill, span, grow, and full support for resizable layouts.  Simply drop in the ResizableXXX replacement classes (ResizableScene, ResizableHBox, ResizableImageView, etc.) and forget about manual binding of layouts.
• Plus the JFXtras Defaults System – Most components want to be laid out a certain way.  For example, you usually want Labels left aligned and TextBoxes to grow horizontally.  JFXtras provides defaults for all the new JavaFX 1.2 controls so you don’t have to.
• And still the best Grids around – The JFXtras Grid and MigLayout have both been fully updated to work with JavaFX 1.2.  Combined together, you have the most powerful layout system available for JavaFX (or any RIA platform) period.

A great way to learn about the JFXtras layouts is by reading Chapter 8 of the Pro JavaFX Platform book.  It goes over a complex MediaExplorer Sample built from the ground up using all the JFXtras layouts from ResizableScene to Grid to MigLayout.

JavaFX Wrapper for Swing

Amy had a great blog that described how to makeover a JavaFX application by embedding Swing, but how about going the other direction?  With the new SceneToJComponent class, you can do exactly that from a standard API like this:

public SceneToJComponentTest() {
    String sceneClass = "org.jfxtras.scene.SceneToJComponentScene";
    setDefaultCloseOperation(javax.swing.WindowConstants.EXIT_ON_CLOSE);
    setTitle("FX Panel Test");
    getContentPane().setLayout(new BorderLayout());

    JComponent theScene = SceneToJComponent.loadScene(sceneClass);
    getContentPane().add(new JLabel("JLabel: The following is a JavaFX Scene"), BorderLayout.NORTH);
    getContentPane().add(theScene, BorderLayout.CENTER);

    pack();
}

This class allows you convert any JavaFX Scene to a Swing JComponent that can be embedded in a larger application, insulating you from future changes in the JavaFX internal APIs.

Full List of Features, Enhancements, and Changes

For existing JFXtras users who want all the gory details that they will need to migrate their applications and take advantage of new features, here it is:

• JavaFX Wrapper for Swing:
  • The new SceneToJComponent class makes it easy to wrap your JavaFX user interface in a JComponent that you can use from any Swing UI
  • This insulates you from directly calling the JavaFX internal APIs, which may change in any release.
• JavaFX 1.2 Compatibility:
  • This breaks binary compatibility with old versions.  Please recompile all your code
• JSONHandler:
  • Enhanced variable name mapping support
• JFXtras Borders Changes:
  • Border child is now in a parameter called “node” rather than “content”
  • New shapeToFit property to choose between matching the container set width/height or wrapping the nested node
  • Properties are now exposed directly on the border classes in addition to being accessible from CSS.
  • Various border tweaks…  ShapeBorder is now used for clipping, TitledBorder has a line, etc.
• JFXtras Layout Changes:
  • HAlign/VAlign have been removed in favor of using the new built-in HPos/VPos classes.
  • Fill is not an orthoganal property in its own class used by ExtendedLayoutInfo (which extends LayoutInfo)
  • Grow and span are now on a new GridLayoutInfo class that extends ExtendedLayoutInfo
  • Layout contants are now all in the new LayoutConstants class (formerly GridContraints)
  • ResizableHBox/ResizableVBox have been updated with the new hpos/vpos/nodeHPos/nodeVPos parameters from HBox/VBox
  • ResizableScene now support nodeHPos/nodeVPos parameters
  • Deck now supports nodeHPos/nodeVPos parameters
  • Grid position default is LEFT/MIDDLE
  • Grid now supports nodeHPos/nodeVPos parameters
  • Grid now handles toFront/toBack correctly (and is the only layout in existence that does)
  • New DefaultLayout class for supporting the JFXtras defaults system
  • New JFXContainer class created to support JFXtras layout extensions
  • Removed org.jfxtras.layout.EmptyBorder.  User org.jfxtras.scene.border.EmptyBorder instead.
• Component Changes:
  • ScrollView now uses JavaFX ScrollBar and ClipView
• MigLayout Changes
  • MigLayout fixed to make it work with JavaFX 1.2.
  • MigLayout handles dynamic changes to node sizes and their layoutInfo’s managed flag
  • MigLayout code is no longer forked (thanks to nativearrary support in JavaFX!)
• JFXtras Shapes changes:
  • JFXtras Shapes are now defined as native JavaFX shapes
  • Shapes are generally more fault tolerant to invalid parameter values
  • Almond & Asterisk ‘width’ is now from left to right rather than left-to-center or center-to-right.
  • Asterisk arm width is now as specified (was twice as wide.)
  • ReuleauxTriangle is treated as a spherical object and has centerX, centerY, and radius, rather than x/y/width.
  • All shapes use native JavaFX transforms; specifically, angle of rotation is clockwise rather than counterclockwise as before.
  • All shapes rotate about their bounds center rather than around a starting point – as do all Path-based native JavaFX shapes.

Thanks to the whole JFXtras team, and especially Steve Bixby, Jim Clarke, Dean Iverson, and Keith Combs, for making this release possible.

Enjoy the new JFXtras Release!