site/j2s/java/awt/geom/Path2D.js

   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
   5 this.numTypes = 0;\r
   6 this.numCoords = 0;\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
  11 function () {\r
  12 });\r
  13 Clazz.makeConstructor (c$, \r
  14 function (rule, initialTypes) {\r
  15 this.setWindingRule (rule);\r
  16 this.pointTypes =  Clazz.newByteArray (initialTypes, 0);\r
  17 }, "~N,~N");\r
  18 Clazz.defineMethod (c$, "closePath", \r
  19 function () {\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
  23 }});\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
  29 function () {\r
  30 return this.windingRule;\r
  31 });\r
  32 Clazz.defineMethod (c$, "setWindingRule", \r
  33 function (rule) {\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
  37 }, "~N");\r
  38 Clazz.defineMethod (c$, "getCurrentPoint", \r
  39 function () {\r
  40 var index = this.numCoords;\r
  41 if (this.numTypes < 1 || index < 1) {\r
  42 return null;\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
  46 case 0:\r
  47 break loop;\r
  48 case 1:\r
  49 index -= 2;\r
  50 break;\r
  51 case 2:\r
  52 index -= 4;\r
  53 break;\r
  54 case 3:\r
  55 index -= 6;\r
  56 break;\r
  57 case 4:\r
  58 break;\r
  59 }\r
  60 }\r
  61 }return this.getPoint (index - 2);\r
  62 });\r
  63 Clazz.defineMethod (c$, "reset", \r
  64 function () {\r
  65 this.numTypes = this.numCoords = 0;\r
  66 });\r
  67 Clazz.defineMethod (c$, "createTransformedShape", \r
  68 function (at) {\r
  69 var p2d = this.clone ();\r
  70 if (at != null) {\r
  71 p2d.transform (at);\r
  72 }return p2d;\r
  73 }, "java.awt.geom.AffineTransform");\r
  74 Clazz.overrideMethod (c$, "getBounds", \r
  75 function () {\r
  76 return this.getBounds2D ().getBounds ();\r
  77 });\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
  84 } else {\r
  85 return false;\r
  86 }}, "java.awt.geom.PathIterator,~N,~N");\r
  87 c$.contains = Clazz.defineMethod (c$, "contains", \r
  88 function (pi, p) {\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
  92 function (x, y) {\r
  93 if (x * 0.0 + y * 0.0 == 0.0) {\r
  94 if (this.numTypes < 2) {\r
  95 return false;\r
  96 }var mask = (this.windingRule == 1 ? -1 : 1);\r
  97 return ((this.pointCrossings (x, y) & mask) != 0);\r
  98 } else {\r
  99 return false;\r
 100 }}, "~N,~N");\r
 101 Clazz.defineMethod (c$, "contains", \r
 102 function (p) {\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
 108 return false;\r
 109 }if (w <= 0 || h <= 0) {\r
 110 return false;\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
 116 function (pi, r) {\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
 122 return false;\r
 123 }if (w <= 0 || h <= 0) {\r
 124 return false;\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
 128 }, "~N,~N,~N,~N");\r
 129 Clazz.defineMethod (c$, "contains", \r
 130 function (r) {\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
 136 return false;\r
 137 }if (w <= 0 || h <= 0) {\r
 138 return false;\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
 144 function (pi, r) {\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
 150 return false;\r
 151 }if (w <= 0 || h <= 0) {\r
 152 return false;\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
 156 }, "~N,~N,~N,~N");\r
 157 Clazz.defineMethod (c$, "intersects", \r
 158 function (r) {\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
 167 this.typeIdx = 0;\r
 168 this.pointIdx = 0;\r
 169 this.path = null;\r
 170 Clazz.instantialize (this, arguments);\r
 171 }, java.awt.geom.Path2D, "Iterator", null, java.awt.geom.PathIterator);\r
 172 Clazz.makeConstructor (c$, \r
 173 function (a) {\r
 174 this.path = a;\r
 175 }, "java.awt.geom.Path2D");\r
 176 Clazz.overrideMethod (c$, "getWindingRule", \r
 177 function () {\r
 178 return this.path.getWindingRule ();\r
 179 });\r
 180 Clazz.overrideMethod (c$, "isDone", \r
 181 function () {\r
 182 return (this.typeIdx >= this.path.numTypes);\r
 183 });\r
 184 Clazz.overrideMethod (c$, "next", \r
 185 function () {\r
 186 var a = this.path.pointTypes[this.typeIdx++];\r
 187 this.pointIdx += java.awt.geom.Path2D.Iterator.curvecoords[a];\r
 188 });\r
 189 Clazz.defineStatics (c$,\r
 190 "curvecoords",  Clazz.newIntArray (-1, [2, 2, 4, 6, 0]));\r
 191 c$ = Clazz.p0p ();\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
 198 function () {\r
 199 this.construct (1, 20);\r
 200 });\r
 201 Clazz.makeConstructor (c$, \r
 202 function (a) {\r
 203 this.construct (a, 20);\r
 204 }, "~N");\r
 205 Clazz.makeConstructor (c$, \r
 206 function (a, b) {\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
 211 }, "~N,~N");\r
 212 Clazz.makeConstructor (c$, \r
 213 function (a) {\r
 214 this.construct (a, null);\r
 215 }, "java.awt.Shape");\r
 216 Clazz.makeConstructor (c$, \r
 217 function (a, b) {\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
 222  function (a, b) {\r
 223 if (Clazz.instanceOf (a, java.awt.geom.Path2D)) {\r
 224 var c = a;\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
 230 } else {\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
 238 function (a) {\r
 239 var b;\r
 240 if (a == null) {\r
 241 b = java.util.Arrays.copyOf (this.floatCoords, this.floatCoords.length);\r
 242 } else {\r
 243 b =  Clazz.newFloatArray (this.floatCoords.length, 0);\r
 244 a.transform (this.floatCoords, 0, b, 0, Clazz.doubleToInt (this.numCoords / 2));\r
 245 }return b;\r
 246 }, "java.awt.geom.AffineTransform");\r
 247 Clazz.overrideMethod (c$, "cloneCoordsDouble", \r
 248 function (a) {\r
 249 var b =  Clazz.newDoubleArray (this.floatCoords.length, 0);\r
 250 if (a == null) {\r
 251 for (var c = 0; c < this.numCoords; c++) {\r
 252 b[c] = this.floatCoords[c];\r
 253 }\r
 254 } else {\r
 255 a.transform (this.floatCoords, 0, b, 0, Clazz.doubleToInt (this.numCoords / 2));\r
 256 }return b;\r
 257 }, "java.awt.geom.AffineTransform");\r
 258 Clazz.defineMethod (c$, "append", \r
 259 function (a, b) {\r
 260 {\r
 261 if (typeof pi == "number") {\r
 262 this.floatCoords[this.numCoords++] = pi;\r
 263 this.floatCoords[this.numCoords++] = connect;\r
 264 return;\r
 265 }\r
 266 }var c =  Clazz.newFloatArray (6, 0);\r
 267 while (!a.isDone ()) {\r
 268 switch (a.currentSegment (c)) {\r
 269 case 0:\r
 270 if (!b || this.numTypes < 1 || this.numCoords < 1) {\r
 271 this.moveTo (c[0], c[1]);\r
 272 break;\r
 273 }if (this.pointTypes[this.numTypes - 1] != 4 && this.floatCoords[this.numCoords - 2] == c[0] && this.floatCoords[this.numCoords - 1] == c[1]) {\r
 274 break;\r
 275 }case 1:\r
 276 this.lineTo (c[0], c[1]);\r
 277 break;\r
 278 case 2:\r
 279 this.quadTo (c[0], c[1], c[2], c[3]);\r
 280 break;\r
 281 case 3:\r
 282 this.curveTo (c[0], c[1], c[2], c[3], c[4], c[5]);\r
 283 break;\r
 284 case 4:\r
 285 this.closePath ();\r
 286 break;\r
 287 }\r
 288 a.next ();\r
 289 b = false;\r
 290 }\r
 291 }, "java.awt.geom.PathIterator,~B");\r
 292 Clazz.overrideMethod (c$, "getPoint", \r
 293 function (a) {\r
 294 return  new java.awt.geom.Point2D.Float (this.floatCoords[a], this.floatCoords[a + 1]);\r
 295 }, "~N");\r
 296 Clazz.overrideMethod (c$, "needRoom", \r
 297 function (a, b) {\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
 302 var d = c;\r
 303 if (d > 500) {\r
 304 d = 500;\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
 308 var d = c;\r
 309 if (d > 1000) {\r
 310 d = 1000;\r
 311 }if (d < b) {\r
 312 d = b;\r
 313 }this.floatCoords = java.util.Arrays.copyOf (this.floatCoords, c + d);\r
 314 }}, "~B,~N");\r
 315 Clazz.defineMethod (c$, "moveTo", \r
 316 function (a, b) {\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
 320 } else {\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
 325 }}, "~N,~N");\r
 326 Clazz.defineMethod (c$, "moveTo", \r
 327 function (a, b) {\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
 331 } else {\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
 336 }}, "~N,~N");\r
 337 Clazz.defineMethod (c$, "lineTo", \r
 338 function (a, b) {\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
 343 }, "~N,~N");\r
 344 Clazz.defineMethod (c$, "lineTo", \r
 345 function (a, b) {\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
 350 }, "~N,~N");\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
 359 }, "~N,~N,~N,~N");\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
 368 }, "~N,~N,~N,~N");\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
 392 function (a, b) {\r
 393 var c;\r
 394 var d;\r
 395 var e;\r
 396 var f;\r
 397 var g;\r
 398 var h;\r
 399 var i = this.floatCoords;\r
 400 e = c = i[0];\r
 401 f = d = i[1];\r
 402 var j = 0;\r
 403 var k = 2;\r
 404 for (var l = 1; l < this.numTypes; l++) {\r
 405 switch (this.pointTypes[l]) {\r
 406 case 0:\r
 407 if (f != d) {\r
 408 j += jssun.awt.geom.Curve.pointCrossingsForLine (a, b, e, f, c, d);\r
 409 }c = e = i[k++];\r
 410 d = f = i[k++];\r
 411 break;\r
 412 case 1:\r
 413 j += jssun.awt.geom.Curve.pointCrossingsForLine (a, b, e, f, g = i[k++], h = i[k++]);\r
 414 e = g;\r
 415 f = h;\r
 416 break;\r
 417 case 2:\r
 418 j += jssun.awt.geom.Curve.pointCrossingsForQuad (a, b, e, f, i[k++], i[k++], g = i[k++], h = i[k++], 0);\r
 419 e = g;\r
 420 f = h;\r
 421 break;\r
 422 case 3:\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
 424 e = g;\r
 425 f = h;\r
 426 break;\r
 427 case 4:\r
 428 if (f != d) {\r
 429 j += jssun.awt.geom.Curve.pointCrossingsForLine (a, b, e, f, c, d);\r
 430 }e = c;\r
 431 f = d;\r
 432 break;\r
 433 }\r
 434 }\r
 435 if (f != d) {\r
 436 j += jssun.awt.geom.Curve.pointCrossingsForLine (a, b, e, f, c, d);\r
 437 }return j;\r
 438 }, "~N,~N");\r
 439 Clazz.overrideMethod (c$, "rectCrossings", \r
 440 function (a, b, c, d) {\r
 441 var e = this.floatCoords;\r
 442 var f;\r
 443 var g;\r
 444 var h;\r
 445 var i;\r
 446 var j;\r
 447 var k;\r
 448 f = h = e[0];\r
 449 g = i = e[1];\r
 450 var l = 0;\r
 451 var m = 2;\r
 452 for (var n = 1; l != -2147483648 && n < this.numTypes; n++) {\r
 453 switch (this.pointTypes[n]) {\r
 454 case 0:\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
 457 }h = f = e[m++];\r
 458 i = g = e[m++];\r
 459 break;\r
 460 case 1:\r
 461 l = jssun.awt.geom.Curve.rectCrossingsForLine (l, a, b, c, d, f, g, j = e[m++], k = e[m++]);\r
 462 f = j;\r
 463 g = k;\r
 464 break;\r
 465 case 2:\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
 467 f = j;\r
 468 g = k;\r
 469 break;\r
 470 case 3:\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
 472 f = j;\r
 473 g = k;\r
 474 break;\r
 475 case 4:\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
 478 }f = h;\r
 479 g = i;\r
 480 break;\r
 481 }\r
 482 }\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
 485 }return l;\r
 486 }, "~N,~N,~N,~N");\r
 487 Clazz.overrideMethod (c$, "transform", \r
 488 function (a) {\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
 492 function () {\r
 493 var a;\r
 494 var b;\r
 495 var c;\r
 496 var d;\r
 497 var e = this.numCoords;\r
 498 if (e > 0) {\r
 499 b = d = this.floatCoords[--e];\r
 500 a = c = this.floatCoords[--e];\r
 501 while (e > 0) {\r
 502 var f = this.floatCoords[--e];\r
 503 var g = this.floatCoords[--e];\r
 504 if (g < a) a = g;\r
 505 if (f < b) b = f;\r
 506 if (g > c) c = g;\r
 507 if (f > d) d = f;\r
 508 }\r
 509 } else {\r
 510 a = b = c = d = 0.0;\r
 511 }return  new java.awt.geom.Rectangle2D.Float (a, b, c - a, d - b);\r
 512 });\r
 513 Clazz.defineMethod (c$, "getPathIterator", \r
 514 function (a) {\r
 515 if (a == null) {\r
 516 return  new java.awt.geom.Path2D.Float.CopyIterator (this);\r
 517 } else {\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
 521 function () {\r
 522 return  new java.awt.geom.Path2D.Float (this);\r
 523 });\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
 530 function (a) {\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
 535 function (a) {\r
 536 var b = this.path.pointTypes[this.typeIdx];\r
 537 var c = java.awt.geom.Path2D.Iterator.curvecoords[b];\r
 538 if (c > 0) {\r
 539 for (var d = 0; d < c; d++) {\r
 540 a[d] = this.floatCoords[this.pointIdx + d];\r
 541 }\r
 542 }return b;\r
 543 }, "~A");\r
 544 c$ = Clazz.p0p ();\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
 552 function (a, b) {\r
 553 Clazz.superConstructor (this, java.awt.geom.Path2D.Float.TxIterator, [a]);\r
 554 this.floatCoords = a.floatCoords;\r
 555 this.affine = b;\r
 556 }, "java.awt.geom.Path2D.Float,java.awt.geom.AffineTransform");\r
 557 Clazz.defineMethod (c$, "currentSegment", \r
 558 function (a) {\r
 559 var b = this.path.pointTypes[this.typeIdx];\r
 560 var c = java.awt.geom.Path2D.Iterator.curvecoords[b];\r
 561 if (c > 0) {\r
 562 this.affine.transform (this.floatCoords, this.pointIdx, a, 0, Clazz.doubleToInt (c / 2));\r
 563 }return b;\r
 564 }, "~A");\r
 565 c$ = Clazz.p0p ();\r
 566 c$ = Clazz.p0p ();\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
 573 function () {\r
 574 this.construct (1, 20);\r
 575 });\r
 576 Clazz.makeConstructor (c$, \r
 577 function (a) {\r
 578 this.construct (a, 20);\r
 579 }, "~N");\r
 580 Clazz.makeConstructor (c$, \r
 581 function (a, b) {\r
 582 Clazz.superConstructor (this, java.awt.geom.Path2D.Double, [a, b]);\r
 583 this.doubleCoords =  Clazz.newDoubleArray (b * 2, 0);\r
 584 }, "~N,~N");\r
 585 Clazz.makeConstructor (c$, \r
 586 function (a) {\r
 587 this.construct (a, null);\r
 588 }, "java.awt.Shape");\r
 589 Clazz.makeConstructor (c$, \r
 590 function (a, b) {\r
 591 Clazz.superConstructor (this, java.awt.geom.Path2D.Double, []);\r
 592 if (Clazz.instanceOf (a, java.awt.geom.Path2D)) {\r
 593 var c = a;\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
 599 } else {\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
 607 function (a) {\r
 608 var b =  Clazz.newFloatArray (this.doubleCoords.length, 0);\r
 609 if (a == null) {\r
 610 for (var c = 0; c < this.numCoords; c++) {\r
 611 b[c] = this.doubleCoords[c];\r
 612 }\r
 613 } else {\r
 614 a.transform (this.doubleCoords, 0, b, 0, Clazz.doubleToInt (this.numCoords / 2));\r
 615 }return b;\r
 616 }, "java.awt.geom.AffineTransform");\r
 617 Clazz.defineMethod (c$, "cloneCoordsDouble", \r
 618 function (a) {\r
 619 var b;\r
 620 if (a == null) {\r
 621 b = java.util.Arrays.copyOf (this.doubleCoords, this.doubleCoords.length);\r
 622 } else {\r
 623 b =  Clazz.newDoubleArray (this.doubleCoords.length, 0);\r
 624 a.transform (this.doubleCoords, 0, b, 0, Clazz.doubleToInt (this.numCoords / 2));\r
 625 }return b;\r
 626 }, "java.awt.geom.AffineTransform");\r
 627 Clazz.defineMethod (c$, "append", \r
 628 function (a, b) {\r
 629 {\r
 630 if (typeof pi == "number") {\r
 631 this.floatCoords[this.numCoords++] = pi;\r
 632 this.floatCoords[this.numCoords++] = connect;\r
 633 return;\r
 634 }\r
 635 }var c =  Clazz.newDoubleArray (6, 0);\r
 636 while (!a.isDone ()) {\r
 637 switch (a.currentSegment (c)) {\r
 638 case 0:\r
 639 if (!b || this.numTypes < 1 || this.numCoords < 1) {\r
 640 this.moveTo (c[0], c[1]);\r
 641 break;\r
 642 }if (this.pointTypes[this.numTypes - 1] != 4 && this.doubleCoords[this.numCoords - 2] == c[0] && this.doubleCoords[this.numCoords - 1] == c[1]) {\r
 643 break;\r
 644 }case 1:\r
 645 this.lineTo (c[0], c[1]);\r
 646 break;\r
 647 case 2:\r
 648 this.quadTo (c[0], c[1], c[2], c[3]);\r
 649 break;\r
 650 case 3:\r
 651 this.curveTo (c[0], c[1], c[2], c[3], c[4], c[5]);\r
 652 break;\r
 653 case 4:\r
 654 this.closePath ();\r
 655 break;\r
 656 }\r
 657 a.next ();\r
 658 b = false;\r
 659 }\r
 660 }, "java.awt.geom.PathIterator,~B");\r
 661 Clazz.overrideMethod (c$, "getPoint", \r
 662 function (a) {\r
 663 return  new java.awt.geom.Point2D.Double (this.doubleCoords[a], this.doubleCoords[a + 1]);\r
 664 }, "~N");\r
 665 Clazz.overrideMethod (c$, "needRoom", \r
 666 function (a, b) {\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
 671 var d = c;\r
 672 if (d > 500) {\r
 673 d = 500;\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
 677 var d = c;\r
 678 if (d > 1000) {\r
 679 d = 1000;\r
 680 }if (d < b) {\r
 681 d = b;\r
 682 }this.doubleCoords = java.util.Arrays.copyOf (this.doubleCoords, c + d);\r
 683 }}, "~B,~N");\r
 684 Clazz.overrideMethod (c$, "moveTo", \r
 685 function (a, b) {\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
 689 } else {\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
 694 }}, "~N,~N");\r
 695 Clazz.overrideMethod (c$, "lineTo", \r
 696 function (a, b) {\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
 701 }, "~N,~N");\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
 710 }, "~N,~N,~N,~N");\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
 723 function (a, b) {\r
 724 var c;\r
 725 var d;\r
 726 var e;\r
 727 var f;\r
 728 var g;\r
 729 var h;\r
 730 var i = this.doubleCoords;\r
 731 e = c = i[0];\r
 732 f = d = i[1];\r
 733 var j = 0;\r
 734 var k = 2;\r
 735 for (var l = 1; l < this.numTypes; l++) {\r
 736 switch (this.pointTypes[l]) {\r
 737 case 0:\r
 738 if (f != d) {\r
 739 j += jssun.awt.geom.Curve.pointCrossingsForLine (a, b, e, f, c, d);\r
 740 }c = e = i[k++];\r
 741 d = f = i[k++];\r
 742 break;\r
 743 case 1:\r
 744 j += jssun.awt.geom.Curve.pointCrossingsForLine (a, b, e, f, g = i[k++], h = i[k++]);\r
 745 e = g;\r
 746 f = h;\r
 747 break;\r
 748 case 2:\r
 749 j += jssun.awt.geom.Curve.pointCrossingsForQuad (a, b, e, f, i[k++], i[k++], g = i[k++], h = i[k++], 0);\r
 750 e = g;\r
 751 f = h;\r
 752 break;\r
 753 case 3:\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
 755 e = g;\r
 756 f = h;\r
 757 break;\r
 758 case 4:\r
 759 if (f != d) {\r
 760 j += jssun.awt.geom.Curve.pointCrossingsForLine (a, b, e, f, c, d);\r
 761 }e = c;\r
 762 f = d;\r
 763 break;\r
 764 }\r
 765 }\r
 766 if (f != d) {\r
 767 j += jssun.awt.geom.Curve.pointCrossingsForLine (a, b, e, f, c, d);\r
 768 }return j;\r
 769 }, "~N,~N");\r
 770 Clazz.overrideMethod (c$, "rectCrossings", \r
 771 function (a, b, c, d) {\r
 772 var e = this.doubleCoords;\r
 773 var f;\r
 774 var g;\r
 775 var h;\r
 776 var i;\r
 777 var j;\r
 778 var k;\r
 779 f = h = e[0];\r
 780 g = i = e[1];\r
 781 var l = 0;\r
 782 var m = 2;\r
 783 for (var n = 1; l != -2147483648 && n < this.numTypes; n++) {\r
 784 switch (this.pointTypes[n]) {\r
 785 case 0:\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
 788 }h = f = e[m++];\r
 789 i = g = e[m++];\r
 790 break;\r
 791 case 1:\r
 792 j = e[m++];\r
 793 k = e[m++];\r
 794 l = jssun.awt.geom.Curve.rectCrossingsForLine (l, a, b, c, d, f, g, j, k);\r
 795 f = j;\r
 796 g = k;\r
 797 break;\r
 798 case 2:\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
 800 f = j;\r
 801 g = k;\r
 802 break;\r
 803 case 3:\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
 805 f = j;\r
 806 g = k;\r
 807 break;\r
 808 case 4:\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
 811 }f = h;\r
 812 g = i;\r
 813 break;\r
 814 }\r
 815 }\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
 818 }return l;\r
 819 }, "~N,~N,~N,~N");\r
 820 Clazz.overrideMethod (c$, "transform", \r
 821 function (a) {\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
 825 function () {\r
 826 var a;\r
 827 var b;\r
 828 var c;\r
 829 var d;\r
 830 var e = this.numCoords;\r
 831 if (e > 0) {\r
 832 b = d = this.doubleCoords[--e];\r
 833 a = c = this.doubleCoords[--e];\r
 834 while (e > 0) {\r
 835 var f = this.doubleCoords[--e];\r
 836 var g = this.doubleCoords[--e];\r
 837 if (g < a) a = g;\r
 838 if (f < b) b = f;\r
 839 if (g > c) c = g;\r
 840 if (f > d) d = f;\r
 841 }\r
 842 } else {\r
 843 a = b = c = d = 0.0;\r
 844 }return  new java.awt.geom.Rectangle2D.Double (a, b, c - a, d - b);\r
 845 });\r
 846 Clazz.defineMethod (c$, "getPathIterator", \r
 847 function (a) {\r
 848 if (a == null) {\r
 849 return  new java.awt.geom.Path2D.Double.CopyIterator (this);\r
 850 } else {\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
 854 function () {\r
 855 return  new java.awt.geom.Path2D.Double (this);\r
 856 });\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
 863 function (a) {\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
 868 function (a) {\r
 869 var b = this.path.pointTypes[this.typeIdx];\r
 870 var c = java.awt.geom.Path2D.Iterator.curvecoords[b];\r
 871 if (c > 0) {\r
 872 for (var d = 0; d < c; d++) {\r
 873 a[d] = this.doubleCoords[this.pointIdx + d];\r
 874 }\r
 875 }return b;\r
 876 }, "~A");\r
 877 Clazz.defineMethod (c$, "currentSegment", \r
 878 function (a) {\r
 879 var b = this.path.pointTypes[this.typeIdx];\r
 880 var c = java.awt.geom.Path2D.Iterator.curvecoords[b];\r
 881 if (c > 0) {\r
 882 System.arraycopy (this.doubleCoords, this.pointIdx, a, 0, c);\r
 883 }return b;\r
 884 }, "~A");\r
 885 c$ = Clazz.p0p ();\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
 893 function (a, b) {\r
 894 Clazz.superConstructor (this, java.awt.geom.Path2D.Double.TxIterator, [a]);\r
 895 this.doubleCoords = a.doubleCoords;\r
 896 this.affine = b;\r
 897 }, "java.awt.geom.Path2D.Double,java.awt.geom.AffineTransform");\r
 898 Clazz.defineMethod (c$, "currentSegment", \r
 899 function (a) {\r
 900 var b = this.path.pointTypes[this.typeIdx];\r
 901 var c = java.awt.geom.Path2D.Iterator.curvecoords[b];\r
 902 if (c > 0) {\r
 903 this.affine.transform (this.doubleCoords, this.pointIdx, a, 0, Clazz.doubleToInt (c / 2));\r
 904 }return b;\r
 905 }, "~A");\r
 906 Clazz.defineMethod (c$, "currentSegment", \r
 907 function (a) {\r
 908 var b = this.path.pointTypes[this.typeIdx];\r
 909 var c = java.awt.geom.Path2D.Iterator.curvecoords[b];\r
 910 if (c > 0) {\r
 911 this.affine.transform (this.doubleCoords, this.pointIdx, a, 0, Clazz.doubleToInt (c / 2));\r
 912 }return b;\r
 913 }, "~A");\r
 914 c$ = Clazz.p0p ();\r
 915 c$ = Clazz.p0p ();\r
 916 Clazz.defineStatics (c$,\r
 917 "WIND_EVEN_ODD", 0,\r
 918 "WIND_NON_ZERO", 1,\r
 919 "SEG_MOVETO", 0,\r
 920 "SEG_LINETO", 1,\r
 921 "SEG_QUADTO", 2,\r
 922 "SEG_CUBICTO", 3,\r
 923 "SEG_CLOSE", 4,\r
 924 "INIT_SIZE", 20,\r
 925 "EXPAND_MAX", 500);\r
 926 });\r