/*

 * Copyright (c) 1996, 2008, 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.  Oracle designates this

 * particular file as subject to the "Classpath" exception as provided

 * by Oracle in the LICENSE file that accompanied this code.

 *

 * 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.

 */

package sun.java2d;

import java.awt.Graphics;

import java.awt.Graphics2D;

import java.awt.RenderingHints;

import java.awt.RenderingHints.Key;

import java.awt.geom.Area;

import java.awt.geom.AffineTransform;

import java.awt.geom.NoninvertibleTransformException;

import java.awt.AlphaComposite;

import java.awt.BasicStroke;

import java.awt.image.BufferedImage;

import java.awt.image.BufferedImageOp;

import java.awt.image.RenderedImage;

import java.awt.image.renderable.RenderableImage;

import java.awt.image.renderable.RenderContext;

import java.awt.image.AffineTransformOp;

import java.awt.image.Raster;

import java.awt.image.WritableRaster;

import java.awt.Image;

import java.awt.Composite;

import java.awt.Color;

import java.awt.image.ColorModel;

import java.awt.GraphicsConfiguration;

import java.awt.Paint;

import java.awt.GradientPaint;

import java.awt.LinearGradientPaint;

import java.awt.RadialGradientPaint;

import java.awt.TexturePaint;

import java.awt.geom.Rectangle2D;

import java.awt.geom.PathIterator;

import java.awt.geom.GeneralPath;

import java.awt.Shape;

import java.awt.Stroke;

import java.awt.FontMetrics;

import java.awt.Rectangle;

import java.text.AttributedCharacterIterator;

import java.awt.Font;

import java.awt.image.ImageObserver;

import java.awt.Transparency;

import java.awt.font.GlyphVector;

import java.awt.font.TextLayout;

import sun.font.FontDesignMetrics;

import sun.font.FontUtilities;

import sun.java2d.pipe.PixelDrawPipe;

import sun.java2d.pipe.PixelFillPipe;

import sun.java2d.pipe.ShapeDrawPipe;

import sun.java2d.pipe.ValidatePipe;

import sun.java2d.pipe.ShapeSpanIterator;

import sun.java2d.pipe.Region;

import sun.java2d.pipe.TextPipe;

import sun.java2d.pipe.DrawImagePipe;

import sun.java2d.pipe.LoopPipe;

import sun.java2d.loops.FontInfo;

import sun.java2d.loops.RenderLoops;

import sun.java2d.loops.CompositeType;

import sun.java2d.loops.SurfaceType;

import sun.java2d.loops.Blit;

import sun.java2d.loops.MaskFill;

import sun.font.FontManager;

import java.awt.font.FontRenderContext;

import sun.java2d.loops.XORComposite;

import sun.awt.ConstrainableGraphics;

import sun.awt.SunHints;

import java.util.Map;

import java.util.Iterator;

import sun.java2d.DestSurfaceProvider;

import sun.misc.PerformanceLogger;

/**

 * This is a the master Graphics2D superclass for all of the Sun

 * Graphics implementations.  This class relies on subclasses to

 * manage the various device information, but provides an overall

 * general framework for performing all of the requests in the

 * Graphics and Graphics2D APIs.

 *

 * @author Jim Graham

 */

public final class SunGraphics2D

    extends Graphics2D

    implements ConstrainableGraphics, Cloneable, DestSurfaceProvider

{

    /*

     * Attribute States

     */

    /* Paint */

    public static final int PAINT_CUSTOM       = 6; /* Any other Paint object */

    public static final int PAINT_TEXTURE      = 5; /* Tiled Image */

    public static final int PAINT_RAD_GRADIENT = 4; /* Color RadialGradient */

    public static final int PAINT_LIN_GRADIENT = 3; /* Color LinearGradient */

    public static final int PAINT_GRADIENT     = 2; /* Color Gradient */

    public static final int PAINT_ALPHACOLOR   = 1; /* Non-opaque Color */

    public static final int PAINT_OPAQUECOLOR  = 0; /* Opaque Color */

    /* Composite*/

    public static final int COMP_CUSTOM = 3;/* Custom Composite */

    public static final int COMP_XOR    = 2;/* XOR Mode Composite */

    public static final int COMP_ALPHA  = 1;/* AlphaComposite */

    public static final int COMP_ISCOPY = 0;/* simple stores into destination,

                                             * i.e. Src, SrcOverNoEa, and other

                                             * alpha modes which replace

                                             * the destination.

                                             */

    /* Stroke */

    public static final int STROKE_CUSTOM = 3; /* custom Stroke */

    public static final int STROKE_WIDE   = 2; /* BasicStroke */

    public static final int STROKE_THINDASHED   = 1; /* BasicStroke */

    public static final int STROKE_THIN   = 0; /* BasicStroke */

    /* Transform */

    public static final int TRANSFORM_GENERIC = 4; /* any 3x2 */

    public static final int TRANSFORM_TRANSLATESCALE = 3; /* scale XY */

    public static final int TRANSFORM_ANY_TRANSLATE = 2; /* non-int translate */

    public static final int TRANSFORM_INT_TRANSLATE = 1; /* int translate */

    public static final int TRANSFORM_ISIDENT = 0; /* Identity */

    /* Clipping */

    public static final int CLIP_SHAPE       = 2; /* arbitrary clip */

    public static final int CLIP_RECTANGULAR = 1; /* rectangular clip */

    public static final int CLIP_DEVICE      = 0; /* no clipping set */

    /* The following fields are used when the current Paint is a Color. */

    public int eargb;  // ARGB value with ExtraAlpha baked in

    public int pixel;  // pixel value for eargb

    public SurfaceData surfaceData;

    public PixelDrawPipe drawpipe;

    public PixelFillPipe fillpipe;

    public DrawImagePipe imagepipe;

    public ShapeDrawPipe shapepipe;

    public TextPipe textpipe;

    public MaskFill alphafill;

    public RenderLoops loops;

    public CompositeType imageComp;     /* Image Transparency checked on fly */

    public int paintState;

    public int compositeState;

    public int strokeState;

    public int transformState;

    public int clipState;

    public Color foregroundColor;

    public Color backgroundColor;

    public AffineTransform transform;

    public int transX;

    public int transY;

    protected static final Stroke defaultStroke = new BasicStroke();

    protected static final Composite defaultComposite = AlphaComposite.SrcOver;

    private static final Font defaultFont =

        new Font(Font.DIALOG, Font.PLAIN, 12);

    public Paint paint;

    public Stroke stroke;

    public Composite composite;

    protected Font font;

    protected FontMetrics fontMetrics;

    public int renderHint;

    public int antialiasHint;

    public int textAntialiasHint;

    protected int fractionalMetricsHint;

    /* A gamma adjustment to the colour used in lcd text blitting */

    public int lcdTextContrast;

    private static int lcdTextContrastDefaultValue = 140;

    private int interpolationHint;      // raw value of rendering Hint

    public int strokeHint;

    public int interpolationType;       // algorithm choice based on

                                        // interpolation and render Hints

    public RenderingHints hints;

    public Region constrainClip;                // lightweight bounds

    public int constrainX;

    public int constrainY;

    public Region clipRegion;

    public Shape usrClip;

    protected Region devClip;           // Actual physical drawable

    // cached state for text rendering

    private boolean validFontInfo;

    private FontInfo fontInfo;

    private FontInfo glyphVectorFontInfo;

    private FontRenderContext glyphVectorFRC;

    private final static int slowTextTransformMask =

                            AffineTransform.TYPE_GENERAL_TRANSFORM

                        |   AffineTransform.TYPE_MASK_ROTATION

                        |   AffineTransform.TYPE_FLIP;

    static {

        if (PerformanceLogger.loggingEnabled()) {

            PerformanceLogger.setTime("SunGraphics2D static initialization");

        }

    }

    public SunGraphics2D(SurfaceData sd, Color fg, Color bg, Font f) {

        surfaceData = sd;

        foregroundColor = fg;

        backgroundColor = bg;

        transform = new AffineTransform();

        stroke = defaultStroke;

        composite = defaultComposite;

        paint = foregroundColor;

        imageComp = CompositeType.SrcOverNoEa;

        renderHint = SunHints.INTVAL_RENDER_DEFAULT;

        antialiasHint = SunHints.INTVAL_ANTIALIAS_OFF;

        textAntialiasHint = SunHints.INTVAL_TEXT_ANTIALIAS_DEFAULT;

        fractionalMetricsHint = SunHints.INTVAL_FRACTIONALMETRICS_OFF;

        lcdTextContrast = lcdTextContrastDefaultValue;

        interpolationHint = -1;

        strokeHint = SunHints.INTVAL_STROKE_DEFAULT;

        interpolationType = AffineTransformOp.TYPE_NEAREST_NEIGHBOR;

        validateColor();

        font = f;

        if (font == null) {

            font = defaultFont;

        }

        setDevClip(sd.getBounds());

        invalidatePipe();

    }

    protected Object clone() {

        try {

            SunGraphics2D g = (SunGraphics2D) super.clone();

            g.transform = new AffineTransform(this.transform);

            if (hints != null) {

                g.hints = (RenderingHints) this.hints.clone();

            }

            /* FontInfos are re-used, so must be cloned too, if they

             * are valid, and be nulled out if invalid.

             * The implied trade-off is that there is more to be gained

             * from re-using these objects than is lost by having to

             * clone them when the SG2D is cloned.

             */

            if (this.fontInfo != null) {

                if (this.validFontInfo) {

                    g.fontInfo = (FontInfo)this.fontInfo.clone();

                } else {

                    g.fontInfo = null;

                }

            }

            if (this.glyphVectorFontInfo != null) {

                g.glyphVectorFontInfo =

                    (FontInfo)this.glyphVectorFontInfo.clone();

                g.glyphVectorFRC = this.glyphVectorFRC;

            }

            //g.invalidatePipe();

            return g;

        } catch (CloneNotSupportedException e) {

        }

        return null;

    }

    /**

     * Create a new SunGraphics2D based on this one.

     */

    public Graphics create() {

        return (Graphics) clone();

    }

    public void setDevClip(int x, int y, int w, int h) {

        Region c = constrainClip;

        if (c == null) {

            devClip = Region.getInstanceXYWH(x, y, w, h);

        } else {

            devClip = c.getIntersectionXYWH(x, y, w, h);

        }

        validateCompClip();

    }

    public void setDevClip(Rectangle r) {

        setDevClip(r.x, r.y, r.width, r.height);

    }

    /**

     * Constrain rendering for lightweight objects.

     *

     * REMIND: This method will back off to the "workaround"

     * of using translate and clipRect if the Graphics

     * to be constrained has a complex transform.  The

     * drawback of the workaround is that the resulting

     * clip and device origin cannot be "enforced".

     *

     * @exception IllegalStateException If the Graphics

     * to be constrained has a complex transform.

     */

    public void constrain(int x, int y, int w, int h) {

        if ((x|y) != 0) {

            translate(x, y);

        }

        if (transformState >= TRANSFORM_TRANSLATESCALE) {

            clipRect(0, 0, w, h);

            return;

        }

        x = constrainX = transX;

        y = constrainY = transY;

        w = Region.dimAdd(x, w);

        h = Region.dimAdd(y, h);

        Region c = constrainClip;

        if (c == null) {

            c = Region.getInstanceXYXY(x, y, w, h);

        } else {

            c = c.getIntersectionXYXY(x, y, w, h);

            if (c == constrainClip) {

                // Common case to ignore

                return;

            }

        }

        constrainClip = c;

        if (!devClip.isInsideQuickCheck(c)) {

            devClip = devClip.getIntersection(c);

            validateCompClip();

        }

    }

    protected static ValidatePipe invalidpipe = new ValidatePipe();

    /*

     * Invalidate the pipeline

     */

    protected void invalidatePipe() {

        drawpipe = invalidpipe;

        fillpipe = invalidpipe;

        shapepipe = invalidpipe;

        textpipe = invalidpipe;

        imagepipe = invalidpipe;

        loops = null;

    }

    public void validatePipe() {

        /* This workaround is for the situation when we update the Pipelines

         * for invalid SurfaceData and run further code when the current

         * pipeline doesn't support the type of new SurfaceData created during

         * the current pipeline's work (in place of the invalid SurfaceData).

         * Usually SurfaceData and Pipelines are repaired (through revalidateAll)

         * and called again in the exception handlers */

        if (!surfaceData.isValid()) {

            throw new InvalidPipeException("attempt to validate Pipe with invalid SurfaceData");

        }

        surfaceData.validatePipe(this);

    }

    /*

     * Intersect two Shapes by the simplest method, attempting to produce

     * a simplified result.

     * The boolean arguments keep1 and keep2 specify whether or not

     * the first or second shapes can be modified during the operation

     * or whether that shape must be "kept" unmodified.

     */

    Shape intersectShapes(Shape s1, Shape s2, boolean keep1, boolean keep2) {

        if (s1 instanceof Rectangle && s2 instanceof Rectangle) {

            return ((Rectangle) s1).intersection((Rectangle) s2);

        }

        if (s1 instanceof Rectangle2D) {

            return intersectRectShape((Rectangle2D) s1, s2, keep1, keep2);

        } else if (s2 instanceof Rectangle2D) {

            return intersectRectShape((Rectangle2D) s2, s1, keep2, keep1);

        }

        return intersectByArea(s1, s2, keep1, keep2);

    }

    /*

     * Intersect a Rectangle with a Shape by the simplest method,

     * attempting to produce a simplified result.

     * The boolean arguments keep1 and keep2 specify whether or not

     * the first or second shapes can be modified during the operation

     * or whether that shape must be "kept" unmodified.

     */

    Shape intersectRectShape(Rectangle2D r, Shape s,

                             boolean keep1, boolean keep2) {

        if (s instanceof Rectangle2D) {

            Rectangle2D r2 = (Rectangle2D) s;

            Rectangle2D outrect;

            if (!keep1) {

                outrect = r;

            } else if (!keep2) {

                outrect = r2;

            } else {

                outrect = new Rectangle2D.Float();

            }

            double x1 = Math.max(r.getX(), r2.getX());

            double x2 = Math.min(r.getX()  + r.getWidth(),

                                 r2.getX() + r2.getWidth());

            double y1 = Math.max(r.getY(), r2.getY());

            double y2 = Math.min(r.getY()  + r.getHeight(),

                                 r2.getY() + r2.getHeight());

            if (((x2 - x1) < 0) || ((y2 - y1) < 0))

                // Width or height is negative. No intersection.

                outrect.setFrameFromDiagonal(0, 0, 0, 0);

            else

                outrect.setFrameFromDiagonal(x1, y1, x2, y2);

            return outrect;

        }

        if (r.contains(s.getBounds2D())) {

            if (keep2) {

                s = cloneShape(s);

            }

            return s;

        }

        return intersectByArea(r, s, keep1, keep2);

    }

    protected static Shape cloneShape(Shape s) {

        return new GeneralPath(s);

    }

    /*

     * Intersect two Shapes using the Area class.  Presumably other

     * attempts at simpler intersection methods proved fruitless.

     * The boolean arguments keep1 and keep2 specify whether or not

     * the first or second shapes can be modified during the operation

     * or whether that shape must be "kept" unmodified.

     * @see #intersectShapes

     * @see #intersectRectShape

     */

    Shape intersectByArea(Shape s1, Shape s2, boolean keep1, boolean keep2) {

        Area a1, a2;

        // First see if we can find an overwriteable source shape

        // to use as our destination area to avoid duplication.

        if (!keep1 && (s1 instanceof Area)) {

            a1 = (Area) s1;

        } else if (!keep2 && (s2 instanceof Area)) {

            a1 = (Area) s2;

            s2 = s1;

        } else {

            a1 = new Area(s1);

        }

        if (s2 instanceof Area) {

            a2 = (Area) s2;

        } else {

            a2 = new Area(s2);

        }

        a1.intersect(a2);

        if (a1.isRectangular()) {

            return a1.getBounds();

        }

        return a1;

    }

    /*

     * Intersect usrClip bounds and device bounds to determine the composite

     * rendering boundaries.

     */

    public Region getCompClip() {

        if (!surfaceData.isValid()) {

            // revalidateAll() implicitly recalculcates the composite clip

            revalidateAll();

        }

        return clipRegion;

    }

    public Font getFont() {

        if (font == null) {

            font = defaultFont;

        }

        return font;

    }

    private static final double[] IDENT_MATRIX = {1, 0, 0, 1};

    private static final AffineTransform IDENT_ATX =

        new AffineTransform();

    private static final int MINALLOCATED = 8;

    private static final int TEXTARRSIZE = 17;

    private static double[][] textTxArr = new double[TEXTARRSIZE][];

    private static AffineTransform[] textAtArr =

        new AffineTransform[TEXTARRSIZE];

    static {

        for (int i=MINALLOCATED;i<TEXTARRSIZE;i++) {

          textTxArr[i] = new double [] {i, 0, 0, i};