OSCON Java is a new conference that I am helping to kick off as co-chair this July.  While there are plenty of conferences out there that you could attend, I am confident that this is the one you won’t want to miss.

To celebrate the Java 7 release, I put together 7 reasons why you should attend OSCON Java.  Also, make sure to use the 20% discount code of “OS11COM” when you register:

1. Come Celebrate the First New Java Release in Half a Decade!

The last major release of Java was Java 6, which came out 5 years ago on December 11, 2006. After only a year of the Sun acquisition, Oracle has already made a major Java release happen with another scheduled in a year’s time.

We have broad coverage of the Java 7 release with a keynote and technical session by Joe Darcy, and technical sessions on OpenJDK and Coin by Dalibor Topic and Stuart Marks. I have been pretty impressed with Stuart’s coverage of topics from a developer’s perspective and am looking forward to his talk myself.

2. Because Google Matters

Regardless of what you think about the Android lawsuit, I think the biggest detriment has been the lack of good content on Google technologies at Java conferences. We are an independent conference, so it allows us to bring content that you would otherwise not find, such as an exclusive keynote from Joshua Bloch and several mobile Android sessions to help you leverage your Java skills on modern devices.

3. You Think JVM Languages are Cool

It has been said that the crown jewel of the Java platform is the JVM, not the language. Java 7 has further solidified this with better support for dynamic languages. Come find out what is the latest and greatest on the alternative language front with a keynote and some meaty sessions from Martin Odersky, deep technical sessions on Groovy, Clojure, Scala, and other languages, and some bytecode hacking with Charles Nutter.

4. And You Wouldn’t Mind Hanging out with JVM language Authors for a Day…

On the Sunday before OSCON we are organizing a free JVM Languages Symposium that many of the speakers will be attending.  This is a great opportunity to hang out with JVM language authors and the movers and shakers in the industry in an informal unconference atmosphere.  Events like this are what I believe sets apart community-driven conferences from large corporate events, and provide a lot more value to the attendees than simply one-way content.  If you happen to be in the Portland area, you can drop by for this free event with no obligation to stay for OSCON.

5. Your Boss Won’t Let You Fly to Belgium

I travel to speak at different conferences around the world and I would have to say that the golden standard for Java conferences is Devoxx. They have an amazing venue — it is great to see your slides on a huge movie screen, and relaxing for attendees to take it in from nice, plush seats. They attract an international audience… not only Belgium, but Italy, France, Germany, and citizens of many of the other surrounding countries consider Devoxx their home conference. Even though Devoxx is a wildly successful conference, they still have a small-conference feel, run by a very tight knit conference committee that acts more like a user group than an organization. This makes the entire conference experience much more personalized.

OSCON Java has a lot of similarities with Devoxx. It has a small, enthusiastic program committee with folks who really care about Java technologies. We are also following the Devoxx model of recording and posting talks online afterwards, so even if you miss a great talk because you are in the room next door, you can always watch it online later. Finally, since we are an independent conference, you get the full experience of Java, Android, and other technologies that you would otherwise have to go to multiple conferences to see.

6. OSCON is a Pretty Sweet Conference as Well…

The O’Reilly OSCON conference has been underrepresented in the Java community, but is a pretty huge event in its own right.  They have some amazing content around emerging languages and mobile platforms.  Plus, you can get OSCON, OSCON Java, and OSCON Data all wrapped up in one neat package with the OSCON Superpass.

7. There is Only One Inaugural Year!

This is our first year putting on OSCON Java, so we are pulling out all the stops with the best speakers, tutorials, content, and events.  You will have a unique opportunity to participate in the creation of a new Java tradition, and a decade from now can brag to your friends about being a founding attendee of the biggest open-source Java conference in the world.

It is pretty easy to get lost in the media hype around the Java events of the past year.  If you follow the headlines, you might believe that all the Java talent left Oracle in a mass exodus, Larry hates open source, or Java is turning into the next COBOL.  Regardless of the factual correctness of these headlines, the Java ecosystem is about more than a single company or set of individuals.  Java has the largest open-source community of any language in existence!

So how big is Java and open-source?  Here is an informal search poll of some of the most popular open-source project hosting providers:

The data for this chart comes from the top six open-source hosting providers using Google Search as a metric for gauging activity level for each of the platforms.  As you can see, Java is still the most active open-source platform in the world, followed closely by PHP and Python.  While not an indicator of language popularity, Bill Gates has gone on record speaking out against open source, so the poor representation from the C# community is not surprising.

This takes us to OSCON Java, which is a new conference I am helping to kick off as conference co-chair together with Laurel Ruma.  It is colocated with OSCON in Portland, Oregon, but is exclusively focused on Java and open source.  O’Reilly is the conference organizer, but they are very neutral when it comes to corporations and technologies.  This allows us to reach out to a wide variety of Java technology players including Apache, Google, Adobe, Oracle, the JCP, and many others.

We have big plans for the OSCON Java keynotes, technical content, and exhibitors.  Also, we are working on making this a model conference from the get-go based on my experience attending and speaking at premier conference venues across the world.  Expect a huge focus on community outreach, a lot of interaction between speakers and attendees, and a particular focus on the JVM languages of tomorrow.

If you are interested in participating as a speaker, it is still not too late to submit a talk.  The CFP ends on March 28th (4 days!), so you still have time to submit a last minute talk:

http://www.oscon.com/oscon2011/public/cfp/159

If you have a great idea, but can’t get your talk together in time or miss the deadline by a few days, shoot me an e-mail via the contact form on my blog.

I look forward to seeing you at OSCON Java, uniting the Java open-source community towards a brighter future!

I am pleased to announce the Flash On… user group that I am kicking off together with Keith Sutton, Oswald Campesato, and Justin Webb.  The focus is Flash on consumer devices from Mobile to Tablet to TV.

Oswald and I will be doing the inaugural presentation on Flash mobile technologies this evening.  You can catch the live stream on Adobe Connect here:

http://experts.na3.acrobat.com/flashondevices/
(Stream starts at 7PM PST!)

For those of you who haven’t been following the Flash Mobile headlines, there have been a lot of great announcements that make this platform worth developing for:

Mobile

• With the AIR 2.5 release, Android devices are fully supported
• Apple has relaxed their license to allow Flash-based applications in the App Store
• Similar announcements have come from other vendors such as Palm, Windows 7, and others

TV

• Google TV prominently features Flash support
• Adobe also announced AIR support for Samsung devices such as Smart TVs and Blu-ray Players

Tablet

• Blackberry announced Adobe AIR support for their Playbook Tablet

Here is an excerpt from the Adobe Max 2010 keynote that shows off the Blackberry Playbook Tablet running Flash:

When put together, Flash is well poised to become the defacto standard for building rich user experiences across different screens.

We will cover all this and more in our presentation tonight.  As usual, we will have high production values for the talk with side-by-side presenter video and slides plus a chat area to ask questions.  I hope to see you there!

I am pleased to announce the Visage Language, a domain specific language (DSL) for writing user interfaces.

http://visage-lang.org/

User interface developers have long been neglected and forced to deal with languages and tooling that are a poor fit for their craft.  At times they are asked to write user interfaces in languages originally meant for server-side applications such as C and Java.  In other instances they are required to use a markup language originally meant for representing documents or structured data such as HTML and XML.  These are fine technologies for the applications in which they were originally intended, but a weak substitute for declaring and representing user interfaces.

The goal of Visage is to provide a common language for user interface developers that provides the following benefits:

1. Model the UI – The code should look like the user interface with a similar structure to how the resulting application will appear.
2. Data Binding – All user interfaces have a backend model, so it should be easy and painless to hook this up to the UI with bidirectional integration.
3. Resilient Behavior – The last thing you want to see during a customer demo of your new application is a NullPointerException.  Language constructs should have deterministic, but fault tolerant behavior in all cases.
4. Rapid Development – Application development should allow rapid, iterative cycles with early feedback starting right at the compilation phase.

The way in which Visage satisfies these requirements is summarized in the following table:

So what does a Visage application look like?  Here is Hello World in the Visage language:

Stage {
  title: "Hello World"
  Scene {
    Text {
      "Hello World"
    }
  }
}

This code should look familiar to readers of my blog.  It is based on the JavaFX Script language with a few (proposed) syntactic additions.

For those of you who don’t know the history of JavaFX Script, it was originally designed by Christopher Oliver and called F3 for Form Follows Function.  With the acquisition of SeeBeyond by Sun, this technology became the cornerstone of JavaFX and was open sourced in 2007 at JavaOne.  Oracle purchased Sun and just this past week at JavaOne 2010 announced that they are going to continue with the JavaFX Platform, but replace the JavaFX Script language with Java APIs.  We are adopting the JavaFX Compiler for use in the Visage project, and plan to continue evolving it.

Here are some of the goals of the Visage project:

• Provide a JavaFX Java API Binding – One of the most innovative parts of the JavaFX platform was the language, and it is what all JavaFX applications are written in today.  Our number 1 project goal is to make sure that developers can continue to write declarative code and easily port over their existing applications.
• Enhance the Visage Language – The language syntax remains largely unchanged since the 1.0 release of JavaFX.  We plan on making numerous improvements that will be beneficial to UI programmers and make common patterns easier to code.
• Support for Other Platforms – For the Visage language to thrive, it has to be a general purpose UI programming language.  Some other platforms that are in great need of a UI DSL include HTML5, Flex, and Android.
• Language Standardization – We would like to see the Visage language be made an official standard with possibly multiple implementations.

If you are interested in following the project or helping out, please join the Google Groups:

http://groups.google.com/group/visage-users

http://groups.google.com/group/visage-dev

There were some huge announcements at JavaOne today for the JavaFX platform.  Overall I think the announcements show some very positive momentum for the future of JavaFX and rich client Java, but there were some casualties…

In this blog I will cover the salient bits, but if you would like an opportunity to hear it directly from the JavaFX leadership team in a free event, we will be hosting a JavaFX 2.0 event with Richard Bair and Jai Suri at our next SvJugFX meeting.  As usual, the event will be streamed live, and questions can be asked remotely via Google Moderator.

.

The Good Parts:

Java and Alternative JVM Languages

JavaFX has a new API face.  All the JavaFX 2.0 APIs will be exposed via Java classes that will make it much easier to integrate Java server and client code.  This also opens up some huge possibilities for JVM language integration with JavaFX that Jonathan Giles and I explored in our JavaOne talk today.  We did a whirlwind tour through four different JVM languages (Ruby, Clojure, Groovy, and Scala) showing what JavaFX 2.0 code may look like when ported to these different languages.

Here is the full presentation deck:

Which can also be downloaded as a PDF.

Open Source Controls

Thomas Kurian announced a strategy to open source the JavaFX controls going forward.  This is a huge move in the right direction for the platform, and will make life for us third-party control developers much better!  Even though this is not the full platform open sourcing that I have been petitioning for (thanks for all your support!!!), I will still take some of the credit. 

JavaFX 2.0 Proposed Roadmap

Oracle has published a proposed roadmap for JavaFX 2.0 in the 2011 timeframe.  There are some really great things included, many of which I have been campaigning for:

• Multithreading Improvements – The move to Java APIs breaks down some of the barriers to multi-threaded programming that were present with JavaFX.  Presumably a similar model to Swing will exist where you can launch worker threads, but still have to do all UI operations on a main event thread.
• Texture Paint – Interesting to see this highlighted, but its use in JavaFX was pioneered by Jeff Friesen and included in JFXtras 0.7.
• Grid Layout Container + CSS – Very good to see that they are taking the Grid Layout and evolving it.  The addition of making it accessible from CSS will make it an extremely powerful layout container suitable for multiple uses.
• HD Media – Media seems to be getting a big upgrade, which has been long overdue.  This is in addition to other promised improvements in full screen capabilities, media markers, animation synchronization, and low latency audio.
• HTML5 WebView – It is good to see that this is finally getting the attention it deserves.  JavaFX is great for dynamic application development, but is not well suited for content presentation.  The combination of JavaFX + HTML5 will greatly expand the range of applications that can be developed.
• Controls Galore! – TableView, SplitView, TabView, and Rich Text to name a few.  This is a necessity to build robust enterprise applications.
• File (and other) Dialogs – This may seem like a minor point, but is incredibly important for building real applications.

HTML5 Support

Not to be confused with the WebView, there is also a plan for the successor to JavaFX 2.0 (2012 timeframe) to support an alternate HTML5 rendering pipeline.  Not many details are available about this yet, but it could be a huge technological breakthrough if they are able to pull it off successfully.  The practical applications of being able to deploy your JavaFX application to any HTML5 compliant device is enormous.

.

The Casualties:

JavaFX Script

JavaFX Script was good to us, but it is no longer a go forward technology for Oracle.  I am a bit disappointed about this move, because it takes away a lot of the productivity benefits that have made JavaFX code a joy to write.  However, many of the promised improvements in JavaFX 2.0 are around language features of JavaFX Script (such as binding and sequences), so hopefully they can maintain some of the benefits.

Richard Bair added a very insightful post on his blog, which goes into more details on the language changes and is well worth a read.

JavaFX Mobile

JavaFX Mobile has not seen a lot of action since JavaOne 2009 and the mobile focus in the keynote was on JavaME and LWUIT.  I am still a big fan of the “write once, run anywhere” mantra, and am waiting for this to return to the mobile space.  With the proliferation of different mobile programming models (Android, iPhone, WebOS, etc.), whoever solves the mobile cross-platform development problem in a technically solid way will profit immensely.

.

What’s Next?

Now that Oracle is done with their announcements, I have some of my own.  If you are at JavaOne, drop by my Wednesday session entitled “JFXtras: JavaFX Controls, Layouts, Services, and More” at 2:15 to hear it firsthand, or wait for my blog post shortly following that.

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.