Back to index...

	/*
	* Copyright (c) 1998, 2013, 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.print;

	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.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>, <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>, <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, 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 transform 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
	* copy it into a BufferedImage (this takes care of
	* ColorSpace and BufferedImageOp issues) and then
	* send that to PS.
	*/
	} else {

	/* Create a buffered image big enough to hold the portion
	* of the source image being printed.
	*/
	BufferedImage deepImage = new BufferedImage(
	(int) rotBounds.getWidth(),
	(int) rotBounds.getHeight(),
	BufferedImage.TYPE_3BYTE_BGR);

	/* Setup a Graphics2D on to the BufferedImage so that the
	* source image when copied, lands within the image buffer.
	*/
	Graphics2D imageGraphics = deepImage.createGraphics();
	imageGraphics.clipRect(0, 0,
	deepImage.getWidth(),
	deepImage.getHeight());

	imageGraphics.translate(-rotBounds.getX(),
	-rotBounds.getY());
	imageGraphics.transform(rotTransform);

	/* Fill the BufferedImage either with the caller supplied
	* color, 'bgColor' or, if null, with white.
	*/
	if (bgcolor == null) {
	bgcolor = Color.white;
	}

	/* REMIND: no need to use scaling here. */
	imageGraphics.drawImage(img,
	srcX, srcY,
	srcX + srcWidth, srcY + srcHeight,
	srcX, srcY,
	srcX + srcWidth, srcY + srcHeight,
	bgcolor, null);

	/* In PSPrinterJob images are printed in device space
	* and therefore we need to set a device space clip.
	* FIX: this is an overly tight coupling of these
	* two classes.
	* The temporary clip set needs to be an intersection
	* with the previous user clip.
	* REMIND: two xfms may lose accuracy in clip path.
	*/
	Shape holdClip = getClip();
	Shape oldClip =
	getTransform().createTransformedShape(holdClip);
	AffineTransform sat = AffineTransform.getScaleInstance(
	scaleX, scaleY);
	Shape imgClip = sat.createTransformedShape(rotShape);
	Area imgArea = new Area(imgClip);
	Area oldArea = new Area(oldClip);
	imgArea.intersect(oldArea);
	psPrinterJob.setClip(imgArea);

	/* Scale the bounding rectangle by the scale transform.
	* Because the scaling transform has only x and y
	* scaling components it is equivalent to multiply
	* the x components of the bounding rectangle by
	* the x scaling factor and to multiply the y components
	* by the y scaling factor.
	*/
	Rectangle2D.Float scaledBounds
	= new Rectangle2D.Float(
	(float) (rotBounds.getX() * scaleX),
	(float) (rotBounds.getY() * scaleY),
	(float) (rotBounds.getWidth() * scaleX),
	(float) (rotBounds.getHeight() * scaleY));


	/* Pull the raster data from the buffered image
	* and pass it along to PS.
	*/
	ByteComponentRaster tile =
	(ByteComponentRaster)deepImage.getRaster();

	psPrinterJob.drawImageBGR(tile.getDataStorage(),
	scaledBounds.x, scaledBounds.y,
	(float)Math.rint(scaledBounds.width+0.5),
	(float)Math.rint(scaledBounds.height+0.5),
	0f, 0f,
	deepImage.getWidth(), deepImage.getHeight(),
	deepImage.getWidth(), deepImage.getHeight());

	/* Reset the device clip to match user clip */
	psPrinterJob.setClip(
	getTransform().createTransformedShape(holdClip));


	imageGraphics.dispose();
	}

	}
	}

	return true;
	}

	/** Redraw a rectanglular area using a proxy graphics
	* To do this we need to know the rectangular area to redraw and
	* the transform & clip in effect at the time of the original drawImage
	*
	*/

	public void redrawRegion(Rectangle2D region, double scaleX, double scaleY,
	Shape savedClip, AffineTransform savedTransform)

	throws PrinterException {

	PSPrinterJob psPrinterJob = (PSPrinterJob)getPrinterJob();
	Printable painter = getPrintable();
	PageFormat pageFormat = getPageFormat();
	int pageIndex = getPageIndex();

	/* Create a buffered image big enough to hold the portion
	* of the source image being printed.
	*/
	BufferedImage deepImage = new BufferedImage(
	(int) region.getWidth(),
	(int) region.getHeight(),
	BufferedImage.TYPE_3BYTE_BGR);

	/* Get a graphics for the application to render into.
	* We initialize the buffer to white in order to
	* match the paper and then we shift the BufferedImage
	* so that it covers the area on the page where the
	* caller's Image will be drawn.
	*/
	Graphics2D g = deepImage.createGraphics();
	ProxyGraphics2D proxy = new ProxyGraphics2D(g, psPrinterJob);
	proxy.setColor(Color.white);
	proxy.fillRect(0, 0, deepImage.getWidth(), deepImage.getHeight());
	proxy.clipRect(0, 0, deepImage.getWidth(), deepImage.getHeight());

	proxy.translate(-region.getX(), -region.getY());

	/* Calculate the resolution of the source image.
	*/
	float sourceResX = (float)(psPrinterJob.getXRes() / scaleX);
	float sourceResY = (float)(psPrinterJob.getYRes() / scaleY);

	/* The application expects to see user space at 72 dpi.
	* so change user space from image source resolution to
	* 72 dpi.
	*/
	proxy.scale(sourceResX / DEFAULT_USER_RES,
	sourceResY / DEFAULT_USER_RES);
	proxy.translate(
	-psPrinterJob.getPhysicalPrintableX(pageFormat.getPaper())
	/ psPrinterJob.getXRes() * DEFAULT_USER_RES,
	-psPrinterJob.getPhysicalPrintableY(pageFormat.getPaper())
	/ psPrinterJob.getYRes() * DEFAULT_USER_RES);
	/* NB User space now has to be at 72 dpi for this calc to be correct */
	proxy.transform(new AffineTransform(getPageFormat().getMatrix()));

	proxy.setPaint(Color.black);

	painter.print(proxy, pageFormat, pageIndex);

	g.dispose();

	/* In PSPrinterJob images are printed in device space
	* and therefore we need to set a device space clip.
	*/
	psPrinterJob.setClip(savedTransform.createTransformedShape(savedClip));


	/* Scale the bounding rectangle by the scale transform.
	* Because the scaling transform has only x and y
	* scaling components it is equivalent to multiply
	* the x components of the bounding rectangle by
	* the x scaling factor and to multiply the y components
	* by the y scaling factor.
	*/
	Rectangle2D.Float scaledBounds
	= new Rectangle2D.Float(
	(float) (region.getX() * scaleX),
	(float) (region.getY() * scaleY),
	(float) (region.getWidth() * scaleX),
	(float) (region.getHeight() * scaleY));


	/* Pull the raster data from the buffered image
	* and pass it along to PS.
	*/
	ByteComponentRaster tile = (ByteComponentRaster)deepImage.getRaster();

	psPrinterJob.drawImageBGR(tile.getDataStorage(),
	scaledBounds.x, scaledBounds.y,
	scaledBounds.width,
	scaledBounds.height,
	0f, 0f,
	deepImage.getWidth(), deepImage.getHeight(),
	deepImage.getWidth(), deepImage.getHeight());


	}


	/*
	* Fill the path defined by <code>pathIter</code>
	* with the specified color.
	* The path is provided in current user space.
	*/
	protected void deviceFill(PathIterator pathIter, Color color) {

	PSPrinterJob psPrinterJob = (PSPrinterJob) getPrinterJob();
	psPrinterJob.deviceFill(pathIter, color, getTransform(), getClip());
	}

	/*
	* Draw the bounding rectangle using path by calling draw()
	* function and passing a rectangle shape.
	*/
	protected void deviceFrameRect(int x, int y, int width, int height,
	Color color) {

	draw(new Rectangle2D.Float(x, y, width, height));
	}

	/*
	* Draw a line using path by calling draw() function and passing
	* a line shape.
	*/
	protected void deviceDrawLine(int xBegin, int yBegin,
	int xEnd, int yEnd, Color color) {

	draw(new Line2D.Float(xBegin, yBegin, xEnd, yEnd));
	}

	/*
	* Fill the rectangle with the specified color by calling fill().
	*/
	protected void deviceFillRect(int x, int y, int width, int height,
	Color color) {
	fill(new Rectangle2D.Float(x, y, width, height));
	}


	/*
	* This method should not be invoked by PSPathGraphics.
	* FIX: Rework PathGraphics so that this method is
	* not an abstract method there.
	*/
	protected void deviceClip(PathIterator pathIter) {
	}

	}

Back to index...