LoopPipe.java

/*
 * Copyright (c) 1999, 2021, 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.Shape;
import java.awt.BasicStroke;
import java.awt.geom.AffineTransform;
import java.awt.geom.PathIterator;
import java.awt.geom.RoundRectangle2D;
import java.awt.geom.Ellipse2D;
import java.awt.geom.Arc2D;
import java.awt.geom.Path2D;
import sun.java2d.SunGraphics2D;
import sun.java2d.SurfaceData;
import sun.java2d.loops.FillParallelogram;
import sun.java2d.loops.DrawParallelogram;
import sun.awt.SunHints;

public class LoopPipe
    implements PixelDrawPipe,
               PixelFillPipe,
               ParallelogramPipe,
               ShapeDrawPipe,
               LoopBasedPipe
{
    static final RenderingEngine RenderEngine = RenderingEngine.getInstance();

    public void drawLine(SunGraphics2D sg2d,
                         int x1, int y1, int x2, int y2)
    {
        int tX = sg2d.transX;
        int tY = sg2d.transY;
        sg2d.loops.drawLineLoop.DrawLine(sg2d, sg2d.getSurfaceData(),
                                         x1 + tX, y1 + tY,
                                         x2 + tX, y2 + tY);
    }

    public void drawRect(SunGraphics2D sg2d,
                         int x, int y, int width, int height)
    {
        sg2d.loops.drawRectLoop.DrawRect(sg2d, sg2d.getSurfaceData(),
                                         x + sg2d.transX,
                                         y + sg2d.transY,
                                         width, height);
    }

    public void drawRoundRect(SunGraphics2D sg2d,
                              int x, int y, int width, int height,
                              int arcWidth, int arcHeight)
    {
        sg2d.shapepipe.draw(sg2d,
                            new RoundRectangle2D.Float(x, y, width, height,
                                                       arcWidth, arcHeight));
    }

    public void drawOval(SunGraphics2D sg2d,
                         int x, int y, int width, int height)
    {
        sg2d.shapepipe.draw(sg2d, new Ellipse2D.Float(x, y, width, height));
    }

    public void drawArc(SunGraphics2D sg2d,
                        int x, int y, int width, int height,
                        int startAngle, int arcAngle)
    {
        sg2d.shapepipe.draw(sg2d, new Arc2D.Float(x, y, width, height,
                                                  startAngle, arcAngle,
                                                  Arc2D.OPEN));
    }

    public void drawPolyline(SunGraphics2D sg2d,
                             int[] xPoints, int[] yPoints,
                             int nPoints)
    {
        int[] nPointsArray = { nPoints };
        sg2d.loops.drawPolygonsLoop.DrawPolygons(sg2d, sg2d.getSurfaceData(),
                                                 xPoints, yPoints,
                                                 nPointsArray, 1,
                                                 sg2d.transX, sg2d.transY,
                                                 false);
    }

    public void drawPolygon(SunGraphics2D sg2d,
                            int[] xPoints, int[] yPoints,
                            int nPoints)
    {
        int[] nPointsArray = { nPoints };
        sg2d.loops.drawPolygonsLoop.DrawPolygons(sg2d, sg2d.getSurfaceData(),
                                                 xPoints, yPoints,
                                                 nPointsArray, 1,
                                                 sg2d.transX, sg2d.transY,
                                                 true);
    }

    public void fillRect(SunGraphics2D sg2d,
                         int x, int y, int width, int height)
    {
        sg2d.loops.fillRectLoop.FillRect(sg2d, sg2d.getSurfaceData(),
                                         x + sg2d.transX,
                                         y + sg2d.transY,
                                         width, height);
    }

    public void fillRoundRect(SunGraphics2D sg2d,
                              int x, int y, int width, int height,
                              int arcWidth, int arcHeight)
    {
        sg2d.shapepipe.fill(sg2d,
                            new RoundRectangle2D.Float(x, y, width, height,
                                                       arcWidth, arcHeight));
    }

    public void fillOval(SunGraphics2D sg2d,
                         int x, int y, int width, int height)
    {
        sg2d.shapepipe.fill(sg2d, new Ellipse2D.Float(x, y, width, height));
    }

    public void fillArc(SunGraphics2D sg2d,
                        int x, int y, int width, int height,
                        int startAngle, int arcAngle)
    {
        sg2d.shapepipe.fill(sg2d, new Arc2D.Float(x, y, width, height,
                                                  startAngle, arcAngle,
                                                  Arc2D.PIE));
    }

    public void fillPolygon(SunGraphics2D sg2d,
                            int[] xPoints, int[] yPoints,
                            int nPoints)
    {
        ShapeSpanIterator sr = getFillSSI(sg2d);

        try {
            sr.setOutputArea(sg2d.getCompClip());
            sr.appendPoly(xPoints, yPoints, nPoints, sg2d.transX, sg2d.transY);
            fillSpans(sg2d, sr);
        } finally {
            sr.dispose();
        }
    }


    public void draw(SunGraphics2D sg2d, Shape s) {
        if (sg2d.strokeState == SunGraphics2D.STROKE_THIN) {
            Path2D.Float p2df;
            int transX;
            int transY;
            if (sg2d.transformState <= SunGraphics2D.TRANSFORM_INT_TRANSLATE) {
                if (s instanceof Path2D.Float) {
                    p2df = (Path2D.Float)s;
                } else {
                    p2df = new Path2D.Float(s);
                }
                transX = sg2d.transX;
                transY = sg2d.transY;
            } else {
                p2df = new Path2D.Float(s, sg2d.transform);
                transX = 0;
                transY = 0;
            }
            sg2d.loops.drawPathLoop.DrawPath(sg2d, sg2d.getSurfaceData(),
                                             transX, transY, p2df);
            return;
        }

        if (sg2d.strokeState == SunGraphics2D.STROKE_CUSTOM) {
            fill(sg2d, sg2d.stroke.createStrokedShape(s));
            return;
        }

        ShapeSpanIterator sr = getStrokeSpans(sg2d, s);

        try {
            fillSpans(sg2d, sr);
        } finally {
            sr.dispose();
        }
    }

    /**
     * Return a ShapeSpanIterator instance that normalizes as
     * appropriate for a fill operation as per the settings in
     * the specified SunGraphics2D object.
     *
     * The ShapeSpanIterator will be newly constructed and ready
     * to start taking in geometry.
     *
     * Note that the caller is responsible for calling dispose()
     * on the returned ShapeSpanIterator inside a try/finally block:
     * <pre>
     *     ShapeSpanIterator ssi = LoopPipe.getFillSSI(sg2d);
     *     try {
     *         ssi.setOutputArea(clip);
     *         ssi.appendPath(...); // or appendPoly
     *         // iterate the spans from ssi and operate on them
     *     } finally {
     *         ssi.dispose();
     *     }
     * </pre>
     */
    public static ShapeSpanIterator getFillSSI(SunGraphics2D sg2d) {
        boolean adjust = ((sg2d.stroke instanceof BasicStroke) &&
                          sg2d.strokeHint != SunHints.INTVAL_STROKE_PURE);
        return new ShapeSpanIterator(adjust);
    }

    /*
     * Return a ShapeSpanIterator ready to iterate the spans of the wide
     * outline of Shape s using the attributes of the SunGraphics2D
     * object.
     *
     * The ShapeSpanIterator returned will be fully constructed
     * and filled with the geometry from the Shape widened by the
     * appropriate BasicStroke and normalization parameters taken
     * from the SunGraphics2D object and be ready to start returning
     * spans.
     *
     * Note that the caller is responsible for calling dispose()
     * on the returned ShapeSpanIterator inside a try/finally block.
     * <pre>
     *     ShapeSpanIterator ssi = LoopPipe.getStrokeSpans(sg2d, s);
     *     try {
     *         // iterate the spans from ssi and operate on them
     *     } finally {
     *         ssi.dispose();
     *     }
     * </pre>
     *
     * REMIND: This should return a SpanIterator interface object
     * but the caller needs to dispose() the object and that method
     * is only on ShapeSpanIterator.
     * TODO: Add a dispose() method to the SpanIterator interface.
     */
    public static ShapeSpanIterator getStrokeSpans(SunGraphics2D sg2d,
                                                   Shape s)
    {
        ShapeSpanIterator sr = new ShapeSpanIterator(false);

        try {
            final Region clip = sg2d.getCompClip();
            sr.setOutputArea(clip);
            sr.setRule(PathIterator.WIND_NON_ZERO);

            BasicStroke bs = (BasicStroke) sg2d.stroke;
            boolean thin = (sg2d.strokeState <= SunGraphics2D.STROKE_THINDASHED);
            boolean normalize =
                (sg2d.strokeHint != SunHints.INTVAL_STROKE_PURE);

            RenderEngine.strokeTo(s,
                                  sg2d.transform, clip, bs,
                                  thin, normalize, false, sr);
        } catch (Throwable t) {
            sr.dispose();
            sr = null;
            throw new InternalError("Unable to Stroke shape ("+
                                    t.getMessage()+")", t);
        }
        return sr;
    }

    public void fill(SunGraphics2D sg2d, Shape s) {
        if (sg2d.strokeState == SunGraphics2D.STROKE_THIN) {
            Path2D.Float p2df;
            int transX;
            int transY;
            if (sg2d.transformState <= SunGraphics2D.TRANSFORM_INT_TRANSLATE) {
                if (s instanceof Path2D.Float) {
                    p2df = (Path2D.Float)s;
                } else {
                    p2df = new Path2D.Float(s);
                }
                transX = sg2d.transX;
                transY = sg2d.transY;
            } else {
                p2df = new Path2D.Float(s, sg2d.transform);
                transX = 0;
                transY = 0;
            }
            sg2d.loops.fillPathLoop.FillPath(sg2d, sg2d.getSurfaceData(),
                                             transX, transY, p2df);
            return;
        }

        ShapeSpanIterator sr = getFillSSI(sg2d);
        try {
            sr.setOutputArea(sg2d.getCompClip());
            AffineTransform at =
                ((sg2d.transformState == SunGraphics2D.TRANSFORM_ISIDENT)
                 ? null
                 : sg2d.transform);
            sr.appendPath(s.getPathIterator(at));
            fillSpans(sg2d, sr);
        } finally {
            sr.dispose();
        }
    }

    private static void fillSpans(SunGraphics2D sg2d, SpanIterator si) {
        // REMIND: Eventually, the plan is that it will not be possible for
        // fs to be null since the FillSpans loop will be the fundamental
        // loop implemented for any destination type...
        if (sg2d.clipState == SunGraphics2D.CLIP_SHAPE) {
            si = sg2d.clipRegion.filter(si);
            // REMIND: Region.filter produces a Java-only iterator
            // with no native counterpart...
        } else {
            sun.java2d.loops.FillSpans fs = sg2d.loops.fillSpansLoop;
            if (fs != null) {
                fs.FillSpans(sg2d, sg2d.getSurfaceData(), si);
                return;
            }
        }
        int[] spanbox = new int[4];
        SurfaceData sd = sg2d.getSurfaceData();
        while (si.nextSpan(spanbox)) {
            int x = spanbox[0];
            int y = spanbox[1];
            int w = spanbox[2] - x;
            int h = spanbox[3] - y;
            sg2d.loops.fillRectLoop.FillRect(sg2d, sd, x, y, w, h);
        }
    }

    public void fillParallelogram(SunGraphics2D sg2d,
                                  double ux1, double uy1,
                                  double ux2, double uy2,
                                  double x, double y,
                                  double dx1, double dy1,
                                  double dx2, double dy2)
    {
        FillParallelogram fp = sg2d.loops.fillParallelogramLoop;
        fp.FillParallelogram(sg2d, sg2d.getSurfaceData(),
                             x, y, dx1, dy1, dx2, dy2);
    }

    public void drawParallelogram(SunGraphics2D sg2d,
                                  double ux1, double uy1,
                                  double ux2, double uy2,
                                  double x, double y,
                                  double dx1, double dy1,
                                  double dx2, double dy2,
                                  double lw1, double lw2)
    {
        DrawParallelogram dp = sg2d.loops.drawParallelogramLoop;
        dp.DrawParallelogram(sg2d, sg2d.getSurfaceData(),
                             x, y, dx1, dy1, dx2, dy2, lw1, lw2);
    }
}