    FOREIGN MODULE sun_awt_Albert;

    IMPORT
        java_awt_geom,
        java_lang,
        java_awt,
        java_io,
        java_util;

    TYPE

      AffineTransform* = POINTER TO EXTENSIBLE RECORD (java_lang.Object)
                           m00! : REAL;
                           m10! : REAL;
                           m01! : REAL;
                           m11! : REAL;
                           m02! : REAL;
                           m12! : REAL;
                         STATIC
                           TYPE_IDENTITY! = 0;
                           TYPE_ROTATE! = 1;
                           TYPE_TRANSLATE! = 2;
                           TYPE_SCALE! = 3;
                           TYPE_AFFINE! = 4;
                           ROTATE_0! = 0;
                           ROTATE_90! = 1;
                           ROTATE_180! = 2;
                           ROTATE_270! = 3;
                           ROTATE_SLOW! = 4;
                           ELEMENT_SCALE_X* = 0;
                           ELEMENT_SHEAR_Y* = 1;
                           ELEMENT_SHEAR_X* = 2;
                           ELEMENT_SCALE_Y* = 3;
                           ELEMENT_TRANSLATE_X* = 4;
                           ELEMENT_TRANSLATE_Y* = 5;
                           kAngle! = 0;
                           kSin! = 1;
                           kCos! = 2;
                           kCenterX! = 3;
                           kCenterY! = 4;
                           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 : java_awt_geom.AffineTransform) : 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 Init*(IN  p0 : ARRAY OF REAL) : AffineTransform,CONSTRUCTOR;
                           PROCEDURE Init*(IN  p0 : ARRAY OF SHORTREAL) : AffineTransform,CONSTRUCTOR;
                         END;

      AreaPathIterator* = POINTER TO EXTENSIBLE RECORD (java_lang.Object + java_awt_geom.PathIterator)
                          STATIC
                            PROCEDURE Init*(p0 : TGLoop) : AreaPathIterator,CONSTRUCTOR;
                          END;

      MAreaGeometry* = POINTER TO ABSTRACT RECORD (java_lang.Object)
                       STATIC
                         PROCEDURE Init!() : MAreaGeometry,CONSTRUCTOR;
                         PROCEDURE Init!(p0 : MAreaGeometry) : MAreaGeometry,CONSTRUCTOR;
                         PROCEDURE add*(p0 : MAreaGeometry;
                                        p1 : MAreaGeometry) : MAreaGeometry;
                         PROCEDURE exclusiveOr*(p0 : MAreaGeometry;
                                                p1 : MAreaGeometry) : MAreaGeometry;
                         PROCEDURE intersect*(p0 : MAreaGeometry;
                                              p1 : MAreaGeometry) : MAreaGeometry;
                         PROCEDURE subtract*(p0 : MAreaGeometry;
                                             p1 : MAreaGeometry) : MAreaGeometry;
                       END;

      TCAGRoot* = POINTER TO EXTENSIBLE RECORD (TCAGNode)
                  STATIC
                    PROCEDURE Init*() : TCAGRoot,CONSTRUCTOR;
                  END;

      TEllipseGeometry* = POINTER TO EXTENSIBLE RECORD (MAreaGeometry)
                            fEllipse* : TGEllipse;
                          STATIC
                            PROCEDURE Init*() : TEllipseGeometry,CONSTRUCTOR;
                            PROCEDURE Init*(p0 : TEllipseGeometry) : TEllipseGeometry,CONSTRUCTOR;
                            PROCEDURE Init*(p0 : TGEllipse) : TEllipseGeometry,CONSTRUCTOR;
                          END;

      TGCurve* = POINTER TO EXTENSIBLE RECORD (TBaseCurve)
                   fConicInfo! : TConicInfo;
                 STATIC
                   PROCEDURE Init*() : TGCurve,CONSTRUCTOR;
                   PROCEDURE Init*(p0 : INTEGER;
                                   p1 : INTEGER) : TGCurve,CONSTRUCTOR;
                   PROCEDURE Init*(p0 : INTEGER;
                                   p1 : TGRPointArray;
                                   p2 : TGParametricArray) : TGCurve,CONSTRUCTOR;
                   PROCEDURE Init*(p0 : TGCurve) : TGCurve,CONSTRUCTOR;
                   PROCEDURE Init*(p0 : TGPoint;
                                   p1 : TGPoint) : TGCurve,CONSTRUCTOR;
                   PROCEDURE Init*(p0 : TGPoint;
                                   p1 : TGPoint;
                                   p2 : TGPoint) : TGCurve,CONSTRUCTOR;
                   PROCEDURE Init*(p0 : TGPoint;
                                   p1 : TGPoint;
                                   p2 : TGPoint;
                                   p3 : TGPoint) : TGCurve,CONSTRUCTOR;
                 END;

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

      TGLoop* = POINTER TO EXTENSIBLE RECORD (TGCurve)
                STATIC
                  PROCEDURE Init*() : TGLoop,CONSTRUCTOR;
                  PROCEDURE Init*(p0 : INTEGER;
                                  p1 : TGRPointArray;
                                  p2 : TGParametricArray) : TGLoop,CONSTRUCTOR;
                  PROCEDURE Init*(p0 : INTEGER;
                                  p1 : TGRPointArray;
                                  p2 : TGParametricArray;
                                  p3 : BOOLEAN) : TGLoop,CONSTRUCTOR;
                  PROCEDURE Init*(p0 : TGCurve;
                                  p1 : BOOLEAN) : TGLoop,CONSTRUCTOR;
                  PROCEDURE Init*(p0 : TGEllipse) : TGLoop,CONSTRUCTOR;
                  PROCEDURE Init*(p0 : TGLoop) : TGLoop,CONSTRUCTOR;
                  PROCEDURE Init*(p0 : TGPolygon) : TGLoop,CONSTRUCTOR;
                  PROCEDURE Init*(p0 : TGRect) : TGLoop,CONSTRUCTOR;
                END;

      TGPoint* = POINTER TO RECORD (java_awt_geom.Point2D$Double)
                 STATIC
                   PROCEDURE Init*() : TGPoint,CONSTRUCTOR;
                   PROCEDURE Init*(p0 : REAL;
                                   p1 : REAL) : TGPoint,CONSTRUCTOR;
                   PROCEDURE Init*(p0 : java_awt_geom.Point2D) : TGPoint,CONSTRUCTOR;
                   PROCEDURE add*(p0 : TGPoint;
                                  p1 : TGPoint) : TGPoint;
                   PROCEDURE multiply*(p0 : REAL;
                                       p1 : TGPoint) : TGPoint;
                   PROCEDURE multiply*(p0 : TGPoint;
                                       p1 : REAL) : TGPoint;
                   PROCEDURE subtract*(p0 : TGPoint;
                                       p1 : TGPoint) : TGPoint;
                 END;

      TGPolygon* = POINTER TO EXTENSIBLE RECORD (TGPolyline + java_lang.Cloneable)
                   STATIC
                     PROCEDURE Init*() : TGPolygon,CONSTRUCTOR;
                     PROCEDURE Init*(p0 : INTEGER) : TGPolygon,CONSTRUCTOR;
                     PROCEDURE Init*(p0 : INTEGER;
                                     p1 : BOOLEAN) : TGPolygon,CONSTRUCTOR;
                     PROCEDURE Init*(p0 : java_awt.Polygon) : TGPolygon,CONSTRUCTOR;
                     PROCEDURE Init*(p0 : java_awt.Polygon;
                                     p1 : BOOLEAN) : TGPolygon,CONSTRUCTOR;
                     PROCEDURE Init*(p0 : TGPolygon) : TGPolygon,CONSTRUCTOR;
                     PROCEDURE Init*(p0 : TGRect) : TGPolygon,CONSTRUCTOR;
                     PROCEDURE Init*(p0 : TGRect;
                                     p1 : BOOLEAN) : TGPolygon,CONSTRUCTOR;
                   END;

      TGPolyline* = POINTER TO EXTENSIBLE RECORD (java_lang.Object + java_lang.Cloneable)
                      fPoints! : TGPointArray;
                    STATIC
                      PROCEDURE Init*() : TGPolyline,CONSTRUCTOR;
                      PROCEDURE Init*(p0 : INTEGER) : TGPolyline,CONSTRUCTOR;
                      PROCEDURE Init*(p0 : TGPointArray) : TGPolyline,CONSTRUCTOR;
                      PROCEDURE Init*(p0 : TGPolyline) : TGPolyline,CONSTRUCTOR;
                    END;

      TGrafMatrix* = POINTER TO EXTENSIBLE RECORD (AffineTransform)
                     STATIC
                       PROCEDURE Init*() : TGrafMatrix,CONSTRUCTOR;
                       PROCEDURE Init*(p0 : java_awt_geom.AffineTransform) : TGrafMatrix,CONSTRUCTOR;
                       PROCEDURE Init*(p0 : TGrafMatrix) : TGrafMatrix,CONSTRUCTOR;
                       PROCEDURE getIdentity*() : TGrafMatrix;
                     END;

      TGRect* = POINTER TO RECORD (java_awt_geom.Rectangle2D$Double)
                STATIC
                  PROCEDURE Init*() : TGRect,CONSTRUCTOR;
                  PROCEDURE Init*(p0 : REAL;
                                  p1 : REAL;
                                  p2 : REAL;
                                  p3 : REAL) : TGRect,CONSTRUCTOR;
                  PROCEDURE Init*(p0 : java_awt_geom.Rectangle2D) : TGRect,CONSTRUCTOR;
                  PROCEDURE Init*(p0 : java_awt_geom.RectangularShape) : TGRect,CONSTRUCTOR;
                  PROCEDURE Init*(p0 : TGPoint) : TGRect,CONSTRUCTOR;
                  PROCEDURE Init*(p0 : TGPoint;
                                  p1 : TGPoint) : TGRect,CONSTRUCTOR;
                  PROCEDURE Init*(p0 : TGRect) : TGRect,CONSTRUCTOR;
                END;

      TGStatics* = POINTER TO RECORD (java_lang.Object)
                   STATIC
                     PROCEDURE Init*() : TGStatics,CONSTRUCTOR;
                   END;

      TLoopGeometry* = POINTER TO EXTENSIBLE RECORD (MAreaGeometry)
                         fLoop* : TGLoop;
                       STATIC
                         PROCEDURE Init*() : TLoopGeometry,CONSTRUCTOR;
                         PROCEDURE Init*(p0 : TGLoop) : TLoopGeometry,CONSTRUCTOR;
                         PROCEDURE Init*(p0 : TLoopGeometry) : TLoopGeometry,CONSTRUCTOR;
                       END;

      TOutlineMakerVertexEngine* = POINTER TO EXTENSIBLE RECORD (java_lang.Object)
                                   STATIC
                                     PROCEDURE Init*(p0 : TGLoop) : TOutlineMakerVertexEngine,CONSTRUCTOR;
                                   END;

      TPathExtractor* = POINTER TO EXTENSIBLE RECORD (TGrafExtractor)
                        STATIC
                          PROCEDURE Init*() : TPathExtractor,CONSTRUCTOR;
                        END;

      TPolygonGeometry* = POINTER TO EXTENSIBLE RECORD (MAreaGeometry)
                            fPolygon* : TGPolygon;
                          STATIC
                            PROCEDURE Init*() : TPolygonGeometry,CONSTRUCTOR;
                            PROCEDURE Init*(p0 : TGPolygon) : TPolygonGeometry,CONSTRUCTOR;
                            PROCEDURE Init*(p0 : TPolygonGeometry) : TPolygonGeometry,CONSTRUCTOR;
                          END;

      TRectGeometry* = POINTER TO EXTENSIBLE RECORD (MAreaGeometry)
                         fRect* : TGRect;
                       STATIC
                         PROCEDURE Init*() : TRectGeometry,CONSTRUCTOR;
                         PROCEDURE Init*(p0 : TGRect) : TRectGeometry,CONSTRUCTOR;
                         PROCEDURE Init*(p0 : TRectGeometry) : TRectGeometry,CONSTRUCTOR;
                       END;

      TSamplingExtractor* = POINTER TO EXTENSIBLE RECORD (TGrafExtractor)
                            STATIC
                              PROCEDURE Init*(p0 : TOutlineMakerVertexEngine;
                                              p1 : REAL) : TSamplingExtractor,CONSTRUCTOR;
                            END;

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

    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) equals*(p0 : AffineTransform) : BOOLEAN,NEW,EXTENSIBLE;

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

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

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

    PROCEDURE (self:AffineTransform) getRotateType!() : INTEGER,NEW,EXTENSIBLE;

    PROCEDURE (self:AffineTransform) getRotationElement!(p0 : INTEGER) : REAL,NEW,EXTENSIBLE;

    PROCEDURE (self:AffineTransform) getTransformType!() : INTEGER,NEW,EXTENSIBLE;

    PROCEDURE (self:AffineTransform) inverseTransform*(p0 : java_awt_geom.Point2D;
                                                       p1 : java_awt_geom.Point2D) : java_awt_geom.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) invert!(),NEW,EXTENSIBLE;

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

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

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

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

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

    PROCEDURE (self:AffineTransform) preRotate!(p0 : REAL;
                                                p1 : REAL;
                                                p2 : REAL),NEW,EXTENSIBLE;

    PROCEDURE (self:AffineTransform) preScale!(p0 : REAL;
                                               p1 : REAL;
                                               p2 : REAL;
                                               p3 : REAL),NEW,EXTENSIBLE;

    PROCEDURE (self:AffineTransform) preTranslate!(p0 : REAL;
                                                   p1 : REAL),NEW,EXTENSIBLE;

    PROCEDURE (self:AffineTransform) prepend*(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) scale!(p0 : REAL;
                                            p1 : REAL;
                                            p2 : REAL;
                                            p3 : 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) setToScale!(p0 : REAL;
                                                 p1 : REAL;
                                                 p2 : REAL;
                                                 p3 : REAL),NEW,EXTENSIBLE;

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

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

    PROCEDURE (self:AffineTransform) transform*(p0 : java_awt_geom.Point2D;
                                                p1 : java_awt_geom.Point2D) : java_awt_geom.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 java_awt_geom.Point2D;
                                                    p1 : INTEGER;
                                                IN  p2 : ARRAY OF java_awt_geom.Point2D;
                                                    p3 : INTEGER;
                                                    p4 : INTEGER),NEW,EXTENSIBLE;

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

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

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

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

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

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

    PROCEDURE (self:MAreaGeometry) clone*() : java_lang.Object,ABSTRACT;

    PROCEDURE (self:MAreaGeometry) cloneAndAdd*(p0 : MAreaGeometry) : MAreaGeometry,NEW,EXTENSIBLE;

    PROCEDURE (self:MAreaGeometry) cloneAndExclusiveOr*(p0 : MAreaGeometry) : MAreaGeometry,NEW,EXTENSIBLE;

    PROCEDURE (self:MAreaGeometry) cloneAndIntersect*(p0 : MAreaGeometry) : MAreaGeometry,NEW,EXTENSIBLE;

    PROCEDURE (self:MAreaGeometry) cloneAndSubtract*(p0 : MAreaGeometry) : MAreaGeometry,NEW,EXTENSIBLE;

    PROCEDURE (self:MAreaGeometry) cloneAndTransform*(p0 : TGrafMatrix) : MAreaGeometry,NEW,EXTENSIBLE;

    PROCEDURE (self:MAreaGeometry) contains*(p0 : TGPoint) : BOOLEAN,NEW,ABSTRACT;

    PROCEDURE (self:MAreaGeometry) contains*(p0 : TGRect) : BOOLEAN,NEW,ABSTRACT;

    PROCEDURE (self:MAreaGeometry) copyFrom!(p0 : MAreaGeometry) : MAreaGeometry,NEW,EXTENSIBLE;

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

    PROCEDURE (self:MAreaGeometry) extract*(p0 : TGrafExtractor;
                                            p1 : TCAGNode),NEW;

    PROCEDURE (self:MAreaGeometry) extract*(p0 : TGrafExtractor;
                                            p1 : TCAGNode;
                                            p2 : TGrafMatrix),NEW,ABSTRACT;

    PROCEDURE (self:MAreaGeometry) getBounds*() : TGRect,NEW,ABSTRACT;

    PROCEDURE (self:MAreaGeometry) getTimeStamp*() : LONGINT,NEW,EXTENSIBLE;

    PROCEDURE (self:MAreaGeometry) intersects*(p0 : TGRect) : BOOLEAN,NEW,ABSTRACT;

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

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

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

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

    PROCEDURE (self:TCAGRoot) getFillCount*() : INTEGER,NEW;

    PROCEDURE (self:TCAGRoot) leftFrameCount*() : INTEGER,NEW;

    PROCEDURE (self:TCAGRoot) rightFrameCount*() : INTEGER,NEW;

    PROCEDURE (self:TCAGRoot) transition*(p0 : INTEGER),EXTENSIBLE;

    PROCEDURE (self:TCAGRoot) transitionLeftFrame*(p0 : INTEGER),EXTENSIBLE;

    PROCEDURE (self:TCAGRoot) transitionRightFrame*(p0 : INTEGER),EXTENSIBLE;

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

    PROCEDURE (self:TEllipseGeometry) cloneAndTransform*(p0 : TGrafMatrix) : MAreaGeometry,EXTENSIBLE;

    PROCEDURE (self:TEllipseGeometry) contains*(p0 : TGPoint) : BOOLEAN,EXTENSIBLE;

    PROCEDURE (self:TEllipseGeometry) contains*(p0 : TGRect) : BOOLEAN,EXTENSIBLE;

    PROCEDURE (self:TEllipseGeometry) copyFrom*(p0 : TEllipseGeometry) : TEllipseGeometry,NEW;

    PROCEDURE (self:TEllipseGeometry) equals*(p0 : MAreaGeometry) : BOOLEAN,EXTENSIBLE;

    PROCEDURE (self:TEllipseGeometry) extract*(p0 : TGrafExtractor;
                                               p1 : TCAGNode;
                                               p2 : TGrafMatrix),EXTENSIBLE;

    PROCEDURE (self:TEllipseGeometry) getBounds*() : TGRect,EXTENSIBLE;

    PROCEDURE (self:TEllipseGeometry) intersects*(p0 : TGRect) : BOOLEAN,EXTENSIBLE;

    PROCEDURE (self:TEllipseGeometry) isEmpty*() : BOOLEAN,EXTENSIBLE;

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

    PROCEDURE (self:TGCurve) concatenate*(p0 : TBaseCurve),EXTENSIBLE;

    PROCEDURE (self:TGCurve) concatenate*(p0 : TBaseCurve;
                                          p1 : BOOLEAN),EXTENSIBLE;

    PROCEDURE (self:TGCurve) copyFrom*(p0 : TGCurve) : TGCurve,NEW,EXTENSIBLE;

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

    PROCEDURE (self:TGCurve) evaluate*(p0 : REAL) : TGPoint,EXTENSIBLE;

    PROCEDURE (self:TGCurve) evaluateW*(p0 : REAL) : TGRPoint,EXTENSIBLE;

    PROCEDURE (self:TGCurve) incrementOrder!(),EXTENSIBLE;

    PROCEDURE (self:TGCurve) makeArc!(p0 : INTEGER;
                                      p1 : TGRPointArray),NEW,EXTENSIBLE;

    PROCEDURE (self:TGCurve) makeEllipticCurve!(p0 : TGEllipse),NEW,EXTENSIBLE;

    PROCEDURE (self:TGCurve) prAppendCurve*(p0 : TBaseCurve;
                                            p1 : BOOLEAN),EXTENSIBLE;

    PROCEDURE (self:TGCurve) refine*(p0 : TGParametricArray),EXTENSIBLE;

    PROCEDURE (self:TGCurve) setKnotScheme*(p0 : INTEGER),EXTENSIBLE;

    PROCEDURE (self:TGCurve) setPoint*(p0 : INTEGER;
                                       p1 : TGRPoint),EXTENSIBLE;

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

    PROCEDURE (self:TGCurve) transformBy*(p0 : TGrafMatrix),NEW,EXTENSIBLE;

    PROCEDURE (self:TGEllipse) contains*(p0 : TGPoint) : BOOLEAN,NEW,EXTENSIBLE;

    PROCEDURE (self:TGEllipse) copyFrom*(p0 : TGEllipse) : TGEllipse,NEW,EXTENSIBLE;

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

    PROCEDURE (self:TGEllipse) getBounds*() : TGRect,NEW,EXTENSIBLE;

    PROCEDURE (self:TGEllipse) getCenter*() : TGPoint,NEW,EXTENSIBLE;

    PROCEDURE (self:TGEllipse) getSize*() : TGPoint,NEW,EXTENSIBLE;

    PROCEDURE (self:TGEllipse) intersects*(p0 : TGRect) : BOOLEAN,NEW,EXTENSIBLE;

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

    PROCEDURE (self:TGLoop) closeLoop*(),NEW,EXTENSIBLE;

    PROCEDURE (self:TGLoop) contains*(p0 : TGPoint) : BOOLEAN,NEW,EXTENSIBLE;

    PROCEDURE (self:TGLoop) contains*(p0 : TGRect) : BOOLEAN,NEW,EXTENSIBLE;

    PROCEDURE (self:TGLoop) copyFrom*(p0 : TGLoop) : TGLoop,NEW,EXTENSIBLE;

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

    PROCEDURE (self:TGLoop) evaluate*(p0 : REAL) : TGPoint,EXTENSIBLE;

    PROCEDURE (self:TGLoop) evaluateW*(p0 : REAL) : TGRPoint,EXTENSIBLE;

    PROCEDURE (self:TGLoop) getBounds*() : TGRect,NEW,EXTENSIBLE;

    PROCEDURE (self:TGLoop) getEOFill*() : BOOLEAN,NEW,EXTENSIBLE;

    PROCEDURE (self:TGLoop) intersects*(p0 : TGRect) : BOOLEAN,NEW,EXTENSIBLE;

    PROCEDURE (self:TGLoop) raiseOrder*(p0 : INTEGER),EXTENSIBLE;

    PROCEDURE (self:TGLoop) refineToBeziers*(),EXTENSIBLE;

    PROCEDURE (self:TGLoop) refineToPinned*(),EXTENSIBLE;

    PROCEDURE (self:TGLoop) setEOFill*(p0 : BOOLEAN),NEW,EXTENSIBLE;

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

    PROCEDURE (self:TGPoint) addBy*(p0 : TGPoint) : TGPoint,NEW,EXTENSIBLE;

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

    PROCEDURE (self:TGPoint) copyFrom*(p0 : TGPoint) : TGPoint,NEW;

    PROCEDURE (self:TGPoint) divideBy*(p0 : REAL) : TGPoint,NEW,EXTENSIBLE;

    PROCEDURE (self:TGPoint) divideBy*(p0 : TGPoint) : TGPoint,NEW,EXTENSIBLE;

    PROCEDURE (self:TGPoint) dotProduct*(p0 : TGPoint) : REAL,NEW,EXTENSIBLE;

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

    PROCEDURE (self:TGPoint) multiplyBy*(p0 : REAL) : TGPoint,NEW,EXTENSIBLE;

    PROCEDURE (self:TGPoint) multiplyBy*(p0 : TGPoint) : TGPoint,NEW,EXTENSIBLE;

    PROCEDURE (self:TGPoint) negate*() : TGPoint,NEW,EXTENSIBLE;

    PROCEDURE (self:TGPoint) setPolarCoordinates*(p0 : REAL),NEW,EXTENSIBLE;

    PROCEDURE (self:TGPoint) setPolarCoordinates*(p0 : REAL;
                                                  p1 : REAL),NEW,EXTENSIBLE;

    PROCEDURE (self:TGPoint) subtractBy*(p0 : TGPoint) : TGPoint,NEW,EXTENSIBLE;

    PROCEDURE (self:TGPoint) vectorAngle*() : REAL,NEW,EXTENSIBLE;

    PROCEDURE (self:TGPoint) vectorLength*() : REAL,NEW,EXTENSIBLE;

    PROCEDURE (self:TGPoint) vectorSquaredLength*() : REAL,NEW,EXTENSIBLE;

    PROCEDURE (self:TGPolygon) contains*(p0 : TGPoint) : BOOLEAN,NEW;

    PROCEDURE (self:TGPolygon) copyFrom*(p0 : TGPolygon) : TGPolygon,NEW;

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

    PROCEDURE (self:TGPolygon) getEOFill*() : BOOLEAN,NEW;

    PROCEDURE (self:TGPolygon) intersects*(p0 : TGRect) : BOOLEAN;

    PROCEDURE (self:TGPolygon) isRectilinear*() : BOOLEAN;

    PROCEDURE (self:TGPolygon) setEOFill*(p0 : BOOLEAN),NEW;

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

    PROCEDURE (self:TGPolyline) addBefore*(p0 : INTEGER;
                                           p1 : TGPoint),NEW,EXTENSIBLE;

    PROCEDURE (self:TGPolyline) append*(p0 : TGPoint),NEW,EXTENSIBLE;

    PROCEDURE (self:TGPolyline) copyFrom*(p0 : TGPolyline) : TGPolyline,NEW,EXTENSIBLE;

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

    PROCEDURE (self:TGPolyline) evaluate*(p0 : REAL) : TGPoint,NEW,EXTENSIBLE;

    PROCEDURE (self:TGPolyline) getBounds*() : TGRect,NEW,EXTENSIBLE;

    PROCEDURE (self:TGPolyline) getNumberOfPoints*() : INTEGER,NEW,EXTENSIBLE;

    PROCEDURE (self:TGPolyline) getPoint*(p0 : INTEGER) : TGPoint,NEW,EXTENSIBLE;

    PROCEDURE (self:TGPolyline) getPoints*(p0 : TGPointArray),NEW,EXTENSIBLE;

    PROCEDURE (self:TGPolyline) intersects*(p0 : TGRect) : BOOLEAN,NEW,EXTENSIBLE;

    PROCEDURE (self:TGPolyline) isDegenerateToAPoint*() : BOOLEAN,NEW,EXTENSIBLE;

    PROCEDURE (self:TGPolyline) isRectilinear*() : BOOLEAN,NEW,EXTENSIBLE;

    PROCEDURE (self:TGPolyline) removePoint*(p0 : INTEGER),NEW,EXTENSIBLE;

    PROCEDURE (self:TGPolyline) reverseDirection*(),NEW,EXTENSIBLE;

    PROCEDURE (self:TGPolyline) setPoint*(p0 : INTEGER;
                                          p1 : TGPoint),NEW,EXTENSIBLE;

    PROCEDURE (self:TGPolyline) transformBy*(p0 : TGrafMatrix),NEW,EXTENSIBLE;

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

    PROCEDURE (self:TGrafMatrix) getElement*(p0 : INTEGER) : REAL,EXTENSIBLE;

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

    PROCEDURE (self:TGrafMatrix) isAffine*() : BOOLEAN,NEW,EXTENSIBLE;

    PROCEDURE (self:TGrafMatrix) preConcatWith*(p0 : TGrafMatrix),NEW,EXTENSIBLE;

    PROCEDURE (self:TGrafMatrix) transformBounds*(p0 : TGRect) : TGRect,NEW,EXTENSIBLE;

    PROCEDURE (self:TGrafMatrix) transformPoint*(p0 : TGPoint) : TGPoint,NEW,EXTENSIBLE;

    PROCEDURE (self:TGrafMatrix) transformPoint*(p0 : TGRPoint) : TGRPoint,NEW,EXTENSIBLE;

    PROCEDURE (self:TGrafMatrix) transformPoints*(p0 : TGPointArray),NEW,EXTENSIBLE;

    PROCEDURE (self:TGrafMatrix) transformPoints*(p0 : TGRPointArray),NEW,EXTENSIBLE;

    PROCEDURE (self:TGrafMatrix) transformPoints*(IN  p0 : ARRAY OF TGRPoint;
                                                  IN  p1 : ARRAY OF TGRPoint;
                                                      p2 : INTEGER),NEW,EXTENSIBLE;

    PROCEDURE (self:TGrafMatrix) untransformBounds*(p0 : TGRect) : TGRect,NEW,EXTENSIBLE;

    PROCEDURE (self:TGrafMatrix) untransformPoint*(p0 : TGPoint) : TGPoint,NEW,EXTENSIBLE;

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

    PROCEDURE (self:TGRect) copyFrom*(p0 : TGRect) : TGRect,NEW,EXTENSIBLE;

    PROCEDURE (self:TGRect) equalSize*(p0 : TGRect) : BOOLEAN,NEW,EXTENSIBLE;

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

    PROCEDURE (self:TGRect) extendTo*(p0 : REAL;
                                      p1 : REAL),NEW,EXTENSIBLE;

    PROCEDURE (self:TGRect) extendTo*(p0 : TGPoint),NEW,EXTENSIBLE;

    PROCEDURE (self:TGRect) extendTo*(p0 : TGRect),NEW,EXTENSIBLE;

    PROCEDURE (self:TGRect) getBottomLeft*() : TGPoint,NEW,EXTENSIBLE;

    PROCEDURE (self:TGRect) getBottomRight*() : TGPoint,NEW,EXTENSIBLE;

    PROCEDURE (self:TGRect) getCenter*() : TGPoint,NEW,EXTENSIBLE;

    PROCEDURE (self:TGRect) getSize*() : TGPoint,NEW,EXTENSIBLE;

    PROCEDURE (self:TGRect) getTopLeft*() : TGPoint,NEW,EXTENSIBLE;

    PROCEDURE (self:TGRect) getTopRight*() : TGPoint,NEW,EXTENSIBLE;

    PROCEDURE (self:TGRect) inset*(p0 : TGPoint),NEW,EXTENSIBLE;

    PROCEDURE (self:TGRect) interpolate*(p0 : REAL;
                                         p1 : REAL) : TGPoint,NEW,EXTENSIBLE;

    PROCEDURE (self:TGRect) intersectWith*(p0 : TGRect),NEW,EXTENSIBLE;

    PROCEDURE (self:TGRect) offset*(p0 : TGPoint),NEW,EXTENSIBLE;

    PROCEDURE (self:TGRect) pin*(p0 : TGPoint),NEW,EXTENSIBLE;

    PROCEDURE (self:TGRect) set*(p0 : REAL;
                                 p1 : REAL;
                                 p2 : REAL;
                                 p3 : REAL),NEW,EXTENSIBLE;

    PROCEDURE (self:TGRect) set*(p0 : TGPoint;
                                 p1 : TGPoint),NEW,EXTENSIBLE;

    PROCEDURE (self:TGRect) setBottomLeft*(p0 : TGPoint),NEW,EXTENSIBLE;

    PROCEDURE (self:TGRect) setBottomRight*(p0 : TGPoint),NEW,EXTENSIBLE;

    PROCEDURE (self:TGRect) setCenter*(p0 : TGPoint),NEW,EXTENSIBLE;

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

    PROCEDURE (self:TGRect) setToPoint*(p0 : TGPoint),NEW,EXTENSIBLE;

    PROCEDURE (self:TGRect) setTopLeft*(p0 : TGPoint),NEW,EXTENSIBLE;

    PROCEDURE (self:TGRect) setTopRight*(p0 : TGPoint),NEW,EXTENSIBLE;

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

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

    PROCEDURE (self:TLoopGeometry) cloneAndTransform*(p0 : TGrafMatrix) : MAreaGeometry,EXTENSIBLE;

    PROCEDURE (self:TLoopGeometry) contains*(p0 : TGPoint) : BOOLEAN,EXTENSIBLE;

    PROCEDURE (self:TLoopGeometry) contains*(p0 : TGRect) : BOOLEAN,EXTENSIBLE;

    PROCEDURE (self:TLoopGeometry) copyFrom*(p0 : TLoopGeometry) : TLoopGeometry,NEW;

    PROCEDURE (self:TLoopGeometry) equals*(p0 : MAreaGeometry) : BOOLEAN,EXTENSIBLE;

    PROCEDURE (self:TLoopGeometry) extract*(p0 : TGrafExtractor;
                                            p1 : TCAGNode;
                                            p2 : TGrafMatrix),EXTENSIBLE;

    PROCEDURE (self:TLoopGeometry) getBounds*() : TGRect,EXTENSIBLE;

    PROCEDURE (self:TLoopGeometry) intersects*(p0 : TGRect) : BOOLEAN,EXTENSIBLE;

    PROCEDURE (self:TLoopGeometry) isEmpty*() : BOOLEAN,EXTENSIBLE;

    PROCEDURE (self:TLoopGeometry) isPolygonal*() : BOOLEAN,EXTENSIBLE;

    PROCEDURE (self:TOutlineMakerVertexEngine) AddVertex*(p0 : TGPoint),NEW,EXTENSIBLE;

    PROCEDURE (self:TOutlineMakerVertexEngine) End*(),NEW,EXTENSIBLE;

    PROCEDURE (self:TOutlineMakerVertexEngine) Render*(p0 : TCAGRoot),NEW,EXTENSIBLE;

    PROCEDURE (self:TOutlineMakerVertexEngine) Reset*(),NEW,EXTENSIBLE;

    PROCEDURE (self:TOutlineMakerVertexEngine) SetCAGNode*(p0 : TCAGUnary),NEW,EXTENSIBLE;

    PROCEDURE (self:TPathExtractor) AddPatches*(p0 : TBezierList),NEW,EXTENSIBLE;

    PROCEDURE (self:TPathExtractor) AddVertex*(p0 : TGPoint),NEW,EXTENSIBLE;

    PROCEDURE (self:TPathExtractor) End*(),NEW,EXTENSIBLE;

    PROCEDURE (self:TPathExtractor) Reset*(),NEW,EXTENSIBLE;

    PROCEDURE (self:TPathExtractor) SetCAGNode*(p0 : TCAGUnary),NEW,EXTENSIBLE;

    PROCEDURE (self:TPathExtractor) extractEllipse*(p0 : TGEllipse;
                                                    p1 : TCAGUnary;
                                                    p2 : TGrafMatrix),EXTENSIBLE;

    PROCEDURE (self:TPathExtractor) extractLoop*(p0 : TGLoop;
                                                 p1 : TCAGUnary;
                                                 p2 : TGrafMatrix),EXTENSIBLE;

    PROCEDURE (self:TPathExtractor) extractPolygon*(p0 : TGPolygon;
                                                    p1 : TCAGUnary;
                                                    p2 : TGrafMatrix),EXTENSIBLE;

    PROCEDURE (self:TPathExtractor) extractRect*(p0 : TGRect;
                                                 p1 : TCAGUnary;
                                                 p2 : TGrafMatrix),EXTENSIBLE;

    PROCEDURE (self:TPathExtractor) getPath*() : TGLoop,NEW,EXTENSIBLE;

    PROCEDURE (self:TPathExtractor) render*(p0 : TCAGRoot),EXTENSIBLE;

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

    PROCEDURE (self:TPolygonGeometry) cloneAndTransform*(p0 : TGrafMatrix) : MAreaGeometry,EXTENSIBLE;

    PROCEDURE (self:TPolygonGeometry) contains*(p0 : TGPoint) : BOOLEAN,EXTENSIBLE;

    PROCEDURE (self:TPolygonGeometry) contains*(p0 : TGRect) : BOOLEAN,EXTENSIBLE;

    PROCEDURE (self:TPolygonGeometry) copyFrom*(p0 : TPolygonGeometry) : TPolygonGeometry,NEW;

    PROCEDURE (self:TPolygonGeometry) equals*(p0 : MAreaGeometry) : BOOLEAN,EXTENSIBLE;

    PROCEDURE (self:TPolygonGeometry) extract*(p0 : TGrafExtractor;
                                               p1 : TCAGNode;
                                               p2 : TGrafMatrix),EXTENSIBLE;

    PROCEDURE (self:TPolygonGeometry) getBounds*() : TGRect,EXTENSIBLE;

    PROCEDURE (self:TPolygonGeometry) intersects*(p0 : TGRect) : BOOLEAN,EXTENSIBLE;

    PROCEDURE (self:TPolygonGeometry) isEmpty*() : BOOLEAN,EXTENSIBLE;

    PROCEDURE (self:TPolygonGeometry) isPolygonal*() : BOOLEAN,EXTENSIBLE;

    PROCEDURE (self:TPolygonGeometry) isRectangular*() : BOOLEAN,EXTENSIBLE;

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

    PROCEDURE (self:TRectGeometry) cloneAndAdd*(p0 : MAreaGeometry) : MAreaGeometry,EXTENSIBLE;

    PROCEDURE (self:TRectGeometry) cloneAndExclusiveOr*(p0 : MAreaGeometry) : MAreaGeometry,EXTENSIBLE;

    PROCEDURE (self:TRectGeometry) cloneAndIntersect*(p0 : MAreaGeometry) : MAreaGeometry,EXTENSIBLE;

    PROCEDURE (self:TRectGeometry) cloneAndSubtract*(p0 : MAreaGeometry) : MAreaGeometry,EXTENSIBLE;

    PROCEDURE (self:TRectGeometry) cloneAndTransform*(p0 : TGrafMatrix) : MAreaGeometry,EXTENSIBLE;

    PROCEDURE (self:TRectGeometry) contains*(p0 : TGPoint) : BOOLEAN,EXTENSIBLE;

    PROCEDURE (self:TRectGeometry) contains*(p0 : TGRect) : BOOLEAN,EXTENSIBLE;

    PROCEDURE (self:TRectGeometry) copyFrom*(p0 : TRectGeometry) : TRectGeometry,NEW;

    PROCEDURE (self:TRectGeometry) equals*(p0 : MAreaGeometry) : BOOLEAN,EXTENSIBLE;

    PROCEDURE (self:TRectGeometry) extract*(p0 : TGrafExtractor;
                                            p1 : TCAGNode;
                                            p2 : TGrafMatrix),EXTENSIBLE;

    PROCEDURE (self:TRectGeometry) getBounds*() : TGRect,EXTENSIBLE;

    PROCEDURE (self:TRectGeometry) intersects*(p0 : TGRect) : BOOLEAN,EXTENSIBLE;

    PROCEDURE (self:TRectGeometry) isEmpty*() : BOOLEAN,EXTENSIBLE;

    PROCEDURE (self:TRectGeometry) isPolygonal*() : BOOLEAN,EXTENSIBLE;

    PROCEDURE (self:TRectGeometry) isRectangular*() : BOOLEAN,EXTENSIBLE;

    PROCEDURE (self:TSamplingExtractor) SetClipBounds*(p0 : TGRect),NEW;

    PROCEDURE (self:TSamplingExtractor) extractEllipse*(p0 : TGEllipse;
                                                        p1 : TCAGUnary;
                                                        p2 : TGrafMatrix),EXTENSIBLE;

    PROCEDURE (self:TSamplingExtractor) extractLoop*(p0 : TGLoop;
                                                     p1 : TCAGUnary;
                                                     p2 : TGrafMatrix),EXTENSIBLE;

    PROCEDURE (self:TSamplingExtractor) extractPolygon*(p0 : TGPolygon;
                                                        p1 : TCAGUnary;
                                                        p2 : TGrafMatrix),EXTENSIBLE;

    PROCEDURE (self:TSamplingExtractor) extractRect*(p0 : TGRect;
                                                     p1 : TCAGUnary;
                                                     p2 : TGrafMatrix),EXTENSIBLE;

    PROCEDURE (self:TSamplingExtractor) render*(p0 : TCAGRoot),EXTENSIBLE;

    END sun_awt_Albert.