ojluni/src/main/java/sun/java2d/xr/MaskTile.java

/*
 * Copyright (c) 2010, 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.xr;

/**
 * Represents a single tile, used to store the rectangles covering the area
 * of the mask where the tile is located.
 *
 * @author Clemens Eisserer
 */
public class MaskTile {
    GrowableRectArray rects;
    DirtyRegion dirtyArea;

    public MaskTile()
    {
        rects = new GrowableRectArray(128);
        dirtyArea = new DirtyRegion();
    }

    public void addRect(int x, int y, int width, int height) {
        int index = rects.getNextIndex();
        rects.setX(index, x);
        rects.setY(index, y);
        rects.setWidth(index, width);
        rects.setHeight(index, height);
    }

    public void addLine(int x1, int y1, int x2, int y2) {
        /*
         * EXA is not able to accalerate diagonal lines, we try to "guide" it a
         * bit to avoid excessive migration See project documentation for an
         * detailed explanation
         */
        DirtyRegion region = new DirtyRegion();
        region.setDirtyLineRegion(x1, y1, x2, y2);
        int xDiff = region.x2 - region.x;
        int yDiff = region.y2 - region.y;

        if (xDiff == 0 || yDiff == 0) {
            addRect(region.x, region.y,
                    region.x2 - region.x + 1, region.y2 - region.y + 1);
        } else if (xDiff == 1 && yDiff == 1) {
            addRect(x1, y1, 1, 1);
            addRect(x2, y2, 1, 1);
        } else {
            lineToRects(x1, y1, x2, y2);
        }
    }

    private void lineToRects(int xstart, int ystart, int xend, int yend) {
        int x, y, t, dx, dy, incx, incy, pdx, pdy, ddx, ddy, es, el, err;

        /* Entfernung in beiden Dimensionen berechnen */
        dx = xend - xstart;
        dy = yend - ystart;

        /* Vorzeichen des Inkrements bestimmen */
        incx = dx > 0 ? 1 : (dx < 0) ? -1 : 0;
        incy = dy > 0 ? 1 : (dy < 0) ? -1 : 0;
        if (dx < 0)
            dx = -dx;
        if (dy < 0)
            dy = -dy;

        /* feststellen, welche Entfernung groesser ist */
        if (dx > dy) {
            /* x ist schnelle Richtung */
            pdx = incx;
            pdy = 0; /* pd. ist Parallelschritt */
            ddx = incx;
            ddy = incy; /* dd. ist Diagonalschritt */
            es = dy;
            el = dx; /* Fehlerschritte schnell, langsam */
        } else {
            /* y ist schnelle Richtung */
            pdx = 0;
            pdy = incy; /* pd. ist Parallelschritt */
            ddx = incx;
            ddy = incy; /* dd. ist Diagonalschritt */
            es = dx;
            el = dy; /* Fehlerschritte schnell, langsam */
        }

        /* Initialisierungen vor Schleifenbeginn */
        x = xstart;
        y = ystart;
        err = el / 2;
        addRect(x, y, 1, 1);

        /* Pixel berechnen */
        for (t = 0; t < el; ++t) /* t zaehlt die Pixel, el ist auch Anzahl */
        {
            /* Aktualisierung Fehlerterm */
            err -= es;
            if (err < 0) {
                /* Fehlerterm wieder positiv (>=0) machen */
                err += el;
                /* Schritt in langsame Richtung, Diagonalschritt */
                x += ddx;
                y += ddy;
            } else {
                /* Schritt in schnelle Richtung, Parallelschritt */
                x += pdx;
                y += pdy;
            }
            addRect(x, y, 1, 1);
            // SetPixel(x,y);
            // System.out.println(x+":"+y);
        }
    }

    public void calculateDirtyAreas()
    {
        for (int i=0; i < rects.getSize(); i++) {
            int x = rects.getX(i);
            int y = rects.getY(i);
            dirtyArea.growDirtyRegion(x, y,
                                      x + rects.getWidth(i),
                                      y + rects.getHeight(i));
        }
    }

    public void reset() {
        rects.clear();
        dirtyArea.clear();
    }

    public void translate(int x, int y) {
        if (rects.getSize() > 0) {
            dirtyArea.translate(x, y);
        }
        rects.translateRects(x, y);
    }

    public GrowableRectArray getRects() {
        return rects;
    }

    public DirtyRegion getDirtyArea() {
        return dirtyArea;
    }
}