Java Swing: GUI Environments

• Study notes from lecture 18 on Java Swing

Modern Windowing/GUI Environment

• Windowing/GUI environments use Windows, Icons, Menus, Pointer (WIMP) to render a GUI.
• Everything is arranged on a desktop (desktop metaphor).

Desktop Environment Parts

• Windowing System: handles input/output
• Widget Toolkit: draws widgets and dispatches their events
• Window Manager: manages windows

Windowing System

• Manages input and output devices, including graphics cards, screens, mice, and keyboards.
• It redirects data from input devices to applications.
• Receives and processes drawing commands from applications.
• May communicate with remote applications, sending input events and receiving drawing commands over a network.

GUI Interaction Events

• Primitive Keyboard Events: Key Down, Key Up
• Primitive Pointer Events: Mouse Moved, Mouse Down, Mouse Up
• Complex Pointer Events:
  • Click: mouse down, mouse up
  • Double Click: two clicks within a certain time
  • Enter: mouse moves into a region
  • Leave: mouse moves out of a region
  • Hover: mouse stays in region for a period of time
  • Drag and Drop: mouse down, mouse moved, mouse up

Input Handling in Widgets

• Input events are dispatched to the right widgets by the windowing system and/or toolkit.
• Keyboard events are sent to the widget with input focus in the active window.
• Widgets have handlers for input events; they can translate simple input events into more complex, specific ones (e.g., “activated”).
• Developers can set event handlers for widgets, which invoke application logic.

Rendering of Widgets

• Widgets have a visual representation.
• Widgets define a "paint" event handler, which draws the widget by sending commands to the windowing system.
• Widgets receive "paint" (or "update") events from the windowing system (possibly through a toolkit).
• Often not complete redrawing, but "update region" redrawing.
• Redrawing the update region is achieved with clipping.
• Applications can send "invalidate" events to the windowing system if redrawing is necessary, potentially triggering paint events.

GUI Event Loop Steps

• GUI application is started.
• Widgets are set up.
• Event loop is started.
• Wait for events from the windowing system (event queue).
• Dispatch each event to the right widget.
  • Input event: call appropriate event handler (call to application logic).
  • Paint event: call paint method.
• Return to step 4.

Event-Driven Programming

• GUI applications are event-driven.

Window Manager

• Controls placement and appearance of windows (but not the window contents).
• Manages window operations: open, close, minimize, maximize, move, resize.
• Starts apps, lists and switches between running apps.
• Provides window decorators and desktop background with icons.
• Often built into the windowing system and implemented using a widget toolkit.

Introduction to Java Swing

• Explains the differences between AWT and Swing.

AWT vs. Swing

• AWT (Abstract Windowing Toolkit):
  • Original Java GUI toolkit.
  • Wrapper API for native GUI components.
  • Uses the lowest-common-denominator approach for all Java host environments.
• Swing:
  • Implemented entirely in Java on top of AWT.
  • Offers a richer set of GUI components.
  • Provides pluggable look-and-feel support.

Swing Design Principles

• GUI is built as a containment hierarchy of widgets (parent-child nesting).
• Uses event objects and event listeners:
  • Event object: created when an event occurs (e.g., click) and contains additional information (e.g., mouse coordinates).
  • Event listener: object implementing an interface with an event handler method that receives an event object as an argument.
• Separation of Model and View:
  • Model: the data presented by a widget.
  • View: the actual presentation on the screen.

Partial AWT and Swing Class Hierarchy

• java.lang.Object
  • MenuComponent
  • Component
    • Button
    • Canvas
    • Checkbox
    • Choice
    • Container
      • Panel
        • Applet
        • Scrollpane
      • Window
        • Dialog
        • Frame
    • Label
    • List
    • Scrollbar
    • TextComponent
  • JComponent
    • AbstractButton
      • JButton
    • JLabel
    • JList
    • JPanel
      • JApplet
      • JDialog
      • JFrame
    • JScrollpane
• java.awt.*
• javax.swing.*

Swing Widgets

• Top-Level Containers: JFrame, JDialog, JApplet
• General-Purpose Containers: JPanel, JScrollPane, JSplitPane, JTabbedPane
• Widgets: JButton, JCombobox, JList, Menu, JLabel, JRadioButton and ButtonGroup, JCheckbox, JFileChooser, JTree, JTable, JColorChooser

Initial Swing GUI Containment Hierarchy

• Includes Frame / Dialog / Applet, Root Pane, Layered Pane, Content Pane and Glass Pane
• A 3D model enables menus to pop up above the content pane
• Allows for interception of mouse events and painting across GUI components

Swing GUI Containment Hierarchy Details

• TopLevelContainer (JFrame, JDialog, JApplet) contains:
  • rootPane (JRootPane, a JPanel) contains:
    • glassPane (java.awt.Component)
    • layeredPane (JLayeredPane, optional JPanel) contains:
      • contentPane (java.awt.Container)
      • menuBar (JMenuBar)

Swing Hello World Example

import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
public class HelloWorld {
    public static void main(String[] args) {
        JFrame frame = new JFrame("Hello World!");
        frame.setSize(220, 200);
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        Container contentPane = frame.getContentPane();
        contentPane.setLayout(null);
        JButton button = new JButton("Hello World!");
        button.setLocation(30, 30);
        button.setSize(150, 100);
        contentPane.add(button);
        frame.setVisible(true);
    }
}

Swing Hello World with Events

public class HelloWorld {
    public static void main(String[] args) {
        ...
        JButton button = new JButton("Hello World!");
        button.addActionListener(new MyActionListener());
        ...
    }
}
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
public class MyActionListener implements ActionListener {
    public void actionPerformed(ActionEvent e) {
        Toolkit.getDefaultToolkit().beep();
    }
}

Containment Hierarchy of a Menu

public class MenuExample {
    public static void main(String[] args) {
        JFrame frame = new JFrame("My Frame");
        frame.setDefaultCloseOperation( JFrame.EXIT_ON_CLOSE);
        JMenu fileMenu = new JMenu("File");
        fileMenu.add(new JMenuItem("New"));
        fileMenu.add(new JMenuItem("Open"));
        fileMenu.add(new JMenuItem("Close"));
        JMenu editMenu = new JMenu("Edit");
        editMenu.add(new JMenuItem("Undo"));
        editMenu.add(new JMenuItem("Redo"));
        editMenu.add(new JMenuItem("Cut"));
        JMenuBar menubar = new JMenuBar();
        menubar.add(fileMenu);
        menubar.add(editMenu);
        frame.setJMenuBar(menubar);
        frame.setVisible(true);
    }
}

Handling Menu Events

public class MenuExample {
    static JFrame frame;
    public static void main(String[] args) {
        ...
        JMenuItem item = new JMenuItem("Close");
        item.addActionListener(new MenuActionListener());
        fileMenu.add(item);
        ...
    }
}
...
public class MenuActionListener implements ActionListener {
    public void actionPerformed(ActionEvent e) {
        JOptionPane.showMessageDialog(MenuExample.frame, "Got an ActionEvent at " + new Date(e.getWhen()) + " from " + e.getSource().getClass());
    }
}

Defining Event Listeners with Anonymous Classes

public class MenuExample {
    public static void main(String[] args) {
        final JFrame frame = new JFrame("My Frame");
        ...
        JMenuItem item = new JMenuItem("Close");
        item.addActionListener(new ActionListener() {
            public void actionPerformed(ActionEvent e) {
                int n = JOptionPane.showOptionDialog(frame,...
            }
        });
        ...
    }
}

• Use new Classname() {…} or new Interfacename(){…} to create a single object of an anonymous subclass of the given class/interface.
• Anonymous classes can access final variables of their context (i.e., final variables of the method or class they are created in).

Kinds of Swing Events

• Low-level events:
  • MouseEvent: Component got mouse-down, mouse-move, etc.
  • KeyEvent: Component got key-press, key-release, etc.
  • ComponentEvent: Component resized, moved, etc.
  • ContainerEvent: Container's contents changed because a component was added or removed
  • FocusEvent: Component got focus or lost focus
  • WindowEvent: Window opened, closed, etc.
• High-level semantic events:
  • ActionEvent: Main action of control invoked (e.g., JButton click).
  • AdjustmentEvent: Value was adjusted (e.g., JScrollBar moved).
  • ItemEvent: Item was selected or deselected (e.g., in JList).
  • TextEvent: Text in component has changed (e.g., in JTextField).

Events, Listeners, Adapters, and Handler Methods

• Adapter classes with empty methods exist for Listener interfaces that have >1 methods.

Summary

• Desktop environments comprise of:
  • Windowing System handles input/output.
  • Widget Toolkit draws widgets and dispatches their events.
  • Window Manager takes care of windows.
• Swing is a widget toolkit for Java.
• GUI is structured as a containment hierarchy of widgets.
• Utilizes event objects and event listeners.