/*

 * Copyright 1998-2006 Sun Microsystems, Inc.  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.  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.util.Map;

import java.awt.Color;

import java.awt.Composite;

import java.awt.Graphics;

import java.awt.Graphics2D;

import java.awt.Font;

import java.awt.FontMetrics;

import java.awt.font.FontRenderContext;

import java.awt.Graphics;

import java.awt.GraphicsConfiguration;

import java.awt.Image;

import java.awt.Paint;

import java.awt.Rectangle;

import java.awt.Shape;

import java.awt.Stroke;

import java.awt.RenderingHints;

import java.awt.RenderingHints.Key;

import java.awt.font.GlyphVector;

import java.awt.geom.AffineTransform;

import java.awt.geom.Rectangle2D;

import java.awt.geom.NoninvertibleTransformException;

import java.awt.image.BufferedImage;

import java.awt.image.BufferedImageOp;

import java.awt.image.ImageObserver;

import java.awt.image.RenderedImage;

import java.awt.image.renderable.RenderContext;

import java.awt.image.renderable.RenderableImage;

import java.awt.print.PrinterGraphics;

import java.awt.print.PrinterJob;

import java.text.AttributedCharacterIterator;

public class ProxyGraphics2D extends Graphics2D implements PrinterGraphics {

    /**

     * Drawing methods will be forwarded to this object.

     */

    Graphics2D mGraphics;

    /**

     * The PrinterJob controlling the current printing.

     */

    PrinterJob mPrinterJob;

    /**

     * The new ProxyGraphics2D will forward all graphics

     * calls to 'graphics'.

     */

    public ProxyGraphics2D(Graphics2D graphics, PrinterJob printerJob) {

        mGraphics = graphics;

        mPrinterJob = printerJob;

    }

    /**

     * Return the Graphics2D object that does the drawing

     * for this instance.

     */

    public Graphics2D getDelegate() {

        return mGraphics;

    }

    /**

     * Set the Graphics2D instance which will do the

     * drawing.

     */

    public void setDelegate(Graphics2D graphics) {

        mGraphics = graphics;

    }

    public PrinterJob getPrinterJob() {

        return mPrinterJob;

    }

    /**

     * Returns the device configuration associated with this Graphics2D.

     */

    public GraphicsConfiguration getDeviceConfiguration() {

        return ((RasterPrinterJob)mPrinterJob).getPrinterGraphicsConfig();

    }

/* The Delegated Graphics Methods */

    /**

     * 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 ProxyGraphics2D((Graphics2D) mGraphics.create(),

                                   mPrinterJob);

    }

    /**

     * Translates the origin of the graphics context to the point

     * (<i>x</i>,&nbsp;<i>y</i>) in the current coordinate system.

     * Modifies this graphics context so that its new origin corresponds

     * to the point (<i>x</i>,&nbsp;<i>y</i>) in this graphics context's

     * original coordinate system.  All coordinates used in subsequent

     * rendering operations on this graphics context will be relative

     * to this new origin.

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

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

     * @since   JDK1.0

     */

    public void translate(int x, int y) {

        mGraphics.translate(x, y);

    }

    /**

     * Concatenates the current transform of this Graphics2D with a

     * translation transformation.

     * This is equivalent to calling transform(T), where T is an

     * AffineTransform represented by the following matrix:

     * <pre>

     *          [   1    0    tx  ]

     *          [   0    1    ty  ]

     *          [   0    0    1   ]

     * </pre>

     */

    public void translate(double tx, double ty) {

        mGraphics.translate(tx, ty);

    }

    /**

     * Concatenates the current transform of this Graphics2D with a

     * rotation transformation.

     * This is equivalent to calling transform(R), where R is an

     * AffineTransform represented by the following matrix:

     * <pre>

     *          [   cos(theta)    -sin(theta)    0   ]

     *          [   sin(theta)     cos(theta)    0   ]

     *          [       0              0         1   ]

     * </pre>

     * Rotating with a positive angle theta rotates points on the positive

     * x axis toward the positive y axis.

     * @param theta The angle of rotation in radians.

     */

    public void rotate(double theta) {

        mGraphics.rotate(theta);

    }

    /**

     * Concatenates the current transform of this Graphics2D with a

     * translated rotation transformation.

     * This is equivalent to the following sequence of calls:

     * <pre>

     *          translate(x, y);

     *          rotate(theta);

     *          translate(-x, -y);

     * </pre>

     * Rotating with a positive angle theta rotates points on the positive

     * x axis toward the positive y axis.

     * @param theta The angle of rotation in radians.

     * @param x The x coordinate of the origin of the rotation

     * @param y The x coordinate of the origin of the rotation

     */

    public void rotate(double theta, double x, double y) {

        mGraphics.rotate(theta, x, y);

    }

    /**

     * Concatenates the current transform of this Graphics2D with a

     * scaling transformation.

     * This is equivalent to calling transform(S), where S is an

     * AffineTransform represented by the following matrix:

     * <pre>

     *          [   sx   0    0   ]

     *          [   0    sy   0   ]

     *          [   0    0    1   ]

     * </pre>

     */

    public void scale(double sx, double sy) {

        mGraphics.scale(sx, sy);

    }

    /**

     * Concatenates the current transform of this Graphics2D with a

     * shearing transformation.

     * This is equivalent to calling transform(SH), where SH is an

     * AffineTransform represented by the following matrix:

     * <pre>

     *          [   1   shx   0   ]

     *          [  shy   1    0   ]

     *          [   0    0    1   ]

     * </pre>

     * @param shx The factor by which coordinates are shifted towards the

     * positive X axis direction according to their Y coordinate

     * @param shy The factor by which coordinates are shifted towards the

     * positive Y axis direction according to their X coordinate

     */

    public void shear(double shx, double shy) {

        mGraphics.shear(shx, shy);

    }

    /**

     * Gets this graphics context's current color.

     * @return    this graphics context's current color.

     * @see       java.awt.Color

     * @see       java.awt.Graphics#setColor

     * @since     JDK1.0

     */

    public Color getColor() {

        return mGraphics.getColor();

    }

    /**

     * Sets this graphics context's current color to the specified

     * color. All subsequent graphics operations using this graphics

     * context use this specified color.

     * @param     c   the new rendering color.

     * @see       java.awt.Color

     * @see       java.awt.Graphics#getColor

     * @since     JDK1.0

     */

    public void setColor(Color c) {

        mGraphics.setColor(c);

    }

    /**

     * Sets the paint mode of this graphics context to overwrite the

     * destination with this graphics context's current color.

     * This sets the logical pixel operation function to the paint or

     * overwrite mode.  All subsequent rendering operations will

     * overwrite the destination with the current color.

     * @since   JDK1.0

     */

    public void setPaintMode() {

        mGraphics.setPaintMode();

    }

    /**

     * Sets the paint mode of this graphics context to alternate between

     * this graphics context's current color and the new specified color.

     * This specifies that logical pixel operations are performed in the

     * XOR mode, which alternates pixels between the current color and

     * a specified XOR color.

     * <p>

     * When drawing operations are performed, pixels which are the

     * current color are changed to the specified color, and vice versa.

     * <p>

     * Pixels that are of colors other than those two colors are changed

     * in an unpredictable but reversible manner; if the same figure is

     * drawn twice, then all pixels are restored to their original values.

     * @param     c1 the XOR alternation color

     * @since     JDK1.0

     */

    public void setXORMode(Color c1) {

        mGraphics.setXORMode(c1);

    }

    /**

     * Gets the current font.

     * @return    this graphics context's current font.

     * @see       java.awt.Font

     * @see       java.awt.Graphics#setFont

     * @since     JDK1.0

     */

    public Font getFont() {

        return mGraphics.getFont();

    }

    /**

     * Sets this graphics context's font to the specified font.

     * All subsequent text operations using this graphics context

     * use this font.

     * @param  font   the font.

     * @see     java.awt.Graphics#getFont

     * @see     java.awt.Graphics#drawChars(java.lang.String, int, int)

     * @see     java.awt.Graphics#drawString(byte[], int, int, int, int)

     * @see     java.awt.Graphics#drawBytes(char[], int, int, int, int)

     * @since   JDK1.0

    */

    public void setFont(Font font) {

        mGraphics.setFont(font);

    }

    /**

     * Gets the font metrics for the specified font.

     * @return    the font metrics for the specified font.

     * @param     f the specified font

     * @see       java.awt.Graphics#getFont

     * @see       java.awt.FontMetrics

     * @see       java.awt.Graphics#getFontMetrics()

     * @since     JDK1.0

     */

    public FontMetrics getFontMetrics(Font f) {

        return mGraphics.getFontMetrics(f);

    }

    /**

    * Get the rendering context of the font

    * within this Graphics2D context.

    */

    public FontRenderContext getFontRenderContext() {

        return mGraphics.getFontRenderContext();

    }

    /**

     * Returns the bounding rectangle of the current clipping area.

     * The coordinates in the rectangle are relative to the coordinate

     * system origin of this graphics context.

     * @return      the bounding rectangle of the current clipping area.

     * @see         java.awt.Graphics#getClip

     * @see         java.awt.Graphics#clipRect

     * @see         java.awt.Graphics#setClip(int, int, int, int)

     * @see         java.awt.Graphics#setClip(Shape)

     * @since       JDK1.1

     */

    public Rectangle getClipBounds() {

        return mGraphics.getClipBounds();

    }

    /**

     * Intersects the current clip with the specified rectangle.

     * The resulting clipping area is the intersection of the current

     * clipping area and the specified rectangle.

     * This method can only be used to make the current clip smaller.

     * To set the current clip larger, use any of the setClip methods.

     * Rendering operations have no effect outside of the clipping area.

     * @param x the x coordinate of the rectangle to intersect the clip with

     * @param y the y coordinate of the rectangle to intersect the clip with

     * @param width the width of the rectangle to intersect the clip with

     * @param height the height of the rectangle to intersect the clip with

     * @see #setClip(int, int, int, int)

     * @see #setClip(Shape)

     */

    public void clipRect(int x, int y, int width, int height) {

        mGraphics.clipRect(x, y, width, height);

    }

    /**

     * Sets the current clip to the rectangle specified by the given

     * coordinates.

     * Rendering operations have no effect outside of the clipping area.

     * @param       x the <i>x</i> coordinate of the new clip rectangle.

     * @param       y the <i>y</i> coordinate of the new clip rectangle.

     * @param       width the width of the new clip rectangle.

     * @param       height the height of the new clip rectangle.

     * @see         java.awt.Graphics#clipRect

     * @see         java.awt.Graphics#setClip(Shape)

     * @since       JDK1.1

     */

    public void setClip(int x, int y, int width, int height) {

        mGraphics.setClip(x, y, width, height);

    }

    /**

     * Gets the current clipping area.

     * @return      a <code>Shape</code> object representing the

     *                      current clipping area.

     * @see         java.awt.Graphics#getClipBounds

     * @see         java.awt.Graphics#clipRect

     * @see         java.awt.Graphics#setClip(int, int, int, int)

     * @see         java.awt.Graphics#setClip(Shape)

     * @since       JDK1.1

     */

    public Shape getClip() {

        return mGraphics.getClip();

    }

    /**

     * Sets the current clipping area to an arbitrary clip shape.

     * Not all objects which implement the <code>Shape</code>

     * interface can be used to set the clip.  The only

     * <code>Shape</code> objects which are guaranteed to be

     * supported are <code>Shape</code> objects which are

     * obtained via the <code>getClip</code> method and via

     * <code>Rectangle</code> objects.

     * @see         java.awt.Graphics#getClip()

     * @see         java.awt.Graphics#clipRect

     * @see         java.awt.Graphics#setClip(int, int, int, int)

     * @since       JDK1.1

     */

    public void setClip(Shape clip) {

        mGraphics.setClip(clip);

    }

    /**

     * Copies an area of the component by a distance specified by

     * <code>dx</code> and <code>dy</code>. From the point specified

     * by <code>x</code> and <code>y</code>, this method

     * copies downwards and to the right.  To copy an area of the

     * component to the left or upwards, specify a negative value for

     * <code>dx</code> or <code>dy</code>.

     * If a portion of the source rectangle lies outside the bounds

     * of the component, or is obscured by another window or component,

     * <code>copyArea</code> will be unable to copy the associated

     * pixels. The area that is omitted can be refreshed by calling

     * the component's <code>paint</code> method.

     * @param       x the <i>x</i> coordinate of the source rectangle.

     * @param       y the <i>y</i> coordinate of the source rectangle.

     * @param       width the width of the source rectangle.

     * @param       height the height of the source rectangle.

     * @param       dx the horizontal distance to copy the pixels.

     * @param       dy the vertical distance to copy the pixels.

     * @since       JDK1.0

     */

    public void copyArea(int x, int y, int width, int height,

                         int dx, int dy) {

        mGraphics.copyArea(x, y, width, height, dx, dy);

    }

    /**

     * Draws a line, using the current color, between the points

     * <code>(x1,&nbsp;y1)</code> and <code>(x2,&nbsp;y2)</code>

     * in this graphics context's coordinate system.

     * @param   x1  the first point's <i>x</i> coordinate.

     * @param   y1  the first point's <i>y</i> coordinate.

     * @param   x2  the second point's <i>x</i> coordinate.

     * @param   y2  the second point's <i>y</i> coordinate.

     * @since   JDK1.0

     */

    public void drawLine(int x1, int y1, int x2, int y2) {

        mGraphics.drawLine(x1, y1, x2, y2);

    }

    /**

     * Fills the specified rectangle.

     * The left and right edges of the rectangle are at

     * <code>x</code> and <code>x&nbsp;+&nbsp;width&nbsp;-&nbsp;1</code>.

     * The top and bottom edges are at

     * <code>y</code> and <code>y&nbsp;+&nbsp;height&nbsp;-&nbsp;1</code>.

     * The resulting rectangle covers an area

     * <code>width</code> pixels wide by

     * <code>height</code> pixels tall.

     * The rectangle is filled using the graphics context's current color.

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

     *                         of the rectangle to be filled.

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

     *                         of the rectangle to be filled.

     * @param         width   the width of the rectangle to be filled.

     * @param         height   the height of the rectangle to be filled.

     * @see           java.awt.Graphics#fillRect

     * @see           java.awt.Graphics#clearRect

     * @since         JDK1.0

     */

    public void fillRect(int x, int y, int width, int height) {

        mGraphics.fillRect(x, y, width, height);

    }

    /**

     * Clears the specified rectangle by filling it with the background

     * color of the current drawing surface. This operation does not

     * use the current paint mode.

     * <p>

     * Beginning with Java 1.1, the background color

     * of offscreen images may be system dependent. Applications should

     * use <code>setColor</code> followed by <code>fillRect</code> to

     * ensure that an offscreen image is cleared to a specific color.

     * @param       x the <i>x</i> coordinate of the rectangle to clear.

     * @param       y the <i>y</i> coordinate of the rectangle to clear.

     * @param       width the width of the rectangle to clear.

     * @param       height the height of the rectangle to clear.

     * @see         java.awt.Graphics#fillRect(int, int, int, int)

     * @see         java.awt.Graphics#drawRect

     * @see         java.awt.Graphics#setColor(java.awt.Color)

     * @see         java.awt.Graphics#setPaintMode

     * @see         java.awt.Graphics#setXORMode(java.awt.Color)

     * @since       JDK1.0

     */

    public void clearRect(int x, int y, int width, int height) {

        mGraphics.clearRect(x, y, width, height);

    }

    /**

     * Draws an outlined round-cornered rectangle using this graphics

     * context's current color. The left and right edges of the rectangle

     * are at <code>x</code> and <code>x&nbsp;+&nbsp;width</code>,

     * respectively. The top and bottom edges of the rectangle are at

     * <code>y</code> and <code>y&nbsp;+&nbsp;height</code>.

     * @param      x the <i>x</i> coordinate of the rectangle to be drawn.

     * @param      y the <i>y</i> coordinate of the rectangle to be drawn.

     * @param      width the width of the rectangle to be drawn.

     * @param      height the height of the rectangle to be drawn.

     * @param      arcWidth the horizontal diameter of the arc

     *                    at the four corners.

     * @param      arcHeight the vertical diameter of the arc

     *                    at the four corners.

     * @see        java.awt.Graphics#fillRoundRect

     * @since      JDK1.0

     */

    public void drawRoundRect(int x, int y, int width, int height,

                              int arcWidth, int arcHeight) {

        mGraphics.drawRoundRect(x, y, width, height, arcWidth, arcHeight);

    }

    /**

     * Fills the specified rounded corner rectangle with the current color.

     * The left and right edges of the rectangle

     * are at <code>x</code> and <code>x&nbsp;+&nbsp;width&nbsp;-&nbsp;1</code>,

     * respectively. The top and bottom edges of the rectangle are at