/* J2dBenchmarkGUI.java -- GUI for java2d benchmarker
 Copyright (C) 2006  Free Software Foundation, Inc.

 This file is part of GNU Classpath.

 GNU Classpath 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, or (at your option)
 any later version.

 GNU Classpath is distributed in the hope that it will be useful, but
 WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 General Public License for more details.

 You should have received a copy of the GNU General Public License
 along with GNU Classpath; see the file COPYING.  If not, write to the
 Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
 02110-1301 USA.

 Linking this library statically or dynamically with other modules is
 making a combined work based on this library.  Thus, the terms and
 conditions of the GNU General Public License cover the whole
 combination.

 As a special exception, the copyright holders of this library give you
 permission to link this library with independent modules to produce an
 executable, regardless of the license terms of these independent
 modules, and to copy and distribute the resulting executable under
 terms of your choice, provided that you also meet, for each linked
 independent module, the terms and conditions of the license of that
 module.  An independent module is a module which is not derived from
 or based on this library.  If you modify this library, you may extend
 this exception to your version of the library, but you are not
 obligated to do so.  If you do not wish to do so, delete this
 exception statement from your version. */

package gnu.classpath.examples.java2d;

import java.awt.BorderLayout;
import java.awt.Color;
import java.awt.Container;
import java.awt.GridBagConstraints;
import java.awt.GridBagLayout;
import java.awt.GridLayout;
import java.awt.Insets;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;
import java.util.ArrayList;
import java.util.Hashtable;
import java.util.Iterator;
import java.util.logging.Handler;
import java.util.logging.Level;
import java.util.logging.LogRecord;

import javax.swing.Box;
import javax.swing.BoxLayout;
import javax.swing.ButtonGroup;
import javax.swing.JButton;
import javax.swing.JCheckBox;
import javax.swing.JComboBox;
import javax.swing.JComponent;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JPanel;
import javax.swing.JRadioButton;
import javax.swing.JScrollPane;
import javax.swing.JTextArea;
import javax.swing.JTextField;
import javax.swing.border.BevelBorder;

/**
 * Extends the J2dBenchmark to provide a GUI for selecting options and tests.
 */
public class J2dBenchmarkGUI
    implements ActionListener
{

  JLabel errorLabel;

  JCheckBox noClipping;

  JCheckBox withClipping;

  JCheckBox zeroClipping;

  JCheckBox singleBuffer;

  JCheckBox doubleBuffer;

  public J2dBenchmarkGUI()
  {
    super();
  }

  public static void main(String[] args)
  {
    new J2dBenchmarkGUI().run();
  }

  /**
   * Sets up the initial GUI
   */
  public void run()
  {
    // Store all elements in a hashtable so that they can be passed into the
    // harness easily.
    Hashtable elements = new Hashtable();

    // Set up frame
    final JFrame frame = new JFrame("Java2D benchmark");
    errorLabel = new JLabel(" ");

    JPanel panel = new JPanel();
    panel.setLayout(new BoxLayout(panel, BoxLayout.PAGE_AXIS));
    Container content = frame.getContentPane();

    // Display options for dimensions, iterations, test size, etc
    JPanel options = new JPanel(new GridLayout(0, 2));

    options.add(new JLabel("Height: "));
    JTextField heightField = new JTextField(Integer.toString(J2dBenchmark.DEFAULT_SCREEN_HEIGHT));
    heightField.setColumns(5);
    options.add(heightField);
    elements.put("height", heightField);

    options.add(new JLabel("Width: "));
    JTextField widthField = new JTextField(Integer.toString(J2dBenchmark.DEFAULT_SCREEN_WIDTH));
    widthField.setColumns(5);
    options.add(widthField);
    elements.put("width", widthField);

    options.add(new JLabel("Iterations: "));
    JTextField iterField = new JTextField("1");
    iterField.setColumns(5);
    options.add(iterField);
    elements.put("iterations", iterField);

    options.add(new JLabel("Test size: "));
    JTextField testSizeField = new JTextField(Integer.toString(J2dBenchmark.DEFAULT_TEST_SIZE));
    testSizeField.setColumns(5);
    options.add(testSizeField);
    elements.put("size", testSizeField);

    options.add(new JLabel("Test without clipping: "));
    noClipping = new JCheckBox("", true);
    noClipping.addActionListener(this);
    options.add(noClipping);
    elements.put("noclip", noClipping);

    options.add(new JLabel("Test with clipping: "));
    withClipping = new JCheckBox("", true);
    withClipping.addActionListener(this);
    options.add(withClipping);
    elements.put("withclip", withClipping);

    options.add(new JLabel("Test with clipping to zero: "));
    zeroClipping = new JCheckBox("", true);
    zeroClipping.addActionListener(this);
    options.add(zeroClipping);
    elements.put("zeroclip", zeroClipping);

    options.add(new JLabel("Run single-buffer test: "));
    singleBuffer = new JCheckBox("", true);
    singleBuffer.addActionListener(this);
    options.add(singleBuffer);
    elements.put("singlebuffer", singleBuffer);

    options.add(new JLabel("Run double-buffer test: "));
    doubleBuffer = new JCheckBox("", true);
    doubleBuffer.addActionListener(this);
    options.add(doubleBuffer);
    elements.put("doublebuffer", doubleBuffer);

    // Allow user to select tests to run
    JPanel tests = new JPanel();
    tests.setLayout(new BoxLayout(tests, BoxLayout.PAGE_AXIS));
    tests.setBorder(new BevelBorder(BevelBorder.RAISED));
    tests.add(new JLabel("Shapes to test:"));

    JCheckBox test_arcDraw = new JCheckBox("Arc", true);
    tests.add(test_arcDraw);
    elements.put("test_arcDraw", test_arcDraw);

    JCheckBox test_ccurveDraw = new JCheckBox("Cubic Curve", true);
    tests.add(test_ccurveDraw);
    elements.put("test_ccurveDraw", test_ccurveDraw);

    JCheckBox test_ellipseDraw = new JCheckBox("Ellipse", true);
    tests.add(test_ellipseDraw);
    elements.put("test_ellipseDraw", test_ellipseDraw);

    /*
     JCheckBox test_pathDraw = new JCheckBox("General Path", true);
     tests.add(test_pathDraw);
     elements.put("test_pathDraw", test_pathDraw);
     */

    JCheckBox test_lineDraw = new JCheckBox("Line", true);
    tests.add(test_lineDraw);
    elements.put("test_lineDraw", test_lineDraw);

    JCheckBox test_qcurveDraw = new JCheckBox("Quadratic Curve", true);
    tests.add(test_qcurveDraw);
    elements.put("test_qcurveDraw", test_qcurveDraw);

    JCheckBox test_rectDraw = new JCheckBox("Rectangle", true);
    tests.add(test_rectDraw);
    elements.put("test_rectDraw", test_rectDraw);

    JCheckBox test_rrectDraw = new JCheckBox("Round Rectangle", true);
    tests.add(test_rrectDraw);
    elements.put("test_rrectDraw", test_rrectDraw);

    JCheckBox test_image = new JCheckBox("Images", true);
    tests.add(test_image);
    elements.put("test_image", test_image);

    // Additional image-processing options
    JPanel extras = new JPanel();
    extras.setBorder(new BevelBorder(BevelBorder.LOWERED));
    GridBagLayout layout = new GridBagLayout();
    GridBagConstraints gbc = new GridBagConstraints();
    gbc.anchor = GridBagConstraints.NORTHWEST;
    gbc.insets = new Insets(5, 2, 15, 15);
    extras.setLayout(layout);

    // Filling (solid, gradient, or texture)
    JPanel opt_Fill = new JPanel();
    opt_Fill.setLayout(new BoxLayout(opt_Fill, BoxLayout.PAGE_AXIS));
    JLabel opt_FillLabel = new JLabel("Filling:");
    opt_FillLabel.setBorder(new BevelBorder(BevelBorder.RAISED));
    opt_Fill.add(opt_FillLabel);

    ButtonGroup opt_FillGroup = new ButtonGroup();
    JRadioButton opt_FillSolid = new JRadioButton("Solid colour", true);
    opt_FillSolid.setActionCommand("solid");
    opt_Fill.add(opt_FillSolid);
    opt_FillGroup.add(opt_FillSolid);
    JRadioButton opt_FillGradient = new JRadioButton("Gradient", false);
    opt_FillGradient.setActionCommand("gradient");
    opt_Fill.add(opt_FillGradient);
    opt_FillGroup.add(opt_FillGradient);
    JRadioButton opt_FillTexture = new JRadioButton("Texture", false);
    opt_FillTexture.setActionCommand("texture");
    opt_Fill.add(opt_FillTexture);
    opt_FillGroup.add(opt_FillTexture);
    JTextField opt_FillTextureFile = new JTextField("texture file");
    opt_FillTextureFile.setAlignmentX(JComponent.LEFT_ALIGNMENT);
    opt_Fill.add(opt_FillTextureFile);
    elements.put("opt_FillGroup", opt_FillGroup);
    elements.put("opt_FillTextureFile", opt_FillTextureFile);
    layout.setConstraints(opt_Fill, gbc);
    extras.add(opt_Fill);

    // Stroke
    JPanel opt_Stroke = new JPanel();
    opt_Stroke.setLayout(new BoxLayout(opt_Stroke, BoxLayout.PAGE_AXIS));
    JLabel opt_StrokeLabel = new JLabel("Stroke:");
    opt_StrokeLabel.setBorder(new BevelBorder(BevelBorder.RAISED));
    opt_Stroke.add(opt_StrokeLabel);
    JCheckBox opt_StrokeRandom = new JCheckBox("random", false);
    elements.put("opt_StrokeRandom", opt_StrokeRandom);
    opt_Stroke.add(opt_StrokeRandom);
    gbc.gridwidth = GridBagConstraints.REMAINDER;
    layout.setConstraints(opt_Stroke, gbc);
    extras.add(opt_Stroke);

    // Anti-Alias
    JPanel opt_Alias = new JPanel();
    opt_Alias.setLayout(new BoxLayout(opt_Alias, BoxLayout.PAGE_AXIS));
    JLabel opt_AliasLabel = new JLabel("Anti-Aliasing:");
    opt_AliasLabel.setBorder(new BevelBorder(BevelBorder.RAISED));
    opt_Alias.add(opt_AliasLabel);
    JCheckBox opt_AliasOn = new JCheckBox("on", false);
    elements.put("opt_AliasOn", opt_AliasOn);
    opt_Alias.add(opt_AliasOn);
    gbc.gridwidth = 1;
    layout.setConstraints(opt_Alias, gbc);
    extras.add(opt_Alias);

    // Alpha composite
    JPanel opt_Composite = new JPanel();
    opt_Composite.setLayout(new BoxLayout(opt_Composite, BoxLayout.PAGE_AXIS));
    JLabel opt_CompositeLabel = new JLabel("Alpha Composite:");
    opt_CompositeLabel.setBorder(new BevelBorder(BevelBorder.RAISED));
    opt_Composite.add(opt_CompositeLabel);
    JTextField opt_CompositeValue = new JTextField("1.0");
    opt_CompositeValue.setAlignmentX(JComponent.LEFT_ALIGNMENT);
    elements.put("opt_CompositeValue", opt_CompositeValue);
    opt_Composite.add(opt_CompositeValue);
    gbc.gridwidth = GridBagConstraints.REMAINDER;
    layout.setConstraints(opt_Composite, gbc);
    extras.add(opt_Composite);

    // Transformations
    // TODO: allow user-defined matrices for AffineTransform
    // (backend already has hooks for it, need to create gui)
    JLabel opt_TransformLabel = new JLabel("Transformations:");
    opt_TransformLabel.setBorder(new BevelBorder(BevelBorder.RAISED));
    gbc.insets = new Insets(5, 2, 0, 15);
    layout.setConstraints(opt_TransformLabel, gbc);
    extras.add(opt_TransformLabel);

    JPanel opt_Transform_Translate = new JPanel(new GridLayout(0, 2, 5, 5));
    opt_Transform_Translate.add(new JLabel("x-axis translation "));
    JTextField opt_TransformTranslateX = new JTextField("0");
    opt_TransformTranslateX.setAlignmentX(JComponent.LEFT_ALIGNMENT);
    opt_Transform_Translate.add(opt_TransformTranslateX);
    elements.put("opt_TransformTranslateX", opt_TransformTranslateX);
    opt_Transform_Translate.add(new JLabel("y-axis translation "));
    JTextField opt_TransformTranslateY = new JTextField("0");
    opt_TransformTranslateY.setAlignmentX(JComponent.LEFT_ALIGNMENT);
    opt_Transform_Translate.add(opt_TransformTranslateY);
    elements.put("opt_TransformTranslateY", opt_TransformTranslateY);
    gbc.gridwidth = 1;
    gbc.insets = new Insets(0, 2, 5, 15);
    layout.setConstraints(opt_Transform_Translate, gbc);
    extras.add(opt_Transform_Translate);

    JPanel opt_Transform_Shear = new JPanel(new GridLayout(0, 2, 5, 5));
    opt_Transform_Shear.add(new JLabel("x-axis shear "));
    JTextField opt_TransformShearX = new JTextField("0");
    opt_TransformShearX.setAlignmentX(JComponent.LEFT_ALIGNMENT);
    opt_Transform_Shear.add(opt_TransformShearX);
    elements.put("opt_TransformShearX", opt_TransformShearX);
    opt_Transform_Shear.add(new JLabel("y-axis shear "));
    JTextField opt_TransformShearY = new JTextField("0");
    opt_Transform_Shear.add(opt_TransformShearY);
    elements.put("opt_TransformShearY", opt_TransformShearY);
    gbc.gridwidth = GridBagConstraints.REMAINDER;
    layout.setConstraints(opt_Transform_Shear, gbc);
    extras.add(opt_Transform_Shear);

    JPanel opt_Transform_Rotate = new JPanel(new GridLayout(0, 2, 5, 5));
    opt_Transform_Rotate.add(new JLabel("rotation (radians) "));
    JTextField opt_TransformRotate = new JTextField("0");
    opt_Transform_Rotate.add(opt_TransformRotate);
    elements.put("opt_TransformRotate", opt_TransformRotate);
    layout.setConstraints(opt_Transform_Rotate, gbc);
    extras.add(opt_Transform_Rotate);

    // Final submit button
    JPanel submit = new JPanel();
    submit.setLayout(new BoxLayout(submit, BoxLayout.PAGE_AXIS));

    JButton rectButton = new JButton("Run benchmark");
    rectButton.setAlignmentX(JComponent.CENTER_ALIGNMENT);
    submit.add(rectButton, BorderLayout.CENTER);

    errorLabel.setAlignmentX(JComponent.CENTER_ALIGNMENT);
    errorLabel.setForeground(Color.RED);
    submit.add(errorLabel);

    rectButton.addActionListener(new Harness(elements, errorLabel));

    // Lay it all out
    JPanel body = new JPanel();
    body.setLayout(new BoxLayout(body, BoxLayout.LINE_AXIS));
    options.setAlignmentX(JComponent.LEFT_ALIGNMENT);
    body.add(options);
    body.add(Box.createHorizontalStrut(50));
    tests.setAlignmentX(JComponent.RIGHT_ALIGNMENT);
    body.add(tests);

    body.setAlignmentX(JComponent.CENTER_ALIGNMENT);
    panel.add(body);
    extras.setAlignmentX(JComponent.CENTER_ALIGNMENT);
    panel.add(extras);
    submit.setAlignmentX(JComponent.CENTER_ALIGNMENT);
    panel.add(submit);

    content.add(panel, BorderLayout.CENTER);

    // Leave some breathing space in the frame
    frame.pack();

    frame.addWindowListener(new WindowAdapter()
    {
      public void windowClosing(WindowEvent e)
      {
        frame.setVisible(false);
        System.exit(0);
      }
    });

    frame.show();
  }

  /**
   * Handles user events on the options GUI, ensuring that user input is valid
   */
  public void actionPerformed(ActionEvent ev)
  {
    if (! noClipping.isSelected() && ! withClipping.isSelected()
        && ! zeroClipping.isSelected())
      errorLabel.setText("You must select at least one clipping option");

    else if (! singleBuffer.isSelected() && ! doubleBuffer.isSelected())
      errorLabel.setText("You must select at least one buffering option");

    else
      errorLabel.setText(" ");
  }

  /**
   * Parses GUI input and sets options in the benchmarker 
   */
  private class Harness
      implements ActionListener
  {
    Hashtable elements;

    JLabel errorLabel;

    /**
     * Creates a new Harness object
     * 
     * @param elements Hashtable containing the swing elements from the GUI
     * @param errorLabel JLabel on which to display any error messages
     */
    public Harness(Hashtable elements, JLabel errorLabel)
    {
      super();

      this.elements = elements;
      this.errorLabel = errorLabel;
    }

    /**
     * Handles user button-clicks, parsing the form, setting options, and
     * starting the J2dBenchmark
     * 
     * @param ae event that triggered this action
     */
    public void actionPerformed(ActionEvent ae)
    {
      try
        {
          // Create benchmarker object
          final JFrame frame = new JFrame("Java2D benchmark");
          J2dBenchmarkWrapper speed = new J2dBenchmarkWrapper(frame);

          // Set options
          speed.setDimensions(Integer.parseInt(((JTextField) elements.get("width")).getText()),
                              Integer.parseInt(((JTextField) elements.get("height")).getText()));

          speed.setIterations(Integer.parseInt(((JTextField) elements.get("iterations")).getText()));
          speed.setTestSize(Integer.parseInt(((JTextField) elements.get("size")).getText()));

          speed.setClipping(((JCheckBox) elements.get("noclip")).isSelected(),
                            ((JCheckBox) elements.get("withclip")).isSelected(),
                            ((JCheckBox) elements.get("zeroclip")).isSelected());

          speed.setBuffers(((JCheckBox) elements.get("singlebuffer")).isSelected(),
                           ((JCheckBox) elements.get("doublebuffer")).isSelected());

          // Set additional processing options
          speed.setFill(((ButtonGroup) elements.get("opt_FillGroup")).getSelection().getActionCommand(),
                        ((JTextField) elements.get("opt_FillTextureFile")).getText());

          speed.setStroke(((JCheckBox) elements.get("opt_StrokeRandom")).isSelected());

          speed.setAlias(((JCheckBox) elements.get("opt_AliasOn")).isSelected());

          speed.setComposite(Float.parseFloat(((JTextField) elements.get("opt_CompositeValue")).getText()));

          speed.setTranslation(Integer.parseInt(((JTextField) elements.get("opt_TransformTranslateX")).getText()),
                               Integer.parseInt(((JTextField) elements.get("opt_TransformTranslateY")).getText()));

          speed.setRotation(Double.parseDouble(((JTextField) elements.get("opt_TransformRotate")).getText()));

          speed.setShear(Double.parseDouble(((JTextField) elements.get("opt_TransformShearX")).getText()),
                         Double.parseDouble(((JTextField) elements.get("opt_TransformShearY")).getText()));

          // Set tests
          int testSuite = 0;
          if (((JCheckBox) elements.get("test_arcDraw")).isSelected())
            testSuite |= J2dBenchmarkWrapper.J2DTEST_ARC;
          if (((JCheckBox) elements.get("test_ccurveDraw")).isSelected())
            testSuite |= J2dBenchmarkWrapper.J2DTEST_CUBICCURVE;
          if (((JCheckBox) elements.get("test_ellipseDraw")).isSelected())
            testSuite |= J2dBenchmarkWrapper.J2DTEST_ELLIPSE;
          //if (((JCheckBox)elements.get("test_pathDraw")).isSelected())
          //  testSuite |= J2dBenchmarkWrapper.J2DTEST_GENERALPATH; 
          if (((JCheckBox) elements.get("test_lineDraw")).isSelected())
            testSuite |= J2dBenchmarkWrapper.J2DTEST_LINE;
          if (((JCheckBox) elements.get("test_qcurveDraw")).isSelected())
            testSuite |= J2dBenchmarkWrapper.J2DTEST_QUADCURVE;
          if (((JCheckBox) elements.get("test_rectDraw")).isSelected())
            testSuite |= J2dBenchmarkWrapper.J2DTEST_RECTANGLE;
          if (((JCheckBox) elements.get("test_rrectDraw")).isSelected())
            testSuite |= J2dBenchmarkWrapper.J2DTEST_ROUNDRECTANGLE;
          if (((JCheckBox) elements.get("test_image")).isSelected())
            testSuite |= J2dBenchmarkWrapper.J2DTEST_IMAGE;

          if (testSuite != 0)
            {
              speed.setTests(testSuite);

              String initResult = speed.init();

              if (initResult == null)
                {
                  // Create graphics.
                  frame.add(speed, BorderLayout.CENTER);
                  frame.setSize(
                                Integer.parseInt(((JTextField) elements.get("width")).getText()),
                                Integer.parseInt(((JTextField) elements.get("height")).getText()));
                  frame.setVisible(true);

                  // Insets are correctly set only after the native peer was
                  // created.
                  Insets insets = frame.getInsets();
                  frame.setSize(frame.getWidth() + insets.right + insets.left,
                                frame.getHeight() + insets.top + insets.bottom);

                  // Clear any old error messages
                  errorLabel.setText(" ");
                }
              else
                errorLabel.setText(initResult);
            }
          else
            errorLabel.setText("Please select at least one test.");
        }
      catch (NumberFormatException e)
        {
          errorLabel.setText("Please enter valid integers");
        }
    }
  }

  /**
   * Wrapper for the J2dBenchmark, which outputs the results to a GUI
   * instead of the command-line
   */
  private class J2dBenchmarkWrapper
      extends J2dBenchmark
  {
    JFrame myFrame;

    ResultsDisplay display;

    /**
     * Create new J2dBenchmarkWrapper object
     * 
     * @param frame parent frame
     */
    public J2dBenchmarkWrapper(JFrame frame)
    {
      // Redirect log messages to the custom handler
      logger.setUseParentHandlers(false);
      display = new ResultsDisplay();
      display.setLevel(Level.INFO);
      logger.addHandler(display);

      myFrame = frame;
    }

    /**
     * Set dimensions of benchmarking canvas
     * 
     * @param width width of canvas
     * @param height height of canvas
     */
    public void setDimensions(int width, int height)
    {
      screenHeight = height;
      screenWidth = width;
      setSize(width, height);
    }

    /**
     * Set number of iterations
     * 
     * @param it number of iterations
     */
    public void setIterations(int it)
    {
      iterations = it;
    }

    /**
     * Set size of each test
     * 
     * @param size size of test
     */
    public void setTestSize(int size)
    {
      testSize = size;
    }

    /**
     * Set clipping options
     * 
     * @param no run test with no clipping
     * @param with run test with clipping
     * @param zero run test with clipping to zero
     */
    public void setClipping(boolean no, boolean with, boolean zero)
    {
      this.noClippingFlag = no;
      this.withClippingFlag = with;
      this.zeroClippingFlag = zero;
    }

    /**
     * Set buffering options
     * 
     * @param single run test without double-buffering
     * @param doubleb run test with double-buffering
     */
    public void setBuffers(boolean single, boolean doubleb)
    {
      this.singleBufferFlag = single;
      this.doubleBufferFlag = doubleb;
    }

    /**
     * Set fill options
     * 
     * @param type fill type: "solid", "gradient", or "texture"
     * @param file filename to use if texturing
     */
    public void setFill(String type, String file)
    {
      if (type.equals("gradient"))
        this.gradientFlag = true;
      else if (type.equals("texture"))
        {
          this.texture = file;
        }
    }

    /**
     * Set stroke options
     * 
     * @param stroke boolean flag to use random stroking or not
     */
    public void setStroke(boolean stroke)
    {
      this.strokeFlag = stroke;
    }

    /**
     * Set anti-aliasing options
     * 
     * @param alias boolean flag to use anti-aliasing or not
     */
    public void setAlias(boolean alias)
    {
      this.antialiasFlag = alias;
    }

    /**
     * Set alpha composite
     * 
     * @param alpha alpha composite
     */
    public void setComposite(float alpha)
    {
      this.composite = alpha;
    }

    /**
     * Set translation values
     * 
     * @param x x-axis translation
     * @param y y-axis translation
     */
    public void setTranslation(int x, int y)
    {
      this.xtranslate = x;
      this.ytranslate = y;
    }

    /**
     * Set rotation
     * 
     * @param theta angle to rotate by (radians)
     */
    public void setRotation(double theta)
    {
      this.rotate = theta;
    }

    /**
     * Set shear values
     * 
     * @param x x-axis shear value
     * @param y-axis shear value
     */
    public void setShear(double x, double y)
    {
      this.xshear = x;
      this.yshear = y;
    }

    /**
     * Set tests to run
     * 
     * @param tests bit-shifted list of tests (see J2dBenchmark constants)
     */
    public void setTests(int tests)
    {
      awtTests = tests;
    }

    /**
     * Saves test report after each iteration
     */
    void printReport()
    {
      // Report test results to the GUI display
      ArrayList results = new ArrayList();
      for (Iterator i = testSetMap.testIterator(); i.hasNext();)
        {
          TestRecorder recorder = testSetMap.getTest((String) i.next());

          results.add("TEST " + recorder.getTestName() + ": average "
                      + recorder.getAverage() + "ms [" + recorder.getMinTime()
                      + "-" + recorder.getMaxTime() + "]");
        }

      display.report(results);
    }

    /**
     * Disables current frame and displays test results
     */
    void testComplete()
    {
      // Clear benchmarking canvas and display results instead
      myFrame.setVisible(false);

      display.show();
    }
  }

  /**
   * GUI to display results of benchmarking
   */
  private class ResultsDisplay
      extends Handler
      implements ActionListener
  {
    /**
     * Allow user to select results from each iteration
     */
    JComboBox iterations;

    /**
     * Area to print results in
     */
    JTextArea results;

    /**
     * Allow user to view summary or full details of test report
     */
    JCheckBox details;

    /**
     * Store all test results
     */
    ArrayList testResults;

    /**
     * Store all test details
     */
    ArrayList testDetails;

    /**
     * Initialize variables
     */
    public ResultsDisplay()
    {
      testResults = new ArrayList();
      testDetails = new ArrayList();
      testDetails.add(new ArrayList());
    }

    /**
     * Parse all results and display on a GUI
     */
    public void show()
    {
      // Set up panel
      JFrame frame = new JFrame("Java2D benchmark results");
      Container cp = frame.getContentPane();

      // Non-editable text area for the results
      results = new JTextArea();
      results.setEditable(false);
      results.setRows(15);
      results.setColumns(60);

      // Checkbox to optionally display details (ie log messages)
      details = new JCheckBox("Details", false);
      details.addActionListener(this);

      // Combo box to allow selection of iteration number
      iterations = new JComboBox();
      iterations.addActionListener(this);
      for (int i = 0; i < testResults.size(); i++)
        iterations.addItem("Iteration #" + (i + 1));

      // Lay it all out
      JPanel topleft = new JPanel();
      topleft.add(new JLabel("View results from: "));
      topleft.add(iterations);
      topleft.setAlignmentX(JComponent.LEFT_ALIGNMENT);
      details.setAlignmentX(JComponent.RIGHT_ALIGNMENT);
      JPanel top = new JPanel();
      top.setLayout(new BoxLayout(top, BoxLayout.LINE_AXIS));
      top.add(topleft);
      top.add(details);

      cp.add(top, BorderLayout.NORTH);
      cp.add(new JScrollPane(results), BorderLayout.SOUTH);

      frame.pack();
      frame.show();
    }

    /**
     * This overrides the logger publish method, which accepts log messages and
     * saves them for later display
     * 
     * @param record information about the log event
     */
    public void publish(LogRecord record)
    {
      ((ArrayList) testDetails.get(testDetails.size() - 1)).add(record.getMessage());
    }

    /**
     * Accepts a test summary report, generated after each iteration of a test
     * 
     * @param results test results
     */
    public void report(ArrayList results)
    {
      testResults.add(results);
      testDetails.add(new ArrayList());
    }

    /**
     * Provided as part of the Handler interface; not used
     */
    public void flush()
    {
    }

    /**
     * Provided as part of the Handler interface; not used
     */
    public void close()
    {
    }

    /**
     * Handle user-generated events on the results GUI
     */
    public void actionPerformed(ActionEvent ev)
    {
      // Display information about the requested iteration
      int iteration = iterations.getSelectedIndex();
      String message = "";

      // Display summary or details, as requested
      Iterator it;
      if (details.isSelected())
        it = ((ArrayList) testDetails.get(iteration)).iterator();
      else
        it = ((ArrayList) testResults.get(iteration)).iterator();

      // Parse the ArrayList's
      while (it.hasNext())
        {
          message = message + ((String) it.next() + "\n");
        }

      // Output to screen
      results.setText(message);
    }
  }

}