James Weaver on Quantum Computing and Java

Six Degrees of Aynsley Dunbar: BandmatesFX Example JavaFX App Continued

So far in this Freebase Contributing Artists App series, we've been developing a JavaFX application that enables the user to navigate connections among musicians.  I'm calling this application BandmatesFX, and it uses the JSONHandler feature of the JFXtras open source library to easily query the Freebase.com database.

Note: While using this app, I noticed that drummer Aynsley Dunbar has played with lots of bands over the years, so he's a good starting point for trying to navigate to another given musician in six or less degrees.  Try, for example, to navigate from Aynsley Dunbar to Roy Orbison.  Here's one way in five degrees:

1. Aynsley Dunbar played in The Animals, with Andy Summers
2. Andy Summers played in The Police, with Sting
3. Sting played in Band Aid, with Paul McCartney
4. Paul McCartney played in The Quarrymen (and of course The Beatles), with George Harrison
5. George Harrison played in The Traveling Wilburys, with Roy Orbison

Today I'm going to point out some enhancements to this application, and the updated code, which are reflected in the following screenshot:

These enhancements include:

• The user can type in an artist name, and with each keystroke the Freebase database web service is invoked, returning suggested names from which the user can choose.
• Band and artist pictures are presented in a cover-flow style, using the JFXtras Shelf component.  In addition, the JFXtras TitledBorder component is employed to enclose and label the cover-flows.
• When the user clicks the central image in the bottom (e.g. Steve Smith in the screenshot above), that artist becomes the featured artist at the top of the page.  The group cover-flow images are updated to reflect the groups in which the artist has played, and the member cover-flow images contain the artists that have played in the currently selected group.

One of the cool feature of the JFXtras Shelf component is that the mouse wheel moves the images horizontally on the Shelf, enabling the user to navigate even more quickly than clicking on one of the images.  Before invoking this application from the Web Start link at the end of this article, take a look at the main script of the program (named BandmatesFX.fx) in the listing below:

/*
 * BandmatesMain.fx
 *
 * Uses Freebase and JFXtras with JavaFX to explore connections
 * between musical artists
 *
 * Developed by James L. Weaver to demonstrate using JavaFX and JFXtras
 */

package javafxpert;

import javafx.io.http.HttpRequest;
import javafx.animation.transition.*;
import javafx.geometry.HPos;
import javafx.scene.*;
import javafx.scene.control.Label;
import javafx.scene.control.ProgressIndicator;
import javafx.scene.control.ListView;
import javafx.scene.control.TextBox;
import javafx.scene.image.*;
import javafx.scene.input.*;
import javafx.scene.layout.*;
import javafx.scene.paint.*;
import javafx.scene.text.*;
import javafx.stage.Stage;

import org.jfxtras.data.pull.*;
import org.jfxtras.scene.border.TitledBorder;
import org.jfxtras.scene.control.Shelf;

/**
 * Height of the images that we'll be working with
 */
def IMAGE_HEIGHT:Integer = 140;

/**
 * Artist for which we're searching bandmates
 */
var artistToSearch:String = "/en/aynsley_dunbar";

/**
 * Name for which we're finding matches and ids
 */
var nameToFind:String = "Aynsley Dunbar";

var textBoxRef:TextBox;
var listViewRef:ListView;
var selectedNameIndex = bind listViewRef.selectedIndex on replace {
  def selectedId = freebaseSearchResult.result[selectedNameIndex].id;
  if (selectedId != "") {
    println("selectedId:{selectedId}");
    nameToFind = freebaseSearchResult.result[selectedNameIndex].name;
    obtainGroupsForArtist(selectedId);
  }
};

/**
 * Hover text that contains the name of the artist or group
 */
var nameHoverText:String;

/**
 * A reference to the HTTP request, for the purpose of monitoring progress
 */
var req:HttpRequest;

/**
 * The root class that will hold the object graph from the JSON results
 */
var freebaseResult:FreebaseResult;

/**
 * The root class that will hold the object graph from the JSON results
 */
var freebaseSearchResult:FreebaseSearchResult;

/**
 * The base URL for the freebase query
 */
def freebaseURL = "http://www.freebase.com/api/service/mqlread?";

/**
 * The base URL for a freebase search request
 */
def freebaseSearchURL = "http://www.freebase.com/api/service/search?";

/**
 * The base URL to get a freebase image
 */
def freebaseImageURL = "http://img.freebase.com/api/trans/image_thumb";

var artistsNode:Node;

/**
 * Fade in transition for artists
 */
def shelfFadeIn = FadeTransition {
  node: bind artistsNode
  duration: 1500ms
  fromValue: 0.2
  toValue: 1.0
}

/**
 * Indexe into groups list
 */
var groupOneIndex:Integer on replace {
  shelfFadeIn.playFromStart();

  // Choose the middle one
  def numArtists:Integer = sizeof freebaseResult.result.
                          musicGroupMemberMembership[groupOneIndex].
                          group.musicMusicalGroupMember;
  artistTwoIndex = if (numArtists > 1) numArtists / 2 else 0;
  
  groupOneName = freebaseResult.result.
                 musicGroupMemberMembership[groupOneIndex].group.name;
};

/**
 * Name of the currently selected band
 */
var groupOneName:String;

/**
 * Index into artists list
 */
var artistTwoIndex:Integer;

/**
 * Create a search query and invoke the JSON handler
 */
function obtainIdForArtistPartialName(artistPartialName:String) {
  listViewRef.visible = true;
  nameToFind = artistPartialName;
  def partialName = artistPartialName.replace(" ", "+");
  var searchUrl = "{freebaseSearchURL}prefix={partialName}&type=/music/artist&limit=10&mql_output=[\{\"id\":null,\"name\":null\}]";

  println("searchUrl:{searchUrl}");
  var albumHandler:JSONHandler = JSONHandler {
    rootClass: "javafxpert.FreebaseSearchResult"
    onDone: function(obj, isSequence): Void {
      freebaseSearchResult = obj as FreebaseSearchResult;
      println("# of search results:{sizeof freebaseSearchResult.result},freebaseSearchResult:{freebaseSearchResult.code}");
      req.stop();
    }
  };
  req = HttpRequest {
    location: searchUrl
    onInput: function(is: java.io.InputStream) {
      albumHandler.parse(is);
    }
  };
  req.start();
}

/**
 * Create the Freebase query and invoke the JSON handler
 */
function obtainGroupsForArtist(artistFreebaseId:String) {
  listViewRef.visible = false;
  artistToSearch = artistFreebaseId;
  var queryUrl = "{freebaseURL}query=\{\"query\":"
    " \{ "
    "   \"/common/topic/image\": [\{ "
    "     \"id\": null "
    "   \}], "
    "   \"/music/group_member/membership\": [\{ "
    "     \"group\": \{ "
    "       \"name\": null, "
    "       \"id\":   null, "
    "       \"/common/topic/image\": [\{ "
    "         \"id\": null "
    "       \}], "
    "       \"/music/musical_group/member\": [\{ "
    "         \"member\": \{ "
    "           \"name\": null, "
    "           \"id\":   null, "
    "           \"/common/topic/image\": [\{ "
    "             \"id\": null "
    "           \}] "
    "         \} "
    "       \}] "
    "     \} "
    "   \}], "
    "   \"id\":   \"{artistFreebaseId}\", "
    "   \"name\": null, "
    "   \"type\": \"/music/artist\" "
    " \} \}";

  println("queryUrl:{queryUrl}");
  var albumHandler:JSONHandler = JSONHandler {
    rootClass: "javafxpert.FreebaseResult"
    onDone: function(obj, isSequence): Void {
      freebaseResult = obj as FreebaseResult;
      println("# of bands:{sizeof freebaseResult.result.musicGroupMemberMembership}");
      req.stop();

      // Choose the middle one
      def numGroups:Integer = sizeof freebaseResult.result.musicGroupMemberMembership;
      groupOneIndex = if (numGroups > 1) numGroups / 2 else 0;
    }
  };
  req = HttpRequest {
    location: queryUrl
    onInput: function(is: java.io.InputStream) {
      albumHandler.parse(is);
    }
  };
  req.start();
}
var sceneRef:Scene;

Stage {
  title: bind "BandmatesFX - {nameToFind}"
  scene: sceneRef = Scene {
    width: 1000
    height: 700
    content: [
      ImageView {
        image: Image {
          url: "http://www.popsci.com/files/imagecache/article_image_large/files/articles/guitar.gif"
        }
        fitWidth: bind sceneRef.width
        preserveRatio: true
        opacity: 0.1
      },
      VBox {
        nodeHPos: HPos.CENTER
        layoutY: 10
        spacing: 10
        content: [
          HBox {
            spacing: 10
            content: [
              ImageView {
                image: bind Image {
                  url: "{freebaseImageURL}{artistToSearch}?maxheight={IMAGE_HEIGHT}"
                }
              },
              VBox {
                content: [
                  textBoxRef = TextBox {
                    promptText: "Enter artist name"
                    text: bind nameToFind with inverse
                    columns: 20
                    font: Font.font(null, 14)
                    action:function():Void {
                      if (nameToFind != "" and (req.percentDone == 0.0 or req.percentDone == 100.0)) {
                        obtainIdForArtistPartialName(nameToFind);
                      }
                    }
                    onKeyTyped:function(ke:KeyEvent) {
                      println("req.percentDone:{req.percentDone}");
                      if (textBoxRef.rawText != "" and (req.percentDone == 0.0 or req.percentDone == 100.0)) {
                        obtainIdForArtistPartialName(textBoxRef.rawText);
                      }
                    }
                  },
                  listViewRef = ListView {
                    visible: false
                    height: 100
                    items: bind for (rslt in freebaseSearchResult.result) {
                      rslt.name
                    }
                    layoutInfo: LayoutInfo {
                      width: bind textBoxRef.width - 10
                      height: 80
                    }
                  }
                ]
              },
              ProgressIndicator {
                progress: bind req.progress
              },
              Label {
                text: bind nameHoverText
                font: Font.font(null, FontWeight.BOLD, 18)
              }
            ]
          },
          TitledBorder {
            text: bind "{nameToFind} played in these groups:"
            font: Font.font(null, FontWeight.BOLD, 14)
            lineColor: Color.GREY
            node: Shelf {
              reflection: false
              showScrollBar: false
              showText: true
              imageUrls: bind for (grp in freebaseResult.result.musicGroupMemberMembership) {
                "{freebaseImageURL}{grp.group.id}?maxheight={IMAGE_HEIGHT}"
              }
              imageNames: bind for (grp in freebaseResult.result.musicGroupMemberMembership) {
                grp.group.name;
              }
              index: bind groupOneIndex with inverse
              thumbnailWidth: IMAGE_HEIGHT
              thumbnailHeight: IMAGE_HEIGHT
              layoutInfo: LayoutInfo {
                width: bind sceneRef.width
                height: IMAGE_HEIGHT + 120
              }
            }
          },
          artistsNode = Panel {
            content: bind for (grp in freebaseResult.result.musicGroupMemberMembership) {
              TitledBorder {
                text: bind "{groupOneName} has had the following members:"
                font: Font.font(null, FontWeight.BOLD, 14)
                lineColor: Color.GREY
                node: Shelf {
                  visible: bind indexof grp == groupOneIndex
                  reflection: false
                  showScrollBar: false
                  showText: true
                  imageUrls: bind for (mmbr in freebaseResult.result.
                                           musicGroupMemberMembership[indexof grp].
                                           group.musicMusicalGroupMember) {
                    "{freebaseImageURL}{mmbr.member.id}?maxheight={IMAGE_HEIGHT}"
                  }
                  imageNames: bind for (mmbr in freebaseResult.result.
                                           musicGroupMemberMembership[indexof grp].
                                           group.musicMusicalGroupMember) {
                    mmbr.member.name
                  }
                  onCenterImagePressed:function(me:MouseEvent):Void {
                    var mmbr = freebaseResult.result.
                               musicGroupMemberMembership[indexof grp].
                               group.musicMusicalGroupMember[artistTwoIndex];
                    nameToFind = mmbr.member.name;
                    artistToSearch = mmbr.member.id;
                    obtainGroupsForArtist(mmbr.member.id);
                  }
                  index: bind artistTwoIndex with inverse
                  thumbnailWidth: IMAGE_HEIGHT
                  thumbnailHeight: IMAGE_HEIGHT
                  layoutInfo: LayoutInfo {
                    width: bind sceneRef.width
                    height: IMAGE_HEIGHT + 120
                  }
                }
              }
            }
            layoutInfo: LayoutInfo {
              width: bind sceneRef.width
              height: IMAGE_HEIGHT + 120
            }
          }
        ]
      }
    ]
  }
}
obtainGroupsForArtist(artistToSearch);

To try out this application, click the Web Start link below.  Since this application is a work in progress, I'll give you a couple of pointers:

• When typing the name of an artist in the text box, each key invokes a web service, so wait until the progress indicator is solid before typing the final character (I'll make this smoother in a future iteration).
• Not all artists are in groups, and I'm not doing the necessary exception handling yet to catch this in the response from Freebase.  I know that many artists such as Eric Clapton, Bob Dylan, and Steve Winwood work, as well as any artist that you can click in the bottom cover flow (by definition they are members of a group).

For more background on this application, see the previous article in this series.  As always, please leave a comment if you have any questions.  Also, if you have any suggestions for future enhancements, please leave a comment as well.

Regards,

Jim Weaver

"Working Code Trumps All Theories" - A JavaFX Samples Mother Lode

Philip Dodds was a brilliant audio engineer, an e-learning pioneer, and operated the synthesizer in Close Encounters of the Third Kind (he's the one in the middle of the picture shown from the movie).  Philip used to say that "working code trumps all theories", which is very relevant to the the JavaFX examples repository library announcement that Stephen Chin made this morning.

This repository, which is located in the JFXtras Community Site, contains working code and Web Start links for a growing number of examples in JavaFX books and blogs.

You are cordially invited to take a look at the examples in the site, and contribute your own JavaFX examples!  To get you started, here's the link to the site that contains a Color Picker example from the Pro JavaFX book.

Regards,

Jim Weaver

Sten Anderson Wins the JavaFX Coding Challenge with a Rockin App!

Congratulations to the winners of the JavaFX Coding Challenge: Sten Anderson, Naoaki Suganuma, and Evgeni Sergeev!  The apps written by all three winners are oustanding, and 1st-place winner Sten Anderson's Music Explorer FX app is IMHO brilliant!  Here's a screenshot from the app:

Sten's JavaFX app enables the user to navigate among musical artists whose music has a degree of similarity by making use of Echo Nest web services.  The Music Explorer FX app has a graphically pleasing user interface that helps the user explore interesting details about musical artists and the connections between them.  The Help page even features one of my favorite groups: Liquid Tension Experiment :-)

Congrats again to Sten, Naoaki and Evgen!

Jim Weaver

Making Music (and Software) with My Friends in JavaFX

It's great to finally be able to give you some details about a cool JavaFX project in which I've had the privilege of participating.  For the last couple of months, some co-workers at Veriana and I have been helping Indaba Music create an internet-based, collaborative recording studio named Indaba Console 2.0.  The alpha release was this morning (July 9, 2009) and it is written entirely in JavaFX/Java.  Check out this screenshot, and a Wired article that contains a demonstration video by musician and co-founder Dan Zaccagnino.

If you were at JavaOne 2009 you may remember the JavaFX panel session on which Chris Danzig (Indaba co-founder) and I participated.

One of the main reasons that Indaba chose JavaFX/Java is that it enables recording high-quality audio directly onto the client platform.  This is achieved by leveraging the capability of JavaFX to call Java methods, and Java to call JavaFX functions.  One person with whom we work closely is Bjorn Roche, who created a Java-based facility and API that interacts with the audio capabilities of the client machine.  The JavaFX portion of the Console provides most of the UI, and uses the Java-based API when it needs to play a track, apply audio effects, render a sound-wave, or record music.  This Java library then invokes JavaFX callback functions as it is doing its work.

The UI consists of many custom components, some of which subclass CustomNode, and many which subclass Contol (when skinnable and/or highly interactive components are required).  Recording session, mix, and audio data are stored "in the cloud", as they say.  The application is written in JavaFX 1.1, but is being ported to JavaFX 1.2, where performance and memory usage are greatly optimized.

Congrats, and thanks to the Indaba folks!  Please give the music console a whirl and unleash your musical creativity!

Regards,

Jim Weaver

Asynchronicity in JavaFX 1.2

The asynchronous task model has been much improved in JavaFX 1.2.  Not only does it have a simple and elegant API, but several of the asynchronous tasks (e.g. HttpRequest) in the JavaFX API now use this model.  In addition, there are a couple of progress UI controls introduced in JavaFX 1.2, and they work well with the new asynchronous model.

The JavaFX package that contains the asynchronous-related classes is javafx.async, and a good class to take a look at first is JavaTaskBase.  This class enables you to start a task, check on its progress, and be notified when the task has completed.  JavaFX is single threaded, so the task that is started is one that you define in a Java class (that implements the javafx.async.RunnableFuture interface).  The Java class can then call functions of your JavaFX classes, demonstrating bi-directional integration between JavaFX and Java.

Take a look at the screenshot of a simple example on which Stephen Chin and I collaborated, that demonstrates the capabilities just described:

Clicking on the Start the Task button starts a new task and adds a ProgressBar into the scene (up to a maximum of eight, the built-in limit on the number of tasks in JavaFX that can be run in parallel).  When a task completes, its ProgressBar is removed from the scene.  Take a look at the AsyncProgressMain.fx script below to understand how the UI is drawn, and how the tasks are started:

package projavafx.asyncprogress.ui;

import projavafx.asyncprogress.model.*;

import javafx.scene.*;
import javafx.scene.control.*;
import javafx.scene.layout.*;
import javafx.stage.Stage;

var vbox:VBox;

function startTask() {
  def progressBar:ProgressIndicator = ProgressBar {
    progress: bind taskController.floatProgress
  }

  def taskController:TaskController = TaskController {
    maxProg: 100
    onStart:function():Void {
      insert progressBar into vbox.content;
    }
    onDone:function():Void {
      delete progressBar from vbox.content;
    }
  }
  taskController.start();
}

Stage {
  title: "Async and Progress Example"
  scene: Scene {
    width: 200
    height: 250
    content: vbox = VBox {
      layoutX: 10
      layoutY: 10
      spacing: 10
      content: [
        Button {
          text: "Start the task"
          action: function():Void {
            println("Starting TaskController");
            startTask();
          }
        }
      ]
    }
  }
}

Now take a look at the TaskController class that is instantiated in the script above when the button is clicked:

package projavafx.asyncprogress.model;

import projavafx.asyncprogress.model.Ticker;
import javafx.async.RunnableFuture;
import javafx.async.JavaTaskBase;

public class TaskController extends JavaTaskBase, TickerHandler {
  public var maxProg:Integer;
  public-read protected var floatProgress:Number;

  override public function create():RunnableFuture {
    maxProgress = maxProg;
    return new Ticker(this);
  }

  override public function onTick(tickNum:Integer):Void {
    progress = tickNum;
    floatProgress = percentDone / 100.0;
  }
}

Note that the TaskController class above extends the JavaTaskBase class mentioned earlier.  We'll use its capabilities to start and monitor the task.  When the create function of the TaskController instance is called by the JavaFX runtime (as a result of its start function being called) it creates a new instance of the Ticker class that we developed in Java.  As shown in the code below, the Ticker class implements the RunnableFuture interface mentioned earlier.

package projavafx.asyncprogress.model;

import com.sun.javafx.functions.Function0;
import javafx.lang.FX;
import javafx.async.RunnableFuture;

public class Ticker implements RunnableFuture {
  TickerHandler tickerHandler;

  public Ticker (TickerHandler tickerHandler) {
    this.tickerHandler = tickerHandler;
  }

  @Override public void run() {
    for (int i = 1; i <= 100; i++) {
      if (tickerHandler != null) {
        final int tick = i;
        FX.deferAction(new Function0<Void>() {
           @Override public Void invoke() {
             tickerHandler.onTick(tick);
             return null;
           }
        });
      }
      try {
        Thread.sleep(200);
      }
      catch (InterruptedException te) {}
    }
    System.out.println("Ticker#run is finished");
  }
}

The Ticker class shown above counts to 100, sleeping for a couple hundred milliseconds each iteration.  During each iteration it calls the onTick function of the TaskController class shown previously, which implements the TickerHandler interface.  Here's the code for that interface:

package projavafx.asyncprogress.model;

public interface TickerHandler {
  void onTick(int tickNum);
}

For an excellent explanation (including UML sequence diagrams) of asynchronous tasks in JavaFX, see Baechul's JavaFX 1.2 Async blog post.  Also take a look at the Richard Bair and Jasper Potts fxexperience.com post on the subject.

For those interested in JavaFX Mobile, here's a short video clip of this example running on an HTC Diamond phone.  You may want to mute the audio, as I didn't mute the microphone when creating this video. ;-)

As I mentioned in the dynamic Timeline values post, I'm trying to encourage you to compile and run the examples in this blog.  However, please leave a comment if you'd like a Java Web Start link. 

Regards,

Jim Weaver

Create a News Ticker with JavaFX 1.2 RssTask/AtomTask

JavaFX 1.2 has many new features, not the least of which is a stone-simple way of reading RSS and Atom feeds.  The new classes that contain much of this functionality are javafx.data.feed.rss.RssTask and javafx.data.feed.atom.AtomTask, respectively.

Take a look at this post by Rakesh Menon that shows you how to create news tickers with these classes.

Also, I'll give a free copy of the Pro JavaFX early access eBook (rewritten for 1.2) to the first person that leaves a comment with the name of the inventor of the Stock Ticker shown in the image above. :-)

Update: We have two winners of the Pro JavaFX early access eBook: Steve Sobczak, and Warren Strange (author of the Strange Brew blog).  Steve asserted that Edward A. Calahan invented the stock ticker, and Warren asserted that Thomas Edison did.  I'm giving a book to each of them, citing the following paragraph from The Stock Ticker Company web site:

"Edward A. Calahan invented the first stock ticker, which was introduced to the New York Stock Exchange in 1867. A young Thomas Edison improved on Calahan's design and made the stock ticker easier to use and maintain. It was Edison's first profitable innovation, and it introduced him to the powerful Wall Street businessmen who funded his subsequent inventions such as the phonograph, the light bulb, and motion pictures. It is the Universal Stock Ticker that we have reproduced."

Congratulations Steve and Warren!

Regards,

Jim Weaver

Skinning Architecture in JavaFX -- straight from the horse's mouth

No, I'm not calling Richard Bair a horse, but rather using an idiom that has its origins in horse racing.  From The Phrase Finder:

"In horse racing circles tips on which horse is a likely winner circulate amongst punters. The most trusted authorities are considered to be those in closest touch with the recent form of the horse, i.e. stable lads, trainers etc. The notional 'from the horse's mouth' is supposed to indicate one step better than even that inner circle, i.e. the horse itself."

In their latest fxexperience.com blog post, Richard (Jasper is on holiday) sheds a lot of light on the skinning architecture in JavaFX 1.2 and what is planned for the next release.

Regards,

Jim Weaver

Painting with JavaJeff (JavaFX Jeff?)

One of the great features of JavaFX is that it can instantiate and call methods of Java classes.  Java author "JavaJeff" Friesen has created a Painter/Canvas infrastructure using JavaFX and Java.  This infrastructure supports complex/fast painting possibilities such as fireworks, plasma, fractals, and even fire.

Check out Jeff's blog post that provides the code, an explanation, and a Web Start link for the "plasma" painting example shown in the screenshot above.

Regards,
Jim Weaver

Pro JavaFX Book SDK 1.2 Rewrite Complete

All Pro JavaFX early access eBook chapters have been updated to SDK 1.2.  They are being shipped to the printer, so the book composed of atoms vs. bits will be available soon.

In addition, we're releasing a 16-page Pro JavaFX 1.2 children's book, shown below (not really). :-)

The image shown above was created by Stephen Chin for the slides in his presentation with Josh Marinacci on WidgetFX at JavaOne.  The Nabaztag bunny is a robot used in the presentation, but neither rabbits nor robots were harmed in the making of this image or during the presentation :-)  By the way here are the slides for the presentation on JavaFX that Stephen and I gave at JavaOne.

If you're interested in what's between the covers of the book, here's a brief description of each chapter:

• Chapter 1, Getting a Jump Start in JavaFX, gives you a jump start in developing applications in the JavaFX language, brings you up to date on the brief history of JavaFX, and shows you how to get the JavaFX software development kit. It then walks you through the process of compiling and running JavaFX applications, and teaches you a lot about the JavaFX language and API while walking through example application code.

• Chapter 2, Taking a Closer Look at the JavaFX Script Language, covers the fundamentals of the JavaFX Script language, including  concepts such as variables, primitive types, literal values, and basic operations.  JavaFX sequences are introduced in this chapter, along with how to access their members and perform sequence comprehension.

• Chapter 3, Creating a User Interface in JavaFX, associates the metaphor of creating a theatre play with JavaFX development, and discusses creating a stage, a scene, nodes, a model, event handlers, and animating some of the nodes.  It then delves into each of these concepts using JavaFX examples, finishing up with a Pong-like game that demonstrates how to detect when nodes in the scene have collided.

• Chapter 4, Using Functions, Classes, and Other Advanced Features, discusses how to define functions and classes of your own. It then covers function signatures and function types, and how to write anonymous functions.  From there, this chapter introduces how to define class hierarchies, and the covers the details about class types. It also discusses what happens when an object is instantiated and how you can exert control over the process.

• Chapter 5, Creating Custom UI Components and Charts in JavaFX, explains how to define custom UI components of two fundamentally different types -- custom nodes, and UI controls.  After showing you how to create custom nodes in the context of creating a couple of color selection components, it covers how to create UI controls in the context of a stoplight control that has multiple skins.  The chapter finishes by teaching you how to use the charting controls to simply and easily create charts in JavaFX.

• Chapter 6, Using the Media Classes, explores the capabilities of the JavaFX media classes that make it easy for developers to incorporate playback support for most of the popular formats.   This chapter demostrates how simple it is to include basic media playback support in your JavaFX applications and then show you how to build more sophisticated playback applications.

• Chapter 7, Dynamically Laying Out Nodes in the User Interface, shows how you can leverage the dynamic layouts mechanisms of JavaFX to build complicated user interfaces with zero static positioning.  These mechanisms include the bind statement, powerful custom layouts built on top of the Panel and Container classes, and the built-in layouts including HBox, VBox, Flow, Tile, and Stack.

• Chapter 8, Extending JavaFX with Third-Party Libraries, introduces several of the JavaFX third-party extensions that simplify the development of applications.   All of the third-party extensions introduced in this chapter are available as free or open source libraries. This ensures that anyone can make use of these libraries, and also guarantees that you will not be locked into a specific vendor.

• Chapter 9, Building a Professional JavaFX Application, shows you some of the professional techniques we use to write real-world JavaFX applications. You will need them when working with a graphic designer, and you will find them useful when you are confronted with the memory usage and performance trade-offs that developers need to consider for real applications. This chapter also provides tips and techniques for enhancing the user’s experience.

• Chapter 10, Developing JavaFX Mobile Applications, teaches you the basics of JavaFX Mobile development, which will enable you to write portable applications that work on both desktop and mobile devices.  During this chapter you’ll gain an understanding of the Common Profile, learn how to take advantage of the Java ME capabilities beneath JavaFX Mobile, and adopt JavaFX Mobile best practices that will enable you to write high-performance applications.

• The Appendix presents the keywords and the operators of JavaFX Script.  Precedence and associativity rules are supplied for the operators.

Regards, and enjoy the book!

Jim Weaver

JavaFX Authoring Tool Demo at JavaOne

At JavaOne 2009 during James Gosling's Toy Show, Tor Norbye demonstrated the current state of the long-awaited JavaFX Authoring Tool. 

Some of the demonstrated features were:

• The ability to position/orient a node (e.g. an image) in multiple places on the stage, each corresponding with a point in time on a timeline (represented by a slider).  Each point in time becomes a KeyFrame, and interpolations are calculated based upon position/orientation.  Dragging the slider results in seeing the node move and rotate through the positions in which the node was placed.  I assume that scaling and other transforms will be supported in the tool as well.  Tor mentioned that various interpolations are supported (LINEAR, EASEIN, EASEOUT, and EASEBOTH).  I assume that spline interpolation will be supported as well.
• Placing UI controls on the stage, hooking them up with event handlers, as well as binding to instance variable values (e.g. in other UI controls).
• Targeting an application at multiple screens (e.g. desktop, mobile phones), with the ability to customize for each screen.

Augusto Sellhorn (AKA sellmic) has compiled some video clips and his thoughts about the JavaFX Authoring Tool in a blog post.  If you didn't see the Toy Show, checking out Augusto's post is a quick way of seeing the preview of the tool.

Update June 13, 2009: Augusto created another blog post with new screenshots, links and thoughts on the JavaFX Authoring Tool.

Regards,

Jim Weaver