Using Menus with Frames

Menus are an integral part of GUIs. Menus allow the user to perform actions without unnecessarily cluttering a GUI with extra components. In Swing GUIs, menus can be attached only to objects of the classes that provide method setJMenuBar. Two such classes are JFrame and JApplet. The classes used to declare menus are JMenuBar, JMenu, JMenuItem, JCheckBoxMenuItem and class JRadioButtonMenuItem.

Look-and-Feel Observation 22.2

Menus simplify GUIs because components can be hidden within them. These components will only be visible when the user looks for them by selecting the menu.

Class JMenuBar (a subclass of JComponent) contains the methods necessary to manage a menu bar, which is a container for menus. Class JMenu (a subclass of javax.swing.JMenuItem) contains the methods necessary for managing menus. Menus contain menu items and are added to menu bars or to other menus as submenus. When a menu is clicked, it expands to show its list of menu items.

Class JMenuItem (a subclass of javax.swing.AbstractButton) contains the methods necessary to manage menu items. A menu item is a GUI component inside a menu that, when selected, causes an action event. A menu item can be used to initiate an action or it can be a submenu that provides more menu items from which the user can select. Submenus are useful for grouping related menu items in a menu.

Class JCheckBoxMenuItem (a subclass of javax.swing.JMenuItem) contains the methods necessary to manage menu items that can be toggled on or off. When a JCheckBoxMenuItem is selected, a check appears to the left of the menu item. When the JCheckBoxMenuItem is selected again, the check is removed.

Class JRadioButtonMenuItem (a subclass of javax.swing.JMenuItem) contains the methods necessary to manage menu items that can be toggled on or off like JCheckBoxMenuItems. When multiple JRadioButtonMenuItems are maintained as part of a ButtonGroup, only one item in the group can be selected at a given time. When a JRadioButtonMenuItem is selected, a filled circle appears to the left of the menu item. When another JRadioButtonMenuItem is selected, the filled circle of the previously selected menu item is removed.

The application in Fig. 22.5 and Fig. 22.6 demonstrates various menu items. The application also demonstrates how to specify special characters called mnemonics that can provide quick access to a menu or menu item from the keyboard. Mnemonics can be used with all subclasses of javax.swing.AbstractButton.

Figure 22.5. JMenus and mnemonics.

(This item is displayed on pages 1012 - 1016 in the print version)

 1 // Fig. 22.5: MenuFrame.java
 2 // Demonstrating menus.
 3 import java.awt.Color;
 4 import java.awt.Font;
 5 import java.awt.BorderLayout;
 6 import java.awt.event.ActionListener;
 7 import java.awt.event.ActionEvent;
 8 import java.awt.event.ItemListener;
 9 import java.awt.event.ItemEvent;
10 import javax.swing.JFrame;
11 import javax.swing.JRadioButtonMenuItem;
12 import javax.swing.JCheckBoxMenuItem; 
13 import javax.swing.JOptionPane;
14 import javax.swing.JLabel;
15 import javax.swing.SwingConstants;
16 import javax.swing.ButtonGroup;
17 import javax.swing.JMenu; 
18 import javax.swing.JMenuItem;
19 import javax.swing.JMenuBar; 
20
21 public class MenuFrame extends JFrame
22 {
23 private final Color colorValues[] =
24 { Color.BLACK, Color.BLUE, Color.RED, Color.GREEN };
25 private JRadioButtonMenuItem colorItems[]; // color menu items 
26 private JRadioButtonMenuItem fonts[]; // font menu items 
27 private JCheckBoxMenuItem styleItems[]; // font style menu items
28 private JLabel displayJLabel; // displays sample text
29 private ButtonGroup fontButtonGroup; // manages font menu items
30 private ButtonGroup colorButtonGroup; // manages color menu items
31 private int style; // used to create style for font
32
33 // no-argument constructor set up GUI
34 public MenuFrame()
35 {
36 super ( "Using JMenus" );
37
38 JMenu fileMenu = new JMenu( "File" ); // create file menu
39 fileMenu.setMnemonic( 'F' ); // set mnemonic to F 
40
41 // create About... menu item
42 JMenuItem aboutItem = new JMenuItem( "About..." ); 
43 aboutItem.setMnemonic( 'A' ); // set mnemonic to A 
44 fileMenu.add( aboutItem ); // add about item to file menu
45 aboutItem.addActionListener(
46
47 new ActionListener() // anonymous inner class
48 {
49 // display message dialog when user selects About...
50 public void actionPerformed( ActionEvent event )
51 {
52 JOptionPane.showMessageDialog( MenuFrame.this,
53 "This is an example
of using menus",
54 "About", JOptionPane.PLAIN_MESSAGE );
55 } // end method actionPerformed
56 } // end anonymous inner class
57 ); // end call to addActionListener
58
59 JMenuItem exitItem = new JMenuItem( "Exit" ); // create exit item
60 exitItem.setMnemonic( 'x' ); // set mnemonic to x 
61 fileMenu.add( exitItem ); // add exit item to file menu 
62 exitItem.addActionListener(
63
64 new ActionListener() // anonymous inner class
65 {
66 // terminate application when user clicks exitItem
67 public void actionPerformed( ActionEvent event )
68 {
69 System.exit( 0 ); // exit application
70 } // end method actionPerformed
71 } // end anonymous inner class
72 ); // end call to addActionListener
73
74 JMenuBar bar = new JMenuBar(); // create menu bar 
75 setJMenuBar( bar ); // add menu bar to application
76 bar.add( fileMenu ); // add file menu to menu bar 
77
78 JMenu formatMenu = new JMenu( "Format" ); // create format menu
79 formatMenu.setMnemonic( 'r' ); // set mnemonic to r 
80
81 // array listing string colors
82 String colors[] = { "Black", "Blue", "Red", "Green" };
83
84 JMenu colorMenu = new JMenu( "Color" ); // create color menu
85 colorMenu.setMnemonic( 'C' ); // set mnemonic to C 
86
87 // create radiobutton menu items for colors
88 colorItems = new JRadioButtonMenuItem[ colors.length ];
89 colorButtonGroup = new ButtonGroup(); // manages colors
90 ItemHandler itemHandler = new ItemHandler(); // handler for colors
91
92 // create color radio button menu items
93 for ( int count = 0 ; count < colors.length; count++ )
94 {
95 colorItems[ count ] = 
96  new JRadioButtonMenuItem( colors[ count ] ); // create item 
97 colorMenu.add( colorItems[ count ] ); // add item to color menu
98 colorButtonGroup.add( colorItems[ count ] ); // add to group 
99 colorItems[ count ].addActionListener( itemHandler );
100 } // end for
101
102 colorItems[ 0 ].setSelected( true ); // select first Color item
103
104 formatMenu.add( colorMenu ); // add color menu to format menu
105 formatMenu.addSeparator(); // add separator in menu 
106
107 // array listing font names
108 String fontNames[] = { "Serif", "Monospaced", "SansSerif" };
109 JMenu fontMenu = new JMenu( "Font" ); // create font menu
110 fontMenu.setMnemonic( 'n' ); // set mnemonic to n 
111
112 // create radiobutton menu items for font names
113 fonts = new JRadioButtonMenuItem[ fontNames.length ]; 
114 fontButtonGroup = new ButtonGroup(); // manages font names
115
116 // create Font radio button menu items
117 for ( int count = 0 ; count < fonts.length; count++ )
118 {
119 fonts[ count ] = new JRadioButtonMenuItem( fontNames[ count ] );
120 fontMenu.add( fonts[ count ] ); // add font to font menu 
121 fontButtonGroup.add( fonts[ count ] ); // add to button group 
122 fonts[ count ].addActionListener( itemHandler ); // add handler
123 } // end for
124
125 fonts[ 0 ].setSelected( true ); // select first Font menu item
126 fontMenu.addSeparator(); // add separator bar to font menu 
127
128 String styleNames[] = { "Bold", "Italic" }; // names of styles
129 styleItems = new JCheckBoxMenuItem[ styleNames.length ];
130 StyleHandler styleHandler = new StyleHandler(); // style handler
131
132 // create style checkbox menu items
133 for ( int count = 0 ; count < styleNames.length; count++ )
134 {
135 styleItems[ count ] = 
136  new JCheckBoxMenuItem( styleNames[ count ] ); // for style
137 fontMenu.add( styleItems[ count ] ); // add to font menu 
138 styleItems[ count ].addItemListener( styleHandler ); // handler
139 } // end for
140
141 formatMenu.add( fontMenu ); // add Font menu to Format menu
142 bar.add( formatMenu ); // add Format menu to menu bar 
143
144 // set up label to display text
145 displayJLabel = new JLabel( "Sample Text", SwingConstants.CENTER );
146 displayJLabel.setForeground( colorValues[ 0 ] );
147 displayJLabel.setFont( new Font( "Serif", Font.PLAIN, 72 ) );
148
149 getContentPane().setBackground( Color.CYAN ); // set background
150 add( displayJLabel, BorderLayout.CENTER ); // add displayJLabel
151 } // end MenuFrame constructor
152
153 // inner class to handle action events from menu items
154 private class ItemHandler implements ActionListener
155 {
156 // process color and font selections
157 public void actionPerformed( ActionEvent event )
158 {
159 // process color selection
160 for ( int count = 0 ; count < colorItems.length; count++ )
161 {
162 if ( colorItems[ count ].isSelected() )
163 {
164 displayJLabel.setForeground( colorValues[ count ] );
165 break ;
166 } // end if
167 } // end for
168
169 // process font selection
170 for ( int count = 0 ; count < fonts.length; count++ )
171 {
172 if ( event.getSource() == fonts[ count ] )
173 {
174 displayJLabel.setFont(
175 new Font( fonts[ count ].getText(), style, 72 ) );
176 } // end if
177 } // end for
178
179 repaint(); // redraw application
180 } // end method actionPerformed
181 } // end class ItemHandler
182
183 // inner class to handle item events from check box menu items
184 private class StyleHandler implements ItemListener
185 {
186 // process font style selections
187 public void itemStateChanged( ItemEvent e )
188 {
189 style = 0 ; // initialize style
190
191 // check for bold selection
192 if ( styleItems[ 0 ].isSelected() )
193 style += Font.BOLD; // add bold to style
194
195 // check for italic selection
196 if ( styleItems[ 1 ].isSelected() )
197 style += Font.ITALIC; // add italic to style
198
199 displayJLabel.setFont(
200 new Font( displayJLabel.getFont().getName(), style, 72 ) );
201 repaint(); // redraw application
202 } // end method itemStateChanged
203 } // end class StyleHandler
204 } // end class MenuFrame

Figure 22.6. Test class for MenuFrame.

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

 1 // Fig. 22.6: MenuTest.java
 2 // Testing MenuFrame.
 3 import javax.swing.JFrame;
 4
 5 public class MenuTest
 6 {
 7 public static void main( String args[] )
 8 {
 9 MenuFrame menuFrame = new MenuFrame(); // create MenuFrame
10 menuFrame.setDefaultCloseOperation( JFrame.EXIT_ON_CLOSE );
11 menuFrame.setSize( 500, 200 ); // set frame size
12 menuFrame.setVisible( true ); // display frame
13 } // end main
14 } // end class MenuTest

 

Class MenuFrame (Fig. 22.5) declares the GUI components and event handling for the menu items. Most of the code in this application appears in the class's constructor (lines 34151).

Lines 3876 set up the File menu and attach it to the menu bar. The File menu contains an About... menu item that displays a message dialog when the menu item is selected and an Exit menu item that can be selected to terminate the application.

Line 38 creates a JMenu and passes to the constructor the string "File" as the name of the menu. Line 39 uses JMenu method setMnemonic (inherited from class AbstractButton) to indicate that F is the mnemonic for this menu. Pressing the Alt key and the letter F opens the menu, just as clicking the menu name with the mouse would. In the GUI, the mnemonic character in the menu's name is displayed with an underline. (See the screen captures in Fig. 22.6)

Look-and-Feel Observation 22.3

Mnemonics provide quick access to menu commands and button commands through the keyboard.

Look-and-Feel Observation 22.4

Different mnemonics should be used for each button or menu item. Normally, the first letter in the label on the menu item or button is used as the mnemonic. If several buttons or menu items start with the same letter, choose the next most prominent letter in the name (e.g., x is commonly chosen for a button or menu item called Exit).

Lines 4243 create JMenuItem aboutItem with the text "About..." and set its mnemonic to the letter A. This menu item is added to fileMenu at line 44 with JMenu method add. To access the About... menu item through the keyboard, press the Alt key and letter F to open the File menu, then press A to select the About... menu item. Lines 4756 create an ActionListener to process aboutItem's action event. Lines 5254 display a message dialog box. In most prior uses of showMessageDialog, the first argument was null. The purpose of the first argument is to specify the parent window that helps determine where the dialog box will be displayed. If the parent window is specified as null, the dialog box appears in the center of the screen. Otherwise, it appears centered over the specified parent window. In this example, the program specifies the parent window with MenuTest.thisthe this reference of the MenuTest object. When using the this reference in an inner class, specifying this by itself refers to the inner-class object. To reference the outer-class object's this reference, qualify this with the outer-class name and a dot (.).

Dialog boxes are typically modal. A modal dialog box does not allow any other window in the application to be accessed until the dialog box is dismissed. The dialogs displayed with class JOptionPane are modal dialogs. Class JDialog can be used to create your own modal or nonmodal dialogs.

Lines 5972 create menu item exitItem, set its mnemonic to x, add it to fileMenu and register an ActionListener that terminates the application when the user selects exitItem.

Lines 7476 create the JMenuBar, attach it to the application window with JFrame method setJMenuBar and use JMenuBar method add to attach the fileMenu to the menu bar.

Common Programming Error 22.3

Forgetting to set the menu bar with JFrame method setJMenuBar results in the menu bar not being displayed on the JFrame.

Look-and-Feel Observation 22.5

Menus appear left to right in the order that they are added to a JMenuBar.

Lines 7879 create menu formatMenu and set its mnemonic to r. (F is not used because that is the File menu's mnemonic.)

Lines 8485 create menu colorMenu (this will be a submenu in the Format menu) and set its mnemonic to C. Line 88 creates JRadioButtonMenuItem array colorItems, which refers to the menu items in colorMenu. Line 89 creates ButtonGroup colorGroup, which will ensure that only one of the menu items in the Color submenu is selected at a time. Line 90 creates an instance of inner class ItemHandler (declared at lines 154181) that responds to selections from the Color and Font submenus (discussed shortly). The for statement at lines 93100 creates each JRadioButtonMenuItem in array colorItems, adds each menu item to colorMenu and to colorGroup and registers the ActionListener for each menu item.

Line 102 invokes AbstractButton method setSelected to select the first element in array colorItems. Line 104 adds colorMenu as a submenu of formatMenu. Line 105 invokes JMenu method addSeparator to add a horizontal separator line to the menu.

Look-and-Feel Observation 22.6

A submenu is created by adding a menu as a menu item in another menu. When the mouse is positioned over a submenu (or the submenu's mnemonic is pressed), the submenu expands to show its menu items.

Look-and-Feel Observation 22.7

Separators can be added to a menu to group menu items logically.

Look-and-Feel Observation 22.8

Any lightweight GUI component (i.e., a component that is a subclass of JComponent) can be added to a JMenu or to a JMenuBar.

Lines 108126 create the Font submenu and several JRadioButtonMenuItems and select the first element of JRadioButtonMenuItem array fonts. Line 129 creates a JCheckBoxMenuItem array to represent the menu items for specifying bold and italic styles for the fonts. Line 130 creates an instance of inner class StyleHandler (declared at lines 184203) to respond to the JCheckBoxMenuItem events. The for statement at lines 133139 creates each JCheckBoxMenuItem, adds each menu item to fontMenu and registers the ItemListener for each menu item. Line 141 adds fontMenu as a submenu of formatMenu. Line 142 adds the formatMenu to bar (the menu bar).

Lines 145147 create a JLabel for which the Format menu items control the font, font color and font style. The initial foreground color is set to the first element of array colorValues (Color.BLACK) by invoking JComponent method setForeground, and the initial font is set to Serif with PLAIN style and 72-point size. Line 149 sets the background color of the window's content pane to cyan, and line 150 attaches the JLabel to the CENTER of the content pane's BorderLayout.

ItemHandler method actionPerformed (lines 157180) uses two for statements to determine which font or color menu item generated the event and sets the font or color of the JLabel displayLabel, respectively. The if condition at line 162 uses AbstractButton method isSelected to determine the selected JRadioButtonMenuItem. The if condition at line 172 invokes the event object's getSource method to get a reference to the JRadioButtonMenuItem that generated the event. Line 175 invokes AbstractButton method getText to obtain the name of the font from the menu item.

The program calls StyleHandler method itemStateChanged (lines 187202) if the user selects a JCheckBoxMenuItem in the fontMenu. Lines 192 and 196 determine whether either or both of the JCheckBoxMenuItems are selected and use their combined state to determine the new style of the font.