Since 1.0 beta

* New methods

** setColor(int argb) in AGLGraphics2D

   Colors can be specified using one integer instead of a Color
   object.  For visualization or other programs using a lot of colors,
   it saves a lot of allocation and garbage collection.  The integer
   encodes the color as 8 bits values with the alpha in the high bits
   and the other components as returned by the Color.getRGB() method.

** setPaint(AGLGradientPaint paint) in AGLGradientPaint

   Gradient paint can also avoid allocating colors using the new
   AGLGradientPaint class, deriving from GradientPaint and recognized
   by AGLGraphics2D.  The advantages are the same as with Colors when
   a lot of gradients are used.

** VertexArray and VertexAttribute in agile2d.geom

   fill and draw can now render several shapes at once using the
   VertexArray data structure. A vertex array can contain several
   instances of the same primitive, such as points, lines, triangles,
   quadrilaterals or one convex polygon.  These primitives are
   rendered in hardware by OpenGL. VertexArray can also be rendered on
   a standard Java2D graphics for compatibility.

   VertexAttribute is associated with VertexArray, a color can be assigned
   to each vertex or each shape.  Rendering of this kind of colored
   shapes is very fast: 625,000 quadrilaterals per second on an nVidia
   Quadro4Go with transparency and smooth shading between different
   colors at each vertex.  A compatibility mode is provided for
   Java2D, albeit with less features due to limitations of the Java2D
   gradient rendering.  VertexAttribute will also manage texture
   indices in the future.

** runGL(gl4java.drawable.GLEventListener ev) in AGLGraphics2D

   This method runs a GL program in the context of the AGLGraphics2D,
   protecting the state of AGLGraphics2D while still allowing native
   GL programs to be run.
   The GLEventListener is a standard class documented by gl4java.

   This method is experimental and will require some changes in the
   AgileJFrame constructors for requesting extra capabilities from the
   GL windows such as a depth buffer or more stencil bits.

   Some issues remain about how much protection should the
   AGLGraphics2D need.  More protection, such as saving the transform
   stacks and stencil buffer would prevent the AGLGraphics2D to be
   corrupted by buggy OpenGL programs but would also require more
   setup overhead.

* Bugs fixed

** getClip/setClip bug in AGLGraphics2D
   Shapes for getClip/setClip should be considered in local
   coordinates, not global coordinates as was done before.

** addDirtyRegion bug in AGLRepaintManager
   When propagating a dirty region from a component, the case where
   the component were in a regular Java window was not correctly
   managed, losing window updates in dialogs for example.

* Improvements

** getClip/setClip performance in AGLGraphics2D

   To avoid transforming the clip Shape returned by getClip or set by
   setClip -- a very frequent pattern during swing traversals --
   getClip now return an internal object deriving from Area but
   storing also the non-transformed clip.  If this object is passed
   back to setClip, the stored clip is reinstalled without further
   computation, at the expense of more allocation.

** Font rendering performance in AGLGraphics2D and TextureFontRenderer

   Instead of using one texture per character, AGLGraphics2D now
   allocate one image mosaic where it renders all the glyphs of the
   font.  This, rendering a string involves just one texture binding,
   which is much faster than switching textures for each characters.
   
   Font rendering should be consistent between Java and Agile now.

** GradientPaint performance in AGLGraphics2D and GradientManager

   Gradient Paint used the stencil buffer to render a shape first and
   then render a gradient through the stencil.  The stencil is not
   used any more, GradientManager uses computed texture coordinates
   (glTexGen) and one 1D texure containing 2 texels (the gradient
   colors).  Once the texture is installed and the equation for
   computing the texture coordinates is installed, the rendering is
   entirely hardware supported on new graphics cards.  Furthermore,
   the rendering is now done in one pass and one bit of stencil is
   saved.

** TexturePaint performance in AGLGraphics2D and Texture

   TexturePaint uses the same mechanism as GradientPaint using a 2D
   texture.  The Texture image is installed as a repeated texture and
   the texture coordinates are computed using glTexGen and two
   equations.  Same savings as GradientPaint.

** Image size not limited to 1024x1024

   Images can now be rendered at any size and will be correctly
   cached using the IMMUTABLE_IMAGE_HINT.

** Images are faster to render

   When images are not transformed, they are sent to OpenGL in one
   pass, achieving a better performance than before.


** VertexArray used in AGLGraphics2D and ShapeManager

   Each occurence polygon rendering with potentially large polygons
   now use GL Vertex Arrays instead of glBegin/glEnd sequences.  This
   mechanisms saves a lot of function call overhead, already in C but
   even more in Java which goes through the Java native interface.

   VertexArray is also available as a Java Shape in the agile2d.geom
   package. It is treated specially for rendering by the
   AGLGraphics2d, achieving very high speed with OpenGL while
   maintaining acceptable speed with the standard Java rendered.

** Misc. optimizations

   All the primitive filled shapes which are convex are now correctly
   rendered without tesselation.  The 1.0 beta code failed to
   propagate the convex flag.