Tutorial 12 - Advanced Swing

This tutorial covers more advanced Java Swing topics such as inner class event listeners using inner classes and the MVC architecture. Dropdown menus, popup menus, toolbars, specialized containers, layered panes, split panes, tabbed panes, tables and trees are also included.

Advanced Event Listeners
Model-View-Controller
Menu Bars & Tool Bars

Specialty Panes
Tables and Trees
Global HotKeys

Advanced Event Listeners

One difficulty with the basic event listening technique (ie event sharing) previously demonstrated is that it becomes awkward to program for many buttons and widgets. Extended if statements or switch constructs can make code hard to maintain. There are better ways!

Inner (ie nested) class event handlers allow handler routines to be written for specific objects. For example, instead of using the addActionListener(this) method for several buttons you can have each button call its own inner class. Function code can still be mixed into GUI code. See the list of other event listeners.

import java.awt.*;import java.awt.event.*;import javax.swing.*;
public class SomeGUI extends JFrame
{
  JButton run=new JButton("Run the Utility");
  JButton exit=new JButton("Exit After Save");
  JPanel buttons=new JPanel();
  SomeGUI() // the constructor
  {
    super("Event Listener Demo");setBounds(100,100,250,150);
    setDefaultCloseOperation(EXIT_ON_CLOSE);
    buttons.setLayout(new GridLayout(4,1,2,2));
    buttons.add(run);buttons.add(exit);
    this.getContentPane().add("Center",buttons);
    exit.addActionListener(new ExitHandler());
    setVisible(true);
  }
  // add inner class event handler for each button here
  class ExitHandler implements ActionListener
  {public void actionPerformed(ActionEvent e) {System.exit(0);}}
  public static void main(String args[]) {new SomeGUI();}
}

NOTE: The implements clause is now placed in each inner class header and not in the main class header. Also the listener registration is of a specific Listener_class object, not the generic this.

Anonymous inner classes have no name (hence no name conflict) and are used when only one instance of the class is required. They also do not have constructors. Anonymous inner classes are most often found in event listeners with very simple actions. Beware! Anonymous listeners intermix action code with the GUI object. This is contrary to the separation of worker code from GUI that is a part of clean design. Avoid this construction if possible.

exit.addActionListener(new ActionListener()
  {
    public void actionPerformed(ActionEvent e){System.exit(0);}
  });

As event classes are interfaces, all methods within that event must be implemented. Adapter classes provide default do-nothing methods which you can chose to override. Here is a short example using the WindowAdapter class to avoid coding all seven window events.

import java.awt.*;import java.awt.event.*;
class Listener2 extends Frame
{
  Listener2()
  {
    setBounds(100,100,200,200);setVisible(true);
    addWindowListener(new WindowAdapter()
    {
      public void windowclosing(WindowEvent e){System.exit(0);}
    });
  }
  public static void main(String args[]) {new Listener2();}
}

Model-View-Controller Architecture

The Model-View-Controller (MVC) architecture factors function code from the GUI design using a controller module. The controller module ties event listeners in the view module to their actions in the model module. Good programming practice implies private properties with public accessor methods for those needing access from outside their container object. These three object modules can be designed at different times by different programmers. Refer to Using The GUI in the Guidebook. Stuart Davidson of Heriot Watt University has done an excellent job of explaining MVC with a working example.

The model object contains the run-time actions for the application. It often has methods for exit(), run(), about() and help() as these are common to most utilities. The view object constructor should accept a string that incorporates the utility title. The view object also requires methods to build the listeners. buttonActionListeners() includes addActionListener() and a setActionCommand(string) which is used to pass a reference of the pressed button. The controller module uses getActionCommand() to call the correct action method in the model. An example of MVC architecture using the SomeGUI example is:

import java.awt.*;import java.awt.event.*;import javax.swing.*;
/* GridGUI demonstrates separation of functionality
   from GUI design by using MVC architecture */

// first comes the root class that builds the architecture
public class GridGUI
{
  public static void main(String args[])
  {
    GridGUIModel model=new GridGUIModel();
    GridGUIView view=new GridGUIView("GridGUI MVC Demo");
    GridGUIController controller=new GridGUIController(model,view);
  }
}

// the model contains the functionality (ie properties and methods)
class GridGUIModel
{
  public void exit() {System.exit(0);}
  public void run()
  {
    JOptionPane.showMessageDialog(null,"I hear you!",
    "Message Dialog",JOptionPane.PLAIN_MESSAGE);
  }
}

// the view is where the GUI is built
class GridGUIView extends JFrame
{
  JButton run=new JButton("Run the Utility");
  JButton exit=new JButton("Exit After Save");
  JPanel buttons=new JPanel();
  GridGUIView(String title) // the constructor
  {
    super(title);setBounds(100,100,250,150);
    setDefaultCloseOperation(EXIT_ON_CLOSE);
    buttons.setLayout(new GridLayout(4,1,2,2));
    buttons.add(run);buttons.add(exit);
    this.getContentPane().add("Center",buttons);
    setVisible(true);
  }
  //method to add ActionListener passed by Controller to buttons
  public void buttonActionListeners(ActionListener al)
  {
   run.setActionCommand("run");run.addActionListener(al);
   exit.setActionCommand("exit");exit.addActionListener(al);
  }
}

// the controller listens for actions and reacts
class GridGUIController implements  ActionListener
{
  GridGUIModel model; GridGUIView view;
  public GridGUIController(GridGUIModel model, GridGUIView view)
  {
    // create the model and the GUI view
    this.model=model;this.view=view;
    // Add action listener from this class to buttons of the view
    view.buttonActionListeners(this);
  }
  // Provide interactions for actions performed in the view.
  public void actionPerformed(ActionEvent ae)
  {
    String action_com=ae.getActionCommand();
    char c=action_com.charAt(0);switch(c)
    {
    case 'r':model.run();break;
    case 'e':model.exit();break;
    }
  }
}

Menu Bars and ToolBars

Dropdown/pullout menu bars are menus similar to those that appear across the top of most Windows programs. The menu bars are constructed from the JMenuBar class. Menus (aka bar items) are constructed from the JMenu class and menu items from the JMenuItem class. Item separators can either be added to a menu with addSeparator() or inserted with insertSeparator(posn). Menu items can be disabled or grayed out with the setEnabled(false) method and tested with the isEnabled() method. Menu items can have a hotkey shortcut added by using a setMnemonic(char) method. Accelerator keys are added with the setAccelerator() method. The menubar is added to the main frame by using this.setJMenuBar(obj). MyMenu demonstrates many of the features of the menu classes including mnemonics, accelerators keyed to platform, checkbox & radiobutton items and icons.

Dockable toolbars can be constructed from the JToolBar class. JToolBar(SwingConstants.VERTICAL) overrides the default orientation. The add() method adds components which are often icons. Toolbars are always fully exposed. MyToolBar demonstrates features of the toolbar class including action classes.

Popup menus are revealed by some user action and look similar to a dialog box. MyPop demonstrates features of the popup menu classes including specialized listeners.

Specialty Panes

Layered panes allow components such as buttons to be overlapped or layered. A simple example is:

import java.awt.*;import javax.swing.*;
public class Frame3 extends JFrame
{
  public Frame3() // constructor method for the class
  {
    super("Simple Layers Demo");setBounds(100,100,300,200);
    setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    JLayeredPane lp=getLayeredPane();// inherit layered pane
    JButton top=new JButton();
    top.setBackground(Color.white);
    top.setBounds(20,20,50,50);
    JButton mid=new JButton();
    mid.setBackground(Color.gray);
    mid.setBounds(40,40,50,50);
    JButton bot=new JButton();
    bot.setBackground(Color.black);
    bot.setBounds(60,60,50,50);
    lp.add(mid,new Integer(2));
    lp.add(top,new Integer(3));
    lp.add(bot,new Integer(1));
    setVisible(true);
  }
  public static void main(String args[]) {new Frame3();}
}

Split panes allow you to place two components side by side in a single pane. It can also split the pane horizontally. A simple example of a split pane is:

 import java.awt.*;import javax.swing.*;
class MySplit extends JFrame
{
  static String sometext="This is a simple text string that is long enough "+
  "to wrap over a few lines in the simple demo that we have just built. We "+
  "will put two Text areas side by side in a split pane";
  public MySplit()
  {
    super("Simple JSplitPane Frame");setSize(450,200);
    JTextArea jt1=new JTextArea(sometext);
    JTextArea jt2=new JTextArea(sometext);
    jt1.setLineWrap(true);jt1.setMinimumSize(new Dimension(150,150));
    jt2.setLineWrap(true);jt2.setMinimumSize(new Dimension(150,150));
    jt1.setPreferredSize(nw Dimension(250,200));
    JSplitPane sp=new JSplitPane(JSplitPane.HORIZONTAL_SPLIT,jt1,jt2);
    getContentPane().add(sp,BorderLayout.CENTER);
    setDefaultCloseOperation(EXIT_ON_CLOSE);setVisible(true);
  }
  public static void main (String args[]) {new MySplit();}
}

Tabbed panes allow a multilayered pane with tabs for the user to access the layer he wants. Each tab contains a single component. A simple example of a tabbed pane is:

import java.awt.*;import java.util.*;import javax.swing.*;
class MyTab extends JFrame
{
  JTabbedPane jtp;
  public MyTab()
  {
    super("JTabbedPane");setSize(200,200);
    Container contents=getContentPane();
    jtp=new JTabbedPane();
    jtp.addTab("Tab1",new JLabel("This is Tab One"));
    jtp.addTab("Tab2",new JButton("This is Tab Two"));
    jtp.addTab("Tab3",new JCheckBox("This is Tab Three"));
    contents.add(jtp);
    setDefaultCloseOperation(EXIT_ON_CLOSE);
    setVisible(true);
  }
  public static void main (String args[]) {new MyTab();}
}

Tables and Trees

Tables represent data in a row/column two dimensional grid format. The constructor is JTable(data,headers) where data is a two dimension string and headers is a one dimension string. SimpleTable is a demo. For a more complete tutorial see Sun.com.

Trees allow visualization, traversal and manipulation of hierarchical information (ie. parent-children) much easier. Trees consist of nodes. Common examples of trees are directories, organizational charts, and family trees. In Java the JTree(var) constructor is used to create trees. The variable parameter can be one of Object, TreeNode, TreeModel, Vector, or Hashtable class. ObjectTree is an example which uses a hashtable to hold the actual tree.

Global Hotkeys

Global hotkeys allow a program to be activated from any other program. Java uses its events handler system to monitor the global hotkeys registry after a key sequence has been entered in the registry. Check out JIntellitype (Wintel) and JxGrabKey (Linux) or google 'global hotkeys in java'.

Tutorial Source Code

Obtain source for MyMenu, MyToolBar, MyPop, SimpleTable and ObjectTree here.

JR's HomePage | Comments [jatutorc.htm:2009 09 13]