    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.