Back to index...

	/*
	* Copyright (c) 1999, 2011, 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.pipe;

	import java.awt.Font;
	import java.awt.Shape;
	import java.awt.BasicStroke;
	import java.awt.Polygon;
	import java.awt.geom.AffineTransform;
	import java.awt.geom.PathIterator;
	import java.awt.geom.RoundRectangle2D;
	import java.awt.geom.Ellipse2D;
	import java.awt.geom.Arc2D;
	import java.awt.geom.IllegalPathStateException;
	import java.awt.geom.Path2D;
	import java.awt.font.GlyphVector;
	import sun.java2d.SunGraphics2D;
	import sun.java2d.SurfaceData;
	import sun.java2d.loops.FontInfo;
	import sun.java2d.loops.DrawPolygons;
	import sun.java2d.loops.FillParallelogram;
	import sun.java2d.loops.DrawParallelogram;
	import sun.awt.SunHints;

	public class LoopPipe
	implements PixelDrawPipe,
	PixelFillPipe,
	ParallelogramPipe,
	ShapeDrawPipe,
	LoopBasedPipe
	{
	final static RenderingEngine RenderEngine = RenderingEngine.getInstance();

	public void drawLine(SunGraphics2D sg2d,
	int x1, int y1, int x2, int y2)
	{
	int tX = sg2d.transX;
	int tY = sg2d.transY;
	sg2d.loops.drawLineLoop.DrawLine(sg2d, sg2d.getSurfaceData(),
	x1 + tX, y1 + tY,
	x2 + tX, y2 + tY);
	}

	public void drawRect(SunGraphics2D sg2d,
	int x, int y, int width, int height)
	{
	sg2d.loops.drawRectLoop.DrawRect(sg2d, sg2d.getSurfaceData(),
	x + sg2d.transX,
	y + sg2d.transY,
	width, height);
	}

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

	public void drawOval(SunGraphics2D sg2d,
	int x, int y, int width, int height)
	{
	sg2d.shapepipe.draw(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)
	{
	sg2d.shapepipe.draw(sg2d, new Arc2D.Float(x, y, width, height,
	startAngle, arcAngle,
	Arc2D.OPEN));
	}

	public void drawPolyline(SunGraphics2D sg2d,
	int xPoints[], int yPoints[],
	int nPoints)
	{
	int nPointsArray[] = { nPoints };
	sg2d.loops.drawPolygonsLoop.DrawPolygons(sg2d, sg2d.getSurfaceData(),
	xPoints, yPoints,
	nPointsArray, 1,
	sg2d.transX, sg2d.transY,
	false);
	}

	public void drawPolygon(SunGraphics2D sg2d,
	int xPoints[], int yPoints[],
	int nPoints)
	{
	int nPointsArray[] = { nPoints };
	sg2d.loops.drawPolygonsLoop.DrawPolygons(sg2d, sg2d.getSurfaceData(),
	xPoints, yPoints,
	nPointsArray, 1,
	sg2d.transX, sg2d.transY,
	true);
	}

	public void fillRect(SunGraphics2D sg2d,
	int x, int y, int width, int height)
	{
	sg2d.loops.fillRectLoop.FillRect(sg2d, sg2d.getSurfaceData(),
	x + sg2d.transX,
	y + sg2d.transY,
	width, height);
	}

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

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

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

	public void fillPolygon(SunGraphics2D sg2d,
	int xPoints[], int yPoints[],
	int nPoints)
	{
	ShapeSpanIterator sr = getFillSSI(sg2d);

	try {
	sr.setOutputArea(sg2d.getCompClip());
	sr.appendPoly(xPoints, yPoints, nPoints, sg2d.transX, sg2d.transY);
	fillSpans(sg2d, sr);
	} finally {
	sr.dispose();
	}
	}


	public void draw(SunGraphics2D sg2d, Shape s) {
	if (sg2d.strokeState == SunGraphics2D.STROKE_THIN) {
	Path2D.Float p2df;
	int transX;
	int 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;
	}
	sg2d.loops.drawPathLoop.DrawPath(sg2d, sg2d.getSurfaceData(),
	transX, transY, p2df);
	return;
	}

	if (sg2d.strokeState == SunGraphics2D.STROKE_CUSTOM) {
	fill(sg2d, sg2d.stroke.createStrokedShape(s));
	return;
	}

	ShapeSpanIterator sr = getStrokeSpans(sg2d, s);

	try {
	fillSpans(sg2d, sr);
	} finally {
	sr.dispose();
	}
	}

	/**
	* Return a ShapeSpanIterator instance that normalizes as
	* appropriate for a fill operation as per the settings in
	* the specified SunGraphics2D object.
	*
	* The ShapeSpanIterator will be newly constructed and ready
	* to start taking in geometry.
	*
	* Note that the caller is responsible for calling dispose()
	* on the returned ShapeSpanIterator inside a try/finally block:
	* <pre>
	* ShapeSpanIterator ssi = LoopPipe.getFillSSI(sg2d);
	* try {
	* ssi.setOutputArea(clip);
	* ssi.appendPath(...); // or appendPoly
	* // iterate the spans from ssi and operate on them
	* } finally {
	* ssi.dispose();
	* }
	* </pre>
	*/
	public static ShapeSpanIterator getFillSSI(SunGraphics2D sg2d) {
	boolean adjust = ((sg2d.stroke instanceof BasicStroke) &&
	sg2d.strokeHint != SunHints.INTVAL_STROKE_PURE);
	return new ShapeSpanIterator(adjust);
	}

	/*
	* Return a ShapeSpanIterator ready to iterate the spans of the wide
	* outline of Shape s using the attributes of the SunGraphics2D
	* object.
	*
	* The ShapeSpanIterator returned will be fully constructed
	* and filled with the geometry from the Shape widened by the
	* appropriate BasicStroke and normalization parameters taken
	* from the SunGraphics2D object and be ready to start returning
	* spans.
	*
	* Note that the caller is responsible for calling dispose()
	* on the returned ShapeSpanIterator inside a try/finally block.
	* <pre>
	* ShapeSpanIterator ssi = LoopPipe.getStrokeSpans(sg2d, s);
	* try {
	* // iterate the spans from ssi and operate on them
	* } finally {
	* ssi.dispose();
	* }
	* </pre>
	*
	* REMIND: This should return a SpanIterator interface object
	* but the caller needs to dispose() the object and that method
	* is only on ShapeSpanIterator.
	* TODO: Add a dispose() method to the SpanIterator interface.
	*/
	public static ShapeSpanIterator getStrokeSpans(SunGraphics2D sg2d,
	Shape s)
	{
	ShapeSpanIterator sr = new ShapeSpanIterator(false);

	try {
	sr.setOutputArea(sg2d.getCompClip());
	sr.setRule(PathIterator.WIND_NON_ZERO);

	BasicStroke bs = (BasicStroke) sg2d.stroke;
	boolean thin = (sg2d.strokeState <= SunGraphics2D.STROKE_THINDASHED);
	boolean normalize =
	(sg2d.strokeHint != SunHints.INTVAL_STROKE_PURE);

	RenderEngine.strokeTo(s,
	sg2d.transform, bs,
	thin, normalize, false, sr);
	} catch (Throwable t) {
	sr.dispose();
	sr = null;
	throw new InternalError("Unable to Stroke shape ("+
	t.getMessage()+")", t);
	}
	return sr;
	}

	public void fill(SunGraphics2D sg2d, Shape s) {
	if (sg2d.strokeState == SunGraphics2D.STROKE_THIN) {
	Path2D.Float p2df;
	int transX;
	int 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;
	}
	sg2d.loops.fillPathLoop.FillPath(sg2d, sg2d.getSurfaceData(),
	transX, transY, p2df);
	return;
	}

	ShapeSpanIterator sr = getFillSSI(sg2d);
	try {
	sr.setOutputArea(sg2d.getCompClip());
	AffineTransform at =
	((sg2d.transformState == SunGraphics2D.TRANSFORM_ISIDENT)
	? null
	: sg2d.transform);
	sr.appendPath(s.getPathIterator(at));
	fillSpans(sg2d, sr);
	} finally {
	sr.dispose();
	}
	}

	private static void fillSpans(SunGraphics2D sg2d, SpanIterator si) {
	// REMIND: Eventually, the plan is that it will not be possible for
	// fs to be null since the FillSpans loop will be the fundamental
	// loop implemented for any destination type...
	if (sg2d.clipState == SunGraphics2D.CLIP_SHAPE) {
	si = sg2d.clipRegion.filter(si);
	// REMIND: Region.filter produces a Java-only iterator
	// with no native counterpart...
	} else {
	sun.java2d.loops.FillSpans fs = sg2d.loops.fillSpansLoop;
	if (fs != null) {
	fs.FillSpans(sg2d, sg2d.getSurfaceData(), si);
	return;
	}
	}
	int spanbox[] = new int[4];
	SurfaceData sd = sg2d.getSurfaceData();
	while (si.nextSpan(spanbox)) {
	int x = spanbox[0];
	int y = spanbox[1];
	int w = spanbox[2] - x;
	int h = spanbox[3] - y;
	sg2d.loops.fillRectLoop.FillRect(sg2d, sd, x, y, w, h);
	}
	}

	public void fillParallelogram(SunGraphics2D sg2d,
	double ux1, double uy1,
	double ux2, double uy2,
	double x, double y,
	double dx1, double dy1,
	double dx2, double dy2)
	{
	FillParallelogram fp = sg2d.loops.fillParallelogramLoop;
	fp.FillParallelogram(sg2d, sg2d.getSurfaceData(),
	x, y, dx1, dy1, dx2, dy2);
	}

	public void drawParallelogram(SunGraphics2D sg2d,
	double ux1, double uy1,
	double ux2, double uy2,
	double x, double y,
	double dx1, double dy1,
	double dx2, double dy2,
	double lw1, double lw2)
	{
	DrawParallelogram dp = sg2d.loops.drawParallelogramLoop;
	dp.DrawParallelogram(sg2d, sg2d.getSurfaceData(),
	x, y, dx1, dy1, dx2, dy2, lw1, lw2);
	}
	}

Back to index...