Edit C:\Program Files\Java\jdk1.8.0_121\com\sun\openpisces\TransformingPathConsumer2D.java

/*
 * Copyright (c) 2007, 2013, Oracle and/or its affiliates. All rights reserved.
 * ORACLE PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 */

package com.sun.openpisces;

import com.sun.javafx.geom.PathConsumer2D;
import com.sun.javafx.geom.transform.BaseTransform;

public abstract class TransformingPathConsumer2D implements PathConsumer2D {
    protected PathConsumer2D out;

public TransformingPathConsumer2D(PathConsumer2D out) {
        this.out = out;
    }

public void setConsumer(PathConsumer2D out) {
        this.out = out;
    }
/*
    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 ScaleTranslateFilter(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);
        }
    }
*/

public static final class FilterSet {
        private TranslateFilter translater;
        private DeltaScaleFilter deltascaler;
        private ScaleTranslateFilter scaletranslater;
        private DeltaTransformFilter deltatransformer;
        private TransformFilter transformer;

public FilterSet() {
        }

public PathConsumer2D getConsumer(PathConsumer2D out,
                                          BaseTransform tx)
        {
            if (tx == null) {
                return out;
            }
            float Mxx = (float) tx.getMxx();
            float Mxy = (float) tx.getMxy();
            float Mxt = (float) tx.getMxt();
            float Myx = (float) tx.getMyx();
            float Myy = (float) tx.getMyy();
            float Myt = (float) tx.getMyt();
            if (Mxy == 0f && Myx == 0f) {
                if (Mxx == 1f && Myy == 1f) {
                    if (Mxt == 0f && Myt == 0f) {
                        return out;
                    } else {
                        if (translater == null) {
                            translater = new TranslateFilter(out, Mxt, Myt);
                        } else {
                            translater.set(Mxt, Myt);
                        }
                        return translater;
                    }
                } else {
                    if (Mxt == 0f && Myt == 0f) {
                        if (deltascaler == null) {
                            deltascaler = new DeltaScaleFilter(out, Mxx, Myy);
                        } else {
                            deltascaler.set(Mxx, Myy);
                        }
                        return deltascaler;
                    } else {
                        if (scaletranslater == null) {
                            scaletranslater =
                                new ScaleTranslateFilter(out, Mxx, Myy, Mxt, Myt);
                        } else {
                            scaletranslater.set(Mxx, Myy, Mxt, Myt);
                        }
                        return scaletranslater;
                    }
                }
            } else if (Mxt == 0f && Myt == 0f) {
                if (deltatransformer == null) {
                    deltatransformer =
                        new DeltaTransformFilter(out, Mxx, Mxy, Myx, Myy);
                } else {
                    deltatransformer.set(Mxx, Mxy, Myx, Myy);
                }
                return deltatransformer;
            } else {
                if (transformer == null) {
                    transformer =
                        new TransformFilter(out, Mxx, Mxy, Mxt, Myx, Myy, Myt);
                } else {
                    transformer.set(Mxx, Mxy, Mxt, Myx, Myy, Myt);
                }
                return transformer;
            }
        }
    }

static final class TranslateFilter extends TransformingPathConsumer2D {
        private float tx;
        private float ty;

TranslateFilter(PathConsumer2D out,
                        float tx, float ty)
        {
            super(out);
            set(tx, ty);
        }

public void set(float tx, float ty) {
            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 ScaleTranslateFilter extends TransformingPathConsumer2D {
        private float sx;
        private float sy;
        private float tx;
        private float ty;

ScaleTranslateFilter(PathConsumer2D out,
                    float sx, float sy, float tx, float ty)
        {
            super(out);
            set(sx, sy, tx, ty);
        }

public void set(float sx, float sy, float tx, float ty) {
            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 extends TransformingPathConsumer2D {
        private float Mxx;
        private float Mxy;
        private float Mxt;
        private float Myx;
        private float Myy;
        private float Myt;

TransformFilter(PathConsumer2D out,
                        float Mxx, float Mxy, float Mxt,
                        float Myx, float Myy, float Myt)
        {
            super(out);
            set(Mxx, Mxy, Mxt, Myx, Myy, Myt);
        }

public void set(float Mxx, float Mxy, float Mxt,
                        float Myx, float Myy, float Myt)
        {
            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 extends TransformingPathConsumer2D {
        private float sx;
        private float sy;

public DeltaScaleFilter(PathConsumer2D out, float Mxx, float Myy) {
            super(out);
            set(Mxx, Myy);
        }

public void set(float Mxx, float Myy) {
            sx = Mxx;
            sy = Myy;
        }

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 extends TransformingPathConsumer2D {
        private float Mxx;
        private float Mxy;
        private float Myx;
        private float Myy;

DeltaTransformFilter(PathConsumer2D out,
                             float Mxx, float Mxy,
                             float Myx, float Myy)
        {
            super(out);
            set(Mxx, Mxy, Myx, Myy);
        }

public void set(float Mxx, float Mxy,
                        float Myx, float Myy)
        {
            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;
        }
    }
}

Ms-Dos/Windows Unix Write backup

jsp File Browser version 1.2 by www.vonloesch.de