Learn JavaFX 17 - Building User Experience and Interfaces with Java

Table of Contents
About the Authors
About the Technical Reviewer
Acknowledgments
Introduction
Chapter 1: Getting Started
What Is JavaFX?
History of JavaFX
System Requirements
JavaFX Runtime Library
JavaFX Source Code
Your First JavaFX Application
Starting an Eclipse Project
Setting Up a Module Info
Creating the HelloJavaFX Class
Overriding the start() Method
Showing the Stage
Launching the Application
Adding a Scene to the Stage
Improving the HelloFX Application
Passing Parameters to a JavaFX Application
Case 1
Case 2
Launching a JavaFX Application
The Life Cycle of a JavaFX Application
Terminating a JavaFX Application
Summary
Chapter 2: Properties and Bindings
What Is a Property?
What Is a Binding?
Understanding Binding Support in JavaBeans
Understanding Properties in JavaFX
Using Properties in JavaFX Beans
Understanding the Property Class Hierarchy
Handling Property Invalidation Events
Handling Property Change Events
Handling Invalidation and Change Events
Using Bindings in JavaFX
Unidirectional and Bidirectional Bindings
Understanding the Binding API
The High-Level Binding API
Using the Fluent API
The Binding Interface
The NumberBinding Interface
The ObservableNumberValue Interface
The ObservableIntegerValue Interface
The NumberExpression Interface
The StringBinding Class
The ObjectExpression and ObjectBinding Classes
The BooleanExpression and BooleanBinding Classes
Using Ternary Operation in Expressions
Using the Bindings Utility Class
Combining the Fluent API and the Bindings Class
Using the Low-Level Binding API
Using Bindings to Center a Circle
Summary
Chapter 3: Observable Collections
What Are Observable Collections?
Understanding ObservableList
Creating an ObservableList
Observing an ObservableList for Invalidations
Observing an ObservableList for Changes
Understanding the ListChangeListener.Change Class
Observing an ObservableList for Updates
A Complete Example of Observing an ObservableList for Changes
Understanding ObservableSet
Creating an ObservableSet
Understanding ObservableMap
Creating an ObservableMap
Properties and Bindings for JavaFX Collections
Understanding ObservableList Property and Binding
Observing a ListProperty for Changes
Binding the size and empty Properties of a ListProperty
Binding to List Properties and Content
Binding to Elements of a List
Understanding ObservableSet Property and Binding
Understanding ObservableMap Property and Binding
Summary
Chapter 4: Managing Stages
Knowing the Details of Your Screens
What Is a Stage?
Showing the Primary Stage
Setting the Bounds of a Stage
Initializing the Style of a Stage
Moving an Undecorated Stage
Initializing Modality of a Stage
Setting the Opacity of a Stage
Resizing a Stage
Showing a Stage in Full-Screen Mode
Showing a Stage and Waiting for It to Close
Summary
Chapter 5: Making Scenes
What Is a Scene?
Graphics Rendering Modes
Setting the Cursor for a Scene
The Focus Owner in a Scene
Understanding the Platform Class
Knowing the Host Environment
Summary
Chapter 6: Understanding Nodes
What Is a Node?
The Cartesian Coordinate System
Cartesian Coordinate System of a Node
The Concept of Bounds and Bounding Box
Knowing the Bounds of a Node
The layoutBounds Property
The boundsInLocal Property
The boundsInParent Property
Bounds of a Group
A Detailed Example on Bounds
Positioning a Node Using layoutX and layoutY
Setting the Size of a Node
Resizable Nodes
Nonresizable Nodes
Storing User Data in a Node
What Is a Managed Node?
Transforming Bounds Between Coordinate Spaces
Summary
Chapter 7: Playing with Colors
Understanding Colors
Using the Color Class
Using the ImagePattern Class
Understanding Linear Color Gradient
Using the LinearGradient Class
Defining Linear Color Gradients Using a String Format
Understanding Radial Color Gradient
Using the RadialGradient Class
Defining Radial Color Gradients in String Format
Summary
Chapter 8: Styling Nodes
What Is a Cascading Style Sheet?
What Are Styles, Skins, and Themes?
A Quick Example
Naming Conventions in JavaFX CSS
Adding Style Sheets
Default Style Sheet
Adding Inline Styles
Priorities of Styles for a Node
Inheriting CSS Properties
Types of CSS Properties
The inherit Type
The boolean Type
The string Type
The number and integer Types
The size Type
The length and percentage Types
The angle Type
The duration Type
The point Type
The color-stop Type
The URI Type
The effect Type
The font Type
The paint and color Types
Specifying Background Colors
Specifying Borders
Border Colors
Border Widths
Border Radii
Border Insets
Border Styles
Understanding Style Selectors
Using Class Selectors
Class Selector for the root Node
Using ID Selectors
Combining ID and Class Selectors
The Universal Selector
Grouping Multiple Selectors
Descendant Selectors
Child Selectors
State-Based Selectors
Using JavaFX Class Names As Selectors
Looking Up Nodes in a Scene Graph
Summary
Chapter 9: Event Handling
What Is an Event?
Event Class Hierarchy
Event Targets
Event Types
Event Processing Mechanism
Event Target Selection
Event Route Construction
Event Route Traversal
Event Capture Phase
Event Bubbling Phase
Handling Events
Creating Event Filters and Handlers
Registering Event Filters and Handlers
Using addXXX( ) and removeXXX( ) Methods
Using onXXX Convenience Properties
Execution Order of Event Filters and Handlers
Consuming Events
Handling Input Events
Handling Mouse Events
Getting Mouse Location
Representing Mouse Buttons
State of Mouse Buttons
Hysteresis in GUI Applications
State of Modifier Keys
Picking Mouse Events on Bounds
Mouse Transparency
Synthesized Mouse Events
Handling Mouse-Entered and Mouse-Exited Events
Handling Key Events
Handling Key-Pressed and Key-Released Events
Handling the Key-Typed Event
Handling Window Events
Summary
Chapter 10: Understanding Layout Panes
What Is a Layout Pane?
Layout Pane Classes
Adding Children to a Layout Pane
Utility Classes and Enums
The Insets Class
The HPos Enum
The VPos Enum
The Pos Enum
The HorizontalDirection Enum
The VerticalDirection Enum
The Orientation Enum
The Side Enum
The Priority Enum
Understanding Group
Creating a Group Object
Rendering Nodes in a Group
Positioning Nodes in a Group
Applying Effects and Transformations to a Group
Styling a Group with CSS
Understanding Region
Setting Backgrounds
Setting Padding
Setting Borders
Setting Margins
Understanding Panes
Understanding HBox
Creating HBox Objects
HBox Properties
The Alignment Property
The fillHeight Property
The Spacing Property
Setting Constraints for Children in HBox
Letting Children Grow Horizontally
Setting Margins for Children
Understanding VBox
Creating VBox Objects
VBox Properties
The Alignment Property
The fillWidth Property
The Spacing Property
Setting Constraints for Children in VBox
Letting Children Grow Vertically
Setting Margin for Children
Understanding FlowPane
Creating FlowPane Objects
FlowPane Properties
The Alignment Property
The rowValignment and columnHalignment Properties
The hgap and vgap Properties
The Orientation Property
The prefWrapLength Property
Content Bias of a FlowPane
Understanding BorderPane
Creating BorderPane Objects
BorderPane Properties
Setting Constraints for Children in BorderPane
Understanding StackPane
Creating StackPane Objects
StackPane Properties
Setting Constraints for Children
Understanding TilePane
Creating TilePane Objects
TilePane Properties
The Alignment Property
The tileAlignment Property
The hgap and vgap Properties
The Orientation Property
The prefRows and prefColumns Properties
The prefTileWidth and prefTileHeight Properties
The tileWidth and tileHeight Properties
Setting Constraints for Children in TilePane
Understanding GridPane
Creating GridPane Objects
Making Grid Lines Visible
Adding Children to GridPane
Setting Positions of Children
Using Convenience Methods to Add Children
Specifying Row and Column Spans
Creating Forms Using GridPanes
GridPane Properties
The Alignment Property
The gridLinesVisible Property
The hgap and vgap Properties
Customizing Columns and Rows
Setting Constraints on Children in GridPane
The halignment and valignment Constraints
The hgrow and vgrow Constraints
The Margin Constraints
Clearing All Constraints
Understanding AnchorPane
Creating AnchorPane Objects
Setting Constraints for Children in AnchorPane
Understanding TextFlow
Creating TextFlow Objects
TextFlow Properties
Setting Constraints for Children in TextFlow
Snapping to Pixel
Summary
Chapter 11: Model-View-Controller Pattern
What Is the Model-View-Controller Pattern?
A Model-View-Presenter Example
The Requirements
The Design
The Implementation
The Model
The View
The Presenter
Putting Them Together
Summary
Chapter 12: Understanding Controls
What Is a Control?
Understanding the Control Class Hierarchy
Labeled Controls
Positioning Graphic and Text
Understanding Mnemonics and Accelerators
Understanding the Label Control
Understanding Buttons
Understanding Command Buttons
Understanding the Button Control
Understanding the Hyperlink Control
Understanding the MenuButton Control
Understanding Choice Buttons
Understanding the ToggleButton Control
Understanding the RadioButton Control
Understanding the CheckBox Control
Understanding the Hybrid Button Control
Making Selections from a List of Items
Understanding the ChoiceBox Control
Using Domain Objects in ChoiceBox
Allowing Nulls in ChoiceBox
Using Separators in ChoiceBox
Styling a ChoiceBox with CSS
Understanding the ComboBox Control
Detecting Value Change in ComboBox
Using Domain Objects in Editable ComboBox
Customizing the Height of a Pop-Up List
Using Nodes As Items in ComboBox
Using a Cell Factory in ComboBox
Styling ComboBox with CSS
Understanding the ListView Control
Orientation of a ListView
Selection Model in ListView
Using Cell Factory in ListView
Using Editable ListView
Using a TextField to Edit ListView Items
Using a ChoiceBox/ComboBox to Edit ListView Items
Using a Check Box to Edit ListView Items
Handling Events While Editing a ListView
Styling ListView with CSS
Understanding the ColorPicker Control
Using the ColorPicker Control
Styling ColorPicker with CSS
Understanding the DatePicker Control
Using the DatePicker Control
Styling DatePicker with CSS
Understanding Text Input Controls
Positioning and Moving Caret
Making Text Selection
Modifying the Content
Cutting, Copying, and Pasting Text
An Example
Styling TextInputControl with CSS
Understanding the TextField Control
Styling TextField with CSS
Understanding the PasswordField Control
Understanding the TextArea Control
Styling TextArea with CSS
Showing the Progress of a Task
Styling ProgressIndicator with CSS
Styling ProgressIndicator and ProgressBar with CSS
Understanding the TitledPane Control
Styling TitledPane with CSS
Understanding the Accordion Control
Styling Accordion with CSS
Understanding the Pagination Control
Styling Pagination with CSS
Understanding the Tool Tip Control
Styling Tooltip with CSS
Providing Scrolling Features in Controls
Understanding the ScrollBar Control
Understanding the ScrollPane Control
Keeping Things Separate
Understanding the Separator Control
Styling Separator with CSS
Understanding the SplitPane Control
Styling SplitPane with CSS
Understanding the Slider Control
Styling Slider with CSS
Understanding Menus
Using Menu Bars
Using Menus
Using Menu Items
Using a MenuItem
Using a RadioMenuItem
Using a CheckMenuItem
Using a Submenu Item
Using a CustomMenuItem
Using a SeparatorMenuItem
Putting All Parts of Menus Together
Styling Menus Using CSS
Understanding the ContextMenu Control
Styling ContextMenu with CSS
Understanding the ToolBar Control
Styling a Toolbar with CSS
Understanding TabPane and Tab
Creating Tabs
Setting the Title and Content of Tabs
Creating TabPanes
Adding Tabs to a TabPane
Putting TabPanes and Tabs Together
Understanding Tab Selection
Closing Tabs in a TabPane
Positioning Tabs in a TabPane
Sizing Tabs in a TabPane
Using Recessed and Floating TabPanes
Styling Tab and TabPane with CSS
Understanding the HTMLEditor Control
Creating an HTMLEditor
Using an HTMLEditor
Styling HTMLEditor with CSS
Choosing Files and Directories
The FileChooser Dialog
Creating a File Dialog
Setting Initial Properties of the Dialog
Showing the Dialog
Using a File Dialog
The DirectoryChooser Dialog
Summary
Chapter 13: Understanding TableView
What Is a TableView?
Creating a TableView
Adding Columns to a TableView
Customizing TableView Placeholder
Populating a TableColumn with Data
Using a Map As Items in a TableView
Showing and Hiding Columns
Reordering Columns in a TableView
Sorting Data in a TableView
Sorting Data by Users
Sorting Data Programmatically
Making a Column Sortable
Specifying the Sort Type of a Column
Specifying the Comparator for a Column
Specifying the Sort Node for a Column
Specifying the Sort Order of Columns
Getting the Comparator for a TableView
Specifying the Sort Policy
Sorting Data Manually
Handling Sorting Event
Disabling Sorting for a TableView
Customizing Data Rendering in Cells
Selecting Cells and Rows in a TableView
Editing Data in a TableView
Editing Data Using a Check Box
Editing Data Using a Choice Box
Editing Data Using a Combo Box
Editing Data Using a TextField
Editing Data in TableCell Using Any Control
Adding and Deleting Rows in a TableView
Scrolling in a TableView
Resizing a TableColumn
Styling a TableView with CSS
Summary
Chapter 14: Understanding 2D Shapes
What Are 2D Shapes?
Drawing 2D Shapes
Drawing Lines
Drawing Rectangles
Drawing Circles
Drawing Ellipses
Drawing Polygons
Drawing Polylines
Drawing Arcs
Drawing Quadratic Curves
Drawing Cubic Curves
Building Complex Shapes Using the Path Class
The MoveTo Path Element
The LineTo Path Element
The HLineTo and VLineTo Path Elements
The ArcTo Path Element
The QuadCurveTo Path Element
The CubicCurveTo Path Element
The ClosePath Path Element
The Fill Rule for a Path
Drawing Scalable Vector Graphics
The “moveTo” Command
The “lineto” Commands
The “arcto” Command
The “Quadratic Bezier curveto” Command
The “Cubic Bezier curveto” Command
The “closepath” Command
Combining Shapes
Understanding the Stroke of a Shape
Styling Shapes with CSS
Summary
Chapter 15: Understanding Text Nodes
What Is a Text Node?
Creating a Text Node
Understanding the Text Origin
Displaying Multiline Text
Setting Text Fonts
Creating Fonts
Accessing Installed Fonts
Using Custom Fonts
Setting Text Fill and Stroke
Applying Text Decorations
Applying Font Smoothing
Styling a Text Node with CSS
Summary
Chapter 16: Understanding 3D Shapes
What Are 3D Shapes?
Checking Support for 3D
The 3D Coordinate System
Rendering Order of Nodes
Using Predefined 3D Shapes
Specifying the Shape Material
Specifying the Draw Mode of Shapes
Specifying the Face Culling for Shapes
Using Cameras
Using Light Sources
Creating Subscenes
Creating User-Defined Shapes
Creating a 3D Triangle
Creating a 3D Rectangle
Creating a Tetrahedron
Summary
Chapter 17: Applying Effects
What Is an Effect?
Chaining Effects
Shadowing Effects
The DropShadow Effect
The InnerShadow Effect
The Shadow Effect
Blurring Effects
The BoxBlur Effect
The GaussianBlur Effect
The MotionBlur Effect
The Bloom Effect
The Glow Effect
The Reflection Effect
The SepiaTone Effect
The DisplacementMap Effect
The ColorInput Effect
The ColorAdjust Effect
The ImageInput Effect
The Blend Effect
The Lighting Effect
Customizing the Surface Texture
Understanding Reflection Types
Understanding the Light Source
Using a Distant Light Source
Using a Point Light Source
Using a Spot Light Source
The PerspectiveTransform Effect
Summary
Chapter 18: Understanding Transformations
What Is a Transformation?
The Translation Transformation
The Rotation Transformation
The Scale Transformation
The Shear Transformation
Applying Multiple Transformations
Summary
Chapter 19: Understanding Animation
What Is Animation?
Understanding Animation Classes
Understanding Utility Classes
Understanding the Duration Class
Understanding the KeyValue Class
Understanding the KeyFrame Class
Understanding the Timeline Animation
Controlling an Animation
Playing an Animation
Delaying the Start of an Animation
Stopping an Animation
Pausing an Animation
Knowing the State of an Animation
Looping an Animation
Auto Reversing an Animation
Attaching an onFinished Action
Knowing the Duration of an Animation
Adjusting the Speed of an Animation
Understanding Cue Points
Understanding Transitions
Understanding the Fade Transition
Understanding the Fill Transition
Understanding the Stroke Transition
Understanding the Translate Transition
Understanding the Rotate Transition
Understanding the Scale Transition
Understanding the Path Transition
Understanding the Pause Transition
Understanding the Sequential Transition
Understanding the Parallel Transition
Understanding Interpolators
Understanding the Linear Interpolator
Understanding the Discrete Interpolator
Understanding the Ease-In Interpolator
Understanding the Ease-Out Interpolator
Understanding the Ease-Both Interpolator
Understanding the Spline Interpolator
Understanding the Tangent Interpolator
Summary
Chapter 20: Understanding Charts
What Is a Chart?
Understanding the Chart API
Styling Charts with CSS
Data Used in Chart Examples
Understanding the PieChart
Customizing Pie Slices
Styling the PieChart with CSS
Using More Than Eight Series Colors
Using Background Images for Pie Slices
Understanding the XYChart
Representing Axes in an XYChart
Adding Data to an XYChart
Understanding the BarChart
Styling the BarChart with CSS
Understanding the StackedBarChart
Styling the StackedBarChart with CSS
Understanding the ScatterChart
Styling the ScatterChart with CSS
Understanding the LineChart
Styling the LineChart with CSS
Understanding the BubbleChart
Styling the BubbleChart with CSS
Understanding the AreaChart
Styling the AreaChart with CSS
Understanding the StackedAreaChart
Styling the StackedAreaChart with CSS
Customizing XYChart Appearance
Setting Alternate Row/Column Fill
Showing Zero Line Axes
Showing Grid Lines
Formatting Numeric Tick Labels
Summary
Chapter 21: Understanding the Image API
What Is the Image API?
Loading an Image
Specifying the Image-Loading Properties
Reading the Loaded Image Properties
Viewing an Image
Multiple Views of an Image
Viewing an Image in a Viewport
Understanding Image Operations
Pixel Formats
Reading Pixels from an Image
Writing Pixels to an Image
Creating an Image from Scratch
Saving a New Image to a File System
Taking the Snapshot of a Node and a Scene
Taking the Snapshot of a Node
Taking the Snapshot of a Scene
Summary
Chapter 22: Drawing on a Canvas
What Is the Canvas API?
Creating a Canvas
Drawing on the Canvas
Drawing Basic Shapes
Drawing Text
Drawing Paths
Drawing Images
Writing Pixels
Clearing the Canvas Area
Saving and Restoring the Drawing States
A Canvas Drawing Example
Summary
Chapter 23: Understanding Drag and Drop
What Is a Press-Drag-Release Gesture?
A Simple Press-Drag-Release Gesture
A Full Press-Drag-Release Gesture
A Drag-and-Drop Gesture
Understanding the Data Transfer Modes
Understanding the Dragboard
The Example Application
Initiating the Drag-and-Drop Gesture
Detecting a Drag Gesture
Dropping the Source onto the Target
Completing the Drag-and-Drop Gesture
Providing Visual Clues
A Complete Drag-and-Drop Example
Transferring an Image
Transferring Custom Data Types
Summary
Chapter 24: Understanding Concurrency in JavaFX
The Need for a Concurrency Framework
Understanding the Concurrency Framework API
Understanding the Worker Interface
State Transitions for a Worker
Properties of a Worker
Utility Classes for Examples
Using the Task Class
Creating a Task
Updating Task Properties
Listening to Task Transition Events
Cancelling a Task
Running a Task
A Prime Finder Task Example
Using the Service Class
Creating the Service
Updating Service Properties
Listening to Service Transition Events
Cancelling the Service
Starting the Service
Resetting the Service
Restarting the Service
The Prime Finder Service Example
Using the ScheduledService Class
Creating the ScheduledService
Updating ScheduledService Properties
Listening to ScheduledService Transition Events
The Prime Finder ScheduledService Example
Summary
Chapter 25: Playing Audios and Videos
Understanding the Media API
Playing Short Audio Clips
Playing Media
Creating a Media Object
Creating a MediaPlayer Object
Creating a MediaView Node
Combining Media, MediaPlayer, and MediaView
A Media Player Example
Handling Playback Errors
State Transitions of the MediaPlayer
Repeating Media Playback
Tracking Media Time
Controlling the Playback Rate
Controlling the Playback Volume
Positioning the MediaPlayer
Marking Positions in the Media
Showing Media Metadata
Customizing the MediaView
Developing a Media Player Application
Summary
Chapter 26: Understanding FXML
What Is FXML?
Editing FXML Documents
FXML Basics
Creating the FXML File
Adding UI Elements
Importing Java Types in FXML
Setting Properties in FXML
Specifying FXML Namespace
Assigning an Identifier to an Object
Adding Event Handlers
Loading FXML Documents
Using a Controller in FXML
Creating Objects in FXML
Using the no-args Constructor
Using the static valueOf() Method
Using a Factory Method
Using Builders
Creating Reusable Objects in FXML
Specifying Locations in Attributes
Using Resource Bundles
Including FXML Files
Using Constants
Referencing Another Element
Copying Elements
Binding Properties in FXML
Creating Custom Controls
Summary
Chapter 27: Understanding the Print API
What Is the Print API?
Listing Available Printers
Getting the Default Printer
Printing Nodes
Showing the Page Setup and Print Dialogs
Customizing PrinterJob Settings
Setting Page Layout
Printing a Web Page
Summary
Appendix: Additional Controls and Resources
Additional Controls
The TreeView Control
The TreeTableView Control
The WebView Control
Further Reading
Index