7.7 The CommandLineTuttle class

The CommandLineTuttle constructor is comparable to the other tuttle interface constructors, creating, configuring and installing an instance of the TextTuttle class, the CommandLineTuttleInterface class and a feedbackPanel into the interface. The ActionListener instance passed as an argument to the CommandLineTuttleInterface constructor is the instance of the CommandLineTuttle currently being initialised. Consequently this class has to implement the ActionListener interface and so an actionPerformed() method. The implementation of the class, presented without comment, as far as the end of its init() method, is as follows.

0001  // Filename CommandLineTuttle.java. 0002  // Supplies the command line translation for   0003  // the Tuttle class. 0004  // 0005  // Written for Java Interface book chapter 7. 0006  // Fintan Culwin, v 0.2, August 1997. 0007   0008  package CommandLineTuttle; 0009   0010  import java.awt.*; 0011  import java.awt.event.*; 0012  import java.applet.*; 0013   0014  import java.util.StringTokenizer; 0015   0016  import Tuttles.TextTuttle; 0017  import CommandLineTuttle.CommandLineTuttleInterface; 0018   0019   0020  public class CommandLineTuttle extends    Applet  0021                                 implements ActionListener {    0022   0023  private TextTuttle                 theTuttle;  0024  private CommandLineTuttleInterface theInterface; 0025   0026  private Panel                      feedbackPanel; 0027  private Label                      feedbackLabel; 0028   0029     public void init() {  0030      0031     Panel tuttlePanel = new Panel(); 0032                 0033        this.setLayout( new BorderLayout()); 0034        this.setFont(   new Font( "TimesRoman", Font.BOLD, 14)); 0035        this.setBackground( Color.white); 0036   0037        theTuttle = new TextTuttle( this, 400, 400); 0038        tuttlePanel.add( theTuttle); 0039         0040        theInterface = new CommandLineTuttleInterface( this);         0041                    0042        feedbackPanel = new Panel();      0043        feedbackPanel.setBackground( Color.white); 0044        feedbackLabel = new Label(); 0045        feedbackPanel.add( feedbackLabel); 0046         0047        this.add( feedbackPanel, "North"); 0048        this.add( tuttlePanel,   "Center"); 0049        this.add( theInterface,  "South"); 0050               0051        this.feedback(); 0052     } // End init.   

As this class has been registered as the actionListener attribute of the single line commandArea shown the user its' actionPerformed() method will be called every time the user presses the <ENTER> key in the command area of the interface. The actionCommand attribute of the event passed as an argument to the actionPerformed() method will contain the entire line of text from the commandArea.

The basis of the actionPerformed() method is to pass the command line, extracted from the ActionEvent argument of the method, to theTuttle instance. The method concludes by echoing the command, and any response received from theTuttle, in the feedback area before clearing the command area and updating the tuttle's feedback Panel. This outline is complicated by the need to process the help and exit commands separately. The implementation of the actionPerformed() method is as follows.

0055     public void actionPerformed( ActionEvent event) {  0056   0057     String          theCommand = event.getActionCommand(); 0058     StringTokenizer tokenizer  = new StringTokenizer( theCommand); 0059     String          firstTerm  = tokenizer.nextToken().toLowerCase(); 0060     String          theResponse; 0061   0062         if ( firstTerm.equals( "help")) {  0063           theResponse = obtainHelp( tokenizer); 0064         } else if ( firstTerm.equals( "exit")) {    0065           theResponse = checkExit( tokenizer); 0066         } else {         0067           theResponse = theTuttle.doCommand( theCommand);  0068         } // End if            0069 0070         theInterface.appendFeedback( "\n> " + theCommand); 0071         if ( theResponse.length() > 0 ) {  0072            theInterface.appendFeedback("\n" + theResponse);     0073         } // End if.    0074         theInterface.clearCommandArea(); 0075         this.feedback(); 0076     } // End actionPerformed.

Lines 0057 to 0059 prepare a StringTokenizer instance, called tokenizer, initialized to parse the command extracted from the event argument, using its getActionCommand() method, and extracts the first term of the command into the local String firstTerm. Line 0060 declares a String instance called theResponse ready to receive any reply from theTuttle.

Lines 0062 and 0063 deal with a help command by using the obtainHelp() method which will be described below, likewise lines 0064 to 0065 deal with an exit command by using the checkExit() method. All other commands are passed to theTuttle on line 0067, by calling its' doCommand() method passing the entire command line retrieved from the event as its argument. As explained above the doCommand() method will attempt to interpret the command and, if it is valid, instruct the tuttle to obey it. If it cannot be interpreted as a valid tuttle command the doCommand() method will return an explanation which will be stored in theResponse.

Line 0070 echoes theCommand to the feedback area on theInterface, preceded by a chevron ('>'), by using its appendFeedback() method. Lines 0071 to 0073 follow this by the contents of theResponse, if any. The method concludes, on lines 0074 and 0075, by clearing the command area on theInterface, ready for the next command and updating the feedbackPanel as usual.

As indicated on Figure 7.5 the command "help" by itself will provide a list of recognized commands, "help" followed by one of the possible tuttle commands will provide specific help for that command and anything else will be reported as an unknown command with the further advice to try "help" by itself. The obtainHelp() method, implemented as follows, will be called from the actionPerformed() method when "help" is identified in the first term of the user's command, and will return a suitable response to be subsequently displayed in the text feedback area.

0090     private String obtainHelp( StringTokenizer tokenizer) {  0091      0092     StringBuffer theHelp = new StringBuffer( ""); 0093     String       secondTerm; 0094     int          helpFor;    0095   0096        if ( ! tokenizer.hasMoreTokens()) {  0097           theHelp.append( "help is available for fd, bd, tr, tl " +  0098                           "fg bg pu pd cl rs cr and exit"); 0099        } else {     0100            secondTerm = tokenizer.nextToken().toLowerCase(); 0101            helpFor = theTuttle.identifyCommand( secondTerm); 0102             0103            switch ( helpFor) {  0104            case theTuttle.FORWARD: 0105               theHelp.append("fd is ForwarD, it must be followed by a number, " +  0106                              "\nthe tuttle will move that many steps in its " +  0107                              "current direction."); 0108               break; ----            // Other branches omitted. 0187            case theTuttle.UNKNOWN: 0188               theHelp.append("Sorry! The command '" + secondTerm +  0189                              "' is not known \n Try 'help' by itself for " + 0190                              "a list of commands which are known."); 0191               break;                                  0192             0193            } // End switch. 0194        } // End if.     0195        return theHelp.toString(); 0196     } // End obtainHelp.

The command "help" by itself will be detected on line 0096, by the absence of a second term in the StringTokenizer tokenizer argument, and causes a suitable message to be placed in theHelp StringBuffer on lines 0097 to 0098. Otherwise, on line 0100, the second term is extracted from the tokenizer and passed to the TextTuttle identifyCommand() method on line 0101. A fourteen way switch structure, starting on line 0103, contains a branch for each recognized command placing a suitable message for each into theHelp. The last branch of the switch structure, on lines 0187 to 0191, provides help if the second term of the command was not recognized by the TextTuttle as a valid command. The method concludes, on line 0195, by returning the String contained in theHelp.

Figure 7.5 illustrates the operation of this method. The "help fd" command was typed in by the user and the help obtained, from lines 0105 to 0107 of the obtainHelp() method, is shown following the command in the feedback area. This was followed by a "help me" request which causes the UNKNOWN branch to be taken and the resulting message is shown.

The remaining checkExit() method is somewhat similar and is implemented as follows.

0078     private String checkExit( StringTokenizer tokenizer) {     0079        if ( (tokenizer.countTokens() == 1)  && 0080             (tokenizer.nextToken().toLowerCase().equals( "please")) ){  0081           System.exit( 0); 0082           return "";   0083        } else {                0084           return new String( "To exit from this application you have to " + 0085                              "type 'exit', followed by 'please'!");          0086        } // End if. 0087     } // End checkExit.

Lines 0079 and 0080 check to see if there is a second term following the exit command and, if so, if it is "please". Only if both these conditions are satisfied will the applet terminate on line 0081; a more complete applet might have to perform some housekeeping at this stage before exiting. Otherwise if the command was not given as exit please, on lines 0084 and 0085 advice on how to exit from the applet is returned to be displayed in theInterface's feedback area.




7.8 Evaluating the interfaces

7.6 The CommandLineTuttleInterface class

A Java GUI programmer's primer
Java GUI Programmers Primer, A
ISBN: 0139088490
EAN: 2147483647
Year: 1998
Pages: 85
Authors: Fintan Culwin

flylib.com © 2008-2017.
If you may any questions please contact us: flylib@qtcs.net