Table of Contents for the Pro JavaFX Platform early access eBook

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

Comments

[kris]

Hello,

Please add your site at http://www.sweebs.com. Sweebs.com is a place where other people can find you among the best sites on the internet!
Its just started and we are collecting the best found on the net! We will be delighted to have you in the sweebs listings.

Regards
Kris

[Rahul Mahajan]

Browning Books application looks most interesting, close to real world application.

Any plan or thoughts on JAVAFx Web component library or any comments on integration with JSF 2 components?

Real world web applications with Rich interface should be P1 priority for Java Fx to fulfill with a mature web framework backing and easy scripting language like JSF 2 PDL(Facelets).

Can't we have something like rich web components created in Java FX like (Advanced Grid, Animated Combos, Animated.Interactive JAVAFx charts etc..) used in JSF 2 with some level of javascript communication(JSON or something) or some kind of integration. This can be a light weight rich interface web framework, deadly killer for others.

Is somebody thinking on these lines or my comments are crap..