Beginning Java Programming: The Object-Oriented Approach (Programmer to Programmer) (2015)

---

When following along with the Try It Out, you might have spotted an Eclipse warning saying that BMICalculator does not contain a serial version identifier. Eclipse will offer to generate a random one for you, which boils down to a line of code similar to this one being added to your class:

private static final long serialVersionUID = -8952857142790654268L;

Now what is this identifier and why is it useful? The reason behind this has to do with serialization (storing objects in a format that allows you to read them back out and initialize them as class instances again later). To make sure that the data of a stored object still matches a class definition (as this might have changed over time), Java also stores a special identifier that verifies that the object to be loaded back in still matches the identifier of the class. As such, as the name suggests, the serialVersionUID is mainly helpful for versioning reasons (an object with UID 100 will not be able to get instantiated to its class when the class definition is on version 101).

In most cases, Java can generate a serialVersionUID based on various aspects of the class at hand. However, it is recommended that all serializable classes explicitly declare serialVersionUID values, since the default serialVersionUID computation is sensitive to class details that may vary depending on compiler implementations. Since Swing components implement Serializable and because Eclipse cares about best practices, it asks you to specify a serialVersionUID.

Since it is unlikely that you will start serializing Swing components (they shouldn’t contain important data anyway and should just concern themselves with UI), the best thing to do if you want to avoid these warnings is to use the default UID everywhere:

private static final long serialVersionUID = 1L;

You can also turn off these warning by navigating to Window, Preferences, Java Compiler Errors/Warnings and setting Serializable Class Without serialVersionUID to Ignore under Potential Programming Problems.

Now take a closer look to see how event listeners work. Swing components hold a collection of listener objects, which have registered themselves to be interested in being notified whenever an event occurs. For instance, for a JButton, you have seen how ActionListenerobjects can be registered using the addActionListener method. Note that the same listener can in theory be registered with multiple components.

NOTE Note By using the term event listener, you might expect the listening objects to be the active players in this setup, but actually, it is the event source (e.g., a button) that will notify its listeners when something interesting happens, by calling one of their methods.

This listener-notifier setup is a typical programming pattern, commonly referred to as the observer pattern. The following chapter has much more information on Object-Oriented Programming patterns.

Generally speaking, there are three ways you will see listener objects being defined and registered. First of all, for simple event listeners you know you’ll only need with one particular component, it is common to define the listener directly as an anonymous inner class, like so:

import java.awt.event.ActionEvent;

import java.awt.event.ActionListener;

import javax.swing.JButton;

import javax.swing.JFrame;

import javax.swing.JOptionPane;

import javax.swing.SwingUtilities;

public class ActionListenerExample extends JFrame {

public ActionListenerExample() {

super();

setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

JButton btn = new JButton("Click Me!");

btn.addActionListener(new ActionListener() {

@Override

public void actionPerformed(ActionEvent arg0) {

JOptionPane.showMessageDialog(

null,

"You clicked me, nice!",

"Aw yeah!",

JOptionPane.PLAIN_MESSAGE);

}

});

this.add(btn);

pack();

setVisible(true);

}

public static void main(String[] args) {

SwingUtilities.invokeLater(new Runnable() {

public void run() {

new ActionListenerExample();

}

});

}

}

The main benefit of this technique is that it is easy and simple, so it works well for simple components. The downside it that it leads quickly to messy-looking code, does not allow the same listener to be reused in multiple components, and will sometimes require you to do some variable hocus-pocus to access them in the inner class (remember the self variable from the Try It Out).

The second way will make the container component itself the event listener. This is helpful when you have multiple components to listen to and you already have a custom class for your container. In this case, you’ll see the pattern class Name extends JContainerName implements ListenerName appearing, like in this example:

import java.awt.event.ActionEvent;

import java.awt.event.ActionListener;

import javax.swing.JButton;

import javax.swing.JFrame;

import javax.swing.JOptionPane;

import javax.swing.SwingUtilities;

public class ActionListenerExample extends JFrame implements ActionListener {

public ActionListenerExample() {

super();

setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

JButton btn = new JButton("Click Me!");

// The JFrame is now also the listener object

btn.addActionListener(this);

this.add(btn);

pack();

setVisible(true);

}

@Override

public void actionPerformed(ActionEvent arg0) {

JOptionPane.showMessageDialog(

null,

"You clicked me, nice!",

"Aw yeah!",

JOptionPane.PLAIN_MESSAGE);

}

public static void main(String[] args) {

SwingUtilities.invokeLater(new Runnable() {

public void run() {

new ActionListenerExample();

}

});

}

}

The upside of this approach is that it allows the class you already have as a container to act as a listener for its child components. The downside is that you need to add some extra code when you want to add a listener to multiple buttons, for instance, and need to know which button (not just that a button) was clicked. More about how to deal with this later.

Finally, you can also decide to keep the listener separated as much as possible by defining it in a new class:

import javax.swing.JButton;

import javax.swing.JFrame;

import javax.swing.JOptionPane;

import javax.swing.SwingUtilities;

public class ActionListenerExample extends JFrame {

public ActionListenerExample() {

super();

setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

JButton btn = new JButton("Click Me!");

MySimpleButtonListener listener = new MySimpleButtonListener();

btn.addActionListener(listener);

this.add(btn);

pack();

setVisible(true);

}

public static void main(String[] args) {

SwingUtilities.invokeLater(new Runnable() {

public void run() {

new ActionListenerExample();

}

});

}

}

import java.awt.event.ActionEvent;

import java.awt.event.ActionListener;

public class MySimpleButtonListener implements ActionListener {

@Override

public void actionPerformed(ActionEvent arg0) {

JOptionPane.showMessageDialog(

null,

"You clicked me, nice!",

"Aw yeah!",

JOptionPane.PLAIN_MESSAGE);

}

}

Obviously, the advantage is that it becomes easy to reuse the same listener class (and instances, even) across different components. The downside is that this requires a little more effort to set up.

So far, you’ve only seen the ActionListener for a JButton. A wealth of other listeners exists as well. The general usage is always the same: construct a listener with the appropriate type using one of the three techniques seen previously, and then add it to a component using addLISTENERTYPEListener. A nonexhaustive list of some of the interesting listeners is included in the following table.

LISTENER (INTERFACE): METHOD TO ADD	CAN BE USED WITH: PURPOSE	METHOD(S) TO IMPLEMENT
Action Listener (ActionListener) - addActionListener	Fires ActionEvent when user performs primary action on component. Can be used with JButton, JCheckBox, JComboBox, JRadioButton, and JTextField.	actionPerformed: Code that reacts to the action.
Caret Listener (CaretListener) - addCaretListener	Fires CaretEvent whenever the caret (the cursor in a text field, for instance) moves or when the selection changes. Can be used with JTextArea, JTextField, and JTextPane.	caretUpdate: Code that reacts whenever caret is updated (is moved, the selection changes, text is inserted, and so on).
Change Listener (ChangeListener) - addChangeListener	Fires ChangeEvent whenever a component changes its state.	stateChanged: Code that reacts to component changes.
	Can be used with JButton, JCheckBox, JProgressBar, and JRadioButton. Also useful with JSlider and JSpinner, as these will fire events for the value of the slider or the spinner changes. These two components do not accept ActionListeners, so here you’ll want to use Change Listeners.
Item Listener (ItemListener) - addItemListener	Fires ItemEvent whenever a state change occurs in the component’s items. JCheckBox, JComboBox, and other components keep a list of items that accept this listener.	itemStateChanged: Code that reacts when state of items changes.
List Selection Listener (ListSelectionListener) - addListSelectionListener	Fires ListSelectionEvent when selection changes in the component’s items. Only JList and JTable accept this listener.	valueChanged: Code that reacts when another item is selected from the component’s items.
Window Listener (WindowListener) - addWindowListener	Fires WindowEvent when state changes occur in windowed components. JDialog and JFrame accept this listener.	windowOpened: Code that reacts when window has been shown for first time (in program’s execution). windowClosing: Code that reacts when user requests the window to close. windowClosed: Code that reacts just after window has closed. windowIconified and windowDeiconified: Code that reacts when window is minimized or unminimized. windowActivated and windowDeactivated: Code that reacts when window is activated or deactivated. This method will not work with frames or dialogs, so you need to use the Window FocusListener here instead.
Window Focus Listener (WindowFocusListener) - addWindowFocusListener	Fires WindowEvent when a windowed component gains or loses focus. JDialog and JFrame accept this listener.	windowGainedFocus and windowLostFocus: Code that reacts when window gains or loses focus.
Window State Listener (WindowStateListener) - addWindowStateListener	Fires WindowEvent when the state of a windowed component changes, such as is maximized or minimized. JDialog and JFrame accept this listener.	windowStateChanged: Code that reacts when window is being (un)minimized, maximized, or returned to normal.
Component Listener (ComponentListener) - addComponentListener	Fires ComponentEvent when a component is hidden, moved, resized, or shown. All components accept this listener.	componentHidden and componentShown: Code that reacts when component is made invisible or visible. componentMoved and componendResized: Code that reacts when position or dimensions of component changes.
Focus Listener (FocusListener) - addFocusListener	Fires FocusEvent when component loses or gains focus. All components accept this listener.	focusGained and focusLost: Code that reacts when component gains or loses focus.
Key Listener (KeyListener) - addKeyListener	Fires KeyEvent when user types on the keyboard and the component the listener is registered with has focus. All components accept this listener.	keyTyped: Code that reacts when user types a key (presses and releases a key). keyPressed and keyReleased: Code that reacts when user presses and releases a key.
Mouse Listener (MouseListener) - addMouseListener	Fires MouseEvent when the mouse pointer interacts with a component. All components accept this listener.	mouseClicked: Code that reacts when a user clicks a mouse button. mouseEntered and mouseExited: Code that reacts when the mouse pointer enters or exits a component. mousePressed and mouseReleased: Code that reacts when user presses and releases a mouse button.
Mouse Motion Listener (MouseMotionListener) - addMouseMotionListener	Fires MouseEvent when the mouse pointer is dragged or moved over a component. All components accept this listener.	mouseDragged: Code that reacts when a user moves the mouse while holding a mouse button down. mouseMoved: Code that reacts when a user moves the mouse.
Mouse Wheel Listener (MouseWheelListener) - addMouseWheelListener	Fires MouseWheelEvent when user scrolls the mouse wheel. All components accept this listener.	mouseWheelMoved: Code that reacts when the user moves the mouse wheel.
Mouse Adapter (MouseAdapter) - addMouseListener, addMouseMotionListener, addMouseWheelListener	Can be used to define all three mouse event listeners at the same time. Convenience class.	See three mouse event listeners above.

Don’t worry if the amount of event types and listeners seems overwhelming for now (and this isn’t even all of them). Just refer to this table when you encounter a need to add more behavior to your components. In most cases, using action listener should cover most of your needs.

That said, whichever listener you’re using, you should still consider a few additional aspects. The first one relates to the event source—the component sending the event to the listeners. Earlier on, you read that in some cases you might want to determine exactly which button was clicked. For example, take the following base scenario:

import java.awt.FlowLayout;

import java.awt.event.ActionEvent;

import java.awt.event.ActionListener;

import javax.swing.JButton;

import javax.swing.JFrame;

import javax.swing.JOptionPane;

import javax.swing.SwingUtilities;

public class ActionListenerExample extends JFrame implements ActionListener {

public ActionListenerExample() {

super();

this.setLayout(new FlowLayout());

setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

JButton btn1 = new JButton("Click Me!");

JButton btn2 = new JButton("No, click me!");

btn1.addActionListener(this);

btn2.addActionListener(this);

getContentPane().add(btn1);

getContentPane().add(btn2);

pack();

setVisible(true);

}

@Override

public void actionPerformed(ActionEvent ev) {

JOptionPane.showMessageDialog(

null,

"You clicked a button!",

"Aw yeah!",

JOptionPane.PLAIN_MESSAGE);

}

public static void main(String[] args) {

SwingUtilities.invokeLater(new Runnable() {

public void run() {

new ActionListenerExample();

}

});

}

}

This class is comparable to the earlier example and acts as both a container and an action listener for two buttons. Now say you want to show a different message depending on which button was clicked.

The first way to do this is by changing the actionPerformed method as follows:

@Override

public void actionPerformed(ActionEvent ev) {

String message;

if (((JButton)ev.getSource()).getText().equals("Click Me!"))

message = "First button was clicked";

else

message = "Second button was clicked";

JOptionPane.showMessageDialog(null,

message, "Aw yeah!",

JOptionPane.PLAIN_MESSAGE);

}

Of course, this is a terrible way to implement the desired functionality. Not only are you making an unsafe case (who says the source component will always be a button?), but you’re also hardcoding some text that might later be changed. This does introduce an interesting method though: getSource(). This method allows you to get the source component for the incoming event. Why not directly use this method as is? You will need to make the two buttons class fields, however:

import java.awt.FlowLayout;

import java.awt.event.ActionEvent;

import java.awt.event.ActionListener;

import javax.swing.JButton;

import javax.swing.JFrame;

import javax.swing.JOptionPane;

import javax.swing.SwingUtilities;

public class ActionListenerExample extends JFrame implements ActionListener {

private final JButton btn1 = new JButton("Click Me!");

private final JButton btn2 = new JButton("No, click me!");

public ActionListenerExample() {

super();

this.setLayout(new FlowLayout());

setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

btn1.addActionListener(this);

btn2.addActionListener(this);

getContentPane().add(btn1);

getContentPane().add(btn2);

pack();

setVisible(true);

}

@Override

public void actionPerformed(ActionEvent ev) {

String message = "";

if (ev.getSource() == btn1)

message = "First button was clicked";

else if (ev.getSource() == btn2)

message = "Second button was clicked";

JOptionPane.showMessageDialog(null,

message, "Aw yeah!",

JOptionPane.PLAIN_MESSAGE);

}

public static void main(String[] args) {

SwingUtilities.invokeLater(new Runnable() {

public void run() {

new ActionListenerExample();

}

});

}

}

This is much better. There is, however, also another mechanism by which you can determine the correct action to take whenever an event is fired, that is by means of a so-called action command. This is especially useful when the same event source can lead to different behavior. The following example shows how action commands work. Pay particular attention to the use of the setActionCommand and getActionCommand methods.

import java.awt.Color;

import java.awt.FlowLayout;

import java.awt.event.ActionEvent;

import java.awt.event.ActionListener;

import javax.swing.JButton;

import javax.swing.JFrame;

import javax.swing.SwingUtilities;

public class DiscoLightsExample extends JFrame implements ActionListener {

private final String ACTION_ON = "LIGHT ON";

private final String ACTION_OFF = "LIGHT OFF";

private final String ACTION_CYCLE = "CYCLE COLOR";

private final Color[] COLORS = new Color[]{

Color.white,

Color.green,

Color.red,

Color.yellow,

Color.orange,

Color.pink

};

private int currentColor = 0;

private boolean isLightOn = false;

public DiscoLightsExample() {

setTitle("Disco Light Party Frame");

setLayout(new FlowLayout());

setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

JButton btnOffOn = new JButton("Lights On");

JButton btnColor = new JButton("Cycle Color");

btnOffOn.setActionCommand(ACTION_ON);

btnColor.setActionCommand(ACTION_CYCLE);

btnOffOn.addActionListener(this);

btnColor.addActionListener(this);

getContentPane().add(btnOffOn);

getContentPane().add(btnColor);

pack();

setVisible(true);

}

@Override

public void actionPerformed(ActionEvent ev) {

String action = ev.getActionCommand();

System.err.println("Got action "+action);

switch (action) {

case ACTION_ON:

isLightOn = true;

getContentPane().setBackground(COLORS[currentColor]);

((JButton) ev.getSource()).setText("Lights Off");

((JButton) ev.getSource()).setActionCommand(ACTION_OFF);

break;

case ACTION_OFF:

isLightOn = false;

getContentPane().setBackground(Color.black);

((JButton) ev.getSource()).setText("Lights On");

((JButton) ev.getSource()).setActionCommand(ACTION_ON);

break;

case ACTION_CYCLE:

if (isLightOn)

getContentPane().setBackground(COLORS[++currentColor

% COLORS.length]);

break;

}

}

public static void main(String[] args) {

SwingUtilities.invokeLater(new Runnable() {

public void run() {

new DiscoLightsExample();

}

});

}

}

On Threading and Swing

Finally, before moving on to the next section, there is one more important thing to highlight when working with event listeners—and indeed with UIs in general when using Swing. Recall that whenever you build a GUI with Java Swing, an event loop will start running in the background that will check for user actions and dispatch events to your listeners. To be more precise, all Swing event handling code runs on a special thread known as the Event Dispatch Thread. We won’t talk in depth about threads in a beginner’s book on programming, but in general, think about a thread as a unit of execution in a program. For instance, the following code snippet shows how two threads are created that will count from 1 to 10 in parallel:

public class CountingTask implements Runnable {

private static int COUNTER = 0;

private int threadId;

public CountingTask() {

threadId = ++COUNTER;

}

public void run() {

for (int i = 1; i <= 10; i++) {

System.out.println("Thread #"+threadId+" is at: "+i);

try {

// Rest a bit to give other threads a chance to work

Thread.sleep(10);

} catch (InterruptedException e) {

e.printStackTrace();

}

}

}

public static void main(String[] args) {

Thread thread1 = new Thread(new CountingTask());

Thread thread2 = new Thread(new CountingTask());

thread1.start();

thread2.start();

}

}

If you try to execute this code, you’ll note that both threads’ output lines will end up mixed on the console. This shows how threads can serve as a helpful way to define multiple work tasks within the same program. Note that your operating system is responsible for the actual allocation of CPU time to the various threads in your program. Even if you have only one CPU core, the operating system will make sure to divide calculation time so that each thread in all running programs on your computer get a chance to do their work, causing them to seemingly run in parallel. Note that running the code snippet above actually involves the creation of three threads: the main thread (all programs have one main thread, where the main method is invoked) and the two custom-defined ones.

Let’s return to the discussion of the Event Dispatch Thread (EDT). This thread is started in the background (i.e., next to the main thread) to continually process events: button clicks, mouse clicks, and so on. Whenever you write code that makes changes to the GUI of a program, all this code must be executed in this Event Dispatch Thread as well. Updating visible components from other threads is the source of many common bugs in Java programs that use Swing. Note that this aspect is not specific to Swing; the same concept exists in other UI toolkits as well. To see how updating the UI outside the EDT can cause problems, take a look at the following code:

import javax.swing.DefaultListModel;

import javax.swing.JFrame;

import javax.swing.JList;

public class MultiThreadedFrame extends JFrame {

public static final int LENGTH = 100;

public static final JList<String> COMPONENT = new JList<>();

public class CountingTask implements Runnable {

public void run() {

for (int i = 1; i <= LENGTH; i++) {

// Add an item

((DefaultListModel<String>) COMPONENT.getModel()).clear();

((DefaultListModel<String>)

COMPONENT.getModel()).addElement("At: "+i);

// Force component repaint

COMPONENT.repaint();

COMPONENT.invalidate();

COMPONENT.repaint();

// Sleep for a little to give other threads a chance

try {

Thread.sleep(1);

} catch (InterruptedException e) {

e.printStackTrace();

}

}

}

}

public MultiThreadedFrame() {

DefaultListModel<String> listModel = new DefaultListModel<>();

COMPONENT.setModel(listModel);

getContentPane().add(COMPONENT);

pack();

setSize(300,500);

setVisible(true);

// Increase the number of threads if problem does not appear

for (int t = 0; t < 16; t++) {

Thread thread = new Thread(new CountingTask());

thread.start();

}

}

public static void main(String[] args) {

new MultiThreadedFrame();

}

}

When you run this code, you’ll see a number of exceptions appearing in the console. Another undesired aspect of the code is that you’ll (most likely) end up with multiple elements in your JList when the program stops running, even though you execute the clear()method before adding a new item in every thread. This is due to the fact that threads can run in parallel, meaning that two threads can add items right after they have both cleared the list.

NOTE Some Swing components’ methods are called “thread safe.” However, this behavior has changed between Java versions before, so it is generally a good idea not to rely on thread-safe components. This also applies to JList.

You’ve already seen an important rule regarding the EDT, namely that all UI-related code should be run inside this thread. The way to do so is simple, namely by using the SwingUtilities helper class, which defines the following methods to help out with threading:

· invokeLater(Runnable doRun): Executes doRun.run() asynchronously on the event dispatching thread.

· invokeAndWait(Runnable doRun): Executes doRun.run() synchronously on the event dispatching thread, meaning that this method will wait until doRun.run() has completed.

· isEventDispatchThread(): Returns true if the current thread is the event dispatching thread.

In almost all cases, you’ll use the invokeLater method to wrap UI-affecting code as follows:

SwingUtilities.invokeLater(new Runnable() {

public void run() {

// UI affecting code

}

});

One particular place where it is important to use this method is in the main method of your programs, as it is guaranteed there that you will not yet be in the EDT (but instead in the initial main thread). Using SwingUtilities, you can rewrite the earlier example as follows:

import javax.swing.DefaultListModel;

import javax.swing.JFrame;

import javax.swing.JList;

import javax.swing.SwingUtilities;

public class MultiThreadedFrame extends JFrame {

public static final int LENGTH = 100;

public static final JList<String> COMPONENT = new JList<>();

public class CountingTask implements Runnable {

public void run() {

for (int i = 1; i <= LENGTH; i++) {

// Add an item

((DefaultListModel<String>) COMPONENT.getModel()).clear();

((DefaultListModel<String>)

COMPONENT.getModel()).addElement("At: "+i);

// Force component repaint

COMPONENT.repaint();

COMPONENT.invalidate();

COMPONENT.repaint();

// Sleep for a little to give other threads a chance

try {

Thread.sleep(1);

} catch (InterruptedException e) {

e.printStackTrace();

}

}

}

}

public MultiThreadedFrame() {

DefaultListModel<String> listModel = new DefaultListModel<>();

COMPONENT.setModel(listModel);

getContentPane().add(COMPONENT);

pack();

setSize(300,500);

setVisible(true);

for (int t = 0; t < 16; t++) {

SwingUtilities.invokeLater(new CountingTask());

}

}

public static void main(String[] args) {

SwingUtilities.invokeLater(new Runnable() {

public void run() { new MultiThreadedFrame(); }

});

}

}

The fact that you must ensure all UI updating code is run on the EDT might seem like an annoying aspect of GUI programming at first, but there is a silver lining that relates to event listeners. Because the EDT is responsible for catching user-interface events and also passes these to any event listeners, any code that you execute inside an event listener will be run inside the EDT. This means that you do not need to use invokeLater, for instance, when running code inside the actionPerformed method of an ActionListener for a button, which, luckily, will also contain the multitude of UI-related code.

However, since this code is executed in the EDT, this means that, while the EDT is busy executing the event listeners, the event loop will block until all event listeners have finished what they need to do. Subsequent events will thus need to wait until they are handled, and since this can involve anything from button clicks to window resizes, this can quickly lead to unresponsive, sluggish interfaces when you stick too much calculation-heavy code in your event listeners. Again, this is illustrated with a simple example. Imagine you come up with the following beautiful progress-tracking interface to wrap around some heavy-duty code:

import java.awt.FlowLayout;

import java.awt.event.ActionEvent;

import java.awt.event.ActionListener;

import javax.swing.JButton;

import javax.swing.JFrame;

import javax.swing.JProgressBar;

import javax.swing.SwingUtilities;

public class ProgressTrackingFrame extends JFrame implements ActionListener {

private boolean isRunning = false;

private final JProgressBar bar = new JProgressBar(0, 100);

private final JButton btn = new JButton("Start Calculation");

public ProgressTrackingFrame() {

super();

setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

setTitle("Progress Tracker");

setLayout(new FlowLayout());

btn.addActionListener(this);

add(bar);

add(btn);

pack();

setVisible(true);

}

@Override

public void actionPerformed(ActionEvent arg0) {

if (isRunning) {

// How to cancel here?

} else {

isRunning = true;

btn.setText("Stop Calculation");

long total = 1000000000;

for (long i = 0; i < total; i++) {

int perc = (int)

(i * (bar.getMaximum() - bar.getMinimum())

/ total);

bar.setValue(perc);

}

}

isRunning = false;

btn.setText("Start Calculation");

}

public static void main(String[] args) {

SwingUtilities.invokeLater(new Runnable() {

public void run() { new ProgressTrackingFrame(); }

});

}

Try running the program and starting the calculation. Unless you have a very fast machine, the loop will take some time to finish. Notice how the rest of the UI becomes frozen during the execution of the action listener. Try resizing the window. You’ll note that this will lead to a garbled result that’s typical for programs that do not redraw their UI anymore, as shown in Figure 11.21.

Figure 11.21

In some cases, Windows will notice that your program is not responding and might attempt to close it. Just wait a few more seconds, however, and you’ll see that the program suddenly pops into life again and the event loop catches up to handle the other events. This is because the event listener includes heavy-duty code that is run inside the EDT.

Of course, you would like a way to improve things, and if possible, you’d also like to implement a way to cancel a running calculation.

Again, luckily, Swing already provides a mechanism to do this in a fairly simple manner, by means of the SwingWorker class. This class allows you to construct objects that represent some kind of background task. Here’s how you can implement it. First of all, define a new class field like so:

private SwingWorker<Boolean, Integer> backgroundTask = null;

You can remove the isRunning field, as you’ll no longer need it. Next, create a method to construct a background task for you:

public SwingWorker<Boolean, Integer> makeBackgroundTask(final long total) {

}

This method will construct a new SwingWorker anonymous inner class. You will need to provide two type parameters to this class. The first one represents the type of the final result value (you use a Boolean here). The second one represents the type of the intermediate result values (Integer is used here as these will be sent out to update the progress bar):

public SwingWorker<Boolean, Integer> makeBackgroundTask(final long total) {

SwingWorker<Boolean, Integer> task = new SwingWorker<Boolean, Integer>(){

@Override

protected Boolean doInBackground() throws Exception {

return true;

}

};

return task;

}

The doInBackground method needs to be implemented and has to have your indicated final result type as a return type (Boolean). This method contains the work that will be performed in the background, so fill it up with your loop:

public SwingWorker<Boolean, Integer> makeBackgroundTask(final long total) {

SwingWorker<Boolean, Integer> task = new SwingWorker<Boolean, Integer>(){

@Override

protected Boolean doInBackground() throws Exception {

btn.setText("Stop Calculation");

for (long i = 0; i < total; i++) {

int perc = (int)

(i * (bar.getMaximum() - bar.getMinimum())

/ total);

}

return true;

}

};

return task;

}

Although you could still update the progress bar value inside this method, SwingWorker also provides a way to work with intermediate values in a better manner, by using its publish method. This method will queue intermediate results that can then be processed by aprocess method. You don’t need to manually call the latter, as SwingWorker will determine when (based on time and results gathered) it is a good time to call this method:

public SwingWorker<Boolean, Integer> makeBackgroundTask(final long total) {

SwingWorker<Boolean, Integer> task = new SwingWorker<Boolean, Integer>(){

@Override

protected Boolean doInBackground() throws Exception {

btn.setText("Stop Calculation");

for (long i = 0; i < total; i++) {

int perc = (int)

(i * (bar.getMaximum() - bar.getMinimum())

/ total);

publish(perc);

}

return true;

}

@Override

protected void process(List<Integer> percs) {

for (int perc : percs)

if (bar.getValue() < perc)

bar.setValue(perc);

}

};

return task;

}

You can also use the isCancelled method to figure out whether your background task was cancelled from the outside. It is a good idea to check the result of this method as often as possible so a cancellation request can be dealt with as soon as possible, for instance in the deepest level of a loop:

public SwingWorker<Boolean, Integer> makeBackgroundTask(final long total) {

SwingWorker<Boolean, Integer> task = new SwingWorker<Boolean, Integer>(){

@Override

protected Boolean doInBackground() throws Exception {

btn.setText("Stop Calculation");

for (long i = 0; i < total; i++) {

if (isCancelled()) {

bar.setValue(0);

return false;

}

int perc = (int)

(i * (bar.getMaximum() - bar.getMinimum())

/ total);

publish(perc);

}

return true;

}

@Override

protected void process(List<Integer> percs) {

for (int perc : percs)

if (bar.getValue() < perc)

bar.setValue(perc);

}

};

return task;

}

Finally, you can also override the done method to update your UI:

public SwingWorker<Boolean, Integer> makeBackgroundTask(final long total) {

SwingWorker<Boolean, Integer> task = new SwingWorker<Boolean, Integer>(){

@Override

protected Boolean doInBackground() throws Exception {

btn.setText("Stop Calculation");

for (long i = 0; i < total; i++) {

if (isCancelled()) {

bar.setValue(0);

return false;

}

int perc = (int)

(i * (bar.getMaximum() - bar.getMinimum())

/ total);

publish(perc);

}

return true;

}

@Override

protected void process(List<Integer> percs) {

for (int perc : percs)

if (bar.getValue() < perc)

bar.setValue(perc);

}

@Override

public void done() {

btn.setText("Start Calculation");

backgroundTask = null;

}

};

return task;

}

Next, the only thing left to do is to change your original action listener so it now sets up and executes your background task, using the execute method. Use the cancel method to send a cancellation request in case the user wants to cancel the calculation. The final result looks like this:

import java.awt.FlowLayout;

import java.awt.event.ActionEvent;

import java.awt.event.ActionListener;

import java.util.List;

import javax.swing.JButton;

import javax.swing.JFrame;

import javax.swing.JProgressBar;

import javax.swing.SwingUtilities;

import javax.swing.SwingWorker;

public class ProgressTrackingFrame extends JFrame implements ActionListener {

private final JProgressBar bar = new JProgressBar(0, 100);

private final JButton btn = new JButton("Start Calculation");

private SwingWorker<Boolean, Integer> backgroundTask = null;

public ProgressTrackingFrame() {

super();

setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

setTitle("Progress Tracker");

setLayout(new FlowLayout());

btn.addActionListener(this);

add(bar);

add(btn);

pack();

setVisible(true);

}

public SwingWorker<Boolean, Integer> makeBackgroundTask(final long total) {

SwingWorker<Boolean, Integer> task = new SwingWorker<Boolean, Integer>(){

@Override

protected Boolean doInBackground() throws Exception {

btn.setText("Stop Calculation");

for (long i = 0; i < total; i++) {

if (isCancelled()) {

bar.setValue(0);

return false;

}

int perc = (int)

(i * (bar.getMaximum() - bar.getMinimum())

/ total);

publish(perc);

}

return true;

}

@Override

protected void process(List<Integer> percs) {

for (int perc : percs)

if (bar.getValue() < perc)

bar.setValue(perc);

}

@Override

public void done() {

btn.setText("Start Calculation");

backgroundTask = null;

}

};

return task;

}

@Override

public void actionPerformed(ActionEvent arg0) {

if (backgroundTask == null) {

backgroundTask = makeBackgroundTask(1000000000);

backgroundTask.execute();

} else {

backgroundTask.cancel(true);

}

}

public static void main(String[] args) {

SwingUtilities.invokeLater(new Runnable() {

public void run() { new ProgressTrackingFrame(); }

});

}

Try running the program again and observe what happens. Finally, it is good to know that you can also call get() and get(long timeout, TimeUnit unit) on a SwingWorker object to block until the background task has completed and you get the final result. In most cases, this blocking behavior is not what you want, and it is a better idea to have the done method of the worker call one of your objects to notify about the completion.

You’ve now seen all the important things you need to know about GUIs in Java. With a complex class hierarchy, a huge list of components and containers, layout managers that all have different behavior and a plethora of event listeners, building GUIs in Java can appear to be a daunting task at first. Don’t be afraid to get started and build some simple interfaces. Check the online documentation and Eclipse’s helpful autosuggest feature to get to know Swing’s components and utilize them whenever you can. Exercise is key here, and this chapter has only outlined the basics. The final chapter in this book contains many case study examples that will have you building more realistic, complex graphical user interfaces, utilizing many of the available Swing components. Don’t hesitate to have a look.

CLOSING TOPICS

This chapter closes with some additional topics related to the concept of GUIs.

Best Practices: Keeping Looks and Logic Separated

A first topic you’ll read about relates to best practices when writing graphical user interfaces. Generally speaking, even after gaining knowledge of Object-Oriented Programming, beginners will find it relatively hard to keep domain logic separated from user-interface concerns. When you find yourself making monstrous user interfaces where buttons and text fields keep track of state, you’ll know it is time for a change.

Ideally, you should be able to perform all your application logic using pure Java objects and without using any graphical user interface at all. Therefore, it is always a good idea to construct your core domain concepts first. Which concepts exist? What data needs to be stored? Which actions can be undertaken? Afterward, you can start building the GUI around all of this. As a challenge, consider creating a “console” version for your applications as an alternative to the graphical one. How hard would it be? Where are the main root issues? Here lies the opportunity for solid refactoring.

The next chapter talks more about patterns, and you will get acquainted with a very helpful pattern when building GUI-driven applications: the model-view-controller pattern.

Although separating your logic from UI is a must, it is also a good idea to keep your UI as architecturally sound as possible. Many of the examples you’ve seen in this chapter already reflect a natural progress in UI architecture, starting with sticking everything in amain method (bad) to creating custom UI classes (good), from creating huge event listeners in inner classes (bad) to separating them into separate classes and even into background tasks (good), from trying to make UIs as hierarchically flat as possible and fighting with layout managers (bad) to accepting the fact that you might want to create another JPanel, or perhaps a separate custom class extending JPanel and nesting this in a reusable manner (good). Writing GUIs in Java is by no means easy. It is oftentimes cumbersome, boring even. You want to focus on the core concepts of your program, and that involves a lot of boilerplate code. However, architectural decisions you make at the beginning might end up saving you a lot of time and headache later.

Let’s Draw: Defining Custom Draw Behavior

It’s already been stated that Swing components handle all drawing behavior by themselves, which is why they can look similar on each platform they’re run on. You saw before how to work with different look and feels inside Swing, but you might also be interested in knowing whether you can override or extend rendering behavior of components.

The answer is that indeed, you can. All Swing components (JComponent) come with the following built-in methods:

· public void paint(Graphics g): Paints the component, its border, and its children by calling these methods:

· protected void paintComponent(Graphics g)

· protected void paintBorder(Graphics g)

· protected void paintChildren(Graphics g)

The Graphics object that’s passed along can be regarded as a general surface area on which Java can draw, representing the geometric area of the component that will need to be painted.

To show this off, the following Try It Out will lead you through a simple painting application, which is also a good opportunity to show off a mouse listener and show another helpful component, the JFileChooser.

TRY IT OUT Making a Paint Application with Custom-Painted Components

In this Try It Out, you create a simple painting application by overriding the default painting behavior of a component.

1. As always, feel free to create a new project in Eclipse when you want to. Create a class called SimplePaint with the following content as a bare bones starting point:

2. import javax.swing.JFrame;

3. import javax.swing.SwingUtilities;

4.

5. public class SimplePaint extends JFrame {

6. public SimplePaint() {

7. super();

8. setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

9. setTitle("Simple Paint");

10.

11.

12. pack();

13. setVisible(true);

14. }

15. public static void main(String[] args) {

16. SwingUtilities.invokeLater(new Runnable() {

17. public void run() { new SimplePaint(); }

18. });

19. }

}

20. Start out by adding some menu items to your JFrame. In fact, a JFrame comes with built-in functionality to set up a menu bar. You just need to construct a menu first:

21. import java.awt.event.ActionEvent;

22. import java.awt.event.ActionListener;

23.

24. import javax.swing.JFrame;

25. import javax.swing.JMenu;

26. import javax.swing.JMenuBar;

27. import javax.swing.JMenuItem;

28.

29.

30. public class SimplePaint extends JFrame implements ActionListener {

31. private final String ACTION_NEW = "New Image";

32. private final String ACTION_LOAD = "Load Image";

33. private final String ACTION_SAVE = "Save Image";

34.

35. public SimplePaint() {

36. super();

37. setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

38. setTitle("Simple Paint");

39.

40. initMenu();

41.

42. pack();

43. setVisible(true);

44. }

45.

46. private void initMenu() {

47. JMenuBar menuBar = new JMenuBar();

48. JMenu menu = new JMenu("File");

49. JMenuItem mnuNew = new JMenuItem(ACTION_NEW);

50. JMenuItem mnuLoad = new JMenuItem(ACTION_LOAD);

51. JMenuItem mnuSave = new JMenuItem(ACTION_SAVE);

52. mnuNew.setActionCommand(ACTION_NEW);

53. mnuLoad.setActionCommand(ACTION_LOAD);

54. mnuSave.setActionCommand(ACTION_SAVE);

55. mnuNew.addActionListener(this);

56. mnuLoad.addActionListener(this);

57. mnuSave.addActionListener(this);

58. menu.add(mnuNew);

59. menu.add(mnuLoad);

60. menu.add(mnuSave);

61. menuBar.add(menu);

62. this.setJMenuBar(menuBar);

63. }

64.

65. @Override

66. public void actionPerformed(ActionEvent ev) {

67.

68. }

69.

70. public static void main(String[] args) {

71. SwingUtilities.invokeLater(new Runnable() {

72. public void run() { new SimplePaint(); }

73. });

74. }

}

75. Feel free to run the program in between steps and check the result. You should get something like Figure 11.22.

Figure 11.22

Next, create a custom panel, that is, a panel with some custom paint code:

import java.awt.Color;

import java.awt.Dimension;

import java.awt.Graphics;

import java.awt.Point;

import java.awt.event.MouseAdapter;

import java.awt.event.MouseEvent;

import java.util.Collection;

import java.util.HashSet;

import java.util.Set;

import javax.swing.JPanel;

public class SimplePaintPanel extends JPanel {

private final Set<Point> blackPixels = new HashSet<Point>();

private final int brushSize;

private int mouseButtonDown = 0;

public SimplePaintPanel() {

this(5, new HashSet<Point>());

}

public SimplePaintPanel(Set<Point> blackPixels) {

this(5, blackPixels);

}

public SimplePaintPanel(int brushSize, Set<Point> blackPixels) {

this.setPreferredSize(new Dimension(300, 300));

this.brushSize = brushSize;

this.blackPixels.addAll(blackPixels);

final SimplePaintPanel self = this;

MouseAdapter mouseAdapter = new MouseAdapter() {

@Override

public void mouseDragged(MouseEvent ev) {

if (self.mouseButtonDown == 1)

self.blackPixels.addAll(getPixelsAround(ev.getPoint()));

else if (self.mouseButtonDown == 3)

self.blackPixels.removeAll(getPixelsAround(ev.getPoint()));

self.invalidate();

self.repaint();

}

@Override

public void mousePressed(MouseEvent ev) {

self.mouseButtonDown = ev.getButton();

}

};

this.addMouseMotionListener(mouseAdapter);

this.addMouseListener(mouseAdapter);

}

public void paint(Graphics g) {

int w = this.getWidth();

int h = this.getHeight();

g.setColor(Color.white);

g.fillRect(0, 0, w, h);

g.setColor(Color.black);

for (Point point : blackPixels)

g.drawRect(point.x, point.y, 1, 1);

}

private Collection<? extends Point> getPixelsAround(Point point) {

Set<Point> points = new HashSet<>();

for (int x = point.x - brushSize; x < point.x + brushSize; x++)

for (int y = point.y - brushSize; y < point.y + brushSize; y++)

points.add(new Point(x, y));

return points;

}

76. Next, add this custom component to your JFrame:

77. import java.awt.event.ActionEvent;

78. import java.awt.event.ActionListener;

79.

80. import javax.swing.JFrame;

81. import javax.swing.JMenu;

82. import javax.swing.JMenuBar;

83. import javax.swing.JMenuItem;

84.

85. public class SimplePaint extends JFrame implements ActionListener {

86. private final String ACTION_NEW = "New Image";

87. private final String ACTION_LOAD = "Load Image";

88. private final String ACTION_SAVE = "Save Image";

89.

90. private final SimplePaintPanel paintPanel = new SimplePaintPanel();

91.

92. public SimplePaint() {

93. super();

94. setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

95. setTitle("Simple Paint");

96.

97. initMenu();

98. this.getContentPane().add(paintPanel);

99.

100. pack();

101. setVisible(true);

102. }

103.

104. private void initMenu() {

105. JMenuBar menuBar = new JMenuBar();

106. JMenu menu = new JMenu("File");

107. JMenuItem mnuNew = new JMenuItem(ACTION_NEW);

108. JMenuItem mnuLoad = new JMenuItem(ACTION_LOAD);

109. JMenuItem mnuSave = new JMenuItem(ACTION_SAVE);

110. mnuNew.setActionCommand(ACTION_NEW);

111. mnuLoad.setActionCommand(ACTION_LOAD);

112. mnuSave.setActionCommand(ACTION_SAVE);

113. mnuNew.addActionListener(this);

114. mnuLoad.addActionListener(this);

115. mnuSave.addActionListener(this);

116. menu.add(mnuNew);

117. menu.add(mnuLoad);

118. menu.add(mnuSave);

119. menuBar.add(menu);

120. this.setJMenuBar(menuBar);

121. }

122.

123. @Override

124. public void actionPerformed(ActionEvent ev) {

125.

126. }

127.

128. public static void main(String[] args) {

129. SwingUtilities.invokeLater(new Runnable() {

130. public void run() { new SimplePaint(); }

131. });

132. }

}

133. Try running the program again. Try dragging the mouse using the left and right mouse buttons. Although the implementation is horribly inefficient, the concept works, as shown in Figure 11.23.

Figure 11.23

134. Now continue by making the menu work. To do so, first make some modifications to your SimplePaintPanel, adding/changing the following methods:

135. // Inside the mouseAdapter:

136. @Override

137. public void mouseDragged(MouseEvent ev) {

138. if (mouseButtonDown == 1)

139. addPixels(getPixelsAround(ev.getPoint()));

140. else if (mouseButtonDown == 3)

141. removePixels(getPixelsAround(ev.getPoint()));

142. }

143.

144. // Add the following methods:

145. public void clear() {

146. this.blackPixels.clear();

147. this.invalidate();

148. this.repaint();

149. }

150.

151. public void addPixels(Collection<? extends Point> blackPixels) {

152. this.blackPixels.addAll(blackPixels);

153. this.invalidate();

154. this.repaint();

155. }

156.

157. public void removePixels(Collection<? extends Point> blackPixels) {

158. this.blackPixels.removeAll(blackPixels);

159. this.invalidate();

160. this.repaint();

161. }

162.

163. public boolean isPixel(Point blackPixel) {

164. return this.blackPixels.contains(blackPixel);

165. }

166.

167. // Change this method:

168. private Collection<? extends Point> getPixelsAround(Point point) {

169. Set<Point> points = new HashSet<>();

170. for (int x = point.x - brushSize; x < point.x + brushSize; x++)

171. for (int y = point.y - brushSize; y < point.y + brushSize; y++)

172. points.add(new Point(x, y));

173. return points;

}

174. Making the New menu work then becomes a simple manner of filling up the actionPerformed method in the SimplePaint class like so:

175. @Override

176. public void actionPerformed(ActionEvent ev) {

177. switch (ev.getActionCommand()) {

178. case ACTION_NEW:

179. paintPanel.clear();

180. break;

181. }

}

182. Next up is the ability to load images. Some tricks are used to convert everything to black and white, but you could theoretically show the image as is if you want to (try this out later by yourself if you want to take up the challenge):

183. @Override

184. public void actionPerformed(ActionEvent ev) {

185. switch (ev.getActionCommand()) {

186. case ACTION_NEW:

187. paintPanel.clear();

188. break;

189. case ACTION_LOAD:

190. doLoadImage();

191. break;

192. }

193. }

194.

195. private void doLoadImage() {

196. JFileChooser fileChooser = new JFileChooser();

197. fileChooser.setFileSelectionMode(JFileChooser.FILES_ONLY);

198. int result = fileChooser.showOpenDialog(this);

199. if (result != JFileChooser.APPROVE_OPTION)

200. return;

201. BufferedImage image;

202. File openFile = fileChooser.getSelectedFile();

203. try (FileInputStream fis = new FileInputStream(openFile)) {

204. image = ImageIO.read(fis);

205. } catch (IOException e) {

206. return;

207. }

208. if (image == null)

209. return;

210. paintPanel.clear();

211. Set<Point> blackPixels = new HashSet<Point>();

212. for (int x = 0; x < image.getWidth(); x++) {

213. for (int y = 0; y < image.getHeight(); y++) {

214. Color c = new Color(image.getRGB(x, y));

215. if ((c.getBlue() < 128 || c.getRed() < 128 || c.getGreen() < 128)

216. && c.getAlpha() == 255) {

217. blackPixels.add(new Point(x, y));

218. }

219. }

220. }

221. paintPanel.addPixels(blackPixels);

}

222. Try loading the project again and loading an image, as shown in Figure 11.24.

Figure 11.24

223. Finally, you can add the ability to save images:

224. @Override

225. public void actionPerformed(ActionEvent ev) {

226. switch (ev.getActionCommand()) {

227. case ACTION_NEW:

228. paintPanel.clear();

229. break;

230. case ACTION_LOAD:

231. doLoadImage();

232. break;

233. case ACTION_SAVE:

234. doSaveImage();

235. break;

236. }

237. }

238.

239. private void doSaveImage() {

240. JFileChooser fileChooser = new JFileChooser();

241. fileChooser.setFileSelectionMode(JFileChooser.FILES_ONLY);

242. int result = fileChooser.showSaveDialog(this);

243. if (result != JFileChooser.APPROVE_OPTION)

244. return;

245. File saveFile = fileChooser.getSelectedFile();

246. if (!saveFile.getAbsolutePath().toLowerCase().endsWith(".png"))

247. saveFile = new File(saveFile.getAbsolutePath() + ".png");

248. BufferedImage image = new BufferedImage(

249. paintPanel.getSize().width,

250. paintPanel.getSize().height,

251. BufferedImage.TYPE_INT_RGB);

252. for (int x = 0; x < image.getWidth(); x++) {

253. for (int y = 0; y < image.getHeight(); y++) {

254. image.setRGB(x, y, Color.white.getRGB());

255. if (paintPanel.isPixel(new Point(x, y))) {

256. image.setRGB(x, y, Color.black.getRGB());

257. }

258. }

259. }

260. try {

261. ImageIO.write(image, "png", saveFile);

262. } catch (IOException e) {

263. return;

264. }

}

This approach works just as well, as shown in Figure 11.25.

Figure 11.25

Here is the full code for the two classes once more for convenience:

import java.awt.Color;

import java.awt.Point;

import java.awt.event.ActionEvent;

import java.awt.event.ActionListener;

import java.awt.image.BufferedImage;

import java.io.File;

import java.io.FileInputStream;

import java.io.IOException;

import java.util.HashSet;

import java.util.Set;

import javax.imageio.ImageIO;

import javax.swing.JFileChooser;

import javax.swing.JFrame;

import javax.swing.JMenu;

import javax.swing.JMenuBar;

import javax.swing.JMenuItem;

import javax.swing.SwingUtilities;

public class SimplePaint extends JFrame implements ActionListener {

private final String ACTION_NEW = "New Image";

private final String ACTION_LOAD = "Load Image";

private final String ACTION_SAVE = "Save Image";

private final SimplePaintPanel paintPanel = new SimplePaintPanel();

public SimplePaint() {

super();

setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

setTitle("Simple Paint");

initMenu();

this.getContentPane().add(paintPanel);

pack();

setVisible(true);

}

private void initMenu() {

JMenuBar menuBar = new JMenuBar();

JMenu menu = new JMenu("File");

JMenuItem mnuNew = new JMenuItem(ACTION_NEW);

JMenuItem mnuLoad = new JMenuItem(ACTION_LOAD);

JMenuItem mnuSave = new JMenuItem(ACTION_SAVE);

mnuNew.setActionCommand(ACTION_NEW);

mnuLoad.setActionCommand(ACTION_LOAD);

mnuSave.setActionCommand(ACTION_SAVE);

mnuNew.addActionListener(this);

mnuLoad.addActionListener(this);

mnuSave.addActionListener(this);

menu.add(mnuNew);

menu.add(mnuLoad);

menu.add(mnuSave);

menuBar.add(menu);

this.setJMenuBar(menuBar);

}

@Override

public void actionPerformed(ActionEvent ev) {

switch (ev.getActionCommand()) {

case ACTION_NEW:

paintPanel.clear();

break;

case ACTION_LOAD:

doLoadImage();

break;

case ACTION_SAVE:

doSaveImage();

break;

}

}

private void doSaveImage() {

JFileChooser fileChooser = new JFileChooser();

fileChooser.setFileSelectionMode(JFileChooser.FILES_ONLY);

int result = fileChooser.showSaveDialog(this);

if (result != JFileChooser.APPROVE_OPTION)

return;

File saveFile = fileChooser.getSelectedFile();

if (!saveFile.getAbsolutePath().toLowerCase().endsWith(".png"))

saveFile = new File(saveFile.getAbsolutePath() + ".png");

BufferedImage image = new BufferedImage(

paintPanel.getSize().width,

paintPanel.getSize().height,

BufferedImage.TYPE_INT_RGB);

for (int x = 0; x < image.getWidth(); x++) {

for (int y = 0; y < image.getHeight(); y++) {

image.setRGB(x, y, Color.white.getRGB());

if (paintPanel.isPixel(new Point(x, y))) {

image.setRGB(x, y, Color.black.getRGB());

}

}

}

try {

ImageIO.write(image, "png", saveFile);

} catch (IOException e) {

return;

}

}

private void doLoadImage() {

JFileChooser fileChooser = new JFileChooser();

fileChooser.setFileSelectionMode(JFileChooser.FILES_ONLY);

int result = fileChooser.showOpenDialog(this);

if (result != JFileChooser.APPROVE_OPTION)

return;

BufferedImage image;

File openFile = fileChooser.getSelectedFile();

try (FileInputStream fis = new FileInputStream(openFile)) {

image = ImageIO.read(fis);

} catch (IOException e) {

return;

}

if (image == null)

return;

paintPanel.clear();

Set<Point> blackPixels = new HashSet<Point>();

for (int x = 0; x < image.getWidth(); x++) {

for (int y = 0; y < image.getHeight(); y++) {

Color c = new Color(image.getRGB(x, y));

if ((c.getBlue() < 128 || c.getRed() < 128 || c.getGreen() < 128)

&& c.getAlpha() == 255) {

blackPixels.add(new Point(x, y));

}

}

}

paintPanel.addPixels(blackPixels);

}

public static void main(String[] args) {

SwingUtilities.invokeLater(new Runnable() {

public void run() { new SimplePaint(); }

});

}

}

import java.awt.Color;

import java.awt.Dimension;

import java.awt.Graphics;

import java.awt.Point;

import java.awt.event.MouseAdapter;

import java.awt.event.MouseEvent;

import java.util.Collection;

import java.util.HashSet;

import java.util.Set;

import javax.swing.JPanel;

public class SimplePaintPanel extends JPanel {

private final Set<Point> blackPixels = new HashSet<Point>();

private final int brushSize;

private int mouseButtonDown = 0;

public SimplePaintPanel() {

this(5, new HashSet<Point>());

}

public SimplePaintPanel(Set<Point> blackPixels) {

this(5, blackPixels);

}

public SimplePaintPanel(int brushSize, Set<Point> blackPixels) {

this.setPreferredSize(new Dimension(300, 300));

this.brushSize = brushSize;

this.blackPixels.addAll(blackPixels);

final SimplePaintPanel self = this;

MouseAdapter mouseAdapter = new MouseAdapter() {

@Override

public void mouseDragged(MouseEvent ev) {

if (mouseButtonDown == 1)

addPixels(getPixelsAround(ev.getPoint()));

else if (mouseButtonDown == 3)

removePixels(getPixelsAround(ev.getPoint()));

}

@Override

public void mousePressed(MouseEvent ev) {

self.mouseButtonDown = ev.getButton();

}

};

this.addMouseMotionListener(mouseAdapter);

this.addMouseListener(mouseAdapter);

}

public void paint(Graphics g) {

int w = this.getWidth();

int h = this.getHeight();

g.setColor(Color.white);

g.fillRect(0, 0, w, h);

g.setColor(Color.black);

for (Point point : blackPixels)

g.drawRect(point.x, point.y, 1, 1);

}

public void clear() {

this.blackPixels.clear();

this.invalidate();

this.repaint();

}

public void addPixels(Collection<? extends Point> blackPixels) {

this.blackPixels.addAll(blackPixels);

this.invalidate();

this.repaint();

}

public void removePixels(Collection<? extends Point> blackPixels) {

this.blackPixels.removeAll(blackPixels);

this.invalidate();

this.repaint();

}

public boolean isPixel(Point blackPixel) {

return this.blackPixels.contains(blackPixel);

}

private Collection<? extends Point> getPixelsAround(Point point) {

Set<Point> points = new HashSet<>();

for (int x = point.x - brushSize; x < point.x + brushSize; x++)

for (int y = point.y - brushSize; y < point.y + brushSize; y++)

points.add(new Point(x, y));

return points;

}

How It Works

This is how it works:

1. There is a lot going on in this small project. Start by taking a look at the SimplePaint class. The JFrame is set up just like before; a SimplePaintPanel component is added to the content pane, and the initMenu() is called to initialize the menu bar.

2. The initMenu() shows you how you can set up menus with Swing. Note that JFrame has a dedicated area to place menu bars, which you can set and get using the setJMenuBar and getJMenuBar methods. Here, a single File menu entry was created, and three menu items were placed under it.

NOTE The Swing menu components are used here. Menu, MenuBar, MenuItem, setMenuBar, and getMenuBar also exist, but these correspond to the AWT components, which should be considered outdated. The naming is somewhat confusing, but that’s the way it is.

3. You will have noted that it is possible to assign action listeners to menu items. In this project, the SimplePaint class acts as a listener for all menu items as well. The actionPerformed method then determines which method to call based on the action command.

4. The New menu item performs a simple operation and just calls the clear method on the paint panel.

5. Loading an image is a bit more convoluted. First, a JFileChooser is constructed (you could also make this a class field; go ahead and try this if you want) and configured so users can only select files. Next, the showOpenDialog method is called to display an Open File dialog. JFileChooser also has a lot of additional options you can configure, such as filtering which files to show. The result of this method is an integer determining whether the user selected a file or cancelled the dialog, or an error occurred. Next, the getSelectedFile method retrieves your file. Note that JFileChooser still utilizes the legacy File class. Next, a built-in utility class called ImageIO does the heavy lifting regarding reading image files. This class reads in common file formats, such as PNG, JPG, BMP, and GIF files, and returns a BufferedImage object to store the image data. Next, it iterates over all pixels in the image and applies a simple trick to determine whether the pixel color should be converted to a black pixel. Dark colors are converted to black, whereas light colors are not; that is what the if ((c.getBlue() < 128 || c.getRed() < 128 || c.getGreen() < 128) && c.getAlpha() == 255) line does. Once all the black pixels are gathered, the paintPanel object is instructed to add them.

6. The save method works similarly. Here, a fresh image is constructed with the width and height equal to the current width and height of the paint panel. Next, it loops over each pixel again and sets them to black when necessary. Note that some additional logic is applied to make the filename selected with showSaveDialog end in .png, as there is no way to force the JFileChooser to do this for you. (This is because file extensions are just a convention to tell the operating system what the default program should be to open files ending in a particular suffix. There is nothing preventing you from saving a PNG image as image.txt and opening it with an image editor afterward.)

7. Now take a look at the SimplePaintPanel class. This class extends JPanel and implements a mouse and mouse motion event listener by using the MouseAdapter class.

8. The mouse-related methods that are implemented are mouseDragged and mousePressed. The latter determines which button (left or right) is being pressed. When the mouse is dragged, it looks at the mouse button currently being pressed and determines whether black pixels should be added or removed. You might wonder why you can’t just use ev.getButton() in the mouseDragged method to determine which mouse button is being pressed. The reason for this is that this will always return 0, asgetButton() only returns the button number when the state has changed. Since you keep holding down the mouse button whilst dragging, no button state is changing. You can, however, use SwingUtilities.isLeftMouseButton(ev) instead, which will work, but here things were done manually to show off how the mouse event listener works as well.

9. The second interesting aspect to note is the custom paint method for this class. First, the whole panel surface is filled out with white, after which a pixel is drawn for each point in the blackPixels set.

10.Finally, it is important to know that you should tell Java when “my surface has changed; you should draw me again.” This is what is done with the invalidate method. A repaint call is placed right after this to instruct Java to redraw the component (which will have Java make a call to the paint method).

11.You will notice this yourself when drawing quickly; the drawing code is horribly inefficient. There are many reasons for this. First, working with a set of pixels is not ideal, especially not for larger images. Second, Swing components were never really designed to perform high-speed drawing updates, which is what is done here while dragging. In a real painting application, you need to look for better-suited drawing components (those exist). That said, this example helps to explain various concepts, and custom drawing code can still be helpful whenever you know components will not need to be redrawn continuously.

If you want to try to improve this simple painting application (this is a great starter project with the right amount of challenges), here are some suggestions:

· Try using background tasks. Perhaps you don’t need to call for a repaint every time the mouse is moved while dragged; perhaps you can postpone the redraw until the movement has settled down?

· Similarly, instead of adding a set of pixels based on every point the mouse touches while dragging, you can also poll less aggressively and draw line segments between two points the mouse has been. This solves the problem of gaps while drawing quickly, but makes it harder to draw smooth curves when moving quickly.

· Try exploring the java.awt.Canvas component. This component has been specifically designed for custom free-form drawing.

· Finally, you can add a panel with some buttons, such as to select colors and so on. In this case, you might want to drop the set of black pixels and work directly on and with the painting surface. You can also try using a BufferedImage to store your image data directly (and more efficiently).

Visual GUI Designers: Making Life Easy?

Earlier in this chapter, you learned that the GroupLayout and SpringLayout layout managers were originally designed to be used in combination with visual GUI designers. So what are these exactly?

Eclipse, by default, does not come with a visual GUI designer, but you can install one by selecting Install New Software from the Help menu and searching for the WindowBuilder packages, as shown in Figure 11.26.

Figure 11.26

NOTE To make WindowBuilder understand Swing components, you will also need to search for the “Swing Designer” packages and install these as well.

Once the new package is installed (and you restart Eclipse), try creating a new class. Right-click it in the Package Explorer and select Open With WindowBuilder Editor. From this editor, you can switch between a Source and Design tab, as shown in Figure 11.27.

Figure 11.27

When you switch to the Design tab, WindowBuilder will complain about the fact that it cannot figure out that this is a GUI class. No worries; just modify the class to make it a JFrame:

import javax.swing.JFrame;

public class WindowBuilderExample extends JFrame {

public WindowBuilderExample() {

}

}

Open the Design tab once more (select Reparse when nothing appears). You will be presented with the screen shown in Figure 11.28.

Figure 11.28

Here, you can drag and drop components and layouts to your JFrame. Figure 11.29 shows an example after five minutes of tinkering.

Figure 11.29

Note the row of buttons at the top of the designer view, including the one that allows you to quickly test a preview of your component in Figure 11.30.

Figure 11.30

Once you’re done prototyping, you can switch back to the source view and check out the generated code:

import javax.swing.JFrame;

import javax.swing.GroupLayout;

import javax.swing.GroupLayout.Alignment;

import javax.swing.JLabel;

import java.awt.Font;

import javax.swing.LayoutStyle.ComponentPlacement;

import javax.swing.JTextField;

import javax.swing.JComboBox;

import javax.swing.DefaultComboBoxModel;

import javax.swing.JCheckBox;

import javax.swing.JButton;

import java.awt.event.ActionListener;

import java.awt.event.ActionEvent;

public class WindowBuilderExample extends JFrame {

private JTextField textField;

private JTextField textField_1;

public WindowBuilderExample() {

JLabel lblAddEmployee = new JLabel("Add Employee");

lblAddEmployee.setFont(new Font("Tahoma", Font.BOLD, 22));

JLabel lblUsername = new JLabel("Username:");

textField = new JTextField();

textField.setColumns(10);

JLabel lblPassword = new JLabel("Password:");

textField_1 = new JTextField();

textField_1.setColumns(10);

JLabel lblRole = new JLabel("Role:");

JComboBox comboBox = new JComboBox();

comboBox.setModel(new DefaultComboBoxModel(

new String[] {"Intern", "Employee", "Manager"}));

JCheckBox chckbxHasUnlimitedCoffee =

new JCheckBox("Has unlimited coffee access");

JButton btnCancel = new JButton("Cancel");

JButton btnAdd = new JButton("Add");

btnAdd.addActionListener(new ActionListener() {

public void actionPerformed(ActionEvent arg0) {

}

});

GroupLayout groupLayout = new GroupLayout(getContentPane());

groupLayout.setHorizontalGroup(

groupLayout.createParallelGroup(Alignment.LEADING)

.addGroup(groupLayout.createSequentialGroup()

.addGroup(groupLayout.createParallelGroup(Alignment.LEADING)

.addComponent(lblAddEmployee)

.addGroup(groupLayout.createSequentialGroup()

.addGroup(groupLayout.createParallelGroup(Alignment.LEADING)

.addComponent(lblUsername)

.addComponent(lblPassword)

.addComponent(lblRole))

.addGap(54)

.addGroup(groupLayout.createParallelGroup(Alignment.LEADING)

.addComponent(comboBox, GroupLayout.PREFERRED_SIZE,

GroupLayout.DEFAULT_SIZE, GroupLayout.PREFERRED_SIZE)

.addComponent(textField, GroupLayout.DEFAULT_SIZE,

229, Short.MAX_VALUE)

.addComponent(textField_1, GroupLayout.DEFAULT_SIZE,

229, Short.MAX_VALUE)))

.addComponent(chckbxHasUnlimitedCoffee)

.addGroup(groupLayout.createSequentialGroup()

.addContainerGap()

.addComponent(btnCancel)

.addPreferredGap(ComponentPlacement.RELATED)

.addComponent(btnAdd)))

.addContainerGap())

);

groupLayout.setVerticalGroup(

groupLayout.createParallelGroup(Alignment.LEADING)

.addGroup(groupLayout.createSequentialGroup()

.addComponent(lblAddEmployee)

.addPreferredGap(ComponentPlacement.RELATED)

.addGroup(groupLayout.createParallelGroup(Alignment.BASELINE)

.addComponent(lblUsername)

.addComponent(textField, GroupLayout.PREFERRED_SIZE,

GroupLayout.DEFAULT_SIZE, GroupLayout.PREFERRED_SIZE))

.addPreferredGap(ComponentPlacement.RELATED)

.addGroup(groupLayout.createParallelGroup(Alignment.BASELINE)

.addComponent(lblPassword)

.addComponent(textField_1, GroupLayout.PREFERRED_SIZE,

GroupLayout.DEFAULT_SIZE, GroupLayout.PREFERRED_SIZE))

.addPreferredGap(ComponentPlacement.RELATED)

.addGroup(groupLayout.createParallelGroup(Alignment.BASELINE)

.addComponent(lblRole)

.addComponent(comboBox, GroupLayout.PREFERRED_SIZE,

GroupLayout.DEFAULT_SIZE, GroupLayout.PREFERRED_SIZE))

.addPreferredGap(ComponentPlacement.RELATED)

.addComponent(chckbxHasUnlimitedCoffee)

.addPreferredGap(ComponentPlacement.RELATED, 49, Short.MAX_VALUE)

.addGroup(groupLayout.createParallelGroup(Alignment.BASELINE)

.addComponent(btnCancel)

.addComponent(btnAdd))

.addContainerGap())

);

getContentPane().setLayout(groupLayout);

}

}

Well, the result certainly looks complicated. WindowBuilder will do its best to anticipate your further code and will make components such as textfields and class fields so you can access them from other methods and objects when needed (to get and set text). By default, listeners are inlined with anonymous inner classes, but you can change this to real listener objects as well. Be careful when changing around too many things, though, as WindowBuilder might then not be able to convert your changes to a GUI layout it understands. This immediately illustrates both the advantages and disadvantages of visual GUI designers. They provide a great, easy method to quickly prototype a GUI (image building the GUI above by hand), but can lose their head once you start making too many custom changes.

In general, especially when you’re starting out, you are advised not to fall into the luring trap of visual designers promising rapid development. If you can construct your GUI with some nimble nested components and simple layout managers, then by all means go ahead. If you do need to build complex forms and don’t want to waste time laying out everything by hand, WindowBuilder provides a great alternative. The designer is also a helpful way to get acquainted quickly with unfamiliar components.

Finally, it is worth noting that you can also download other plug-ins to make WindowBuilder aware of GUI toolkits other than AWT/Swing, such as SWT. Other IDEs (Netbeans especially) also come with great visual designers, and there are some commercial ones as well (Jvider, JFormDesigner, and others).

JavaFX: The Road Ahead?

Swing has been around for a long time, and although the toolkit is immensely robust, it is starting to show its age. You have seen this already when talking about custom painting, or when taking a look at some of the . . . less nice-looking look and feels. With high-resolution retina displays, smartphones, tablets, rich Internet applications, and hardware-accelerated desktop compositors, the Java community started to desire a more modern UI toolkit. JavaFX was kickstarted to answer this need, and the UI toolkit has been around since 2008. With the release of Java 8, JavaFX became an integral part of the JRE (and JDK), so that the latest version of JavaFX went from 2.2 to simply JavaFX 8.

Sadly, this beginner book can’t go into depth on all aspects of JavaFX, but when you are familiar with Swing, switching to JavaFX, should you want to, doesn’t pose too many hurdles. Answering the question whether you should use JavaFX is not so straightforward. If you’re itching to use the latest and greatest, then by all means go ahead. Keep in mind, however, that the community surrounding JavaFX is still young, so it will be much easier to find Swing-related libraries, support, and help when you need it. Finally, the multitude of GUIs in Java were built and are still being built with Swing, so if you’re looking to apply your skills in a real-life setting, you still need to be acquainted with Swing.

The chapter concludes with two example projects built with JavaFX. In the first example, you’ll learn how to build the BMI calculator again. If you’re following along, you can just copy the old BMICalculator class and throw out anything that has to do with AWT or Swing. You’ll also see a few things commented out so you don’t forget to deal with them later:

public class BMICalculatorFX {

//private final JTextField txtMass = makePrettyTextField();

//private final JTextField txtHeight = makePrettyTextField();

//private final JButton btnCalc = makePrettyButton("Calculate BMI");

public BMICalculatorFX() {

/*

btnCalc.addActionListener(new ActionListener() {

@Override

public void actionPerformed(ActionEvent arg0) {

double mass;

double height;

try {

mass = Double.parseDouble(txtMass.getText());

height = Double.parseDouble(txtHeight.getText());

} catch (NumberFormatException e) {

JOptionPane.showMessageDialog(self,

"Please enter a valid number for mass and height.",

"Input error",

JOptionPane.ERROR_MESSAGE);

return;

}

double result = calculateBMI(mass, height);

JOptionPane.showMessageDialog(self,

"Your BMI is: " + (Math.round(result*100.0)/100.0),

"Your BMI result",

JOptionPane.PLAIN_MESSAGE);

}

});

*/

}

protected double calculateBMI(double mass, double height) {

return mass / Math.pow(height/100.0, 2.0);

}

public static void main(String[] args) {

SwingUtilities.invokeLater(new Runnable() {

public void run() { new BMICalculatorFX(); }

});

}

}

The first thing to do is to figure out a way to show a simple window using JavaFX. In JavaFX, the main actor is called an application, and it can manage and show various stages. For this simple JavaFX application, this leads to the following:

import javafx.application.Application;

import javafx.scene.Group;

import javafx.scene.Scene;

import javafx.stage.Stage;

public class BMICalculatorFX extends Application {

//private final JTextField txtMass = makePrettyTextField();

//private final JTextField txtHeight = makePrettyTextField();

//private final JButton btnCalc = makePrettyButton("Calculate BMI");

public BMICalculatorFX() {

/*

btnCalc.addActionListener(new ActionListener() {

@Override

public void actionPerformed(ActionEvent arg0) {

double mass;

double height;

try {

mass = Double.parseDouble(txtMass.getText());

height = Double.parseDouble(txtHeight.getText());

} catch (NumberFormatException e) {

JOptionPane.showMessageDialog(self,

"Please enter a valid number for mass and height.",

"Input error",

JOptionPane.ERROR_MESSAGE);

return;

}

double result = calculateBMI(mass, height);

JOptionPane.showMessageDialog(self,

"Your BMI is: " + (Math.round(result*100.0)/100.0),

"Your BMI result",

JOptionPane.PLAIN_MESSAGE);

}

});

*/

}

@Override

public void start(Stage stage) throws Exception {

Scene scene = new Scene(new Group());

stage.setTitle("JavaFX BMI Calculator");

stage.setScene(scene);

stage.sizeToScene();

stage.show();

}

protected double calculateBMI(double mass, double height) {

return mass / Math.pow(height/100.0, 2.0);

}

public static void main(String[] args) {

Application.launch(args);

}

}

Note that Eclipse will complain about your JavaFX imports. The reason for this is that they are only part of Oracle’s JRE and other Java implementations might not support this. To solve this warning, right-click your project in the Package Explorer, select Build Path followed by Configure Build Path. In the window that opens, navigate to the Libraries tab and expand the entry for JRE System Library. Select Access Rules and click Edit. Next, add an access rule to make javafx/** accessible, as illustrated in Figure 11.31.

Figure 11.31

Press OK. Your build path window should now look like Figure 11.32.

Figure 11.32

Press OK again. Your project will recompile and the errors should disappear.

You can try running the project now. A window will appear, but it seems to contain absolutely nothing, which is not surprising seeing that you set up an empty scene for the stage:

Scene scene = new Scene(new Group());

Now you can fill this scene with some actors. Just as with Swing, JavaFX also has several layout managers you can use. A simple VBox layout is used here:

import javafx.application.Application;

import javafx.scene.Group;

import javafx.scene.Scene;

import javafx.scene.control.Button;

import javafx.scene.control.Label;

import javafx.scene.control.TextField;

import javafx.scene.layout.VBox;

import javafx.scene.text.Font;

import javafx.stage.Stage;

public class BMICalculatorFX extends Application {

private final TextField txtMass = new TextField();

private final TextField txtHeight = new TextField();

private final Button btnCalc = new Button("Calculate BMI");

public BMICalculatorFX() {

/*

btnCalc.addActionListener(new ActionListener() {

@Override

public void actionPerformed(ActionEvent arg0) {

double mass;

double height;

try {

mass = Double.parseDouble(txtMass.getText());

height = Double.parseDouble(txtHeight.getText());

} catch (NumberFormatException e) {

JOptionPane.showMessageDialog(self,

"Please enter a valid number for mass and height.",

"Input error",

JOptionPane.ERROR_MESSAGE);

return;

}

double result = calculateBMI(mass, height);

JOptionPane.showMessageDialog(self,

"Your BMI is: " + (Math.round(result*100.0)/100.0),

"Your BMI result",

JOptionPane.PLAIN_MESSAGE);

}

});

*/

}

@Override

public void start(Stage stage) throws Exception {

VBox vbox = new VBox(10);

Label lblTitle = new Label("BMI Calculator");

lblTitle.setFont(Font.font(18));

vbox.getChildren().add(lblTitle);

vbox.getChildren().add(new Label("Your mass (kg):"));

vbox.getChildren().add(txtMass);

vbox.getChildren().add(new Label("Your height (cm):"));

vbox.getChildren().add(txtHeight);

vbox.getChildren().add(btnCalc);

Scene scene = new Scene(new Group(vbox));

stage.setTitle("JavaFX BMI Calculator");

stage.setScene(scene);

stage.sizeToScene();

stage.show();

}

protected double calculateBMI(double mass, double height) {

return mass / Math.pow(height/100.0, 2.0);

}

public static void main(String[] args) {

Application.launch(args);

}

}

You’ll notice that the basic concepts are not so different from Swing. Running your project now provides the beautifully crafted window shown in Figure 11.33.

Figure 11.33

Next, you’ll need to add an action handler to the button. Again, the basic concepts are the same—you need to catch interesting UI events and respond to them:

import javafx.application.Application;

import javafx.event.ActionEvent;

import javafx.event.EventHandler;

import javafx.scene.Group;

import javafx.scene.Scene;

import javafx.scene.control.Button;

import javafx.scene.control.Label;

import javafx.scene.control.TextField;

import javafx.scene.layout.VBox;

import javafx.scene.text.Font;

import javafx.stage.Stage;

import javafx.geometry.Pos;

import javafx.scene.layout.HBox;

import javafx.stage.Modality;

import javafx.stage.StageStyle;

public class BMICalculatorFX extends Application {

private Stage stage;

private final TextField txtMass = new TextField();

private final TextField txtHeight = new TextField();

private final Button btnCalc = new Button("Calculate BMI");

@Override

public void start(Stage stage) throws Exception {

this.stage = stage;

VBox vbox = new VBox(10);

Label lblTitle = new Label("BMI Calculator");

lblTitle.setFont(Font.font(18));

vbox.getChildren().add(lblTitle);

vbox.getChildren().add(new Label("Your mass (kg):"));

vbox.getChildren().add(txtMass);

vbox.getChildren().add(new Label("Your height (cm):"));

vbox.getChildren().add(txtHeight);

vbox.getChildren().add(btnCalc);

btnCalc.setOnAction(new EventHandler<ActionEvent>() {

@Override

public void handle(ActionEvent ev) {

double mass;

double height;

try {

mass = Double.parseDouble(txtMass.getText());

height = Double.parseDouble(txtHeight.getText());

} catch (NumberFormatException e) {

showMessage("Check your input.", "Error in number input");

return;

}

double result = calculateBMI(mass, height);

showMessage("Your BMI is: " +

(Math.round(result*100.0)/100.0), "Your BMI result");

}

});

Scene scene = new Scene(new Group(vbox));

stage.setTitle("JavaFX BMI Calculator");

stage.setScene(scene);

stage.sizeToScene();

stage.show();

}

protected double calculateBMI(double mass, double height) {

return mass / Math.pow(height/100.0, 2.0);

}

public static void main(String[] args) {

Application.launch(args);

}

public void showMessage(final String message, final String title) {

final Stage dialog = new Stage(StageStyle.UTILITY);

dialog.setTitle(title);

dialog.setResizable(false);

dialog.initModality(Modality.WINDOW_MODAL);

dialog.initOwner(this.stage);

VBox vbox = new VBox(2);

HBox pane = new HBox(10);

dialog.setScene(new Scene(vbox));

vbox.setAlignment(Pos.CENTER);

vbox.getChildren().add(pane);

pane.getChildren().add(new Label(message));

Button btn = new Button("OK");

btn.setOnAction(new EventHandler<ActionEvent>() {

@Override

public void handle(ActionEvent e) {

dialog.close();

}

});

pane.getChildren().add(btn);

dialog.showAndWait();

}

}

Note that JavaFX does not provide a built-in method to show dialogs (this might be included in future Java updates, though). Here, a simple showMessage method was added that constructs a new stage window to show a message with an OK button. The end result looks like Figure 11.34.

Figure 11.34

As of now, you might appreciate the cleaner coding style and look of JavaFX, but still wonder what the big deal is. Earlier, you read that JavaFX hardware accelerated graphics to allow for more spectacular graphical applications as well. The following and final example (adapted from an Oracle tutorial) shows this in action:

import static java.lang.Math.random;

import javafx.animation.Animation;

import javafx.animation.KeyFrame;

import javafx.animation.KeyValue;

import javafx.animation.Timeline;

import javafx.application.Application;

import javafx.scene.Group;

import javafx.scene.Node;

import javafx.scene.Scene;

import javafx.scene.effect.BlendMode;

import javafx.scene.effect.BoxBlur;

import javafx.scene.paint.Color;

import javafx.scene.paint.CycleMethod;

import javafx.scene.paint.LinearGradient;

import javafx.scene.paint.Stop;

import javafx.scene.shape.Circle;

import javafx.scene.shape.Rectangle;

import javafx.scene.shape.StrokeType;

import javafx.stage.Stage;

import javafx.util.Duration;

public class ScreenSaver extends Application {

public static void main(String[] args) {

launch(args);

}

@Override

public void start(Stage primaryStage) {

Group root = new Group();

Scene scene = new Scene(root, 800, 600, Color.WHITE);

primaryStage.setScene(scene);

Group circles = new Group();

for (int i = 0; i < 500; i++) {

Circle circle = new Circle(30, Color.web("black", 0.10));

circle.setStrokeType(StrokeType.OUTSIDE);

circle.setStroke(Color.web("black", 0.15));

circle.setStrokeWidth(2);

circles.getChildren().add(circle);

}

Rectangle colors = new Rectangle(scene.getWidth(), scene.getHeight(),

new LinearGradient(0f, 1f, 1f, 0f, true, CycleMethod.REPEAT,

new Stop[]{

new Stop(0, Color.web("#f8bd55")),

new Stop(0.14, Color.web("#c0fe56")),

new Stop(0.28, Color.web("#5dfbc1")),

new Stop(0.43, Color.web("#64c2f8")),

new Stop(0.57, Color.web("#be4af7")),

new Stop(0.71, Color.web("#ed5fc2")),

new Stop(0.85, Color.web("#ef504c")),

new Stop(1, Color.web("#f2660f"))}

));

colors.widthProperty().bind(scene.widthProperty());

colors.heightProperty().bind(scene.heightProperty());

Group blendModeGroup = new Group(

new Group(

new Rectangle(scene.getWidth(), scene.getHeight(),

Color.WHITE), circles), colors);

colors.setBlendMode(BlendMode.OVERLAY);

root.getChildren().add(blendModeGroup);

circles.setEffect(new BoxBlur(10, 10, 3));

Timeline timeline = new Timeline();

for (Node circle : circles.getChildren()) {

timeline.getKeyFrames().addAll(

new KeyFrame(Duration.ZERO,

new KeyValue(circle.translateXProperty(),

random() * scene.getWidth()),

new KeyValue(circle.translateYProperty(),

random() * scene.getHeight())),

new KeyFrame(new Duration(60000),

new KeyValue(circle.translateXProperty(),

random() * scene.getWidth()),

new KeyValue(circle.translateYProperty(),

random() * scene.getHeight())));

}

timeline.setCycleCount(Animation.INDEFINITE);

timeline.play();

primaryStage.show();

}

}

Feel free to daydream while JavaFX shows its graphical prowess in Figure 11.35.

Figure 11.35

This concludes the chapter on building graphical interfaces. This has been a lengthy one, and even now, many Swing (and JavaFX) components remain worth taking a closer look at. As such, don’t hesitate to get started building your own GUIs and exploring the Javadocs to hone your skills. Make sure to keep the best practices listed in this chapter in mind—keep logic and looks separated and structure your UI code in a neat manner.

Speaking of best practices, the following chapter will be completely devoted to these, as you delve into the topic of Object-Oriented Programming patterns. It covers best practices to solve common architectural challenges and structure your applications in the best maintainable and understandable way possible, something that will become immensely important as your applications start growing in size and complexity.