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 } |
|