If you preregistered for any JavaFX sessions at JavaOne, you probably noticed a bit of churn in the past few weeks.  I actually requested that they drop my talk entitled “Take Control of JavaFX”, because Jonathan and I didn’t think we could do justice to the topic.

However, we came up with an alternative talk, which we believe will be even better and more topical.  Here are the talk details:

JavaFX Your Way: Building JavaFX Applications with Alternative Languages
Abstract: JavaFX is more than a language. It is also a platform for building immersive applications with graphics, animation, and rich media. In this session, you will see how you can leverage JavaFX from a host of different JVM languages, including Java, JRuby, Groovy, Scala, and Clojure.

The talk is on Monday at 4PM in Hilton San Francisco, Golden Gate 8.  Hope to see you there!

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.

For those of you who don’t know, SvJugFx stands for the Silicon Valley JavaFX Users Group.  We will be holding our very first meeting this coming Wednesday with a live, streamed presentation from the world renowned Richard Bair (who is now infamous for divulging JavaFX secrets at Devoxx).

Richard Bair Presenting at Devoxx 2009

Yes, I said streamed live…  for those of you who are not fortunate enough to live in Silicon Valley, you can still participate in realtime by doing the following:

1. Sign-up for the SvJugFx meetup group.  This is the primary communication vehicle we will use to announce last-minute changes:
   http://www.svjugfx.org/
   (Note: Everyone can sign up for the group, but please only RSVP for the event if you are physically attending)
2. For the video feed, please go to the following ustream channel:

   http://www.ustream.tv/channel/silicon-valley-javafx-user-group

3. And to participate, please log on to Google Moderator at the following URL:

   http://moderator.appspot.com/#16/e=d528e

The in-person meeting will start on: Wednesday at 6PM PST
The online streaming will start at latest by: 7PM PST (possibly earlier)

Please leave enough time to login on both sites and test your internet and video playback capabilities.  You will be able to watch the live video stream on ustream and respond with your own questions (as well as vote other participant’s questions up and down) via Google Moderator, which we will be monitoring during the presentation.

This is the first time we are trying this format, so we apologize in advance for technical glitches or issues that we are sure will arise.

“Success is the ability to go from failure to failure without losing your enthusiasm.”

–Winston Churchill

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!

JavaFX has a very active Twitter community.  Some have even said that the best way to get help with your JavaFX app is to ask on Twitter first.  But how do you know who to follow?

To make it easy to hook in to the JavaFX Twitter community, I put together a JavaFX Twitter Group using the new group support.  To subscribe, simply follow @steveonjava/javafx:

The JavaFX Twitter Group Stream

So who will you find on this list?  Some big names in the JavaFX Community, including:

• Richard Bair, Joshua Marinacci, and Jonathan Giles from the JavaFX team
• JavaFX book authors such as Jim Weaver, Weiqi Gao, Dean Iverson, and Simon Morris
• JavaFX evangelists such as Maijaliisa Burkert, and Anatoli Fomenko
• JavaFX early adopters such as Peter Pilgrim, Sten Karl, Steven Herod, Carl Dea, William Antonio, Pär Dahlberg, Mark Macumber, Tom, Enrique Garcia, Eric Wendelin, Hideki Kobayashi, and many, many others

I tried my best to dig in a few levels deep on the twitter lists of folks I know are active in the JavaFX community so I would get pretty good coverage.  The basic criteria I used for selecting folks was percentage of tweets dedicated to JavaFX discussion.  Most of the folks on the list talk about JavaFX in 50% or more of their tweets, although there are a few notable exceptions (ahem..  Steven Herod).

Please follow the new JavaFX Twitter Group, and if you would like to be followed by the list, tweet me a direct message @steveonjava.

I am pleased to announce the formation of a new Silicon Valley JavaFX User Group.  While this group is rooted in the SF Bay Area, we also plan to make it easy for remote attendees to watch and participate by doing live streaming of our meetings via USTREAM and allowing remote participation through Google Moderator.

For the initial launch meeting on December 9th we are fortunate to have Richard Bair as the presenter.  For those of you who don’t know him, he is a JavaFX lead developer, JavaOne Rockstar Speaker, has an awesome blog, and will be talking about JavaFX at Devoxx (where I am also presenting).  He is also a great sparring partner on almost any technical topic (speaking from experience), so Q&A should be lots of fun!

The SvJugFx Homepage is on Meetup.com where you can sign up to become a member and register for the December 9th session with Richard:

This is the first JavaFX User Group in the U.S. to my knowledge.  Although Japan has the title of world’s first JavaFX User Group as reported on Jim Weaver’s blog.

We have an early Halloween treat from the WidgetFX team… a new software release!  The 1.2.4 version of WidgetFX includes some new functionality and fixes a number of issues that our user community has requested.

New SlideShow Widget

The SlideShow widget was completely rewritten from scratch for this release.  It makes use of the pre-release JFXtras XShelf component for transitions and paging forward and back.  Simply click on the side images to scroll forwards and backwards through your library.

Here is a picture of the new SlideShow widget in action, paging through a set of Halloween pictures (courtesy of Keith Combs):

Happy Halloween from the WidgetFX Team!

If you are enough of an Anime buff to know which series these pictures came from, be sure to leave a comment below!

Auto-start on 64-Bit and International Systems

Japanese WidgetFX Article

The link that gets created to restart WidgetFX now picks up the correct JVM version on 64-bit systems and even handles paths properly for non-US versions of Windows.  This is very important for our friends outsides the US, such as the growing Japanese WidgetFX community.  As an example, check out this translated Japanese article in @IT by long-time WidgetFX developer, Hideki Kobayashi (he is also responsible for the Japanese location of our website).

If you have trouble running WidgetFX on a 64-bit system, make sure you have the 32-bit JVM installed on your machine.  This can be installed side-by-side with a 64-bit JVM, and is required for JavaFX applications to run.

Certificate Update

Our application signing certificate expired, producing warnings upon launch of WidgetFX.  We have generated a new certificate, which should be good for another year.

If you noticed any problems with launching WidgetFX this week, please try again.  We ran into a Webstart bug where it did not correctly update the jar file after the certificate upgrade causing a verification error on start-up.  We were able to fix this by doing nothing but revving the version (missing some great opportunities for bad puns on the intermediate 1.2.3 version number).

And Some Bugfixes…

We are always fixing small bugs or issues as they come up.  One in particular was an infinite loop during start-up caused by some specific network settings.

If you notice any issues with WidgetFX, let us know so we can make it better!