FOREIGN MODULE java_awt_geom;

IMPORT
    java_lang,
    java_io,
    java_awt,
    sun_awt_Albert;

TYPE

  AffineTransform* = POINTER TO EXTENSIBLE RECORD (java_lang.Object + java_lang.Cloneable + java_io.Serializable)
                     STATIC
                       TYPE_IDENTITY* = 0;
                       TYPE_TRANSLATION* = 1;
                       TYPE_UNIFORM_SCALE* = 2;
                       TYPE_GENERAL_SCALE* = 4;
                       TYPE_MASK_SCALE* = 6;
                       TYPE_FLIP* = 64;
                       TYPE_QUADRANT_ROTATION* = 8;
                       TYPE_GENERAL_ROTATION* = 16;
                       TYPE_MASK_ROTATION* = 24;
                       TYPE_GENERAL_TRANSFORM* = 32;
                       PROCEDURE Init*() : AffineTransform,CONSTRUCTOR;
                       PROCEDURE Init*(p0 : REAL;
                                       p1 : REAL;
                                       p2 : REAL;
                                       p3 : REAL;
                                       p4 : REAL;
                                       p5 : REAL) : AffineTransform,CONSTRUCTOR;
                       PROCEDURE Init*(p0 : SHORTREAL;
                                       p1 : SHORTREAL;
                                       p2 : SHORTREAL;
                                       p3 : SHORTREAL;
                                       p4 : SHORTREAL;
                                       p5 : SHORTREAL) : AffineTransform,CONSTRUCTOR;
                       PROCEDURE Init*(p0 : AffineTransform) : AffineTransform,CONSTRUCTOR;
                       PROCEDURE Init*(IN  p0 : ARRAY OF REAL) : AffineTransform,CONSTRUCTOR;
                       PROCEDURE Init*(IN  p0 : ARRAY OF SHORTREAL) : AffineTransform,CONSTRUCTOR;
                       PROCEDURE getRotateInstance*(p0 : REAL) : AffineTransform;
                       PROCEDURE getRotateInstance*(p0 : REAL;
                                                    p1 : REAL;
                                                    p2 : REAL) : AffineTransform;
                       PROCEDURE getScaleInstance*(p0 : REAL;
                                                   p1 : REAL) : AffineTransform;
                       PROCEDURE getShearInstance*(p0 : REAL;
                                                   p1 : REAL) : AffineTransform;
                       PROCEDURE getTranslateInstance*(p0 : REAL;
                                                       p1 : REAL) : AffineTransform;
                     END;

  Arc2D$Double* = POINTER TO EXTENSIBLE RECORD (Arc2D)
                    x* : REAL;
                    y* : REAL;
                    width* : REAL;
                    height* : REAL;
                    start* : REAL;
                    extent* : REAL;
                  STATIC
                    PROCEDURE Init*() : Arc2D$Double,CONSTRUCTOR;
                    PROCEDURE Init*(p0 : REAL;
                                    p1 : REAL;
                                    p2 : REAL;
                                    p3 : REAL;
                                    p4 : REAL;
                                    p5 : REAL;
                                    p6 : INTEGER) : Arc2D$Double,CONSTRUCTOR;
                    PROCEDURE Init*(p0 : INTEGER) : Arc2D$Double,CONSTRUCTOR;
                    PROCEDURE Init*(p0 : Rectangle2D;
                                    p1 : REAL;
                                    p2 : REAL;
                                    p3 : INTEGER) : Arc2D$Double,CONSTRUCTOR;
                  END;

  Arc2D$Float* = POINTER TO EXTENSIBLE RECORD (Arc2D)
                   x* : SHORTREAL;
                   y* : SHORTREAL;
                   width* : SHORTREAL;
                   height* : SHORTREAL;
                   start* : SHORTREAL;
                   extent* : SHORTREAL;
                 STATIC
                   PROCEDURE Init*() : Arc2D$Float,CONSTRUCTOR;
                   PROCEDURE Init*(p0 : SHORTREAL;
                                   p1 : SHORTREAL;
                                   p2 : SHORTREAL;
                                   p3 : SHORTREAL;
                                   p4 : SHORTREAL;
                                   p5 : SHORTREAL;
                                   p6 : INTEGER) : Arc2D$Float,CONSTRUCTOR;
                   PROCEDURE Init*(p0 : INTEGER) : Arc2D$Float,CONSTRUCTOR;
                   PROCEDURE Init*(p0 : Rectangle2D;
                                   p1 : SHORTREAL;
                                   p2 : SHORTREAL;
                                   p3 : INTEGER) : Arc2D$Float,CONSTRUCTOR;
                 END;

  Arc2D* = POINTER TO ABSTRACT RECORD (RectangularShape)
           STATIC
             OPEN* = 0;
             CHORD* = 1;
             PIE* = 2;
             PROCEDURE Init!(p0 : INTEGER) : Arc2D,CONSTRUCTOR;
           END;

  Area* = POINTER TO EXTENSIBLE RECORD (java_lang.Object + java_awt.Shape + java_lang.Cloneable)
          STATIC
            PROCEDURE Init*() : Area,CONSTRUCTOR;
            PROCEDURE Init*(p0 : java_awt.Shape) : Area,CONSTRUCTOR;
          END;

  CubicCurve2D$Double* = POINTER TO EXTENSIBLE RECORD (CubicCurve2D)
                           x1* : REAL;
                           y1* : REAL;
                           ctrlx1* : REAL;
                           ctrly1* : REAL;
                           ctrlx2* : REAL;
                           ctrly2* : REAL;
                           x2* : REAL;
                           y2* : REAL;
                         STATIC
                           PROCEDURE Init*() : CubicCurve2D$Double,CONSTRUCTOR;
                           PROCEDURE Init*(p0 : REAL;
                                           p1 : REAL;
                                           p2 : REAL;
                                           p3 : REAL;
                                           p4 : REAL;
                                           p5 : REAL;
                                           p6 : REAL;
                                           p7 : REAL) : CubicCurve2D$Double,CONSTRUCTOR;
                         END;

  CubicCurve2D$Float* = POINTER TO EXTENSIBLE RECORD (CubicCurve2D)
                          x1* : SHORTREAL;
                          y1* : SHORTREAL;
                          ctrlx1* : SHORTREAL;
                          ctrly1* : SHORTREAL;
                          ctrlx2* : SHORTREAL;
                          ctrly2* : SHORTREAL;
                          x2* : SHORTREAL;
                          y2* : SHORTREAL;
                        STATIC
                          PROCEDURE Init*() : CubicCurve2D$Float,CONSTRUCTOR;
                          PROCEDURE Init*(p0 : SHORTREAL;
                                          p1 : SHORTREAL;
                                          p2 : SHORTREAL;
                                          p3 : SHORTREAL;
                                          p4 : SHORTREAL;
                                          p5 : SHORTREAL;
                                          p6 : SHORTREAL;
                                          p7 : SHORTREAL) : CubicCurve2D$Float,CONSTRUCTOR;
                        END;

  CubicCurve2D* = POINTER TO ABSTRACT RECORD (java_lang.Object + java_awt.Shape + java_lang.Cloneable)
                  STATIC
                    PROCEDURE Init!() : CubicCurve2D,CONSTRUCTOR;
                    PROCEDURE getFlatness*(p0 : REAL;
                                           p1 : REAL;
                                           p2 : REAL;
                                           p3 : REAL;
                                           p4 : REAL;
                                           p5 : REAL;
                                           p6 : REAL;
                                           p7 : REAL) : REAL;
                    PROCEDURE getFlatness*(IN  p0 : ARRAY OF REAL;
                                               p1 : INTEGER) : REAL;
                    PROCEDURE getFlatnessSq*(p0 : REAL;
                                             p1 : REAL;
                                             p2 : REAL;
                                             p3 : REAL;
                                             p4 : REAL;
                                             p5 : REAL;
                                             p6 : REAL;
                                             p7 : REAL) : REAL;
                    PROCEDURE getFlatnessSq*(IN  p0 : ARRAY OF REAL;
                                                 p1 : INTEGER) : REAL;
                    PROCEDURE solveCubic*(IN  p0 : ARRAY OF REAL) : INTEGER;
                    PROCEDURE subdivide*(p0 : CubicCurve2D;
                                         p1 : CubicCurve2D;
                                         p2 : CubicCurve2D);
                    PROCEDURE subdivide*(IN  p0 : ARRAY OF REAL;
                                             p1 : INTEGER;
                                         IN  p2 : ARRAY OF REAL;
                                             p3 : INTEGER;
                                         IN  p4 : ARRAY OF REAL;
                                             p5 : INTEGER);
                  END;

  Dimension2D* = POINTER TO ABSTRACT RECORD (java_lang.Object + java_lang.Cloneable)
                 STATIC
                   PROCEDURE Init!() : Dimension2D,CONSTRUCTOR;
                 END;

  Ellipse2D$Double* = POINTER TO EXTENSIBLE RECORD (Ellipse2D)
                        x* : REAL;
                        y* : REAL;
                        width* : REAL;
                        height* : REAL;
                      STATIC
                        PROCEDURE Init*() : Ellipse2D$Double,CONSTRUCTOR;
                        PROCEDURE Init*(p0 : REAL;
                                        p1 : REAL;
                                        p2 : REAL;
                                        p3 : REAL) : Ellipse2D$Double,CONSTRUCTOR;
                      END;

  Ellipse2D$Float* = POINTER TO EXTENSIBLE RECORD (Ellipse2D)
                       x* : SHORTREAL;
                       y* : SHORTREAL;
                       width* : SHORTREAL;
                       height* : SHORTREAL;
                     STATIC
                       PROCEDURE Init*() : Ellipse2D$Float,CONSTRUCTOR;
                       PROCEDURE Init*(p0 : SHORTREAL;
                                       p1 : SHORTREAL;
                                       p2 : SHORTREAL;
                                       p3 : SHORTREAL) : Ellipse2D$Float,CONSTRUCTOR;
                     END;

  Ellipse2D* = POINTER TO ABSTRACT RECORD (RectangularShape)
               STATIC
                 PROCEDURE Init!() : Ellipse2D,CONSTRUCTOR;
               END;

  FlatteningPathIterator* = POINTER TO EXTENSIBLE RECORD (java_lang.Object + PathIterator)
                            STATIC
                              PROCEDURE Init*(p0 : PathIterator;
                                              p1 : REAL) : FlatteningPathIterator,CONSTRUCTOR;
                              PROCEDURE Init*(p0 : PathIterator;
                                              p1 : REAL;
                                              p2 : INTEGER) : FlatteningPathIterator,CONSTRUCTOR;
                            END;

  GeneralPath* = POINTER TO RECORD (java_lang.Object + java_awt.Shape + java_lang.Cloneable)
                 STATIC
                   WIND_EVEN_ODD* = 0;
                   WIND_NON_ZERO* = 1;
                   PROCEDURE Init*() : GeneralPath,CONSTRUCTOR;
                   PROCEDURE Init*(p0 : INTEGER) : GeneralPath,CONSTRUCTOR;
                   PROCEDURE Init*(p0 : INTEGER;
                                   p1 : INTEGER) : GeneralPath,CONSTRUCTOR;
                   PROCEDURE Init*(p0 : java_awt.Shape) : GeneralPath,CONSTRUCTOR;
                 END;

  IllegalPathStateException* = POINTER TO EXTENSIBLE RECORD (java_lang.RuntimeException)
                               STATIC
                                 PROCEDURE Init*() : IllegalPathStateException,CONSTRUCTOR;
                                 PROCEDURE Init*(p0 : java_lang.String) : IllegalPathStateException,CONSTRUCTOR;
                               END;

  Line2D$Double* = POINTER TO EXTENSIBLE RECORD (Line2D)
                     x1* : REAL;
                     y1* : REAL;
                     x2* : REAL;
                     y2* : REAL;
                   STATIC
                     PROCEDURE Init*() : Line2D$Double,CONSTRUCTOR;
                     PROCEDURE Init*(p0 : REAL;
                                     p1 : REAL;
                                     p2 : REAL;
                                     p3 : REAL) : Line2D$Double,CONSTRUCTOR;
                     PROCEDURE Init*(p0 : Point2D;
                                     p1 : Point2D) : Line2D$Double,CONSTRUCTOR;
                   END;

  Line2D$Float* = POINTER TO EXTENSIBLE RECORD (Line2D)
                    x1* : SHORTREAL;
                    y1* : SHORTREAL;
                    x2* : SHORTREAL;
                    y2* : SHORTREAL;
                  STATIC
                    PROCEDURE Init*() : Line2D$Float,CONSTRUCTOR;
                    PROCEDURE Init*(p0 : SHORTREAL;
                                    p1 : SHORTREAL;
                                    p2 : SHORTREAL;
                                    p3 : SHORTREAL) : Line2D$Float,CONSTRUCTOR;
                    PROCEDURE Init*(p0 : Point2D;
                                    p1 : Point2D) : Line2D$Float,CONSTRUCTOR;
                  END;

  Line2D* = POINTER TO ABSTRACT RECORD (java_lang.Object + java_awt.Shape + java_lang.Cloneable)
            STATIC
              PROCEDURE Init!() : Line2D,CONSTRUCTOR;
              PROCEDURE linesIntersect*(p0 : REAL;
                                        p1 : REAL;
                                        p2 : REAL;
                                        p3 : REAL;
                                        p4 : REAL;
                                        p5 : REAL;
                                        p6 : REAL;
                                        p7 : REAL) : BOOLEAN;
              PROCEDURE ptLineDist*(p0 : REAL;
                                    p1 : REAL;
                                    p2 : REAL;
                                    p3 : REAL;
                                    p4 : REAL;
                                    p5 : REAL) : REAL;
              PROCEDURE ptLineDistSq*(p0 : REAL;
                                      p1 : REAL;
                                      p2 : REAL;
                                      p3 : REAL;
                                      p4 : REAL;
                                      p5 : REAL) : REAL;
              PROCEDURE ptSegDist*(p0 : REAL;
                                   p1 : REAL;
                                   p2 : REAL;
                                   p3 : REAL;
                                   p4 : REAL;
                                   p5 : REAL) : REAL;
              PROCEDURE ptSegDistSq*(p0 : REAL;
                                     p1 : REAL;
                                     p2 : REAL;
                                     p3 : REAL;
                                     p4 : REAL;
                                     p5 : REAL) : REAL;
              PROCEDURE relativeCCW*(p0 : REAL;
                                     p1 : REAL;
                                     p2 : REAL;
                                     p3 : REAL;
                                     p4 : REAL;
                                     p5 : REAL) : INTEGER;
            END;

  NoninvertibleTransformException* = POINTER TO EXTENSIBLE RECORD (java_lang.Exception)
                                     STATIC
                                       PROCEDURE Init*(p0 : java_lang.String) : NoninvertibleTransformException,CONSTRUCTOR;
                                     END;

  PathIterator* = POINTER TO INTERFACE RECORD (java_lang.Object)
                  STATIC
                    WIND_EVEN_ODD* = 0;
                    WIND_NON_ZERO* = 1;
                    SEG_MOVETO* = 0;
                    SEG_LINETO* = 1;
                    SEG_QUADTO* = 2;
                    SEG_CUBICTO* = 3;
                    SEG_CLOSE* = 4;
                  END;

  Point2D$Double* = POINTER TO EXTENSIBLE RECORD (Point2D)
                      x* : REAL;
                      y* : REAL;
                    STATIC
                      PROCEDURE Init*() : Point2D$Double,CONSTRUCTOR;
                      PROCEDURE Init*(p0 : REAL;
                                      p1 : REAL) : Point2D$Double,CONSTRUCTOR;
                    END;

  Point2D$Float* = POINTER TO EXTENSIBLE RECORD (Point2D)
                     x* : SHORTREAL;
                     y* : SHORTREAL;
                   STATIC
                     PROCEDURE Init*() : Point2D$Float,CONSTRUCTOR;
                     PROCEDURE Init*(p0 : SHORTREAL;
                                     p1 : SHORTREAL) : Point2D$Float,CONSTRUCTOR;
                   END;

  Point2D* = POINTER TO ABSTRACT RECORD (java_lang.Object + java_lang.Cloneable)
             STATIC
               PROCEDURE Init!() : Point2D,CONSTRUCTOR;
               PROCEDURE distance*(p0 : REAL;
                                   p1 : REAL;
                                   p2 : REAL;
                                   p3 : REAL) : REAL;
               PROCEDURE distanceSq*(p0 : REAL;
                                     p1 : REAL;
                                     p2 : REAL;
                                     p3 : REAL) : REAL;
             END;

  QuadCurve2D$Double* = POINTER TO EXTENSIBLE RECORD (QuadCurve2D)
                          x1* : REAL;
                          y1* : REAL;
                          ctrlx* : REAL;
                          ctrly* : REAL;
                          x2* : REAL;
                          y2* : REAL;
                        STATIC
                          PROCEDURE Init*() : QuadCurve2D$Double,CONSTRUCTOR;
                          PROCEDURE Init*(p0 : REAL;
                                          p1 : REAL;
                                          p2 : REAL;
                                          p3 : REAL;
                                          p4 : REAL;
                                          p5 : REAL) : QuadCurve2D$Double,CONSTRUCTOR;
                        END;

  QuadCurve2D$Float* = POINTER TO EXTENSIBLE RECORD (QuadCurve2D)
                         x1* : SHORTREAL;
                         y1* : SHORTREAL;
                         ctrlx* : SHORTREAL;
                         ctrly* : SHORTREAL;
                         x2* : SHORTREAL;
                         y2* : SHORTREAL;
                       STATIC
                         PROCEDURE Init*() : QuadCurve2D$Float,CONSTRUCTOR;
                         PROCEDURE Init*(p0 : SHORTREAL;
                                         p1 : SHORTREAL;
                                         p2 : SHORTREAL;
                                         p3 : SHORTREAL;
                                         p4 : SHORTREAL;
                                         p5 : SHORTREAL) : QuadCurve2D$Float,CONSTRUCTOR;
                       END;

  QuadCurve2D* = POINTER TO ABSTRACT RECORD (java_lang.Object + java_awt.Shape + java_lang.Cloneable)
                 STATIC
                   PROCEDURE Init!() : QuadCurve2D,CONSTRUCTOR;
                   PROCEDURE getFlatness*(p0 : REAL;
                                          p1 : REAL;
                                          p2 : REAL;
                                          p3 : REAL;
                                          p4 : REAL;
                                          p5 : REAL) : REAL;
                   PROCEDURE getFlatness*(IN  p0 : ARRAY OF REAL;
                                              p1 : INTEGER) : REAL;
                   PROCEDURE getFlatnessSq*(p0 : REAL;
                                            p1 : REAL;
                                            p2 : REAL;
                                            p3 : REAL;
                                            p4 : REAL;
                                            p5 : REAL) : REAL;
                   PROCEDURE getFlatnessSq*(IN  p0 : ARRAY OF REAL;
                                                p1 : INTEGER) : REAL;
                   PROCEDURE solveQuadratic*(IN  p0 : ARRAY OF REAL) : INTEGER;
                   PROCEDURE subdivide*(p0 : QuadCurve2D;
                                        p1 : QuadCurve2D;
                                        p2 : QuadCurve2D);
                   PROCEDURE subdivide*(IN  p0 : ARRAY OF REAL;
                                            p1 : INTEGER;
                                        IN  p2 : ARRAY OF REAL;
                                            p3 : INTEGER;
                                        IN  p4 : ARRAY OF REAL;
                                            p5 : INTEGER);
                 END;

  Rectangle2D$Double* = POINTER TO EXTENSIBLE RECORD (Rectangle2D)
                          x* : REAL;
                          y* : REAL;
                          width* : REAL;
                          height* : REAL;
                        STATIC
                          PROCEDURE Init*() : Rectangle2D$Double,CONSTRUCTOR;
                          PROCEDURE Init*(p0 : REAL;
                                          p1 : REAL;
                                          p2 : REAL;
                                          p3 : REAL) : Rectangle2D$Double,CONSTRUCTOR;
                        END;

  Rectangle2D$Float* = POINTER TO EXTENSIBLE RECORD (Rectangle2D)
                         x* : SHORTREAL;
                         y* : SHORTREAL;
                         width* : SHORTREAL;
                         height* : SHORTREAL;
                       STATIC
                         PROCEDURE Init*() : Rectangle2D$Float,CONSTRUCTOR;
                         PROCEDURE Init*(p0 : SHORTREAL;
                                         p1 : SHORTREAL;
                                         p2 : SHORTREAL;
                                         p3 : SHORTREAL) : Rectangle2D$Float,CONSTRUCTOR;
                       END;

  Rectangle2D* = POINTER TO ABSTRACT RECORD (RectangularShape)
                 STATIC
                   OUT_LEFT* = 1;
                   OUT_TOP* = 2;
                   OUT_RIGHT* = 4;
                   OUT_BOTTOM* = 8;
                   PROCEDURE Init!() : Rectangle2D,CONSTRUCTOR;
                   PROCEDURE intersect*(p0 : Rectangle2D;
                                        p1 : Rectangle2D;
                                        p2 : Rectangle2D);
                   PROCEDURE union*(p0 : Rectangle2D;
                                    p1 : Rectangle2D;
                                    p2 : Rectangle2D);
                 END;

  RectangularShape* = POINTER TO ABSTRACT RECORD (java_lang.Object + java_awt.Shape + java_lang.Cloneable)
                      STATIC
                        PROCEDURE Init!() : RectangularShape,CONSTRUCTOR;
                      END;

  RoundRectangle2D$Double* = POINTER TO EXTENSIBLE RECORD (RoundRectangle2D)
                               x* : REAL;
                               y* : REAL;
                               width* : REAL;
                               height* : REAL;
                               arcwidth* : REAL;
                               archeight* : REAL;
                             STATIC
                               PROCEDURE Init*() : RoundRectangle2D$Double,CONSTRUCTOR;
                               PROCEDURE Init*(p0 : REAL;
                                               p1 : REAL;
                                               p2 : REAL;
                                               p3 : REAL;
                                               p4 : REAL;
                                               p5 : REAL) : RoundRectangle2D$Double,CONSTRUCTOR;
                             END;

  RoundRectangle2D$Float* = POINTER TO EXTENSIBLE RECORD (RoundRectangle2D)
                              x* : SHORTREAL;
                              y* : SHORTREAL;
                              width* : SHORTREAL;
                              height* : SHORTREAL;
                              arcwidth* : SHORTREAL;
                              archeight* : SHORTREAL;
                            STATIC
                              PROCEDURE Init*() : RoundRectangle2D$Float,CONSTRUCTOR;
                              PROCEDURE Init*(p0 : SHORTREAL;
                                              p1 : SHORTREAL;
                                              p2 : SHORTREAL;
                                              p3 : SHORTREAL;
                                              p4 : SHORTREAL;
                                              p5 : SHORTREAL) : RoundRectangle2D$Float,CONSTRUCTOR;
                            END;

  RoundRectangle2D* = POINTER TO ABSTRACT RECORD (RectangularShape)
                      STATIC
                        PROCEDURE Init!() : RoundRectangle2D,CONSTRUCTOR;
                      END;




PROCEDURE (self:AffineTransform) clone*() : java_lang.Object,EXTENSIBLE;

PROCEDURE (self:AffineTransform) concatenate*(p0 : AffineTransform),NEW,EXTENSIBLE;

PROCEDURE (self:AffineTransform) createInverse*() : AffineTransform,NEW,EXTENSIBLE;

PROCEDURE (self:AffineTransform) createTransformedShape*(p0 : java_awt.Shape) : java_awt.Shape,NEW,EXTENSIBLE;

PROCEDURE (self:AffineTransform) deltaTransform*(p0 : Point2D;
                                                 p1 : Point2D) : Point2D,NEW,EXTENSIBLE;

PROCEDURE (self:AffineTransform) deltaTransform*(IN  p0 : ARRAY OF REAL;
                                                     p1 : INTEGER;
                                                 IN  p2 : ARRAY OF REAL;
                                                     p3 : INTEGER;
                                                     p4 : INTEGER),NEW,EXTENSIBLE;

PROCEDURE (self:AffineTransform) equals*(p0 : java_lang.Object) : BOOLEAN,EXTENSIBLE;

PROCEDURE (self:AffineTransform) getDeterminant*() : REAL,NEW,EXTENSIBLE;

PROCEDURE (self:AffineTransform) getMatrix*(IN  p0 : ARRAY OF REAL),NEW,EXTENSIBLE;

PROCEDURE (self:AffineTransform) getScaleX*() : REAL,NEW,EXTENSIBLE;

PROCEDURE (self:AffineTransform) getScaleY*() : REAL,NEW,EXTENSIBLE;

PROCEDURE (self:AffineTransform) getShearX*() : REAL,NEW,EXTENSIBLE;

PROCEDURE (self:AffineTransform) getShearY*() : REAL,NEW,EXTENSIBLE;

PROCEDURE (self:AffineTransform) getTranslateX*() : REAL,NEW,EXTENSIBLE;

PROCEDURE (self:AffineTransform) getTranslateY*() : REAL,NEW,EXTENSIBLE;

PROCEDURE (self:AffineTransform) getType*() : INTEGER,NEW,EXTENSIBLE;

PROCEDURE (self:AffineTransform) hashCode*() : INTEGER,EXTENSIBLE;

PROCEDURE (self:AffineTransform) inverseTransform*(p0 : Point2D;
                                                   p1 : Point2D) : Point2D,NEW,EXTENSIBLE;

PROCEDURE (self:AffineTransform) inverseTransform*(IN  p0 : ARRAY OF REAL;
                                                       p1 : INTEGER;
                                                   IN  p2 : ARRAY OF REAL;
                                                       p3 : INTEGER;
                                                       p4 : INTEGER),NEW,EXTENSIBLE;

PROCEDURE (self:AffineTransform) isIdentity*() : BOOLEAN,NEW,EXTENSIBLE;

PROCEDURE (self:AffineTransform) preConcatenate*(p0 : AffineTransform),NEW,EXTENSIBLE;

PROCEDURE (self:AffineTransform) rotate*(p0 : REAL),NEW,EXTENSIBLE;

PROCEDURE (self:AffineTransform) rotate*(p0 : REAL;
                                         p1 : REAL;
                                         p2 : REAL),NEW,EXTENSIBLE;

PROCEDURE (self:AffineTransform) scale*(p0 : REAL;
                                        p1 : REAL),NEW,EXTENSIBLE;

PROCEDURE (self:AffineTransform) setToIdentity*(),NEW,EXTENSIBLE;

PROCEDURE (self:AffineTransform) setToRotation*(p0 : REAL),NEW,EXTENSIBLE;

PROCEDURE (self:AffineTransform) setToRotation*(p0 : REAL;
                                                p1 : REAL;
                                                p2 : REAL),NEW,EXTENSIBLE;

PROCEDURE (self:AffineTransform) setToScale*(p0 : REAL;
                                             p1 : REAL),NEW,EXTENSIBLE;

PROCEDURE (self:AffineTransform) setToShear*(p0 : REAL;
                                             p1 : REAL),NEW,EXTENSIBLE;

PROCEDURE (self:AffineTransform) setToTranslation*(p0 : REAL;
                                                   p1 : REAL),NEW,EXTENSIBLE;

PROCEDURE (self:AffineTransform) setTransform*(p0 : REAL;
                                               p1 : REAL;
                                               p2 : REAL;
                                               p3 : REAL;
                                               p4 : REAL;
                                               p5 : REAL),NEW,EXTENSIBLE;

PROCEDURE (self:AffineTransform) setTransform*(p0 : AffineTransform),NEW,EXTENSIBLE;

PROCEDURE (self:AffineTransform) shear*(p0 : REAL;
                                        p1 : REAL),NEW,EXTENSIBLE;

PROCEDURE (self:AffineTransform) toString*() : java_lang.String,EXTENSIBLE;

PROCEDURE (self:AffineTransform) transform*(p0 : Point2D;
                                            p1 : Point2D) : Point2D,NEW,EXTENSIBLE;

PROCEDURE (self:AffineTransform) transform*(IN  p0 : ARRAY OF REAL;
                                                p1 : INTEGER;
                                            IN  p2 : ARRAY OF REAL;
                                                p3 : INTEGER;
                                                p4 : INTEGER),NEW,EXTENSIBLE;

PROCEDURE (self:AffineTransform) transform*(IN  p0 : ARRAY OF REAL;
                                                p1 : INTEGER;
                                            IN  p2 : ARRAY OF SHORTREAL;
                                                p3 : INTEGER;
                                                p4 : INTEGER),NEW,EXTENSIBLE;

PROCEDURE (self:AffineTransform) transform*(IN  p0 : ARRAY OF SHORTREAL;
                                                p1 : INTEGER;
                                            IN  p2 : ARRAY OF REAL;
                                                p3 : INTEGER;
                                                p4 : INTEGER),NEW,EXTENSIBLE;

PROCEDURE (self:AffineTransform) transform*(IN  p0 : ARRAY OF SHORTREAL;
                                                p1 : INTEGER;
                                            IN  p2 : ARRAY OF SHORTREAL;
                                                p3 : INTEGER;
                                                p4 : INTEGER),NEW,EXTENSIBLE;

PROCEDURE (self:AffineTransform) transform*(IN  p0 : ARRAY OF Point2D;
                                                p1 : INTEGER;
                                            IN  p2 : ARRAY OF Point2D;
                                                p3 : INTEGER;
                                                p4 : INTEGER),NEW,EXTENSIBLE;

PROCEDURE (self:AffineTransform) translate*(p0 : REAL;
                                            p1 : REAL),NEW,EXTENSIBLE;

PROCEDURE (self:Arc2D$Double) getAngleExtent*() : REAL,EXTENSIBLE;

PROCEDURE (self:Arc2D$Double) getAngleStart*() : REAL,EXTENSIBLE;

PROCEDURE (self:Arc2D$Double) getHeight*() : REAL,EXTENSIBLE;

PROCEDURE (self:Arc2D$Double) getWidth*() : REAL,EXTENSIBLE;

PROCEDURE (self:Arc2D$Double) getX*() : REAL,EXTENSIBLE;

PROCEDURE (self:Arc2D$Double) getY*() : REAL,EXTENSIBLE;

PROCEDURE (self:Arc2D$Double) isEmpty*() : BOOLEAN,EXTENSIBLE;

PROCEDURE (self:Arc2D$Double) makeBounds!(p0 : REAL;
                                          p1 : REAL;
                                          p2 : REAL;
                                          p3 : REAL) : Rectangle2D,EXTENSIBLE;

PROCEDURE (self:Arc2D$Double) setAngleExtent*(p0 : REAL),EXTENSIBLE;

PROCEDURE (self:Arc2D$Double) setAngleStart*(p0 : REAL),EXTENSIBLE;

PROCEDURE (self:Arc2D$Double) setArc*(p0 : REAL;
                                      p1 : REAL;
                                      p2 : REAL;
                                      p3 : REAL;
                                      p4 : REAL;
                                      p5 : REAL;
                                      p6 : INTEGER),EXTENSIBLE;

PROCEDURE (self:Arc2D$Float) getAngleExtent*() : REAL,EXTENSIBLE;

PROCEDURE (self:Arc2D$Float) getAngleStart*() : REAL,EXTENSIBLE;

PROCEDURE (self:Arc2D$Float) getHeight*() : REAL,EXTENSIBLE;

PROCEDURE (self:Arc2D$Float) getWidth*() : REAL,EXTENSIBLE;

PROCEDURE (self:Arc2D$Float) getX*() : REAL,EXTENSIBLE;

PROCEDURE (self:Arc2D$Float) getY*() : REAL,EXTENSIBLE;

PROCEDURE (self:Arc2D$Float) isEmpty*() : BOOLEAN,EXTENSIBLE;

PROCEDURE (self:Arc2D$Float) makeBounds!(p0 : REAL;
                                         p1 : REAL;
                                         p2 : REAL;
                                         p3 : REAL) : Rectangle2D,EXTENSIBLE;

PROCEDURE (self:Arc2D$Float) setAngleExtent*(p0 : REAL),EXTENSIBLE;

PROCEDURE (self:Arc2D$Float) setAngleStart*(p0 : REAL),EXTENSIBLE;

PROCEDURE (self:Arc2D$Float) setArc*(p0 : REAL;
                                     p1 : REAL;
                                     p2 : REAL;
                                     p3 : REAL;
                                     p4 : REAL;
                                     p5 : REAL;
                                     p6 : INTEGER),EXTENSIBLE;

PROCEDURE (self:Arc2D) contains*(p0 : REAL;
                                 p1 : REAL) : BOOLEAN,EXTENSIBLE;

PROCEDURE (self:Arc2D) contains*(p0 : REAL;
                                 p1 : REAL;
                                 p2 : REAL;
                                 p3 : REAL) : BOOLEAN,EXTENSIBLE;

PROCEDURE (self:Arc2D) contains*(p0 : Rectangle2D) : BOOLEAN,EXTENSIBLE;

PROCEDURE (self:Arc2D) containsAngle*(p0 : REAL) : BOOLEAN,NEW,EXTENSIBLE;

PROCEDURE (self:Arc2D) getAngleExtent*() : REAL,NEW,ABSTRACT;

PROCEDURE (self:Arc2D) getAngleStart*() : REAL,NEW,ABSTRACT;

PROCEDURE (self:Arc2D) getArcType*() : INTEGER,NEW,EXTENSIBLE;

PROCEDURE (self:Arc2D) getBounds2D*() : Rectangle2D,EXTENSIBLE;

PROCEDURE (self:Arc2D) getEndPoint*() : Point2D,NEW,EXTENSIBLE;

PROCEDURE (self:Arc2D) getPathIterator*(p0 : AffineTransform) : PathIterator,EXTENSIBLE;

PROCEDURE (self:Arc2D) getStartPoint*() : Point2D,NEW,EXTENSIBLE;

PROCEDURE (self:Arc2D) intersects*(p0 : REAL;
                                   p1 : REAL;
                                   p2 : REAL;
                                   p3 : REAL) : BOOLEAN,EXTENSIBLE;

PROCEDURE (self:Arc2D) makeBounds!(p0 : REAL;
                                   p1 : REAL;
                                   p2 : REAL;
                                   p3 : REAL) : Rectangle2D,NEW,ABSTRACT;

PROCEDURE (self:Arc2D) setAngleExtent*(p0 : REAL),NEW,ABSTRACT;

PROCEDURE (self:Arc2D) setAngleStart*(p0 : REAL),NEW,ABSTRACT;

PROCEDURE (self:Arc2D) setAngleStart*(p0 : Point2D),NEW,EXTENSIBLE;

PROCEDURE (self:Arc2D) setAngles*(p0 : REAL;
                                  p1 : REAL;
                                  p2 : REAL;
                                  p3 : REAL),NEW,EXTENSIBLE;

PROCEDURE (self:Arc2D) setAngles*(p0 : Point2D;
                                  p1 : Point2D),NEW,EXTENSIBLE;

PROCEDURE (self:Arc2D) setArc*(p0 : REAL;
                               p1 : REAL;
                               p2 : REAL;
                               p3 : REAL;
                               p4 : REAL;
                               p5 : REAL;
                               p6 : INTEGER),NEW,ABSTRACT;

PROCEDURE (self:Arc2D) setArc*(p0 : Arc2D),NEW,EXTENSIBLE;

PROCEDURE (self:Arc2D) setArc*(p0 : Point2D;
                               p1 : Dimension2D;
                               p2 : REAL;
                               p3 : REAL;
                               p4 : INTEGER),NEW,EXTENSIBLE;

PROCEDURE (self:Arc2D) setArc*(p0 : Rectangle2D;
                               p1 : REAL;
                               p2 : REAL;
                               p3 : INTEGER),NEW,EXTENSIBLE;

PROCEDURE (self:Arc2D) setArcByCenter*(p0 : REAL;
                                       p1 : REAL;
                                       p2 : REAL;
                                       p3 : REAL;
                                       p4 : REAL;
                                       p5 : INTEGER),NEW,EXTENSIBLE;

PROCEDURE (self:Arc2D) setArcByTangent*(p0 : Point2D;
                                        p1 : Point2D;
                                        p2 : Point2D;
                                        p3 : REAL),NEW,EXTENSIBLE;

PROCEDURE (self:Arc2D) setArcType*(p0 : INTEGER),NEW,EXTENSIBLE;

PROCEDURE (self:Arc2D) setFrame*(p0 : REAL;
                                 p1 : REAL;
                                 p2 : REAL;
                                 p3 : REAL),EXTENSIBLE;

PROCEDURE (self:Area) add*(p0 : Area),NEW,EXTENSIBLE;

PROCEDURE (self:Area) clone*() : java_lang.Object,EXTENSIBLE;

PROCEDURE (self:Area) contains*(p0 : REAL;
                                p1 : REAL) : BOOLEAN,NEW,EXTENSIBLE;

PROCEDURE (self:Area) contains*(p0 : REAL;
                                p1 : REAL;
                                p2 : REAL;
                                p3 : REAL) : BOOLEAN,NEW,EXTENSIBLE;

PROCEDURE (self:Area) contains*(p0 : Point2D) : BOOLEAN,NEW,EXTENSIBLE;

PROCEDURE (self:Area) contains*(p0 : Rectangle2D) : BOOLEAN,NEW,EXTENSIBLE;

PROCEDURE (self:Area) createTransformedArea*(p0 : AffineTransform) : Area,NEW,EXTENSIBLE;

PROCEDURE (self:Area) equals*(p0 : Area) : BOOLEAN,NEW,EXTENSIBLE;

PROCEDURE (self:Area) exclusiveOr*(p0 : Area),NEW,EXTENSIBLE;

PROCEDURE (self:Area) getBounds*() : java_awt.Rectangle,NEW,EXTENSIBLE;

PROCEDURE (self:Area) getBounds2D*() : Rectangle2D,NEW,EXTENSIBLE;

PROCEDURE (self:Area) getPathIterator*(p0 : AffineTransform) : PathIterator,NEW,EXTENSIBLE;

PROCEDURE (self:Area) getPathIterator*(p0 : AffineTransform;
                                       p1 : REAL) : PathIterator,NEW,EXTENSIBLE;

PROCEDURE (self:Area) intersect*(p0 : Area),NEW,EXTENSIBLE;

PROCEDURE (self:Area) intersects*(p0 : REAL;
                                  p1 : REAL;
                                  p2 : REAL;
                                  p3 : REAL) : BOOLEAN,NEW,EXTENSIBLE;

PROCEDURE (self:Area) intersects*(p0 : Rectangle2D) : BOOLEAN,NEW,EXTENSIBLE;

PROCEDURE (self:Area) isEmpty*() : BOOLEAN,NEW,EXTENSIBLE;

PROCEDURE (self:Area) isPolygonal*() : BOOLEAN,NEW,EXTENSIBLE;

PROCEDURE (self:Area) isRectangular*() : BOOLEAN,NEW,EXTENSIBLE;

PROCEDURE (self:Area) isSingular*() : BOOLEAN,NEW,EXTENSIBLE;

PROCEDURE (self:Area) reset*(),NEW,EXTENSIBLE;

PROCEDURE (self:Area) subtract*(p0 : Area),NEW,EXTENSIBLE;

PROCEDURE (self:Area) transform*(p0 : AffineTransform),NEW,EXTENSIBLE;

PROCEDURE (self:CubicCurve2D$Double) getBounds2D*() : Rectangle2D,EXTENSIBLE;

PROCEDURE (self:CubicCurve2D$Double) getCtrlP1*() : Point2D,EXTENSIBLE;

PROCEDURE (self:CubicCurve2D$Double) getCtrlP2*() : Point2D,EXTENSIBLE;

PROCEDURE (self:CubicCurve2D$Double) getCtrlX1*() : REAL,EXTENSIBLE;

PROCEDURE (self:CubicCurve2D$Double) getCtrlX2*() : REAL,EXTENSIBLE;

PROCEDURE (self:CubicCurve2D$Double) getCtrlY1*() : REAL,EXTENSIBLE;

PROCEDURE (self:CubicCurve2D$Double) getCtrlY2*() : REAL,EXTENSIBLE;

PROCEDURE (self:CubicCurve2D$Double) getP1*() : Point2D,EXTENSIBLE;

PROCEDURE (self:CubicCurve2D$Double) getP2*() : Point2D,EXTENSIBLE;

PROCEDURE (self:CubicCurve2D$Double) getX1*() : REAL,EXTENSIBLE;

PROCEDURE (self:CubicCurve2D$Double) getX2*() : REAL,EXTENSIBLE;

PROCEDURE (self:CubicCurve2D$Double) getY1*() : REAL,EXTENSIBLE;

PROCEDURE (self:CubicCurve2D$Double) getY2*() : REAL,EXTENSIBLE;

PROCEDURE (self:CubicCurve2D$Double) setCurve*(p0 : REAL;
                                               p1 : REAL;
                                               p2 : REAL;
                                               p3 : REAL;
                                               p4 : REAL;
                                               p5 : REAL;
                                               p6 : REAL;
                                               p7 : REAL),EXTENSIBLE;

PROCEDURE (self:CubicCurve2D$Float) getBounds2D*() : Rectangle2D,EXTENSIBLE;

PROCEDURE (self:CubicCurve2D$Float) getCtrlP1*() : Point2D,EXTENSIBLE;

PROCEDURE (self:CubicCurve2D$Float) getCtrlP2*() : Point2D,EXTENSIBLE;

PROCEDURE (self:CubicCurve2D$Float) getCtrlX1*() : REAL,EXTENSIBLE;

PROCEDURE (self:CubicCurve2D$Float) getCtrlX2*() : REAL,EXTENSIBLE;

PROCEDURE (self:CubicCurve2D$Float) getCtrlY1*() : REAL,EXTENSIBLE;

PROCEDURE (self:CubicCurve2D$Float) getCtrlY2*() : REAL,EXTENSIBLE;

PROCEDURE (self:CubicCurve2D$Float) getP1*() : Point2D,EXTENSIBLE;

PROCEDURE (self:CubicCurve2D$Float) getP2*() : Point2D,EXTENSIBLE;

PROCEDURE (self:CubicCurve2D$Float) getX1*() : REAL,EXTENSIBLE;

PROCEDURE (self:CubicCurve2D$Float) getX2*() : REAL,EXTENSIBLE;

PROCEDURE (self:CubicCurve2D$Float) getY1*() : REAL,EXTENSIBLE;

PROCEDURE (self:CubicCurve2D$Float) getY2*() : REAL,EXTENSIBLE;

PROCEDURE (self:CubicCurve2D$Float) setCurve*(p0 : REAL;
                                              p1 : REAL;
                                              p2 : REAL;
                                              p3 : REAL;
                                              p4 : REAL;
                                              p5 : REAL;
                                              p6 : REAL;
                                              p7 : REAL),EXTENSIBLE;

PROCEDURE (self:CubicCurve2D$Float) setCurve*(p0 : SHORTREAL;
                                              p1 : SHORTREAL;
                                              p2 : SHORTREAL;
                                              p3 : SHORTREAL;
                                              p4 : SHORTREAL;
                                              p5 : SHORTREAL;
                                              p6 : SHORTREAL;
                                              p7 : SHORTREAL),NEW,EXTENSIBLE;

PROCEDURE (self:CubicCurve2D) clone*() : java_lang.Object,EXTENSIBLE;

PROCEDURE (self:CubicCurve2D) contains*(p0 : REAL;
                                        p1 : REAL) : BOOLEAN,NEW,EXTENSIBLE;

PROCEDURE (self:CubicCurve2D) contains*(p0 : REAL;
                                        p1 : REAL;
                                        p2 : REAL;
                                        p3 : REAL) : BOOLEAN,NEW,EXTENSIBLE;

PROCEDURE (self:CubicCurve2D) contains*(p0 : Point2D) : BOOLEAN,NEW,EXTENSIBLE;

PROCEDURE (self:CubicCurve2D) contains*(p0 : Rectangle2D) : BOOLEAN,NEW,EXTENSIBLE;

PROCEDURE (self:CubicCurve2D) getBounds*() : java_awt.Rectangle,NEW,EXTENSIBLE;

PROCEDURE (self:CubicCurve2D) getBounds2D*() : Rectangle2D,NEW,ABSTRACT;

PROCEDURE (self:CubicCurve2D) getCtrlP1*() : Point2D,NEW,ABSTRACT;

PROCEDURE (self:CubicCurve2D) getCtrlP2*() : Point2D,NEW,ABSTRACT;

PROCEDURE (self:CubicCurve2D) getCtrlX1*() : REAL,NEW,ABSTRACT;

PROCEDURE (self:CubicCurve2D) getCtrlX2*() : REAL,NEW,ABSTRACT;

PROCEDURE (self:CubicCurve2D) getCtrlY1*() : REAL,NEW,ABSTRACT;

PROCEDURE (self:CubicCurve2D) getCtrlY2*() : REAL,NEW,ABSTRACT;

PROCEDURE (self:CubicCurve2D) getFlatness*() : REAL,NEW,EXTENSIBLE;

PROCEDURE (self:CubicCurve2D) getFlatnessSq*() : REAL,NEW,EXTENSIBLE;

PROCEDURE (self:CubicCurve2D) getP1*() : Point2D,NEW,ABSTRACT;

PROCEDURE (self:CubicCurve2D) getP2*() : Point2D,NEW,ABSTRACT;

PROCEDURE (self:CubicCurve2D) getPathIterator*(p0 : AffineTransform) : PathIterator,NEW,EXTENSIBLE;

PROCEDURE (self:CubicCurve2D) getPathIterator*(p0 : AffineTransform;
                                               p1 : REAL) : PathIterator,NEW,EXTENSIBLE;

PROCEDURE (self:CubicCurve2D) getX1*() : REAL,NEW,ABSTRACT;

PROCEDURE (self:CubicCurve2D) getX2*() : REAL,NEW,ABSTRACT;

PROCEDURE (self:CubicCurve2D) getY1*() : REAL,NEW,ABSTRACT;

PROCEDURE (self:CubicCurve2D) getY2*() : REAL,NEW,ABSTRACT;

PROCEDURE (self:CubicCurve2D) intersects*(p0 : REAL;
                                          p1 : REAL;
                                          p2 : REAL;
                                          p3 : REAL) : BOOLEAN,NEW,EXTENSIBLE;

PROCEDURE (self:CubicCurve2D) intersects*(p0 : Rectangle2D) : BOOLEAN,NEW,EXTENSIBLE;

PROCEDURE (self:CubicCurve2D) setCurve*(p0 : REAL;
                                        p1 : REAL;
                                        p2 : REAL;
                                        p3 : REAL;
                                        p4 : REAL;
                                        p5 : REAL;
                                        p6 : REAL;
                                        p7 : REAL),NEW,ABSTRACT;

PROCEDURE (self:CubicCurve2D) setCurve*(p0 : CubicCurve2D),NEW,EXTENSIBLE;

PROCEDURE (self:CubicCurve2D) setCurve*(p0 : Point2D;
                                        p1 : Point2D;
                                        p2 : Point2D;
                                        p3 : Point2D),NEW,EXTENSIBLE;

PROCEDURE (self:CubicCurve2D) setCurve*(IN  p0 : ARRAY OF REAL;
                                            p1 : INTEGER),NEW,EXTENSIBLE;

PROCEDURE (self:CubicCurve2D) setCurve*(IN  p0 : ARRAY OF Point2D;
                                            p1 : INTEGER),NEW,EXTENSIBLE;

PROCEDURE (self:CubicCurve2D) subdivide*(p0 : CubicCurve2D;
                                         p1 : CubicCurve2D),NEW,EXTENSIBLE;

PROCEDURE (self:Dimension2D) clone*() : java_lang.Object,EXTENSIBLE;

PROCEDURE (self:Dimension2D) getHeight*() : REAL,NEW,ABSTRACT;

PROCEDURE (self:Dimension2D) getWidth*() : REAL,NEW,ABSTRACT;

PROCEDURE (self:Dimension2D) setSize*(p0 : REAL;
                                      p1 : REAL),NEW,ABSTRACT;

PROCEDURE (self:Dimension2D) setSize*(p0 : Dimension2D),NEW,EXTENSIBLE;

PROCEDURE (self:Ellipse2D$Double) getBounds2D*() : Rectangle2D,EXTENSIBLE;

PROCEDURE (self:Ellipse2D$Double) getHeight*() : REAL,EXTENSIBLE;

PROCEDURE (self:Ellipse2D$Double) getWidth*() : REAL,EXTENSIBLE;

PROCEDURE (self:Ellipse2D$Double) getX*() : REAL,EXTENSIBLE;

PROCEDURE (self:Ellipse2D$Double) getY*() : REAL,EXTENSIBLE;

PROCEDURE (self:Ellipse2D$Double) isEmpty*() : BOOLEAN,EXTENSIBLE;

PROCEDURE (self:Ellipse2D$Double) setFrame*(p0 : REAL;
                                            p1 : REAL;
                                            p2 : REAL;
                                            p3 : REAL),EXTENSIBLE;

PROCEDURE (self:Ellipse2D$Float) getBounds2D*() : Rectangle2D,EXTENSIBLE;

PROCEDURE (self:Ellipse2D$Float) getHeight*() : REAL,EXTENSIBLE;

PROCEDURE (self:Ellipse2D$Float) getWidth*() : REAL,EXTENSIBLE;

PROCEDURE (self:Ellipse2D$Float) getX*() : REAL,EXTENSIBLE;

PROCEDURE (self:Ellipse2D$Float) getY*() : REAL,EXTENSIBLE;

PROCEDURE (self:Ellipse2D$Float) isEmpty*() : BOOLEAN,EXTENSIBLE;

PROCEDURE (self:Ellipse2D$Float) setFrame*(p0 : REAL;
                                           p1 : REAL;
                                           p2 : REAL;
                                           p3 : REAL),EXTENSIBLE;

PROCEDURE (self:Ellipse2D$Float) setFrame*(p0 : SHORTREAL;
                                           p1 : SHORTREAL;
                                           p2 : SHORTREAL;
                                           p3 : SHORTREAL),NEW,EXTENSIBLE;

PROCEDURE (self:Ellipse2D) contains*(p0 : REAL;
                                     p1 : REAL) : BOOLEAN,EXTENSIBLE;

PROCEDURE (self:Ellipse2D) contains*(p0 : REAL;
                                     p1 : REAL;
                                     p2 : REAL;
                                     p3 : REAL) : BOOLEAN,EXTENSIBLE;

PROCEDURE (self:Ellipse2D) getPathIterator*(p0 : AffineTransform) : PathIterator,EXTENSIBLE;

PROCEDURE (self:Ellipse2D) intersects*(p0 : REAL;
                                       p1 : REAL;
                                       p2 : REAL;
                                       p3 : REAL) : BOOLEAN,EXTENSIBLE;

PROCEDURE (self:FlatteningPathIterator) currentSegment*(IN  p0 : ARRAY OF REAL) : INTEGER,NEW,EXTENSIBLE;

PROCEDURE (self:FlatteningPathIterator) currentSegment*(IN  p0 : ARRAY OF SHORTREAL) : INTEGER,NEW,EXTENSIBLE;

PROCEDURE (self:FlatteningPathIterator) getFlatness*() : REAL,NEW,EXTENSIBLE;

PROCEDURE (self:FlatteningPathIterator) getRecursionLimit*() : INTEGER,NEW,EXTENSIBLE;

PROCEDURE (self:FlatteningPathIterator) getWindingRule*() : INTEGER,NEW,EXTENSIBLE;

PROCEDURE (self:FlatteningPathIterator) isDone*() : BOOLEAN,NEW,EXTENSIBLE;

PROCEDURE (self:FlatteningPathIterator) next*(),NEW,EXTENSIBLE;

PROCEDURE (self:GeneralPath) append*(p0 : java_awt.Shape;
                                     p1 : BOOLEAN),NEW,EXTENSIBLE;

PROCEDURE (self:GeneralPath) append*(p0 : PathIterator;
                                     p1 : BOOLEAN),NEW,EXTENSIBLE;

PROCEDURE (self:GeneralPath) clone*() : java_lang.Object,EXTENSIBLE;

PROCEDURE (self:GeneralPath) closePath*(),NEW,EXTENSIBLE;

PROCEDURE (self:GeneralPath) contains*(p0 : REAL;
                                       p1 : REAL) : BOOLEAN,NEW,EXTENSIBLE;

PROCEDURE (self:GeneralPath) contains*(p0 : REAL;
                                       p1 : REAL;
                                       p2 : REAL;
                                       p3 : REAL) : BOOLEAN,NEW,EXTENSIBLE;

PROCEDURE (self:GeneralPath) contains*(p0 : Point2D) : BOOLEAN,NEW,EXTENSIBLE;

PROCEDURE (self:GeneralPath) contains*(p0 : Rectangle2D) : BOOLEAN,NEW,EXTENSIBLE;

PROCEDURE (self:GeneralPath) createTransformedShape*(p0 : AffineTransform) : java_awt.Shape,NEW,EXTENSIBLE;

PROCEDURE (self:GeneralPath) curveTo*(p0 : SHORTREAL;
                                      p1 : SHORTREAL;
                                      p2 : SHORTREAL;
                                      p3 : SHORTREAL;
                                      p4 : SHORTREAL;
                                      p5 : SHORTREAL),NEW,EXTENSIBLE;

PROCEDURE (self:GeneralPath) getBounds*() : java_awt.Rectangle,NEW,EXTENSIBLE;

PROCEDURE (self:GeneralPath) getBounds2D*() : Rectangle2D,NEW,EXTENSIBLE;

PROCEDURE (self:GeneralPath) getCurrentPoint*() : Point2D,NEW,EXTENSIBLE;

PROCEDURE (self:GeneralPath) getPathIterator*(p0 : AffineTransform) : PathIterator,NEW,EXTENSIBLE;

PROCEDURE (self:GeneralPath) getPathIterator*(p0 : AffineTransform;
                                              p1 : REAL) : PathIterator,NEW,EXTENSIBLE;

PROCEDURE (self:GeneralPath) getWindingRule*() : INTEGER,NEW,EXTENSIBLE;

PROCEDURE (self:GeneralPath) intersects*(p0 : REAL;
                                         p1 : REAL;
                                         p2 : REAL;
                                         p3 : REAL) : BOOLEAN,NEW,EXTENSIBLE;

PROCEDURE (self:GeneralPath) intersects*(p0 : Rectangle2D) : BOOLEAN,NEW,EXTENSIBLE;

PROCEDURE (self:GeneralPath) lineTo*(p0 : SHORTREAL;
                                     p1 : SHORTREAL),NEW,EXTENSIBLE;

PROCEDURE (self:GeneralPath) moveTo*(p0 : SHORTREAL;
                                     p1 : SHORTREAL),NEW,EXTENSIBLE;

PROCEDURE (self:GeneralPath) quadTo*(p0 : SHORTREAL;
                                     p1 : SHORTREAL;
                                     p2 : SHORTREAL;
                                     p3 : SHORTREAL),NEW,EXTENSIBLE;

PROCEDURE (self:GeneralPath) reset*(),NEW,EXTENSIBLE;

PROCEDURE (self:GeneralPath) setWindingRule*(p0 : INTEGER),NEW,EXTENSIBLE;

PROCEDURE (self:GeneralPath) transform*(p0 : AffineTransform),NEW,EXTENSIBLE;

PROCEDURE (self:Line2D$Double) getBounds2D*() : Rectangle2D,EXTENSIBLE;

PROCEDURE (self:Line2D$Double) getP1*() : Point2D,EXTENSIBLE;

PROCEDURE (self:Line2D$Double) getP2*() : Point2D,EXTENSIBLE;

PROCEDURE (self:Line2D$Double) getX1*() : REAL,EXTENSIBLE;

PROCEDURE (self:Line2D$Double) getX2*() : REAL,EXTENSIBLE;

PROCEDURE (self:Line2D$Double) getY1*() : REAL,EXTENSIBLE;

PROCEDURE (self:Line2D$Double) getY2*() : REAL,EXTENSIBLE;

PROCEDURE (self:Line2D$Double) setLine*(p0 : REAL;
                                        p1 : REAL;
                                        p2 : REAL;
                                        p3 : REAL),EXTENSIBLE;

PROCEDURE (self:Line2D$Float) getBounds2D*() : Rectangle2D,EXTENSIBLE;

PROCEDURE (self:Line2D$Float) getP1*() : Point2D,EXTENSIBLE;

PROCEDURE (self:Line2D$Float) getP2*() : Point2D,EXTENSIBLE;

PROCEDURE (self:Line2D$Float) getX1*() : REAL,EXTENSIBLE;

PROCEDURE (self:Line2D$Float) getX2*() : REAL,EXTENSIBLE;

PROCEDURE (self:Line2D$Float) getY1*() : REAL,EXTENSIBLE;

PROCEDURE (self:Line2D$Float) getY2*() : REAL,EXTENSIBLE;

PROCEDURE (self:Line2D$Float) setLine*(p0 : REAL;
                                       p1 : REAL;
                                       p2 : REAL;
                                       p3 : REAL),EXTENSIBLE;

PROCEDURE (self:Line2D$Float) setLine*(p0 : SHORTREAL;
                                       p1 : SHORTREAL;
                                       p2 : SHORTREAL;
                                       p3 : SHORTREAL),NEW,EXTENSIBLE;

PROCEDURE (self:Line2D) clone*() : java_lang.Object,EXTENSIBLE;

PROCEDURE (self:Line2D) contains*(p0 : REAL;
                                  p1 : REAL) : BOOLEAN,NEW,EXTENSIBLE;

PROCEDURE (self:Line2D) contains*(p0 : REAL;
                                  p1 : REAL;
                                  p2 : REAL;
                                  p3 : REAL) : BOOLEAN,NEW,EXTENSIBLE;

PROCEDURE (self:Line2D) contains*(p0 : Point2D) : BOOLEAN,NEW,EXTENSIBLE;

PROCEDURE (self:Line2D) contains*(p0 : Rectangle2D) : BOOLEAN,NEW,EXTENSIBLE;

PROCEDURE (self:Line2D) getBounds*() : java_awt.Rectangle,NEW,EXTENSIBLE;

PROCEDURE (self:Line2D) getBounds2D*() : Rectangle2D,NEW,ABSTRACT;

PROCEDURE (self:Line2D) getP1*() : Point2D,NEW,ABSTRACT;

PROCEDURE (self:Line2D) getP2*() : Point2D,NEW,ABSTRACT;

PROCEDURE (self:Line2D) getPathIterator*(p0 : AffineTransform) : PathIterator,NEW,EXTENSIBLE;

PROCEDURE (self:Line2D) getPathIterator*(p0 : AffineTransform;
                                         p1 : REAL) : PathIterator,NEW,EXTENSIBLE;

PROCEDURE (self:Line2D) getX1*() : REAL,NEW,ABSTRACT;

PROCEDURE (self:Line2D) getX2*() : REAL,NEW,ABSTRACT;

PROCEDURE (self:Line2D) getY1*() : REAL,NEW,ABSTRACT;

PROCEDURE (self:Line2D) getY2*() : REAL,NEW,ABSTRACT;

PROCEDURE (self:Line2D) intersects*(p0 : REAL;
                                    p1 : REAL;
                                    p2 : REAL;
                                    p3 : REAL) : BOOLEAN,NEW,EXTENSIBLE;

PROCEDURE (self:Line2D) intersects*(p0 : Rectangle2D) : BOOLEAN,NEW,EXTENSIBLE;

PROCEDURE (self:Line2D) intersectsLine*(p0 : REAL;
                                        p1 : REAL;
                                        p2 : REAL;
                                        p3 : REAL) : BOOLEAN,NEW,EXTENSIBLE;

PROCEDURE (self:Line2D) intersectsLine*(p0 : Line2D) : BOOLEAN,NEW,EXTENSIBLE;

PROCEDURE (self:Line2D) ptLineDist*(p0 : REAL;
                                    p1 : REAL) : REAL,NEW,EXTENSIBLE;

PROCEDURE (self:Line2D) ptLineDist*(p0 : Point2D) : REAL,NEW,EXTENSIBLE;

PROCEDURE (self:Line2D) ptLineDistSq*(p0 : REAL;
                                      p1 : REAL) : REAL,NEW,EXTENSIBLE;

PROCEDURE (self:Line2D) ptLineDistSq*(p0 : Point2D) : REAL,NEW,EXTENSIBLE;

PROCEDURE (self:Line2D) ptSegDist*(p0 : REAL;
                                   p1 : REAL) : REAL,NEW,EXTENSIBLE;

PROCEDURE (self:Line2D) ptSegDist*(p0 : Point2D) : REAL,NEW,EXTENSIBLE;

PROCEDURE (self:Line2D) ptSegDistSq*(p0 : REAL;
                                     p1 : REAL) : REAL,NEW,EXTENSIBLE;

PROCEDURE (self:Line2D) ptSegDistSq*(p0 : Point2D) : REAL,NEW,EXTENSIBLE;

PROCEDURE (self:Line2D) relativeCCW*(p0 : REAL;
                                     p1 : REAL) : INTEGER,NEW,EXTENSIBLE;

PROCEDURE (self:Line2D) relativeCCW*(p0 : Point2D) : INTEGER,NEW,EXTENSIBLE;

PROCEDURE (self:Line2D) setLine*(p0 : REAL;
                                 p1 : REAL;
                                 p2 : REAL;
                                 p3 : REAL),NEW,ABSTRACT;

PROCEDURE (self:Line2D) setLine*(p0 : Line2D),NEW,EXTENSIBLE;

PROCEDURE (self:Line2D) setLine*(p0 : Point2D;
                                 p1 : Point2D),NEW,EXTENSIBLE;

PROCEDURE (self:PathIterator) currentSegment*(IN  p0 : ARRAY OF REAL) : INTEGER,NEW,ABSTRACT;

PROCEDURE (self:PathIterator) currentSegment*(IN  p0 : ARRAY OF SHORTREAL) : INTEGER,NEW,ABSTRACT;

PROCEDURE (self:PathIterator) getWindingRule*() : INTEGER,NEW,ABSTRACT;

PROCEDURE (self:PathIterator) isDone*() : BOOLEAN,NEW,ABSTRACT;

PROCEDURE (self:PathIterator) next*(),NEW,ABSTRACT;

PROCEDURE (self:Point2D$Double) getX*() : REAL,EXTENSIBLE;

PROCEDURE (self:Point2D$Double) getY*() : REAL,EXTENSIBLE;

PROCEDURE (self:Point2D$Double) setLocation*(p0 : REAL;
                                             p1 : REAL),EXTENSIBLE;

PROCEDURE (self:Point2D$Double) toString*() : java_lang.String,EXTENSIBLE;

PROCEDURE (self:Point2D$Float) getX*() : REAL,EXTENSIBLE;

PROCEDURE (self:Point2D$Float) getY*() : REAL,EXTENSIBLE;

PROCEDURE (self:Point2D$Float) setLocation*(p0 : REAL;
                                            p1 : REAL),EXTENSIBLE;

PROCEDURE (self:Point2D$Float) setLocation*(p0 : SHORTREAL;
                                            p1 : SHORTREAL),NEW,EXTENSIBLE;

PROCEDURE (self:Point2D$Float) toString*() : java_lang.String,EXTENSIBLE;

PROCEDURE (self:Point2D) clone*() : java_lang.Object,EXTENSIBLE;

PROCEDURE (self:Point2D) distance*(p0 : REAL;
                                   p1 : REAL) : REAL,NEW,EXTENSIBLE;

PROCEDURE (self:Point2D) distance*(p0 : Point2D) : REAL,NEW,EXTENSIBLE;

PROCEDURE (self:Point2D) distanceSq*(p0 : REAL;
                                     p1 : REAL) : REAL,NEW,EXTENSIBLE;

PROCEDURE (self:Point2D) distanceSq*(p0 : Point2D) : REAL,NEW,EXTENSIBLE;

PROCEDURE (self:Point2D) equals*(p0 : java_lang.Object) : BOOLEAN,EXTENSIBLE;

PROCEDURE (self:Point2D) getX*() : REAL,NEW,ABSTRACT;

PROCEDURE (self:Point2D) getY*() : REAL,NEW,ABSTRACT;

PROCEDURE (self:Point2D) hashCode*() : INTEGER,EXTENSIBLE;

PROCEDURE (self:Point2D) setLocation*(p0 : REAL;
                                      p1 : REAL),NEW,ABSTRACT;

PROCEDURE (self:Point2D) setLocation*(p0 : Point2D),NEW,EXTENSIBLE;

PROCEDURE (self:QuadCurve2D$Double) getBounds2D*() : Rectangle2D,EXTENSIBLE;

PROCEDURE (self:QuadCurve2D$Double) getCtrlPt*() : Point2D,EXTENSIBLE;

PROCEDURE (self:QuadCurve2D$Double) getCtrlX*() : REAL,EXTENSIBLE;

PROCEDURE (self:QuadCurve2D$Double) getCtrlY*() : REAL,EXTENSIBLE;

PROCEDURE (self:QuadCurve2D$Double) getP1*() : Point2D,EXTENSIBLE;

PROCEDURE (self:QuadCurve2D$Double) getP2*() : Point2D,EXTENSIBLE;

PROCEDURE (self:QuadCurve2D$Double) getX1*() : REAL,EXTENSIBLE;

PROCEDURE (self:QuadCurve2D$Double) getX2*() : REAL,EXTENSIBLE;

PROCEDURE (self:QuadCurve2D$Double) getY1*() : REAL,EXTENSIBLE;

PROCEDURE (self:QuadCurve2D$Double) getY2*() : REAL,EXTENSIBLE;

PROCEDURE (self:QuadCurve2D$Double) setCurve*(p0 : REAL;
                                              p1 : REAL;
                                              p2 : REAL;
                                              p3 : REAL;
                                              p4 : REAL;
                                              p5 : REAL),EXTENSIBLE;

PROCEDURE (self:QuadCurve2D$Float) getBounds2D*() : Rectangle2D,EXTENSIBLE;

PROCEDURE (self:QuadCurve2D$Float) getCtrlPt*() : Point2D,EXTENSIBLE;

PROCEDURE (self:QuadCurve2D$Float) getCtrlX*() : REAL,EXTENSIBLE;

PROCEDURE (self:QuadCurve2D$Float) getCtrlY*() : REAL,EXTENSIBLE;

PROCEDURE (self:QuadCurve2D$Float) getP1*() : Point2D,EXTENSIBLE;

PROCEDURE (self:QuadCurve2D$Float) getP2*() : Point2D,EXTENSIBLE;

PROCEDURE (self:QuadCurve2D$Float) getX1*() : REAL,EXTENSIBLE;

PROCEDURE (self:QuadCurve2D$Float) getX2*() : REAL,EXTENSIBLE;

PROCEDURE (self:QuadCurve2D$Float) getY1*() : REAL,EXTENSIBLE;

PROCEDURE (self:QuadCurve2D$Float) getY2*() : REAL,EXTENSIBLE;

PROCEDURE (self:QuadCurve2D$Float) setCurve*(p0 : REAL;
                                             p1 : REAL;
                                             p2 : REAL;
                                             p3 : REAL;
                                             p4 : REAL;
                                             p5 : REAL),EXTENSIBLE;

PROCEDURE (self:QuadCurve2D$Float) setCurve*(p0 : SHORTREAL;
                                             p1 : SHORTREAL;
                                             p2 : SHORTREAL;
                                             p3 : SHORTREAL;
                                             p4 : SHORTREAL;
                                             p5 : SHORTREAL),NEW,EXTENSIBLE;

PROCEDURE (self:QuadCurve2D) clone*() : java_lang.Object,EXTENSIBLE;

PROCEDURE (self:QuadCurve2D) contains*(p0 : REAL;
                                       p1 : REAL) : BOOLEAN,NEW,EXTENSIBLE;

PROCEDURE (self:QuadCurve2D) contains*(p0 : REAL;
                                       p1 : REAL;
                                       p2 : REAL;
                                       p3 : REAL) : BOOLEAN,NEW,EXTENSIBLE;

PROCEDURE (self:QuadCurve2D) contains*(p0 : Point2D) : BOOLEAN,NEW,EXTENSIBLE;

PROCEDURE (self:QuadCurve2D) contains*(p0 : Rectangle2D) : BOOLEAN,NEW,EXTENSIBLE;

PROCEDURE (self:QuadCurve2D) getBounds*() : java_awt.Rectangle,NEW,EXTENSIBLE;

PROCEDURE (self:QuadCurve2D) getBounds2D*() : Rectangle2D,NEW,ABSTRACT;

PROCEDURE (self:QuadCurve2D) getCtrlPt*() : Point2D,NEW,ABSTRACT;

PROCEDURE (self:QuadCurve2D) getCtrlX*() : REAL,NEW,ABSTRACT;

PROCEDURE (self:QuadCurve2D) getCtrlY*() : REAL,NEW,ABSTRACT;

PROCEDURE (self:QuadCurve2D) getFlatness*() : REAL,NEW,EXTENSIBLE;

PROCEDURE (self:QuadCurve2D) getFlatnessSq*() : REAL,NEW,EXTENSIBLE;

PROCEDURE (self:QuadCurve2D) getP1*() : Point2D,NEW,ABSTRACT;

PROCEDURE (self:QuadCurve2D) getP2*() : Point2D,NEW,ABSTRACT;

PROCEDURE (self:QuadCurve2D) getPathIterator*(p0 : AffineTransform) : PathIterator,NEW,EXTENSIBLE;

PROCEDURE (self:QuadCurve2D) getPathIterator*(p0 : AffineTransform;
                                              p1 : REAL) : PathIterator,NEW,EXTENSIBLE;

PROCEDURE (self:QuadCurve2D) getX1*() : REAL,NEW,ABSTRACT;

PROCEDURE (self:QuadCurve2D) getX2*() : REAL,NEW,ABSTRACT;

PROCEDURE (self:QuadCurve2D) getY1*() : REAL,NEW,ABSTRACT;

PROCEDURE (self:QuadCurve2D) getY2*() : REAL,NEW,ABSTRACT;

PROCEDURE (self:QuadCurve2D) intersects*(p0 : REAL;
                                         p1 : REAL;
                                         p2 : REAL;
                                         p3 : REAL) : BOOLEAN,NEW,EXTENSIBLE;

PROCEDURE (self:QuadCurve2D) intersects*(p0 : Rectangle2D) : BOOLEAN,NEW,EXTENSIBLE;

PROCEDURE (self:QuadCurve2D) setCurve*(p0 : REAL;
                                       p1 : REAL;
                                       p2 : REAL;
                                       p3 : REAL;
                                       p4 : REAL;
                                       p5 : REAL),NEW,ABSTRACT;

PROCEDURE (self:QuadCurve2D) setCurve*(p0 : Point2D;
                                       p1 : Point2D;
                                       p2 : Point2D),NEW,EXTENSIBLE;

PROCEDURE (self:QuadCurve2D) setCurve*(p0 : QuadCurve2D),NEW,EXTENSIBLE;

PROCEDURE (self:QuadCurve2D) setCurve*(IN  p0 : ARRAY OF REAL;
                                           p1 : INTEGER),NEW,EXTENSIBLE;

PROCEDURE (self:QuadCurve2D) setCurve*(IN  p0 : ARRAY OF Point2D;
                                           p1 : INTEGER),NEW,EXTENSIBLE;

PROCEDURE (self:QuadCurve2D) subdivide*(p0 : QuadCurve2D;
                                        p1 : QuadCurve2D),NEW,EXTENSIBLE;

PROCEDURE (self:Rectangle2D$Double) createIntersection*(p0 : Rectangle2D) : Rectangle2D,EXTENSIBLE;

PROCEDURE (self:Rectangle2D$Double) createUnion*(p0 : Rectangle2D) : Rectangle2D,EXTENSIBLE;

PROCEDURE (self:Rectangle2D$Double) getBounds2D*() : Rectangle2D,EXTENSIBLE;

PROCEDURE (self:Rectangle2D$Double) getHeight*() : REAL,EXTENSIBLE;

PROCEDURE (self:Rectangle2D$Double) getWidth*() : REAL,EXTENSIBLE;

PROCEDURE (self:Rectangle2D$Double) getX*() : REAL,EXTENSIBLE;

PROCEDURE (self:Rectangle2D$Double) getY*() : REAL,EXTENSIBLE;

PROCEDURE (self:Rectangle2D$Double) isEmpty*() : BOOLEAN,EXTENSIBLE;

PROCEDURE (self:Rectangle2D$Double) outcode*(p0 : REAL;
                                             p1 : REAL) : INTEGER,EXTENSIBLE;

PROCEDURE (self:Rectangle2D$Double) setRect*(p0 : REAL;
                                             p1 : REAL;
                                             p2 : REAL;
                                             p3 : REAL),EXTENSIBLE;

PROCEDURE (self:Rectangle2D$Double) setRect*(p0 : Rectangle2D),EXTENSIBLE;

PROCEDURE (self:Rectangle2D$Double) toString*() : java_lang.String,EXTENSIBLE;

PROCEDURE (self:Rectangle2D$Float) createIntersection*(p0 : Rectangle2D) : Rectangle2D,EXTENSIBLE;

PROCEDURE (self:Rectangle2D$Float) createUnion*(p0 : Rectangle2D) : Rectangle2D,EXTENSIBLE;

PROCEDURE (self:Rectangle2D$Float) getBounds2D*() : Rectangle2D,EXTENSIBLE;

PROCEDURE (self:Rectangle2D$Float) getHeight*() : REAL,EXTENSIBLE;

PROCEDURE (self:Rectangle2D$Float) getWidth*() : REAL,EXTENSIBLE;

PROCEDURE (self:Rectangle2D$Float) getX*() : REAL,EXTENSIBLE;

PROCEDURE (self:Rectangle2D$Float) getY*() : REAL,EXTENSIBLE;

PROCEDURE (self:Rectangle2D$Float) isEmpty*() : BOOLEAN,EXTENSIBLE;

PROCEDURE (self:Rectangle2D$Float) outcode*(p0 : REAL;
                                            p1 : REAL) : INTEGER,EXTENSIBLE;

PROCEDURE (self:Rectangle2D$Float) setRect*(p0 : REAL;
                                            p1 : REAL;
                                            p2 : REAL;
                                            p3 : REAL),EXTENSIBLE;

PROCEDURE (self:Rectangle2D$Float) setRect*(p0 : SHORTREAL;
                                            p1 : SHORTREAL;
                                            p2 : SHORTREAL;
                                            p3 : SHORTREAL),NEW,EXTENSIBLE;

PROCEDURE (self:Rectangle2D$Float) setRect*(p0 : Rectangle2D),EXTENSIBLE;

PROCEDURE (self:Rectangle2D$Float) toString*() : java_lang.String,EXTENSIBLE;

PROCEDURE (self:Rectangle2D) add*(p0 : REAL;
                                  p1 : REAL),NEW,EXTENSIBLE;

PROCEDURE (self:Rectangle2D) add*(p0 : Point2D),NEW,EXTENSIBLE;

PROCEDURE (self:Rectangle2D) add*(p0 : Rectangle2D),NEW,EXTENSIBLE;

PROCEDURE (self:Rectangle2D) contains*(p0 : REAL;
                                       p1 : REAL) : BOOLEAN,EXTENSIBLE;

PROCEDURE (self:Rectangle2D) contains*(p0 : REAL;
                                       p1 : REAL;
                                       p2 : REAL;
                                       p3 : REAL) : BOOLEAN,EXTENSIBLE;

PROCEDURE (self:Rectangle2D) createIntersection*(p0 : Rectangle2D) : Rectangle2D,NEW,ABSTRACT;

PROCEDURE (self:Rectangle2D) createUnion*(p0 : Rectangle2D) : Rectangle2D,NEW,ABSTRACT;

PROCEDURE (self:Rectangle2D) equals*(p0 : java_lang.Object) : BOOLEAN,EXTENSIBLE;

PROCEDURE (self:Rectangle2D) getBounds2D*() : Rectangle2D,EXTENSIBLE;

PROCEDURE (self:Rectangle2D) getPathIterator*(p0 : AffineTransform) : PathIterator,EXTENSIBLE;

PROCEDURE (self:Rectangle2D) getPathIterator*(p0 : AffineTransform;
                                              p1 : REAL) : PathIterator,EXTENSIBLE;

PROCEDURE (self:Rectangle2D) hashCode*() : INTEGER,EXTENSIBLE;

PROCEDURE (self:Rectangle2D) intersects*(p0 : REAL;
                                         p1 : REAL;
                                         p2 : REAL;
                                         p3 : REAL) : BOOLEAN,EXTENSIBLE;

PROCEDURE (self:Rectangle2D) intersectsLine*(p0 : REAL;
                                             p1 : REAL;
                                             p2 : REAL;
                                             p3 : REAL) : BOOLEAN,NEW,EXTENSIBLE;

PROCEDURE (self:Rectangle2D) intersectsLine*(p0 : Line2D) : BOOLEAN,NEW,EXTENSIBLE;

PROCEDURE (self:Rectangle2D) outcode*(p0 : REAL;
                                      p1 : REAL) : INTEGER,NEW,ABSTRACT;

PROCEDURE (self:Rectangle2D) outcode*(p0 : Point2D) : INTEGER,NEW,EXTENSIBLE;

PROCEDURE (self:Rectangle2D) setFrame*(p0 : REAL;
                                       p1 : REAL;
                                       p2 : REAL;
                                       p3 : REAL),EXTENSIBLE;

PROCEDURE (self:Rectangle2D) setRect*(p0 : REAL;
                                      p1 : REAL;
                                      p2 : REAL;
                                      p3 : REAL),NEW,ABSTRACT;

PROCEDURE (self:Rectangle2D) setRect*(p0 : Rectangle2D),NEW,EXTENSIBLE;

PROCEDURE (self:RectangularShape) clone*() : java_lang.Object,EXTENSIBLE;

PROCEDURE (self:RectangularShape) contains*(p0 : REAL;
                                            p1 : REAL) : BOOLEAN,NEW,ABSTRACT;

PROCEDURE (self:RectangularShape) contains*(p0 : REAL;
                                            p1 : REAL;
                                            p2 : REAL;
                                            p3 : REAL) : BOOLEAN,NEW,ABSTRACT;

PROCEDURE (self:RectangularShape) contains*(p0 : Point2D) : BOOLEAN,NEW,EXTENSIBLE;

PROCEDURE (self:RectangularShape) contains*(p0 : Rectangle2D) : BOOLEAN,NEW,EXTENSIBLE;

PROCEDURE (self:RectangularShape) getBounds*() : java_awt.Rectangle,NEW,EXTENSIBLE;

PROCEDURE (self:RectangularShape) getBounds2D*() : Rectangle2D,NEW,ABSTRACT;

PROCEDURE (self:RectangularShape) getCenterX*() : REAL,NEW,EXTENSIBLE;

PROCEDURE (self:RectangularShape) getCenterY*() : REAL,NEW,EXTENSIBLE;

PROCEDURE (self:RectangularShape) getFrame*() : Rectangle2D,NEW,EXTENSIBLE;

PROCEDURE (self:RectangularShape) getHeight*() : REAL,NEW,ABSTRACT;

PROCEDURE (self:RectangularShape) getMaxX*() : REAL,NEW,EXTENSIBLE;

PROCEDURE (self:RectangularShape) getMaxY*() : REAL,NEW,EXTENSIBLE;

PROCEDURE (self:RectangularShape) getMinX*() : REAL,NEW,EXTENSIBLE;

PROCEDURE (self:RectangularShape) getMinY*() : REAL,NEW,EXTENSIBLE;

PROCEDURE (self:RectangularShape) getPathIterator*(p0 : AffineTransform) : PathIterator,NEW,ABSTRACT;

PROCEDURE (self:RectangularShape) getPathIterator*(p0 : AffineTransform;
                                                   p1 : REAL) : PathIterator,NEW,EXTENSIBLE;

PROCEDURE (self:RectangularShape) getWidth*() : REAL,NEW,ABSTRACT;

PROCEDURE (self:RectangularShape) getX*() : REAL,NEW,ABSTRACT;

PROCEDURE (self:RectangularShape) getY*() : REAL,NEW,ABSTRACT;

PROCEDURE (self:RectangularShape) intersects*(p0 : REAL;
                                              p1 : REAL;
                                              p2 : REAL;
                                              p3 : REAL) : BOOLEAN,NEW,ABSTRACT;

PROCEDURE (self:RectangularShape) intersects*(p0 : Rectangle2D) : BOOLEAN,NEW,EXTENSIBLE;

PROCEDURE (self:RectangularShape) isEmpty*() : BOOLEAN,NEW,ABSTRACT;

PROCEDURE (self:RectangularShape) setFrame*(p0 : REAL;
                                            p1 : REAL;
                                            p2 : REAL;
                                            p3 : REAL),NEW,ABSTRACT;

PROCEDURE (self:RectangularShape) setFrame*(p0 : Point2D;
                                            p1 : Dimension2D),NEW,EXTENSIBLE;

PROCEDURE (self:RectangularShape) setFrame*(p0 : Rectangle2D),NEW,EXTENSIBLE;

PROCEDURE (self:RectangularShape) setFrameFromCenter*(p0 : REAL;
                                                      p1 : REAL;
                                                      p2 : REAL;
                                                      p3 : REAL),NEW,EXTENSIBLE;

PROCEDURE (self:RectangularShape) setFrameFromCenter*(p0 : Point2D;
                                                      p1 : Point2D),NEW,EXTENSIBLE;

PROCEDURE (self:RectangularShape) setFrameFromDiagonal*(p0 : REAL;
                                                        p1 : REAL;
                                                        p2 : REAL;
                                                        p3 : REAL),NEW,EXTENSIBLE;

PROCEDURE (self:RectangularShape) setFrameFromDiagonal*(p0 : Point2D;
                                                        p1 : Point2D),NEW,EXTENSIBLE;

PROCEDURE (self:RoundRectangle2D$Double) getArcHeight*() : REAL,EXTENSIBLE;

PROCEDURE (self:RoundRectangle2D$Double) getArcWidth*() : REAL,EXTENSIBLE;

PROCEDURE (self:RoundRectangle2D$Double) getBounds2D*() : Rectangle2D,EXTENSIBLE;

PROCEDURE (self:RoundRectangle2D$Double) getHeight*() : REAL,EXTENSIBLE;

PROCEDURE (self:RoundRectangle2D$Double) getWidth*() : REAL,EXTENSIBLE;

PROCEDURE (self:RoundRectangle2D$Double) getX*() : REAL,EXTENSIBLE;

PROCEDURE (self:RoundRectangle2D$Double) getY*() : REAL,EXTENSIBLE;

PROCEDURE (self:RoundRectangle2D$Double) isEmpty*() : BOOLEAN,EXTENSIBLE;

PROCEDURE (self:RoundRectangle2D$Double) setRoundRect*(p0 : REAL;
                                                       p1 : REAL;
                                                       p2 : REAL;
                                                       p3 : REAL;
                                                       p4 : REAL;
                                                       p5 : REAL),EXTENSIBLE;

PROCEDURE (self:RoundRectangle2D$Double) setRoundRect*(p0 : RoundRectangle2D),EXTENSIBLE;

PROCEDURE (self:RoundRectangle2D$Float) getArcHeight*() : REAL,EXTENSIBLE;

PROCEDURE (self:RoundRectangle2D$Float) getArcWidth*() : REAL,EXTENSIBLE;

PROCEDURE (self:RoundRectangle2D$Float) getBounds2D*() : Rectangle2D,EXTENSIBLE;

PROCEDURE (self:RoundRectangle2D$Float) getHeight*() : REAL,EXTENSIBLE;

PROCEDURE (self:RoundRectangle2D$Float) getWidth*() : REAL,EXTENSIBLE;

PROCEDURE (self:RoundRectangle2D$Float) getX*() : REAL,EXTENSIBLE;

PROCEDURE (self:RoundRectangle2D$Float) getY*() : REAL,EXTENSIBLE;

PROCEDURE (self:RoundRectangle2D$Float) isEmpty*() : BOOLEAN,EXTENSIBLE;

PROCEDURE (self:RoundRectangle2D$Float) setRoundRect*(p0 : REAL;
                                                      p1 : REAL;
                                                      p2 : REAL;
                                                      p3 : REAL;
                                                      p4 : REAL;
                                                      p5 : REAL),EXTENSIBLE;

PROCEDURE (self:RoundRectangle2D$Float) setRoundRect*(p0 : SHORTREAL;
                                                      p1 : SHORTREAL;
                                                      p2 : SHORTREAL;
                                                      p3 : SHORTREAL;
                                                      p4 : SHORTREAL;
                                                      p5 : SHORTREAL),NEW,EXTENSIBLE;

PROCEDURE (self:RoundRectangle2D$Float) setRoundRect*(p0 : RoundRectangle2D),EXTENSIBLE;

PROCEDURE (self:RoundRectangle2D) contains*(p0 : REAL;
                                            p1 : REAL) : BOOLEAN,EXTENSIBLE;

PROCEDURE (self:RoundRectangle2D) contains*(p0 : REAL;
                                            p1 : REAL;
                                            p2 : REAL;
                                            p3 : REAL) : BOOLEAN,EXTENSIBLE;

PROCEDURE (self:RoundRectangle2D) getArcHeight*() : REAL,NEW,ABSTRACT;

PROCEDURE (self:RoundRectangle2D) getArcWidth*() : REAL,NEW,ABSTRACT;

PROCEDURE (self:RoundRectangle2D) getPathIterator*(p0 : AffineTransform) : PathIterator,EXTENSIBLE;

PROCEDURE (self:RoundRectangle2D) intersects*(p0 : REAL;
                                              p1 : REAL;
                                              p2 : REAL;
                                              p3 : REAL) : BOOLEAN,EXTENSIBLE;

PROCEDURE (self:RoundRectangle2D) setFrame*(p0 : REAL;
                                            p1 : REAL;
                                            p2 : REAL;
                                            p3 : REAL),EXTENSIBLE;

PROCEDURE (self:RoundRectangle2D) setRoundRect*(p0 : REAL;
                                                p1 : REAL;
                                                p2 : REAL;
                                                p3 : REAL;
                                                p4 : REAL;
                                                p5 : REAL),NEW,ABSTRACT;

PROCEDURE (self:RoundRectangle2D) setRoundRect*(p0 : RoundRectangle2D),NEW,EXTENSIBLE;

END java_awt_geom.