Tutorial 12 - Advanced Swing

This tutorial covers advanced Java Swing topics such as inner class event listeners using inner classes, the MVC architecture, dropdown menus, popup menus, toolbars and specialized containers. Basics|Intermediate

Advanced Event Listeners
Model-View-Controller

MenuBars,ToolBars,PopUps
Panes: Scrolled and Layered

Panes: Split&Tabbed
Tables and Trees

Advanced Event Listeners

A difficulty with the basic event listening technique (ie event sharing) 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);
  }
}

// Model contains the functionality (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);
  }
}

// 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 view buttons
    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;
    }
  }
}

MenuBars, ToolBars, PopUps

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.

Context sensitive popup menus are revealed by some user action (such as right click) and look similar to a dialog box. MyPop demonstrates JPopupMenu and some features of the popup menu classes including specialized listeners.

Panes: Scrolled and Layered

Scrolled panes establish scroll bars for moving the displayed area in lists, textareas and other components. If you wish a scrollbar policy other than 'display scollers when needed' read Scroll Bar Policies. As an example, to add scrollbars to a text area:

JTextArea edit=new JTextArea(rows,columns);
JScrollPane pane=new JScrollPane(edit);
con.add(pane);

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();}
}

Panes: Split and Tabbed

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 desired layer. 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 Oracle.

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. The constructor is JTree(class) where class can be one of Object, TreeNode, TreeModel, Vector or Hashtable. ObjectTree is a demo which uses a hashtable to hold the actual tree.

Tutorial Source Code

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

JR's HomePage | Comments [jatutorc.htm:2010 12 19]