Everything you see on the screen of your computer can be split into three large categories:

• Shapes
• Text
• Images

Thus, by being able to create each of these, you can build any UI in reasonable time. Let's start with JavaFX shapes.

The simplest object you can put on a scene is a shape. Under the javafx.scene.shape package, the JavaFX API supports a great range of shapes, from circles and rectangles to polygons and SVG paths. Most shapes can be divided then into two categories—lines and closed shapes. The properties that are shared among all shapes will be covered in the next section. After, we will review each shape's specific APIs.

JavaFX API supports basic transformations for every Node (and Shape, which extends Node).

Three basic transformations can be used through Node methods:

• setRotate (double angle): Rotates around the center of the Node
• setTranslateX (double pixels), setTranslateY (double pixels): Shifts the Node by a set amount of pixels
• setScaleX (double scale), setScaleY (double scale): Increases (or decreases) the Node by multiplying its horizontal or vertical dimensions by scale

For more complex transformations, the Transform class can be used. It allows us to work precisely with every parameter of the transformation. For example, you can concatenate two transformations into one combined and use two different nodes to save.

Note that through Transform, there are usually more options available. For example, the setRotate() method always uses the center of the shape as a pivot...

Let's look into determining Shape and Node bounds in Scene and Scenegraph.

The simplest of all are layoutBounds. These rectangular bounds are used for all size and location calculations for this Node, and describe its basic shape size. They don't include any extra effects or transformations.

The next thing is boundsInLocal. These bounds include all information about effects. So, you can determine how large of an area is covered by your Node or Shape.

The last one is boundsInParent. These are bounds after all transformations as well and bounding rectangles uses their parents' coordinate system.

There is a very nice public demo by Kishori Sharan that shows how bounds...

Controls are a special subset of Node objects that were designed to handle user interaction. Most of them allow user input and support focus traversal.

Another difference from Shape is that Control objects are inherited not directly from Node but through the Region interface (like layout managers), which means their size and location are not fixed and can be managed by layout managers.

The first and most common control is button's family. Button has an EventHandler that is called when Button is clicked (or fired). All code in the event handler is always run on JavaFX Application Thread:

// chapter2/other/ButtonDemo.java
Button btn = new Button();
btn.setText("Say 'Hello...

Let's apply some of the stuff we learned in this Chapter to the Clock demo we started in the previous chapter.

The digital clock is not as fun as an analog one, so let's add hands to it.

We need three hands—hours, minutes, and seconds. We'll use a simple line for the seconds hand and slightly more complex path shapes for the hour and minute ones. For example, here is the path for the minute hand:

Path minuteHand = new Path(
                new MoveTo(0, 0),
                new LineTo(15, -5),
                new LineTo(100,0),
                new LineTo(15,5),
                new ClosePath());
minuteHand.setFill(Color.DARKGRAY);

This code gives us not the prettiest but a conveniently simple hand. We'll work on making it nicer in following chapters:

To show time, the hand has to rotate. We'll use the Rotate transformation. We need to rotate...

In this chapter, we've studied a lot of different building blocks for JavaFX applications: shapes, text, and simple controls. Also, we looked at various ways to customize them. With these tools, you can already build a visually rich JavaFX UI.

The only problem is that it will be static, which is not enough for a modern application. In the next two chapters, we will learn about Binding and Animation, which will allow us to develop more dynamic applications.