Subversion Repositories openrisc

/* 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;