/*

 * Copyright (c) 2011, 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.*;

import java.awt.font.*;

import java.awt.geom.*;

import java.awt.image.*;

import java.nio.*;

import sun.awt.*;

import sun.awt.image.*;

import sun.java2d.loops.*;

import sun.java2d.pipe.*;

import sun.lwawt.macosx.*;

/*

 * This is the SurfaceData for a CGContextRef.

 */

public abstract class OSXSurfaceData extends BufImgSurfaceData {

    final static float UPPER_BND = Float.MAX_VALUE / 2.0f;

    final static float LOWER_BND = -UPPER_BND;

    protected static CRenderer sQuartzPipe = null;

    protected static CTextPipe sCocoaTextPipe = null;

    protected static CompositeCRenderer sQuartzCompositePipe = null;

    private GraphicsConfiguration fConfig;

    private Rectangle fBounds; // bounds in user coordinates

    static {

        sQuartzPipe = new CRenderer(); // Creates the singleton quartz pipe.

    }

    // NOTE: Any subclasses must eventually call QuartzSurfaceData_InitOps in OSXSurfaceData.h

    // This sets up the native side for the SurfaceData, and is required.

    public OSXSurfaceData(SurfaceType sType, ColorModel cm) {

        this(sType, cm, null, new Rectangle());

    }

    public OSXSurfaceData(SurfaceType sType, ColorModel cm, GraphicsConfiguration config, Rectangle bounds) {

        super(sType, cm);

        this.fConfig = config;

        this.fBounds = new Rectangle(bounds.x, bounds.y, bounds.width, bounds.y + bounds.height);

        this.fGraphicsStates = getBufferOfSize(kSizeOfParameters);

        this.fGraphicsStatesInt = this.fGraphicsStates.asIntBuffer();

        this.fGraphicsStatesFloat = this.fGraphicsStates.asFloatBuffer();

        this.fGraphicsStatesLong = this.fGraphicsStates.asLongBuffer();

        this.fGraphicsStatesObject = new Object[6]; // clip coordinates + clip types + texture paint image + stroke dash

                                                    // array + font + font paint

        // NOTE: All access to the DrawingQueue comes through this OSXSurfaceData instance. Therefore

        // every instance method of OSXSurfaceData that accesses the fDrawingQueue is synchronized.

        // Thread.dumpStack();

    }

    public void validatePipe(SunGraphics2D sg2d) {

        if (sg2d.compositeState <= SunGraphics2D.COMP_ALPHA) {

            if (sCocoaTextPipe == null) {

                sCocoaTextPipe = new CTextPipe();

            }

            sg2d.imagepipe = sQuartzPipe;

            sg2d.drawpipe = sQuartzPipe;

            sg2d.fillpipe = sQuartzPipe;

            sg2d.shapepipe = sQuartzPipe;

            sg2d.textpipe = sCocoaTextPipe;

        } else {

            setPipesToQuartzComposite(sg2d);

        }

    }

    protected void setPipesToQuartzComposite(SunGraphics2D sg2d) {

        if (sQuartzCompositePipe == null) {

            sQuartzCompositePipe = new CompositeCRenderer();

        }

        if (sCocoaTextPipe == null) {

            sCocoaTextPipe = new CTextPipe();

        }

        sg2d.imagepipe = sQuartzCompositePipe;

        sg2d.drawpipe = sQuartzCompositePipe;

        sg2d.fillpipe = sQuartzCompositePipe;

        sg2d.shapepipe = sQuartzCompositePipe;

        sg2d.textpipe = sCocoaTextPipe;

    }

    public Rectangle getBounds() {

        // gznote: always return a copy, not the rect itself and translate into device space

        return new Rectangle(fBounds.x, fBounds.y, fBounds.width, fBounds.height - fBounds.y);

    }

    public GraphicsConfiguration getDeviceConfiguration() {

        return fConfig;

    }

    protected void setBounds(int x, int y, int w, int h) {

        fBounds.reshape(x, y, w, y + h);

    }

    // START compositing support API

    public abstract BufferedImage copyArea(SunGraphics2D sg2d, int x, int y, int w, int h, BufferedImage image);

    public abstract boolean xorSurfacePixels(SunGraphics2D sg2d, BufferedImage srcPixels, int x, int y, int w, int h, int colorXOR);

    GraphicsConfiguration sDefaultGraphicsConfiguration = null;

    protected BufferedImage getCompositingImage(int w, int h) {

        if (sDefaultGraphicsConfiguration == null) {

            sDefaultGraphicsConfiguration = GraphicsEnvironment.getLocalGraphicsEnvironment().getDefaultScreenDevice().getDefaultConfiguration();

        }

        BufferedImage img = new BufferedImage(w, h, BufferedImage.TYPE_INT_ARGB_PRE);

        // clear the image.

        clearRect(img, w, h);

        return img;

    }

    protected BufferedImage getCompositingImageSame(BufferedImage img, int w, int h) {

        if ((img == null) || (img.getWidth() != w) || (img.getHeight() != h)) {

            img = getCompositingImage(w, h);

        }

        return img;

    }

    BufferedImage sSrcComposite = null;

    public BufferedImage getCompositingSrcImage(int w, int h) {

        // <rdar://problem/3720263>. Changed from getCompositingImageBiggerOrSame() to

        // getCompositingImageSame(). (vm)

        BufferedImage bim = getCompositingImageSame(sSrcComposite, w, h);

        sSrcComposite = bim;

        return bim;

    }

    BufferedImage sDstInComposite = null;

    public BufferedImage getCompositingDstInImage(int w, int h) {

        BufferedImage bim = getCompositingImageSame(sDstInComposite, w, h);

        sDstInComposite = bim;

        return bim;

    }

    BufferedImage sDstOutComposite = null;

    public BufferedImage getCompositingDstOutImage(int w, int h) {

        BufferedImage bim = getCompositingImageSame(sDstOutComposite, w, h);

        sDstOutComposite = bim;

        return bim;

    }

    public void clearRect(BufferedImage bim, int w, int h) {

        Graphics2D g = bim.createGraphics();

        g.setComposite(AlphaComposite.Clear);

        g.fillRect(0, 0, w, h);

        g.dispose();

    }

    // END compositing support API

    public void invalidate() {

        // always valid

    }

     // graphics primitives drawing implementation:

    // certain primitives don't care about all the states (ex. drawing an image needs not involve setting current paint)

    static final int kPrimitive = 0;

    static final int kImage = 1;

    static final int kText = 2;

    static final int kCopyArea = 3;

    static final int kExternal = 4;

    static final int kLine = 5; // belongs to kPrimitive

    static final int kRect = 6; // belongs to kPrimitive

    static final int kRoundRect = 7; // belongs to kPrimitive

    static final int kOval = 8; // belongs to kPrimitive

    static final int kArc = 9; // belongs to kPrimitive

    static final int kPolygon = 10; // belongs to kPrimitive

    static final int kShape = 11; // belongs to kPrimitive

    // static final int kImage = 12; // belongs to kImage

    static final int kString = 13; // belongs to kText

    static final int kGlyphs = 14; // belongs to kText

    static final int kUnicodes = 15; // belongs to kText

    // static final int kCopyArea = 16; // belongs to kCopyArea

    // static final int kExternal = 17; // belongs to kExternal

    static final int kCommonParameterCount = 1 + 1 + 4 + 4; // type + change flags + color info (type(1) align(1) and

                                                            // value(2)) + parameters ((x1, y1, x2, y2) OR (x, y, w, h))

    static final int kLineParametersCount = kCommonParameterCount; // kCommonParameterCount

    static final int kRectParametersCount = kCommonParameterCount + 1; // kCommonParameterCount + isfill

    static final int kRoundRectParametersCount = kCommonParameterCount + 2 + 1; // kCommonParameterCount + arcW + arcH +

                                                                                // isfill

    static final int kOvalParametersCount = kCommonParameterCount + 1; // kCommonParameterCount + isfill

    static final int kArcParametersCount = kCommonParameterCount + 2 + 1 + 1;// kCommonParameterCount + startAngle +

                                                                             // arcAngle + isfill + type

    static final int kPolygonParametersCount = 0; // not supported

    static final int kShapeParametersCount = 0; // not supported

    static final int kImageParametersCount = kCommonParameterCount + 2 + 2 + 4 + 4; // flip horz vert + w&h + src + dst

    static final int kStringParametersCount = 0; // not supported

    static final int kGlyphsParametersCount = 0; // not supported

    static final int kUnicodesParametersCount = 0; // not supported

    static final int kPixelParametersCount = 0; // not supported

    static final int kExternalParametersCount = 0; // not supported

    // for intParameters

    // states info

    static final int kChangeFlagIndex = 0; // kBoundsChangedBit | .. | kFontChangedBit

    // bounds info

    static final int kBoundsXIndex = 1;

    static final int kBoundsYIndex = 2;

    static final int kBoundsWidthIndex = 3;

    static final int kBoundsHeightIndex = 4;

    // clip info

    static final int kClipStateIndex = 5;

    static final int kClipNumTypesIndex = 6;

    static final int kClipNumCoordsIndex = 7;

    static final int kClipWindingRuleIndex = 8;

    static final int kClipXIndex = 9;

    static final int kClipYIndex = 10;

    static final int kClipWidthIndex = 11;

    static final int kClipHeightIndex = 12;

    // ctm info

    static final int kCTMaIndex = 13;

    static final int kCTMbIndex = 14;

    static final int kCTMcIndex = 15;

    static final int kCTMdIndex = 16;

    static final int kCTMtxIndex = 17;

    static final int kCTMtyIndex = 18;

    // color info

    static final int kColorStateIndex = 19; // kColorSimple or kColorGradient or kColorTexture

    static final int kColorRGBValueIndex = 20; // if kColorSimple

    static final int kColorIndexValueIndex = 21; // if kColorSystem

    static final int kColorPointerIndex = 22; //

    static final int kColorPointerIndex2 = 23; //

    static final int kColorRGBValue1Index = 24; // if kColorGradient

    static final int kColorWidthIndex = 25; // if kColorTexture

    static final int kColorRGBValue2Index = 26; // if kColorGradient

    static final int kColorHeightIndex = 27; // if kColorTexture

    static final int kColorIsCyclicIndex = 28; // if kColorGradient (kColorNonCyclic or kColorCyclic)

    static final int kColorx1Index = 29;

    static final int kColortxIndex = 30;

    static final int kColory1Index = 31;

    static final int kColortyIndex = 32;

    static final int kColorx2Index = 33;

    static final int kColorsxIndex = 34;

    static final int kColory2Index = 35;

    static final int kColorsyIndex = 36;

    // composite info

    static final int kCompositeRuleIndex = 37; // kCGCompositeClear or ... or kCGCompositeXor

    static final int kCompositeValueIndex = 38;

    // stroke info

    static final int kStrokeJoinIndex = 39; // see BasicStroke.java

    static final int kStrokeCapIndex = 40; // see BasicStroke.java

    static final int kStrokeWidthIndex = 41;

    static final int kStrokeDashPhaseIndex = 42;

    static final int kStrokeLimitIndex = 43;

    // hints info

    static final int kHintsAntialiasIndex = 44;

    static final int kHintsTextAntialiasIndex = 45;

    static final int kHintsFractionalMetricsIndex = 46;

    static final int kHintsRenderingIndex = 47;

    static final int kHintsInterpolationIndex = 48;

    // live resizing info

    static final int kCanDrawDuringLiveResizeIndex = 49;

    static final int kSizeOfParameters = kCanDrawDuringLiveResizeIndex + 1;

    // for objectParameters

    static final int kClipCoordinatesIndex = 0;

    static final int kClipTypesIndex = 1;

    static final int kTextureImageIndex = 2;

    static final int kStrokeDashArrayIndex = 3;

    static final int kFontIndex = 4;

    static final int kFontPaintIndex = 5;

    // possible state changes

    static final int kBoundsChangedBit = 1 << 0;

    static final int kBoundsNotChangedBit = ~kBoundsChangedBit;

    static final int kClipChangedBit = 1 << 1;

    static final int kClipNotChangedBit = ~kClipChangedBit;

    static final int kCTMChangedBit = 1 << 2;

    static final int kCTMNotChangedBit = ~kCTMChangedBit;

    static final int kColorChangedBit = 1 << 3;

    static final int kColorNotChangedBit = ~kColorChangedBit;

    static final int kCompositeChangedBit = 1 << 4;

    static final int kCompositeNotChangedBit = ~kCompositeChangedBit;

    static final int kStrokeChangedBit = 1 << 5;

    static final int kStrokeNotChangedBit = ~kStrokeChangedBit;

    static final int kHintsChangedBit = 1 << 6;

    static final int kHintsNotChangedBit = ~kHintsChangedBit;

    static final int kFontChangedBit = 1 << 7;

    static final int kFontNotChangedBit = ~kFontChangedBit;

    static final int kEverythingChangedFlag = 0xffffffff;

    // possible color states

    static final int kColorSimple = 0;

    static final int kColorSystem = 1;

    static final int kColorGradient = 2;

    static final int kColorTexture = 3;

    // possible gradient color states

    static final int kColorNonCyclic = 0;

    static final int kColorCyclic = 1;

    // possible clip states

    static final int kClipRect = 0;

    static final int kClipShape = 1;

    static int getRendererTypeForPrimitive(int primitiveType) {

        switch (primitiveType) {

            case kImage:

                return kImage;

            case kCopyArea:

                return kCopyArea;

            case kExternal:

                return kExternal;

            case kString:

            case kGlyphs:

            case kUnicodes:

                return kText;

            default:

                return kPrimitive;

        }

    }

    int fChangeFlag;

    protected ByteBuffer fGraphicsStates = null;

    IntBuffer fGraphicsStatesInt = null;

    FloatBuffer fGraphicsStatesFloat = null;

    LongBuffer fGraphicsStatesLong = null;

    protected Object[] fGraphicsStatesObject = null;

    Rectangle userBounds = new Rectangle();

    float lastUserX = 0;

    float lastUserY = 0;

    float lastUserW = 0;

    float lastUserH = 0;

    void setUserBounds(SunGraphics2D sg2d, int x, int y, int width, int height) {

        if ((lastUserX != x) || (lastUserY != y) || (lastUserW != width) || (lastUserH != height)) {

            lastUserX = x;

            lastUserY = y;

            lastUserW = width;

            lastUserH = height;

            this.fGraphicsStatesInt.put(kBoundsXIndex, x);

            this.fGraphicsStatesInt.put(kBoundsYIndex, y);

            this.fGraphicsStatesInt.put(kBoundsWidthIndex, width);

            this.fGraphicsStatesInt.put(kBoundsHeightIndex, height);

            userBounds.setBounds(x, y, width, height);

            this.fChangeFlag = (this.fChangeFlag | kBoundsChangedBit);

        } else {

            this.fChangeFlag = (this.fChangeFlag & kBoundsNotChangedBit);

        }

    }

    static ByteBuffer getBufferOfSize(int size) {

        ByteBuffer buffer = ByteBuffer.allocateDirect(size * 4);

        buffer.order(ByteOrder.nativeOrder());

        return buffer;

    }

    FloatBuffer clipCoordinatesArray = null;

    IntBuffer clipTypesArray = null;

    Shape lastClipShape = null;

    float lastClipX = 0;

    float lastClipY = 0;

    float lastClipW = 0;

    float lastClipH = 0;

    void setupClip(SunGraphics2D sg2d) {

        switch (sg2d.clipState) {

            case SunGraphics2D.CLIP_DEVICE:

            case SunGraphics2D.CLIP_RECTANGULAR: {

                Region clip = sg2d.getCompClip();

                float x = clip.getLoX();

                float y = clip.getLoY();

                float w = clip.getWidth();

                float h = clip.getHeight();

                if ((this.fGraphicsStatesInt.get(kClipStateIndex) != kClipRect) ||

                        (x != lastClipX) ||

                            (y != lastClipY) ||

                                (w != lastClipW) ||

                                    (h != lastClipH)) {

                    this.fGraphicsStatesFloat.put(kClipXIndex, x);

                    this.fGraphicsStatesFloat.put(kClipYIndex, y);

                    this.fGraphicsStatesFloat.put(kClipWidthIndex, w);

                    this.fGraphicsStatesFloat.put(kClipHeightIndex, h);

                    lastClipX = x;

                    lastClipY = y;

                    lastClipW = w;

                    lastClipH = h;

                    this.fChangeFlag = (this.fChangeFlag | kClipChangedBit);

                } else {

                    this.fChangeFlag = (this.fChangeFlag & kClipNotChangedBit);

                }

                this.fGraphicsStatesInt.put(kClipStateIndex, kClipRect);

                break;

            }

            case SunGraphics2D.CLIP_SHAPE: {

                // if (lastClipShape != sg2d.usrClip) shapes are mutable!, and doing "equals" traverses all

                // the coordinates, so we might as well do all of it anyhow

                lastClipShape = sg2d.usrClip;

                GeneralPath gp = null;

                if (sg2d.usrClip instanceof GeneralPath) {

                    gp = (GeneralPath) sg2d.usrClip;

                } else {

                    gp = new GeneralPath(sg2d.usrClip);

                }

                int shapeLength = getPathLength(gp);

                if ((clipCoordinatesArray == null) || (clipCoordinatesArray.capacity() < (shapeLength * 6))) {

                    clipCoordinatesArray = getBufferOfSize(shapeLength * 6).asFloatBuffer(); // segment can have a

                                                                                             // max of 6 coordinates

                }

                if ((clipTypesArray == null) || (clipTypesArray.capacity() < shapeLength)) {

                    clipTypesArray = getBufferOfSize(shapeLength).asIntBuffer();

                }

                int windingRule = getPathCoordinates(gp, clipCoordinatesArray, clipTypesArray);

                this.fGraphicsStatesInt.put(kClipNumTypesIndex, clipTypesArray.position());

                this.fGraphicsStatesInt.put(kClipNumCoordsIndex, clipCoordinatesArray.position());

                this.fGraphicsStatesInt.put(kClipWindingRuleIndex, windingRule);

                this.fGraphicsStatesObject[kClipTypesIndex] = clipTypesArray;

                this.fGraphicsStatesObject[kClipCoordinatesIndex] = clipCoordinatesArray;

                this.fChangeFlag = (this.fChangeFlag | kClipChangedBit);

                this.fGraphicsStatesInt.put(kClipStateIndex, kClipShape);

                break;

            }

        }

    }

    final double[] lastCTM = new double[6];

    float lastCTMa = 0;

    float lastCTMb = 0;

    float lastCTMc = 0;

    float lastCTMd = 0;

    float lastCTMtx = 0;

    float lastCTMty = 0;

    void setupTransform(SunGraphics2D sg2d) {

        sg2d.transform.getMatrix(lastCTM);

        float a = (float) lastCTM[0];

        float b = (float) lastCTM[1];

        float c = (float) lastCTM[2];

        float d = (float) lastCTM[3];

        float tx = (float) lastCTM[4];

        float ty = (float) lastCTM[5];

        if (tx != lastCTMtx ||

                ty != lastCTMty ||

                    a != lastCTMa ||

                        b != lastCTMb ||

                            c != lastCTMc ||

                                d != lastCTMd) {

            this.fGraphicsStatesFloat.put(kCTMaIndex, a);

            this.fGraphicsStatesFloat.put(kCTMbIndex, b);

            this.fGraphicsStatesFloat.put(kCTMcIndex, c);

            this.fGraphicsStatesFloat.put(kCTMdIndex, d);

            this.fGraphicsStatesFloat.put(kCTMtxIndex, tx);

            this.fGraphicsStatesFloat.put(kCTMtyIndex, ty);

            lastCTMa = a;

            lastCTMb = b;

            lastCTMc = c;

            lastCTMd = d;

            lastCTMtx = tx;

            lastCTMty = ty;

            this.fChangeFlag = (this.fChangeFlag | kCTMChangedBit);

        } else {

            this.fChangeFlag = (this.fChangeFlag & kCTMNotChangedBit);

        }

    }

    static AffineTransform sIdentityMatrix = new AffineTransform();

    Paint lastPaint = null;

    long lastPaintPtr = 0;

    int lastPaintRGB = 0;

    int lastPaintIndex = 0;

    BufferedImage texturePaintImage = null;

    void setupPaint(SunGraphics2D sg2d, int x, int y, int w, int h) {

        if (sg2d.paint instanceof SystemColor) {