Lab 5: The Game of Life

This week we'll have some fun with Java. Your program this week must do the following:

Much like last week, throw up a window with a 10 by 10 matrix of buttons all in an initial state "0". You may represent state "0" visually however you prefer as long as you use a distinct ImageIcon.
Like last week, allow the user to click any number of "cells" in this matrix to toggle the state to "1". Represent the state "1" visually with a different ImageIcon.
Unlike last week, place three buttons below or to the side of your grid of cells:
1. "next": This button should cycle the grid of cells through one iteration of Conway's Game of Life. The rules are as follows:
  - For a space that is 'populated':
    - Each cell with one or no neighbors dies, as if by loneliness,
    - each cell with four or more neighbors dies, as if by overpopulation, and
    - each cell with two or three neighbors survives.
  - For a space this is 'empty' or 'unpopulated':
    - Each cell with three neighbors becomes populated.
  These rules must be applied simultaneously to the entire grid of cells. (In other words, the new values for the cells can't be plugged back into the original matrix until you compute the entire next step, or the intermediate changes will impact the results of the cells which have not yet been computed!)
2. "go": This button should commence a continuous cycle whereby the grid of cells experiences one Life iteration per second. If the cycle is already happening, nothing special should happen. (The cycle should not speed up.)
3. "stop": This button should stop any such cycle started by the go button. If the Game of Life is not running, nothing should happen.
When the window close button is clicked, the window should close and the entire program should exit as well, returning the user to the command shell.

Hints and tips

Make sure you understand how to implement the Runnable interface. You'll need a Thread reference as a data member of your class so you can signal your Life-iterator thread that it's time to stop iterating. For more information on threads, read through the java tutorial on threads, especially these sections:
1. What is a Thread?
2. Customizing a Thread's run method
3. Implementing the Runnable interface
4. The life cycle of a Thread
Ignore the other sections for now; we'll deal with them later.
For this lab, treat out-of-bounds cells as unpopulated.

Design advice

There are lots of ways to design this program. Here is how we want you to do it:

Have a top-level class called Lab5 which handles command line arguments (if there are any), creates the graphical interface, starts it up, and does nothing else.
Have a class called Life whose instances hold the state and perform updates for a single life board. This class has nothing to do with the graphical interface, so it shouldn't have references to any graphical objects whatsoever. It should be usable on its own if desired.
Have a class called LifeGUI whose instances contain a Life instance as a field. This class will implement the Runnable interface in order to permit the creation and management of threads. This class will also have a two-dimensional array of LifeButtons (see below). The purpose of this class is to display the states of the LifeButtons, to allow the user to interact with the buttons and start or stop the board update, and to coordinate the updating of the Life instance, which holds the real state of the board.
Have a class called LifeButton whose instances hold the state for a single location on the life board. They should also have a reference to a Life instance in order to change the state of that instance when the button is clicked. In addition, this class must have a method that allows the LifeGUI instance to flip the state of the button when the board is updating itself.
Use anonymous inner classes defined in the LifeGUI class to implement the response to clicking on the "go", "stop", and "next" buttons.

Extra Credit

Accept a command-line argument indicating the size of the matrix of cells.
If the above argument is above some threshold, display the grid of cells within a scrollable interior window.
Have the grid of cells "wrap" around, so a slider or a gun can move or shoot things that come back on the other side of the screen.
Change your data representation so that you can represent an arbitrarily large matrix of cells. (Say, 10000 by 10000.)
Allow the user to "throttle" the speed of the iteration in some way. You could use a JSlider, a JComboBox, or a creative combination of multiple presses of your Go button combined with a label displaying the current throttle setting.
Do anything else cool ;-)