/*

 * 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.  Sun designates this

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

 * by Sun 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 Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,

 * CA 95054 USA or visit www.sun.com if you need additional information or

 * have any questions.

 */

package sun.print;

import java.awt.Color;

import java.awt.Font;

import java.awt.Graphics;

import java.awt.Graphics2D;

import java.awt.Image;

import java.awt.Paint;

import java.awt.Shape;

import java.awt.Transparency;

import java.awt.font.FontRenderContext;

import java.awt.font.TextLayout;

import java.awt.geom.AffineTransform;

import java.awt.geom.Area;

import java.awt.geom.PathIterator;

import java.awt.geom.Point2D;

import java.awt.geom.Rectangle2D;

import java.awt.geom.Line2D;

import java.awt.image.BufferedImage;

import sun.awt.image.ByteComponentRaster;

import java.awt.print.PageFormat;

import java.awt.print.Printable;

import java.awt.print.PrinterException;

import java.awt.print.PrinterJob;

/**

 * This class converts paths into PostScript

 * by breaking all graphics into fills and

 * clips of paths.

 */

class PSPathGraphics extends PathGraphics {

    /**

     * For a drawing application the initial user space

     * resolution is 72dpi.

     */

    private static final int DEFAULT_USER_RES = 72;

    PSPathGraphics(Graphics2D graphics, PrinterJob printerJob,

                   Printable painter, PageFormat pageFormat, int pageIndex,

                   boolean canRedraw) {

        super(graphics, printerJob, painter, pageFormat, pageIndex, canRedraw);

    }

    /**

     * Creates a new <code>Graphics</code> object that is

     * a copy of this <code>Graphics</code> object.

     * @return     a new graphics context that is a copy of

     *                       this graphics context.

     * @since      JDK1.0

     */

    public Graphics create() {

        return new PSPathGraphics((Graphics2D) getDelegate().create(),

                                  getPrinterJob(),

                                  getPrintable(),

                                  getPageFormat(),

                                  getPageIndex(),

                                  canDoRedraws());

    }

    /**

     * Override the inherited implementation of fill

     * so that we can generate PostScript in user space

     * rather than device space.

     */

    public void fill(Shape s, Color color) {

        deviceFill(s.getPathIterator(new AffineTransform()), color);

    }

    /**

     * Draws the text given by the specified string, using this

     * graphics context's current font and color. The baseline of the

     * first character is at position (<i>x</i>,&nbsp;<i>y</i>) in this

     * graphics context's coordinate system.

     * @param       str      the string to be drawn.

     * @param       x        the <i>x</i> coordinate.

     * @param       y        the <i>y</i> coordinate.

     * @see         java.awt.Graphics#drawBytes

     * @see         java.awt.Graphics#drawChars

     * @since       JDK1.0

     */

    public void drawString(String str, int x, int y) {

        drawString(str, (float) x, (float) y);

    }

    /**

     * Renders the text specified by the specified <code>String</code>,

     * using the current <code>Font</code> and <code>Paint</code> attributes

     * in the <code>Graphics2D</code> context.

     * The baseline of the first character is at position

     * (<i>x</i>,&nbsp;<i>y</i>) in the User Space.

     * The rendering attributes applied include the <code>Clip</code>,

     * <code>Transform</code>, <code>Paint</code>, <code>Font</code> and

     * <code>Composite</code> attributes. For characters in script systems

     * such as Hebrew and Arabic, the glyphs can be rendered from right to

     * left, in which case the coordinate supplied is the location of the

     * leftmost character on the baseline.

     * @param s the <code>String</code> to be rendered

     * @param x,&nbsp;y the coordinates where the <code>String</code>

     * should be rendered

     * @see #setPaint

     * @see java.awt.Graphics#setColor

     * @see java.awt.Graphics#setFont

     * @see #setTransform

     * @see #setComposite

     * @see #setClip

     */

     public void drawString(String str, float x, float y) {

         drawString(str, x, y, getFont(), getFontRenderContext(), 0f);

     }

    protected boolean canDrawStringToWidth() {

        return true;

    }

    protected int platformFontCount(Font font, String str) {

        PSPrinterJob psPrinterJob = (PSPrinterJob) getPrinterJob();

        return psPrinterJob.platformFontCount(font,  str);

    }

    protected void drawString(String str, float x, float y,

                              Font font, FontRenderContext frc, float w) {

        if (str.length() == 0) {

            return;

        }

        /* If the Font has layout attributes we need to delegate to TextLayout.

         * TextLayout renders text as GlyphVectors. We try to print those

         * using printer fonts - ie using Postscript text operators so

         * we may be reinvoked. In that case the "!printingGlyphVector" test

         * prevents us recursing and instead sends us into the body of the

         * method where we can safely ignore layout attributes as those

         * are already handled by TextLayout.

         */

        if (font.hasLayoutAttributes() && !printingGlyphVector) {

            TextLayout layout = new TextLayout(str, font, frc);

            layout.draw(this, x, y);

            return;

        }

        Font oldFont = getFont();

        if (!oldFont.equals(font)) {

            setFont(font);

        } else {

            oldFont = null;

        }

        boolean drawnWithPS = false;

        float translateX = 0f, translateY = 0f;

        boolean fontisTransformed = getFont().isTransformed();

        if (fontisTransformed) {

            AffineTransform fontTx = getFont().getTransform();

            int transformType = fontTx.getType();

            /* TYPE_TRANSLATION is a flag bit but we can do "==" here

             * because we want to detect when its just that bit set and

             *

             */

            if (transformType == AffineTransform.TYPE_TRANSLATION) {

                translateX = (float)(fontTx.getTranslateX());

                translateY = (float)(fontTx.getTranslateY());

                if (Math.abs(translateX) < 0.00001) translateX = 0f;

                if (Math.abs(translateY) < 0.00001) translateY = 0f;

                fontisTransformed = false;

            }

        }

        boolean directToPS = !fontisTransformed;

        if (!PSPrinterJob.shapeTextProp && directToPS) {

            PSPrinterJob psPrinterJob = (PSPrinterJob) getPrinterJob();

            if (psPrinterJob.setFont(getFont())) {

                /* Set the text color.

                 * We should not be in this shape printing path

                 * if the application is drawing with non-solid

                 * colors. We should be in the raster path. Because

                 * we are here in the shape path, the cast of the

                 * paint to a Color should be fine.

                 */

                try {

                    psPrinterJob.setColor((Color)getPaint());

                } catch (ClassCastException e) {

                    if (oldFont != null) {

                        setFont(oldFont);

                    }

                    throw new IllegalArgumentException(

                                                "Expected a Color instance");

                }

                psPrinterJob.setTransform(getTransform());

                psPrinterJob.setClip(getClip());

                drawnWithPS = psPrinterJob.textOut(this, str,

                                                   x+translateX, y+translateY,

                                                   font, frc, w);

            }

        }

        /* The text could not be converted directly to PS text

         * calls so decompose the text into a shape.

         */

        if (drawnWithPS == false) {

            if (oldFont != null) {

                setFont(oldFont);

                oldFont = null;

            }

            super.drawString(str, x, y, font, frc, w);

        }

        if (oldFont != null) {

            setFont(oldFont);

        }

    }

    /**

     * The various <code>drawImage()</code> methods for

     * <code>WPathGraphics</code> are all decomposed

     * into an invocation of <code>drawImageToPlatform</code>.

     * The portion of the passed in image defined by

     * <code>srcX, srcY, srcWidth, and srcHeight</code>

     * is transformed by the supplied AffineTransform and

     * drawn using PS to the printer context.

     *

     * @param   img     The image to be drawn.

     *                  This method does nothing if <code>img</code> is null.

     * @param   xform   Used to tranform the image before drawing.

     *                  This can be null.

     * @param   bgcolor This color is drawn where the image has transparent

     *                  pixels. If this parameter is null then the

     *                  pixels already in the destination should show

     *                  through.

     * @param   srcX    With srcY this defines the upper-left corner

     *                  of the portion of the image to be drawn.

     *

     * @param   srcY    With srcX this defines the upper-left corner

     *                  of the portion of the image to be drawn.

     * @param   srcWidth    The width of the portion of the image to

     *                      be drawn.

     * @param   srcHeight   The height of the portion of the image to

     *                      be drawn.

     * @param   handlingTransparency if being recursively called to

     *                    print opaque region of transparent image

     */

    protected boolean drawImageToPlatform(Image image, AffineTransform xform,

                                          Color bgcolor,

                                          int srcX, int srcY,

                                          int srcWidth, int srcHeight,

                                          boolean handlingTransparency) {

        BufferedImage img = getBufferedImage(image);

        if (img == null) {

            return true;

        }

        PSPrinterJob psPrinterJob = (PSPrinterJob) getPrinterJob();

        /* The full transform to be applied to the image is the

         * caller's transform concatenated on to the transform

         * from user space to device space. If the caller didn't

         * supply a transform then we just act as if they passed

         * in the identify transform.

         */

        AffineTransform fullTransform = getTransform();

        if (xform == null) {

            xform = new AffineTransform();

        }

        fullTransform.concatenate(xform);

        /* Split the full transform into a pair of

         * transforms. The first transform holds effects

         * such as rotation and shearing. The second transform

         * is setup to hold only the scaling effects.

         * These transforms are created such that a point,

         * p, in user space, when transformed by 'fullTransform'

         * lands in the same place as when it is transformed

         * by 'rotTransform' and then 'scaleTransform'.

         *

         * The entire image transformation is not in Java in order

         * to minimize the amount of memory needed in the VM. By

         * dividing the transform in two, we rotate and shear

         * the source image in its own space and only go to

         * the, usually, larger, device space when we ask

         * PostScript to perform the final scaling.

         */

        double[] fullMatrix = new double[6];

        fullTransform.getMatrix(fullMatrix);

        /* Calculate the amount of scaling in the x

         * and y directions. This scaling is computed by

         * transforming a unit vector along each axis

         * and computing the resulting magnitude.

         * The computed values 'scaleX' and 'scaleY'

         * represent the amount of scaling PS will be asked

         * to perform.

         * Clamp this to the device scale for better quality printing.

         */

        Point2D.Float unitVectorX = new Point2D.Float(1, 0);

        Point2D.Float unitVectorY = new Point2D.Float(0, 1);

        fullTransform.deltaTransform(unitVectorX, unitVectorX);

        fullTransform.deltaTransform(unitVectorY, unitVectorY);

        Point2D.Float origin = new Point2D.Float(0, 0);

        double scaleX = unitVectorX.distance(origin);

        double scaleY = unitVectorY.distance(origin);

        double devResX = psPrinterJob.getXRes();

        double devResY = psPrinterJob.getYRes();

        double devScaleX = devResX / DEFAULT_USER_RES;

        double devScaleY = devResY / DEFAULT_USER_RES;

        /* check if rotated or sheared */

        int transformType = fullTransform.getType();

        boolean clampScale = ((transformType &

                               (AffineTransform.TYPE_GENERAL_ROTATION |

                                AffineTransform.TYPE_GENERAL_TRANSFORM)) != 0);

        if (clampScale) {

            if (scaleX > devScaleX) scaleX = devScaleX;

            if (scaleY > devScaleY) scaleY = devScaleY;

        }

        /* We do not need to draw anything if either scaling

         * factor is zero.

         */

        if (scaleX != 0 && scaleY != 0) {

            /* Here's the transformation we will do with Java2D,

            */

            AffineTransform rotTransform = new AffineTransform(

                                        fullMatrix[0] / scaleX,  //m00

                                        fullMatrix[1] / scaleY,  //m10

                                        fullMatrix[2] / scaleX,  //m01

                                        fullMatrix[3] / scaleY,  //m11

                                        fullMatrix[4] / scaleX,  //m02

                                        fullMatrix[5] / scaleY); //m12

            /* The scale transform is not used directly: we instead

             * directly multiply by scaleX and scaleY.

             *

             * Conceptually here is what the scaleTransform is:

             *

             * AffineTransform scaleTransform = new AffineTransform(

             *                      scaleX,                     //m00

             *                      0,                          //m10

             *                      0,                          //m01

             *                      scaleY,                     //m11

             *                      0,                          //m02

             *                      0);                         //m12

             */

            /* Convert the image source's rectangle into the rotated

             * and sheared space. Once there, we calculate a rectangle

             * that encloses the resulting shape. It is this rectangle

             * which defines the size of the BufferedImage we need to

             * create to hold the transformed image.

             */

            Rectangle2D.Float srcRect = new Rectangle2D.Float(srcX, srcY,

                                                              srcWidth,

                                                              srcHeight);

            Shape rotShape = rotTransform.createTransformedShape(srcRect);

            Rectangle2D rotBounds = rotShape.getBounds2D();

            /* add a fudge factor as some fp precision problems have

             * been observed which caused pixels to be rounded down and

             * out of the image.

             */

            rotBounds.setRect(rotBounds.getX(), rotBounds.getY(),

                              rotBounds.getWidth()+0.001,

                              rotBounds.getHeight()+0.001);

            int boundsWidth = (int) rotBounds.getWidth();

            int boundsHeight = (int) rotBounds.getHeight();

            if (boundsWidth > 0 && boundsHeight > 0) {

                /* If the image has transparent or semi-transparent

                 * pixels then we'll have the application re-render

                 * the portion of the page covered by the image.

                 * This will be done in a later call to print using the

                 * saved graphics state.

                 * However several special cases can be handled otherwise:

                 * - bitmask transparency with a solid background colour

                 * - images which have transparency color models but no

                 * transparent pixels

                 * - images with bitmask transparency and an IndexColorModel

                 * (the common transparent GIF case) can be handled by

                 * rendering just the opaque pixels.

                 */

                boolean drawOpaque = true;

                if (!handlingTransparency && hasTransparentPixels(img)) {

                    drawOpaque = false;

                    if (isBitmaskTransparency(img)) {

                        if (bgcolor == null) {

                            if (drawBitmaskImage(img, xform, bgcolor,

                                                srcX, srcY,

                                                 srcWidth, srcHeight)) {

                                // image drawn, just return.

                                return true;

                            }

                        } else if (bgcolor.getTransparency()

                                   == Transparency.OPAQUE) {

                            drawOpaque = true;

                        }

                    }

                    if (!canDoRedraws()) {

                        drawOpaque = true;

                    }

                } else {

                    // if there's no transparent pixels there's no need

                    // for a background colour. This can avoid edge artifacts

                    // in rotation cases.

                    bgcolor = null;

                }

                // if src region extends beyond the image, the "opaque" path

                // may blit b/g colour (including white) where it shoudn't.

                if ((srcX+srcWidth > img.getWidth(null) ||

                     srcY+srcHeight > img.getHeight(null))

                    && canDoRedraws()) {

                    drawOpaque = false;

                }

                if (drawOpaque == false) {

                    fullTransform.getMatrix(fullMatrix);

                    AffineTransform tx =

                        new AffineTransform(

                                            fullMatrix[0] / devScaleX,  //m00

                                            fullMatrix[1] / devScaleY,  //m10

                                            fullMatrix[2] / devScaleX,  //m01

                                            fullMatrix[3] / devScaleY,  //m11

                                            fullMatrix[4] / devScaleX,  //m02

                                            fullMatrix[5] / devScaleY); //m12

                    Rectangle2D.Float rect =

                        new Rectangle2D.Float(srcX, srcY, srcWidth, srcHeight);

                    Shape shape = fullTransform.createTransformedShape(rect);

                    // Region isn't user space because its potentially

                    // been rotated for landscape.

                    Rectangle2D region = shape.getBounds2D();

                    region.setRect(region.getX(), region.getY(),

                                   region.getWidth()+0.001,

                                   region.getHeight()+0.001);

                    // Try to limit the amount of memory used to 8Mb, so

                    // if at device resolution this exceeds a certain

                    // image size then scale down the region to fit in

                    // that memory, but never to less than 72 dpi.

                    int w = (int)region.getWidth();

                    int h = (int)region.getHeight();

                    int nbytes = w * h * 3;

                    int maxBytes = 8 * 1024 * 1024;

                    double origDpi = (devResX < devResY) ? devResX : devResY;

                    int dpi = (int)origDpi;

                    double scaleFactor = 1;

                    double maxSFX = w/(double)boundsWidth;

                    double maxSFY = h/(double)boundsHeight;

                    double maxSF = (maxSFX > maxSFY) ? maxSFY : maxSFX;

                    int minDpi = (int)(dpi/maxSF);

                    if (minDpi < DEFAULT_USER_RES) minDpi = DEFAULT_USER_RES;

                    while (nbytes > maxBytes && dpi > minDpi) {

                        scaleFactor *= 2;

                        dpi /= 2;

                        nbytes /= 4;

                    }

                    if (dpi < minDpi) {

                        scaleFactor = (origDpi / minDpi);

                    }

                    region.setRect(region.getX()/scaleFactor,

                                   region.getY()/scaleFactor,

                                   region.getWidth()/scaleFactor,

                                   region.getHeight()/scaleFactor);

                    /*

                     * We need to have the clip as part of the saved state,

                     * either directly, or all the components that are

                     * needed to reconstitute it (image source area,

                     * image transform and current graphics transform).

                     * The clip is described in user space, so we need to

                     * save the current graphics transform anyway so just

                     * save these two.

                     */

                    psPrinterJob.saveState(getTransform(), getClip(),

                                           region, scaleFactor, scaleFactor);

                    return true;

                /* The image can be rendered directly by PS so we