Computer Science 161

Laboratory Exercise #6

Thursday, December 3, 2008

A brief introduction to graphical user interfaces (GUI) in Java:  Building Command Interfaces in Java.

In this laboratory exercise we look at three ways in which we can communicate with a user using the Java graphical user interface (GUI).  We begin by first looking at the JOptionPane methods we have used before.  We then look at another JOptionPane example which allows us to build a more sophisticated button-driven menu.  We finally begin to look at some of the layout features of Java windows and see an introduction to capturing mouse actions using the ActionListener interface (more on interfaces Friday).

Notes on the current assignment:

• You are welcome to use any one of these three techniques for the current assignment.  I have arranged them in order of increasing difficulty.
• Please note that the "message" portion of a Dialog can be as big as you want.  In the first example below, we use it to give the user a comprehensive list of options.  In the printAll method of your Inventory class, you can use it to build a string containing all of the parts.  Look at the toString and tryit methods of HashMapExample for details.

Step 1:  Using what we already know about Dialog boxes to build a command interface

In class Tuesday (12/2/08) we discussed a procedure getValidInput which worked with the user using System.out.println and the Reader class to present the user with a menu of choices and kept on asking until the user entered an invalid command.

Write a simple class by creating a new project and clicking on the New Class button.  Accept the default class (we will not use the class in this exercise;  Write a simple private static int getValidInput() routine which throws up a JOptionPane.showInputDialog window with the messsage listing the four possibilities for command:

       String message1 = "Wecome to the Inventory Management System\n" +

            "Please enter a command:  0 to add a part\n" +

            "                         1 to delete a part\n" +

            "                         2 to list all parts\n" +

            "                         3 to quit";

Before converting the resulting String from showInputDialog we must consider what happens when the user clicks "CANCEL" or the close box.  In both of these cases showInputDialog returns a null string.  If we pass a null string to Integer.valueOf, we get an exception (more on exceptions next week).  So we need to check first:

       if (commandString == null) command = QUIT;

        else command = Integer.valueOf(commandString); to quit";

Where QUIT is a con.  stant defined earlier.

Try this out.  To see a completed example, copy GUI01 from the Handouts folder on Hedwig.

Step 2:  Using a more sophisticated version of JOptionPane.showInputDialog

In this example, we revisit the showOptionDialog method used earlier in this laboratory exercise and discussed in more detail in an earlier laboratory exercise (Laboratory exercise #3)..  This approach will introduce a few new fields in our discussion on showOptionDialog.

Several have already discovered that there are several methods described in the JOptionPane documention titled showInputDialog.  They differ from each other in the signature of the method.  For this example, we want to use the method with the signature

public static int showOptionDialog(Component parentComponent,
                                     Object message,
                                     String title,
                                     int messageType,
                                     Icon icon,
                                     Object[] selectionValues,
                                     Object initialSelectionValue)
                              throws HeadlessException

(this and the following is copied verbatim from the Java Documentation)

The parameters are as follows:

• parentComponent:  we will continue to use null for this
• message:  we will provide a message string as before (but without giving the lists of options)
• title:  the title for the window
• messageType:  I used JOptionPane.YES_NO_CANCEL_OPTION and it worked nicely.  There may be a default value for this.  The actual options are taken from selectionValues (described below).
• icon:  This is the interesting one.  We will use null for this field and take the default option (determined, it appears, by the messageType), but imagine the possibilities!
• selectionValues allows us to establish a series of buttons. The easiest way to do this is to declare an array of Striong and to initialize it to the options you want displayed. The showOptionDialog method will return the index of the string in the selectionValues array. For example, suppose I specify

  
  	String[] commandOptions = {"ADD", "REMOVE", "LIST", "QUIT"}, 

  then showOptionDialog will return a 0 if the user clicks on the ADD button, a 1 if the user clicks on the REMOVE button, etc. Special note: If the user clicks on the close box, a value of -1 is returned, so the easiest thing to do is to treat this as a QUIT command.
• initialSelectionValue should allow us to specify a default choice.  I used commandOptions[3] (the quit option) but nothing happened.
• Don't worry (for now) about the throws statement.  We'll talk about this Monday.

Try this out (you can use a modification of the methods (including main) you wrote above.  The Java class GUI02 in the handouts folder gives a completed example of all this.

Step 3:  Interacting with the user through mouse clicks, etc.:  The ActionListener interface

Finally, we take a brief look at the ActionListener.