Back to index...

	/*
	* Copyright (c) 1999, 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.geom.PathIterator;
	import java.awt.Rectangle;

	/**
	* This class clips a SpanIterator to a Region and outputs the
	* resulting spans as another SpanIterator.
	*
	* Spans are output in the usual y/x order, unless the input span
	* iterator doesn't conform to this order, or the iterator's span
	* straddle more than one band of the Region used for clipping.
	*
	* Principle of operation:
	*
	* The iterator maintains a several cursors onto the RegionIterator
	* in order to avoid having to buffer spans from the SpanIterator.
	* They are:
	* resetState The initial state of the RegionIterator
	* lwm Low Water Mark, a running start point for
	* processing each band. Usually goes down, but
	* can be reset to resetState if a span has a lower
	* start coordinate than the previous one.
	* row The start of the current band of the RegionIterator
	* box The current span of the current row
	*
	* The main nextSpan() loop implements a coroutine like structure, with
	* three producers to get the next span, row and box calling each other
	* to iterate through the span iterator and region.
	*
	* REMIND: Needs a native implementation!
	*/
	public class RegionClipSpanIterator implements SpanIterator {

	// The inputs to the filter
	Region rgn;
	SpanIterator spanIter;

	// The cursors that track the progress through the region
	RegionIterator resetState;
	RegionIterator lwm;
	RegionIterator row;
	RegionIterator box;

	// The bounds of the current span iterator span
	int spanlox, spanhix, spanloy, spanhiy;

	// The extent of the region band marking the low water mark
	int lwmloy, lwmhiy;

	// The bounds of the current region box
	int rgnlox, rgnloy, rgnhix, rgnhiy;

	// The bounding box of the input Region. Used for click
	// rejection of iterator spans
	int rgnbndslox, rgnbndsloy, rgnbndshix, rgnbndshiy;

	// The array used to hold coordinates from the region iterator
	int rgnbox[] = new int[4];

	// The array used to hold coordinates from the span iterator
	int spanbox[] = new int[4];

	// True if the next iterator span should be read on the next
	// iteration of the main nextSpan() loop
	boolean doNextSpan;

	// True if the next region box should be read on the next
	// iteration of the main nextSpan() loop
	boolean doNextBox;

	// True if there are no more spans or the Region is empty
	boolean done = false;

	/*
	* Creates an instance that filters the spans generated by
	* spanIter through the region described by rgn.
	*/
	public RegionClipSpanIterator(Region rgn, SpanIterator spanIter) {

	this.spanIter = spanIter;

	resetState = rgn.getIterator();
	lwm = resetState.createCopy();

	if (!lwm.nextYRange(rgnbox)) {
	done = true;
	return;
	}

	rgnloy = lwmloy = rgnbox[1];
	rgnhiy = lwmhiy = rgnbox[3];

	rgn.getBounds(rgnbox);
	rgnbndslox = rgnbox[0];
	rgnbndsloy = rgnbox[1];
	rgnbndshix = rgnbox[2];
	rgnbndshiy = rgnbox[3];
	if (rgnbndslox >= rgnbndshix \|\|
	rgnbndsloy >= rgnbndshiy) {
	done = true;
	return;
	}

	this.rgn = rgn;


	row = lwm.createCopy();
	box = row.createCopy();
	doNextSpan = true;
	doNextBox = false;
	}

	/*
	* Gets the bbox of the available path segments, clipped to the
	* Region.
	*/
	public void getPathBox(int pathbox[]) {
	int[] rgnbox = new int[4];
	rgn.getBounds(rgnbox);
	spanIter.getPathBox(pathbox);

	if (pathbox[0] < rgnbox[0]) {
	pathbox[0] = rgnbox[0];
	}

	if (pathbox[1] < rgnbox[1]) {
	pathbox[1] = rgnbox[1];
	}

	if (pathbox[2] > rgnbox[2]) {
	pathbox[2] = rgnbox[2];
	}

	if (pathbox[3] > rgnbox[3]) {
	pathbox[3] = rgnbox[3];
	}
	}

	/*
	* Intersects the path box with the given bbox.
	* Returned spans are clipped to this region, or discarded
	* altogether if they lie outside it.
	*/
	public void intersectClipBox(int lox, int loy, int hix, int hiy) {
	spanIter.intersectClipBox(lox, loy, hix, hiy);
	}


	/*
	* Fetches the next span that needs to be operated on.
	* If the return value is false then there are no more spans.
	*/
	public boolean nextSpan(int resultbox[]) {
	if (done) {
	return false;
	}

	int resultlox, resultloy, resulthix, resulthiy;
	boolean doNextRow = false;

	// REMIND: Cache the coordinate inst vars used in this loop
	// in locals vars.
	while (true) {
	// We've exhausted the current span so get the next one
	if (doNextSpan) {
	if (!spanIter.nextSpan(spanbox)) {
	done = true;
	return false;
	} else {
	spanlox = spanbox[0];
	// Clip out spans that lie outside of the rgn's bounds
	if (spanlox >= rgnbndshix) {
	continue;
	}

	spanloy = spanbox[1];
	if (spanloy >= rgnbndshiy) {
	continue;
	}

	spanhix = spanbox[2];
	if (spanhix <= rgnbndslox) {
	continue;
	}

	spanhiy = spanbox[3];
	if (spanhiy <= rgnbndsloy) {
	continue;
	}
	}
	// If the span starts higher up than the low-water mark,
	// reset the lwm. This can only happen if spans aren't
	// returned in strict y/x order, or the first time through.
	if (lwmloy > spanloy) {
	lwm.copyStateFrom(resetState);
	lwm.nextYRange(rgnbox);
	lwmloy = rgnbox[1];
	lwmhiy = rgnbox[3];
	}
	// Skip to the first rgn row whose bottom edge is
	// below the top of the current span. This will only
	// execute >0 times when the current span starts in a
	// lower region row than the previous one, or possibly the
	// first time through.
	while (lwmhiy <= spanloy) {
	if (!lwm.nextYRange(rgnbox))
	break;
	lwmloy = rgnbox[1];
	lwmhiy = rgnbox[3];
	}
	// If the row overlaps the span, process it, otherwise
	// fetch another span
	if (lwmhiy > spanloy && lwmloy < spanhiy) {
	// Update the current row if it's different from the
	// new lwm
	if (rgnloy != lwmloy) {
	row.copyStateFrom(lwm);
	rgnloy = lwmloy;
	rgnhiy = lwmhiy;
	}
	box.copyStateFrom(row);
	doNextBox = true;
	doNextSpan = false;
	}
	continue;
	}

	// The current row's spans are exhausted, do the next one
	if (doNextRow) {
	// Next time we either do the next span or the next box
	doNextRow = false;
	// Get the next row
	boolean ok = row.nextYRange(rgnbox);
	// If there was one, update the bounds
	if (ok) {
	rgnloy = rgnbox[1];
	rgnhiy = rgnbox[3];
	}
	if (!ok \|\| rgnloy >= spanhiy) {
	// If we've exhausted the rows or this one is below the span,
	// go onto the next span
	doNextSpan = true;
	}
	else {
	// Otherwise get the first box on this row
	box.copyStateFrom(row);
	doNextBox = true;
	}
	continue;
	}

	// Process the next box in the current row
	if (doNextBox) {
	boolean ok = box.nextXBand(rgnbox);
	if (ok) {
	rgnlox = rgnbox[0];
	rgnhix = rgnbox[2];
	}
	if (!ok \|\| rgnlox >= spanhix) {
	// If there was no next rgn span or it's beyond the
	// source span, go onto the next row or span
	doNextBox = false;
	if (rgnhiy >= spanhiy) {
	// If the current row totally overlaps the span,
	// go onto the next span
	doNextSpan = true;
	} else {
	// otherwise go onto the next rgn row
	doNextRow = true;
	}
	} else {
	// Otherwise, if the new rgn span overlaps the
	// spanbox, no need to get another box
	doNextBox = rgnhix <= spanlox;
	}
	continue;
	}

	// Prepare to do the next box either on this call or
	// or the subsequent one
	doNextBox = true;

	// Clip the current span against the current box
	if (spanlox > rgnlox) {
	resultlox = spanlox;
	}
	else {
	resultlox = rgnlox;
	}

	if (spanloy > rgnloy) {
	resultloy = spanloy;
	}
	else {
	resultloy = rgnloy;
	}

	if (spanhix < rgnhix) {
	resulthix = spanhix;
	}
	else {
	resulthix = rgnhix;
	}

	if (spanhiy < rgnhiy) {
	resulthiy = spanhiy;
	}
	else {
	resulthiy = rgnhiy;
	}

	// If the result is empty, try then next box
	// otherwise return the box.
	// REMIND: I think by definition it's non-empty
	// if we're here. Need to think about this some more.
	if (resultlox >= resulthix \|\|
	resultloy >= resulthiy) {
	continue;
	}
	else {
	break;
	}
	}

	resultbox[0] = resultlox;
	resultbox[1] = resultloy;
	resultbox[2] = resulthix;
	resultbox[3] = resulthiy;
	return true;

	}


	/**
	* This method tells the iterator that it may skip all spans
	* whose Y range is completely above the indicated Y coordinate.
	*/
	public void skipDownTo(int y) {
	spanIter.skipDownTo(y);
	}

	/**
	* This method returns a native pointer to a function block that
	* can be used by a native method to perform the same iteration
	* cycle that the above methods provide while avoiding upcalls to
	* the Java object.
	* The definition of the structure whose pointer is returned by
	* this method is defined in:
	* <pre>
	* src/share/native/sun/java2d/pipe/SpanIterator.h
	* </pre>
	*/
	public long getNativeIterator() {
	return 0;
	}

	/*
	* Cleans out all internal data structures.
	*/
	//public native void dispose();

	protected void finalize() {
	//dispose();
	}

	}

Back to index...