jdk/src/solaris/classes/sun/java2d/xr/XRRenderer.java - edge/openjdk - Git at Google

 /*
  * Copyright (c) 2010, 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.java2d.xr;

 import java.awt.*;
 import java.awt.geom.*;
 import sun.awt.SunToolkit;
 import sun.java2d.SunGraphics2D;
 import sun.java2d.loops.*;
 import sun.java2d.pipe.Region;
 import sun.java2d.pipe.PixelDrawPipe;
 import sun.java2d.pipe.PixelFillPipe;
 import sun.java2d.pipe.ShapeDrawPipe;
 import sun.java2d.pipe.SpanIterator;
 import sun.java2d.pipe.ShapeSpanIterator;
 import sun.java2d.pipe.LoopPipe;

 import static sun.java2d.xr.XRUtils.clampToShort;
 import static sun.java2d.xr.XRUtils.clampToUShort;

 /**
  * XRender provides only accalerated rectangles. To emulate higher "order"
  *  geometry we have to pass everything else to DoPath/FillSpans.
  *
  * TODO: DrawRect could be instrified
  *
  * @author Clemens Eisserer
  */

 public class XRRenderer implements PixelDrawPipe, PixelFillPipe, ShapeDrawPipe {
     XRDrawHandler drawHandler;
     MaskTileManager tileManager;
     XRDrawLine lineGen;
     GrowableRectArray rectBuffer;

     public XRRenderer(MaskTileManager tileManager) {
         this.tileManager = tileManager;
         this.rectBuffer = tileManager.getMainTile().getRects();

         this.drawHandler = new XRDrawHandler();
         this.lineGen = new XRDrawLine();
     }

     /**
      * Common validate method, used by all XRRender functions to validate the
      * destination context.
      */
     private final void validateSurface(SunGraphics2D sg2d) {
         XRSurfaceData xrsd = (XRSurfaceData) sg2d.surfaceData;
         xrsd.validateAsDestination(sg2d, sg2d.getCompClip());
         xrsd.maskBuffer.validateCompositeState(sg2d.composite, sg2d.transform,
                                                sg2d.paint, sg2d);
     }

     public void drawLine(SunGraphics2D sg2d, int x1, int y1, int x2, int y2) {
         Region compClip = sg2d.getCompClip();
         int transX1 = Region.clipAdd(x1, sg2d.transX);
         int transY1 = Region.clipAdd(y1, sg2d.transY);
         int transX2 = Region.clipAdd(x2, sg2d.transX);
         int transY2 = Region.clipAdd(y2, sg2d.transY);

         SunToolkit.awtLock();
         try {
             validateSurface(sg2d);
             lineGen.rasterizeLine(rectBuffer, transX1, transY1,
                     transX2, transY2, compClip.getLoX(), compClip.getLoY(),
                     compClip.getHiX(), compClip.getHiY(), true, true);
             tileManager.fillMask((XRSurfaceData) sg2d.surfaceData);
         } finally {
             SunToolkit.awtUnlock();
         }
     }

     public void drawRect(SunGraphics2D sg2d,
                          int x, int y, int width, int height) {
         draw(sg2d, new Rectangle2D.Float(x, y, width, height));
     }

     public void drawPolyline(SunGraphics2D sg2d,
                              int xpoints[], int ypoints[], int npoints) {
         Path2D.Float p2d = new Path2D.Float();
         if (npoints > 1) {
             p2d.moveTo(xpoints[0], ypoints[0]);
             for (int i = 1; i < npoints; i++) {
                 p2d.lineTo(xpoints[i], ypoints[i]);
             }
         }

         draw(sg2d, p2d);
     }

     public void drawPolygon(SunGraphics2D sg2d,
                             int xpoints[], int ypoints[], int npoints) {
         draw(sg2d, new Polygon(xpoints, ypoints, npoints));
     }

     public void fillRect(SunGraphics2D sg2d, int x, int y, int width, int height) {
         x = Region.clipAdd(x, sg2d.transX);
         y = Region.clipAdd(y, sg2d.transY);

         /*
          * Limit x/y to signed short, width/height to unsigned short,
          * to match the X11 coordinate limits for rectangles.
          * Correct width/height in case x/y have been modified by clipping.
          */
         if (x > Short.MAX_VALUE || y > Short.MAX_VALUE) {
             return;
         }

         int x2 = Region.dimAdd(x, width);
         int y2 = Region.dimAdd(y, height);

         if (x2 < Short.MIN_VALUE || y2 < Short.MIN_VALUE) {
             return;
         }

         x = clampToShort(x);
         y = clampToShort(y);
         width = clampToUShort(x2 - x);
         height = clampToUShort(y2 - y);

         if (width == 0 || height == 0) {
             return;
         }

         SunToolkit.awtLock();
         try {
             validateSurface(sg2d);
             rectBuffer.pushRectValues(x, y, width, height);
             tileManager.fillMask((XRSurfaceData) sg2d.surfaceData);
         } finally {
             SunToolkit.awtUnlock();
         }
     }

     public void fillPolygon(SunGraphics2D sg2d,
                             int xpoints[], int ypoints[], int npoints) {
         fill(sg2d, new Polygon(xpoints, ypoints, npoints));
     }

     public void drawRoundRect(SunGraphics2D sg2d,
                               int x, int y, int width, int height,
                               int arcWidth, int arcHeight) {
         draw(sg2d, new RoundRectangle2D.Float(x, y, width, height,
                                               arcWidth, arcHeight));
     }

     public void fillRoundRect(SunGraphics2D sg2d, int x, int y,
                               int width, int height,
                               int arcWidth, int arcHeight) {
         fill(sg2d, new RoundRectangle2D.Float(x, y, width, height,
                                               arcWidth, arcHeight));
     }

     public void drawOval(SunGraphics2D sg2d,
                          int x, int y, int width, int height) {
         draw(sg2d, new Ellipse2D.Float(x, y, width, height));
     }

     public void fillOval(SunGraphics2D sg2d,
                          int x, int y, int width, int height) {
         fill(sg2d, new Ellipse2D.Float(x, y, width, height));
     }

     public void drawArc(SunGraphics2D sg2d,
                        int x, int y, int width, int height,
                         int startAngle, int arcAngle) {
         draw(sg2d, new Arc2D.Float(x, y, width, height,
                                    startAngle, arcAngle, Arc2D.OPEN));
     }

     public void fillArc(SunGraphics2D sg2d,
                          int x, int y, int width, int height,
                          int startAngle, int arcAngle) {
         fill(sg2d, new Arc2D.Float(x, y, width, height,
              startAngle, arcAngle, Arc2D.PIE));
     }

     private class XRDrawHandler extends ProcessPath.DrawHandler {
         DirtyRegion region;

         XRDrawHandler() {
             // these are bogus values; the caller will use validate()
             // to ensure that they are set properly prior to each usage
             super(0, 0, 0, 0);
             this.region = new DirtyRegion();
         }

         /**
          * This method needs to be called prior to each draw/fillPath()
          * operation to ensure the clip bounds are up to date.
          */
         void validate(SunGraphics2D sg2d) {
             Region clip = sg2d.getCompClip();
             setBounds(clip.getLoX(), clip.getLoY(),
                       clip.getHiX(), clip.getHiY(), sg2d.strokeHint);
             validateSurface(sg2d);
         }

         public void drawLine(int x1, int y1, int x2, int y2) {
             region.setDirtyLineRegion(x1, y1, x2, y2);
             int xDiff = region.x2 - region.x;
             int yDiff = region.y2 - region.y;

             if (xDiff == 0 || yDiff == 0) {
                 // horizontal / diagonal lines can be represented by a single
                 // rectangle
                 rectBuffer.pushRectValues(region.x, region.y, region.x2 - region.x
                         + 1, region.y2 - region.y + 1);
             } else if (xDiff == 1 && yDiff == 1) {
                 // fast path for pattern commonly generated by
                 // ProcessPath.DrawHandler
                 rectBuffer.pushRectValues(x1, y1, 1, 1);
                 rectBuffer.pushRectValues(x2, y2, 1, 1);
             } else {
                 lineGen.rasterizeLine(rectBuffer, x1, y1, x2, y2, 0, 0,
                                       0, 0, false, false);
             }
         }

         public void drawPixel(int x, int y) {
             rectBuffer.pushRectValues(x, y, 1, 1);
         }

         public void drawScanline(int x1, int x2, int y) {
             rectBuffer.pushRectValues(x1, y, x2 - x1 + 1, 1);
         }
     }

     protected void drawPath(SunGraphics2D sg2d, Path2D.Float p2df,
                             int transx, int transy) {
         SunToolkit.awtLock();
         try {
             validateSurface(sg2d);
             drawHandler.validate(sg2d);
             ProcessPath.drawPath(drawHandler, p2df, transx, transy);
             tileManager.fillMask(((XRSurfaceData) sg2d.surfaceData));
         } finally {
             SunToolkit.awtUnlock();
         }
     }

     protected void fillPath(SunGraphics2D sg2d, Path2D.Float p2df,
                             int transx, int transy) {
         SunToolkit.awtLock();
         try {
             validateSurface(sg2d);
             drawHandler.validate(sg2d);
             ProcessPath.fillPath(drawHandler, p2df, transx, transy);
             tileManager.fillMask(((XRSurfaceData) sg2d.surfaceData));
         } finally {
             SunToolkit.awtUnlock();
         }
     }

     protected void fillSpans(SunGraphics2D sg2d, SpanIterator si,
                              int transx, int transy) {
         SunToolkit.awtLock();
         try {
             validateSurface(sg2d);
             int[] spanBox = new int[4];
             while (si.nextSpan(spanBox)) {
                 rectBuffer.pushRectValues(spanBox[0] + transx,
                                     spanBox[1] + transy,
                                     spanBox[2] - spanBox[0],
                                     spanBox[3] - spanBox[1]);
             }
             tileManager.fillMask(((XRSurfaceData) sg2d.surfaceData));
         } finally {
             SunToolkit.awtUnlock();
         }
     }

     public void draw(SunGraphics2D sg2d, Shape s) {
         if (sg2d.strokeState == SunGraphics2D.STROKE_THIN) {
             Path2D.Float p2df;
             int transx, transy;
             if (sg2d.transformState <= SunGraphics2D.TRANSFORM_INT_TRANSLATE) {
                 if (s instanceof Path2D.Float) {
                     p2df = (Path2D.Float) s;
                 } else {
                     p2df = new Path2D.Float(s);
                 }
                 transx = sg2d.transX;
                 transy = sg2d.transY;
             } else {
                 p2df = new Path2D.Float(s, sg2d.transform);
                 transx = 0;
                 transy = 0;
             }
             drawPath(sg2d, p2df, transx, transy);
         } else if (sg2d.strokeState < SunGraphics2D.STROKE_CUSTOM) {
             ShapeSpanIterator si = LoopPipe.getStrokeSpans(sg2d, s);
             try {
                 fillSpans(sg2d, si, 0, 0);
             } finally {
                 si.dispose();
             }
         } else {
             fill(sg2d, sg2d.stroke.createStrokedShape(s));
         }
     }

     public void fill(SunGraphics2D sg2d, Shape s) {
         int transx, transy;

         if (sg2d.strokeState == SunGraphics2D.STROKE_THIN) {
             // Here we are able to use fillPath() for
             // high-quality fills.
             Path2D.Float p2df;
             if (sg2d.transformState <= SunGraphics2D.TRANSFORM_INT_TRANSLATE) {
                 if (s instanceof Path2D.Float) {
                     p2df = (Path2D.Float) s;
                 } else {
                     p2df = new Path2D.Float(s);
                 }
                 transx = sg2d.transX;
                 transy = sg2d.transY;
             } else {
                 p2df = new Path2D.Float(s, sg2d.transform);
                 transx = 0;
                 transy = 0;
             }
             fillPath(sg2d, p2df, transx, transy);
             return;
         }

         AffineTransform at;
         if (sg2d.transformState <= SunGraphics2D.TRANSFORM_INT_TRANSLATE) {
             // Transform (translation) will be done by FillSpans
             at = null;
             transx = sg2d.transX;
             transy = sg2d.transY;
         } else {
             // Transform will be done by the PathIterator
             at = sg2d.transform;
             transx = transy = 0;
         }

         ShapeSpanIterator ssi = LoopPipe.getFillSSI(sg2d);
         try {
             // Subtract transx/y from the SSI clip to match the
             // (potentially untranslated) geometry fed to it
             Region clip = sg2d.getCompClip();
             ssi.setOutputAreaXYXY(clip.getLoX() - transx,
                                   clip.getLoY() - transy,
                                   clip.getHiX() - transx,
                                   clip.getHiY() - transy);
             ssi.appendPath(s.getPathIterator(at));
             fillSpans(sg2d, ssi, transx, transy);
         } finally {
             ssi.dispose();
         }
     }
 }
	/*
	* Copyright (c) 2010, 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.java2d.xr;

	import java.awt.*;
	import java.awt.geom.*;
	import sun.awt.SunToolkit;
	import sun.java2d.SunGraphics2D;
	import sun.java2d.loops.*;
	import sun.java2d.pipe.Region;
	import sun.java2d.pipe.PixelDrawPipe;
	import sun.java2d.pipe.PixelFillPipe;
	import sun.java2d.pipe.ShapeDrawPipe;
	import sun.java2d.pipe.SpanIterator;
	import sun.java2d.pipe.ShapeSpanIterator;
	import sun.java2d.pipe.LoopPipe;

	import static sun.java2d.xr.XRUtils.clampToShort;
	import static sun.java2d.xr.XRUtils.clampToUShort;

	/**
	* XRender provides only accalerated rectangles. To emulate higher "order"
	* geometry we have to pass everything else to DoPath/FillSpans.
	*
	* TODO: DrawRect could be instrified
	*
	* @author Clemens Eisserer
	*/

	public class XRRenderer implements PixelDrawPipe, PixelFillPipe, ShapeDrawPipe {
	XRDrawHandler drawHandler;
	MaskTileManager tileManager;
	XRDrawLine lineGen;
	GrowableRectArray rectBuffer;

	public XRRenderer(MaskTileManager tileManager) {
	this.tileManager = tileManager;
	this.rectBuffer = tileManager.getMainTile().getRects();

	this.drawHandler = new XRDrawHandler();
	this.lineGen = new XRDrawLine();
	}

	/**
	* Common validate method, used by all XRRender functions to validate the
	* destination context.
	*/
	private final void validateSurface(SunGraphics2D sg2d) {
	XRSurfaceData xrsd = (XRSurfaceData) sg2d.surfaceData;
	xrsd.validateAsDestination(sg2d, sg2d.getCompClip());
	xrsd.maskBuffer.validateCompositeState(sg2d.composite, sg2d.transform,
	sg2d.paint, sg2d);
	}

	public void drawLine(SunGraphics2D sg2d, int x1, int y1, int x2, int y2) {
	Region compClip = sg2d.getCompClip();
	int transX1 = Region.clipAdd(x1, sg2d.transX);
	int transY1 = Region.clipAdd(y1, sg2d.transY);
	int transX2 = Region.clipAdd(x2, sg2d.transX);
	int transY2 = Region.clipAdd(y2, sg2d.transY);

	SunToolkit.awtLock();
	try {
	validateSurface(sg2d);
	lineGen.rasterizeLine(rectBuffer, transX1, transY1,
	transX2, transY2, compClip.getLoX(), compClip.getLoY(),
	compClip.getHiX(), compClip.getHiY(), true, true);
	tileManager.fillMask((XRSurfaceData) sg2d.surfaceData);
	} finally {
	SunToolkit.awtUnlock();
	}
	}

	public void drawRect(SunGraphics2D sg2d,
	int x, int y, int width, int height) {
	draw(sg2d, new Rectangle2D.Float(x, y, width, height));
	}

	public void drawPolyline(SunGraphics2D sg2d,
	int xpoints[], int ypoints[], int npoints) {
	Path2D.Float p2d = new Path2D.Float();
	if (npoints > 1) {
	p2d.moveTo(xpoints[0], ypoints[0]);
	for (int i = 1; i < npoints; i++) {
	p2d.lineTo(xpoints[i], ypoints[i]);
	}
	}

	draw(sg2d, p2d);
	}

	public void drawPolygon(SunGraphics2D sg2d,
	int xpoints[], int ypoints[], int npoints) {
	draw(sg2d, new Polygon(xpoints, ypoints, npoints));
	}

	public void fillRect(SunGraphics2D sg2d, int x, int y, int width, int height) {
	x = Region.clipAdd(x, sg2d.transX);
	y = Region.clipAdd(y, sg2d.transY);

	/*
	* Limit x/y to signed short, width/height to unsigned short,
	* to match the X11 coordinate limits for rectangles.
	* Correct width/height in case x/y have been modified by clipping.
	*/
	if (x > Short.MAX_VALUE \|\| y > Short.MAX_VALUE) {
	return;
	}

	int x2 = Region.dimAdd(x, width);
	int y2 = Region.dimAdd(y, height);

	if (x2 < Short.MIN_VALUE \|\| y2 < Short.MIN_VALUE) {
	return;
	}

	x = clampToShort(x);
	y = clampToShort(y);
	width = clampToUShort(x2 - x);
	height = clampToUShort(y2 - y);

	if (width == 0 \|\| height == 0) {
	return;
	}

	SunToolkit.awtLock();
	try {
	validateSurface(sg2d);
	rectBuffer.pushRectValues(x, y, width, height);
	tileManager.fillMask((XRSurfaceData) sg2d.surfaceData);
	} finally {
	SunToolkit.awtUnlock();
	}
	}

	public void fillPolygon(SunGraphics2D sg2d,
	int xpoints[], int ypoints[], int npoints) {
	fill(sg2d, new Polygon(xpoints, ypoints, npoints));
	}

	public void drawRoundRect(SunGraphics2D sg2d,
	int x, int y, int width, int height,
	int arcWidth, int arcHeight) {
	draw(sg2d, new RoundRectangle2D.Float(x, y, width, height,
	arcWidth, arcHeight));
	}

	public void fillRoundRect(SunGraphics2D sg2d, int x, int y,
	int width, int height,
	int arcWidth, int arcHeight) {
	fill(sg2d, new RoundRectangle2D.Float(x, y, width, height,
	arcWidth, arcHeight));
	}

	public void drawOval(SunGraphics2D sg2d,
	int x, int y, int width, int height) {
	draw(sg2d, new Ellipse2D.Float(x, y, width, height));
	}

	public void fillOval(SunGraphics2D sg2d,
	int x, int y, int width, int height) {
	fill(sg2d, new Ellipse2D.Float(x, y, width, height));
	}

	public void drawArc(SunGraphics2D sg2d,
	int x, int y, int width, int height,
	int startAngle, int arcAngle) {
	draw(sg2d, new Arc2D.Float(x, y, width, height,
	startAngle, arcAngle, Arc2D.OPEN));
	}

	public void fillArc(SunGraphics2D sg2d,
	int x, int y, int width, int height,
	int startAngle, int arcAngle) {
	fill(sg2d, new Arc2D.Float(x, y, width, height,
	startAngle, arcAngle, Arc2D.PIE));
	}

	private class XRDrawHandler extends ProcessPath.DrawHandler {
	DirtyRegion region;

	XRDrawHandler() {
	// these are bogus values; the caller will use validate()
	// to ensure that they are set properly prior to each usage
	super(0, 0, 0, 0);
	this.region = new DirtyRegion();
	}

	/**
	* This method needs to be called prior to each draw/fillPath()
	* operation to ensure the clip bounds are up to date.
	*/
	void validate(SunGraphics2D sg2d) {
	Region clip = sg2d.getCompClip();
	setBounds(clip.getLoX(), clip.getLoY(),
	clip.getHiX(), clip.getHiY(), sg2d.strokeHint);
	validateSurface(sg2d);
	}

	public void drawLine(int x1, int y1, int x2, int y2) {
	region.setDirtyLineRegion(x1, y1, x2, y2);
	int xDiff = region.x2 - region.x;
	int yDiff = region.y2 - region.y;

	if (xDiff == 0 \|\| yDiff == 0) {
	// horizontal / diagonal lines can be represented by a single
	// rectangle
	rectBuffer.pushRectValues(region.x, region.y, region.x2 - region.x
	+ 1, region.y2 - region.y + 1);
	} else if (xDiff == 1 && yDiff == 1) {
	// fast path for pattern commonly generated by
	// ProcessPath.DrawHandler
	rectBuffer.pushRectValues(x1, y1, 1, 1);
	rectBuffer.pushRectValues(x2, y2, 1, 1);
	} else {
	lineGen.rasterizeLine(rectBuffer, x1, y1, x2, y2, 0, 0,
	0, 0, false, false);
	}
	}

	public void drawPixel(int x, int y) {
	rectBuffer.pushRectValues(x, y, 1, 1);
	}

	public void drawScanline(int x1, int x2, int y) {
	rectBuffer.pushRectValues(x1, y, x2 - x1 + 1, 1);
	}
	}

	protected void drawPath(SunGraphics2D sg2d, Path2D.Float p2df,
	int transx, int transy) {
	SunToolkit.awtLock();
	try {
	validateSurface(sg2d);
	drawHandler.validate(sg2d);
	ProcessPath.drawPath(drawHandler, p2df, transx, transy);
	tileManager.fillMask(((XRSurfaceData) sg2d.surfaceData));
	} finally {
	SunToolkit.awtUnlock();
	}
	}

	protected void fillPath(SunGraphics2D sg2d, Path2D.Float p2df,
	int transx, int transy) {
	SunToolkit.awtLock();
	try {
	validateSurface(sg2d);
	drawHandler.validate(sg2d);
	ProcessPath.fillPath(drawHandler, p2df, transx, transy);
	tileManager.fillMask(((XRSurfaceData) sg2d.surfaceData));
	} finally {
	SunToolkit.awtUnlock();
	}
	}

	protected void fillSpans(SunGraphics2D sg2d, SpanIterator si,
	int transx, int transy) {
	SunToolkit.awtLock();
	try {
	validateSurface(sg2d);
	int[] spanBox = new int[4];
	while (si.nextSpan(spanBox)) {
	rectBuffer.pushRectValues(spanBox[0] + transx,
	spanBox[1] + transy,
	spanBox[2] - spanBox[0],
	spanBox[3] - spanBox[1]);
	}
	tileManager.fillMask(((XRSurfaceData) sg2d.surfaceData));
	} finally {
	SunToolkit.awtUnlock();
	}
	}

	public void draw(SunGraphics2D sg2d, Shape s) {
	if (sg2d.strokeState == SunGraphics2D.STROKE_THIN) {
	Path2D.Float p2df;
	int transx, transy;
	if (sg2d.transformState <= SunGraphics2D.TRANSFORM_INT_TRANSLATE) {
	if (s instanceof Path2D.Float) {
	p2df = (Path2D.Float) s;
	} else {
	p2df = new Path2D.Float(s);
	}
	transx = sg2d.transX;
	transy = sg2d.transY;
	} else {
	p2df = new Path2D.Float(s, sg2d.transform);
	transx = 0;
	transy = 0;
	}
	drawPath(sg2d, p2df, transx, transy);
	} else if (sg2d.strokeState < SunGraphics2D.STROKE_CUSTOM) {
	ShapeSpanIterator si = LoopPipe.getStrokeSpans(sg2d, s);
	try {
	fillSpans(sg2d, si, 0, 0);
	} finally {
	si.dispose();
	}
	} else {
	fill(sg2d, sg2d.stroke.createStrokedShape(s));
	}
	}

	public void fill(SunGraphics2D sg2d, Shape s) {
	int transx, transy;

	if (sg2d.strokeState == SunGraphics2D.STROKE_THIN) {
	// Here we are able to use fillPath() for
	// high-quality fills.
	Path2D.Float p2df;
	if (sg2d.transformState <= SunGraphics2D.TRANSFORM_INT_TRANSLATE) {
	if (s instanceof Path2D.Float) {
	p2df = (Path2D.Float) s;
	} else {
	p2df = new Path2D.Float(s);
	}
	transx = sg2d.transX;
	transy = sg2d.transY;
	} else {
	p2df = new Path2D.Float(s, sg2d.transform);
	transx = 0;
	transy = 0;
	}
	fillPath(sg2d, p2df, transx, transy);
	return;
	}

	AffineTransform at;
	if (sg2d.transformState <= SunGraphics2D.TRANSFORM_INT_TRANSLATE) {
	// Transform (translation) will be done by FillSpans
	at = null;
	transx = sg2d.transX;
	transy = sg2d.transY;
	} else {
	// Transform will be done by the PathIterator
	at = sg2d.transform;
	transx = transy = 0;
	}

	ShapeSpanIterator ssi = LoopPipe.getFillSSI(sg2d);
	try {
	// Subtract transx/y from the SSI clip to match the
	// (potentially untranslated) geometry fed to it
	Region clip = sg2d.getCompClip();
	ssi.setOutputAreaXYXY(clip.getLoX() - transx,
	clip.getLoY() - transy,
	clip.getHiX() - transx,
	clip.getHiY() - transy);
	ssi.appendPath(s.getPathIterator(at));
	fillSpans(sg2d, ssi, transx, transy);
	} finally {
	ssi.dispose();
	}
	}
	}