435 lines
14 KiB
Java
435 lines
14 KiB
Java
/*
|
|
* Copyright (c) 2007, Oracle and/or its affiliates. All rights reserved.
|
|
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
|
|
*
|
|
* This code is free software; you can redistribute it and/or modify it
|
|
* under the terms of the GNU General Public License version 2 only, as
|
|
* published by the Free Software Foundation.
|
|
*
|
|
* This code 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
|
|
* version 2 for more details (a copy is included in the LICENSE file that
|
|
* accompanied this code).
|
|
*
|
|
* You should have received a copy of the GNU General Public License version
|
|
* 2 along with this work; if not, write to the Free Software Foundation,
|
|
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
|
|
*
|
|
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
|
|
* or visit www.oracle.com if you need additional information or have any
|
|
* questions.
|
|
*/
|
|
|
|
/*
|
|
* @test
|
|
* @bug 6296064 6521533
|
|
* @summary A simple manual test for visual verification of GradientPaint
|
|
* LinearGradientPaint, and RadialGradientPaint.
|
|
* @run main/manual MultiGradientTest
|
|
* @author campbelc
|
|
*/
|
|
|
|
import java.awt.BorderLayout;
|
|
import java.awt.Color;
|
|
import java.awt.Dimension;
|
|
import java.awt.GradientPaint;
|
|
import java.awt.Graphics;
|
|
import java.awt.Graphics2D;
|
|
import java.awt.LinearGradientPaint;
|
|
import java.awt.MultipleGradientPaint.ColorSpaceType;
|
|
import java.awt.MultipleGradientPaint.CycleMethod;
|
|
import java.awt.Paint;
|
|
import java.awt.Polygon;
|
|
import java.awt.RadialGradientPaint;
|
|
import java.awt.Rectangle;
|
|
import java.awt.RenderingHints;
|
|
import java.awt.geom.AffineTransform;
|
|
import java.awt.geom.NoninvertibleTransformException;
|
|
import java.awt.geom.Point2D;
|
|
import java.awt.event.ActionEvent;
|
|
import java.awt.event.ActionListener;
|
|
import java.awt.event.MouseAdapter;
|
|
import java.awt.event.MouseEvent;
|
|
import java.awt.event.WindowAdapter;
|
|
import java.awt.event.WindowEvent;
|
|
import java.util.Arrays;
|
|
import java.util.ArrayList;
|
|
import java.util.EnumSet;
|
|
import java.util.List;
|
|
import javax.swing.AbstractListModel;
|
|
import javax.swing.BoxLayout;
|
|
import javax.swing.ComboBoxModel;
|
|
import javax.swing.JCheckBox;
|
|
import javax.swing.JComboBox;
|
|
import javax.swing.JFrame;
|
|
import javax.swing.JLabel;
|
|
import javax.swing.JPanel;
|
|
import javax.swing.JSpinner;
|
|
import javax.swing.SpinnerNumberModel;
|
|
import javax.swing.event.ChangeEvent;
|
|
import javax.swing.event.ChangeListener;
|
|
|
|
public class MultiGradientTest extends JPanel {
|
|
|
|
private static final Color[] COLORS = {
|
|
new Color(0, 0, 0),
|
|
new Color(128, 128, 128),
|
|
new Color(255, 0, 0),
|
|
new Color(255, 255, 0),
|
|
new Color(0, 255, 0),
|
|
new Color(0, 255, 255),
|
|
new Color(128, 0, 255),
|
|
new Color(128, 128, 128),
|
|
};
|
|
|
|
private static enum PaintType {BASIC, LINEAR, RADIAL};
|
|
private static enum ShapeType {RECT, ELLIPSE, MULTIPLE};
|
|
private static enum XformType {IDENTITY, TRANSLATE, SCALE, SHEAR, ROTATE};
|
|
|
|
private PaintType paintType = PaintType.LINEAR;
|
|
private ShapeType shapeType = ShapeType.RECT;
|
|
private XformType xformType = XformType.IDENTITY;
|
|
private CycleMethod cycleMethod = CycleMethod.NO_CYCLE;
|
|
private ColorSpaceType colorSpace = ColorSpaceType.SRGB;
|
|
private Object antialiasHint = RenderingHints.VALUE_ANTIALIAS_OFF;
|
|
private Object renderHint = RenderingHints.VALUE_RENDER_SPEED;
|
|
private AffineTransform transform = new AffineTransform();
|
|
|
|
private int numColors;
|
|
|
|
private GradientPanel gradientPanel;
|
|
private ControlsPanel controlsPanel;
|
|
|
|
private MultiGradientTest() {
|
|
numColors = COLORS.length;
|
|
|
|
setLayout(new BorderLayout());
|
|
gradientPanel = new GradientPanel();
|
|
add(gradientPanel, BorderLayout.CENTER);
|
|
controlsPanel = new ControlsPanel();
|
|
add(controlsPanel, BorderLayout.SOUTH);
|
|
}
|
|
|
|
private class GradientPanel extends JPanel {
|
|
private int startX, startY, endX, endY;
|
|
private int ctrX, ctrY, focusX, focusY;
|
|
private float radius;
|
|
private Paint paint;
|
|
|
|
private GradientPanel() {
|
|
startX = 20;
|
|
startY = 20;
|
|
endX = 100;
|
|
endY = 100;
|
|
ctrX = 100;
|
|
ctrY = 100;
|
|
focusX = 100;
|
|
focusY = 100;
|
|
radius = 100.0f;
|
|
|
|
makeNewPaint();
|
|
|
|
MouseAdapter l = new MyMouseAdapter();
|
|
addMouseListener(l);
|
|
addMouseMotionListener(l);
|
|
}
|
|
|
|
public void paintComponent(Graphics g) {
|
|
Graphics2D g2d = (Graphics2D)g.create();
|
|
|
|
int w = getWidth();
|
|
int h = getHeight();
|
|
g2d.setColor(Color.black);
|
|
g2d.fillRect(0, 0, w, h);
|
|
|
|
g2d.setRenderingHint(RenderingHints.KEY_ANTIALIASING,
|
|
antialiasHint);
|
|
g2d.setRenderingHint(RenderingHints.KEY_RENDERING,
|
|
renderHint);
|
|
|
|
g2d.transform(transform);
|
|
g2d.setPaint(paint);
|
|
|
|
switch (shapeType) {
|
|
default:
|
|
case RECT:
|
|
g2d.fillRect(0, 0, w, h);
|
|
break;
|
|
|
|
case ELLIPSE:
|
|
g2d.fillOval(0, 0, w, h);
|
|
break;
|
|
|
|
case MULTIPLE:
|
|
g2d.fillRect(0, 0, w/2, h/2);
|
|
g2d.fillOval(w/2, 0, w/2, h/2);
|
|
g2d.drawOval(0, h/2, w/2, h/2);
|
|
g2d.drawLine(0, h/2, w/2, h);
|
|
g2d.drawLine(0, h, w/2, h/2);
|
|
Polygon p = new Polygon();
|
|
p.addPoint(w/2, h);
|
|
p.addPoint(w, h);
|
|
p.addPoint(3*w/4, h/2);
|
|
g2d.fillPolygon(p);
|
|
break;
|
|
}
|
|
|
|
switch (paintType) {
|
|
default:
|
|
case BASIC:
|
|
case LINEAR:
|
|
g2d.setColor(Color.white);
|
|
g2d.fillRect(startX-1, startY-1, 2, 2);
|
|
g2d.drawString("1", startX, startY + 12);
|
|
g2d.fillRect(endX-1, endY-1, 2, 2);
|
|
g2d.drawString("2", endX, endY + 12);
|
|
break;
|
|
|
|
case RADIAL:
|
|
g2d.setColor(Color.white);
|
|
g2d.fillRect(ctrX-1, ctrY-1, 2, 2);
|
|
g2d.drawString("C", ctrX, ctrY + 12);
|
|
g2d.fillRect(focusX-1, focusY-1, 2, 2);
|
|
g2d.drawString("F", focusX, focusY + 12);
|
|
break;
|
|
}
|
|
|
|
g2d.dispose();
|
|
}
|
|
|
|
private void updatePoints(int x, int y) {
|
|
Point2D inv = new Point2D.Double(x, y);
|
|
|
|
try {
|
|
inv = transform.inverseTransform(inv, null);
|
|
} catch (NoninvertibleTransformException e) {
|
|
e.printStackTrace();
|
|
}
|
|
|
|
x = (int)inv.getX();
|
|
y = (int)inv.getY();
|
|
|
|
switch (paintType) {
|
|
default:
|
|
case BASIC:
|
|
case LINEAR:
|
|
// pick the closest point to move
|
|
if (inv.distance(startX, startY) < inv.distance(endX, endY)) {
|
|
startX = x;
|
|
startY = y;
|
|
} else {
|
|
endX = x;
|
|
endY = y;
|
|
}
|
|
break;
|
|
|
|
case RADIAL:
|
|
// pick the closest point to move
|
|
if (inv.distance(ctrX, ctrY) < inv.distance(focusX, focusY)) {
|
|
ctrX = x;
|
|
ctrY = y;
|
|
} else {
|
|
focusX = x;
|
|
focusY = y;
|
|
}
|
|
break;
|
|
}
|
|
|
|
updatePaint();
|
|
}
|
|
|
|
private void makeNewPaint() {
|
|
Color[] colors = Arrays.copyOf(COLORS, numColors);
|
|
float[] fractions = new float[colors.length];
|
|
for (int i = 0; i < fractions.length; i++) {
|
|
fractions[i] = ((float)i) / (fractions.length-1);
|
|
}
|
|
|
|
switch (paintType) {
|
|
case BASIC:
|
|
boolean cyclic = (cycleMethod != CycleMethod.NO_CYCLE);
|
|
paint = new GradientPaint(startX, startY, Color.RED,
|
|
endX, endY, Color.BLUE, cyclic);
|
|
break;
|
|
|
|
default:
|
|
case LINEAR:
|
|
paint =
|
|
new LinearGradientPaint(new Point2D.Float(startX, startY),
|
|
new Point2D.Float(endX, endY),
|
|
fractions, colors,
|
|
cycleMethod, colorSpace,
|
|
new AffineTransform());
|
|
break;
|
|
|
|
case RADIAL:
|
|
paint =
|
|
new RadialGradientPaint(new Point2D.Float(ctrX, ctrY),
|
|
radius,
|
|
new Point2D.Float(focusX, focusY),
|
|
fractions, colors,
|
|
cycleMethod, colorSpace,
|
|
new AffineTransform());
|
|
break;
|
|
}
|
|
|
|
switch (xformType) {
|
|
default:
|
|
case IDENTITY:
|
|
transform = new AffineTransform();
|
|
break;
|
|
case TRANSLATE:
|
|
transform = AffineTransform.getTranslateInstance(2, 2);
|
|
break;
|
|
case SCALE:
|
|
transform = AffineTransform.getScaleInstance(1.2, 1.4);
|
|
break;
|
|
case SHEAR:
|
|
transform = AffineTransform.getShearInstance(0.1, 0.1);
|
|
break;
|
|
case ROTATE:
|
|
transform = AffineTransform.getRotateInstance(Math.PI / 4,
|
|
getWidth()/2,
|
|
getHeight()/2);
|
|
break;
|
|
}
|
|
}
|
|
|
|
public void updatePaint() {
|
|
makeNewPaint();
|
|
repaint();
|
|
}
|
|
|
|
private class MyMouseAdapter extends MouseAdapter {
|
|
@Override
|
|
public void mouseClicked(MouseEvent e) {
|
|
updatePoints(e.getX(), e.getY());
|
|
}
|
|
|
|
@Override
|
|
public void mouseDragged(MouseEvent e) {
|
|
updatePoints(e.getX(), e.getY());
|
|
}
|
|
}
|
|
|
|
public Dimension getPreferredSize() {
|
|
return new Dimension(400, 400);
|
|
}
|
|
}
|
|
|
|
private class ControlsPanel extends JPanel implements ActionListener {
|
|
private JComboBox cmbPaint, cmbCycle, cmbSpace, cmbShape, cmbXform;
|
|
private JCheckBox cbAntialias, cbRender;
|
|
private JSpinner spinNumColors;
|
|
|
|
private ControlsPanel() {
|
|
cmbPaint = createCombo(this, paintType);
|
|
cmbPaint.setSelectedIndex(1);
|
|
cmbCycle = createCombo(this, cycleMethod);
|
|
cmbSpace = createCombo(this, colorSpace);
|
|
cmbShape = createCombo(this, shapeType);
|
|
cmbXform = createCombo(this, xformType);
|
|
|
|
int max = COLORS.length;
|
|
SpinnerNumberModel model = new SpinnerNumberModel(max, 2, max, 1);
|
|
spinNumColors = new JSpinner(model);
|
|
spinNumColors.addChangeListener(new ChangeListener() {
|
|
public void stateChanged(ChangeEvent e) {
|
|
numColors = ((Integer)spinNumColors.getValue()).intValue();
|
|
gradientPanel.updatePaint();
|
|
}
|
|
});
|
|
add(spinNumColors);
|
|
|
|
cbAntialias = createCheck(this, "Antialiasing");
|
|
cbRender = createCheck(this, "Render Quality");
|
|
}
|
|
|
|
private JComboBox createCombo(JPanel panel, Enum e) {
|
|
JComboBox cmb = new JComboBox();
|
|
cmb.setModel(new EnumComboBoxModel(e.getClass()));
|
|
cmb.addActionListener(this);
|
|
panel.add(cmb);
|
|
return cmb;
|
|
}
|
|
|
|
private JCheckBox createCheck(JPanel panel, String name) {
|
|
JCheckBox cb = new JCheckBox(name);
|
|
cb.addActionListener(this);
|
|
panel.add(cb);
|
|
return cb;
|
|
}
|
|
|
|
public void actionPerformed(ActionEvent e) {
|
|
Object source = e.getSource();
|
|
|
|
if (source == cmbPaint) {
|
|
paintType = (PaintType)cmbPaint.getSelectedItem();
|
|
} else if (source == cmbCycle) {
|
|
cycleMethod = (CycleMethod)cmbCycle.getSelectedItem();
|
|
} else if (source == cmbSpace) {
|
|
colorSpace = (ColorSpaceType)cmbSpace.getSelectedItem();
|
|
} else if (source == cmbShape) {
|
|
shapeType = (ShapeType)cmbShape.getSelectedItem();
|
|
} else if (source == cmbXform) {
|
|
xformType = (XformType)cmbXform.getSelectedItem();
|
|
} else if (source == cbAntialias) {
|
|
antialiasHint = cbAntialias.isSelected() ?
|
|
RenderingHints.VALUE_ANTIALIAS_ON :
|
|
RenderingHints.VALUE_ANTIALIAS_OFF;
|
|
} else if (source == cbRender) {
|
|
renderHint = cbRender.isSelected() ?
|
|
RenderingHints.VALUE_RENDER_QUALITY :
|
|
RenderingHints.VALUE_RENDER_SPEED;
|
|
}
|
|
|
|
gradientPanel.updatePaint();
|
|
}
|
|
}
|
|
|
|
private static class EnumComboBoxModel<E extends Enum<E>>
|
|
extends AbstractListModel
|
|
implements ComboBoxModel
|
|
{
|
|
private E selected = null;
|
|
private List<E> list;
|
|
|
|
public EnumComboBoxModel(Class<E> en) {
|
|
EnumSet<E> ens = EnumSet.allOf(en);
|
|
list = new ArrayList<E>(ens);
|
|
selected = list.get(0);
|
|
}
|
|
|
|
public int getSize() {
|
|
return list.size();
|
|
}
|
|
|
|
public E getElementAt(int index) {
|
|
return list.get(index);
|
|
}
|
|
|
|
public void setSelectedItem(Object anItem) {
|
|
selected = (E)anItem;
|
|
this.fireContentsChanged(this, 0, getSize());
|
|
}
|
|
|
|
public E getSelectedItem() {
|
|
return selected;
|
|
}
|
|
}
|
|
|
|
public static void main(String[] args) {
|
|
final JFrame frame = new JFrame("Multistop Gradient Demo");
|
|
frame.addWindowListener(new WindowAdapter() {
|
|
public void windowClosing(WindowEvent e) {
|
|
frame.dispose();
|
|
}
|
|
});
|
|
frame.add(new MultiGradientTest());
|
|
frame.pack();
|
|
frame.setLocationRelativeTo(null);
|
|
frame.setVisible(true);
|
|
}
|
|
}
|