The WindowListener interface and the WindowAdapter class

 

Overview

A class that is interested in processing a window event must either (1) implement the WindowListener interface and all the methods it contains or (2) extend the abstract WindowAdapter class.

 

The WindowListener interface

x.addWindowListener(this);

When the object's status changes due to being opened or closed, activated or deactivated, iconified or deiconified, a WindowEvent is fired to the relevant method within the listener object. 

Method

Usage

windowActivated()

Invoked when the window becomes the active window, which means the window may receive keyboard events

windowClosed()

Invoked when the window has been closed as the result of calling dispose() on the window

windowClosing()

Invoked when the user attempts to close the window

windowDeactivated()

Invoked when the window is no longer the active window, which means the window can no longer receive keyboard events

windowDeiconified()

Invoked when the window is changed from a minimized to a normal state

windowIconified()

Invoked when the window is changed from a normal to a minimized state

windowOpened()

Invoked when the window is first made visible

Each of the above methods receives a WindowEvent object as a parameter and returns no value (is void). Consult the Java API for more details.

Example:

import java.awt.*;
import java.awt.event.*;

public class App extends Frame implements WindowListener {

  TextArea log = new TextArea("",5,20,TextArea.SCROLLBARS_VERTICAL_ONLY);

  public static void main(String[] args) {
    App myWindow = new App("Window event log");
    myWindow.setSize(200,150);
    myWindow.setVisible(true);
  }

  public App(String title) {
    super(title);
    setLayout(new BorderLayout());
    addWindowListener(this);
    log.setEditable(false);
    add(log);
  }

  public void windowOpened(WindowEvent e) {
    log.append("Opened" + "\n");
  }

  public void windowActivated(WindowEvent e) {
    log.append("Activated" + "\n");
  }

  public void windowIconified(WindowEvent e) {
    log.append("Iconified" + "\n");
  }

  public void windowDeiconified(WindowEvent e) {
    log.append("Deiconified" + "\n");
  }

  public void windowDeactivated(WindowEvent e) {
    log.append("Deactivated" + "\n");
  }

  public void windowClosing(WindowEvent e) {
    System.out.println("Closing");
    dispose();
  }

  public void windowClosed(WindowEvent e) {
    System.out.println("Closed");
    System.exit(0);
  }
}

Notes:

  1. The class implements the WindowListener interface in order to handle window events

  2. The TextArea object (log) is used to display a scrolling list of messages pertaining to window events

  3. Within the application's constructor, the WindowListener is registered

  4. Each of the required WindowListener methods is defined to send a message to either the text area or the system output device (if the window is closing or closed)

  5. When testing, launch more than one copy of the program. Then, click back and forth between the windows to see activation and deactivation messages.

 

The WindowAdapter class

Object

\

WindowAdapter

For example, the following code may be added to any windows program to properly close its window:

addWindowListener(
  new WindowAdapter() {
    public void windowClosing(WindowEvent e) {
      dispose();
      System.exit(0);
    }
  }
);

These statements define an inner WindowAdapter class with an overriding windowClosing() method and register the inner class as a WindowListener. For custom handling of other window events, the corresponding overriding methods can be inserted.

Example:

import java.awt.*;
import java.awt.event.*;

public class App extends Frame {

  Label message = new Label("");

  public static void main(String[] args) {
    App myWindow = new App("Find the active window");
    myWindow.setSize(250,150);
    myWindow.setVisible(true);
  }

  public App(String title) {
    super(title);
    setLayout(new BorderLayout());
    addWindowListener(
      new WindowAdapter() {
        public void windowActivated(WindowEvent e) {
          message.setBackground(Color.red);
          message.setText("I'm active");
        }
        public void windowDeactivated(WindowEvent e) {
          message.setBackground(Color.lightGray);
          message.setText("I'm not active");
        }
        public void windowClosing(WindowEvent e) {
          System.out.println("I'm toast!");
          dispose();
          System.exit(0);
        }
      }
    );
    setForeground(Color.white);
    setFont(new Font("SanSerif", Font.ITALIC, 24));
    message.setAlignment(Label.CENTER);
    add(message);
  }
}

Notes:

  1. The class does NOT implement the WindowListener interface

  2. The Label object (message) is used to display whether the window is active or not

  3. Within the application's constructor, the WindowListener is registered to an inner WindowAdapter class that contains overriding methods for handling for window activation, deactivation, and closing

  4. When testing, launch more than one copy of the program. Then, click back and forth between the windows to see activation and deactivation messages.

 

Lab exercise for Ferris students

E-mail your answers to this assignment no later than the due date listed in the class schedule.

 

Review questions

  1. Which of the following class headers is properly coded?  (choose two)

  1. public class X extends Frame, WindowAdapter

  1. public class X extends Frame implements WindowAdapter

  2. public class X extends Frame, WindowListener

  3. public class X extends WindowAdapter

  4. public class X extends Frame implements WindowListener

  1. Which of the following fire a window event?  (choose two)

  1. minimizing a window

  1. maximizing a window

  2. clicking on an inactive window

  3. dragging a window to a new screen location

  4. dragging on a window border to change its size

  1. Assume that all unseen code is correct. If the following statements define the only event handling methods within a class that implements the WindowListener interface, which one of the statements below is true of attempting to compile and execute?

public void windowOpened(WindowEvent e) {
  setBackground(Color.blue);
}
public void windowIconified(WindowEvent e) {
  System.exit(0);
}
  1. a compile error will occur

  2. the compile will succeed and the window will have a blue background when it is opened for the first time

  3. the compile will succeed and the program will end if the user minimizes the window

  4. the compile will succeed but a runtime error will occur if the user attempts to close the window

  5. the compile will succeed but the window can never be made active because no windowActivated() method has been defined

  1. Which of the following is not a method of the WindowListener interface?  (choose two)

  1. windowDeiconified()

  2. windowMoved()

  3. windowClosed()

  4. windowDeactivated()

  5. windowResized()