Java SE (Java Platform, Standard Edition)

Hi I would like to implement a 'reset' button which effectively clears the grid and allows new variables to be inputted in this sample GUI for a sudoku puzzle. Could anyone help me do this?

import java.awt.BorderLayout;
import java.awt.Color;
import java.awt.Component;
import java.awt.Dimension;
import java.awt.FlowLayout;
import java.awt.Font;
import java.awt.FontMetrics;
import java.awt.Graphics;
import java.awt.GraphicsConfiguration;
import java.awt.GridLayout;
import java.awt.HeadlessException;
import java.awt.Insets;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.MouseAdapter;
import java.awt.event.MouseEvent;
import java.util.Vector;

/*import javax.swing.BorderFactory;*/
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JMenuItem;
import javax.swing.JPanel;
import javax.swing.JPopupMenu;
import javax.swing.JTextField;

public class sudokuGUI extends JFrame
{
private static final int PUZZLE_DIAGRAM_INSET = 30;

private int[][] sudoku = new int[9][9];
private int[][] fixed = null;
private int[][] solution = null;
private int solutionNum = 0;
private Vector v;

// GUI components
private SudokuPanel sudokuPanel;
private JTextField message;
private JButton back;
private JButton next;
private JButton reset;
private JButton solve;

// Puzzle diagram values
private double cellDim;
private int xOffset;
private int yOffset;
private int width;
private int height;
private Font font;

// Mouse hits
private int xCell;
private int yCell;

public sudokuGUI()
{
super("Sudoku Solver");

setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
setLocation(50, 50);
setSize(520, 560);

initGUI();
}

private void initGUI()
{
JPanel southPanel = new JPanel(new GridLayout(2, 1));

message = new JTextField("Please enter the correct sudoku puzzle configuration you wish to solve");
message.setHorizontalAlignment(JTextField.CENTER);
message.setBackground(Color.white);
message.setEditable(false);
southPanel.add(message);

JPanel centeredFlowPanel = new JPanel(new FlowLayout(FlowLayout.CENTER));
back = new JButton("Back");
next = new JButton("Next");
solve = new JButton("Solve");
reset = new JButton("Reset");
back.setEnabled(false);
next.setEnabled(false);
SudokuActionListener listener = new SudokuActionListener();
back.addActionListener(listener);
solve.addActionListener(listener);
next.addActionListener(listener);
reset.addActionListener(listener);

centeredFlowPanel.add(back);
centeredFlowPanel.add(solve);
centeredFlowPanel.add(next);
centeredFlowPanel.add(reset);

southPanel.add(centeredFlowPanel);

sudokuPanel = new SudokuPanel();
sudokuPanel.addMouseListener(new SudokuMouseListener());
font = sudokuPanel.getFont().deriveFont(Font.BOLD, 30);

getContentPane().setLayout(new BorderLayout());
getContentPane().add(sudokuPanel, BorderLayout.CENTER);
getContentPane().add(southPanel, BorderLayout.SOUTH);
}

private void showPopup(Component panel, int x, int y)
{
JPopupMenu menu = new JPopupMenu();
JMenuItem item;
SudokuActionListener listener = new SudokuActionListener();

if ( x >= xOffset && y >= yOffset &&
x <= xOffset + width && y <= yOffset + height )
{
xCell = (int) Math.floor((double)(x - xOffset) / cellDim);
yCell = (int) Math.floor((double)(y - yOffset) / cellDim);

item = new JMenuItem("clear");
item.addActionListener(listener);
menu.add(item);

for (int i = 1; i <= 9; i++)
{
item = new JMenuItem( Integer.toString(i) );
item.addActionListener(listener);
menu.add(item);
}

menu.show(panel, x, y);
}
}

public static void main(String[] args)
{
sudokuGUI gui = new sudokuGUI();

gui.setVisible(true);
}

public class SudokuActionListener implements ActionListener
{
public void actionPerformed(ActionEvent e)
{
if (e.getActionCommand().equals("Back"))
{
next.setEnabled(true);

solution = (int[][]) v.get(--solutionNum);
solve.setText("Solution " + (solutionNum + 1) + " of " + v.size());

back.setEnabled(solutionNum > 0);
sudokuPanel.repaint();
}
else if (e.getActionCommand().equals("Next"))
{
back.setEnabled(true);

solution = (int[][]) v.get(++solutionNum);
solve.setText("Solution " + (solutionNum + 1) + " of " + v.size());

next.setEnabled(solutionNum < v.size() - 1);
sudokuPanel.repaint();
}
else if (e.getActionCommand().equals("Solve"))
{
sudokuSolver s = new sudokuSolver(sudoku);

try
{
v = s.solve();

fixed = s.getFixedSudoku();
if (v.size() > 0)
{
solution = (int[][]) v.get(solutionNum);
solve.setText("Solution 1 of " + v.size());

}
else
solve.setText("No solutions");

solve.setEnabled(false);
next.setEnabled(v.size() > 1);
message.setText(s.getSolutionTimeString(new Integer(v.size())));
sudokuPanel.repaint();
}
catch (Exception ex)
{
message.setBackground(Color.blue.brighter());
message.setText(ex.getMessage());
}
}
else
{
int newValue = 0;
if (!e.getActionCommand().equals("clear"))
{
newValue = Integer.parseInt( e.getActionCommand() );
}

sudoku[yCell][xCell] = newValue;
sudokuPanel.repaint();
}
}
}

public class SudokuMouseListener extends MouseAdapter
{
public void mouseClicked(MouseEvent e)
{
if (e.isPopupTrigger())
sudokuGUI.this.showPopup((Component)e.getSource(), e.getX(), e.getY());
}

public void mousePressed(MouseEvent e)
{
if (e.isPopupTrigger())
sudokuGUI.this.showPopup((Component)e.getSource(), e.getX(), e.getY());
}

public void mouseReleased(MouseEvent e)
{
if (e.isPopupTrigger())
sudokuGUI.this.showPopup((Component)e.getSource(), e.getX(), e.getY());
}
}

public class SudokuPanel extends JPanel
{
public void paintComponent(Graphics g)
{
super.paintComponent(g);

Dimension size = getSize();
Insets in = getInsets();

xOffset = in.left;
yOffset = in.top;

width = size.width - (in.right + in.left);
height = size.height - (in.bottom + in.top);

// Set background and border
g.setColor(Color.white);
g.fillRect(xOffset, yOffset, width, height);
g.setColor(Color.black);
g.drawRect(xOffset, yOffset, width - 1, height - 1);

int minDimension = Math.min(width, height);
minDimension -= (PUZZLE_DIAGRAM_INSET * 2);

xOffset += (width - minDimension) / 2;
yOffset += (height - minDimension) / 2;
width = height = minDimension;

// Draw the puzzle grid
g.drawRect(xOffset, yOffset, width - 1, height - 1);

cellDim = (double) (width - 1) / 9.0;

FontMetrics fm = g.getFontMetrics(font);
g.setFont(font);
for (int i = 1; i <= 9; i++)
{
int xPos = xOffset + (int)Math.rint(((double)i * cellDim));
int yPos = yOffset + (int)Math.rint(((double)i * cellDim));

if (i < 9)
{
g.setColor(Color.black);
g.drawLine( xPos, yOffset, xPos, yOffset + height - 1 );
g.drawLine( xOffset, yPos, xOffset + width - 1, yPos );

if (i % 3 == 0)
{
g.drawLine( xPos + 1, yOffset, xPos + 1, yOffset + height - 1 );
g.drawLine( xOffset, yPos + 1, xOffset + width - 1, yPos + 1 );
}
}

for (int c = 0; c < 9; c++)
{
int cellValue = 0;
if (sudoku[i-1][c] != 0)
{
cellValue = sudoku[i-1][c];
g.setColor(Color.black);
}
else if (fixed != null && fixed[i-1][c] != 0)
{
cellValue = fixed[i-1][c];
g.setColor(Color.red);
}
else if (solution != null && solution[i-1][c] != 0)
{
cellValue = solution[i-1][c];
g.setColor(Color.blue);
}

if (cellValue != 0)
{
String str = Integer.toString(cellValue);
int y = yPos - (((int)cellDim - fm.getMaxAscent()) / 2) - 2;
int x = xOffset + (int)Math.rint(((double)c * cellDim)) +
(((int)cellDim - fm.stringWidth(str)) / 2);

g.drawString( str, x, y );
}
}
}
}
}
}