Java example source code file (RegionSpanIterator.java)

This example Java source code file (RegionSpanIterator.java) is included in the alvinalexander.com "Java Source Code Warehouse" project. The intent of this project is to help you "Learn Java by Example" ^TM.

Learn more about this Java project at its project page.

Java - Java tags/keywords

regioniterator, regionspaniterator, spaniterator

The RegionSpanIterator.java Java example source code

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