This chapter is an introduction to JavaFX 8; we have already talked about JavaFX 8 as a technology and why you should care about it.

Next, we will navigate its history, exploring its core features and where it could be used.

Before you start using this book to learn JavaFX 8, we will go through the preparation of your development environment by installing various required software bundles, to be able to compile and run many of its examples.

In this chapter, you will learn how to install the required software, such as the Java Development Kit JDK and the NetBeans Integrated Development Environment (IDE).

After installing the required software, you will begin by creating a traditional Hello JavaFX 8 example. Once you feel comfortable with the development environment, as a final verification that we are on the right track, we will walk through the Hello JavaFX 8 source code to understand the basic JavaFX 8 application architecture.

So what you are waiting for? Let's get started!

You might believe JavaFX is quite a new technology, but it actually isn't. JavaFX has been here for a long time; unofficially since 2005. Ever since Sun Microsystems acquired the company SeeBeyond, there has been a graphics-rich scripting language known as F3 (Form Follows Function), which was created by engineer Chris Oliver.

At the JavaOne 2007 conference, Sun Microsystems officially unveiled JavaFX as the language's name instead of F3. During the period 2007 to 2010, Oracle acquired many big companies like BEA Systems, JD Edwards, Siebel Systems, and so on. I was working for Oracle with the responsibility of integrating different customer support channels to the Oracle support website MetaLink, as it was called at that time.

On April 20, 2009, Oracle Corporation announced the acquisition of Sun Microsystems, making Oracle the new steward of JavaFX.

At JavaOne 2010, Oracle announced the JavaFX roadmap, which included its plans to phase out the JavaFX 1.3 scripting language and recreate the JavaFX platform for the Java platform as Java-based APIs. As promised, JavaFX 2.0 SDK was released at JavaOne in October 2011.

In addition to the release of JavaFX 2.0, Oracle took the platform to the next level by announcing its commitment to take steps to make JavaFX open source, thus allowing Java's versatile and strong community to help move the platform forward. Making JavaFX open source increased its adoption, enabled a quicker turnaround time on bug fixes, and generated new enhancements.

Between the versions JavaFX 2.1 and 2.2, the number of new features grew rapidly. JavaFX 2.1 was the official release of the Java SDK on Mac OS. JavaFX 2.2 was the official release of the Java SDK on the Linux operating system.

There was no such thing as JavaFX 3.x, but the big change in the Java development world happened with the Java SE 8 release, which was announced on March 18, 2014. Java SE 8 has many new APIs and language enhancements, which include Lambdas, Stream API, Nashorn JavaScript engine, and JavaFX APIs, which are being incorporated into standard JDK bundles, and JavaFX version becomes 8 as direct successor to JavaFX 2.0.

To see all of the new features in Java SE 8, visit http://www.oracle.com/technetwork/java/javase/8-whats-new-2157071.html.

The following features are included in JavaFX 8 and later releases as per JavaFX's official documentation:

What's new in JavaFX 8

The following is a brief summary of the new features and significant product changes made in the JavaFX component of the Java SE 8 release:

• The new Modena theme is now the default theme for JavaFX applications.
• Support for additional HTML5 features, including Web Sockets, Web Workers, Web Fonts, and printing capabilities have been added.
• The API enables you to embed Swing content into JavaFX applications with the new SwingNode class, which improves the Swing interoperability feature.
• DatePicker, Spinner, and TableView built-in UI controls are now available.
• It provides the public JavaFX printing APIs through the javafx.print package.
• Support for Hi-DPI displays has been made available.
• CSS-styleable classes became public APIs.
• A scheduled service class has been introduced.
• The 3D graphics library has been enhanced with several new API classes.
• Major updates have been added to the Camera API class in this release.
• Now JavaFX 8 supports rich text capabilities. These include bidirectional and complex text scripts such as Thai and Hindi in UI controls, and multiline, multistyle text in text nodes.
• Dialogs and accessibility APIs are supported.

In Appendix, Become a JavaFX Guru, I have provided a list of all the references (links, books, magazines, articles, blogs, and tools) and real JavaFX 8 production applications you will need to become a JavaFX guru.

The following figure shows the Ensemble8.jar application built using JavaFX 8, showing examples dealing with various JavaFX 8 components, topics and concepts. More interestingly, the source code is available to learn from and modify – consult the last chapter to see how to install this application.

JavaFX 8 applications

There are many topics covered by the application, especially the new JavaFX 8 3D APIs, which can be found under the Graphics 3D section as seen in the following figure:

JavaFX 8 3D applications

So far, we have had a good introduction to JavaFX and I am as eager as you to start creating and launching our first "Hello JavaFX 8" application. But this can't happen without downloading and installing the right tools that will allow us to create and compile most of the book's code.

You'll need to download and install Java 8 Java Development Kit (JDK) or a later version. Not the runtime version (JRE).

Download the latest Java SE 8u45 JDK or higher from the following location:

http://www.oracle.com/technetwork/java/javase/downloads/index.html

Download and install NetBeans 8.0.2 or higher from the following link https://netbeans.org/downloads, though the NetBeans IDE All Bundle is recommended, you can use the Java EE bundle as well, as shown in the figure:

NetBeans bundles download.

Currently, JavaFX 8 runs on the following operating systems:

Installing Java SE 8 JDK

The steps outlined in this section will guide you to successfully download and install Java SE 8. Download the Java SE 8 JDK from the following location:

http://www.oracle.com/technetwork/java/javase/downloads/jdk8-downloads-2133151.html

In the following steps, the Java SE 8u45 JDK 64-bit version (at the time of writing) on the Mac OS X Yosemite (10.10.3) operating system will be used as an example.

The steps are similar on other operating systems and JDK versions. However, if your environment is different, refer to the following link for additional details:

http://docs.oracle.com/javase/8/docs/technotes/guides/install/toc.html

The following are steps to install the Java SE 8 JDK:

1. Install the Java 8 JDK by launching the image file jdk-8u45-macosx-x64.dmg. A screen will appear that looks like the following screenshot once you've launched the JDK 8 setup image file. That's the package setup file. Double-click on it and the installer will launch:
   

   JDK 8 setup image file

   Tip

   Typically, you will need administrator rights on the machine to install the software.

2. Begin the setup of the Java 8 JDK. The screen in the following screenshot will appear at the beginning of the installation process. Click on the Continue button, next on the Installation type screen wizard, click on Install to begin the installation.
   

   Java SE Development Kit 8 setup

3. Once you hit Install, you may be asked to supply your password. Supply it, click on Ok and the installation will proceed with a progress bar, as shown in following figure:
   

   Java SE Development Kit 8 installation in progress

4. The setup will complete the installation of the Java 8 SE Development Kit. click on the Close button to exit.

Setting environment variables

Now you need to set a couple of key environment variables. How you set them and the values they should be set to vary depending on your operating system. The two variables to be set are:

• JAVA_HOME: This tells your operating system where the Java installation directory is.
• PATH: This specifies where the Java executable directory resides. This environment variable lets the system search paths or directories containing executable files. The Java executables reside in the bin directory under the JAVA_HOME home directory.

To make JAVA_HOME and PATH more permanent, you will want to add them to your system in such a way that they are always made available whenever you boot or log in. Depending on your operating system, you will need to be able to edit environment variable names and values.

In the Windows environment, you can use the keyboard shortcut Windows logo key + Pause/Break key and then click on Advanced system settings to display the Systems Property dialog.

Next, click on Environment Variables. This is where you can add, edit, and delete environment variables. You will add or edit the JAVA_HOME environment variable by using the installed home directory as the value. Shown in this screenshot is the Environment Variables dialog on the Windows operating system:

Windows Environment Variables

Let's set the environment variables:

• To set your JAVA_HOME environment variable for the Mac OS X platform, you will need to launch a terminal window to edit your home directory's .bash_profile file by adding the following export command:

  export JAVA_HOME=$(/usr/libexec/java_home -v 1.8)
  

• On Linux and other Unix operating systems that use Bash shell environments, launch a terminal window and edit either the ~/.bashrc or ~/.profile file to contain the export commands:

  export JAVA_HOME=/usr/java/jdk1.8.0
  export PATH=$PATH:$JAVA_HOME/bin
  

• On Linux and other Unix operating systems that use C shell (csh) environments, launch a terminal window and edit either the ~/.cshrc or ~/.login file to contain the setenv commands:

  setenv JAVA_HOME /usr/java/jdk1.8.0_45
  setenv PATH ${JAVA_HOME}/bin:${PATH}
  

Once you've set up your path and the JAVA_HOME environment variables, you will want to verify your setup by launching a terminal window and executing the following two commands from the command prompt:

java -version
javac –version

Note

The output in each case should display a message indicating the Java SE 8 version of the language and runtime.

The best way to show you what it is like to create and build a JavaFX application would be with a Hello World application.

In this section, you will be using the NetBeans IDE we just installed to develop, compile, and run a JavaFX-based Hello World application.

import javafx.application.Application;
import javafx.scene.Scene;
import javafx.scene.control.Button;
import javafx.scene.text.Text;
import javafx.stage.Stage;
import static javafx.geometry.Pos.CENTER;
import javafx.scene.layout.VBox;

/**
  * @author mohamed_taman
 */
public class HelloJavaFX extends Application {
  
  @Override
  public void start(Stage primaryStage) {
    
    Button btn = new Button();
    Text message = new Text();
    
    btn.setText("Say 'Hello World'");
    
    btn.setOnAction(event -> {
      message.setText("Hello World! JavaFX style :)");
    });
    
    VBox root = new VBox(10,btn,message);
    root.setAlignment(CENTER);
    
    Scene scene = new Scene(root, 300, 250);
    
    primaryStage.setTitle("Hello JavaFX 8 World!");
    primaryStage.setScene(scene);
    primaryStage.show();
  }
  public static void main(String[] args) {
    launch(args);
  }
}

So far, you have learned what JavaFX is and seen its power. You have managed to download and install both Java 8 JDK and NetBeans IDE. After successfully installing the prerequisite software, you created a JavaFX Hello World GUI application through the NetBeans IDE. After learning how to compile and run a JavaFX application, you did a quick code walkthrough of the source file HelloJavaFX.java.

Next, in Chapter 2, JavaFX 8 Essentials and Creating a custom you'll learn about JavaFX 8 architecture components and engines, which allow JavaFX applications to run efficiently and smoothly under the hood. You will also learn about the most common layout UI components and get an idea about theming your application as a whole or as individual scene nodes.

We will also be covering Java SE 8's most important feature, Lambda expressions, and how it works. We will then get insights into Scene Builder as a declarative UI and productive tool, then learn about generated FXML-based markup document and how to import it into NetBeans IDE to continue your application logic implementation to associate it to the already declared UI controls inside your FXML document.

Finally, you will be able to create a custom UI component that isn't bundled with default JavaFX 8 UI controls.