/*
 * Copyright (c) 1997, 2010, Oracle and/or its affiliates. All rights reserved.
 * ORACLE PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 */

package java.awt;

import java.awt.geom.Point2D;
import java.awt.geom.Rectangle2D;
import java.awt.geom.AffineTransform;
import java.awt.image.ColorModel;
import java.beans.ConstructorProperties;

/**
 * The <code>GradientPaint</code> class provides a way to fill
 * a {@link Shape} with a linear color gradient pattern.
 * If {@link Point} P1 with {@link Color} C1 and <code>Point</code> P2 with
 * <code>Color</code> C2 are specified in user space, the
 * <code>Color</code> on the P1, P2 connecting line is proportionally
 * changed from C1 to C2. Any point P not on the extended P1, P2
 * connecting line has the color of the point P' that is the perpendicular
 * projection of P on the extended P1, P2 connecting line.
 * Points on the extended line outside of the P1, P2 segment can be colored
 * in one of two ways.
 * <ul>
 * <li>
 * If the gradient is cyclic then the points on the extended P1, P2
 * connecting line cycle back and forth between the colors C1 and C2.
 * <li>
 * If the gradient is acyclic then points on the P1 side of the segment
 * have the constant <code>Color</code> C1 while points on the P2 side
 * have the constant <code>Color</code> C2.
 * </ul>
 *
 * @see Paint
 * @see Graphics2D#setPaint
 * @version 10 Feb 1997
 */

public class GradientPaint implements Paint {
 Point2D.Float p1;
 Point2D.Float p2;
 Color color1;
 Color color2;
 boolean cyclic;

 /**
 * Constructs a simple acyclic <code>GradientPaint</code> object.
 * @param x1 x coordinate of the first specified
 * <code>Point</code> in user space
 * @param y1 y coordinate of the first specified
 * <code>Point</code> in user space
 * @param color1 <code>Color</code> at the first specified
 * <code>Point</code>
 * @param x2 x coordinate of the second specified
 * <code>Point</code> in user space
 * @param y2 y coordinate of the second specified
 * <code>Point</code> in user space
 * @param color2 <code>Color</code> at the second specified
 * <code>Point</code>
 * @throws NullPointerException if either one of colors is null
 */
 public GradientPaint(float x1,
 float y1,
 Color color1,
 float x2,
 float y2,
 Color color2) {
 if ((color1 == null) || (color2 == null)) {
 throw new NullPointerException("Colors cannot be null");
 }

 p1 = new Point2D.Float(x1, y1);
 p2 = new Point2D.Float(x2, y2);
 this.color1 = color1;
 this.color2 = color2;
 }

 /**
 * Constructs a simple acyclic <code>GradientPaint</code> object.
 * @param pt1 the first specified <code>Point</code> in user space
 * @param color1 <code>Color</code> at the first specified
 * <code>Point</code>
 * @param pt2 the second specified <code>Point</code> in user space
 * @param color2 <code>Color</code> at the second specified
 * <code>Point</code>
 * @throws NullPointerException if either one of colors or points
 * is null
 */
 public GradientPaint(Point2D pt1,
 Color color1,
 Point2D pt2,
 Color color2) {
 if ((color1 == null) || (color2 == null) ||
 (pt1 == null) || (pt2 == null)) {
 throw new NullPointerException("Colors and points should be non-null");
 }

 p1 = new Point2D.Float((float)pt1.getX(), (float)pt1.getY());
 p2 = new Point2D.Float((float)pt2.getX(), (float)pt2.getY());
 this.color1 = color1;
 this.color2 = color2;
 }

 /**
 * Constructs either a cyclic or acyclic <code>GradientPaint</code>
 * object depending on the <code>boolean</code> parameter.
 * @param x1 x coordinate of the first specified
 * <code>Point</code> in user space
 * @param y1 y coordinate of the first specified
 * <code>Point</code> in user space
 * @param color1 <code>Color</code> at the first specified
 * <code>Point</code>
 * @param x2 x coordinate of the second specified
 * <code>Point</code> in user space
 * @param y2 y coordinate of the second specified
 * <code>Point</code> in user space
 * @param color2 <code>Color</code> at the second specified
 * <code>Point</code>
 * @param cyclic <code>true</code> if the gradient pattern should cycle
 * repeatedly between the two colors; <code>false</code> otherwise
 */
 public GradientPaint(float x1,
 float y1,
 Color color1,
 float x2,
 float y2,
 Color color2,
 boolean cyclic) {
 this (x1, y1, color1, x2, y2, color2);
 this.cyclic = cyclic;
 }

 /**
 * Constructs either a cyclic or acyclic <code>GradientPaint</code>
 * object depending on the <code>boolean</code> parameter.
 * @param pt1 the first specified <code>Point</code>
 * in user space
 * @param color1 <code>Color</code> at the first specified
 * <code>Point</code>
 * @param pt2 the second specified <code>Point</code>
 * in user space
 * @param color2 <code>Color</code> at the second specified
 * <code>Point</code>
 * @param cyclic <code>true</code> if the gradient pattern should cycle
 * repeatedly between the two colors; <code>false</code> otherwise
 * @throws NullPointerException if either one of colors or points
 * is null
 */
 @ConstructorProperties({ "point1", "color1", "point2", "color2", "cyclic" })
 public GradientPaint(Point2D pt1,
 Color color1,
 Point2D pt2,
 Color color2,
 boolean cyclic) {
 this (pt1, color1, pt2, color2);
 this.cyclic = cyclic;
 }

 /**
 * Returns a copy of the point P1 that anchors the first color.
 * @return a {@link Point2D} object that is a copy of the point
 * that anchors the first color of this
 * <code>GradientPaint</code>.
 */
 public Point2D getPoint1() {
 return new Point2D.Float(p1.x, p1.y);
 }

 /**
 * Returns the color C1 anchored by the point P1.
 * @return a <code>Color</code> object that is the color
 * anchored by P1.
 */
 public Color getColor1() {
 return color1;
 }

 /**
 * Returns a copy of the point P2 which anchors the second color.
 * @return a {@link Point2D} object that is a copy of the point
 * that anchors the second color of this
 * <code>GradientPaint</code>.
 */
 public Point2D getPoint2() {
 return new Point2D.Float(p2.x, p2.y);
 }

 /**
 * Returns the color C2 anchored by the point P2.
 * @return a <code>Color</code> object that is the color
 * anchored by P2.
 */
 public Color getColor2() {
 return color2;
 }

 /**
 * Returns <code>true</code> if the gradient cycles repeatedly
 * between the two colors C1 and C2.
 * @return <code>true</code> if the gradient cycles repeatedly
 * between the two colors; <code>false</code> otherwise.
 */
 public boolean isCyclic() {
 return cyclic;
 }

 /**
 * Creates and returns a {@link PaintContext} used to
 * generate a linear color gradient pattern.
 * See the {@link Paint#createContext specification} of the
 * method in the {@link Paint} interface for information
 * on null parameter handling.
 *
 * @param cm the preferred {@link ColorModel} which represents the most convenient
 * format for the caller to receive the pixel data, or {@code null}
 * if there is no preference.
 * @param deviceBounds the device space bounding box
 * of the graphics primitive being rendered.
 * @param userBounds the user space bounding box
 * of the graphics primitive being rendered.
 * @param xform the {@link AffineTransform} from user
 * space into device space.
 * @param hints the set of hints that the context object can use to
 * choose between rendering alternatives.
 * @return the {@code PaintContext} for
 * generating color patterns.
 * @see Paint
 * @see PaintContext
 * @see ColorModel
 * @see Rectangle
 * @see Rectangle2D
 * @see AffineTransform
 * @see RenderingHints
 */
 public PaintContext createContext(ColorModel cm,
 Rectangle deviceBounds,
 Rectangle2D userBounds,
 AffineTransform xform,
 RenderingHints hints) {

 return new GradientPaintContext(cm, p1, p2, xform,
 color1, color2, cyclic);
 }

 /**
 * Returns the transparency mode for this <code>GradientPaint</code>.
 * @return an integer value representing this <code>GradientPaint</code>
 * object's transparency mode.
 * @see Transparency
 */
 public int getTransparency() {
 int a1 = color1.getAlpha();
 int a2 = color2.getAlpha();
 return (((a1 & a2) == 0xff) ? OPAQUE : TRANSLUCENT);
 }

}