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