/*

 * 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.awt.windows;

import java.awt.BasicStroke;

import java.awt.Color;

import java.awt.Font;

import java.awt.Graphics;

import java.awt.Graphics2D;

import java.awt.Image;

import java.awt.Shape;

import java.awt.Stroke;

import java.awt.Transparency;

import java.awt.font.FontRenderContext;

import java.awt.font.GlyphVector;

import java.awt.font.TextLayout;

import java.awt.geom.AffineTransform;

import java.awt.geom.NoninvertibleTransformException;

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 java.awt.image.ColorModel;

import java.awt.image.DataBuffer;

import java.awt.image.IndexColorModel;

import java.awt.image.WritableRaster;

import java.awt.image.ComponentSampleModel;

import java.awt.image.MultiPixelPackedSampleModel;

import java.awt.image.SampleModel;

import sun.awt.image.ByteComponentRaster;

import sun.awt.image.BytePackedRaster;

import java.awt.print.PageFormat;

import java.awt.print.Printable;

import java.awt.print.PrinterException;

import java.awt.print.PrinterJob;

import java.util.Arrays;

import sun.font.CharToGlyphMapper;

import sun.font.CompositeFont;

import sun.font.Font2D;

import sun.font.FontUtilities;

import sun.font.PhysicalFont;

import sun.font.TrueTypeFont;

import sun.print.PathGraphics;

import sun.print.ProxyGraphics2D;

class WPathGraphics extends PathGraphics {

    /**

     * For a drawing application the initial user space

     * resolution is 72dpi.

     */

    private static final int DEFAULT_USER_RES = 72;

    private static final float MIN_DEVICE_LINEWIDTH = 1.2f;

    private static final float MAX_THINLINE_INCHES = 0.014f;

    /* Note that preferGDITextLayout implies useGDITextLayout.

     * "prefer" is used to override cases where would otherwise

     * choose not to use it. Note that non-layout factors may

     * still mean that GDI cannot be used.

     */

    private static boolean useGDITextLayout = true;

    private static boolean preferGDITextLayout = false;

    static {

        String textLayoutStr =

            (String)java.security.AccessController.doPrivileged(

                   new sun.security.action.GetPropertyAction(

                         "sun.java2d.print.enableGDITextLayout"));

        if (textLayoutStr != null) {

            useGDITextLayout = Boolean.getBoolean(textLayoutStr);

            if (!useGDITextLayout) {

                if (textLayoutStr.equalsIgnoreCase("prefer")) {

                    useGDITextLayout = true;

                    preferGDITextLayout = true;

                }

            }

        }

    }

    WPathGraphics(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

     */

    @Override

    public Graphics create() {

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

                                 getPrinterJob(),

                                 getPrintable(),

                                 getPageFormat(),

                                 getPageIndex(),

                                 canDoRedraws());

    }

    /**

     * Strokes the outline of a Shape using the settings of the current

     * graphics state.  The rendering attributes applied include the

     * clip, transform, paint or color, composite and stroke attributes.

     * @param s The shape to be drawn.

     * @see #setStroke

     * @see #setPaint

     * @see java.awt.Graphics#setColor

     * @see #transform

     * @see #setTransform

     * @see #clip

     * @see #setClip

     * @see #setComposite

     */

    @Override

    public void draw(Shape s) {

        Stroke stroke = getStroke();

        /* If the line being drawn is thinner than can be

         * rendered, then change the line width, stroke

         * the shape, and then set the line width back.

         * We can only do this for BasicStroke's.

         */

        if (stroke instanceof BasicStroke) {

            BasicStroke lineStroke;

            BasicStroke minLineStroke = null;

            float deviceLineWidth;

            float lineWidth;

            AffineTransform deviceTransform;

            Point2D.Float penSize;

            /* Get the requested line width in user space.

             */

            lineStroke = (BasicStroke) stroke;

            lineWidth = lineStroke.getLineWidth();

            penSize = new Point2D.Float(lineWidth, lineWidth);

            /* Compute the line width in device coordinates.

             * Work on a point in case there is asymetric scaling

             * between user and device space.

             * Take the absolute value in case there is negative

             * scaling in effect.

             */

            deviceTransform = getTransform();

            deviceTransform.deltaTransform(penSize, penSize);

            deviceLineWidth = Math.min(Math.abs(penSize.x),

                                       Math.abs(penSize.y));

            /* If the requested line is too thin then map our

             * minimum line width back to user space and set

             * a new BasicStroke.

             */

            if (deviceLineWidth < MIN_DEVICE_LINEWIDTH) {

                Point2D.Float minPenSize = new Point2D.Float(

                                                MIN_DEVICE_LINEWIDTH,

                                                MIN_DEVICE_LINEWIDTH);

                try {

                    AffineTransform inverse;

                    float minLineWidth;

                    /* Convert the minimum line width from device

                     * space to user space.

                     */

                    inverse = deviceTransform.createInverse();

                    inverse.deltaTransform(minPenSize, minPenSize);

                    minLineWidth = Math.max(Math.abs(minPenSize.x),

                                            Math.abs(minPenSize.y));

                    /* Use all of the parameters from the current

                     * stroke but change the line width to our

                     * calculated minimum.

                     */

                    minLineStroke = new BasicStroke(minLineWidth,

                                                    lineStroke.getEndCap(),

                                                    lineStroke.getLineJoin(),

                                                    lineStroke.getMiterLimit(),

                                                    lineStroke.getDashArray(),

                                                    lineStroke.getDashPhase());

                    setStroke(minLineStroke);

                } catch (NoninvertibleTransformException e) {

                    /* If we can't invert the matrix there is something

                     * very wrong so don't worry about the minor matter

                     * of a minimum line width.

                     */

                }

            }

            super.draw(s);

            /* If we changed the stroke, put back the old

             * stroke in order to maintain a minimum line

             * width.

             */

            if (minLineStroke != null) {

                setStroke(lineStroke);

            }

        /* The stroke in effect was not a BasicStroke so we

         * will not try to enforce a minimum line width.

         */

        } else {

            super.draw(s);

        }

    }

    /**

     * 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

     */

    @Override

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

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

    }

    @Override

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

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

     }

    /* A return value of 0 would mean font not available to GDI, or the

     * it can't be used for this string.

     * A return of 1 means it is suitable, including for composites.

     * We check that the transform in effect is doable with GDI, and that

     * this is a composite font AWT can handle, or a physical font GDI

     * can handle directly. Its possible that some strings may ultimately

     * fail the more stringent tests in drawString but this is rare and

     * also that method will always succeed, as if the font isn't available

     * it will use outlines via a superclass call. Also it is only called for

     * the default render context (as canDrawStringToWidth() will return

     * false. That is why it ignores the frc and width arguments.

     */

    @Override

    protected int platformFontCount(Font font, String str) {

        AffineTransform deviceTransform = getTransform();

        AffineTransform fontTransform = new AffineTransform(deviceTransform);

        fontTransform.concatenate(getFont().getTransform());

        int transformType = fontTransform.getType();

        /* Test if GDI can handle the transform */

        boolean directToGDI = ((transformType !=

                               AffineTransform.TYPE_GENERAL_TRANSFORM)

                               && ((transformType & AffineTransform.TYPE_FLIP)

                                   == 0));

        if (!directToGDI) {

            return 0;

        }

        /* Since all windows fonts are available, and the JRE fonts

         * are also registered. Only the Font.createFont() case is presently

         * unknown to GDI. Those can be registered too, although that

         * code does not exist yet, it can be added too, so we should not

         * fail that case. Just do a quick check whether its a TrueTypeFont

         * - ie not a Type1 font etc, and let drawString() resolve the rest.

         */

        Font2D font2D = FontUtilities.getFont2D(font);

        if (font2D instanceof CompositeFont ||

            font2D instanceof TrueTypeFont) {

            return 1;

        } else {

            return 0;

        }

    }

    private static boolean isXP() {

        String osVersion = System.getProperty("os.version");

        if (osVersion != null) {

            Float version = Float.valueOf(osVersion);

            return (version.floatValue() >= 5.1f);

        } else {

            return false;

        }

    }

    /* In case GDI doesn't handle shaping or BIDI consistently with

     * 2D's TextLayout, we can detect these cases and redelegate up to

     * be drawn via TextLayout, which in is rendered as runs of

     * GlyphVectors, to which we can assign positions for each glyph.

     */

    private boolean strNeedsTextLayout(String str, Font font) {

        char[] chars = str.toCharArray();

        boolean isComplex = FontUtilities.isComplexText(chars, 0, chars.length);

        if (!isComplex) {

            return false;

        } else if (!useGDITextLayout) {

            return true;

        } else {

            if (preferGDITextLayout ||

                (isXP() && FontUtilities.textLayoutIsCompatible(font))) {

                return false;

            } else {

                return true;

            }

        }

    }

    private int getAngle(Point2D.Double pt) {

        /* Get the rotation in 1/10'ths degree (as needed by Windows)

         * so that GDI can draw the text rotated.

         * This calculation is only valid for a uniform scale, no shearing.

         */

        double angle = Math.toDegrees(Math.atan2(pt.y, pt.x));

        if (angle < 0.0) {

            angle+= 360.0;

        }

        /* Windows specifies the rotation anti-clockwise from the x-axis

         * of the device, 2D specifies +ve rotation towards the y-axis

         * Since the 2D y-axis runs from top-to-bottom, windows angle of

         * rotation here is opposite than 2D's, so the rotation needed

         * needs to be recalculated in the opposite direction.

         */

        if (angle != 0.0) {

            angle = 360.0 - angle;

        }

        return (int)Math.round(angle * 10.0);

    }

    private float getAwScale(double scaleFactorX, double scaleFactorY) {

        float awScale = (float)(scaleFactorX/scaleFactorY);

        /* don't let rounding errors be interpreted as non-uniform scale */

        if (awScale > 0.999f && awScale < 1.001f) {

            awScale = 1.0f;

        }

        return awScale;

    }

    /**

     * 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

     */

    @Override

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

                           Font font, FontRenderContext frc, float targetW) {

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

            return;

        }

        if (WPrinterJob.shapeTextProp) {

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

            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.

         * Similarly if layout is needed based on the text, then we

         * delegate to TextLayout if possible, or failing that we delegate

         * upwards to filled shapes.

         */

        boolean layoutNeeded = strNeedsTextLayout(str, font);

        if ((font.hasLayoutAttributes() || layoutNeeded)

            && !printingGlyphVector) {

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

            layout.draw(this, x, y);

            return;

        } else if (layoutNeeded) {

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

            return;

        }

        AffineTransform deviceTransform = getTransform();

        AffineTransform fontTransform = new AffineTransform(deviceTransform);

        fontTransform.concatenate(font.getTransform());

        int transformType = fontTransform.getType();

        /* Use GDI for the text if the graphics transform is something

         * for which we can obtain a suitable GDI font.

         * A flip or shearing transform on the graphics or a transform

         * on the font force us to decompose the text into a shape.

         */

        boolean directToGDI = ((transformType !=

                               AffineTransform.TYPE_GENERAL_TRANSFORM)

                               && ((transformType & AffineTransform.TYPE_FLIP)

                                   == 0));

        WPrinterJob wPrinterJob = (WPrinterJob) getPrinterJob();

        try {

            wPrinterJob.setTextColor((Color)getPaint());

        } catch (ClassCastException e) { // peek should detect such paints.

            directToGDI = false;

        }

        if (!directToGDI) {

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

            return;

        }

        /* Now we have checked everything is OK to go through GDI as text

         * with the exception of testing GDI can find and use the font. That

         * is handled in the textOut() call.

         */

        /* Compute the starting position of the string in

         * device space.

         */

        Point2D.Float userpos = new Point2D.Float(x, y);

        Point2D.Float devpos = new Point2D.Float();

        /* Already have the translate from the deviceTransform,

         * but the font may have a translation component too.

         */

        if (font.isTransformed()) {

            AffineTransform fontTx = font.getTransform();

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

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

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

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

            userpos.x += translateX; userpos.y += translateY;

        }

        deviceTransform.transform(userpos, devpos);

        if (getClip() != null) {

            deviceClip(getClip().getPathIterator(deviceTransform));

        }

        /* Get the font size in device coordinates.

         * The size needed is the font height scaled to device space.

         * Although we have already tested that there is no shear,

         * there may be a non-uniform scale, so the width of the font

         * does not scale equally with the height. That is handled

         * by specifying an 'average width' scale to GDI.

         */

        float fontSize = font.getSize2D();

        Point2D.Double pty = new Point2D.Double(0.0, 1.0);

        fontTransform.deltaTransform(pty, pty);

        double scaleFactorY = Math.sqrt(pty.x*pty.x+pty.y*pty.y);

        float scaledFontSizeY = (float)(fontSize * scaleFactorY);

        Point2D.Double ptx = new Point2D.Double(1.0, 0.0);

        fontTransform.deltaTransform(ptx, ptx);

        double scaleFactorX = Math.sqrt(ptx.x*ptx.x+ptx.y*ptx.y);

        float scaledFontSizeX = (float)(fontSize * scaleFactorX);

        float awScale = getAwScale(scaleFactorX, scaleFactorY);

        int iangle = getAngle(ptx);

        Font2D font2D = FontUtilities.getFont2D(font);

        if (font2D instanceof TrueTypeFont) {

            textOut(str, font, (TrueTypeFont)font2D, frc,

                    scaledFontSizeY, iangle, awScale,

                    deviceTransform, scaleFactorX,

                    x, y, devpos.x, devpos.y, targetW);

        } else if (font2D instanceof CompositeFont) {

            /* Composite fonts are made up of multiple fonts and each

             * substring that uses a particular component font needs to

             * be separately sent to GDI.

             * This works for standard composite fonts, alternate ones,

             * Fonts that are a physical font backed by a standard composite,

             * and with fallback fonts.

             */

            CompositeFont compFont = (CompositeFont)font2D;

            float userx = x, usery = y;