Learn JavaFX 17 Building User Experience and Interfaces with Java — Second Edition — Kishori Sharan Peter Späth Learn JavaFX 17 Building User Experience and Interfaces with Java Second Edition Kishori Sharan Peter Späth Learn JavaFX 17: Building User Experience and Interfaces with Java Kishori Sharan Peter Späth Montgomery, AL, USA Leipzig, Sachsen, Germany ISBN-13 (pbk): 978-1-4842-7847-5 ISBN-13 (electronic): 978-1-4842-7848-2 https://doi.org/10.1007/978-1-4842-7848-2 Copyright © 2022 by Kishori Sharan and Peter Späth This work is subject to copyright. All rights are reserved by the Publisher, whether the whole or part of the material is concerned, specifically the rights of translation, reprinting, reuse of illustrations, recitation, broadcasting, reproduction on microfilms or in any other physical way, and transmission or information storage and retrieval, electronic adaptation, computer software, or by similar or dissimilar methodology now known or hereafter developed. Trademarked names, logos, and images may appear in this book. Rather than use a trademark symbol with every occurrence of a trademarked name, logo, or image we use the names, logos, and images only in an editorial fashion and to the benefit of the trademark owner, with no intention of infringement of the trademark. The use in this publication of trade names, trademarks, service marks, and similar terms, even if they are not identified as such, is not to be taken as an expression of opinion as to whether or not they are subject to proprietary rights. While the advice and information in this book are believed to be true and accurate at the date of publication, neither the authors nor the editors nor the publisher can accept any legal responsibility for any errors or omissions that may be made. The publisher makes no warranty, express or implied, with respect to the material contained herein. Managing Director, Apress Media LLC: Welmoed Spahr Acquisitions Editor: Steve Anglin Development Editor: Laura Berendson Coordinating Editor: Mark Powers Cover designed by eStudioCalamar Cover image by Onder Ortel on Unsplash (www.unsplash.com) Distributed to the book trade worldwide by Apress Media, LLC, 1 New York Plaza, New York, NY 10004, U.S.A. Phone 1-800-SPRINGER, fax (201) 348-4505, e-mail [email protected], or visit www. springeronline.com. Apress Media, LLC is a California LLC and the sole member (owner) is Springer Science + Business Media Finance Inc (SSBM Finance Inc). SSBM Finance Inc is a Delaware corporation. For information on translations, please e-mail [email protected]; for reprint, paperback, or audio rights, please e-mail [email protected]. Apress titles may be purchased in bulk for academic, corporate, or promotional use. eBook versions and licenses are also available for most titles. For more information, reference our Print and eBook Bulk Sales web page at http://www.apress.com/bulk-sales. Any source code or other supplementary material referenced by the author in this book is available to readers on GitHub via the book’s product page, located at www.apress.com/9781484278475. For more detailed information, please visit http://www.apress.com/source- code. Printed on acid-free paper To my father-in-law Mr. Jim Baker —Kishori Sharan To my niece Alina —Peter Späth Table of Contents About the Authors �������������������������������������������������������������������������������������������������xxix About the Technical Reviewer ������������������������������������������������������������������������������xxxi Acknowledgments ����������������������������������������������������������������������������������������������xxxiii Introduction ���������������������������������������������������������������������������������������������������������xxxv ■ Chapter 1: Getting Started �������������������������������������������������������������������������������������1 What Is JavaFX? ���������������������������������������������������������������������������������������������������������������1 History of JavaFX �������������������������������������������������������������������������������������������������������������3 System Requirements ������������������������������������������������������������������������������������������������������4 JavaFX Runtime Library ���������������������������������������������������������������������������������������������������4 JavaFX Source Code ���������������������������������������������������������������������������������������������������������5 Your First JavaFX Application �������������������������������������������������������������������������������������������5 Starting an Eclipse Project ���������������������������������������������������������������������������������������������������������������������5 Setting Up a Module Info ������������������������������������������������������������������������������������������������������������������������7 Creating the HelloJavaFX Class ��������������������������������������������������������������������������������������������������������������8 Overriding the start() Method �����������������������������������������������������������������������������������������������������������������8 Showing the Stage ���������������������������������������������������������������������������������������������������������������������������������9 Launching the Application ��������������������������������������������������������������������������������������������������������������������10 Adding a Scene to the Stage ����������������������������������������������������������������������������������������������������������������10 Improving the HelloFX Application����������������������������������������������������������������������������������12 Passing Parameters to a JavaFX Application �����������������������������������������������������������������15 Case 1 ���������������������������������������������������������������������������������������������������������������������������������������������������16 Case 2 ���������������������������������������������������������������������������������������������������������������������������������������������������16 v ■ Table of ConTenTs Launching a JavaFX Application �������������������������������������������������������������������������������������17 The Life Cycle of a JavaFX Application ���������������������������������������������������������������������������19 Terminating a JavaFX Application ����������������������������������������������������������������������������������21 Summary ������������������������������������������������������������������������������������������������������������������������22 ■ Chapter 2: Properties and Bindings ���������������������������������������������������������������������23 What Is a Property? ��������������������������������������������������������������������������������������������������������23 What Is a Binding? ���������������������������������������������������������������������������������������������������������25 Understanding Binding Support in JavaBeans ���������������������������������������������������������������26 Understanding Properties in JavaFX ������������������������������������������������������������������������������29 Using Properties in JavaFX Beans ����������������������������������������������������������������������������������32 Understanding the Property Class Hierarchy������������������������������������������������������������������36 Handling Property Invalidation Events ����������������������������������������������������������������������������39 Handling Property Change Events ����������������������������������������������������������������������������������40 Handling Invalidation and Change Events ����������������������������������������������������������������������43 Using Bindings in JavaFX �����������������������������������������������������������������������������������������������44 Unidirectional and Bidirectional Bindings ����������������������������������������������������������������������47 Understanding the Binding API ���������������������������������������������������������������������������������������51 The High-Level Binding API ������������������������������������������������������������������������������������������������������������������51 Using the Low-Level Binding API ����������������������������������������������������������������������������������������������������������64 Using Bindings to Center a Circle �����������������������������������������������������������������������������������66 Summary ������������������������������������������������������������������������������������������������������������������������67 ■ Chapter 3: Observable Collections�����������������������������������������������������������������������69 What Are Observable Collections? ���������������������������������������������������������������������������������69 Understanding ObservableList ���������������������������������������������������������������������������������������70 Creating an ObservableList �������������������������������������������������������������������������������������������������������������������72 Observing an ObservableList for Invalidations �������������������������������������������������������������������������������������74 Observing an ObservableList for Changes ��������������������������������������������������������������������������������������������75 Understanding ObservableSet ����������������������������������������������������������������������������������������84 Creating an ObservableSet �������������������������������������������������������������������������������������������������������������������85 vi ■ Table of ConTenTs Understanding ObservableMap ��������������������������������������������������������������������������������������85 Creating an ObservableMap �����������������������������������������������������������������������������������������������������������������86 Properties and Bindings for JavaFX Collections �������������������������������������������������������������87 Understanding ObservableList Property and Binding ���������������������������������������������������������������������������87 Binding to List Properties and Content �������������������������������������������������������������������������������������������������90 Understanding ObservableSet Property and Binding����������������������������������������������������������������������������94 Understanding ObservableMap Property and Binding ��������������������������������������������������������������������������95 Summary ������������������������������������������������������������������������������������������������������������������������97 ■ Chapter 4: Managing Stages �������������������������������������������������������������������������������99 Knowing the Details of Your Screens �����������������������������������������������������������������������������99 What Is a Stage? ����������������������������������������������������������������������������������������������������������101 Showing the Primary Stage ������������������������������������������������������������������������������������������102 Setting the Bounds of a Stage ��������������������������������������������������������������������������������������104 Initializing the Style of a Stage �������������������������������������������������������������������������������������108 Moving an Undecorated Stage �������������������������������������������������������������������������������������111 Initializing Modality of a Stage �������������������������������������������������������������������������������������113 Setting the Opacity of a Stage ��������������������������������������������������������������������������������������116 Resizing a Stage �����������������������������������������������������������������������������������������������������������116 Showing a Stage in Full-Screen Mode �������������������������������������������������������������������������117 Showing a Stage and Waiting for It to Close ����������������������������������������������������������������118 Summary ����������������������������������������������������������������������������������������������������������������������120 ■ Chapter 5: Making Scenes ���������������������������������������������������������������������������������123 What Is a Scene? ����������������������������������������������������������������������������������������������������������123 Graphics Rendering Modes ������������������������������������������������������������������������������������������125 Setting the Cursor for a Scene �������������������������������������������������������������������������������������126 The Focus Owner in a Scene ����������������������������������������������������������������������������������������127 Understanding the Platform Class ��������������������������������������������������������������������������������128 Knowing the Host Environment ������������������������������������������������������������������������������������130 Summary ����������������������������������������������������������������������������������������������������������������������132 vii ■ Table of ConTenTs ■ Chapter 6: Understanding Nodes �����������������������������������������������������������������������133 What Is a Node? �����������������������������������������������������������������������������������������������������������133 The Cartesian Coordinate System ��������������������������������������������������������������������������������134 Cartesian Coordinate System of a Node �����������������������������������������������������������������������135 The Concept of Bounds and Bounding Box ������������������������������������������������������������������136 Knowing the Bounds of a Node ������������������������������������������������������������������������������������138 The layoutBounds Property ����������������������������������������������������������������������������������������������������������������140 The boundsInLocal Property ���������������������������������������������������������������������������������������������������������������143 The boundsInParent Property �������������������������������������������������������������������������������������������������������������144 Bounds of a Group ��������������������������������������������������������������������������������������������������������144 A Detailed Example on Bounds ������������������������������������������������������������������������������������144 Positioning a Node Using layoutX and layoutY �������������������������������������������������������������150 Setting the Size of a Node ��������������������������������������������������������������������������������������������151 Resizable Nodes ���������������������������������������������������������������������������������������������������������������������������������153 Nonresizable Nodes ����������������������������������������������������������������������������������������������������������������������������161 Storing User Data in a Node �����������������������������������������������������������������������������������������161 What Is a Managed Node? �������������������������������������������������������������������������������������������162 Transforming Bounds Between Coordinate Spaces �����������������������������������������������������166 Summary ����������������������������������������������������������������������������������������������������������������������170 ■ Chapter 7: Playing with Colors ��������������������������������������������������������������������������171 Understanding Colors ���������������������������������������������������������������������������������������������������172 Using the Color Class ��������������������������������������������������������������������������������������������������������������������������173 Using the ImagePattern Class ������������������������������������������������������������������������������������������������������������174 Understanding Linear Color Gradient ���������������������������������������������������������������������������177 Using the LinearGradient Class�����������������������������������������������������������������������������������������������������������178 Defining Linear Color Gradients Using a String Format ����������������������������������������������������������������������183 Understanding Radial Color Gradient ���������������������������������������������������������������������������185 Using the RadialGradient Class�����������������������������������������������������������������������������������������������������������186 Defining Radial Color Gradients in String Format �������������������������������������������������������������������������������192 Summary ����������������������������������������������������������������������������������������������������������������������193 viii ■ Table of ConTenTs ■ Chapter 8: Styling Nodes �����������������������������������������������������������������������������������195 What Is a Cascading Style Sheet? ��������������������������������������������������������������������������������195 What Are Styles, Skins, and Themes? ��������������������������������������������������������������������������196 A Quick Example ����������������������������������������������������������������������������������������������������������196 Naming Conventions in JavaFX CSS ����������������������������������������������������������������������������198 Adding Style Sheets �����������������������������������������������������������������������������������������������������198 Default Style Sheet �������������������������������������������������������������������������������������������������������199 Adding Inline Styles ������������������������������������������������������������������������������������������������������199 Priorities of Styles for a Node ���������������������������������������������������������������������������������������201 Inheriting CSS Properties ���������������������������������������������������������������������������������������������204 Types of CSS Properties �����������������������������������������������������������������������������������������������206 The inherit Type ����������������������������������������������������������������������������������������������������������������������������������207 The boolean Type ��������������������������������������������������������������������������������������������������������������������������������207 The string Type �����������������������������������������������������������������������������������������������������������������������������������207 The number and integer Types �����������������������������������������������������������������������������������������������������������208 The size Type ��������������������������������������������������������������������������������������������������������������������������������������208 The length and percentage Types �������������������������������������������������������������������������������������������������������208 The angle Type ������������������������������������������������������������������������������������������������������������������������������������208 The duration Type �������������������������������������������������������������������������������������������������������������������������������209 The point Type ������������������������������������������������������������������������������������������������������������������������������������209 The color-stop Type ����������������������������������������������������������������������������������������������������������������������������209 The URI Type ���������������������������������������������������������������������������������������������������������������������������������������209 The effect Type �����������������������������������������������������������������������������������������������������������������������������������209 The font Type ��������������������������������������������������������������������������������������������������������������������������������������210 The paint and color Types �������������������������������������������������������������������������������������������������������������������211 Specifying Background Colors �������������������������������������������������������������������������������������213 Specifying Borders �������������������������������������������������������������������������������������������������������215 Border Colors ��������������������������������������������������������������������������������������������������������������������������������������215 Border Widths �������������������������������������������������������������������������������������������������������������������������������������216 Border Radii ����������������������������������������������������������������������������������������������������������������������������������������216 ix ■ Table of ConTenTs Border Insets ��������������������������������������������������������������������������������������������������������������������������������������216 Border Styles ��������������������������������������������������������������������������������������������������������������������������������������217 Understanding Style Selectors �������������������������������������������������������������������������������������219 Using Class Selectors �������������������������������������������������������������������������������������������������������������������������219 Class Selector for the root Node ���������������������������������������������������������������������������������������������������������222 Using ID Selectors ������������������������������������������������������������������������������������������������������������������������������224 Combining ID and Class Selectors ������������������������������������������������������������������������������������������������������225 The Universal Selector ������������������������������������������������������������������������������������������������������������������������226 Grouping Multiple Selectors ���������������������������������������������������������������������������������������������������������������226 Descendant Selectors �������������������������������������������������������������������������������������������������������������������������227 Child Selectors ������������������������������������������������������������������������������������������������������������������������������������227 State-Based Selectors ������������������������������������������������������������������������������������������������������������������������228 Using JavaFX Class Names As Selectors ��������������������������������������������������������������������������������������������229 Looking Up Nodes in a Scene Graph ����������������������������������������������������������������������������229 Summary ����������������������������������������������������������������������������������������������������������������������230 ■ Chapter 9: Event Handling ���������������������������������������������������������������������������������231 What Is an Event? ���������������������������������������������������������������������������������������������������������231 Event Class Hierarchy ���������������������������������������������������������������������������������������������������232 Event Targets ����������������������������������������������������������������������������������������������������������������233 Event Types ������������������������������������������������������������������������������������������������������������������234 Event Processing Mechanism ��������������������������������������������������������������������������������������235 Event Target Selection ������������������������������������������������������������������������������������������������������������������������235 Event Route Construction �������������������������������������������������������������������������������������������������������������������236 Event Route Traversal �������������������������������������������������������������������������������������������������������������������������236 Handling Events �����������������������������������������������������������������������������������������������������������239 Creating Event Filters and Handlers ���������������������������������������������������������������������������������������������������239 Registering Event Filters and Handlers ����������������������������������������������������������������������������������������������239 Execution Order of Event Filters and Handlers �������������������������������������������������������������245 Consuming Events ��������������������������������������������������������������������������������������������������������248 Handling Input Events ��������������������������������������������������������������������������������������������������251 x