Create a Toolbar - Swing

Create a Toolbar

A toolbar is a component that can serve as both an alternative and as an adjunct to a menu. A toolbar contains a list of buttons (or other components) that give the user immediate access to various program options. For example, a toolbar might contain buttons that select various font options, such as bold, italics, highlight, or underline. These options can be selected without needing to drop through a menu. Typically, toolbar buttons show icons rather than text, although either or both are allowed. Furthermore, tooltips are often associated with icon-based toolbar buttons. Toolbars can be positioned on any side of a window by dragging the toolbar, or they can be dragged out of the window entirely, in which case they become free floating.

In Swing, toolbars are instances of the JToolBar class. Its constructors enable you to create a toolbar with or without a title. You can also specify the layout of the toolbar, which will be either horizontal or vertical. The JToolBar constructors are shown here:

JToolBar( ) JToolBar(String title) JToolBar(int how) JToolBar(String title, int how)

The first constructor creates a horizontal toolbar with no title. The second creates a horizontal toolbar with the title specified by title. The title will show only when the toolbar is dragged out of its window. The third creates a toolbar that is oriented as specified by how. The value of how must be either JToolBar.VERTICAL or JToolBar.HORIZONTAL. The fourth constructor creates a toolbar that has the title specified by title and is oriented as specified by how.

A toolbar is typically used with a window that uses a border layout. There are two reasons for this. First, it allows the toolbar to be initially positioned along one of the four border positions. Frequently, the top position is used. Second, it allows the toolbar to be dragged to any side of the window.

In addition to dragging the toolbar to different locations within a window, you can also drag it out of the window. Doing so creates an undocked toolbar. If you specify a title when you create the toolbar, then that title will be shown when the toolbar is undocked.

You add buttons (or other components) to a toolbar in much the same way that you add them to a menu bar. Simply call add( ). The components are shown in the toolbar in the order in which they are added.

Once you have created a toolbar, you do not add it to the menu bar (if one exists). Instead, you add it to the window container. As mentioned, typically you will add a toolbar to the top (that is, north) position of a border layout, using a horizontal orientation. The component that will be affected is added to the center of the border layout. Using this approach causes the program to begin running with the toolbar in the expected location. However, you can drag the toolbar to any of the other positions. Of course, you can also drag the toolbar out of the window.

To illustrate the toolbar, we will add one to the MenuDemo program. The toolbar will present three debugging options: set a breakpoint, clear a breakpoint, and resume program execution. Three steps are needed to add the toolbar.

First, remove this line from the program.

jfrm.setLayout(new FlowLayout());

By removing this line, the JFrame automatically uses a border layout.

Second, because BorderLayout is being used, change the line that adds the label jlab to the frame, as shown next:

jfrm.add(jlab, BorderLayout.CENTER);

This line explicitly adds jlab to the center of the border layout. (Explicitly specifying the center position is technically not necessary because, by default, components are added to the center when a border layout is used. However, explicitly specifying the center makes it clear to anyone reading the code that a border layout is being used and that jlab goes in the center.)

Next, add the following code, which creates the Debug toolbar.

// Create a Debug toolbar.

JToolBar jtb = new JToolBar("Debug");

// Load the images.

ImageIcon set = new ImageIcon("setBP.gif"); ImageIcon clear = new ImageIcon("clearBP.gif"); ImageIcon resume = new ImageIcon("resume.gif");

// Create the toolbar buttons.

JButton jbtnSet = new JButton(set);

jbtnSet.setActionCommand("Set Breakpoint"); jbtnSet.setToolTipText("Set Breakpoint");

JButton jbtnClear = new JButton(clear); jbtnClear.setActionCommand("Clear Breakpoint"); jbtnClear.setToolTipText("Clear Breakpoint");

JButton jbtnResume = new JButton(resume); jbtnResume.setActionCommand("Resume"); jbtnResume.setToolTipText("Resume");

     //Add the buttons to the toolbar.

     jtb.add(jbtnSet); jtb.add(jbtnClear); jtb.add(jbtnResume);

     //Add the toolbar to the north position of

     //the content pane.

jfrm.add(jtb, BorderLayout.NORTH);

Let’s look at this code closely. First, a JToolBar is created and given the title "Debug". Then, a set of ImageIcon objects are created that hold the images for the toolbar buttons. Next, three toolbar buttons are created. Notice that each has an image, but no text. Also, each is explicitly given an action command and a tooltip. The action commands are set because the buttons are not given names when they are constructed. Tooltips are especially useful when applied to icon-based toolbar components because sometimes it’s hard to design images that are intuitive to all users. The buttons are then added to the toolbar, and the toolbar is added to the north side of the border layout of the frame.

Finally, add the action listeners for the toolbar, as shown here:

// Add the toolbar action listeners.

jbtnSet.addActionListener(this); jbtnClear.addActionListener(this); jbtnResume.addActionListener(this);

Each time the user presses a toolbar button, an action event is fired, and it is handled in the same way as the other menu-related events. Figure 33-6 shows the toolbar in action.