Back to index...

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

	/**
	* This class implements the ShapeIterator interface for a Region.
	* This is useful as the source iterator of a device clip region
	* (in its native guise), and also as the result of clipping a
	* Region to a rectangle.
	*/
	public class RegionSpanIterator implements SpanIterator {
	// The RegionIterator that we use to do the work
	RegionIterator ri;

	// Clipping bounds
	int lox, loy, hix, hiy;

	// Current Y band limits
	int curloy, curhiy;

	// Are we done?
	boolean done = false;

	// Is the associated Region rectangular?
	boolean isrect;

	/*
	REMIND: For native implementation
	long pData; // Private storage of rect info

	static {
	initIDs();
	}

	public static native void initIDs();
	*/

	/**
	* Constructs an instance based on the given Region
	*/
	public RegionSpanIterator(Region r) {
	int[] bounds = new int[4];

	r.getBounds(bounds);
	lox = bounds[0];
	loy = bounds[1];
	hix = bounds[2];
	hiy = bounds[3];
	isrect = r.isRectangular();

	ri = r.getIterator();
	}

	/**
	* Gets the bbox of the available region spans.
	*/
	public void getPathBox(int pathbox[]) {
	pathbox[0] = lox;
	pathbox[1] = loy;
	pathbox[2] = hix;
	pathbox[3] = hiy;
	}

	/**
	* Intersect the box used for clipping the output spans with the
	* given box.
	*/
	public void intersectClipBox(int clox, int cloy, int chix, int chiy) {
	if (clox > lox) {
	lox = clox;
	}
	if (cloy > loy) {
	loy = cloy;
	}
	if (chix < hix) {
	hix = chix;
	}
	if (chiy < hiy) {
	hiy = chiy;
	}
	done = lox >= hix \|\| loy >= 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 spanbox[]) {

	// Quick test for end conditions
	if (done) {
	return false;
	}

	// If the Region is rectangular, we store our bounds (possibly
	// clipped via intersectClipBox()) in spanbox and return true
	// so that the caller will process the single span. We set done
	// to true to ensure that this will be the last span processed.
	if (isrect) {
	getPathBox(spanbox);
	done = true;
	return true;
	}

	// Local cache of current span's bounds
	int curlox, curhix;
	int curloy = this.curloy;
	int curhiy = this.curhiy;

	while (true) {
	if (!ri.nextXBand(spanbox)) {
	if (!ri.nextYRange(spanbox)) {
	done = true;
	return false;
	}
	// Update the current y band and clip it
	curloy = spanbox[1];
	curhiy = spanbox[3];
	if (curloy < loy) {
	curloy = loy;
	}
	if (curhiy > hiy) {
	curhiy = hiy;
	}
	// Check for moving below the clip rect
	if (curloy >= hiy) {
	done = true;
	return false;
	}
	continue;
	}
	// Clip the x box
	curlox = spanbox[0];
	curhix = spanbox[2];
	if (curlox < lox) {
	curlox = lox;
	}
	if (curhix > hix) {
	curhix = hix;
	}
	// If it's non- box, we're done
	if (curlox < curhix && curloy < curhiy) {
	break;
	}
	}

	// Update the result and the store y range
	spanbox[0] = curlox;
	spanbox[1] = this.curloy = curloy;
	spanbox[2] = curhix;
	spanbox[3] = this.curhiy = curhiy;
	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) {
	loy = 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.
	* REMIND: Native implementation
	public native void dispose();

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

Back to index...