import java.awt.*;
import javax.swing.*;
import javax.swing.border.*;
import java.util.*;
import java.awt.event.*;
import java.io.*;

/**  A GUI for the game of Boggle.
 * 
 * BoggleGUI defines and implements methods to do these things:
 * 
 * 1.  Draw the boggle board
 * 2.  Manage the computer and human players' word lists
 * 3.  Update the scoreboard
 *
 * BoggleGUI requires class BogglePlayer, to define these instance methods:
 * <PRE>
 * public void buildLexicon(Set wordList)
 * public void setBoard(String[] letterArray)
 * public Vector getAllValidWords(int minimumWordLength)
 * public boolean isInLexicon(String wordToCheck)
 * public Vector isOnBoard(String wordToCheck)
 * public String[] getCustomBoard()
 * </PRE>
 *
 * @author Michael Green
 * @author Paul Kube
 * @author Eric Chown
 * @author Laura Toma
 *
 * Copyright (C) 2002 Michael Green <mtgreen@cs.ucsd.edu>
 * Copyright (C) 2002 Paul Kube <kube@cs.ucsd.edu>
 * Copyright (C) 2003 Eric Chown <chown@bowdoin.edu>
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; either version 2
 * of the License, or (at your option) any later version.  See
 * http://www.gnu.org/copyleft/gpl.html
 */
public class BoggleGUI extends JFrame {

  public static String WORDLISTFILENAME = "dict.txt";  // default
  public static  int DICEROWS = 4;  // default 4
  public static  int DICECOLS = 4;  // default 4
  public static  int MINIMUMWORDLENGTH = 4; // default
  
  
  private BogglePlayer computerPlayer;
  private BoggleBoard theBoard;
  private ScoreArea humanArea, computerArea;
  private WordEntryField wordEntryField;
        
  public BoggleGUI()  {
    super("Welcome to CS 210!");
                
    // create a BogglePlayer computer player to use
    computerPlayer = new BogglePlayer(MINIMUMWORDLENGTH, DICEROWS, DICECOLS);
    // Read word list from file and initialize computerPlayer's Lexicon
    initLexicon();
    // Intialize graphics panels
    initPanels();
    // Establish menu bar options and listeners for them
    setUpMenuBar();
    // WindowClosing listener:  for JDK 1.2 compatibility
    addWindowListener(new WindowAdapter() {
	    public void windowClosing(WindowEvent e) {
		System.exit(0);
	    }});
    // Trust contained components to set their sizes; top level frame packs
    pack();
  }

  /**
   * Get ready for a new game, given a letter list specification of
   * the Boggle board.
   * @param letterList specification of the board
   * @return void
   */
    public void newGame(String[] letterList)  {
    // Tell theBoard about the board layout
	theBoard.setBoard(letterList);
	// Tell computerPlayer about the board layout
	computerPlayer.setBoard(letterList);
	// Prepare score areas
	humanArea.setReady();
	computerArea.setReady();
	// Clear board highlighting
	theBoard.unHighlightAllDice();
	// Allow edits to text area and set focus
	wordEntryField.setReady();
	// redraw the whole thing so it looks as nice as can be
	repaint();
    }
    
    
  /**
   * Consider a word entered by the human player.
   * @param wordToCheck word entered by human
   * @return Nothing, but highlight the letters when on board
   */
    public void checkAndAddWordHuman(String wordToCheck)   {
	
	// clear any board highlighting
	theBoard.unHighlightAllDice();
	
	// if empty word, the computer gets to take its turn
	if(wordToCheck.length() == 0)      {
	    wordEntryField.setUnready();
	    computerPlay();
	    return;
	}
	
    // check that word is:
    // (1) at least minimum length, (2) on the board, (3) in the lexicon,
    // (4) not already entered by the player
    if(wordToCheck.length() <  MINIMUMWORDLENGTH)      {
      chideUser(wordToCheck, "Less Than " + MINIMUMWORDLENGTH + " Letters");
      return;
    }
    
    Vector letterLocations;
    
    // letterLocations = theBoard.getLocationsForWord(wordToCheck);
    // String wordOnBoard = theBoard.getWordFromLocations(letterLocations);
    //    if(!wordToCheck.equalsIgnoreCase(wordOnBoard)) { // double check

    // we just trust the computer player to check this
    letterLocations = computerPlayer.isOnBoard(wordToCheck);
    if(letterLocations == null) { 
      chideUser(wordToCheck, "Not On Board");
      return;
    }

    if(!computerPlayer.isInLexicon(wordToCheck))          {
      chideUser(wordToCheck, "Not In Lexicon");
      return;
    }
    
    if(humanArea.containsWord(wordToCheck)) {
	chideUser(wordToCheck, "Duplicate Word");
	return;
    }
    
    // OK, this word passed our rigorous suite of tests.  Add it
    humanArea.addWord(wordToCheck);
    // Highlight locations on board
    theBoard.highlightDice(letterLocations);
    wordEntryField.clear();      //clear the wordEntryField text
    }
    


  /**
   * Print a message that the human player did something wrong.
   * @param attemptedWord  The word the human entered
   *        complaint      Description of what went wrong
   * @return void
   */
    public void chideUser(String attemptedWord, String complaint) {
	JOptionPane.showMessageDialog(this,
				      attemptedWord + ": " + complaint + "!!!",
				      complaint,
				      JOptionPane.ERROR_MESSAGE);
	wordEntryField.clear();      //clear the wordEntryField text
    }



  /**
   * Let the computer player take its turn.
   * @param none
   * @return nothing, but highlights words computer got and computes its score
   */
  public void computerPlay() {
    computerArea.setName("Thinking!");
    computerArea.paintImmediately(computerArea.getVisibleRect());
    Vector<String> allWords = computerPlayer.getAllValidWords(MINIMUMWORDLENGTH);
    if (allWords == null) {
	System.out.println("getAllValidWords returns null; cannot play"); 
	System.exit(1); 
    }
    Iterator allWordsIterator = allWords.iterator();
    computerArea.setName("Computer");
    while(allWordsIterator.hasNext())     {
	String newWord = (String) allWordsIterator.next();
	Vector wordPath = computerPlayer.isOnBoard(newWord);
	// Add word to appropriate score area & highlight appropriate dice
	computerArea.addWord(newWord);
	theBoard.highlightDice(wordPath);
	// pause for a tenth of a second
	//try {Thread.sleep(100); }   catch (Exception e) {}
    }
    theBoard.unHighlightAllDice(); // leave board unhighlighted when done
    
    //computerPlayer.debug();  //Show debug info
  } 
    
    



  /**
   * Read word list from file with name WORDLISTFILENAME, and pass a Set
   * containing those words to the computer player to intialize its lexicon.
   * @param none
   * @return void
   */
  private void initLexicon()  { 
    boolean EOF = false;
    HashSet<String> wordsFromFile = new HashSet<String>();
    System.err.print("Reading word list from file " + WORDLISTFILENAME + "...");
    try      {
      // Open File
      BufferedReader input = new BufferedReader( new FileReader(WORDLISTFILENAME));
      String nextWord;
      while((nextWord = input.readLine()) != null)
        // there is a contract that these are all lowercase but
        // we'll just assume it here for speed
        wordsFromFile.add(nextWord);

      //Close the file
      input.close();
    } catch (FileNotFoundException fnfex )      {
      JOptionPane.showMessageDialog(null, 
                                    "Unable to find word list file " + WORDLISTFILENAME, "Error",
                                    JOptionPane.ERROR_MESSAGE);
    }
    catch( IOException e)       {
      JOptionPane.showMessageDialog(null, 
                                    "Error Opening File", "Error",
                                    JOptionPane.ERROR_MESSAGE);
    }
    System.err.println(" Read " + wordsFromFile.size() + " words.");
    System.err.print("Building player's lexicon... ");
    computerPlayer.buildLexicon(wordsFromFile);
    System.err.println("done.");
  }




    /**
     * Initialize graphic display.
     * @param none
     * @return void
     */
    private void initPanels()  {
	Container contentPane = getContentPane();
	humanArea = new ScoreArea("Me");
	computerArea = new ScoreArea("Computer");
	theBoard = new BoggleBoard(DICEROWS,DICECOLS,computerPlayer);
	wordEntryField = new WordEntryField();
	contentPane.add(wordEntryField,BorderLayout.SOUTH);
	contentPane.add(humanArea, BorderLayout.WEST);
	contentPane.add(theBoard, BorderLayout.CENTER);
	contentPane.add(computerArea, BorderLayout.EAST);
    }
    

    

  /**
   * Initialize menus for controlling game.
   * @param none
   * @return void
   */
    private void setUpMenuBar()  {
	//Set Up Menu Bar
	JMenuBar menu = new JMenuBar();
	
	// Game Menu
	JMenu gameMenu = new JMenu("Game");
	gameMenu.setMnemonic('G');
	menu.add(gameMenu);
	
	JMenuItem newRandom = new JMenuItem("New Random");
	gameMenu.add(newRandom);
	newRandom.setMnemonic('N');
	newRandom.addActionListener(new ActionListener() {
		public void actionPerformed( ActionEvent e) {
		    newGame(theBoard.getRandomBoard());
		}});
	
	JMenuItem customGame = new JMenuItem("New Custom");
	gameMenu.add(customGame);
	customGame.setMnemonic('C');
	customGame.addActionListener(new ActionListener() {
		public void actionPerformed( ActionEvent e) {
		    newGame(computerPlayer.getCustomBoard());
		}});
	
	JMenuItem quitGame = new JMenuItem("Quit");
	gameMenu.add(quitGame);
	quitGame.setMnemonic('Q');
	quitGame.addActionListener( new ActionListener() {
		public void actionPerformed( ActionEvent e) {
		    System.exit(0);
		}});
	
	// Help menu
	JMenu helpMenu = new JMenu("Help");
	menu.add(helpMenu);
	helpMenu.setMnemonic('H');
	
	JMenuItem aboutGame = new JMenuItem("About...");
	helpMenu.add(aboutGame);
	aboutGame.setMnemonic('A');
	aboutGame.addActionListener(new ActionListener() {
		public void actionPerformed( ActionEvent e)  {
		    JOptionPane.showMessageDialog(BoggleGUI.this,
						  "It's ABOUT time you got to work", 
						  "About Game",
						  JOptionPane.PLAIN_MESSAGE);
		}});
	setJMenuBar(menu);
    }
    


    





  /**
   * A class defining the visual appearance of a Boggle board, and
   * defining some related methods.
   */
    static class BoggleBoard extends JPanel {
	public static final Color BACKGROUNDCOLOR = new Color(255, 219, 13);
	
	private DiePanel theDice[][];
	private Vector<Die> diceBag;  // used for drawing a random game
	private int rows, cols;
	private BogglePlayer theComputer;
	
	BoggleBoard(int rows, int cols, BogglePlayer theComputer ) {
	    this.rows = rows; this.cols = cols;
	    this.theComputer = theComputer;
	    
	    // create some dice to use when getting a random game
	    initDiceBag();
	    
	    // create a JPanel with rowsXcols GridLayout to hold the DiePanels
	    JPanel innerPanel = new JPanel();
	    innerPanel.setLayout(new GridLayout(rows,cols,1,1));
	    innerPanel.setBackground(BACKGROUNDCOLOR);
	    
	    // Create Individual DiePanels, and add them
	    theDice = new DiePanel[rows][cols];
	    for (int row = 0; row < rows; row++)      {
		for (int col = 0; col < cols; col++)      {
		    theDice[row][col] = new DiePanel();
		    
		    innerPanel.add(theDice[row][col]);
		}
	    }
	    innerPanel.setBorder(BorderFactory.createMatteBorder(10,10,10,10,      
								 BACKGROUNDCOLOR));
	    this.add(innerPanel);
	}
	

    /**
     * fill the diceBag with the 16 "official" Boggle dice for the 4X4 game
     * @param none
     * @return void
     */
	private void initDiceBag() {
	    diceBag = new Vector<Die>(16);
	    diceBag.add(new Die("A", "O", "B", "B", "O", "J"));
	    diceBag.add(new Die("W", "H", "G", "E", "E", "N"));
	    diceBag.add(new Die("N", "R", "N", "Z", "H", "L"));
	    diceBag.add(new Die("N", "A", "E", "A", "G", "E"));
	    diceBag.add(new Die("D", "I", "Y", "S", "T", "T"));
	    diceBag.add(new Die("I", "E", "S", "T", "S", "O"));
	    diceBag.add(new Die("A", "O", "T", "T", "W", "O"));
	    diceBag.add(new Die("H", "Qu", "U", "M", "N", "I"));
	    diceBag.add(new Die("R", "Y", "T", "L", "T", "E"));
	    diceBag.add(new Die("P", "O", "H", "C", "S", "A"));
	    diceBag.add(new Die("L", "R", "E", "V", "Y", "D"));
	    diceBag.add(new Die("E", "X", "L", "D", "I", "R"));
	    diceBag.add(new Die("I", "E", "N", "S", "U", "E"));
	    diceBag.add(new Die("S", "F", "F", "K", "A", "P"));
	    diceBag.add(new Die("I", "O", "T", "M", "U", "C"));
	    diceBag.add(new Die("E", "H", "W", "V", "T", "R"));
	}
	
	/**
	 * Return an array of Strings showing the sequence of faces on
	 * a randomly generated board.
	 * @param none
	 * @return array of strings representing the letters on the board
	 */
	public String[] getRandomBoard()  {
	    // Get random faces from randomy selected dice to fill the letterList
	    int diceBagSize = diceBag.size();
	    int boardSize = rows * cols;
	    String[] letterList = new String[(rows * cols)];
	    // we try to handle any size board with a fixed diceBag
	    for (int i = 0; i<boardSize; i++) {
		if(i % diceBagSize == 0 )  Collections.shuffle(diceBag);
		Die d = (Die) diceBag.elementAt(i % diceBagSize);
		letterList[i] =   d.getRandomFace();
	    }
	    // set the corresponding DiePanels, and return the result
	    return letterList;
	}
	
	
    /**
     * Non-randomly reset the board according to 
     * an array of Strings showing the sequence of faces on
     * the new board.  Return the array.
     * @param letterList an array of strings to use for the board
     * @return void
     */
	public void setBoard(String[] letterList)  {
	    if(letterList == null ||
	       letterList.length != rows*cols) {
		throw new IllegalArgumentException("setBoard(): String array length is not " + rows*cols);
	    }
	    
	    //Set the DiePanels with given letters
	    for (int row = 0; row < rows; row++)  {
		for (int col = 0; col < cols; col++)  {
		    theDice[row][col].setFace(letterList[(row*cols) + col]);
		}
	    }
	}
	

	
	/**
	 * Find the locations of the letters for a legal word.  We
	 * cheat and let the computer player do this for us.
	 * @param word the word to fnd on the board
	 * @return Vector of locations, one for each letter
	 * @see BogglePlayer
	 */
	public Vector getLocationsForWord(String word) {
	    // we use the computer player for this
	    return theComputer.isOnBoard(word);
	}


	/**
	 * Given a list of locations, recreate the word at the locations.
	 * @param locations Vector containing the letter placements
	 * @return String of letters
	 */
	public String getWordFromLocations(Vector locations) {
	    int loc;
	    int row,col;
	    if (locations==null) return null;
	    String result = "";
	    for(int i = 0; i < locations.size(); i++)              {
		loc = ((Integer)locations.get(i)).intValue();
		row = loc / rows;
		col = loc % cols;
		result += theDice[row][col].getFace();
	    }
	    return result;
	}
	
	
	/**
	 * Highlight the dice corresponding to the chosen word.
	 * @param locations for each die
	 * @return void
	 */
	public void highlightDice(Vector locations) {
	    if(locations == null) return;
	    
	    Integer loc;
	    int row, col;
	    
	    unHighlightAllDice();
	    for(int i = 0; i < locations.size(); i++) {
		highlightDie((Integer) locations.get(i));
	    }
	    this.paintImmediately(this.getVisibleRect());
	}
	
	
	/**
	 * Highlight the specified die, given row and column.
	 * @param row
	 *        col
	 * @return void
	 */
	public void highlightDie(int row, int column) {
	    theDice[row][column].highlight();
	}
	
	/**
	 * Highlight the specified die, given Integer offset
	 * from upper-left-hand corner, using left-to-right,
	 * top-to-bottom ordering of dice.
	 * @param indx the die's location
	 * @return void
	 */
	public void highlightDie(Integer indx) {
	    int i = indx.intValue();
	    int row = i / theDice[0].length;
	    int col = i % theDice[0].length;
	    highlightDie(row, col);
	}


	
	/**
	 * Unhighlight all dice.
	 */
	public void unHighlightAllDice()  {
	    for (int row = 0; row < theDice.length; row++)   {
		for (int col = 0; col < theDice[row].length; col++)  {
		    theDice[row][col].unHighlight();
		}
	    }
	    this.paintImmediately(this.getVisibleRect());
	}
	
	
	/**
	   Helper class used to represent dice.
	*/
	static class Die {
	    private String[] sides;
	    private int currentSideUp;
	    public Random randomizer = new Random();
	    
	    public Die(String side1, String side2, String side3,
		       String side4, String side5, String side6)    {
		sides = new String[] {side1,side2,side3,side4,side5,side6};
		randomize();
	    }
	    
	    
	    /**
	     * Given the state of the die, retrieves the letter on top.
	     * @return String the letter
	     */
	    public String getLetter()    {
		return sides[currentSideUp];
	    }
	    
	    /**
	     * Picks a side of the die at random and returns the letter.
	     * @return String the letter chosen.
	     */
	    public String getRandomFace()    {
		randomize();
		return sides[currentSideUp];
	    }
	    
	    /**
	     * Picks a number between 0 and 5.
	     */
	    private void randomize()    {
		currentSideUp = randomizer.nextInt(6);
	    }
	}
	
	
	
	
	
	
	/** For displaying one Die on the board
	 */
	static class DiePanel extends JPanel {
	    private String face;
	    private boolean isHighlighted;
	    private JLabel faceLabel;
	    
	    private final Color DIECOLOR = new Color(230, 230, 230);
	    private final Color FACECOLOR = new Color(3, 51, 217);
	    
	    private final Font FACEFONT = new Font("SansSerif", Font.PLAIN, 24);
	    private final int DIESIZE = 50;
	    
	    public DiePanel()  {
		face = new String(""); 
		faceLabel = new JLabel("", SwingConstants.CENTER);
		setLayout(new BorderLayout());
		add(faceLabel, BorderLayout.CENTER);
		setBackground(BoggleBoard.BACKGROUNDCOLOR);
		setSize(DIESIZE, DIESIZE);
	    }
	    
	    public Dimension getPreferredSize()  {
		return (new Dimension (DIESIZE+1, DIESIZE+1));
	    }
	    
	    public Dimension getMinimumSize()  {
		return (getPreferredSize());
	    }
	    
	    public void setFace( String chars )  {
		face = chars;
	    }
	    
	    public String getFace() {
		return face;
	    }
	    
	    /**
	     * Draw one die including the letter centered in the middle of the die.
	     * If highlight is true, we 
	     * reverse the background and letter colors to highlight the die.
	     */
	    public void paintComponent(Graphics g)  {
		super.paintComponent(g);
                
		int centeredXOffset, centeredYOffset;
		// Draw the blank die
		g.setColor( (isHighlighted) ? FACECOLOR : DIECOLOR);
		g.fillRoundRect( 0, 0, DIESIZE, DIESIZE, DIESIZE/2, DIESIZE/2);
                
		// Outline the die with black
		g.setColor(Color.black);
		g.drawRoundRect( 0, 0, DIESIZE, DIESIZE, 
				 DIESIZE/2, DIESIZE/2);
		Graphics faceGraphics = faceLabel.getGraphics();
		faceGraphics.setColor( isHighlighted ? DIECOLOR : FACECOLOR);   
		Color myColor =  isHighlighted ? DIECOLOR : FACECOLOR;  
		faceLabel.setForeground(myColor);
		faceLabel.setFont(FACEFONT);
		faceLabel.setText(face);
	    }
	    
	    public void unHighlight()  {
		isHighlighted = false;
	    }
	    
	    public void highlight()  {
		isHighlighted = true;
	    }
	}
	
    } // class BoggeBoard
    

    /** Maintains name, score, and word list information for one player
     */
    class ScoreArea extends JPanel {
	private final int WORDAREALINES = 16;
	private String playerName;
	private int playerScore, dimensionX, dimensionY;
	private HashSet<String> wordList;
        
	private final Font ScoreFont = new Font("SansSerif", Font.PLAIN, 18);
	private final Font WordFont = new Font("Geneva", Font.PLAIN, 9);
	private final Font LabelFont = new Font("Helvitica", Font.PLAIN, 9);
	
	private final Color WordColor = new Color(3, 128, 77);
	private final Color LabelColor = new Color(3, 115, 64);
	
	private JPanel topPanel, wordPanel, namePanel, scorePanel;
	private JTextArea wordArea;
	private JLabel nameText, scoreText;
        
	public ScoreArea(String player) {
	    playerName = new String(player);
	    playerScore = 0;
	    wordList = new HashSet<String>();
	    
	    // Set-Up Top of Score Area
	    namePanel = new JPanel();
	    nameText = new JLabel(player);
	    nameText.setFont(ScoreFont);
	    namePanel.setLayout( new BorderLayout() );
	    namePanel.add(nameText, BorderLayout.CENTER);
	    
	    scorePanel = new JPanel();
	    scoreText = new JLabel("  0");
	    scoreText.setFont(ScoreFont);
	    scorePanel.setLayout( new BorderLayout() );
	    scorePanel.add(scoreText, BorderLayout.CENTER);
	    
	    topPanel = new JPanel();
	    topPanel.setLayout( new BorderLayout());
	    topPanel.add(namePanel, BorderLayout.WEST);
	    topPanel.add(scorePanel, BorderLayout.EAST);
	    
	    // Create bordering for top panel
	    Border raisedBevel, loweredBevel, compound;
                
	    raisedBevel = BorderFactory.createRaisedBevelBorder();
	    loweredBevel = BorderFactory.createLoweredBevelBorder(); 
	    compound = BorderFactory.createCompoundBorder(raisedBevel,
							  loweredBevel);
	    topPanel.setBorder(compound);
                
	    // Set-Up area to display word list
	    wordPanel = new JPanel();
	    Border etched = BorderFactory.createEtchedBorder();
	    TitledBorder etchedTitle =
		BorderFactory.createTitledBorder(etched, "Word List");
	    etchedTitle.setTitleJustification(TitledBorder.RIGHT);
	    wordPanel.setBorder(etchedTitle);
	    wordArea = new JTextArea(WORDAREALINES,
				     // 2/3 of max word len is a good # of columns
				     BoggleGUI.DICEROWS*BoggleGUI.DICECOLS*2/3);
	    wordArea.addMouseListener(new MouseAdapter() {
		    public void mouseClicked(MouseEvent e) {
			// if double-click, highlight the selection on the board
			if(e.getClickCount() == 2) {
			    String word = wordArea.getSelectedText().trim();
			    theBoard.highlightDice(theBoard.getLocationsForWord(word));
			}
		    }});
	    wordArea.setEditable(false); // for now
	    wordPanel.add(new JScrollPane(wordArea,
					  JScrollPane.VERTICAL_SCROLLBAR_ALWAYS,
					  JScrollPane.HORIZONTAL_SCROLLBAR_AS_NEEDED));

	    setLayout(new BorderLayout());
	    add(topPanel, BorderLayout.NORTH);
	    add(wordPanel, BorderLayout.CENTER);
	}

	public void setReady()  {
	    resetScore();  // zero out score
	    wordList.clear();  // remove words from HashSet
	    // remove words from TextArea
	    wordArea.setEditable(true);
	    wordArea.selectAll();
	    wordArea.cut();
	    wordArea.setEditable(false);
	    paintImmediately(getVisibleRect());
	}

	public void setName(String newName)  {
	    playerName = newName;
	    nameText.setText(playerName);
	    repaint();
	}

	public boolean containsWord(String word) {
	    return wordList.contains(word);
	}

	public void addWord(String word)  {
	    if (containsWord(word)) return;
	    wordList.add(word);
	    wordArea.append(" " +word+"\n");
	    addPoints(pointsForWord(word));
	    wordArea.paintImmediately(wordArea.getVisibleRect());
	}

	/**
	 * Define how many points a player gets for a given word.
	 */
	public int pointsForWord(String word) {
	    return word.length() - BoggleGUI.MINIMUMWORDLENGTH + 1;
	}

	public void addPoints(int points)  {
	    playerScore += points;
	    scoreText.setText(playerScore+"");
	    scoreText.paintImmediately(scoreText.getVisibleRect());
	}

	public void resetScore() {
	    playerScore = 0;
	    scoreText.setText(playerScore+"");
	    scoreText.paintImmediately(scoreText.getVisibleRect());
	}

    } // class ScoreArea




    class WordEntryField extends JPanel {
	private JTextField textField;
    
	public WordEntryField() {
	    //Set up for human player's Text Entry Field
	    textField = new JTextField(30);
	    //Add listener to text entry field
	    textField.addActionListener( new ActionListener() {
		    public void actionPerformed( ActionEvent e) {
			checkAndAddWordHuman(textField.getText());
		    }});
	    this.add(new JLabel("Enter word: "));
	    this.add(textField);
	    setUnready();
	}

	public void clear() {
	    textField.setText("");
	}

	public void setUnready() {
	    clear();
	    textField.setEditable(false);
	    paintImmediately(getVisibleRect());
	    // attempt to give up focus to top-level frame
	    BoggleGUI.this.requestFocus();
	}
	public void setReady() {
	    textField.setEditable(true);
	    textField.requestFocus();
	}
    } // class WordEntryField

    /**
     * The entry point for the BoggleGUI application.
     * Usage:
     * java BoggleGUI [ wordfile [ rows [ columns [ minwordlength ]]]]
     */
    public static void main(String args[] )  {
	if(args.length > 0) WORDLISTFILENAME = args[0];
	if(args.length > 1) DICEROWS = Integer.parseInt(args[1]);
	if(args.length > 2) DICECOLS = Integer.parseInt(args[2]);
	if(args.length > 3) MINIMUMWORDLENGTH = Integer.parseInt(args[3]);

	System.err.println("Starting " + DICEROWS + "x" + DICECOLS + " game," +
			   " words from " + WORDLISTFILENAME +
			   ", min word length " + MINIMUMWORDLENGTH + ".");
	(new BoggleGUI()).setVisible(true);
    }

} //class BoggleGUI