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