1 /*

     2  * Copyright (c) 2007, 2011, Oracle and/or its affiliates. All rights reserved.

     3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

     4  *

     5  * This code is free software; you can redistribute it and/or modify it

     6  * under the terms of the GNU General Public License version 2 only, as

     7  * published by the Free Software Foundation.  Oracle designates this

     8  * particular file as subject to the "Classpath" exception as provided

     9  * by Oracle in the LICENSE file that accompanied this code.

    10  *

    11  * This code is distributed in the hope that it will be useful, but WITHOUT

    12  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

    13  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

    14  * version 2 for more details (a copy is included in the LICENSE file that

    15  * accompanied this code).

    16  *

    17  * You should have received a copy of the GNU General Public License version

    18  * 2 along with this work; if not, write to the Free Software Foundation,

    19  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

    20  *

    21  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

    22  * or visit www.oracle.com if you need additional information or have any

    23  * questions.

    24  */

    25 

    26 package sun.java2d.pisces;

    27 

    28 import sun.awt.geom.PathConsumer2D;

    29 import java.awt.geom.AffineTransform;

    30 

    31 final class TransformingPathConsumer2D {

    32     public static PathConsumer2D

    33         transformConsumer(PathConsumer2D out,

    34                           AffineTransform at)

    35     {

    36         if (at == null) {

    37             return out;

    38         }

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

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

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

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

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

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

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

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

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

    48                     return out;

    49                 } else {

    50                     return new TranslateFilter(out, Mxt, Myt);

    51                 }

    52             } else {

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

    54                     return new DeltaScaleFilter(out, Mxx, Myy);

    55                 } else {

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

    57                 }

    58             }

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

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

    61         } else {

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

    63         }

    64     }

    65 

    66     public static PathConsumer2D

    67         deltaTransformConsumer(PathConsumer2D out,

    68                                AffineTransform at)

    69     {

    70         if (at == null) {

    71             return out;

    72         }

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

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

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

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

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

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

    79                 return out;

    80             } else {

    81                 return new DeltaScaleFilter(out, Mxx, Myy);

    82             }

    83         } else {

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

    85         }

    86     }

    87 

    88     public static PathConsumer2D

    89         inverseDeltaTransformConsumer(PathConsumer2D out,

    90                                       AffineTransform at)

    91     {

    92         if (at == null) {

    93             return out;

    94         }

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

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

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

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

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

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

   101                 return out;

   102             } else {

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

   104             }

   105         } else {

   106             float det = Mxx * Myy - Mxy * Myx;

   107             return new DeltaTransformFilter(out,

   108                                             Myy / det,

   109                                             -Mxy / det,

   110                                             -Myx / det,

   111                                             Mxx / det);

   112         }

   113     }

   114 

   115     static final class TranslateFilter implements PathConsumer2D {

   116         private final PathConsumer2D out;

   117         private final float tx;

   118         private final float ty;

   119 

   120         TranslateFilter(PathConsumer2D out,

   121                         float tx, float ty)

   122         {

   123             this.out = out;

   124             this.tx = tx;

   125             this.ty = ty;

   126         }

   127 

   128         public void moveTo(float x0, float y0) {

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

   130         }

   131 

   132         public void lineTo(float x1, float y1) {

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

   134         }

   135 

   136         public void quadTo(float x1, float y1,

   137                            float x2, float y2)

   138         {

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

   140                        x2 + tx, y2 + ty);

   141         }

   142 

   143         public void curveTo(float x1, float y1,

   144                             float x2, float y2,

   145                             float x3, float y3)

   146         {

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

   148                         x2 + tx, y2 + ty,

   149                         x3 + tx, y3 + ty);

   150         }

   151 

   152         public void closePath() {

   153             out.closePath();

   154         }

   155 

   156         public void pathDone() {

   157             out.pathDone();

   158         }

   159 

   160         public long getNativeConsumer() {

   161             return 0;

   162         }

   163     }

   164 

   165     static final class ScaleFilter implements PathConsumer2D {

   166         private final PathConsumer2D out;

   167         private final float sx;

   168         private final float sy;

   169         private final float tx;

   170         private final float ty;

   171 

   172         ScaleFilter(PathConsumer2D out,

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

   174         {

   175             this.out = out;

   176             this.sx = sx;

   177             this.sy = sy;

   178             this.tx = tx;

   179             this.ty = ty;

   180         }

   181 

   182         public void moveTo(float x0, float y0) {

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

   184         }

   185 

   186         public void lineTo(float x1, float y1) {

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

   188         }

   189 

   190         public void quadTo(float x1, float y1,

   191                            float x2, float y2)

   192         {

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

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

   195         }

   196 

   197         public void curveTo(float x1, float y1,

   198                             float x2, float y2,

   199                             float x3, float y3)

   200         {

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

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

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

   204         }

   205 

   206         public void closePath() {

   207             out.closePath();

   208         }

   209 

   210         public void pathDone() {

   211             out.pathDone();

   212         }

   213 

   214         public long getNativeConsumer() {

   215             return 0;

   216         }

   217     }

   218 

   219     static final class TransformFilter implements PathConsumer2D {

   220         private final PathConsumer2D out;

   221         private final float Mxx;

   222         private final float Mxy;

   223         private final float Mxt;

   224         private final float Myx;

   225         private final float Myy;

   226         private final float Myt;

   227 

   228         TransformFilter(PathConsumer2D out,

   229                         float Mxx, float Mxy, float Mxt,

   230                         float Myx, float Myy, float Myt)

   231         {

   232             this.out = out;

   233             this.Mxx = Mxx;

   234             this.Mxy = Mxy;

   235             this.Mxt = Mxt;

   236             this.Myx = Myx;

   237             this.Myy = Myy;

   238             this.Myt = Myt;

   239         }

   240 

   241         public void moveTo(float x0, float y0) {

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

   243                        x0 * Myx + y0 * Myy + Myt);

   244         }

   245 

   246         public void lineTo(float x1, float y1) {

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

   248                        x1 * Myx + y1 * Myy + Myt);

   249         }

   250 

   251         public void quadTo(float x1, float y1,

   252                            float x2, float y2)

   253         {

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

   255                        x1 * Myx + y1 * Myy + Myt,

   256                        x2 * Mxx + y2 * Mxy + Mxt,

   257                        x2 * Myx + y2 * Myy + Myt);

   258         }

   259 

   260         public void curveTo(float x1, float y1,

   261                             float x2, float y2,

   262                             float x3, float y3)

   263         {

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

   265                         x1 * Myx + y1 * Myy + Myt,

   266                         x2 * Mxx + y2 * Mxy + Mxt,

   267                         x2 * Myx + y2 * Myy + Myt,

   268                         x3 * Mxx + y3 * Mxy + Mxt,

   269                         x3 * Myx + y3 * Myy + Myt);

   270         }

   271 

   272         public void closePath() {

   273             out.closePath();

   274         }

   275 

   276         public void pathDone() {

   277             out.pathDone();

   278         }

   279 

   280         public long getNativeConsumer() {

   281             return 0;

   282         }

   283     }

   284 

   285     static final class DeltaScaleFilter implements PathConsumer2D {

   286         private final float sx, sy;

   287         private final PathConsumer2D out;

   288 

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

   290             sx = Mxx;

   291             sy = Myy;

   292             this.out = out;

   293         }

   294 

   295         public void moveTo(float x0, float y0) {

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

   297         }

   298 

   299         public void lineTo(float x1, float y1) {

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

   301         }

   302 

   303         public void quadTo(float x1, float y1,

   304                            float x2, float y2)

   305         {

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

   307                        x2 * sx, y2 * sy);

   308         }

   309 

   310         public void curveTo(float x1, float y1,

   311                             float x2, float y2,

   312                             float x3, float y3)

   313         {

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

   315                         x2 * sx, y2 * sy,

   316                         x3 * sx, y3 * sy);

   317         }

   318 

   319         public void closePath() {

   320             out.closePath();

   321         }

   322 

   323         public void pathDone() {

   324             out.pathDone();

   325         }

   326 

   327         public long getNativeConsumer() {

   328             return 0;

   329         }

   330     }

   331 

   332     static final class DeltaTransformFilter implements PathConsumer2D {

   333         private PathConsumer2D out;

   334         private final float Mxx;

   335         private final float Mxy;

   336         private final float Myx;

   337         private final float Myy;

   338 

   339         DeltaTransformFilter(PathConsumer2D out,

   340                              float Mxx, float Mxy,

   341                              float Myx, float Myy)

   342         {

   343             this.out = out;

   344             this.Mxx = Mxx;

   345             this.Mxy = Mxy;

   346             this.Myx = Myx;

   347             this.Myy = Myy;

   348         }

   349 

   350         public void moveTo(float x0, float y0) {

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

   352                        x0 * Myx + y0 * Myy);

   353         }

   354 

   355         public void lineTo(float x1, float y1) {

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

   357                        x1 * Myx + y1 * Myy);

   358         }

   359 

   360         public void quadTo(float x1, float y1,

   361                            float x2, float y2)

   362         {

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

   364                        x1 * Myx + y1 * Myy,

   365                        x2 * Mxx + y2 * Mxy,

   366                        x2 * Myx + y2 * Myy);

   367         }

   368 

   369         public void curveTo(float x1, float y1,

   370                             float x2, float y2,

   371                             float x3, float y3)

   372         {

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

   374                         x1 * Myx + y1 * Myy,

   375                         x2 * Mxx + y2 * Mxy,

   376                         x2 * Myx + y2 * Myy,

   377                         x3 * Mxx + y3 * Mxy,

   378                         x3 * Myx + y3 * Myy);

   379         }

   380 

   381         public void closePath() {

   382             out.closePath();

   383         }

   384 

   385         public void pathDone() {

   386             out.pathDone();

   387         }

   388 

   389         public long getNativeConsumer() {

   390             return 0;

   391         }

   392     }

   393 }