History

My first initial commit with all of mine experimental changes.

Dmitry Kabak (userdima committed 13 years ago

Commit d37b88d1 parent 3f5b46618352 files · +2598093 −-8690Browse files

Showing the changes to java/pkg/sun/java2d/pisces/TransformingPathConsumer2D.java (1 of 18352 files). Show all

Unified · Split

java/pkg/sun/java2d/pisces/TransformingPathConsumer2D.java+393−0
@@ -0,0 +1,393 @@
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+}