Java/2D Graphics GUI/Gradient Paint
Содержание
- 1 A cyclic gradient
- 2 A non-cyclic gradient
- 3 Another GradientPaint Demo
- 4 Color gradient
- 5 Control the direction of Gradients
- 6 Drawing with a Gradient Color
- 7 GradientPaint demo
- 8 GradientPaint Ellipse
- 9 GradientPaint: iron
- 10 Gradients: a smooth blending of shades from light to dark or from one color to another
- 11 Gradient Shapes
- 12 Gradients in the middle
- 13 Horizontal Gradients
- 14 Returns true if the two Paint objects are equal OR both null.
- 15 Round GradientPaint Fill demo
- 16 Text effect: image texture
- 17 Text effect: rotation and transparent
- 18 Texture paint
- 19 Vertical Gradient Paint
A cyclic gradient
import java.awt.Color;
import java.awt.GradientPaint;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.Rectangle;
import javax.swing.JComponent;
import javax.swing.JFrame;
public class BasicDraw {
public static void main(String[] args) {
new BasicDraw();
}
BasicDraw() {
JFrame frame = new JFrame();
frame.add(new MyComponent());
frame.setSize(300, 300);
frame.setVisible(true);
}
}
class MyComponent extends JComponent {
public void paint(Graphics g) {
Graphics2D g2d = (Graphics2D) g;
Color startColor = Color.red;
Color endColor = Color.blue;
int startX = 10, startY = 20, endX = 30, endY = 40;
GradientPaint gradient = new GradientPaint(startX, startY, startColor, endX, endY, endColor,true);
g2d.setPaint(gradient);
g2d.draw(new Rectangle(20, 20, 200, 200));
}
}
A non-cyclic gradient
import java.awt.Color;
import java.awt.GradientPaint;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.Rectangle;
import javax.swing.JComponent;
import javax.swing.JFrame;
public class BasicDraw {
public static void main(String[] args) {
new BasicDraw();
}
BasicDraw() {
JFrame frame = new JFrame();
frame.add(new MyComponent());
frame.setSize(300, 300);
frame.setVisible(true);
}
}
class MyComponent extends JComponent {
public void paint(Graphics g) {
Graphics2D g2d = (Graphics2D) g;
Color startColor = Color.red;
Color endColor = Color.blue;
int startX = 10, startY = 20, endX = 30, endY = 40;
GradientPaint gradient = new GradientPaint(startX, startY, startColor, endX, endY, endColor);
g2d.setPaint(gradient);
g2d.draw(new Rectangle(20,20,200,200));
}
}
Another GradientPaint Demo
import java.awt.Color;
import java.awt.Dimension;
import java.awt.GradientPaint;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.Rectangle;
import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;
import javax.swing.JFrame;
import javax.swing.JPanel;
public class GradientPaintDemo extends JPanel {
public void init() {
setBackground(Color.white);
}
public void paint(Graphics g) {
Graphics2D g2 = (Graphics2D) g;
g2.setPaint(new GradientPaint(0, 0, Color.lightGray, 200,
200, Color.blue, false));
Rectangle r = new Rectangle(5,5,200,200);
g2.fill(r);
}
public static void main(String s[]) {
JFrame f = new JFrame();
f.addWindowListener(new WindowAdapter() {
public void windowClosing(WindowEvent e) {
System.exit(0);
}
});
GradientPaintDemo p = new GradientPaintDemo();
f.getContentPane().add("Center", p);
p.init();
f.pack();
f.setSize(new Dimension(250, 250));
f.show();
}
}
Color gradient
import java.awt.Color;
import java.awt.Dimension;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.geom.Rectangle2D;
import javax.swing.JFrame;
import javax.swing.JPanel;
public class ColorBlocks extends JPanel{
public void paint(Graphics g) {
Graphics2D g2 = (Graphics2D)g;
Dimension d = getSize();
g2.translate(d.width / 2, d.height / 2);
Color[] colors = {
Color.white, Color.lightGray, Color.gray, Color.darkGray,
Color.black, Color.red, Color.pink, Color.orange,
Color.yellow, Color.green, Color.magenta, Color.cyan, Color.blue
};
float size = 25;
float x = -size * colors.length / 2;
float y = -size * 3 / 2;
// Show all the predefined colors.
for (int i = 0; i < colors.length; i++) {
Rectangle2D r = new Rectangle2D.Float(
x + size * (float)i, y, size, size);
g2.setPaint(colors[i]);
g2.fill(r);
}
//a linear gradient.
y += size;
Color c1 = Color.yellow;
Color c2 = Color.blue;
for (int i = 0; i < colors.length; i++) {
float ratio = (float)i / (float)colors.length;
int red = (int)(c2.getRed() * ratio + c1.getRed() * (1 - ratio));
int green = (int)(c2.getGreen() * ratio +
c1.getGreen() * (1 - ratio));
int blue = (int)(c2.getBlue() * ratio +
c1.getBlue() * (1 - ratio));
Color c = new Color(red, green, blue);
Rectangle2D r = new Rectangle2D.Float(
x + size * (float)i, y, size, size);
g2.setPaint(c);
g2.fill(r);
}
// Show an alpha gradient.
y += size;
c1 = Color.red;
for (int i = 0; i < colors.length; i++) {
int alpha = (int)(255 * (float)i / (float)colors.length);
Color c = new Color(c1.getRed(), c1.getGreen(),
c1.getBlue(), alpha);
Rectangle2D r = new Rectangle2D.Float(
x + size * (float)i, y, size, size);
g2.setPaint(c);
g2.fill(r);
}
// Draw a frame around the whole thing.
y -= size * 2;
Rectangle2D frame = new Rectangle2D.Float(x, y, size * colors.length, size * 3);
g2.setPaint(Color.black);
g2.draw(frame);
}
public static void main(String[] args) {
JFrame f = new JFrame();
f.getContentPane().add(new ColorBlocks());
f.setSize(350, 250);
f.show();
}
}
Control the direction of Gradients
import java.awt.Color;
import java.awt.GradientPaint;
import java.awt.Graphics;
import java.awt.Graphics2D;
import javax.swing.JFrame;
import javax.swing.JPanel;
public class GradientsDirection extends JPanel {
public void paint(Graphics g) {
super.paint(g);
Graphics2D g2d = (Graphics2D) g;
GradientPaint gp1 = new GradientPaint(5, 25, Color.yellow, 20, 2, Color.black, true);
g2d.setPaint(gp1);
g2d.fillRect(20, 80, 300, 40);
}
public static void main(String[] args) {
JFrame frame = new JFrame("GradientsDirection");
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
frame.add(new GradientsDirection());
frame.setSize(350, 350);
frame.setLocationRelativeTo(null);
frame.setVisible(true);
}
}
Drawing with a Gradient Color
import java.awt.Color;
import java.awt.GradientPaint;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.Rectangle;
import javax.swing.JComponent;
import javax.swing.JFrame;
public class BasicDraw {
public static void main(String[] args) {
new BasicDraw();
}
BasicDraw() {
JFrame frame = new JFrame();
frame.add(new MyComponent());
frame.setSize(300, 300);
frame.setVisible(true);
}
}
class MyComponent extends JComponent {
public void paint(Graphics g) {
Graphics2D g2d = (Graphics2D) g;
Color startColor = Color.red;
Color endColor = Color.blue;
int startX = 10, startY = 20, endX = 30, endY = 40;
GradientPaint gradient = new GradientPaint(startX, startY, startColor, endX, endY, endColor);
g2d.setPaint(gradient);
g2d.draw(new Rectangle(20,20,200,200));
}
}
GradientPaint demo
import java.awt.BasicStroke;
import java.awt.Color;
import java.awt.Dimension;
import java.awt.Font;
import java.awt.FontMetrics;
import java.awt.GradientPaint;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.RenderingHints;
import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;
import java.awt.geom.Arc2D;
import java.awt.geom.Ellipse2D;
import java.awt.geom.GeneralPath;
import java.awt.geom.Line2D;
import java.awt.geom.Rectangle2D;
import java.awt.geom.RoundRectangle2D;
import javax.swing.JApplet;
import javax.swing.JFrame;
public class GradientPaintDemo2D extends JApplet {
public void init() {
setBackground(Color.white);
setForeground(Color.white);
}
public void paint(Graphics g) {
Graphics2D g2 = (Graphics2D) g;
g2.setRenderingHint(RenderingHints.KEY_ANTIALIASING,
RenderingHints.VALUE_ANTIALIAS_ON);
g2.setPaint(Color.gray);
int x = 5;
int y = 7;
// fill RoundRectangle2D.Double
GradientPaint redtowhite = new GradientPaint(x, y, Color.red, 200, y,
Color.blue);
g2.setPaint(redtowhite);
g2.fill(new RoundRectangle2D.Double(x, y, 200, 200, 10, 10));
g2.setPaint(Color.black);
g2.drawString("Filled RoundRectangle2D", x, 250);
}
public static void main(String s[]) {
JFrame f = new JFrame("");
f.addWindowListener(new WindowAdapter() {
public void windowClosing(WindowEvent e) {
System.exit(0);
}
});
JApplet applet = new GradientPaintDemo2D();
f.getContentPane().add("Center", applet);
applet.init();
f.pack();
f.setSize(new Dimension(300, 300));
f.show();
}
}
GradientPaint Ellipse
import java.awt.BasicStroke;
import java.awt.Color;
import java.awt.Dimension;
import java.awt.Font;
import java.awt.FontMetrics;
import java.awt.GradientPaint;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.RenderingHints;
import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;
import java.awt.geom.Arc2D;
import java.awt.geom.Ellipse2D;
import java.awt.geom.GeneralPath;
import java.awt.geom.Line2D;
import java.awt.geom.Rectangle2D;
import java.awt.geom.RoundRectangle2D;
import javax.swing.JApplet;
import javax.swing.JFrame;
public class GradientPaintEllipse extends JApplet {
public void init() {
setBackground(Color.white);
setForeground(Color.white);
}
public void paint(Graphics g) {
Graphics2D g2 = (Graphics2D) g;
g2.setRenderingHint(RenderingHints.KEY_ANTIALIASING,
RenderingHints.VALUE_ANTIALIAS_ON);
int x = 5;
int y = 7;
// fill Ellipse2D.Double
GradientPaint redtowhite = new GradientPaint(x, y, Color.red, 200, y, Color.white);
g2.setPaint(redtowhite);
g2.fill(new Ellipse2D.Double(x, y, 200, 200));
g2.setPaint(Color.black);
g2.drawString("Filled Ellipse2D", x,250);
}
public static void main(String s[]) {
JFrame f = new JFrame("");
f.addWindowListener(new WindowAdapter() {
public void windowClosing(WindowEvent e) {
System.exit(0);
}
});
JApplet applet = new GradientPaintEllipse();
f.getContentPane().add("Center", applet);
applet.init();
f.pack();
f.setSize(new Dimension(300, 300));
f.show();
}
}
GradientPaint: iron
import java.awt.Color;
import java.awt.GradientPaint;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.geom.Ellipse2D;
import javax.swing.JFrame;
import javax.swing.JPanel;
public class SimplestGradientPaint extends JPanel{
public static void main(String[] args) {
JFrame f = new JFrame();
f.getContentPane().add(new SimplestGradientPaint());
f.setSize(350, 250);
f.show();
}
public void paint(Graphics g) {
Graphics2D g2 = (Graphics2D) g;
Ellipse2D e = new Ellipse2D.Float(40, 40, 120, 120);
GradientPaint gp = new GradientPaint(75, 75, Color.white, 95, 95,
Color.gray, true);
g2.setPaint(gp);
g2.fill(e);
}
}
Gradients: a smooth blending of shades from light to dark or from one color to another
import java.awt.Color;
import java.awt.GradientPaint;
import java.awt.Graphics;
import java.awt.Graphics2D;
import javax.swing.JFrame;
import javax.swing.JPanel;
public class GradientsRedYellow extends JPanel {
public void paint(Graphics g) {
super.paint(g);
Graphics2D g2d = (Graphics2D) g;
GradientPaint gp1 = new GradientPaint(5, 5, Color.red, 20, 20, Color.yellow, true);
g2d.setPaint(gp1);
g2d.fillRect(20, 20, 300, 40);
}
public static void main(String[] args) {
JFrame frame = new JFrame("GradientsRedYellow");
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
frame.add(new GradientsRedYellow());
frame.setSize(350, 350);
frame.setLocationRelativeTo(null);
frame.setVisible(true);
}
}
Gradient Shapes
import java.awt.Color;
import java.awt.GradientPaint;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.RadialGradientPaint;
import java.awt.Rectangle;
import java.awt.RenderingHints;
import java.awt.Shape;
import java.awt.event.MouseAdapter;
import java.awt.event.MouseEvent;
import java.awt.geom.Area;
import java.awt.geom.Ellipse2D;
import java.awt.geom.GeneralPath;
import java.awt.geom.Point2D;
import java.util.ArrayList;
import java.util.List;
import javax.swing.JComponent;
import javax.swing.JFrame;
import javax.swing.SwingUtilities;
/*
* DrawShapes_2008.java
*
* Created on May 1, 2007, 4:16 PM
*
* Copyright (c) 2007, Sun Microsystems, Inc
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above
* copyright notice, this list of conditions and the following
* disclaimer in the documentation and/or other materials provided
* with the distribution.
* * Neither the name of the TimingFramework project nor the names of its
* contributors may be used to endorse or promote products derived
* from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
/**
*
* @author Chet
*/
public class DrawShapes_2008 extends JComponent {
private List<Shape> shapes = new ArrayList();
private boolean getStar = true;
/**
* Generates a star Shape from the given location, radii, and points
* parameters. The Shape is created by constructing a GeneralPath
* that moves between the inner and outer rings.
*/
private static Shape generateStar(double x, double y,
double innerRadius, double outerRadius,
int pointsCount) {
GeneralPath path = new GeneralPath();
double outerAngleIncrement = 2 * Math.PI / pointsCount;
double outerAngle = 0.0;
double innerAngle = outerAngleIncrement / 2.0;
x += outerRadius;
y += outerRadius;
float x1 = (float) (Math.cos(outerAngle) * outerRadius + x);
float y1 = (float) (Math.sin(outerAngle) * outerRadius + y);
float x2 = (float) (Math.cos(innerAngle) * innerRadius + x);
float y2 = (float) (Math.sin(innerAngle) * innerRadius + y);
path.moveTo(x1, y1);
path.lineTo(x2, y2);
outerAngle += outerAngleIncrement;
innerAngle += outerAngleIncrement;
for (int i = 1; i < pointsCount; i++) {
x1 = (float) (Math.cos(outerAngle) * outerRadius + x);
y1 = (float) (Math.sin(outerAngle) * outerRadius + y);
path.lineTo(x1, y1);
x2 = (float) (Math.cos(innerAngle) * innerRadius + x);
y2 = (float) (Math.sin(innerAngle) * innerRadius + y);
path.lineTo(x2, y2);
outerAngle += outerAngleIncrement;
innerAngle += outerAngleIncrement;
}
path.closePath();
return path;
}
/**
* Generates a donut shape from the given location and radii by subtracting
* an inner circular Area from an outer one.
*/
private static Shape generateDonut(double x, double y,
double innerRadius, double outerRadius) {
Area a1 = new Area(new Ellipse2D.Double(x, y, outerRadius, outerRadius));
double innerOffset = (outerRadius - innerRadius)/2;
Area a2 = new Area(new Ellipse2D.Double(x + innerOffset, y + innerOffset,
innerRadius, innerRadius));
a1.subtract(a2);
return a1;
}
/**
* This class processes mouse clicks and generates stars and donuts,
* alternately, in the click location. The new shape is added to the
* List of current shapes, then the scene is repainted.
*/
private class ClickReceiver extends MouseAdapter {
public void mouseClicked(MouseEvent me) {
int centerX = me.getX();
int centerY = me.getY();
double innerSize = 1 + (25 * Math.random());
double outerSize = innerSize + 10 + (15 * Math.random());
Shape newShape;
if (getStar) {
int numPoints = (int)(8 * Math.random() + 5);
newShape = generateStar(centerX - outerSize,
centerY - outerSize,
innerSize, outerSize, numPoints);
} else {
newShape = generateDonut(centerX - outerSize/2,
centerY - outerSize/2,
innerSize, outerSize);
}
getStar = !getStar;
shapes.add(newShape);
repaint();
}
}
@Override
protected void paintComponent(Graphics g) {
Graphics2D g2d = (Graphics2D)g;
// Paint a gradient for the sky
GradientPaint background = new GradientPaint(0f, 0f, Color.GRAY.darker(),
0f, (float)getHeight(), Color.GRAY.brighter());
g2d.setPaint(background);
g2d.fillRect(0, 0, getWidth(), 4*getHeight()/5);
// Paint a gradient for the ground
background = new GradientPaint(0f, (float)4*getHeight()/5,
Color.BLACK,
0f, (float)getHeight(), Color.GRAY.darker());
g2d.setPaint(background);
g2d.fillRect(0, 4*getHeight()/5, getWidth(), getHeight()/5);
// Enable anti-aliasing to get smooth outlines
g2d.setRenderingHint(RenderingHints.KEY_ANTIALIASING,
RenderingHints.VALUE_ANTIALIAS_ON);
// Iterate through all of the current shapes
for (Shape shape : shapes) {
// Get the bounds to compute the RadialGradient properties
Rectangle rect = shape.getBounds();
Point2D center = new Point2D.Float(
rect.x + (float)rect.width / 2.0f,
rect.y + (float)rect.height / 2.0f);
float radius = (float)rect.width / 2.0f;
float[] dist = {0.1f, 0.9f};
Color[] colors = {Color.WHITE, Color.BLACK};
// Create and set a RadialGradient centered on the object,
// going from white at the center to black at the edges
RadialGradientPaint paint = new RadialGradientPaint(center, radius,
dist, colors);
g2d.setPaint(paint);
// Finally, render our shape
g2d.fill(shape);
}
}
/**
* Creates a new instance of DrawShapes_2008
*/
public DrawShapes_2008() {
setBackground(Color.WHITE);
addMouseListener(new ClickReceiver());
}
private static void createAndShowGUI() {
JFrame f = new JFrame("Draw Shapes");
f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
f.setSize(500, 500);
f.add(new DrawShapes_2008());
f.setVisible(true);
}
public static void main(String args[]) {
Runnable doCreateAndShowGUI = new Runnable() {
public void run() {
createAndShowGUI();
}
};
SwingUtilities.invokeLater(doCreateAndShowGUI);
}
}
Gradients in the middle
import java.awt.Color;
import java.awt.GradientPaint;
import java.awt.Graphics;
import java.awt.Graphics2D;
import javax.swing.JFrame;
import javax.swing.JPanel;
public class GradientsMiddle extends JPanel {
public void paint(Graphics g) {
super.paint(g);
Graphics2D g2d = (Graphics2D) g;
GradientPaint gp1 = new GradientPaint(0, 0, Color.orange, 0, 20, Color.black, true);
g2d.setPaint(gp1);
g2d.fillRect(20, 260, 300, 40);
}
public static void main(String[] args) {
JFrame frame = new JFrame("GradientsMiddle");
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
frame.add(new GradientsMiddle());
frame.setSize(350, 350);
frame.setLocationRelativeTo(null);
frame.setVisible(true);
}
}
Horizontal Gradients
import java.awt.Color;
import java.awt.GradientPaint;
import java.awt.Graphics;
import java.awt.Graphics2D;
import javax.swing.JFrame;
import javax.swing.JPanel;
public class GradientsLine extends JPanel {
public void paint(Graphics g) {
super.paint(g);
Graphics2D g2d = (Graphics2D) g;
GradientPaint gp1 = new GradientPaint(5, 25, Color.green, 2, 2, Color.black, true);
g2d.setPaint(gp1);
g2d.fillRect(20, 140, 300, 40);
}
public static void main(String[] args) {
JFrame frame = new JFrame("GradientsLine");
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
frame.add(new GradientsLine());
frame.setSize(350, 350);
frame.setLocationRelativeTo(null);
frame.setVisible(true);
}
}
Returns true if the two Paint objects are equal OR both null.
import java.awt.GradientPaint;
import java.awt.Paint;
/*
* JCommon : a free general purpose class library for the Java(tm) platform
*
*
* (C) Copyright 2000-2005, by Object Refinery Limited and Contributors.
*
* Project Info: http://www.jfree.org/jcommon/index.html
*
* This library is free software; you can redistribute it and/or modify it
* under the terms of the GNU Lesser General Public License as published by
* the Free Software Foundation; either version 2.1 of the License, or
* (at your option) any later version.
*
* This library 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 Lesser General Public
* License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
* USA.
*
* [Java is a trademark or registered trademark of Sun Microsystems, Inc.
* in the United States and other countries.]
*
* -------------------
* PaintUtilities.java
* -------------------
* (C) Copyright 2003-2005, by Object Refinery Limited.
*
* Original Author: David Gilbert (for Object Refinery Limited);
* Contributor(s): -;
*
* $Id: PaintUtilities.java,v 1.10 2007/11/02 17:50:37 taqua Exp $
*
* Changes
* -------
* 13-Nov-2003 : Version 1 (DG);
* 04-Oct-2004 : Renamed PaintUtils --> PaintUtilities (DG);
* 23-Feb-2005 : Rewrote equal() method with less indenting required (DG);
*
*/
public class Main {
/**
* Returns <code>true</code> if the two <code>Paint</code> objects are equal
* OR both <code>null</code>. This method handles
* <code>GradientPaint</code> as a special case.
*
* @param p1 paint 1 (<code>null</code> permitted).
* @param p2 paint 2 (<code>null</code> permitted).
*
* @return A boolean.
*/
public static boolean equal(final Paint p1, final Paint p2) {
// handle cases where either or both arguments are null
if (p1 == null) {
return (p2 == null);
}
if (p2 == null) {
return false;
}
boolean result = false;
// handle GradientPaint as a special case...
if (p1 instanceof GradientPaint && p2 instanceof GradientPaint) {
final GradientPaint gp1 = (GradientPaint) p1;
final GradientPaint gp2 = (GradientPaint) p2;
result = gp1.getColor1().equals(gp2.getColor1())
&& gp1.getColor2().equals(gp2.getColor2())
&& gp1.getPoint1().equals(gp2.getPoint1())
&& gp1.getPoint2().equals(gp2.getPoint2())
&& gp1.isCyclic() == gp2.isCyclic()
&& gp1.getTransparency() == gp1.getTransparency();
}
else {
result = p1.equals(p2);
}
return result;
}
}
Round GradientPaint Fill demo
import java.awt.Color;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.Paint;
import java.awt.PaintContext;
import java.awt.Rectangle;
import java.awt.RenderingHints;
import java.awt.geom.AffineTransform;
import java.awt.geom.Point2D;
import java.awt.geom.Rectangle2D;
import java.awt.geom.RoundRectangle2D;
import java.awt.image.ColorModel;
import java.awt.image.Raster;
import java.awt.image.WritableRaster;
import javax.swing.JFrame;
import javax.swing.JPanel;
public class RoundGradientPaintFill extends JPanel{
public void paint(Graphics g) {
Graphics2D g2 = (Graphics2D) g;
RoundRectangle2D r = new RoundRectangle2D.Float(5, 5, 150, 150, 25,
25);
RoundGradientPaint rgp = new RoundGradientPaint(75, 75, Color.magenta,
new Point2D.Double(0, 85), Color.blue);
g2.setPaint(rgp);
g2.fill(r);
}
public static void main(String[] args) {
JFrame f = new JFrame();
f.getContentPane().add(new RoundGradientPaintFill());
f.setSize(200, 200);
f.show();
}
class RoundGradientPaint implements Paint {
protected Point2D point;
protected Point2D mRadius;
protected Color mPointColor, mBackgroundColor;
public RoundGradientPaint(double x, double y, Color pointColor,
Point2D radius, Color backgroundColor) {
if (radius.distance(0, 0) <= 0)
throw new IllegalArgumentException("Radius must be greater than 0.");
point = new Point2D.Double(x, y);
mPointColor = pointColor;
mRadius = radius;
mBackgroundColor = backgroundColor;
}
public PaintContext createContext(ColorModel cm, Rectangle deviceBounds,
Rectangle2D userBounds, AffineTransform xform, RenderingHints hints) {
Point2D transformedPoint = xform.transform(point, null);
Point2D transformedRadius = xform.deltaTransform(mRadius, null);
return new RoundGradientContext(transformedPoint, mPointColor,
transformedRadius, mBackgroundColor);
}
public int getTransparency() {
int a1 = mPointColor.getAlpha();
int a2 = mBackgroundColor.getAlpha();
return (((a1 & a2) == 0xff) ? OPAQUE : TRANSLUCENT);
}
}
public class RoundGradientContext implements PaintContext {
protected Point2D mPoint;
protected Point2D mRadius;
protected Color color1, color2;
public RoundGradientContext(Point2D p, Color c1, Point2D r, Color c2) {
mPoint = p;
color1 = c1;
mRadius = r;
color2 = c2;
}
public void dispose() {
}
public ColorModel getColorModel() {
return ColorModel.getRGBdefault();
}
public Raster getRaster(int x, int y, int w, int h) {
WritableRaster raster = getColorModel().createCompatibleWritableRaster(
w, h);
int[] data = new int[w * h * 4];
for (int j = 0; j < h; j++) {
for (int i = 0; i < w; i++) {
double distance = mPoint.distance(x + i, y + j);
double radius = mRadius.distance(0, 0);
double ratio = distance / radius;
if (ratio > 1.0)
ratio = 1.0;
int base = (j * w + i) * 4;
data[base + 0] = (int) (color1.getRed() + ratio
* (color2.getRed() - color1.getRed()));
data[base + 1] = (int) (color1.getGreen() + ratio
* (color2.getGreen() - color1.getGreen()));
data[base + 2] = (int) (color1.getBlue() + ratio
* (color2.getBlue() - color1.getBlue()));
data[base + 3] = (int) (color1.getAlpha() + ratio
* (color2.getAlpha() - color1.getAlpha()));
}
}
raster.setPixels(0, 0, w, h, data);
return raster;
}
}
}
Text effect: image texture
import java.awt.Color;
import java.awt.Dimension;
import java.awt.Font;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.Rectangle;
import java.awt.RenderingHints;
import java.awt.TexturePaint;
import java.awt.image.BufferedImage;
import javax.swing.JFrame;
import javax.swing.JPanel;
public class TexturedText extends JPanel {
public void paint(Graphics g) {
Graphics2D g2 = (Graphics2D) g;
g2.setRenderingHint(RenderingHints.KEY_ANTIALIASING,
RenderingHints.VALUE_ANTIALIAS_ON);
Font font = new Font("Times New Roman", Font.PLAIN, 72);
g2.setFont(font);
String s = "Java Source and Support";
Dimension d = getSize();
float x = 20, y = 100;
BufferedImage bi = getTextureImage();
Rectangle r = new Rectangle(0, 0, bi.getWidth(), bi.getHeight());
TexturePaint tp = new TexturePaint(bi, r);
g2.setPaint(tp);
g2.drawString(s, x, y);
}
private BufferedImage getTextureImage() {
// Create the test image.
int size = 8;
BufferedImage bi = new BufferedImage(size, size,
BufferedImage.TYPE_INT_ARGB);
Graphics2D g2 = bi.createGraphics();
g2.setPaint(Color.red);
g2.fillRect(0, 0, size / 2, size / 2);
g2.setPaint(Color.yellow);
g2.fillRect(size / 2, 0, size, size / 2);
g2.setPaint(Color.green);
g2.fillRect(0, size / 2, size / 2, size);
g2.setPaint(Color.blue);
g2.fillRect(size / 2, size / 2, size, size);
return bi;
}
public static void main(String[] args) {
JFrame f = new JFrame();
f.getContentPane().add(new TexturedText());
f.setSize(800, 250);
f.show();
}
}
Text effect: rotation and transparent
import java.awt.AlphaComposite;
import java.awt.Dimension;
import java.awt.Font;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.RenderingHints;
import java.awt.geom.AffineTransform;
import javax.swing.JFrame;
import javax.swing.JPanel;
public class TextRendering extends JPanel {
public void paint(Graphics g) {
Graphics2D g2 = (Graphics2D) g;
g2.setRenderingHint(RenderingHints.KEY_ANTIALIASING,
RenderingHints.VALUE_ANTIALIAS_ON);
Dimension d = getSize();
AffineTransform ct = AffineTransform.getTranslateInstance(d.width / 2,
d.height * 3 / 4);
g2.transform(ct);
String s = "www.jexp.ru";
Font f = new Font("Serif", Font.PLAIN, 128);
g2.setFont(f);
int count = 6;
for (int i = 1; i <= count; i++) {
AffineTransform oldTransform = g2.getTransform();
float ratio = (float) i / (float) count;
g2.transform(AffineTransform.getRotateInstance(Math.PI
* (ratio - 1.0f)));
float alpha = ((i == count) ? 1.0f : ratio / 3);
g2.setComposite(AlphaComposite.getInstance(AlphaComposite.SRC_OVER,
alpha));
g2.drawString(s, 0, 0);
g2.setTransform(oldTransform);
}
}
public static void main(String[] args) {
JFrame f = new JFrame();
f.getContentPane().add(new TextRendering());
f.setSize(800, 800);
f.show();
}
}
Texture paint
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.TexturePaint;
import java.awt.geom.Rectangle2D;
import java.awt.geom.RoundRectangle2D;
import java.awt.image.BufferedImage;
import java.io.IOException;
import java.io.InputStream;
import javax.swing.JFrame;
import javax.swing.JPanel;
import com.sun.image.codec.jpeg.ImageFormatException;
import com.sun.image.codec.jpeg.JPEGCodec;
import com.sun.image.codec.jpeg.JPEGImageDecoder;
public class TexturePaintFill extends JPanel {
private BufferedImage mImage;
public TexturePaintFill() throws IOException, ImageFormatException {
// Load the specified JPEG file.
InputStream in = getClass().getResourceAsStream("largejexpLogo.jpg");
JPEGImageDecoder decoder = JPEGCodec.createJPEGDecoder(in);
mImage = decoder.decodeAsBufferedImage();
in.close();
}
public void paint(Graphics g) {
Graphics2D g2 = (Graphics2D) g;
// a round rectangle.
RoundRectangle2D r = new RoundRectangle2D.Float(25, 35, 150, 150, 25,
25);
// a texture rectangle the same size as the texture image.
Rectangle2D tr = new Rectangle2D.Double(0, 0, mImage.getWidth(), mImage
.getHeight());
// the TexturePaint.
TexturePaint tp = new TexturePaint(mImage, tr);
// Now fill the round rectangle.
g2.setPaint(tp);
g2.fill(r);
}
public static void main(String[] args) throws Exception {
JFrame f = new JFrame();
f.getContentPane().add(new TexturePaintFill());
f.setSize(350, 250);
f.show();
}
}
Vertical Gradient Paint
import java.awt.Color;
import java.awt.GradientPaint;
import java.awt.Graphics;
import java.awt.Graphics2D;
import javax.swing.JFrame;
import javax.swing.JPanel;
public class GradientsVertical extends JPanel {
public void paint(Graphics g) {
super.paint(g);
Graphics2D g2d = (Graphics2D) g;
GradientPaint gp1 = new GradientPaint(25, 25, Color.blue, 15, 25, Color.black, true);
g2d.setPaint(gp1);
g2d.fillRect(20, 200, 300, 40);
}
public static void main(String[] args) {
JFrame frame = new JFrame("GradientsVertical");
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
frame.add(new GradientsVertical());
frame.setSize(350, 350);
frame.setLocationRelativeTo(null);
frame.setVisible(true);
}
}