Building the About Dialog

Java


	Log In \| Not a Member?	Contact ADC

Building the About Dialog

File: AboutDialog.java

Contents

Overview

1) Declare the dialog controls

2) Setting up the dialog

3) Setting up the label and placing it in the layout

4) Setting up the "OK" button and placing it in the layout

5) Responding to clicks from the OK button

6) Creating an inner class to handle action events

7) Registering our action listener

8) Implementing setVisible( )

Summary

Overview

About Dialog This file creates a dialog which is made visible when the user selects the About SlideShow… item from the Apple Menu. This class is a subclass of java.awt.Dialog, and registers a listener to dismiss the dialog when the OK button is pressed.

This file has two methods. The first is a constructor which specifies the dialog size, position, creates the OK button and the label, and other properties. The second is the setVisible( ) method which is called to change the state of the dialog’s visibility.

Steps to Follow

At the top of the file, we import packages we will use in this file (in this case, for simplicity, we import the entire java.awt package, and a couple classes we need for event handling), and declare our about dialog class.

Importing packages and classes allows us to abbreviate class names later on in the file. For instance, since we imported the entire java.awt package, when we make reference to classes in that package we do not need to specify the fully qualified package name. Instead, we can simply refer to the class by its immediate name. Thus, when we declare a java.awt.Label object, we only need to specify label as the class name. One might ask why not import all the packages all the time so anything that might be needed would be available. Importing a lot of files slows down the compiler since it needs to search for each class referred to in a large list. So then, why not import each class needed explicitly? This tends to make the top of the file unsightly and unnecessarily complex. Deciding when to import an entire package versus a collection of classes from a package is a judgement call. A good rule of thumb is if you are importing four or more classes from one package, go ahead and import the package instead.

import java.awt.*; 
Import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

public class AboutDialog extends Dialog
{

    //DECLARE_CONTROLS        
    //Insert "AboutDialog Declare Controls"

Locate the AboutDialog Declare Controls clipping in the AboutDialog folder and drag it directly below the last line of code shown above. Your code should now look like this:

import java.awt.*; 
Import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

public class AboutDialog extends Dialog
{
    //DECLARE_CONTROLS        
    //Insert "AboutDialog Declare Controls"

    Label label1;
    Button okButton;

We have now declared two variables. The label1 variable represents a Label component, and the okButton variable represents a Button component.

We now define the constructor for the AboutDialog class. This constructor takes two parameters, a Frame object which is the creator of the dialog, and a Boolean which specifies whether the dialog is modal or not. We pass these parameters off to the superclass (java.awt.Dialog) constructor so that we can take advantage of the default behavior of the dialog class.

public AboutDialog(Frame parent, Boolean modal)
{
    super(parent, modal);
    //INIT_CONTROLS

    //Setting up the dialog the way we want it.
    //Insert "AboutDialog Dialog Setup"

Now we are ready to set up the dialog. Locate the AboutDialog Dialog Setup clipping in the AboutDialog folder and drag it directly below the last line of code shown above. Your code should now look like this:

public AboutDialog(Frame parent, Boolean modal)
{
    super(parent, modal);
    //INIT_CONTROLS
    
    //Setting up the dialog the way we want it.
    //Insert "AboutDialog Dialog Setup"

    GridBagLayout gridBagLayout;
    gridBagLayout = new GridBagLayout( );
    setLayout(gridBagLayout);
    setVisible(false);
    setSize(277,100);
    setBackground(new Color(15724527));
    setTitle("About...");
    setResizable(false);

The new dialog setup code creates a new GridBagLayout layout manager. A layout manager is a class that is responsible for the placement of objects in a container. GridBagLayout is one of the most flexible layout managers, but its flexibility comes at the price of complexity. For the purpose of this tutorial, we will not be examining GridBagLayout in detail. Please see the JavaSoft web site for a tutorial on GridBagLayout.

Once the layout manager is created, setVisible(false) is called to ensure the dialog is not initially visible. The dialog is set to the required size, a light gray background color is specified, the title is specified, and the dialog is made non-resizable, as a matter of personal preference.

Now that we have specified the basic properties of the dialog, we are ready to create the label and define its characteristics.

    setTitle("About...");
    setResizable(false);

    //Setting up label1 and placing it in the layout
    //Insert "AboutDialog label1 Setup"

Locate the AboutDialog label1 Setup clipping in the AboutDialog folder and drag it directly below the last line of code shown above. Your code should now look like this:

    setTitle("About...");
    setResizable(false);

    //Setting up label1 and placing it in the layout
    //Insert "AboutDialog label1 Setup"

    label1 = new Label("This is my cool SlideShow 
                        Application!",Label.CENTER);
    GridBagConstraints gbc;
    gbc = new GridBagConstraints( );
    gbc.gridx = 1;
    gbc.gridy = 1;
    gbc.fill = GridBagConstraints.NONE;
    gbc.insets = new Insets(0,0,0,0);
    ((GridBagLayout)getLayout( )).setConstraints(label1, gbc);
    add(label1);

The first step is to create a new java.awt.Label object and assign it to the label1 variable we previously declared. We pass the Label constructor the text to display and specify “Label.CENTER” as the horizontal alignment. This will cause the label to be drawn centered within its bounds.

We now set up the GridBagConstraints and add the label to the dialog.

The next item to be added is the okButton.

    ((GridBagLayout)getLayout( )).setConstraints(label1, gbc);
    add(label1);

    //Setting up okButton and placing it in the layout
    //Insert "AboutDialog okButton Setup"

Locate the AboutDialog okButton Setup clipping in the AboutDialog folder and drag it directly below the last line of code shown above. Your code should now look like this:

    ((GridBagLayout)getLayout( )).setConstraints(label1, gbc);
    add(label1);

    //Setting up okButton and placing it in the layout
    //Insert "AboutDialog okButton Setup"

    okButton = new Button( );
okButton.setLabel("OK");
    gbc = new GridBagConstraints( );
    gbc.gridx = 1;
    gbc.gridy = 2;
    gbc.fill = GridBagConstraints.NONE;
    gbc.insets = new Insets(0,0,0,0);
    ((GridBagLayout)getLayout( )).setConstraints(okButton, gbc);
    add(okButton);

The first step is to create a new instance of class java.awt.Button and assign it to our okButton variable we previously declared. We set the label of the button to "OK", and set up the GridBagConstraints. Lastly, we add the button to the dialog.

Now that we have an OK button, we need to create a method that will respond to the button press and hide the AboutDialog. Skip down in the source file past the setVisible( ) method.

Public void setVisible(Boolean b)
{
    //Place the dialog in the Macintosh Alert Position
    //Insert "AboutDialog setVisible"
}

//Innerclass for handling ActionEvents
//Insert "AboutDialog ActionListener"

//Respond to button clicked ActionEvents from the okButton
//Insert "AboutDialog okButton_Clicked"

Locate the AboutDialog okButton_Clicked clipping in the AboutDialog folder and drag it directly below the last line of code shown above. Your code should now look like this:

public void setVisible(Boolean b)
{
    //Place the dialog in the Macintosh Alert Position
    //Insert "AboutDialog setVisible"
}

//Innerclass for handling ActionEvents
//Insert "AboutDialog ActionListener"

/Respond to button clicked ActionEvents from the okButton
//Insert "AboutDialog okButton_Clicked"

void okButton_Clicked(ActionEvent event)
{
    setVisible(false);
}

Here we are creating a method that takes an action event parameter and does not return anything. The ActionEvent will be broadcast from the button when the button is clicked. This method hides the dialog by calling setVisible( ) with false as the parameter.

We have an okButton_Clicked( ) method that knows how to behave appropriately when the “OK” Button is clicked. Now we need a mechanism that responds to the button press and calls our method. When the Button is pressed, it generates an ActionEvent. We need to create an inner class which will listen for this ActionEvent and call our okButton_Clicked( ) method to hide the dialog. Go back up in the source file to the comment immediately following the setVisible( ) method.

Public void setVisible(Boolean b)
{
    //Place the dialog in the Macintosh Alert Position
    //Insert "AboutDialog setVisible"
}

//Inner class for handling ActionEvents
//Insert "AboutDialog ActionListener"

Locate the AboutDialog ActionListener clipping in the AboutDialog folder and drag it directly below the last line of code shown above. Your code should now look like this:

public void setVisible(Boolean b)
{
    //Place the dialog in the Macintosh Alert Position
    //Insert "AboutDialog setVisible"
}

//Innerclass for handling ActionEvents
//Insert "AboutDialog ActionListener"

class Action implements ActionListener
{
    public void actionPerformed(ActionEvent event)
    {
        okButton_Clicked(event);
    }
}

This code may seem confusing at first, but it is really quite straightforward. We want to respond to the ActionEvent broadcast by the okButton object. Hence we create an inner class called Action which implements the ActionListener interface. The ActionListener interface defines a single actionPerformed method which we implement in our class. By implementing this method, we can respond to action performed events. Our actionPerformed method simply calls our okButton_Clicked( ) method and passes the received event as the parameter.

In a nutshell, the Button keeps a list of Listeners who have registered with the Button that they wish to be notified when an actionPerformed event occurs. When an actionPerformed event occurs, the Button traverses its list of Listeners and notifies each one in turn that the event occurred. It subsequently calls the actionPerformed method of each listener with a new ActionEvent describing the details of the event.

For more information on event handling in JDK 1.1, see JavaSoft’s Event Handling Tutorial.

We have created an inner class that responds to ActionEvents by calling our okButton_Clicked( ) method. Now we need to hook up our handler to the okButton.

Go up to the end of the code block we added in Step 4.

gbc.fill = GridBagConstraints.NONE;
gbc.insets = new Insets(0,0,0,0);
((GridBagLayout)getLayout( )).setConstraints(okButton, gbc);
add(okButton);

//REGISTER_LISTENERS
//Registering our ActionListener with the okButton
//Insert "AboutDialog Register Listeners"

Locate the AboutDialog Register Listeners clipping in the AboutDialog folder and drag it directly below the last line of code shown above. Your code should now look like this:

gbc.fill = GridBagConstraints.NONE;
gbc.insets = new Insets(0,0,0,0);
((GridBagLayout)getLayout( )).setConstraints(okButton, gbc);
add(okButton);

//REGISTER_LISTENERS
//Registering our ActionListener with the okButton
//Insert "AboutDialog Register Listeners"

Action lAction = new Action( );
okButton.addActionListener(lAction);

Registering our ActionListener is fairly straightforward. We create an instance of our inner class, and call addActionListener( ) from our button with our Action object as a parameter. Basically, we are telling the button that we have a class (our Action class) that is interested in receiving notification when ActionEvents occur. When the okButton is clicked, it checks its list of registered listeners, and sends the Action object an ActionEvent. The Action object processes the ActionEvent and calls okButton_clicked( ) which hides the window.

There is one task remaining that we need to accomplish for this class. We want to override setVisible( ) so that we can add centering behavior to our AboutBox.

/**
 * Shows or hides the component depending on the Boolean flag b.
 * @param b  if true, show the component; otherwise, hide the 
 * component.
 * @see java.awt.Component#isVisible
 */
 public void setVisible(Boolean b)
 {

     //Place the dialog in the Macintosh Alert Position
     //Insert "AboutDialog setVisible"

Locate the AboutDialog setVisible clipping in the AboutDialog folder and drag it directly below the last line of code shown above in orange. Make sure that it precedes the closing brace of the function. Your code should now look like this:

/**
 * Shows or hides the component depending on the Boolean flag b.
 * @param b  if true, show the component; otherwise, hide the 
 *    component.
 * @See java.awt.Component#isVisible
 */
 public void setVisible(Boolean b)
 {	
     //Place the dialog in the Macintosh Alert Position
     //Insert "AboutDialog setVisible"

     if(b) 
     { 
         Dimension bounds  = 
              Toolkit.getDefaultToolkit( ).getScreenSize( );
         Dimension abounds = getSize( ); 
         setLocation((bounds.width - abounds.width) / 2, 
              (bounds.height - abounds.height) / 3); 
     } 
     super.setVisible(b);

This code snippet uses basic math to determine the center of the screen. It is within an if( ) statement because we only want to do our computation if we are in the process of becoming visible. The first thing we do is get the bounds (height and width) of the screen. We do this via a utility class called the Toolkit. This class is part of the standard AWT.

Once we have the screen bounds, we get the size of the dialog and move the dialog so that it is centered horizontally, and placed at 1/3 of the screen height.

This completes the source modifications for About.java.

There are several important concepts to be learned from this source file. We learned how to declare and initialize controls that appear in a dialog. We were introduced to event management in Java and learned how to respond to a button click. We also took a cursory look at layout components in a window, and learned how to register our event handlers. It is surprising how much we learned just from a simple About box.

Now we are ready to return to our main tutorial file where we will prepare our project for the next step, Building the ImageButton.