Java/2D Graphics GUI/Gradient Paint

Материал из Java эксперт
Перейти к: навигация, поиск

A cyclic gradient

<source lang="java"> 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));
 }

} 


 </source>



A non-cyclic gradient

<source lang="java">

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));
 }

} 


 </source>



Another GradientPaint Demo

<source lang="java"> 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();
 }

} 



 </source>



Color gradient

<source lang="java"> 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();
 }

} 



 </source>



Control the direction of Gradients

<source lang="java"> 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);
 }

} 


 </source>



Drawing with a Gradient Color

<source lang="java"> 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));
 }

} 


 </source>



GradientPaint demo

<source lang="java"> 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();
 }

} 



 </source>



GradientPaint Ellipse

<source lang="java"> 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();
 }

} 



 </source>



GradientPaint: iron

<source lang="java"> 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);
 }

} 



 </source>



Gradients: a smooth blending of shades from light to dark or from one color to another

<source lang="java"> 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);
 }

} 


 </source>



Gradient Shapes

<source lang="java">


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);
   }

} 



 </source>



Gradients in the middle

<source lang="java"> 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);
 }

} 


 </source>



Horizontal Gradients

<source lang="java"> 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);
 }

} 


 </source>



Returns true if the two Paint objects are equal OR both null.

<source lang="java"> 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 true if the two Paint objects are equal 
  * OR both null.  This method handles
  * GradientPaint as a special case.
  *
  * @param p1  paint 1 (null permitted).
  * @param p2  paint 2 (null 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;
 }

} 


 </source>



Round GradientPaint Fill demo

<source lang="java"> 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;
   }
 }

} 



 </source>



Text effect: image texture

<source lang="java"> 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();
 }

} 



 </source>



Text effect: rotation and transparent

<source lang="java"> 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();
 }

} 



 </source>



Texture paint

<source lang="java"> 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();
 }

} 



 </source>



Vertical Gradient Paint

<source lang="java"> 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);
 }

} 


 </source>
Источник — «http://jexp.ru/index.php?title=Java/2D_Graphics_GUI/Gradient_Paint&oldid=8179»