Back to index...

	/*
	* Copyright (c) 1998, 2007, 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 sun.java2d.SunGraphics2D;
	import sun.java2d.SurfaceData;
	import java.awt.Rectangle;
	import java.awt.Shape;
	import java.awt.BasicStroke;
	import java.awt.geom.PathIterator;
	import java.awt.geom.AffineTransform;
	import java.awt.geom.Rectangle2D;
	import sun.awt.SunHints;

	/**
	* This class is used to convert raw geometry into a span iterator
	* object using a simple flattening polygon scan converter.
	* The iterator can be passed on to special SpanFiller loops to
	* perform the actual rendering.
	*/
	public abstract class SpanShapeRenderer implements ShapeDrawPipe {
	final static RenderingEngine RenderEngine = RenderingEngine.getInstance();

	public static class Composite extends SpanShapeRenderer {
	CompositePipe comppipe;

	public Composite(CompositePipe pipe) {
	comppipe = pipe;
	}

	public Object startSequence(SunGraphics2D sg, Shape s,
	Rectangle devR, int[] bbox) {
	return comppipe.startSequence(sg, s, devR, bbox);
	}

	public void renderBox(Object ctx, int x, int y, int w, int h) {
	comppipe.renderPathTile(ctx, null, 0, w, x, y, w, h);
	}

	public void endSequence(Object ctx) {
	comppipe.endSequence(ctx);
	}
	}

	public static class Simple extends SpanShapeRenderer
	implements LoopBasedPipe
	{
	public Object startSequence(SunGraphics2D sg, Shape s,
	Rectangle devR, int[] bbox) {
	return sg;
	}

	public void renderBox(Object ctx, int x, int y, int w, int h) {
	SunGraphics2D sg2d = (SunGraphics2D) ctx;
	SurfaceData sd = sg2d.getSurfaceData();
	sg2d.loops.fillRectLoop.FillRect(sg2d, sd, x, y, w, h);
	}

	public void endSequence(Object ctx) {
	}
	}

	public void draw(SunGraphics2D sg, Shape s) {
	if (sg.stroke instanceof BasicStroke) {
	ShapeSpanIterator sr = LoopPipe.getStrokeSpans(sg, s);
	try {
	renderSpans(sg, sg.getCompClip(), s, sr);
	} finally {
	sr.dispose();
	}
	} else {
	fill(sg, sg.stroke.createStrokedShape(s));
	}
	}

	public static final int NON_RECTILINEAR_TRANSFORM_MASK =
	(AffineTransform.TYPE_GENERAL_TRANSFORM \|
	AffineTransform.TYPE_GENERAL_ROTATION);

	public void fill(SunGraphics2D sg, Shape s) {
	if (s instanceof Rectangle2D &&
	(sg.transform.getType() & NON_RECTILINEAR_TRANSFORM_MASK) == 0)
	{
	renderRect(sg, (Rectangle2D) s);
	return;
	}

	Region clipRegion = sg.getCompClip();
	ShapeSpanIterator sr = LoopPipe.getFillSSI(sg);
	try {
	sr.setOutputArea(clipRegion);
	sr.appendPath(s.getPathIterator(sg.transform));
	renderSpans(sg, clipRegion, s, sr);
	} finally {
	sr.dispose();
	}
	}

	public abstract Object startSequence(SunGraphics2D sg, Shape s,
	Rectangle devR, int[] bbox);

	public abstract void renderBox(Object ctx, int x, int y, int w, int h);

	public abstract void endSequence(Object ctx);

	public void renderRect(SunGraphics2D sg, Rectangle2D r) {
	double corners[] = {
	r.getX(), r.getY(), r.getWidth(), r.getHeight(),
	};
	corners[2] += corners[0];
	corners[3] += corners[1];
	if (corners[2] <= corners[0] \|\| corners[3] <= corners[1]) {
	return;
	}
	sg.transform.transform(corners, 0, corners, 0, 2);
	if (corners[2] < corners[0]) {
	double t = corners[2];
	corners[2] = corners[0];
	corners[0] = t;
	}
	if (corners[3] < corners[1]) {
	double t = corners[3];
	corners[3] = corners[1];
	corners[1] = t;
	}
	int abox[] = {
	(int) corners[0],
	(int) corners[1],
	(int) corners[2],
	(int) corners[3],
	};
	Rectangle devR = new Rectangle(abox[0], abox[1],
	abox[2] - abox[0],
	abox[3] - abox[1]);
	Region clipRegion = sg.getCompClip();
	clipRegion.clipBoxToBounds(abox);
	if (abox[0] >= abox[2] \|\| abox[1] >= abox[3]) {
	return;
	}
	Object context = startSequence(sg, r, devR, abox);
	if (clipRegion.isRectangular()) {
	renderBox(context, abox[0], abox[1],
	abox[2] - abox[0],
	abox[3] - abox[1]);
	} else {
	SpanIterator sr = clipRegion.getSpanIterator(abox);
	while (sr.nextSpan(abox)) {
	renderBox(context, abox[0], abox[1],
	abox[2] - abox[0],
	abox[3] - abox[1]);
	}
	}
	endSequence(context);
	}

	public void renderSpans(SunGraphics2D sg, Region clipRegion, Shape s,
	ShapeSpanIterator sr)
	{
	Object context = null;
	int abox[] = new int[4];
	try {
	sr.getPathBox(abox);
	Rectangle devR = new Rectangle(abox[0], abox[1],
	abox[2] - abox[0],
	abox[3] - abox[1]);
	clipRegion.clipBoxToBounds(abox);
	if (abox[0] >= abox[2] \|\| abox[1] >= abox[3]) {
	return;
	}
	sr.intersectClipBox(abox[0], abox[1], abox[2], abox[3]);
	context = startSequence(sg, s, devR, abox);

	spanClipLoop(context, sr, clipRegion, abox);

	} finally {
	if (context != null) {
	endSequence(context);
	}
	}
	}

	public void spanClipLoop(Object ctx, SpanIterator sr,
	Region r, int[] abox) {
	if (!r.isRectangular()) {
	sr = r.filter(sr);
	}
	while (sr.nextSpan(abox)) {
	int x = abox[0];
	int y = abox[1];
	renderBox(ctx, x, y, abox[2] - x, abox[3] - y);
	}
	}
	}

Back to index...