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