/*
* 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();
}
}