1 Clazz.declarePackage ("java.awt.geom");
\r
2 Clazz.load (["java.awt.Shape", "java.awt.geom.PathIterator"], "java.awt.geom.Path2D", ["java.lang.Double", "$.IllegalArgumentException", "java.util.Arrays", "java.awt.geom.FlatteningPathIterator", "$.IllegalPathStateException", "$.Point2D", "$.Rectangle2D", "jssun.awt.geom.Curve"], function () {
\r
3 c$ = Clazz.decorateAsClass (function () {
\r
4 this.pointTypes = null;
\r
7 this.windingRule = 0;
\r
8 Clazz.instantialize (this, arguments);
\r
9 }, java.awt.geom, "Path2D", null, [java.awt.Shape, Cloneable]);
\r
10 Clazz.makeConstructor (c$,
\r
13 Clazz.makeConstructor (c$,
\r
14 function (rule, initialTypes) {
\r
15 this.setWindingRule (rule);
\r
16 this.pointTypes = Clazz.newByteArray (initialTypes, 0);
\r
18 Clazz.defineMethod (c$, "closePath",
\r
20 if (this.numTypes == 0 || this.pointTypes[this.numTypes - 1] != 4) {
\r
21 this.needRoom (true, 0);
\r
22 this.pointTypes[this.numTypes++] = 4;
\r
24 Clazz.defineMethod (c$, "append",
\r
25 function (s, connect) {
\r
26 this.append (s.getPathIterator (null), connect);
\r
27 }, "java.awt.Shape,~B");
\r
28 Clazz.defineMethod (c$, "getWindingRule",
\r
30 return this.windingRule;
\r
32 Clazz.defineMethod (c$, "setWindingRule",
\r
34 if (rule != 0 && rule != 1) {
\r
35 throw new IllegalArgumentException ("winding rule must be WIND_EVEN_ODD or WIND_NON_ZERO");
\r
36 }this.windingRule = rule;
\r
38 Clazz.defineMethod (c$, "getCurrentPoint",
\r
40 var index = this.numCoords;
\r
41 if (this.numTypes < 1 || index < 1) {
\r
43 }if (this.pointTypes[this.numTypes - 1] == 4) {
\r
44 loop : for (var i = this.numTypes - 2; i > 0; i--) {
\r
45 switch (this.pointTypes[i]) {
\r
61 }return this.getPoint (index - 2);
\r
63 Clazz.defineMethod (c$, "reset",
\r
65 this.numTypes = this.numCoords = 0;
\r
67 Clazz.defineMethod (c$, "createTransformedShape",
\r
69 var p2d = this.clone ();
\r
73 }, "java.awt.geom.AffineTransform");
\r
74 Clazz.overrideMethod (c$, "getBounds",
\r
76 return this.getBounds2D ().getBounds ();
\r
78 c$.contains = Clazz.defineMethod (c$, "contains",
\r
79 function (pi, x, y) {
\r
80 if (x * 0.0 + y * 0.0 == 0.0) {
\r
81 var mask = (pi.getWindingRule () == 1 ? -1 : 1);
\r
82 var cross = jssun.awt.geom.Curve.pointCrossingsForPath (pi, x, y);
\r
83 return ((cross & mask) != 0);
\r
86 }}, "java.awt.geom.PathIterator,~N,~N");
\r
87 c$.contains = Clazz.defineMethod (c$, "contains",
\r
89 return java.awt.geom.Path2D.contains (pi, p.getX (), p.getY ());
\r
90 }, "java.awt.geom.PathIterator,java.awt.geom.Point2D");
\r
91 Clazz.defineMethod (c$, "contains",
\r
93 if (x * 0.0 + y * 0.0 == 0.0) {
\r
94 if (this.numTypes < 2) {
\r
96 }var mask = (this.windingRule == 1 ? -1 : 1);
\r
97 return ((this.pointCrossings (x, y) & mask) != 0);
\r
101 Clazz.defineMethod (c$, "contains",
\r
103 return this.contains (p.getX (), p.getY ());
\r
104 }, "java.awt.geom.Point2D");
\r
105 c$.contains = Clazz.defineMethod (c$, "contains",
\r
106 function (pi, x, y, w, h) {
\r
107 if (java.lang.Double.isNaN (x + w) || java.lang.Double.isNaN (y + h)) {
\r
109 }if (w <= 0 || h <= 0) {
\r
111 }var mask = (pi.getWindingRule () == 1 ? -1 : 2);
\r
112 var crossings = jssun.awt.geom.Curve.rectCrossingsForPath (pi, x, y, x + w, y + h);
\r
113 return (crossings != -2147483648 && (crossings & mask) != 0);
\r
114 }, "java.awt.geom.PathIterator,~N,~N,~N,~N");
\r
115 c$.contains = Clazz.defineMethod (c$, "contains",
\r
117 return java.awt.geom.Path2D.contains (pi, r.getX (), r.getY (), r.getWidth (), r.getHeight ());
\r
118 }, "java.awt.geom.PathIterator,java.awt.geom.Rectangle2D");
\r
119 Clazz.defineMethod (c$, "contains",
\r
120 function (x, y, w, h) {
\r
121 if (java.lang.Double.isNaN (x + w) || java.lang.Double.isNaN (y + h)) {
\r
123 }if (w <= 0 || h <= 0) {
\r
125 }var mask = (this.windingRule == 1 ? -1 : 2);
\r
126 var crossings = this.rectCrossings (x, y, x + w, y + h);
\r
127 return (crossings != -2147483648 && (crossings & mask) != 0);
\r
129 Clazz.defineMethod (c$, "contains",
\r
131 return this.contains (r.getX (), r.getY (), r.getWidth (), r.getHeight ());
\r
132 }, "java.awt.geom.Rectangle2D");
\r
133 c$.intersects = Clazz.defineMethod (c$, "intersects",
\r
134 function (pi, x, y, w, h) {
\r
135 if (java.lang.Double.isNaN (x + w) || java.lang.Double.isNaN (y + h)) {
\r
137 }if (w <= 0 || h <= 0) {
\r
139 }var mask = (pi.getWindingRule () == 1 ? -1 : 2);
\r
140 var crossings = jssun.awt.geom.Curve.rectCrossingsForPath (pi, x, y, x + w, y + h);
\r
141 return (crossings == -2147483648 || (crossings & mask) != 0);
\r
142 }, "java.awt.geom.PathIterator,~N,~N,~N,~N");
\r
143 c$.intersects = Clazz.defineMethod (c$, "intersects",
\r
145 return java.awt.geom.Path2D.intersects (pi, r.getX (), r.getY (), r.getWidth (), r.getHeight ());
\r
146 }, "java.awt.geom.PathIterator,java.awt.geom.Rectangle2D");
\r
147 Clazz.defineMethod (c$, "intersects",
\r
148 function (x, y, w, h) {
\r
149 if (java.lang.Double.isNaN (x + w) || java.lang.Double.isNaN (y + h)) {
\r
151 }if (w <= 0 || h <= 0) {
\r
153 }var mask = (this.windingRule == 1 ? -1 : 2);
\r
154 var crossings = this.rectCrossings (x, y, x + w, y + h);
\r
155 return (crossings == -2147483648 || (crossings & mask) != 0);
\r
157 Clazz.defineMethod (c$, "intersects",
\r
159 return this.intersects (r.getX (), r.getY (), r.getWidth (), r.getHeight ());
\r
160 }, "java.awt.geom.Rectangle2D");
\r
161 Clazz.overrideMethod (c$, "getPathIterator",
\r
162 function (at, flatness) {
\r
163 return new java.awt.geom.FlatteningPathIterator (this.getPathIterator (at), flatness);
\r
164 }, "java.awt.geom.AffineTransform,~N");
\r
165 Clazz.pu$h(self.c$);
\r
166 c$ = Clazz.decorateAsClass (function () {
\r
170 Clazz.instantialize (this, arguments);
\r
171 }, java.awt.geom.Path2D, "Iterator", null, java.awt.geom.PathIterator);
\r
172 Clazz.makeConstructor (c$,
\r
175 }, "java.awt.geom.Path2D");
\r
176 Clazz.overrideMethod (c$, "getWindingRule",
\r
178 return this.path.getWindingRule ();
\r
180 Clazz.overrideMethod (c$, "isDone",
\r
182 return (this.typeIdx >= this.path.numTypes);
\r
184 Clazz.overrideMethod (c$, "next",
\r
186 var a = this.path.pointTypes[this.typeIdx++];
\r
187 this.pointIdx += java.awt.geom.Path2D.Iterator.curvecoords[a];
\r
189 Clazz.defineStatics (c$,
\r
190 "curvecoords", Clazz.newIntArray (-1, [2, 2, 4, 6, 0]));
\r
192 Clazz.pu$h(self.c$);
\r
193 c$ = Clazz.decorateAsClass (function () {
\r
194 this.floatCoords = null;
\r
195 Clazz.instantialize (this, arguments);
\r
196 }, java.awt.geom.Path2D, "Float", java.awt.geom.Path2D);
\r
197 Clazz.makeConstructor (c$,
\r
199 this.construct (1, 20);
\r
201 Clazz.makeConstructor (c$,
\r
203 this.construct (a, 20);
\r
205 Clazz.makeConstructor (c$,
\r
207 Clazz.superConstructor (this, java.awt.geom.Path2D.Float, []);
\r
208 this.setWindingRule (a);
\r
209 this.pointTypes = Clazz.newByteArray (b, 0);
\r
210 this.floatCoords = Clazz.newFloatArray (b * 2, 0);
\r
212 Clazz.makeConstructor (c$,
\r
214 this.construct (a, null);
\r
215 }, "java.awt.Shape");
\r
216 Clazz.makeConstructor (c$,
\r
218 Clazz.superConstructor (this, java.awt.geom.Path2D.Float, []);
\r
219 this.setPath (a, b);
\r
220 }, "java.awt.Shape,java.awt.geom.AffineTransform");
\r
221 Clazz.defineMethod (c$, "setPath",
\r
223 if (Clazz.instanceOf (a, java.awt.geom.Path2D)) {
\r
225 this.setWindingRule (c.windingRule);
\r
226 this.numTypes = c.numTypes;
\r
227 this.pointTypes = java.util.Arrays.copyOf (c.pointTypes, c.pointTypes.length);
\r
228 this.numCoords = c.numCoords;
\r
229 this.floatCoords = c.cloneCoordsFloat (b);
\r
231 var c = a.getPathIterator (b);
\r
232 this.setWindingRule (c.getWindingRule ());
\r
233 this.pointTypes = Clazz.newByteArray (20, 0);
\r
234 this.floatCoords = Clazz.newFloatArray (40, 0);
\r
235 this.append (c, false);
\r
236 }}, "java.awt.Shape,java.awt.geom.AffineTransform");
\r
237 Clazz.defineMethod (c$, "cloneCoordsFloat",
\r
241 b = java.util.Arrays.copyOf (this.floatCoords, this.floatCoords.length);
\r
243 b = Clazz.newFloatArray (this.floatCoords.length, 0);
\r
244 a.transform (this.floatCoords, 0, b, 0, Clazz.doubleToInt (this.numCoords / 2));
\r
246 }, "java.awt.geom.AffineTransform");
\r
247 Clazz.overrideMethod (c$, "cloneCoordsDouble",
\r
249 var b = Clazz.newDoubleArray (this.floatCoords.length, 0);
\r
251 for (var c = 0; c < this.numCoords; c++) {
\r
252 b[c] = this.floatCoords[c];
\r
255 a.transform (this.floatCoords, 0, b, 0, Clazz.doubleToInt (this.numCoords / 2));
\r
257 }, "java.awt.geom.AffineTransform");
\r
258 Clazz.defineMethod (c$, "append",
\r
261 if (typeof pi == "number") {
\r
262 this.floatCoords[this.numCoords++] = pi;
\r
263 this.floatCoords[this.numCoords++] = connect;
\r
266 }var c = Clazz.newFloatArray (6, 0);
\r
267 while (!a.isDone ()) {
\r
268 switch (a.currentSegment (c)) {
\r
270 if (!b || this.numTypes < 1 || this.numCoords < 1) {
\r
271 this.moveTo (c[0], c[1]);
\r
273 }if (this.pointTypes[this.numTypes - 1] != 4 && this.floatCoords[this.numCoords - 2] == c[0] && this.floatCoords[this.numCoords - 1] == c[1]) {
\r
276 this.lineTo (c[0], c[1]);
\r
279 this.quadTo (c[0], c[1], c[2], c[3]);
\r
282 this.curveTo (c[0], c[1], c[2], c[3], c[4], c[5]);
\r
291 }, "java.awt.geom.PathIterator,~B");
\r
292 Clazz.overrideMethod (c$, "getPoint",
\r
294 return new java.awt.geom.Point2D.Float (this.floatCoords[a], this.floatCoords[a + 1]);
\r
296 Clazz.overrideMethod (c$, "needRoom",
\r
298 if (a && this.numTypes == 0) {
\r
299 throw new java.awt.geom.IllegalPathStateException ("missing initial moveto in path definition");
\r
300 }var c = this.pointTypes.length;
\r
301 if (this.numTypes >= c) {
\r
305 }this.pointTypes = java.util.Arrays.copyOf (this.pointTypes, c + d);
\r
306 }c = this.floatCoords.length;
\r
307 if (this.numCoords + b > c) {
\r
313 }this.floatCoords = java.util.Arrays.copyOf (this.floatCoords, c + d);
\r
315 Clazz.defineMethod (c$, "moveTo",
\r
317 if (this.numTypes > 0 && this.pointTypes[this.numTypes - 1] == 0) {
\r
318 this.floatCoords[this.numCoords - 2] = a;
\r
319 this.floatCoords[this.numCoords - 1] = b;
\r
321 this.needRoom (false, 2);
\r
322 this.pointTypes[this.numTypes++] = 0;
\r
323 this.floatCoords[this.numCoords++] = a;
\r
324 this.floatCoords[this.numCoords++] = b;
\r
326 Clazz.defineMethod (c$, "moveTo",
\r
328 if (this.numTypes > 0 && this.pointTypes[this.numTypes - 1] == 0) {
\r
329 this.floatCoords[this.numCoords - 2] = a;
\r
330 this.floatCoords[this.numCoords - 1] = b;
\r
332 this.needRoom (false, 2);
\r
333 this.pointTypes[this.numTypes++] = 0;
\r
334 this.floatCoords[this.numCoords++] = a;
\r
335 this.floatCoords[this.numCoords++] = b;
\r
337 Clazz.defineMethod (c$, "lineTo",
\r
339 this.needRoom (true, 2);
\r
340 this.pointTypes[this.numTypes++] = 1;
\r
341 this.floatCoords[this.numCoords++] = a;
\r
342 this.floatCoords[this.numCoords++] = b;
\r
344 Clazz.defineMethod (c$, "lineTo",
\r
346 this.needRoom (true, 2);
\r
347 this.pointTypes[this.numTypes++] = 1;
\r
348 this.floatCoords[this.numCoords++] = a;
\r
349 this.floatCoords[this.numCoords++] = b;
\r
351 Clazz.defineMethod (c$, "quadTo",
\r
352 function (a, b, c, d) {
\r
353 this.needRoom (true, 4);
\r
354 this.pointTypes[this.numTypes++] = 2;
\r
355 this.floatCoords[this.numCoords++] = a;
\r
356 this.floatCoords[this.numCoords++] = b;
\r
357 this.floatCoords[this.numCoords++] = c;
\r
358 this.floatCoords[this.numCoords++] = d;
\r
360 Clazz.defineMethod (c$, "quadTo",
\r
361 function (a, b, c, d) {
\r
362 this.needRoom (true, 4);
\r
363 this.pointTypes[this.numTypes++] = 2;
\r
364 this.floatCoords[this.numCoords++] = a;
\r
365 this.floatCoords[this.numCoords++] = b;
\r
366 this.floatCoords[this.numCoords++] = c;
\r
367 this.floatCoords[this.numCoords++] = d;
\r
369 Clazz.defineMethod (c$, "curveTo",
\r
370 function (a, b, c, d, e, f) {
\r
371 this.needRoom (true, 6);
\r
372 this.pointTypes[this.numTypes++] = 3;
\r
373 this.floatCoords[this.numCoords++] = a;
\r
374 this.floatCoords[this.numCoords++] = b;
\r
375 this.floatCoords[this.numCoords++] = c;
\r
376 this.floatCoords[this.numCoords++] = d;
\r
377 this.floatCoords[this.numCoords++] = e;
\r
378 this.floatCoords[this.numCoords++] = f;
\r
379 }, "~N,~N,~N,~N,~N,~N");
\r
380 Clazz.defineMethod (c$, "curveTo",
\r
381 function (a, b, c, d, e, f) {
\r
382 this.needRoom (true, 6);
\r
383 this.pointTypes[this.numTypes++] = 3;
\r
384 this.floatCoords[this.numCoords++] = a;
\r
385 this.floatCoords[this.numCoords++] = b;
\r
386 this.floatCoords[this.numCoords++] = c;
\r
387 this.floatCoords[this.numCoords++] = d;
\r
388 this.floatCoords[this.numCoords++] = e;
\r
389 this.floatCoords[this.numCoords++] = f;
\r
390 }, "~N,~N,~N,~N,~N,~N");
\r
391 Clazz.overrideMethod (c$, "pointCrossings",
\r
399 var i = this.floatCoords;
\r
404 for (var l = 1; l < this.numTypes; l++) {
\r
405 switch (this.pointTypes[l]) {
\r
408 j += jssun.awt.geom.Curve.pointCrossingsForLine (a, b, e, f, c, d);
\r
413 j += jssun.awt.geom.Curve.pointCrossingsForLine (a, b, e, f, g = i[k++], h = i[k++]);
\r
418 j += jssun.awt.geom.Curve.pointCrossingsForQuad (a, b, e, f, i[k++], i[k++], g = i[k++], h = i[k++], 0);
\r
423 j += jssun.awt.geom.Curve.pointCrossingsForCubic (a, b, e, f, i[k++], i[k++], i[k++], i[k++], g = i[k++], h = i[k++], 0);
\r
429 j += jssun.awt.geom.Curve.pointCrossingsForLine (a, b, e, f, c, d);
\r
436 j += jssun.awt.geom.Curve.pointCrossingsForLine (a, b, e, f, c, d);
\r
439 Clazz.overrideMethod (c$, "rectCrossings",
\r
440 function (a, b, c, d) {
\r
441 var e = this.floatCoords;
\r
452 for (var n = 1; l != -2147483648 && n < this.numTypes; n++) {
\r
453 switch (this.pointTypes[n]) {
\r
455 if (f != h || g != i) {
\r
456 l = jssun.awt.geom.Curve.rectCrossingsForLine (l, a, b, c, d, f, g, h, i);
\r
461 l = jssun.awt.geom.Curve.rectCrossingsForLine (l, a, b, c, d, f, g, j = e[m++], k = e[m++]);
\r
466 l = jssun.awt.geom.Curve.rectCrossingsForQuad (l, a, b, c, d, f, g, e[m++], e[m++], j = e[m++], k = e[m++], 0);
\r
471 l = jssun.awt.geom.Curve.rectCrossingsForCubic (l, a, b, c, d, f, g, e[m++], e[m++], e[m++], e[m++], j = e[m++], k = e[m++], 0);
\r
476 if (f != h || g != i) {
\r
477 l = jssun.awt.geom.Curve.rectCrossingsForLine (l, a, b, c, d, f, g, h, i);
\r
483 if (l != -2147483648 && (f != h || g != i)) {
\r
484 l = jssun.awt.geom.Curve.rectCrossingsForLine (l, a, b, c, d, f, g, h, i);
\r
487 Clazz.overrideMethod (c$, "transform",
\r
489 a.transform (this.floatCoords, 0, this.floatCoords, 0, Clazz.doubleToInt (this.numCoords / 2));
\r
490 }, "java.awt.geom.AffineTransform");
\r
491 Clazz.overrideMethod (c$, "getBounds2D",
\r
497 var e = this.numCoords;
\r
499 b = d = this.floatCoords[--e];
\r
500 a = c = this.floatCoords[--e];
\r
502 var f = this.floatCoords[--e];
\r
503 var g = this.floatCoords[--e];
\r
510 a = b = c = d = 0.0;
\r
511 }return new java.awt.geom.Rectangle2D.Float (a, b, c - a, d - b);
\r
513 Clazz.defineMethod (c$, "getPathIterator",
\r
516 return new java.awt.geom.Path2D.Float.CopyIterator (this);
\r
518 return new java.awt.geom.Path2D.Float.TxIterator (this, a);
\r
519 }}, "java.awt.geom.AffineTransform");
\r
520 Clazz.overrideMethod (c$, "clone",
\r
522 return new java.awt.geom.Path2D.Float (this);
\r
524 Clazz.pu$h(self.c$);
\r
525 c$ = Clazz.decorateAsClass (function () {
\r
526 this.floatCoords = null;
\r
527 Clazz.instantialize (this, arguments);
\r
528 }, java.awt.geom.Path2D.Float, "CopyIterator", java.awt.geom.Path2D.Iterator);
\r
529 Clazz.makeConstructor (c$,
\r
531 Clazz.superConstructor (this, java.awt.geom.Path2D.Float.CopyIterator, [a]);
\r
532 this.floatCoords = a.floatCoords;
\r
533 }, "java.awt.geom.Path2D.Float");
\r
534 Clazz.defineMethod (c$, "currentSegment",
\r
536 var b = this.path.pointTypes[this.typeIdx];
\r
537 var c = java.awt.geom.Path2D.Iterator.curvecoords[b];
\r
539 for (var d = 0; d < c; d++) {
\r
540 a[d] = this.floatCoords[this.pointIdx + d];
\r
545 Clazz.pu$h(self.c$);
\r
546 c$ = Clazz.decorateAsClass (function () {
\r
547 this.floatCoords = null;
\r
548 this.affine = null;
\r
549 Clazz.instantialize (this, arguments);
\r
550 }, java.awt.geom.Path2D.Float, "TxIterator", java.awt.geom.Path2D.Iterator);
\r
551 Clazz.makeConstructor (c$,
\r
553 Clazz.superConstructor (this, java.awt.geom.Path2D.Float.TxIterator, [a]);
\r
554 this.floatCoords = a.floatCoords;
\r
556 }, "java.awt.geom.Path2D.Float,java.awt.geom.AffineTransform");
\r
557 Clazz.defineMethod (c$, "currentSegment",
\r
559 var b = this.path.pointTypes[this.typeIdx];
\r
560 var c = java.awt.geom.Path2D.Iterator.curvecoords[b];
\r
562 this.affine.transform (this.floatCoords, this.pointIdx, a, 0, Clazz.doubleToInt (c / 2));
\r
567 Clazz.pu$h(self.c$);
\r
568 c$ = Clazz.decorateAsClass (function () {
\r
569 this.doubleCoords = null;
\r
570 Clazz.instantialize (this, arguments);
\r
571 }, java.awt.geom.Path2D, "Double", java.awt.geom.Path2D);
\r
572 Clazz.makeConstructor (c$,
\r
574 this.construct (1, 20);
\r
576 Clazz.makeConstructor (c$,
\r
578 this.construct (a, 20);
\r
580 Clazz.makeConstructor (c$,
\r
582 Clazz.superConstructor (this, java.awt.geom.Path2D.Double, [a, b]);
\r
583 this.doubleCoords = Clazz.newDoubleArray (b * 2, 0);
\r
585 Clazz.makeConstructor (c$,
\r
587 this.construct (a, null);
\r
588 }, "java.awt.Shape");
\r
589 Clazz.makeConstructor (c$,
\r
591 Clazz.superConstructor (this, java.awt.geom.Path2D.Double, []);
\r
592 if (Clazz.instanceOf (a, java.awt.geom.Path2D)) {
\r
594 this.setWindingRule (c.windingRule);
\r
595 this.numTypes = c.numTypes;
\r
596 this.pointTypes = java.util.Arrays.copyOf (c.pointTypes, c.pointTypes.length);
\r
597 this.numCoords = c.numCoords;
\r
598 this.doubleCoords = c.cloneCoordsDouble (b);
\r
600 var c = a.getPathIterator (b);
\r
601 this.setWindingRule (c.getWindingRule ());
\r
602 this.pointTypes = Clazz.newByteArray (20, 0);
\r
603 this.doubleCoords = Clazz.newDoubleArray (40, 0);
\r
604 this.append (c, false);
\r
605 }}, "java.awt.Shape,java.awt.geom.AffineTransform");
\r
606 Clazz.overrideMethod (c$, "cloneCoordsFloat",
\r
608 var b = Clazz.newFloatArray (this.doubleCoords.length, 0);
\r
610 for (var c = 0; c < this.numCoords; c++) {
\r
611 b[c] = this.doubleCoords[c];
\r
614 a.transform (this.doubleCoords, 0, b, 0, Clazz.doubleToInt (this.numCoords / 2));
\r
616 }, "java.awt.geom.AffineTransform");
\r
617 Clazz.defineMethod (c$, "cloneCoordsDouble",
\r
621 b = java.util.Arrays.copyOf (this.doubleCoords, this.doubleCoords.length);
\r
623 b = Clazz.newDoubleArray (this.doubleCoords.length, 0);
\r
624 a.transform (this.doubleCoords, 0, b, 0, Clazz.doubleToInt (this.numCoords / 2));
\r
626 }, "java.awt.geom.AffineTransform");
\r
627 Clazz.defineMethod (c$, "append",
\r
630 if (typeof pi == "number") {
\r
631 this.floatCoords[this.numCoords++] = pi;
\r
632 this.floatCoords[this.numCoords++] = connect;
\r
635 }var c = Clazz.newDoubleArray (6, 0);
\r
636 while (!a.isDone ()) {
\r
637 switch (a.currentSegment (c)) {
\r
639 if (!b || this.numTypes < 1 || this.numCoords < 1) {
\r
640 this.moveTo (c[0], c[1]);
\r
642 }if (this.pointTypes[this.numTypes - 1] != 4 && this.doubleCoords[this.numCoords - 2] == c[0] && this.doubleCoords[this.numCoords - 1] == c[1]) {
\r
645 this.lineTo (c[0], c[1]);
\r
648 this.quadTo (c[0], c[1], c[2], c[3]);
\r
651 this.curveTo (c[0], c[1], c[2], c[3], c[4], c[5]);
\r
660 }, "java.awt.geom.PathIterator,~B");
\r
661 Clazz.overrideMethod (c$, "getPoint",
\r
663 return new java.awt.geom.Point2D.Double (this.doubleCoords[a], this.doubleCoords[a + 1]);
\r
665 Clazz.overrideMethod (c$, "needRoom",
\r
667 if (a && this.numTypes == 0) {
\r
668 throw new java.awt.geom.IllegalPathStateException ("missing initial moveto in path definition");
\r
669 }var c = this.pointTypes.length;
\r
670 if (this.numTypes >= c) {
\r
674 }this.pointTypes = java.util.Arrays.copyOf (this.pointTypes, c + d);
\r
675 }c = this.doubleCoords.length;
\r
676 if (this.numCoords + b > c) {
\r
682 }this.doubleCoords = java.util.Arrays.copyOf (this.doubleCoords, c + d);
\r
684 Clazz.overrideMethod (c$, "moveTo",
\r
686 if (this.numTypes > 0 && this.pointTypes[this.numTypes - 1] == 0) {
\r
687 this.doubleCoords[this.numCoords - 2] = a;
\r
688 this.doubleCoords[this.numCoords - 1] = b;
\r
690 this.needRoom (false, 2);
\r
691 this.pointTypes[this.numTypes++] = 0;
\r
692 this.doubleCoords[this.numCoords++] = a;
\r
693 this.doubleCoords[this.numCoords++] = b;
\r
695 Clazz.overrideMethod (c$, "lineTo",
\r
697 this.needRoom (true, 2);
\r
698 this.pointTypes[this.numTypes++] = 1;
\r
699 this.doubleCoords[this.numCoords++] = a;
\r
700 this.doubleCoords[this.numCoords++] = b;
\r
702 Clazz.overrideMethod (c$, "quadTo",
\r
703 function (a, b, c, d) {
\r
704 this.needRoom (true, 4);
\r
705 this.pointTypes[this.numTypes++] = 2;
\r
706 this.doubleCoords[this.numCoords++] = a;
\r
707 this.doubleCoords[this.numCoords++] = b;
\r
708 this.doubleCoords[this.numCoords++] = c;
\r
709 this.doubleCoords[this.numCoords++] = d;
\r
711 Clazz.overrideMethod (c$, "curveTo",
\r
712 function (a, b, c, d, e, f) {
\r
713 this.needRoom (true, 6);
\r
714 this.pointTypes[this.numTypes++] = 3;
\r
715 this.doubleCoords[this.numCoords++] = a;
\r
716 this.doubleCoords[this.numCoords++] = b;
\r
717 this.doubleCoords[this.numCoords++] = c;
\r
718 this.doubleCoords[this.numCoords++] = d;
\r
719 this.doubleCoords[this.numCoords++] = e;
\r
720 this.doubleCoords[this.numCoords++] = f;
\r
721 }, "~N,~N,~N,~N,~N,~N");
\r
722 Clazz.overrideMethod (c$, "pointCrossings",
\r
730 var i = this.doubleCoords;
\r
735 for (var l = 1; l < this.numTypes; l++) {
\r
736 switch (this.pointTypes[l]) {
\r
739 j += jssun.awt.geom.Curve.pointCrossingsForLine (a, b, e, f, c, d);
\r
744 j += jssun.awt.geom.Curve.pointCrossingsForLine (a, b, e, f, g = i[k++], h = i[k++]);
\r
749 j += jssun.awt.geom.Curve.pointCrossingsForQuad (a, b, e, f, i[k++], i[k++], g = i[k++], h = i[k++], 0);
\r
754 j += jssun.awt.geom.Curve.pointCrossingsForCubic (a, b, e, f, i[k++], i[k++], i[k++], i[k++], g = i[k++], h = i[k++], 0);
\r
760 j += jssun.awt.geom.Curve.pointCrossingsForLine (a, b, e, f, c, d);
\r
767 j += jssun.awt.geom.Curve.pointCrossingsForLine (a, b, e, f, c, d);
\r
770 Clazz.overrideMethod (c$, "rectCrossings",
\r
771 function (a, b, c, d) {
\r
772 var e = this.doubleCoords;
\r
783 for (var n = 1; l != -2147483648 && n < this.numTypes; n++) {
\r
784 switch (this.pointTypes[n]) {
\r
786 if (f != h || g != i) {
\r
787 l = jssun.awt.geom.Curve.rectCrossingsForLine (l, a, b, c, d, f, g, h, i);
\r
794 l = jssun.awt.geom.Curve.rectCrossingsForLine (l, a, b, c, d, f, g, j, k);
\r
799 l = jssun.awt.geom.Curve.rectCrossingsForQuad (l, a, b, c, d, f, g, e[m++], e[m++], j = e[m++], k = e[m++], 0);
\r
804 l = jssun.awt.geom.Curve.rectCrossingsForCubic (l, a, b, c, d, f, g, e[m++], e[m++], e[m++], e[m++], j = e[m++], k = e[m++], 0);
\r
809 if (f != h || g != i) {
\r
810 l = jssun.awt.geom.Curve.rectCrossingsForLine (l, a, b, c, d, f, g, h, i);
\r
816 if (l != -2147483648 && (f != h || g != i)) {
\r
817 l = jssun.awt.geom.Curve.rectCrossingsForLine (l, a, b, c, d, f, g, h, i);
\r
820 Clazz.overrideMethod (c$, "transform",
\r
822 a.transform (this.doubleCoords, 0, this.doubleCoords, 0, Clazz.doubleToInt (this.numCoords / 2));
\r
823 }, "java.awt.geom.AffineTransform");
\r
824 Clazz.overrideMethod (c$, "getBounds2D",
\r
830 var e = this.numCoords;
\r
832 b = d = this.doubleCoords[--e];
\r
833 a = c = this.doubleCoords[--e];
\r
835 var f = this.doubleCoords[--e];
\r
836 var g = this.doubleCoords[--e];
\r
843 a = b = c = d = 0.0;
\r
844 }return new java.awt.geom.Rectangle2D.Double (a, b, c - a, d - b);
\r
846 Clazz.defineMethod (c$, "getPathIterator",
\r
849 return new java.awt.geom.Path2D.Double.CopyIterator (this);
\r
851 return new java.awt.geom.Path2D.Double.TxIterator (this, a);
\r
852 }}, "java.awt.geom.AffineTransform");
\r
853 Clazz.overrideMethod (c$, "clone",
\r
855 return new java.awt.geom.Path2D.Double (this);
\r
857 Clazz.pu$h(self.c$);
\r
858 c$ = Clazz.decorateAsClass (function () {
\r
859 this.doubleCoords = null;
\r
860 Clazz.instantialize (this, arguments);
\r
861 }, java.awt.geom.Path2D.Double, "CopyIterator", java.awt.geom.Path2D.Iterator);
\r
862 Clazz.makeConstructor (c$,
\r
864 Clazz.superConstructor (this, java.awt.geom.Path2D.Double.CopyIterator, [a]);
\r
865 this.doubleCoords = a.doubleCoords;
\r
866 }, "java.awt.geom.Path2D.Double");
\r
867 Clazz.defineMethod (c$, "currentSegment",
\r
869 var b = this.path.pointTypes[this.typeIdx];
\r
870 var c = java.awt.geom.Path2D.Iterator.curvecoords[b];
\r
872 for (var d = 0; d < c; d++) {
\r
873 a[d] = this.doubleCoords[this.pointIdx + d];
\r
877 Clazz.defineMethod (c$, "currentSegment",
\r
879 var b = this.path.pointTypes[this.typeIdx];
\r
880 var c = java.awt.geom.Path2D.Iterator.curvecoords[b];
\r
882 System.arraycopy (this.doubleCoords, this.pointIdx, a, 0, c);
\r
886 Clazz.pu$h(self.c$);
\r
887 c$ = Clazz.decorateAsClass (function () {
\r
888 this.doubleCoords = null;
\r
889 this.affine = null;
\r
890 Clazz.instantialize (this, arguments);
\r
891 }, java.awt.geom.Path2D.Double, "TxIterator", java.awt.geom.Path2D.Iterator);
\r
892 Clazz.makeConstructor (c$,
\r
894 Clazz.superConstructor (this, java.awt.geom.Path2D.Double.TxIterator, [a]);
\r
895 this.doubleCoords = a.doubleCoords;
\r
897 }, "java.awt.geom.Path2D.Double,java.awt.geom.AffineTransform");
\r
898 Clazz.defineMethod (c$, "currentSegment",
\r
900 var b = this.path.pointTypes[this.typeIdx];
\r
901 var c = java.awt.geom.Path2D.Iterator.curvecoords[b];
\r
903 this.affine.transform (this.doubleCoords, this.pointIdx, a, 0, Clazz.doubleToInt (c / 2));
\r
906 Clazz.defineMethod (c$, "currentSegment",
\r
908 var b = this.path.pointTypes[this.typeIdx];
\r
909 var c = java.awt.geom.Path2D.Iterator.curvecoords[b];
\r
911 this.affine.transform (this.doubleCoords, this.pointIdx, a, 0, Clazz.doubleToInt (c / 2));
\r
916 Clazz.defineStatics (c$,
\r
917 "WIND_EVEN_ODD", 0,
\r
918 "WIND_NON_ZERO", 1,
\r
925 "EXPAND_MAX", 500);
\r