/*

 * 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.pisces;

import sun.awt.geom.PathConsumer2D;

import java.awt.geom.AffineTransform;

final class TransformingPathConsumer2D {

    public static PathConsumer2D

        transformConsumer(PathConsumer2D out,

                          AffineTransform at)

    {

        if (at == null) {

            return out;

        }

        float Mxx = (float) at.getScaleX();

        float Mxy = (float) at.getShearX();

        float Mxt = (float) at.getTranslateX();

        float Myx = (float) at.getShearY();

        float Myy = (float) at.getScaleY();

        float Myt = (float) at.getTranslateY();

        if (Mxy == 0f && Myx == 0f) {

            if (Mxx == 1f && Myy == 1f) {

                if (Mxt == 0f && Myt == 0f) {

                    return out;

                } else {

                    return new TranslateFilter(out, Mxt, Myt);

                }

            } else {

                if (Mxt == 0f && Myt == 0f) {

                    return new DeltaScaleFilter(out, Mxx, Myy);

                } else {

                    return new ScaleFilter(out, Mxx, Myy, Mxt, Myt);

                }

            }

        } else if (Mxt == 0f && Myt == 0f) {

            return new DeltaTransformFilter(out, Mxx, Mxy, Myx, Myy);

        } else {

            return new TransformFilter(out, Mxx, Mxy, Mxt, Myx, Myy, Myt);

        }

    }

    public static PathConsumer2D

        deltaTransformConsumer(PathConsumer2D out,

                               AffineTransform at)

    {

        if (at == null) {

            return out;

        }

        float Mxx = (float) at.getScaleX();

        float Mxy = (float) at.getShearX();

        float Myx = (float) at.getShearY();

        float Myy = (float) at.getScaleY();

        if (Mxy == 0f && Myx == 0f) {

            if (Mxx == 1f && Myy == 1f) {

                return out;

            } else {

                return new DeltaScaleFilter(out, Mxx, Myy);

            }

        } else {

            return new DeltaTransformFilter(out, Mxx, Mxy, Myx, Myy);

        }

    }

    public static PathConsumer2D

        inverseDeltaTransformConsumer(PathConsumer2D out,

                                      AffineTransform at)

    {

        if (at == null) {

            return out;

        }

        float Mxx = (float) at.getScaleX();

        float Mxy = (float) at.getShearX();

        float Myx = (float) at.getShearY();

        float Myy = (float) at.getScaleY();

        if (Mxy == 0f && Myx == 0f) {

            if (Mxx == 1f && Myy == 1f) {

                return out;

            } else {

                return new DeltaScaleFilter(out, 1.0f/Mxx, 1.0f/Myy);

            }

        } else {

            float det = Mxx * Myy - Mxy * Myx;

            return new DeltaTransformFilter(out,

                                            Myy / det,

                                            -Mxy / det,

                                            -Myx / det,

                                            Mxx / det);

        }

    }

    static final class TranslateFilter implements PathConsumer2D {

        private final PathConsumer2D out;

        private final float tx;

        private final float ty;

        TranslateFilter(PathConsumer2D out,

                        float tx, float ty)

        {

            this.out = out;

            this.tx = tx;

            this.ty = ty;

        }

        public void moveTo(float x0, float y0) {

            out.moveTo(x0 + tx, y0 + ty);

        }

        public void lineTo(float x1, float y1) {

            out.lineTo(x1 + tx, y1 + ty);

        }

        public void quadTo(float x1, float y1,

                           float x2, float y2)

        {

            out.quadTo(x1 + tx, y1 + ty,

                       x2 + tx, y2 + ty);

        }

        public void curveTo(float x1, float y1,

                            float x2, float y2,

                            float x3, float y3)

        {

            out.curveTo(x1 + tx, y1 + ty,

                        x2 + tx, y2 + ty,

                        x3 + tx, y3 + ty);

        }

        public void closePath() {

            out.closePath();

        }

        public void pathDone() {

            out.pathDone();

        }

        public long getNativeConsumer() {

            return 0;

        }

    }

    static final class ScaleFilter implements PathConsumer2D {

        private final PathConsumer2D out;

        private final float sx;

        private final float sy;

        private final float tx;

        private final float ty;

        ScaleFilter(PathConsumer2D out,

                    float sx, float sy, float tx, float ty)

        {

            this.out = out;

            this.sx = sx;

            this.sy = sy;

            this.tx = tx;

            this.ty = ty;

        }

        public void moveTo(float x0, float y0) {

            out.moveTo(x0 * sx + tx, y0 * sy + ty);

        }

        public void lineTo(float x1, float y1) {

            out.lineTo(x1 * sx + tx, y1 * sy + ty);

        }

        public void quadTo(float x1, float y1,

                           float x2, float y2)

        {

            out.quadTo(x1 * sx + tx, y1 * sy + ty,

                       x2 * sx + tx, y2 * sy + ty);

        }

        public void curveTo(float x1, float y1,

                            float x2, float y2,

                            float x3, float y3)

        {

            out.curveTo(x1 * sx + tx, y1 * sy + ty,

                        x2 * sx + tx, y2 * sy + ty,

                        x3 * sx + tx, y3 * sy + ty);

        }

        public void closePath() {

            out.closePath();

        }

        public void pathDone() {

            out.pathDone();

        }

        public long getNativeConsumer() {

            return 0;

        }

    }

    static final class TransformFilter implements PathConsumer2D {

        private final PathConsumer2D out;

        private final float Mxx;

        private final float Mxy;

        private final float Mxt;

        private final float Myx;

        private final float Myy;

        private final float Myt;

        TransformFilter(PathConsumer2D out,

                        float Mxx, float Mxy, float Mxt,

                        float Myx, float Myy, float Myt)

        {

            this.out = out;

            this.Mxx = Mxx;

            this.Mxy = Mxy;

            this.Mxt = Mxt;

            this.Myx = Myx;

            this.Myy = Myy;

            this.Myt = Myt;

        }

        public void moveTo(float x0, float y0) {

            out.moveTo(x0 * Mxx + y0 * Mxy + Mxt,

                       x0 * Myx + y0 * Myy + Myt);

        }

        public void lineTo(float x1, float y1) {

            out.lineTo(x1 * Mxx + y1 * Mxy + Mxt,

                       x1 * Myx + y1 * Myy + Myt);

        }

        public void quadTo(float x1, float y1,

                           float x2, float y2)

        {

            out.quadTo(x1 * Mxx + y1 * Mxy + Mxt,

                       x1 * Myx + y1 * Myy + Myt,

                       x2 * Mxx + y2 * Mxy + Mxt,

                       x2 * Myx + y2 * Myy + Myt);

        }

        public void curveTo(float x1, float y1,

                            float x2, float y2,

                            float x3, float y3)

        {

            out.curveTo(x1 * Mxx + y1 * Mxy + Mxt,

                        x1 * Myx + y1 * Myy + Myt,

                        x2 * Mxx + y2 * Mxy + Mxt,

                        x2 * Myx + y2 * Myy + Myt,

                        x3 * Mxx + y3 * Mxy + Mxt,

                        x3 * Myx + y3 * Myy + Myt);

        }

        public void closePath() {

            out.closePath();

        }

        public void pathDone() {

            out.pathDone();

        }

        public long getNativeConsumer() {

            return 0;

        }

    }

    static final class DeltaScaleFilter implements PathConsumer2D {

        private final float sx, sy;

        private final PathConsumer2D out;

        public DeltaScaleFilter(PathConsumer2D out, float Mxx, float Myy) {

            sx = Mxx;

            sy = Myy;

            this.out = out;

        }

        public void moveTo(float x0, float y0) {

            out.moveTo(x0 * sx, y0 * sy);

        }

        public void lineTo(float x1, float y1) {

            out.lineTo(x1 * sx, y1 * sy);

        }

        public void quadTo(float x1, float y1,

                           float x2, float y2)

        {

            out.quadTo(x1 * sx, y1 * sy,

                       x2 * sx, y2 * sy);

        }

        public void curveTo(float x1, float y1,

                            float x2, float y2,

                            float x3, float y3)

        {

            out.curveTo(x1 * sx, y1 * sy,

                        x2 * sx, y2 * sy,

                        x3 * sx, y3 * sy);

        }

        public void closePath() {

            out.closePath();

        }

        public void pathDone() {

            out.pathDone();

        }

        public long getNativeConsumer() {

            return 0;

        }

    }

    static final class DeltaTransformFilter implements PathConsumer2D {

        private PathConsumer2D out;

        private final float Mxx;

        private final float Mxy;

        private final float Myx;

        private final float Myy;

        DeltaTransformFilter(PathConsumer2D out,

                             float Mxx, float Mxy,

                             float Myx, float Myy)

        {

            this.out = out;

            this.Mxx = Mxx;

            this.Mxy = Mxy;

            this.Myx = Myx;

            this.Myy = Myy;

        }

        public void moveTo(float x0, float y0) {

            out.moveTo(x0 * Mxx + y0 * Mxy,

                       x0 * Myx + y0 * Myy);

        }

        public void lineTo(float x1, float y1) {

            out.lineTo(x1 * Mxx + y1 * Mxy,

                       x1 * Myx + y1 * Myy);

        }

        public void quadTo(float x1, float y1,

                           float x2, float y2)

        {

            out.quadTo(x1 * Mxx + y1 * Mxy,

                       x1 * Myx + y1 * Myy,

                       x2 * Mxx + y2 * Mxy,

                       x2 * Myx + y2 * Myy);

        }

        public void curveTo(float x1, float y1,

                            float x2, float y2,

                            float x3, float y3)

        {

            out.curveTo(x1 * Mxx + y1 * Mxy,

                        x1 * Myx + y1 * Myy,

                        x2 * Mxx + y2 * Mxy,

                        x2 * Myx + y2 * Myy,

                        x3 * Mxx + y3 * Mxy,

                        x3 * Myx + y3 * Myy);

        }

        public void closePath() {

            out.closePath();

        }

        public void pathDone() {

            out.pathDone();

        }

        public long getNativeConsumer() {

            return 0;

        }

    }

}