Introduction To Java GUI

2
Simplest GUI programming:
JOptionPane
An option pane is a simple dialog box for graphical input/output

• advantages:
– simple
– flexible (in some ways)
– looks better than the black box of doom

• disadvantages:
– created with static methods;
not very object-oriented
– not very powerful (just simple dialog boxes)
 3

Types of JOptionPanes
• public static void showMessageDialog(
Component parent, Object message)
Displays a message on a dialog
with an OK button.

• public static int showConfirmDialog(

Component parent, Object message)
Displays a message and list of
choices Yes, No, Cancel

• public static String showInputDialog(

Component parent, Object message)
Displays a message and text
field for input, and returns the
value entered as a String.
 4

JOptionPane examples 1
• showMessageDialog analogous to
System.out.println for displaying a simple
message

import javax.swing.*;

class MessageDialogExample {
public static void main(String[] args) {
JOptionPane.showMessageDialog(null,
"How's the weather?");
JOptionPane.showMessageDialog(null,
"Second message");
}
}
 5

JOptionPane examples 2
• showConfirmDialog analogous to a
System.out.print that prints a question, then reading
an input value from the user (can only be one of the provided
choices)
import javax.swing.*;

class ConfirmDialogExample {
public static void main(String[] args) {
int choice = JOptionPane.showConfirmDialog(null,
"Erase your hard disk?");
if (choice == JOptionPane.YES_OPTION) {
JOptionPane.showMessageDialog(null, "Disk erased!");
} else {
JOptionPane.showMessageDialog(null, "Cancelled.");
}
}
}
 6

JOptionPane examples 3
• showInputDialog analogous to a
System.out.print that prints a question, then reading
an input value from the user (can be any value)

import javax.swing.*;

class InputDialogExample {
public static void main(String[] args) {
String name = JOptionPane.showInputDialog(null,
"What's yer name, pardner?");
JOptionPane.showMessageDialog(null, "Yeehaw, " + name);
}
}
 Swing Overview
• Swing component inheritance hierarchy
java.lang.Object

java.awt.Component

java.awt.Container

javax.swing.JComponent

• Component defines methods that can be used in its subclasses

(for example, paint and repaint)
• Container - collection of related components
– When using JFrames, attach components to the content
pane (a Container)
– Method add to add components to content pane
• JComponent - superclass to most Swing components
• Much of a component's functionality inherited from these
classes
 JLabel

• Labels
– Provide text instructions on a GUI
– Read-only text
– Programs rarely change a label's contents
– Class JLabel (subclass of JComponent)
• Methods
– Can declare label text in constructor
– myLabel.setToolTipText( "Text" )
• Displays "Text"in a tool tip when mouse over label
– myLabel.setText( "Text" )
– myLabel.getText()
 JLabel

• Icon
– Object that implements interface Icon
– One class is ImageIcon (.gif and .jpeg images)
– Display an icon with setIcon method (of class JLabel)
• myLabel.setIcon( myIcon );
• myLabel.getIcon //returns current Icon
• Alignment
– Set of integer constants defined in interface
SwingConstants (javax.swing)
• SwingConstants.LEFT
• Use with JLabel methods
setHorizontalTextPosition and
setVerticalTextPosition
1 // Fig. 29.4: LabelTest.java
2 // Demonstrating the JLabel class.
3 import javax.swing.*;
4 import java.awt.*;
5 import java.awt.event.*;
6 1. import
7 public class LabelTest extends JFrame {
8 private JLabel label1, label2, label3;
9
1.1 extend JFrame
10 public LabelTest()
11 { 1.2 Declarations
12 super( "Testing JLabel" );
13
14 Container c = getContentPane(); 1.3 Create container to
15 c.setLayout( new FlowLayout() ); hold labels
16
17 // JLabel constructor with a string argument
18 label1 = new JLabel( "Label with text" ); 1.4 Initialize JLabels
“
19 label1.setToolTipText( "This is label1" );
20 c.add( label1 );
21
22 // JLabel constructor with string, Icon and
23 // alignment arguments
24 Icon bug = new ImageIcon( "bug1.gif" );
25 label2 = new JLabel( "Label with text and icon",
26 bug, SwingConstants.LEFT );
27 label2.setToolTipText( "This is label2" );
28 c.add( label2 );
29
30 // JLabel constructor no arguments
31 label3 = new JLabel();
32 label3.setText( "Label with icon and text at bottom" );
33 label3.setIcon( bug );
34 label3.setHorizontalTextPosition(
35 SwingConstants.CENTER );
36 label3.setVerticalTextPosition( 1.4 Initialize JLabels
37 SwingConstants.BOTTOM );
38 label3.setToolTipText( "This is label3" );
39 c.add( label3 );
40
41 setSize( 275, 170 );
42 show();
43 }
44
45 public static void main( String args[] )
46 {
47 LabelTest app = new LabelTest();
48
57 }
58 }

<Anchor0>
Program Output
 JTextArea

• Area for manipulating multiple lines of text

– Like JTextField, inherits from JTextComponent
– Many of the same methods
• JScrollPane
– Provides scrolling
– Initialize with component
• new JScrollPane( myComponent )
– Can set scrolling policies (always, as needed, never)
• See book for details
 JTextArea
• Box container
– Uses BoxLayout layout manager
– Arrange GUI components horizontally or vertically
– Box b = Box.createHorizontalbox();
• Arranges components attached to it from left to right, in order
attached
 1 // Fig. 29.9: TextAreaDemo.java
2 // Copying selected text from one text area to another.
3 import java.awt.*;
4 import java.awt.event.*;
5 import javax.swing.*;
6 1. import
7 public class TextAreaDemo extends JFrame {
8 private JTextArea t1, t2;
9 private JButton copy; 1.1 Declarations
10
11 public TextAreaDemo()
1.2 Create Box container
12 {
13 super( "TextArea Demo" );
14 1.3 Add JScrollPane
15 Box b = Box.createHorizontalBox();
16
17 String s = "This is a demo string to\n" + 1.4 Create button and use
18 "illustrate copying text\n" + inner
Initialize JScrollPane class
to t1 andfor event
attach
19 "from one TextArea to \n" + to Box b handling
20 "another TextArea using an\n"+
21 "external event\n";
22
23 t1 = new JTextArea( s, 10, 15 );
24 b.add( new JScrollPane( t1 ) );
25
26 copy = new JButton( "Copy >>>" );
27 copy.addActionListener(
28 new ActionListener() {
29 public void actionPerformed( ActionEvent e )
30 {
31 t2.setText( t1.getSelectedText() );
32 }
33 }
34 );
35 b.add( copy );
36
37 t2 = new JTextArea( 10, 15 );
2. main
38 t2.setEditable( false );
39 b.add( new JScrollPane( t2 ) );
40
41 Container c = getContentPane();
42 c.add( b );
43 setSize( 425, 200 );
44 show();
45 }
46
47 public static void main( String args[] )
48 {
49 TextAreaDemo app = new TextAreaDemo();
50
59 }
60 }
Program Output
 JTextField and JPasswordField

• JTextFields and JPasswordFields

– Single line areas in which text can be entered or displayed
– JPasswordFields show inputted text as *
– JTextField extends JTextComponent
• JPasswordField extends JTextField
• When Enter pressed
– ActionEvent occurs
– Currently active field "has the focus"
• Methods
– Constructor
• JTextField( 10 ) - sets textfield with 10 columns of text
• JTextField( "Hi" ) - sets text, width determined
automatically
 JTextField and JPasswordField

• Methods (continued)
– setEditable( boolean )
• If true, user can edit text
– getPassword
• Class JPasswordField
• Returns password as an array of type char
• Example
– Create JTextFields and a JPasswordField
– Create and register an event handler
• Displays a dialog box when Enter pressed
 JButton

• Button
– Component user clicks to trigger an action
– Several types of buttons
• Command buttons, toggle buttons, check boxes, radio buttons
• Command button
– Generates ActionEvent when clicked
– Created with class JButton
• Inherits from class AbstractButton
• Jbutton
– Text on face called button label
– Each button should have a different label
– Support display of Icons
 JButton

• Constructors
Jbutton myButton = new JButton( "Button" );
Jbutton myButton = new JButton( "Button",
myIcon );
• Method
– setRolloverIcon( myIcon )
• Sets image to display when mouse over button
 JCheckBox

• State buttons
– JToggleButton
• Subclasses JCheckBox, JRadioButton
– Have on/off (true/false) values
• Initialization
– JCheckBox myBox = new JCheckBox( "Title" );
• When JCheckBox changes
– ItemEvent generated
• Handled by an ItemListener, which must define
itemStateChanged
– Register with addItemListener
 JCheckBox (II)

• ItemEvent methods
– getStateChange
• Returns ItemEvent.SELECTED or
ItemEvent.DESELECTED
 JComboBox

• Combo box (drop down list)

– List of items, user makes a selection
– Class JComboBox
• Generate ItemEvents
• JComboBox
– Numeric index keeps track of elements
• First element added at index 0
• First item added is appears as currently selected item when
combo box appears
 JComboBox (II)

• Methods
– getSelectedIndex
• Returns the index of the currently selected item
– setMaximumRowCount( n )
• Set the maximum number of elements to display when user
clicks combo box
• Scrollbar automatically provided
Demo
 29.4 Event Handling Model

• GUIs are event driven

– Generate events when user interacts with GUI
• Mouse movements, mouse clicks, typing in a text field, etc.
– Event information stored in object that extends AWTEvent
• To process an event
– Register an event listener
• Object from a class that implements an event-listener interface
(from java.awt.event or javax.swing.event)
• "Listens" for events
– Implement event handler
• Method that is called in response to an event
• Each event handling interface has one or more event handling
methods that must be defined
 29.4 Event Handling Model

• Delegation event model

– Use of event listeners in event handling
– Processing of event delegated to particular object
• When an event occurs
– GUI component notifies its listeners
• Calls listener's event handling method
• Example:
– Enter pressed in a JTextField
– Method actionPerformed called for registered listener
– Details in following section
 1 // Fig. 29.7: TextFieldTest.java
2 // Demonstrating the JTextField class.
3 import java.awt.*;
4 import java.awt.event.*;
5 import javax.swing.*;
6 1. import
7 public class TextFieldTest extends JFrame {
8 private JTextField text1, text2, text3;
9 private JPasswordField password; 1.1 Declarations
10
11 public TextFieldTest() 1.2 Constructor
12 {
13 super( "Testing JTextField and JPasswordField" );
14 1.3 GUI components
15 Container c = getContentPane();
16 c.setLayout( new FlowLayout() );
17
1.4 Initialize text fields
18 // construct textfield with default sizing
19 text1 = new JTextField( 10 );
20 c.add( text1 );
21
22 // construct textfield with default text
23 text2 = new JTextField( "Enter text here" );
24 c.add( text2 );
25
26 // construct textfield with default text and
27 // 20 visible elements and no event handler
28 text3 = new JTextField( "Uneditable text field", 20 );
29 text3.setEditable( false );
30 c.add( text3 );
31
32 // construct textfield with default text
33 password = new JPasswordField( "Hidden text" );
34 c.add( password );
35
36 TextFieldHandler handler = new TextFieldHandler(); 2. main
37 text1.addActionListener( handler );
38 text2.addActionListener( handler );
39 text3.addActionListener( handler );
40 password.addActionListener( handler );
41
42 setSize( 325, 100 );
43 show();
44 }
45
46 public static void main( String args[] )
47 {
48 TextFieldTest app = new TextFieldTest();
49
50 app.addWindowListener(
51 new WindowAdapter() {
52 public void windowClosing( WindowEvent e )
53 {
54 System.exit( 0 );
55 }
56 }
57 );
58 }
59
60 // inner class for event handling
61 private class TextFieldHandler implements ActionListener {
62 public void actionPerformed( ActionEvent e )
63 {
64 String s = "";
65
3. TextFieldHandler
66 if ( e.getSource() == text1 )
implements
e.getSource() returns a Component
67 s = "text1: " + e.getActionCommand();
reference, which is cast to a ActionListener
68 else if ( e.getSource() == text2 )
69
JPasswordField
s = "text2: " + e.getActionCommand();
70 else if ( e.getSource() == text3 ) 3.1 Display dialog box
71 s = "text3: " + e.getActionCommand();
72 else if ( e.getSource() == password ) {
73 JPasswordField pwd =
74 (JPasswordField) e.getSource();
75 s = "password: " +
76 new String( pwd.getPassword() );
77 }
78
79 JOptionPane.showMessageDialog( null, s );
80 }
81 }
82 }
Program Output
 29.5.1How Event Handling Works

• Registering event listeners

– All JComponents contain an object of class
EventListenerList called listenerList
– When text1.addActionListener( handler )
executes
• New entry placed into listenerList
• Handling events
– When event occurs, has an event ID
• Component uses this to decide which method to call
• If ActionEvent, then actionPerformed called (in all
registered ActionListeners)
 1 // Fig. 29.11: ButtonTest.java
2 // Creating JButtons.
3 import java.awt.*;
4 import java.awt.event.*;
5 import javax.swing.*;
6 1. import
7 public class ButtonTest extends JFrame {
8 private JButton plainButton, fancyButton;
9 1.1 Declarations
10 public ButtonTest()
11 {
1.2 Initialize buttons and
12 super( "Testing Buttons" );
13
Icons
14 Container c = getContentPane();
15 c.setLayout( new FlowLayout() ); 1.3 Register event
16
handler
17 // create buttons
18 plainButton = new JButton( "Plain Button" );
19 c.add( plainButton );
20
21 Icon bug1 = new ImageIcon( "bug1.gif" );
22 Icon bug2 = new ImageIcon( "bug2.gif" );
23 fancyButton = new JButton( "Fancy Button", bug1 );
24 fancyButton.setRolloverIcon( bug2 );
25 c.add( fancyButton );
26
27 // create an instance of inner class ButtonHandler
28 // to use for button event handling
29 ButtonHandler handler = new ButtonHandler();
30 fancyButton.addActionListener( handler );
31 plainButton.addActionListener( handler );
32
33 setSize( 275, 100 );
34 show();
35 }
36 2. main
37 public static void main( String args[] )
38 {
3. Event handler
39 ButtonTest app = new ButtonTest();
40
41 app.addWindowListener(
42 new WindowAdapter() {
43 public void windowClosing( WindowEvent e )
44 {
45 System.exit( 0 );
46 }
47 }
48 );
49 }
50
51 // inner class for button event handling
52 private class ButtonHandler implements ActionListener {
53 public void actionPerformed( ActionEvent e )
54 {
55 JOptionPane.showMessageDialog( null,
56 "You pressed: " + e.getActionCommand() );
57 }
58 }
59 }
Program Output
 1 // Fig. 29.12: CheckBoxTest.java
2 // Creating Checkbox buttons.
3 import java.awt.*;
4 import java.awt.event.*;
5 import javax.swing.*;
6 1. import
7 public class CheckBoxTest extends JFrame {
8 private JTextField t;
9 private JCheckBox bold, italic; 1.1 Declarations
10
11 public CheckBoxTest() 1.2 Initialization
12 {
13 super( "JCheckBox Test" );
14 1.3 Register event
15 Container c = getContentPane(); handler
16 c.setLayout(new FlowLayout());
17
18 t = new JTextField( "Watch the font style change", 20 );
19 t.setFont( new Font( "TimesRoman", Font.PLAIN, 14 ) );
20 c.add( t );
21
22 // create checkbox objects
23 bold = new JCheckBox( "Bold" );
24 c.add( bold );
25
26 italic = new JCheckBox( "Italic" );
27 c.add( italic );
28
29 CheckBoxHandler handler = new CheckBoxHandler();
30 bold.addItemListener( handler );
31 italic.addItemListener( handler );
32
33 addWindowListener(
34 new WindowAdapter() {
35 public void windowClosing( WindowEvent e )
36 { 2. main
37 System.exit( 0 );
38 }
39 } 3. Event handler
40 ); CheckBoxHandler
41
42 setSize( 275, 100 );
43 show();
44 }
45 Because CheckBoxHandler implements
46 public static void main( String args[] ) ItemListener, it must define method
47 { itemStateChanged
48 new CheckBoxTest();
49 }
50
51 private class CheckBoxHandler implements ItemListener {
52 private int valBold = Font.PLAIN;
53 private int valItalic = Font.PLAIN;
54
55 public void itemStateChanged( ItemEvent e )
56 {
57 if ( e.getSource() == bold )
58 if ( e.getStateChange() == ItemEvent.SELECTED )
59 valBold = Font.BOLD;
60 else
61 valBold = Font.PLAIN;
62
63 if ( e.getSource() == italic )
64 if ( e.getStateChange() == ItemEvent.SELECTED )
65 valItalic = Font.ITALIC;
66 else 3. Event handler
67 valItalic = Font.PLAIN; CheckBoxHandler
68
69 t.setFont(
70 new Font( "TimesRoman", valBold + valItalic, 14 ) );
71 t.repaint();
72 }
73 }
74 }

Program Output
 1 // Fig. 29.13: ComboBoxTest.java
2 // Using a JComboBox to select an image to display.
3 import java.awt.*;
4 import java.awt.event.*;
5 import javax.swing.*;
6 1. import
7 public class ComboBoxTest extends JFrame {
8 private JComboBox images;
9 private JLabel label; 1.1 Initialization
10 private String names[] =
11 { "bug1.gif", "bug2.gif", 1.2 Constructor
12 "travelbug.gif", "buganim.gif" };
13 private Icon icons[] =
14 { new ImageIcon( names[ 0 ] ), 1.3 Initialize JComboBox
15 new ImageIcon( names[ 1 ] ),
16 new ImageIcon( names[ 2 ] ),
17 new ImageIcon( names[ 3 ] ) };
1.4 Register
18 ItemListener
19 public ComboBoxTest()
20 {
21 super( "Testing JComboBox" );
22
23 Container c = getContentPane();
24 c.setLayout( new FlowLayout() );
25
26 images = new JComboBox( names );
27 images.setMaximumRowCount( 3 );
28
29 images.addItemListener(
30 new ItemListener() {
31 public void itemStateChanged( ItemEvent e )
32 {
33 label.setIcon(
34 icons[ images.getSelectedIndex() ] );
35 }
36 } 1.5 Event handler
37 );
38
39 c.add( images ); 2. main
40
41 label = new JLabel( icons[ 0 ] );
42 c.add( label );
43
44 setSize( 350, 100 );
45 show();
46 }
47
48 public static void main( String args[] )
49 {
50 ComboBoxTest app = new ComboBoxTest();
51
52 app.addWindowListener(
53 new WindowAdapter() {
54 public void windowClosing( WindowEvent e )
55 {
56 System.exit( 0 );
57 }
58 }
59 );
60 }
61 }
Program Output
 29.10 Mouse Event Handling

• Mouse events
– Can be trapped for any GUI component derived from
java.awt.Component
– Mouse event handling methods
• Take a MouseEvent object
– Contains info about event, including x and y coordinates
– Methods getX and getY
– MouseListener and MouseMotionListener
methods called automatically (if component is registered)
• addMouseListener
• addMouseMotionListener
 29.10 Mouse Event Handling (II)

• Interface methods for MouseListener and

MouseMotionListener
MouseListener a n d MouseMotionListener in te rfa c e m e th o d s

public void mousePressed( MouseEvent e ) // MouseListener

Called when a mouse button is pressed with the mouse cursor on a component.
public void mouseClicked( MouseEvent e ) // MouseListener
Called when a mouse button is pressed and released on a component without moving the
mouse cursor.
public void mouseReleased( MouseEvent e ) // MouseListener
Called when a mouse button is released after being pressed. This event is always preceded
by a mousePressed event.
public void mouseEntered( MouseEvent e ) // MouseListener
Called when the mouse cursor enters the bounds of a component.
public void mouseExited( MouseEvent e ) // MouseListener
Called when the mouse cursor leaves the bounds of a component.
public void mouseDragged( MouseEvent e ) // MouseMotionListener
Called when the mouse button is pressed and the mouse is moved. This event is always
preceded by a call to mousePressed.
public void mouseMoved( MouseEvent e ) // MouseMotionListener
Called when the mouse is moved with the mouse cursor on a component.
 1 // Fig. 29.15: MouseTracker.java
2 // Demonstrating mouse events.
3
4 import java.awt.*;
5 import java.awt.event.*;
6 import javax.swing.*; 1. import
7
8 public class MouseTracker extends JFrame
9 implements MouseListener, MouseMotionListener { 1.1 Implements
10 private JLabel statusBar; MouseListener,
11 MouseMotionListener
12 public MouseTracker()
13 {
14 super( "Demonstrating Mouse Events" );
1.2 Register event
15 handlers (this)
16 statusBar = new JLabel();
17 getContentPane().add( statusBar, BorderLayout.SOUTH );
1.3 Define event handler
18
methods
19 // application listens to its own mouse events
20 addMouseListener( this );
21 addMouseMotionListener( this );
22
23 setSize( 275, 100 );
24 show();
25 }
26
27 // MouseListener event handlers
28 public void mouseClicked( MouseEvent e )
29 {
30 statusBar.setText( "Clicked at [" + e.getX() +
30 statusBar.setText( "Clicked at [" + e.getX() +
31 ", " + e.getY() + "]" );
32 }
33
34 public void mousePressed( MouseEvent e )
35 { 1.3 Define event handler
36 statusBar.setText( "Pressed at [" + e.getX() + methods
37 ", " + e.getY() + "]" );
38 }
39
40 public void mouseReleased( MouseEvent e )
41 {
42 statusBar.setText( "Released at [" + e.getX() +
43 ", " + e.getY() + "]" );
44 }
45
46 public void mouseEntered( MouseEvent e )
47 {
48 statusBar.setText( "Mouse in window" );
49 }
50
51 public void mouseExited( MouseEvent e )
52 {
53 statusBar.setText( "Mouse outside window" );
54 }
55
56 // MouseMotionListener event handlers
57 public void mouseDragged( MouseEvent e )
58 {
59 statusBar.setText( "Dragged at [" + e.getX() +
60 ", " + e.getY() + "]" );
61 }
62
63 public void mouseMoved( MouseEvent e )
64 {
65 statusBar.setText( "Moved at [" + e.getX() +
66 ", " + e.getY() + "]" ); 1.3 Define event handler
67 } methods
68
69 public static void main( String args[] )
70 { 2. main
71 MouseTracker app = new MouseTracker();
72
73 app.addWindowListener(
74 new WindowAdapter() {
75 public void windowClosing( WindowEvent e )
76 {
77 System.exit( 0 );
78 }
79 }
80 );
81 }
82 }
Program Output
 29.11 Layout Managers

• Layout managers
– Arrange GUI components on a container
– Provide basic layout capabilities
• Easier to use than determining exact size and position of every
component
• Programmer concentrates on "look and feel" rather than details
 29.11.1 FlowLayout

• Most basic layout manager

– Components placed left to right in order added
– When edge of container reached, continues on next line
– Components can be left-aligned, centered (default), or right-
aligned
• Method
– setAlignment
• FlowLayout.LEFT, FlowLayout.CENTER,
FlowLayout.RIGHT
– layoutContainer( Container )
• Update Container specified with layout
 1 // Fig. 29.17: FlowLayoutDemo.java
2 // Demonstrating FlowLayout alignments.
3 import java.awt.*;
4 import java.awt.event.*;
5 import javax.swing.*;
6 1. import
7 public class FlowLayoutDemo extends JFrame {
8 private JButton left, center, right;
9 private Container c; 1.1 Declarations
10 private FlowLayout layout;
11
1.2 Initialize layout
12 public FlowLayoutDemo()
13 {
14 super( "FlowLayout Demo" ); 1.3 Create buttons and
15
event handlers
16 layout = new FlowLayout();
17
18 c = getContentPane();
19 c.setLayout( layout );
20
21 left = new JButton( "Left" );
22 left.addActionListener(
23 new ActionListener() {
24 public void actionPerformed( ActionEvent e )
25 {
26 layout.setAlignment( FlowLayout.LEFT );
27
28 // re-align attached components
29 layout.layoutContainer( c );
30 }
31 }
32 );
33 c.add( left );
34
35 center = new JButton( "Center" );
36 center.addActionListener( 1.3 Create buttons and
37 new ActionListener() { event handlers
38 public void actionPerformed( ActionEvent e )
39 {
40 layout.setAlignment( FlowLayout.CENTER );
41
42 // re-align attached components
43 layout.layoutContainer( c );
44 }
45 }
46 );
47 c.add( center );
48
49 right = new JButton( "Right" );
50 right.addActionListener(
51 new ActionListener() {
52 public void actionPerformed( ActionEvent e )
53 {
54 layout.setAlignment( FlowLayout.RIGHT );
55
56 // re-align attached components
57 layout.layoutContainer( c );
58 }
59 }
60 );
61 c.add( right );
62
63 setSize( 300, 75 );
64 show();
65 }
66 2. main
67 public static void main( String args[] )
68 {
69 FlowLayoutDemo app = new FlowLayoutDemo();
70
71 app.addWindowListener(
72 new WindowAdapter() {
73 public void windowClosing( WindowEvent e )
74 {
75 System.exit( 0 );
76 }
77 }
78 );
79 }
80 }

Program Output
 29.11.2 BorderLayout

• BorderLayout
– Default manager for content pane
– Arrange components into 5 regions
• North, south, east, west, center
– Up to 5 components can be added directly
• One for each region
– Components placed in
• North/South - Region is as tall as component
• East/West - Region is as wide as component
• Center - Region expands to take all remaining space
 29.11.2 BorderLayout

• Methods
– Constructor: BorderLayout( hGap, vGap );
• hGap - horizontal gap space between regions
• vGap - vertical gap space between regions
• Default is 0 for both
– Adding components
• myLayout.add( component, position )
• component - component to add
• position - BorderLayout.NORTH
– SOUTH, EAST, WEST, CENTER similar
– setVisible( boolean ) ( in class Jbutton)
• If false, hides component
– layoutContainer( container ) - updates
container, as before
1 // Fig. 29.18: BorderLayoutDemo.java
2 // Demonstrating BorderLayout.
3 import java.awt.*;
4 import java.awt.event.*;
5 import javax.swing.*;
6 1. import
7 public class BorderLayoutDemo extends JFrame
8 implements ActionListener {
9 private JButton b[];
1.1 Declarations
10 private String names[] =
11 { "Hide North", "Hide South", "Hide East", 1.2 Initialize layout
12 "Hide West", "Hide Center" };
13 private BorderLayout layout;
14 1.3 Register event
15 public BorderLayoutDemo() handler
16 {
17 super( "BorderLayout Demo" );
18
19 layout = new BorderLayout( 5, 5 );
20
21 Container c = getContentPane();
22 c.setLayout( layout );
23
24 // instantiate button objects
25 b = new JButton[ names.length ];
26
27 for ( int i = 0; i < names.length; i++ ) {
28 b[ i ] = new JButton( names[ i ] );
29 b[ i ].addActionListener( this );
30 }
31
32 // order not important
33 c.add( b[ 0 ], BorderLayout.NORTH ); // North position
34 c.add( b[ 1 ], BorderLayout.SOUTH ); // South position
35 c.add( b[ 2 ], BorderLayout.EAST ); // East position
36 c.add( b[ 3 ], BorderLayout.WEST ); // West position
1.4 Add components to
container
37 c.add( b[ 4 ], BorderLayout.CENTER ); // Center position
38
39 setSize( 300, 200 ); 1.5 Event handler
40 show();
41 }
42 2. main
43 public void actionPerformed( ActionEvent e )
44 {
45 for ( int i = 0; i < b.length; i++ )
46 if ( e.getSource() == b[ i ] )
47 b[ i ].setVisible( false );
48 else
49 b[ i ].setVisible( true );
50
51 // re-layout the content pane
52 layout.layoutContainer( getContentPane() );
53 }
54
55 public static void main( String args[] )
56 {
57 BorderLayoutDemo app = new BorderLayoutDemo();
58
59 app.addWindowListener(
60 new WindowAdapter() {
61 public void windowClosing( WindowEvent e )

62 {
63 System.exit( 0 );
64 }
65 }
66 );
67 }
68 }
Program Output
 29.11.3 GridLayout

• GridLayout
– Divides container into a grid
– Components placed in rows and columns
– All components have same width and height
• Added starting from top left, then from left to right
• When row full, continues on next row, left to right
• Constructors
– GridLayout( rows, columns, hGap, vGap )
• Specify number of rows and columns, and horizontal and
vertical gaps between elements (in pixels)
– GridLayout( rows, columns )
• Default 0 for hGap and vGap
 29.11.3 GridLayout

• Updating containers
– Container method validate
• Re-layouts a container for which the layout has changed
– Example:
Container c = getContentPane;
c.setLayout( myLayout );
if ( x = 3 ){
c.setLayout( myLayout2 );
c.validate();
}
• Changes layout and updates c if condition met
1 // Fig. 29.19: GridLayoutDemo.java
2 // Demonstrating GridLayout.
3 import java.awt.*;
4 import java.awt.event.*;
5 import javax.swing.*;
6 1. import
7 public class GridLayoutDemo extends JFrame
8 implements ActionListener {
9 private JButton b[]; 1.1 Declarations
10 private String names[] =
11 { "one", "two", "three", "four", "five", "six" };
1.2 Initialize layout
12 private boolean toggle = true;
13 private Container c;
14 private GridLayout grid1, grid2; 1.3 Register event
15
handler
16 public GridLayoutDemo()
17 {
18 super( "GridLayout Demo" );
19
20 grid1 = new GridLayout( 2, 3, 5, 5 );
21 grid2 = new GridLayout( 3, 2 );
22
23 c = getContentPane();
24 c.setLayout( grid1 );
25
26 // create and add buttons
27 b = new JButton[ names.length ];
28
29 for (int i = 0; i < names.length; i++ ) {
30 b[ i ] = new JButton( names[ i ] );
31 b[ i ].addActionListener( this );
32 c.add( b[ i ] );
33 }
34
35 setSize( 300, 150 );
36 show();
37 }
1.4 Add components to
38
39 public void actionPerformed( ActionEvent e ) container
40 {
41 if ( toggle )
42 c.setLayout( grid2 );
1.5 Define event handler
43 else
44 c.setLayout( grid1 );
1.6 Update layout
45
46 toggle = !toggle;
(c.validate())
47 c.validate();
48 }
49
50 public static void main( String args[] ) 2. main
51 {
52 GridLayoutDemo app = new GridLayoutDemo();
53
54 app.addWindowListener(
55 new WindowAdapter() {
56 public void windowClosing( WindowEvent e )
57 {
58 System.exit( 0 );
59 }
60 }
61 );
62 }
63 }
Program Output
 29.12 Panels

• Complex GUIs
– Each component needs to be placed in an exact location
– Can use multiple panels
• Each panel's components arranged in a specific layout
• Panels
– Class JPanel inherits from JComponent, which inherits
from java.awt.Container
• Every JPanel is a Container
– JPanels can have components (and other JPanels)
added to them
• JPanel sized to components it contains
• Grows to accommodate components as they are added
 29.12 Panels

• Usage
– Create panels, and set the layout for each
– Add components to the panels as needed
– Add the panels to the content pane (default
BorderLayout)
 1 // Fig. 29.20: PanelDemo.java
2 // Using a JPanel to help lay out components.
3 import java.awt.*;
4 import java.awt.event.*;
5 import javax.swing.*;
6 1. import
7 public class PanelDemo extends JFrame {
8 private JPanel buttonPanel;
9 private JButton buttons[]; 1.1 Declarations
10
11 public PanelDemo()
12 { 1.2 Initialize
13 super( "Panel Demo" ); buttonPanel
14
15 Container c = getContentPane();
1.3 Panel uses
16 buttonPanel = new JPanel();
17 buttons = new JButton[ 5 ]; GridLayout
18
19 buttonPanel.setLayout(
1.4 Add components to
20 new GridLayout( 1, buttons.length ) );
21
panel
22 for ( int i = 0; i < buttons.length; i++ ) {
23 buttons[ i ] = new JButton( "Button " + (i + 1) ); 1.5 Add panel to content
24 buttonPanel.add( buttons[ i ] ); pane (BorderLayout.
25 } SOUTH)
26
27 c.add( buttonPanel, BorderLayout.SOUTH );
28
29 setSize( 425, 150 );
30 show();
31 }
32
33 public static void main( String args[] )
34 {
35 PanelDemo app = new PanelDemo();
36
2. main
37 app.addWindowListener(
38 new WindowAdapter() {
39 public void windowClosing( WindowEvent e )

40 {
41 System.exit( 0 );
42 }
43 }
44 );
45 }
46 }

Program Output
 29.13 Creating a Self-Contained Subclass of
JPanel

• JPanel
– Can be used as a dedicated drawing area
• Receive mouse events
• Can extend to create new components
– Combining Swing GUI components and drawing can lead to
improper display
• GUI may cover drawing, or may be able to draw over GUI
components
– Solution: separate the GUI and graphics
• Create dedicated drawing areas as subclasses of JPanel
 29.13 Creating a Self-Contained Subclass of
JPanel (II)

• Swing components inheriting from JComponent

– Contain method paintComponent
• Helps to draw properly in a Swing GUI
– When customizing a JPanel, override paintComponent
public void paintComponent( Graphics g )
{
super.paintComponent( g );
//additional drawing code
}
– Call to superclass paintComponent ensures painting occurs in
proper order
• The call should be the first statement - otherwise, it will erase
any drawings before it
 29.13 Creating a Self-Contained Subclass of
JPanel (III)

• JFrame and JApplet

– Not subclasses of JComponent
• Do not contain paintComponent
– Override paint to draw directly on subclasses
• Events
– JPanels do not create events like buttons
– Can recognize lower-level events
• Mouse and key events
 29.13 Creating a Self-Contained Subclass of
JPanel (IV)

• Example
– Create a subclass of JPanel named
SelfContainedPanel that listens for its own mouse
events
• Draws an oval on itself (overrides paintComponent)
– Import SelfContainedPanel into another class
• The other class contains its own mouse handlers
– Add an instance of SelfContainedPanel to the content
pane
1 // Fig. 29.21: SelfContainedPanelTest.java
2 // Creating a self-contained subclass of JPanel
3 // that processes its own mouse events.
4 import java.awt.*;
5 import java.awt.event.*;
6 import javax.swing.*; 1. import
7 import com.deitel.chtp3.ch29.SelfContainedPanel;
SelfContainedPanel
8
9 public class SelfContainedPanelTest extends JFrame {
10 private SelfContainedPanel myPanel; 1.1 Create object
11
12 public SelfContainedPanelTest()
13 {
1.2 Add to content pane
14 myPanel = new SelfContainedPanel();
15 myPanel.setBackground( Color.yellow ); 1.3 Mouse event handler
16
17 Container c = getContentPane();
for application window
18 c.setLayout( new FlowLayout() );
19 c.add( myPanel );
20
21 addMouseMotionListener(
22 new MouseMotionListener() {
23 public void mouseDragged( FMouseEvent e )
24 {
25 setTitle( "Dragging: x=" + e.getX() +
26 "; y=" + e.getY() );
27 }
28
29 public void mouseMoved( MouseEvent e )
30 {
31 setTitle( "Moving: x=" + e.getX() +
32 "; y=" + e.getY() );
33 }
34 }
35 );
36 1.3 Mouse event handler
37 setSize( 300, 200 ); for application window
38 show();
39 }
40 2. main
41 public static void main( String args[] )
42 {
43 SelfContainedPanelTest app =
44 new SelfContainedPanelTest();
45
46 app.addWindowListener(
47 new WindowAdapter() {
48 public void windowClosing( WindowEvent e )
49 {
50 System.exit( 0 );
51 }
52 }
53 );
54 }
55 }
56 // Fig. 29.21: SelfContainedPanel.java
57 // A self-contained JPanel class that
58 // handles its own mouse events.
59 package com.deitel.chtp3.ch29;
60
61 import java.awt.*; Class
62 import java.awt.event.*; SelfContainedPanel
63 import javax.swing.*;
64
65 public class SelfContainedPanel extends JPanel { 1. extends JPanel
66 private int x1, y1, x2, y2;
67
1.1 Mouse event handler
68 public SelfContainedPanel()
69 {
70 addMouseListener(
71 new MouseAdapter() {
72 public void mousePressed( MouseEvent e )
73 {
74 x1 = e.getX();
75 y1 = e.getY();
76 }
77
78 public void mouseReleased( MouseEvent e )
79 {
80 x2 = e.getX();
81 y2 = e.getY();
82 repaint();
83 }
84 }
85 );
86
87 addMouseMotionListener(
88 new MouseMotionAdapter() {
89 public void mouseDragged( MouseEvent e )
90 {
91 x2 = e.getX(); 1.1 Mouse event handler
92 y2 = e.getY();
93 repaint();
94 } 2. Override
95 } paintComponent
96 );
97 }
98
99 public Dimension getPreferredSize()
100 {
101 return new Dimension( 150, 100 );
102 }
103
104 public void paintComponent( Graphics g )
105 {
106 super.paintComponent( g );
107
108 g.drawOval( Math.min( x1, x2 ), Math.min( y1, y2 ),
109 Math.abs( x1 - x2 ), Math.abs( y1 - y2 ) );
110 }
111 }
Program Output
 29.14 Windows
• JFrame
– Inherits from java.awt.Frame, which inherits from
java.awt.Window
– JFrame is a window with a title bar and a border
• Not a lightweight component - not written completely in Java
• Window part of local platform's GUI components
– Different for Windows, Macintosh, and UNIX
• JFrame operations when user closes window
– Controlled with method setDefaultCloseOperation
• Interface WindowConstants (javax.swing) has three
constants to use
• DISPOSE_ON_CLOSE, DO_NOTHING_ON_CLOSE,
HIDE_ON_CLOSE (default)
 29.14 Windows (II)

• Windows take up valuable resources

– Explicitly remove windows when not needed with method
dispose (of class Window, indirect superclass of
JFrame)
• Or, use setDefaultCloseOperation
– DO_NOTHING_ON_CLOSE - you determine what happens
when user wants to close window
• Display
– By default, window not displayed until method show called
– Can display by calling method setVisible( true )
– Method setSize - make sure to set a window's size,
otherwise only the title bar will appear
 29.14 Windows (III)

• All windows generate window events

– addWindowListener
– WindowListener interface has 7 methods
• windowActivated
• windowClosed (called after window closed)
• windowClosing (called when user initiates closing)
• windowDeactivated
• windowIconified (minimized)
• windowDeiconified
• windowOpened
 29.15 Using Menus with Frames

• Menus
– Important part of GUIs
– Perform actions without cluttering GUI
– Attached to objects of classes that have method
setJMenuBar
• JFrame and JApplet
• Classes used to define menus
– JMenuBar - container for menus, manages menu bar
– JMenuItem - manages menu items
• Menu items - GUI components inside a menu
• Can initiate an action or be a submenu
 29.15 Using Menus with Frames (II)

• Classes used to define menus (continued)

– JMenu - manages menus
• Menus contain menu items, and are added to menu bars
• Can be added to other menus as submenus
• When clicked, expands to show list of menu items
– JCheckBoxMenuItem
• Manages menu items that can be toggled
• When selected, check appears to left of item
– JRadioButtonMenuItem
• Manages menu items that can be toggled
• When multiple JRadioButtonMenuItems are part of a
group, only one can be selected at a time
• When selected, filled circle appears to left of item
 29.15 Using Menus with Frames (III)

• Mnemonics
– Provide quick access to menu items (File)
• Can be used with classes that have subclass
javax.swing.AbstractButton
– Use method setMnemonic
JMenu fileMenu = new JMenu( "File" )
fileMenu.setMnemonic( 'F' );
• Press Alt + F to access menu
• Methods
– setSelected( true )
• Of class AbstractButton
• Sets button/item to selected state
 29.15 Using Menus with Frames (IV)

• Methods (continued)
– addSeparator()
• Class JMenu
• Inserts separator line into menu
• Dialog boxes
– Modal - No other window can be accessed while it is open
(default)
• Modeless - other windows can be accessed
– JOptionPane.showMessageDialog( parentWindow,
String, title, messageType )
– parentWindow - determines where dialog box appears
• null - displayed at center of screen
• window specified - dialog box centered horizontally over parent
 29.15 Using Menus with Frames (V)

• Using menus
– Create menu bar
• Set menu bar for JFrame ( setJMenuBar( myBar ); )
– Create menus
• Set Mnemonics
– Create menu items
• Set Mnemonics
• Set event handlers
– If using JRadioButtonMenuItems
• Create a group: myGroup = new ButtonGroup();
• Add JRadioButtonMenuItems to the group
 29.15 Using Menus with Frames (VI)

• Using menus (continued)

– Add menu items to appropriate menus
• myMenu.add( myItem );
• Insert separators if necessary: myMenu.addSeparator();
– If creating submenus, add submenu to menu
• myMenu.add( mySubMenu );
– Add menus to menu bar
• myMenuBar.add( myMenu );
• Example
– Use menus to alter text in a JLabel
– Change color, font, style
– Have a "File" menu with a "About" and "Exit" items
1 // Fig. 29.22: MenuTest.java
2 // Demonstrating menus
3 import javax.swing.*;
4 import java.awt.event.*;
5 import java.awt.*;
6 1. import
7 public class MenuTest extends JFrame {
8 private Color colorValues[] =
9 { Color.black, Color.blue, Color.red, Color.green }; 1.1 extends JFrame
10 private JRadioButtonMenuItem colorItems[], fonts[];
11 private JCheckBoxMenuItem styleItems[]; 1.2 Declare objects
12 private JLabel display;
13 private ButtonGroup fontGroup, colorGroup;
14 private int style; 1.3 Create menubar
15
16 public MenuTest()
17 { 1.4 Set menubar for
18 super( "Using JMenus" ); JFrame
19
20 JMenuBar bar = new JMenuBar(); // create menubar
21 setJMenuBar( bar ); // set the menubar for the JFrame 2. Create File menu
22
23 // create File menu and Exit menu item 2.1 Create menu item
24 JMenu fileMenu = new JMenu( "File" );
25 fileMenu.setMnemonic( 'F' );
26 JMenuItem aboutItem = new JMenuItem( "About..." ); 2.2 Event handler
27 aboutItem.setMnemonic( 'A' );
28 aboutItem.addActionListener(
29 new ActionListener() {
30 public void actionPerformed( ActionEvent e )
31 {
32 JOptionPane.showMessageDialog( MenuTest.this,
33 "This is an example\nof using menus",
34 "About", JOptionPane.PLAIN_MESSAGE );
35 }
2.2 Event handler
36 }
37 );
38 fileMenu.add( aboutItem ); 2.3 Add menu item
39
40 JMenuItem exitItem = new JMenuItem( "Exit" );
41 exitItem.setMnemonic( 'x' ); 2.4 Create menu item
42 exitItem.addActionListener(
43 new ActionListener() {
44 public void actionPerformed( ActionEvent e ) 2.5 Event handler
45 {
46 System.exit( 0 ); 2.6 Add menu item
47 }
48 }
49 ); 2.7 Add menu to
50 fileMenu.add( exitItem ); menubar
51 bar.add( fileMenu ); // add File menu
52
53 // create the Format menu, its submenus and menu items 3. Create Format menu
54 JMenu formatMenu = new JMenu( "Format" );
55 formatMenu.setMnemonic( 'r' );
56
57 // create Color submenu
58 String colors[] =
59 { "Black", "Blue", "Red", "Green" };
60 JMenu colorMenu = new JMenu( "Color" );
61 colorMenu.setMnemonic( 'C' );
62 colorItems = new JRadioButtonMenuItem[ colors.length ];
63 colorGroup = new ButtonGroup();
64 ItemHandler itemHandler = new ItemHandler();
65
66 for ( int i = 0; i < colors.length; i++ ) { 3.1 Create menu items
67 colorItems[ i ] =
68 new JRadioButtonMenuItem( colors[ i ] );
3.2 Add menu items to
69 colorMenu.add( colorItems[ i ] );
Color submenu
70 colorGroup.add( colorItems[ i ] );
71 colorItems[ i ].addActionListener( itemHandler );
72 } 3.3 Register event
73 handler
74 colorItems[ 0 ].setSelected( true );
75 formatMenu.add( colorMenu );
76 formatMenu.addSeparator(); 3.4 Add Color submenu
77 to Format menu
78 // create Font submenu
79 String fontNames[] =
80 { "TimesRoman", "Courier", "Helvetica" }; 4. Create Font submenu
81 JMenu fontMenu = new JMenu( "Font" );
82 fontMenu.setMnemonic( 'n' );
83 fonts = new JRadioButtonMenuItem[ fontNames.length ]; 4.1 Create and add menu
84 fontGroup = new ButtonGroup(); items
85
86 for ( int i = 0; i < fonts.length; i++ ) {
87 fonts[ i ] =
88 new JRadioButtonMenuItem( fontNames[ i ] );
89 fontMenu.add( fonts[ i ] );
90 fontGroup.add( fonts[ i ] );
91 fonts[ i ].addActionListener( itemHandler );
92 }
93
94 fonts[ 0 ].setSelected( true );
95 fontMenu.addSeparator();
96 4.1 Create and add menu
97 String styleNames[] = { "Bold", "Italic" };
items
98 styleItems = new JCheckBoxMenuItem[ styleNames.length ];
99 StyleHandler styleHandler = new StyleHandler();
100 4.2 Add Font submenu to
101 for ( int i = 0; i < styleNames.length; i++ ) { Format menu
102 styleItems[ i ] =
103 new JCheckBoxMenuItem( styleNames[ i ] );
5. Create JLabel (text
104 fontMenu.add( styleItems[ i ] );
105 styleItems[ i ].addItemListener( styleHandler );
to be modified)
106 }
107 5.1 Add to content pane
108 formatMenu.add( fontMenu );
109 bar.add( formatMenu ); // add Format menu
110
111 display = new JLabel(
112 "Sample Text", SwingConstants.CENTER );
113 display.setForeground( colorValues[ 0 ] );
114 display.setFont(
115 new Font( "TimesRoman", Font.PLAIN, 72 ) );
116
117 getContentPane().setBackground( Color.cyan );
118 getContentPane().add( display, BorderLayout.CENTER );
119
120 setSize( 500, 200 );
121 show();
122 }
123
124 public static void main( String args[] )
125 {
126 MenuTest app = new MenuTest();
6. main
127
128 app.addWindowListener(
129 new WindowAdapter() { 7. Event handler
130 public void windowClosing( WindowEvent e )
131 {
132 System.exit( 0 );
133 }
134 }
135 );
136 }
137
138 class ItemHandler implements ActionListener {
139 public void actionPerformed( ActionEvent e )
140 {
141 for ( int i = 0; i < colorItems.length; i++ )
142 if ( colorItems[ i ].isSelected() ) {
143 display.setForeground( colorValues[ i ] );
144 break;
145 }
146
147 for ( int i = 0; i < fonts.length; i++ )
148 if ( e.getSource() == fonts[ i ] ) {
149 display.setFont( new Font(
150 fonts[ i ].getText(), style, 72 ) );
151 break;
152 }
153
154 repaint();
155 }
156 } 8. Event handler
157
158 class StyleHandler implements ItemListener {
159 public void itemStateChanged( ItemEvent e )
160 {
161 style = 0;
162
163 if ( styleItems[ 0 ].isSelected() )
164 style += Font.BOLD;
165
166 if ( styleItems[ 1 ].isSelected() )
167 style += Font.ITALIC;
168
169 display.setFont( new Font(
170 display.getFont().getName(), style, 72 ) );
171
172 repaint();
173 }
174 }
175 }
Program Output