James Weaver’s JavaFX Blog: JavaFX Production Suite

Several people have asked for a table of contents for the Pro JavaFX Platform early access eBook (by Weaver, Gao, Chin, and Iverson) to give them a better idea of what's inside. Because the table of contents isn't on the Apress site yet, I'm posting it here. Apress and Amazon aren't likely to post the fully expanded table of contents anyway.

I've sprinkled in a few screenshots to give you a flavor for some of the example programs:

CHAPTER 1: Getting a Jump Start in JavaFX

JavaFX Can’t Bring Rich-Client Java Back by Itself
A Brief History of JavaFX
Going to the Source – Sun’s JavaFX Websites
- Accessing the JavaFX SDK API and Language Documentation
- Obtaining the JavaFX SDK
- JavaFX Production Suite
- Other Available Tools
Developing Your First JavaFX Program: "Hello Earthrise"
- Compiling and Running from the Command-Line
- Understanding the Hello Earthrise Program
  - Comments
  - The package Declaration
  - import Statements
  - Declarative Code That Defines the User Interface
  - Using the Stage Class
  - Creating String Literals
  - Using the Scene Class
  - Displaying Images
  - Working with Graphical Nodes as a Group
  - Drawing Text
  - Clipping Graphical Areas
  - Animating the Text to Make it Scroll Up
- Building and Running the Program with NetBeans
Deploying JavaFX Applications
- Deploying JavaFX Applications with Java Web Start
- Deploying JavaFX Applets
Developing Your Second JavaFX Program: "More Cowbell!"
- Building and Running the Audio Configuration Program
- The Behavior of the Audio Configuration Program
- Understanding the Audio Configuration Program
  - Creating an Instance of the Model, and the Magic of Binding
  - Colors and Gradients
  - The Model Class for the Audio Configuration Example
  - Structure of a Minimal JavaFX class
  - Defining Triggers in the Model Class
Surveying JavaFX Features
Summary
Resources

CHAPTER 2: Taking a Closer Look at the JavaFX Script Language

An Overview of JavaFX Script
Understanding Variables, Values, and Their Types
- Understanding Variable Names
- Understanding Variable Types
Understanding the Primitive Types
- Understanding the Boolean Type
  - Boolean Literals and Default Value
  - Boolean Operators
  - The Backing Class of Boolean Type
- Understanding the Integer Type
  - Integer Literals and Default Value
  - Arithmetic Operators
  - The Backing Class of Integer Type
- Understanding the Number Type
  - Number Literals and Default Value
  - Arithmetic Operations
  - The Backing Class of Number Type
- Understanding the String Type
  - String Literals and Default Value
  - String Expressions
  - The Backing Class of String Type
- Understanding the Duration Type
  - Duration Literals and Default Value
  - Arithmetic Operations Involving Durations
  - The Backing Class of Duration Type
Working with Sequences
- Understanding Sequence Types
- Constructing Sequences Using Explicit Sequence Expressions
- Constructing Numeric Sequences Using Range Expressions
- Manipulating Sequences
  - Accessing the Size of a Sequence
  - Accessing an Element in a Sequence
  - Accessing a Slice of a Sequence
  - Accessing a Subset of a Sequence through a Predicate
  - Reversing a Sequence
  - Inserting an Element into a Sequence
  - Inserting another Sequence into a Sequence
  - Deleting Elements from a Sequence
  - A Sequence Manipulation Example
- Understanding Sequence Comprehension
- Using Utility Functions in javafx.util.Sequences
JavaFX Script is an Expression Language
- Understanding Expressions and their Types
- Understanding the Block Expression
- Understanding Precedence and Groupings
- Understanding the Expression Separator
- Understanding Variable and Constant Declarations
- Understanding the Assignment Operator
- Understanding the Compound Assignment Operators
- Understanding the Relational Operators
- Understanding the while Expression
- Revisiting the for Expression
- Understanding the if Expression
Understanding Object Literals
- Understanding Classes and Objects
- The Object Literal Expression
  - Initializing Instance variables
  - Declaring Constants and Variables
  - Overriding Instance functions and Instance variables
- Manipulating Objects
  - Manipulating Object States
  - Invoking Instance functions
- Creating Java Objects with the new Operator
- The Making of a Declarative Syntax
Working With Data Bindings
- Understanding the bind Expression
  - What Does the Data Binding Remember?
  - Binding to if Expressions
  - Binding to for Expressions
  - Binding to a Block
  - Binding to Function Invocation Expressions
  - Binding to Object Literal Expressions
- Understanding Bidirectional Bindings
Summary

CHAPTER 3: Creating a User Interface in JavaFX

Introduction to Node-Centric UIs
Setting the Stage
- Understanding the Stage Class
  - Consulting the API Docs for the Stage Class
- Using the Stage Class: The StageCoach Example
- Understanding the StageCoach Program
  - Obtaining Program Arguments
  - Setting the Style of the Stage
  - Controlling Whether a Stage is Resizable
  - Making a Stage Full Screen
  - Working with the Bounds of the Stage
  - Drawing Rounded Rectangles
  - Dragging the Stage on the Desktop when a Title Bar isn’t Available
  - Using UI Layout Containers
  - Ascertaining Whether the Stage is in Focus
  - Controlling Z-Order of the Stage
  - Closing the Stage and Detecting when it is Closed
  - Exiting the application
Making a Scene
- Using the Scene Class: The OnTheScene Example
- Understanding the OnTheScene Program
  - Setting the Cursor for the Scene
  - Painting the Scene's Background
  - Populating the Scene with Nodes
  - Finding a Scene Node by ID
  - Accessing the Stage from the Scene
  - Inserting a Node into the Scene's content Sequence
  - CSS Styling the Nodes in a Scene
  - Understanding the JavaFX Node Class Hierarchy
Handling Input Events
- Surveying Mouse and Keyboard Events and Handlers
  - Understanding the KeyEvent Class
  - Understanding the MouseEvent Class
- Using Mouse and Key Events: The MobileEqualizer Example
- Understanding the MobileEqualizer Program
  - Understanding the Model used in this Program
  - Using the onMousePressed Event Handler
  - Using the onMouseDragged Event Handler
  - Giving Keyboard Input Focus to a Node
  - Using the onKeyPressed Event Handler
Animating Nodes in the Scene
- Using a Timeline for Animation
  - The Metronome1 Example
  - Understanding the Metronome1 Program
    - Understanding the Timeline Class
    - Inserting Key-Frames into the Timeline
    - Controlling and Monitoring the Timeline
    - Shorthand Syntax for Key-Frames
- Using the Transition Classes for Animation
  - The MetronomeTransition Example
  - The Behavior of the MetronomeTransition Program
  - Understanding the MetronomeTransition Program
    - Using the TranslateTransition Class
    - Controlling and Monitoring the Transition
    - The MetronomePathTransition Example
  - The Behavior of the MetronomePathTransition Program
  - Understanding the MetronomePathTransition Program
    - Using the PathTransition Class
    - Drawing an Ellipse
- The Zen of Node Collision Detection
  - Understanding the ZenPong Program
    - Using the KeyFrame action Event Handler
    - Using the Node intersects() Function to Detect Collisions
    - Dragging a Node
- Summary
- Resources

CHAPTER 4: Using Functions, Classes and Other Advanced Features

Working with Functions
- Understanding Function Definitions
  - Understanding Return Types
  - Understanding Parameters and their Types
  - Understanding Function Bodies and the return Expression
  - What Can a Function Body See?
- Understanding Overloaded Functions
  - Understanding Implicit Type Conversions
  - Rules for Overloaded Function Resolution
- Understanding Function Types and Anonymous Functions
  - More Details on Function Type Specifiers
  - More Details on Anonymous Function Expressions
  - More Details on Closures
- Understanding Bound Functions
- Understanding Exceptions
  - Understanding the Call Stack
  - Throwing Exceptions
  - Handling Exceptions
Working with Classes
- Understanding Class Definitions
  - Understanding Instance Variables
  - Understanding Instance Functions
  - Understanding the this Expression
  - Understanding Initialization Blocks
- Creating Class Hierarchies
  - Extending Classes
  - Overriding Instance Variables
  - Overriding Instance Functions
  - Understanding the super Keyword
  - Understanding Abstract Classes
  - Understanding Casting and the instanceof and as Operators
Organizing JavaFX Script Code
- What is a Script?
- Understanding Modules
- A Special Provision for Classes
- Understanding Packages
- Understanding Import Directives
- Understanding Access Modifiers
  - Understanding the protected Modifier
  - Understanding the public-init and public-read Modifiers
Understanding Triggers
- Accessing the Old and New Values in Trigger Blocks
- Accessing Sequence Modification Information in Trigger Blocks
- Debugging With Triggers
Understanding String Formatting and Internationalization
- Using String Format Specifications
- Internationalizing JavaFX Script Programs
Leveraging Java from JavaFX Script
- Instantiating Java Classes
- Accessing Java Object Fields
- Calling Java Methods
- Accessing Static Fields and Methods
- Quoting JavaFX Script Keywords
- Accessing Nested Classes
- Accessing Java Enums
- Extending Java Classes and Interfaces
- Iterating Through Java Collections
Understanding JavaFX Script Reflection
- Understanding Mirror-Based Reflection
- Entering the Reflection World
- Programming through Reflection
  - Creating a New Instance of a Class
  - Getting and Setting Values of Instance and Script variables
  - Invoking Instance and Script Functions
  - Other Reflection Capabilities
Summary

CHAPTER 5: Creating Custom UI Components in JavaFX

Creating Custom UI Components
- Creating a Custom Node
  - The ColorPickerNode Example
  - Understanding the ColorPickerNode Custom Node
    - Overriding the CustomNode create() Function
    - Using the Node hover Variable
  - The ColorPickerSnowFlakeNode Example
  - Understanding ColorPickerSnowFlakeNode
    - Making a Node Act like a Dialog
    - Defining and Invoking an Event Handler
    - Overriding Instance Variables
    - The DropShadow Effect
    - Obtaining the width and height of a Node
    - Creating a Polygon Shape
    - Using the stroke and strokeWidth Variables
    - Using the transforms Variable to Transform Nodes
    - Blocking Mouse Events from Underlying Nodes
- Creating Skinnable UI Controls
  - The StoplightSkinning Example
  - Understanding the StoplightSkinning Program
    - Creating the Control's Model
    - Using the hover, pressed, focused and Variables in the Model
    - Associating a Skin with the Model
    - Creating a Skin for the Control
    - Binding the Skin to the Model
    - Using the hover, pressed, focused and Variables in the Skin
    - The Code for the Horizontal Stoplight Skin
    - Associating a Skin with the Model using a Stylesheet
  - Deciding Between Creating a Custom Node and a UI Control
Summary
Exercise: Putting Chapters 1 – 5 Concepts in Practice
Resources

CHAPTER 6: Using the Media Classes

The Foundation
Working With Media
Playing Audio
- Controlling Playback
- Repetition
- Volume and Balance
- Streaming Media
Playing Video
- Controlling the Size of a MediaView
- Transforming a MediaView
- Compositing And Effects
- One Player, Multiple Views
- Playing Movies with SimpleMediaPlayer
Summary

CHAPTER 7: Dynamically Laying Out Nodes in the User Interface

Introducing JavaFX Reversi
- Board Layout and Basic Rules
- Building a JavaFX Model for Reversi
Dynamic Layout Basics
- Bind For Layouts
- Centering Nodes and Text
- Aligning to Edges
- Aligning Nodes to Each Other
- Using HBox and VBox
- When to Use Bind Versus Boxes
Creating Resizable Nodes
- Building a Reversi Square
- Building a Reversi Piece
Creating a Grid Layout Container
- Understanding the Geometry API
- Extending the Container Class
- The Grid Layout Algorithm
- Binding the Layout to the Model
A New Perspective on Reversi
- The Perspective Layout Algorithm
- Creating the Perspective Layout Class
- Integrating the Perspective Layout
Bringing Reversi to Life
- Highlighting Legal Moves
- Perspective Mouse Interaction
- Highlighting the Active Cell
- Taking Turns
- Additional Game Enhancements
Summary
Resources

Chapter 8: Extending JavaFX with Third-Party Libraries

Creating Desktop Widgets with WidgetFX
- Creating a Movie Widget
- Widget Configuration
- Deploying Widgets to the Web
- Third-Party Widgets
  - Disk Space Widget
  - World Clock Widget
  - World Smiley Widget
- The Future of WidgetFX
Building a Media Explorer with JFXtras
- Laying out a Resizable Directory Navigator
- Building a User Interface with Constraints
- Displaying Media in a Dynamic Grid
- Wrapping Media with Borders in a Deck
- Creating an Asynchronous Search Form with MigLayout
  - Laying out the Search Form with MigLayout
  - Adding Asynchronous Search with the JFXWorker
  - Refining the Search With Filters
The Rest of JFXtras
- JFXtras Test
  - Nesting Test Cases
  - Fluent Expectations
  - Parameterized Testing
    - Using Assume to Calculator Output
  - Unit Testing the Media Search with Custom Expectations
- Extended Shapes
- The Future of JFXtras
Other Libraries
- Atomic Tile - 2D Tile-based Game Authoring
- FXUtil - Inverse Kinetics Library
- FEST-JavaFX - Automated UI Testing of JavaFX
Predicting what will be in future versions of JavaFX
Summary
References

CHAPTER 9: Building a Professional JavaFX Application

Writing RESTful Web Service Clients
- Rise of the RESTful Web
- Using The HttpRequest Class
- Writing JSON Clients
  - Parsing JSON in JavaFX
  - Who is My Representative?
- Writing XML Clients
  - Parsing XML in JavaFX
  - Who is My Representative in XML
Developing a Rich Internet Application
- Making Use of Assets with the Production Suite
- Using the Amazon Web Service API
- User Interface Considerations
  - Inside the NodeFactory
- The Home Page
  - A Java-Based Image Cache
  - Getting the Top Sellers from Amazon
- The Search Page
  - Adding Item Search to the Application Model
- The Cart Page
Summary
Resources

Chapter 10: Developing JavaFX Mobile Applications

The Vision of JavaFX Mobile
Mobile Hello Earthrise
- Running in the Mobile Emulator
- Fitting Applications on the Mobile Screen
Developing for the Common Profile
Mobile DrawJFX
- Creating a Mobile Color Picker
- Refactoring DrawJavaFX for Mobile Devices
Advanced Mobile Features
- Performance Tuning JavaFX Mobile Applications
Summary
References

We end where we began, with the Hello Earthrise program, this time running in JavaFX Mobile.

Regards,
Jim Weaver

Yakov Fain, a fellow Java Champion and Managing Director of Farata Systems, has wondered publicly what many other developers and IT decision-makers are privately wondering: If I may paraphrase, the question is: "Can JavaFX be used for development of applications that real-world software developers can relate to?" To quote Yakov's article referenced above, "Enough of the demos of bubbles moving up and down in a glass with water. Can’t recall any application in my rather long career that would require to program something like this." In this article, Yakov indicated that he has started looking into JavaFX and plans to publish a couple of articles (in Java Developer's Journal) going through development of an application that real-world software developers can relate to.

Yakov gave similar feedback to a blog post that I wrote to demonstrate JavaFX data binding, in which I used a slider to control the diameter of a circle. I was very grateful for this feedback, which helped focus my attention on perhaps the most important criterion for widespread adoption of JavaFX: its ability to be used for developing rich user interfaces for real enterprise systems.

As a result, I recently began creating a "proof of concept" application to prove this capability. This application will have a rich-client user interface that communicates with Amazon web services. Many of you know that I don't have the graphics gene, so I asked someone that does (Casper Hamlet) to create some graphic comps in Adobe Photoshop. I then used the JavaFX Production Suite to export the layers directly into a NetBeans project, where Dean Iverson and I began developing that application. Yesterday at the Jfocus Java Conference in Stockholm I demonstrated the JavaFX Production Suite and the humble beginnings of this proof of concept. The screenshot above shows its capability so far, which is to cause brief info about JavaFX books to be transformed in various ways as they revolve in and out of view (when the right and left icons are clicked). Also, when the Details button is clicked, more information about a book is displayed in the details area, which includes a scrollable area. Currently, the book data is represented only in the model classes, but we plan to communicate with the Amazon web services shortly. You can try the existing functionality out by clicking on the Web Start link below.

Shown below is the original graphic comp for this screen. I obviously have some more work to do on this page to make it match the comp, particularly in the scrolling table:

Here is as a screnshot taken of NetBeans rendering the FXZ file that was exported from Photoshop after tagging the layers that I wanted and deleting the rest:

Please join me in watching for Yakov Fain's JavaFX articles in JDJ. It has been encouraging to see interest increase in JavaFX among those that I hold in high regard in the Java community.

As always, please leave a comment if you have any questions,
Jim Weaver
JavaFXpert.com