1 /* 2 * Copyright (c) 2007, 2017, 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 com.sun.marlin; 27 28 import com.sun.javafx.geom.Path2D; 29 import com.sun.javafx.geom.transform.BaseTransform; 30 31 public final class DTransformingPathConsumer2D { 32 33 DTransformingPathConsumer2D() { 34 // used by DRendererContext 35 } 36 37 // recycled DPathConsumer2D instance from wrapPath2d() 38 private final Path2DWrapper wp_Path2DWrapper = new Path2DWrapper(); 39 40 // recycled DPathConsumer2D instances from deltaTransformConsumer() 41 private final DeltaScaleFilter dt_DeltaScaleFilter = new DeltaScaleFilter(); 42 private final DeltaTransformFilter dt_DeltaTransformFilter = new DeltaTransformFilter(); 43 44 public DPathConsumer2D wrapPath2d(Path2D p2d) 45 { 46 return wp_Path2DWrapper.init(p2d); 47 } 48 49 public DPathConsumer2D deltaTransformConsumer(DPathConsumer2D out, 50 BaseTransform at) 51 { 52 if (at == null) { 53 return out; 54 } 55 double mxx = at.getMxx(); 56 double mxy = at.getMxy(); 57 double myx = at.getMyx(); 58 double myy = at.getMyy(); 59 60 if (mxy == 0.0d && myx == 0.0d) { 61 if (mxx == 1.0d && myy == 1.0d) { 62 return out; 63 } else { 64 return dt_DeltaScaleFilter.init(out, mxx, myy); 65 } 66 } else { 67 return dt_DeltaTransformFilter.init(out, mxx, mxy, myx, myy); 68 } 69 } 70 71 // recycled DPathConsumer2D instances from inverseDeltaTransformConsumer() 72 private final DeltaScaleFilter iv_DeltaScaleFilter = new DeltaScaleFilter(); 73 private final DeltaTransformFilter iv_DeltaTransformFilter = new DeltaTransformFilter(); 74 75 public DPathConsumer2D inverseDeltaTransformConsumer(DPathConsumer2D out, 76 BaseTransform at) 77 { 78 if (at == null) { 79 return out; 80 } 81 double mxx = at.getMxx(); 82 double mxy = at.getMxy(); 83 double myx = at.getMyx(); 84 double myy = at.getMyy(); 85 86 if (mxy == 0.0d && myx == 0.0d) { 87 if (mxx == 1.0d && myy == 1.0d) { 88 return out; 89 } else { 90 return iv_DeltaScaleFilter.init(out, 1.0d/mxx, 1.0d/myy); 91 } 92 } else { 93 double det = mxx * myy - mxy * myx; 94 return iv_DeltaTransformFilter.init(out, 95 myy / det, 96 -mxy / det, 97 -myx / det, 98 mxx / det); 99 } 100 } 101 102 static final class DeltaScaleFilter implements DPathConsumer2D { 103 private DPathConsumer2D out; 104 private double sx, sy; 105 106 DeltaScaleFilter() {} 107 108 DeltaScaleFilter init(DPathConsumer2D out, 109 double mxx, double myy) 110 { 111 this.out = out; 112 sx = mxx; 113 sy = myy; 114 return this; // fluent API 115 } 116 117 @Override 118 public void moveTo(double x0, double y0) { 119 out.moveTo(x0 * sx, y0 * sy); 120 } 121 122 @Override 123 public void lineTo(double x1, double y1) { 124 out.lineTo(x1 * sx, y1 * sy); 125 } 126 127 @Override 128 public void quadTo(double x1, double y1, 129 double x2, double y2) 130 { 131 out.quadTo(x1 * sx, y1 * sy, 132 x2 * sx, y2 * sy); 133 } 134 135 @Override 136 public void curveTo(double x1, double y1, 137 double x2, double y2, 138 double x3, double y3) 139 { 140 out.curveTo(x1 * sx, y1 * sy, 141 x2 * sx, y2 * sy, 142 x3 * sx, y3 * sy); 143 } 144 145 @Override 146 public void closePath() { 147 out.closePath(); 148 } 149 150 @Override 151 public void pathDone() { 152 out.pathDone(); 153 } 154 } 155 156 static final class DeltaTransformFilter implements DPathConsumer2D { 157 private DPathConsumer2D out; 158 private double mxx, mxy, myx, myy; 159 160 DeltaTransformFilter() {} 161 162 DeltaTransformFilter init(DPathConsumer2D out, 163 double mxx, double mxy, 164 double myx, double myy) 165 { 166 this.out = out; 167 this.mxx = mxx; 168 this.mxy = mxy; 169 this.myx = myx; 170 this.myy = myy; 171 return this; // fluent API 172 } 173 174 @Override 175 public void moveTo(double x0, double y0) { 176 out.moveTo(x0 * mxx + y0 * mxy, 177 x0 * myx + y0 * myy); 178 } 179 180 @Override 181 public void lineTo(double x1, double y1) { 182 out.lineTo(x1 * mxx + y1 * mxy, 183 x1 * myx + y1 * myy); 184 } 185 186 @Override 187 public void quadTo(double x1, double y1, 188 double x2, double y2) 189 { 190 out.quadTo(x1 * mxx + y1 * mxy, 191 x1 * myx + y1 * myy, 192 x2 * mxx + y2 * mxy, 193 x2 * myx + y2 * myy); 194 } 195 196 @Override 197 public void curveTo(double x1, double y1, 198 double x2, double y2, 199 double x3, double y3) 200 { 201 out.curveTo(x1 * mxx + y1 * mxy, 202 x1 * myx + y1 * myy, 203 x2 * mxx + y2 * mxy, 204 x2 * myx + y2 * myy, 205 x3 * mxx + y3 * mxy, 206 x3 * myx + y3 * myy); 207 } 208 209 @Override 210 public void closePath() { 211 out.closePath(); 212 } 213 214 @Override 215 public void pathDone() { 216 out.pathDone(); 217 } 218 } 219 static final class Path2DWrapper implements DPathConsumer2D { 220 private Path2D p2d; 221 222 Path2DWrapper() {} 223 224 Path2DWrapper init(Path2D p2d) { 225 this.p2d = p2d; 226 return this; 227 } 228 229 @Override 230 public void moveTo(double x0, double y0) { 231 p2d.moveTo((float)x0, (float)y0); 232 } 233 234 @Override 235 public void lineTo(double x1, double y1) { 236 p2d.lineTo((float)x1, (float)y1); 237 } 238 239 @Override 240 public void closePath() { 241 p2d.closePath(); 242 } 243 244 @Override 245 public void pathDone() {} 246 247 @Override 248 public void curveTo(double x1, double y1, 249 double x2, double y2, 250 double x3, double y3) 251 { 252 p2d.curveTo((float)x1, (float)y1, (float)x2, (float)y2, 253 (float)x3, (float)y3); 254 } 255 256 @Override 257 public void quadTo(double x1, double y1, double x2, double y2) { 258 p2d.quadTo((float)x1, (float)y1, (float)x2, (float)y2); 259 } 260 } 261 }