Wrap-Up | GUI Components: Part 1

Table of contents:

Answers to Self Review Exercises

11.1	a) `mouseMoved`. b) uneditable (read-only). c) layout manager. d) `Container`. e) graphical user interface. f) `setLayout`. g) `mousePressed, mouseReleased`. h) `JOptionPane`. i) `showInputDialog, JOptionPane`. j) `showMessageDialog, JOptionPane`. k) `JTextComponent`.
11.2	True. False. Method `mouseEntered` is called. False. A `JPanel` can be added to another `JPanel`, because `JPanel` is an indirect subclass of `Component`. Therefore, a `JPanel` is a `Component`. Any `Component` can be added to a `Container`. False. Only the last button added will be displayed. Remember that only one component should be added to each region in a `BorderLayout`. True. False. Inner classes have access to all members of the enclosing class declaration. False. `JTextArea`s are editable by default. False. `JTextArea` derives from class `JTextComponent`.
11.3	`new` is needed to create an object. `JLabel` is a class name and cannot be used as a variable name. The arguments passed to the constructor are reversed. The `String` must be passed first. `BorderLayout` has been set, and components are being added without specifying the region so both are added to the center region. Proper `add` statements might be container.add( button1, BorderLayout.NORTH ); container.add( button2, BorderLayout.SOUTH );

Exercises

11.4	Fill in the blanks in each of the following statements: The `JTextField` class directly extends class __________. Container method __________ attaches a GUI component to a container. Method __________ is called when a mouse button is released (without moving the mouse). The __________ class is used to create a group of `JRadioButton`s.
11.5	Determine whether each statement is true or false. If false, explain why. Only one layout manager can be used per `Container`. GUI components can be added to a `Container` in any order in a `BorderLayout`. `JRadioButton`s provide a series of mutually exclusive options (i.e., only one can be `true` at a time). `Graphics` method `setFont` is used to set the font for text fields. A `JList` displays a scrollbar if there are more items in the list than can be displayed. A `Mouse` object has a method called `mouseDragged`.
11.6	Determine whether each statement is true or false. If false, explain why. A `JPanel` is a `JComponent`. A `JPanel` is a `Component`. A `JLabel` is a `Container`. A `JList` is a `JPanel`. An `AbstractButton` is a `JButton`. A `JTextField` is an `Object`. `ButtonGroup` is a subclass of `JComponent`.

11.7	Find any errors in each of the following lines of code, and explain how to correct them. import `javax.swing.JFrame` `panelObject.GridLayout(` 8, 8 `)`; // set GridLayout `container.setLayout(` new `FlowLayout(` FlowLayout.DEFAULT `) )`; `container.add( eastButton`, EAST `)`; // BorderLayout
11.8	Create the following GUI. You do not have to provide any functionality.
11.9	Create the following GUI. You do not have to provide any functionality.
11.10	Create the following GUI. You do not have to provide any functionality.
11.11	Create the following GUI. You do not have to provide any functionality.
11.12	Write a temperature conversion application that converts from Fahrenheit to Celsius. The Fahrenheit temperature should be entered from the keyboard (via a `JTextField`). A `JLabel` should be used to display the converted temperature. Use the following formula for the conversion:

11.13	Enhance the temperature conversion application of Exercise 11.12 by adding the Kelvin temperature scale. The application should also allow the user to make conversions between any two scales. Use the following formula for the conversion between Kelvin and Celsius (in addition to the formula in Exercise 11.12):
11.14	Write an application that displays events as they occur in a `JTextArea`. Provide a `JComboBox` with a minimum of four items. The user should be able to choose an event to monitor from the `JComboBox`. When that particular event occurs, display information about the event in the `JTextArea`. Use method `to String` on the event object to convert it to a string representation.
11.15	Write an application that plays "guess the number" as follows: Your application chooses the number to be guessed by selecting an integer at random in the range 11000. The application then displays the following in a label: I have a number between 1 and 1000. Can you guess my number? Please enter your first guess. A `JTextField` should be used to input the guess. As each guess is input, the background color should change to either red or blue. Red indicates that the user is getting "warmer," and blue indicates that the user is getting "colder." A `JLabel` should display either `"Too High"` or `"Too Low"` to help the user zero in on the correct answer. When the user gets the correct answer, `"Correct!"` should be displayed, and the `JTextField` used for input should be changed to be uneditable. A `JButton` should be provided to allow the user to play the game again. When the `JButton` is clicked, a new random number should be generated and the input `JTextField` changed to be editable.
11.16	It is often useful to display the events that occur during the execution of an application. This can help you understand when the events occur and how they are generated. Write an application that enables the user to generate and process every event discussed in this chapter. The application should provide methods from the `ActionListener`, `ItemListener`, `ListSelectionListener`, `MouseListener`, `MouseMotionListener` and `KeyListener` interfaces to display messages when the events occur. Use method `toString` to convert the event objects received in each event handler into a `String` that can be displayed. Method `toString` creates a `String` containing all the information in the event object.
11.17	Modify the application of Section 6.10 to provide a GUI that enables the user to click a `JButton` to roll the dice. The application should also display four `JLabel`s and four `JTextFields`, with one `JLabel` for each `JTextField`. The `JTextFields` should be used to display the values of each die and the sum of the dice after each roll. The point should be displayed in the fourth `JTextField` when the user does not win or lose on the first roll and should continue to be displayed until the game is lost.

(Optional) GUI and Graphics Case Study Exercise: Expanding the Interface

11.18

In this exercise, you will implement a GUI application that uses the MyShape hierarchy from Exercise 10.10 to create an interactive drawing application. You will create two classes for the GUI and provide a test class that launches the application. The classes of the MyShape hierarchy require no additional changes.

The first class to create is a subclass of JPanel called DrawPanel, which represents the area on which the user draws the shapes. Class DrawPanel should have the following instance variables:

An array shapes of type MyShape that will store all the shapes the user draws.
An integer shapeCount that counts the number of shapes in the array.
An integer shapeType that determines the type of shape to draw.
A MyShape currentShape that represents the current shape the user is drawing.
A Color currentColor that represents the current drawing color.
A boolean filledShape that determines whether to draw a filled shape.
A JLabel statusLabel that represents the status bar. The status bar will display the coordinates of the current mouse position.

Class DrawPanel should also declare the following methods:

Overridden method paintComponent that draws the shapes in the array. Use instance variable shapeCount to determine how many shapes to draw. Method paintComponent should also call currentShape's draw method, provided that currentShape is not null.
Set methods for the shapeType, currentColor and filledShape.
Method clearLastShape should clear the last shape drawn by decrementing instance variable shapeCount. Ensure that shapeCount is never less than zero.
Method clearDrawing should remove all the shapes in the current drawing by setting shapeCount to zero.

Methods clearLastShape and clearDrawing should call method repaint (inherited from JPanel) to refresh the drawing on the DrawPanel by indicating that the system should call method paintComponent.

Class DrawPanel should also provide event handling to enable the user to draw with the mouse. Create a single inner class that both extends MouseAdapter and implements MouseMotionListener to handle all mouse events in one class.

In the inner class, override method mousePressed so that it assigns currentShape a new shape of the type specified by shapeType and initializes both points to the mouse position. Next, override method mouseReleased to finish drawing the current shape and place it in the array. Set the second point of currentShape to the current mouse position and add currentShape to the array. Instance variable shapeCount determines the insertion index. Set currentShape to null and call method repaint to update the drawing with the new shape.

Override method mouseMoved to set the text of the statusLabel so that it displays the mouse coordinatesthis will update the label with the coordinates every time the user moves (but does not drag) the mouse within the DrawPanel. Next, override method mouseDragged so that it sets the second point of the currentShape to the current mouse position and calls method repaint. This will allow the user to see the shape while dragging the mouse. Also, update the JLabel in mouseDragged with the current position of the mouse.

Create a constructor for DrawPanel that has a single JLabel parameter. In the constructor, initialize statusLabel with the value passed to the parameter. Also initialize array shapes with 100 entries, shapeCount to 0, shapeType to the value that represents a line, currentShape to null and currentColor to Color.BLACK. The constructor should then set the background color of the DrawPanel to Color.WHITE and register the MouseListener and MouseMotionLister so the JPanel properly handles mouse events.

Next, create a JFrame subclass called DrawFrame that provides a GUI that enables the user to control various aspects of drawing. For the layout of the DrawFrame, we recommend a BorderLayout, with the components in the NORTH region, the main drawing panel in the CENTER region, and a status bar in the SOUTH region, as in Fig. 11.49. In the top panel, create the components listed below. Each component's event handler should call the appropriate method in class DrawPanel.

Figure 11.49. Interface for drawing shapes.

(This item is displayed on page 594 in the print version)

A button to undo the last shape drawn.
A button to clear all shapes from the drawing.
A combo box for selecting the color from the 13 predefined colors.
A combo box for selecting the shape to draw.
A check box that specifies whether a shape should be filled or unfilled.

Declare and create the interface components in DrawFrame's constructor. You will need to create the status bar JLabel before you create the DrawPanel, so you can pass the JLabel as an argument to DrawPanel's constructor. Finally, create a test class that initializes and displays the DrawFrame to execute the application.