obtained gcc-4.6.4.tar.bz2 from upstream website;upstream

verified gcc-4.6.4.tar.bz2.sig;
imported gcc-4.6.4 source tree from verified upstream tarball.

downloading a git-generated archive based on the 'upstream' tag
should provide you with a source tree that is binary identical
to the one extracted from the above tarball.

if you have obtained the source via the command 'git clone',
however, do note that line-endings of files in your working
directory might differ from line-endings of the respective
files in the upstream repository.

20 files changed, 5811 insertions, 0 deletions

diff --git a/libjava/classpath/gnu/java/awt/java2d/AbstractGraphics2D.java b/libjava/classpath/gnu/java/awt/java2d/AbstractGraphics2D.java
new file mode 100644
index 000000000..1334866f2
--- /dev/null
+++ b/libjava/classpath/gnu/java/awt/java2d/AbstractGraphics2D.java
@@ -0,0 +1,2094 @@
+/* AbstractGraphics2D.java -- Abstract Graphics2D implementation
+   Copyright (C) 2006 Free Software Foundation, Inc.
+
+This file is part of GNU Classpath.
+
+GNU Classpath is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2, or (at your option)
+any later version.
+
+GNU Classpath is distributed in the hope that it will be useful, but
+WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with GNU Classpath; see the file COPYING.  If not, write to the
+Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
+02110-1301 USA.
+
+Linking this library statically or dynamically with other modules is
+making a combined work based on this library.  Thus, the terms and
+conditions of the GNU General Public License cover the whole
+combination.
+
+As a special exception, the copyright holders of this library give you
+permission to link this library with independent modules to produce an
+executable, regardless of the license terms of these independent
+modules, and to copy and distribute the resulting executable under
+terms of your choice, provided that you also meet, for each linked
+independent module, the terms and conditions of the license of that
+module.  An independent module is a module which is not derived from
+or based on this library.  If you modify this library, you may extend
+this exception to your version of the library, but you are not
+obligated to do so.  If you do not wish to do so, delete this
+exception statement from your version. */
+
+package gnu.java.awt.java2d;
+
+import gnu.java.util.LRUCache;
+
+import java.awt.AWTError;
+import java.awt.AlphaComposite;
+import java.awt.AWTPermission;
+import java.awt.BasicStroke;
+import java.awt.Color;
+import java.awt.Composite;
+import java.awt.CompositeContext;
+import java.awt.Dimension;
+import java.awt.Font;
+import java.awt.FontMetrics;
+import java.awt.Graphics;
+import java.awt.Graphics2D;
+import java.awt.Image;
+import java.awt.Paint;
+import java.awt.PaintContext;
+import java.awt.Point;
+import java.awt.Polygon;
+import java.awt.Rectangle;
+import java.awt.RenderingHints;
+import java.awt.Shape;
+import java.awt.Stroke;
+import java.awt.Toolkit;
+import java.awt.RenderingHints.Key;
+import java.awt.font.FontRenderContext;
+import java.awt.font.GlyphVector;
+import java.awt.geom.AffineTransform;
+import java.awt.geom.Arc2D;
+import java.awt.geom.Area;
+import java.awt.geom.Ellipse2D;
+import java.awt.geom.GeneralPath;
+import java.awt.geom.Line2D;
+import java.awt.geom.NoninvertibleTransformException;
+import java.awt.geom.RoundRectangle2D;
+import java.awt.image.BufferedImage;
+import java.awt.image.BufferedImageOp;
+import java.awt.image.ColorModel;
+import java.awt.image.DataBuffer;
+import java.awt.image.FilteredImageSource;
+import java.awt.image.ImageObserver;
+import java.awt.image.ImageProducer;
+import java.awt.image.Raster;
+import java.awt.image.RenderedImage;
+import java.awt.image.ReplicateScaleFilter;
+import java.awt.image.SampleModel;
+import java.awt.image.WritableRaster;
+import java.awt.image.renderable.RenderableImage;
+import java.text.AttributedCharacterIterator;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.LinkedList;
+import java.util.Map;
+import java.util.WeakHashMap;
+
+/**
+ * This is a 100% Java implementation of the Java2D rendering pipeline. It is
+ * meant as a base class for Graphics2D implementations.
+ *
+ * <h2>Backend interface</h2>
+ * <p>
+ * The backend must at the very least provide a Raster which the the rendering
+ * pipeline can paint into. This must be implemented in
+ * {@link #getDestinationRaster()}. For some backends that might be enough, like
+ * when the target surface can be directly access via the raster (like in
+ * BufferedImages). Other targets need some way to synchronize the raster with
+ * the surface, which can be achieved by implementing the
+ * {@link #updateRaster(Raster, int, int, int, int)} method, which always gets
+ * called after a chunk of data got painted into the raster.
+ * </p>
+ * <p>Alternativly the backend can provide a method for filling Shapes by
+ * overriding the protected method fillShape(). This can be accomplished
+ * by a polygon filling function of the backend. Keep in mind though that
+ * Shapes can be quite complex (i.e. non-convex and containing holes, etc)
+ * which is not supported by all polygon fillers. Also it must be noted
+ * that fillShape() is expected to handle painting and compositing as well as
+ * clipping and transformation. If your backend can't support this natively,
+ * then you can fallback to the implementation in this class. You'll need
+ * to provide a writable Raster then, see above.</p>
+ * <p>Another alternative is to implement fillScanline() which only requires
+ * the backend to be able to draw horizontal lines in device space,
+ * which is usually very cheap.
+ * The implementation should still handle painting and compositing,
+ * but no more clipping and transformation is required by the backend.</p>
+ * <p>The backend is free to provide implementations for the various raw*
+ * methods for optimized AWT 1.1 style painting of some primitives. This should
+ * accelerate painting of Swing greatly. When doing so, the backend must also
+ * keep track of the clip and translation, probably by overriding
+ * some clip and translate methods. Don't forget to message super in such a
+ * case.</p>
+ *
+ * <h2>Acceleration options</h2>
+ * <p>
+ * The fact that it is
+ * pure Java makes it a little slow. However, there are several ways of
+ * accelerating the rendering pipeline:
+ * <ol>
+ * <li><em>Optimization hooks for AWT 1.1 - like graphics operations.</em>
+ *   The most important methods from the {@link java.awt.Graphics} class
+ *   have a corresponding <code>raw*</code> method, which get called when
+ *   several optimization conditions are fullfilled. These conditions are
+ *   described below. Subclasses can override these methods and delegate
+ *   it directly to a native backend.</li>
+ * <li><em>Native PaintContexts and CompositeContext.</em> The implementations
+ *   for the 3 PaintContexts and AlphaCompositeContext can be accelerated
+ *   using native code. These have proved to two of the most performance
+ *   critical points in the rendering pipeline and cannot really be done quickly
+ *   in plain Java because they involve lots of shuffling around with large
+ *   arrays. In fact, you really would want to let the graphics card to the
+ *   work, they are made for this.</li>
+ * <li>Provide an accelerated implementation for fillShape(). For instance,
+ * OpenGL can fill shapes very efficiently. There are some considerations
+ * to be made though, see above for details.</li>
+ * </ol>
+ * </p>
+ *
+ * @author Roman Kennke (kennke@aicas.com)
+ */
+public abstract class AbstractGraphics2D
+  extends Graphics2D
+  implements Cloneable, Pixelizer
+{
+  /**
+   * Caches scaled versions of an image.
+   *
+   * @see #drawImage(Image, int, int, int, int, ImageObserver)
+   */
+  protected static final WeakHashMap<Image, HashMap<Dimension,Image>> imageCache =
+    new WeakHashMap<Image, HashMap<Dimension, Image>>();
+
+  /**
+   * Wether we use anti aliasing for rendering text by default or not.
+   */
+  private static final boolean DEFAULT_TEXT_AA =
+    Boolean.getBoolean("gnu.java2d.default_text_aa");
+
+  /**
+   * The default font to use on the graphics object.
+   */
+  private static final Font FONT = new Font("SansSerif", Font.PLAIN, 12);
+
+  /**
+   * The size of the LRU cache used for caching GlyphVectors.
+   */
+  private static final int GV_CACHE_SIZE = 50;
+
+  /**
+   * Caches certain shapes to avoid massive creation of such Shapes in
+   * the various draw* and fill* methods.
+   */
+  private static final ShapeCache shapeCache = new ShapeCache();
+
+  /**
+   * A pool of scanline converters. It is important to reuse scanline
+   * converters because they keep their datastructures in place. We pool them
+   * for use in multiple threads.
+   */
+  private static final LinkedList<ScanlineConverter> scanlineConverters =
+    new LinkedList<ScanlineConverter>();
+
+  /**
+   * Caches glyph vectors for better drawing performance.
+   */
+  private static final Map<TextCacheKey,GlyphVector> gvCache =
+    Collections.synchronizedMap(new LRUCache<TextCacheKey,GlyphVector>(GV_CACHE_SIZE));
+
+  /**
+   * This key is used to search in the gvCache without allocating a new
+   * key each time.
+   */
+  private static final TextCacheKey searchTextKey = new TextCacheKey();
+
+  /**
+   * The transformation for this Graphics2D instance
+   */
+  protected AffineTransform transform;
+
+  /**
+   * The foreground.
+   */
+  private Paint paint;
+
+  /**
+   * The paint context during rendering.
+   */
+  private PaintContext paintContext = null;
+
+  /**
+   * The background.
+   */
+  private Color background = Color.WHITE;
+
+  /**
+   * Foreground color, as set by setColor.
+   */
+  private Color foreground = Color.BLACK;
+  private boolean isForegroundColorNull = true;
+
+  /**
+   * The current font.
+   */
+  private Font font;
+
+  /**
+   * The current composite setting.
+   */
+  private Composite composite;
+
+  /**
+   * The current stroke setting.
+   */
+  private Stroke stroke;
+
+  /**
+   * The current clip. This clip is in user coordinate space.
+   */
+  private Shape clip;
+
+  /**
+   * The rendering hints.
+   */
+  private RenderingHints renderingHints;
+
+  /**
+   * The raster of the destination surface. This is where the painting is
+   * performed.
+   */
+  private WritableRaster destinationRaster;
+
+  /**
+   * Indicates if certain graphics primitives can be rendered in an optimized
+   * fashion. This will be the case if the following conditions are met:
+   * - The transform may only be a translation, no rotation, shearing or
+   *   scaling.
+   * - The paint must be a solid color.
+   * - The composite must be an AlphaComposite.SrcOver.
+   * - The clip must be a Rectangle.
+   * - The stroke must be a plain BasicStroke().
+   *
+   * These conditions represent the standard settings of a new
+   * AbstractGraphics2D object and will be the most commonly used setting
+   * in Swing rendering and should therefore be optimized as much as possible.
+   */
+  private boolean isOptimized = true;
+
+  private static final BasicStroke STANDARD_STROKE = new BasicStroke();
+
+  private static final HashMap<Key, Object> STANDARD_HINTS;
+  static
+    {
+
+      HashMap<Key, Object> hints = new HashMap<Key, Object>();
+      hints.put(RenderingHints.KEY_TEXT_ANTIALIASING,
+                RenderingHints.VALUE_TEXT_ANTIALIAS_DEFAULT);
+      hints.put(RenderingHints.KEY_ANTIALIASING,
+                RenderingHints.VALUE_ANTIALIAS_DEFAULT);
+
+      STANDARD_HINTS = hints;
+    }
+
+  /**
+   * Creates a new AbstractGraphics2D instance.
+   */
+  protected AbstractGraphics2D()
+  {
+    transform = new AffineTransform();
+    background = Color.WHITE;
+    composite = AlphaComposite.SrcOver;
+    stroke = STANDARD_STROKE;
+    renderingHints = new RenderingHints(STANDARD_HINTS);
+  }
+
+  /**
+   * Draws the specified shape. The shape is passed through the current stroke
+   * and is then forwarded to {@link #fillShape}.
+   *
+   * @param shape the shape to draw
+   */
+  public void draw(Shape shape)
+  {
+    // Stroke the shape.
+    Shape strokedShape = stroke.createStrokedShape(shape);
+    // Fill the stroked shape.
+    fillShape(strokedShape, false);
+  }
+
+
+  /**
+   * Draws the specified image and apply the transform for image space ->
+   * user space conversion.
+   *
+   * This method is implemented to special case RenderableImages and
+   * RenderedImages and delegate to
+   * {@link #drawRenderableImage(RenderableImage, AffineTransform)} and
+   * {@link #drawRenderedImage(RenderedImage, AffineTransform)} accordingly.
+   * Other image types are not yet handled.
+   *
+   * @param image the image to be rendered
+   * @param xform the transform from image space to user space
+   * @param obs the image observer to be notified
+   */
+  public boolean drawImage(Image image, AffineTransform xform,
+                           ImageObserver obs)
+  {
+    Rectangle areaOfInterest = new Rectangle(0, 0, image.getWidth(obs),
+                                             image.getHeight(obs));
+    return drawImageImpl(image, xform, obs, areaOfInterest);
+  }
+
+  /**
+   * Draws the specified image and apply the transform for image space ->
+   * user space conversion. This method only draw the part of the image
+   * specified by <code>areaOfInterest</code>.
+   *
+   * This method is implemented to special case RenderableImages and
+   * RenderedImages and delegate to
+   * {@link #drawRenderableImage(RenderableImage, AffineTransform)} and
+   * {@link #drawRenderedImage(RenderedImage, AffineTransform)} accordingly.
+   * Other image types are not yet handled.
+   *
+   * @param image the image to be rendered
+   * @param xform the transform from image space to user space
+   * @param obs the image observer to be notified
+   * @param areaOfInterest the area in image space that is rendered
+   */
+  private boolean drawImageImpl(Image image, AffineTransform xform,
+                             ImageObserver obs, Rectangle areaOfInterest)
+  {
+    boolean ret;
+    if (image == null)
+      {
+        ret = true;
+      }
+    else if (image instanceof RenderedImage)
+      {
+        // FIXME: Handle the ImageObserver.
+        drawRenderedImageImpl((RenderedImage) image, xform, areaOfInterest);
+        ret = true;
+      }
+    else if (image instanceof RenderableImage)
+      {
+        // FIXME: Handle the ImageObserver.
+        drawRenderableImageImpl((RenderableImage) image, xform, areaOfInterest);
+        ret = true;
+      }
+    else
+      {
+        // FIXME: Implement rendering of other Image types.
+        ret = false;
+      }
+    return ret;
+  }
+
+  /**
+   * Renders a BufferedImage and applies the specified BufferedImageOp before
+   * to filter the BufferedImage somehow. The resulting BufferedImage is then
+   * passed on to {@link #drawRenderedImage(RenderedImage, AffineTransform)}
+   * to perform the final rendering.
+   *
+   * @param image the source buffered image
+   * @param op the filter to apply to the buffered image before rendering
+   * @param x the x coordinate to render the image to
+   * @param y the y coordinate to render the image to
+   */
+  public void drawImage(BufferedImage image, BufferedImageOp op, int x, int y)
+  {
+    BufferedImage filtered =
+      op.createCompatibleDestImage(image, image.getColorModel());
+    AffineTransform t = new AffineTransform();
+    t.translate(x, y);
+    drawRenderedImage(filtered, t);
+  }
+
+  /**
+   * Renders the specified image to the destination raster. The specified
+   * transform is used to convert the image into user space. The transform
+   * of this AbstractGraphics2D object is used to transform from user space
+   * to device space.
+   *
+   * The rendering is performed using the scanline algorithm that performs the
+   * rendering of other shapes and a custom Paint implementation, that supplies
+   * the pixel values of the rendered image.
+   *
+   * @param image the image to render to the destination raster
+   * @param xform the transform from image space to user space
+   */
+  public void drawRenderedImage(RenderedImage image, AffineTransform xform)
+  {
+    Rectangle areaOfInterest = new Rectangle(image.getMinX(),
+                                             image.getHeight(),
+                                             image.getWidth(),
+                                             image.getHeight());
+    drawRenderedImageImpl(image, xform, areaOfInterest);
+  }
+
+  /**
+   * Renders the specified image to the destination raster. The specified
+   * transform is used to convert the image into user space. The transform
+   * of this AbstractGraphics2D object is used to transform from user space
+   * to device space. Only the area specified by <code>areaOfInterest</code>
+   * is finally rendered to the target.
+   *
+   * The rendering is performed using the scanline algorithm that performs the
+   * rendering of other shapes and a custom Paint implementation, that supplies
+   * the pixel values of the rendered image.
+   *
+   * @param image the image to render to the destination raster
+   * @param xform the transform from image space to user space
+   */
+  private void drawRenderedImageImpl(RenderedImage image,
+                                     AffineTransform xform,
+                                     Rectangle areaOfInterest)
+  {
+    // First we compute the transformation. This is made up of 3 parts:
+    // 1. The areaOfInterest -> image space transform.
+    // 2. The image space -> user space transform.
+    // 3. The user space -> device space transform.
+    AffineTransform t = new AffineTransform();
+    t.translate(- areaOfInterest.x - image.getMinX(),
+                - areaOfInterest.y - image.getMinY());
+    t.concatenate(xform);
+    t.concatenate(transform);
+    AffineTransform it = null;
+    try
+      {
+        it = t.createInverse();
+      }
+    catch (NoninvertibleTransformException ex)
+      {
+        // Ignore -- we return if the transform is not invertible.
+      }
+    if (it != null)
+      {
+        // Transform the area of interest into user space.
+        GeneralPath aoi = new GeneralPath(areaOfInterest);
+        aoi.transform(xform);
+        // Render the shape using the standard renderer, but with a temporary
+        // ImagePaint.
+        ImagePaint p = new ImagePaint(image, it);
+        Paint savedPaint = paint;
+        try
+          {
+            paint = p;
+            fillShape(aoi, false);
+          }
+        finally
+          {
+            paint = savedPaint;
+          }
+      }
+  }
+
+  /**
+   * Renders a renderable image. This produces a RenderedImage, which is
+   * then passed to {@link #drawRenderedImage(RenderedImage, AffineTransform)}
+   * to perform the final rendering.
+   *
+   * @param image the renderable image to be rendered
+   * @param xform the transform from image space to user space
+   */
+  public void drawRenderableImage(RenderableImage image, AffineTransform xform)
+  {
+    Rectangle areaOfInterest = new Rectangle((int) image.getMinX(),
+                                             (int) image.getHeight(),
+                                             (int) image.getWidth(),
+                                             (int) image.getHeight());
+    drawRenderableImageImpl(image, xform, areaOfInterest);
+
+  }
+
+  /**
+   * Renders a renderable image. This produces a RenderedImage, which is
+   * then passed to {@link #drawRenderedImage(RenderedImage, AffineTransform)}
+   * to perform the final rendering. Only the area of the image specified
+   * by <code>areaOfInterest</code> is rendered.
+   *
+   * @param image the renderable image to be rendered
+   * @param xform the transform from image space to user space
+   */
+  private void drawRenderableImageImpl(RenderableImage image,
+                                       AffineTransform xform,
+                                       Rectangle areaOfInterest)
+  {
+    // TODO: Maybe make more clever usage of a RenderContext here.
+    RenderedImage rendered = image.createDefaultRendering();
+    drawRenderedImageImpl(rendered, xform, areaOfInterest);
+  }
+
+  /**
+   * Draws the specified string at the specified location.
+   *
+   * @param text the string to draw
+   * @param x the x location, relative to the bounding rectangle of the text
+   * @param y the y location, relative to the bounding rectangle of the text
+   */
+  public void drawString(String text, int x, int y)
+  {
+    GlyphVector gv;
+    synchronized (searchTextKey)
+      {
+        TextCacheKey tck = searchTextKey;
+        FontRenderContext frc = getFontRenderContext();
+        tck.setString(text);
+        tck.setFont(font);
+        tck.setFontRenderContext(frc);
+        if (gvCache.containsKey(tck))
+          {
+            gv = gvCache.get(tck);
+          }
+        else
+          {
+            gv = font.createGlyphVector(frc, text.toCharArray());
+            gvCache.put(new TextCacheKey(text, font, frc), gv);
+          }
+      }
+    drawGlyphVector(gv, x, y);
+  }
+
+  /**
+   * Draws the specified string at the specified location.
+   *
+   * @param text the string to draw
+   * @param x the x location, relative to the bounding rectangle of the text
+   * @param y the y location, relative to the bounding rectangle of the text
+   */
+  public void drawString(String text, float x, float y)
+  {
+    FontRenderContext ctx = getFontRenderContext();
+    GlyphVector gv = font.createGlyphVector(ctx, text.toCharArray());
+    drawGlyphVector(gv, x, y);
+  }
+
+  /**
+   * Draws the specified string (as AttributedCharacterIterator) at the
+   * specified location.
+   *
+   * @param iterator the string to draw
+   * @param x the x location, relative to the bounding rectangle of the text
+   * @param y the y location, relative to the bounding rectangle of the text
+   */
+  public void drawString(AttributedCharacterIterator iterator, int x, int y)
+  {
+    FontRenderContext ctx = getFontRenderContext();
+    GlyphVector gv = font.createGlyphVector(ctx, iterator);
+    drawGlyphVector(gv, x, y);
+  }
+
+  /**
+   * Draws the specified string (as AttributedCharacterIterator) at the
+   * specified location.
+   *
+   * @param iterator the string to draw
+   * @param x the x location, relative to the bounding rectangle of the text
+   * @param y the y location, relative to the bounding rectangle of the text
+   */
+  public void drawString(AttributedCharacterIterator iterator, float x, float y)
+  {
+    FontRenderContext ctx = getFontRenderContext();
+    GlyphVector gv = font.createGlyphVector(ctx, iterator);
+    drawGlyphVector(gv, x, y);
+  }
+
+  /**
+   * Fills the specified shape with the current foreground.
+   *
+   * @param shape the shape to fill
+   */
+  public void fill(Shape shape)
+  {
+    fillShape(shape, false);
+  }
+
+  public boolean hit(Rectangle rect, Shape text, boolean onStroke)
+  {
+    // FIXME: Implement this.
+    throw new UnsupportedOperationException("Not yet implemented");
+  }
+
+  /**
+   * Sets the composite.
+   *
+   * @param comp the composite to set
+   */
+  public void setComposite(Composite comp)
+  {
+    if (! (comp instanceof AlphaComposite))
+      {
+        // FIXME: this check is only required "if this Graphics2D
+        // context is drawing to a Component on the display screen".
+        SecurityManager sm = System.getSecurityManager();
+        if (sm != null)
+          sm.checkPermission(new AWTPermission("readDisplayPixels"));
+      }
+
+    composite = comp;
+    if (! (comp.equals(AlphaComposite.SrcOver)))
+      isOptimized = false;
+    else
+      updateOptimization();
+  }
+
+  /**
+   * Sets the current foreground.
+   *
+   * @param p the foreground to set.
+   */
+  public void setPaint(Paint p)
+  {
+    if (p != null)
+      {
+        paint = p;
+
+        if (! (paint instanceof Color))
+          {
+            isOptimized = false;
+          }
+        else
+          {
+            this.foreground = (Color) paint;
+            isForegroundColorNull = false;
+            updateOptimization();
+          }
+      }
+    else
+      {
+        this.foreground = Color.BLACK;
+        isForegroundColorNull = true;
+      }
+
+    // free resources if needed, then put the paint context to null
+    if (this.paintContext != null)
+      this.paintContext.dispose();
+
+    this.paintContext = null;
+  }
+
+  /**
+   * Sets the stroke for this graphics object.
+   *
+   * @param s the stroke to set
+   */
+  public void setStroke(Stroke s)
+  {
+    stroke = s;
+    if (! stroke.equals(new BasicStroke()))
+      isOptimized = false;
+    else
+      updateOptimization();
+  }
+
+  /**
+   * Sets the specified rendering hint.
+   *
+   * @param hintKey the key of the rendering hint
+   * @param hintValue the value
+   */
+  public void setRenderingHint(Key hintKey, Object hintValue)
+  {
+    renderingHints.put(hintKey, hintValue);
+  }
+
+  /**
+   * Returns the rendering hint for the specified key.
+   *
+   * @param hintKey the rendering hint key
+   *
+   * @return the rendering hint for the specified key
+   */
+  public Object getRenderingHint(Key hintKey)
+  {
+    return renderingHints.get(hintKey);
+  }
+
+  /**
+   * Sets the specified rendering hints.
+   *
+   * @param hints the rendering hints to set
+   */
+  public void setRenderingHints(Map hints)
+  {
+    renderingHints.clear();
+    renderingHints.putAll(hints);
+  }
+
+  /**
+   * Adds the specified rendering hints.
+   *
+   * @param hints the rendering hints to add
+   */
+  public void addRenderingHints(Map hints)
+  {
+    renderingHints.putAll(hints);
+  }
+
+  /**
+   * Returns the current rendering hints.
+   *
+   * @return the current rendering hints
+   */
+  public RenderingHints getRenderingHints()
+  {
+    return (RenderingHints) renderingHints.clone();
+  }
+
+  /**
+   * Translates the coordinate system by (x, y).
+   *
+   * @param x the translation X coordinate
+   * @param y the translation Y coordinate
+   */
+  public void translate(int x, int y)
+  {
+    transform.translate(x, y);
+
+    // Update the clip. We special-case rectangular clips here, because they
+    // are so common (e.g. in Swing).
+    if (clip != null)
+      {
+        if (clip instanceof Rectangle)
+          {
+            Rectangle r = (Rectangle) clip;
+            r.x -= x;
+            r.y -= y;
+            setClip(r);
+          }
+        else
+          {
+            AffineTransform clipTransform = new AffineTransform();
+            clipTransform.translate(-x, -y);
+            updateClip(clipTransform);
+          }
+      }
+  }
+
+  /**
+   * Translates the coordinate system by (tx, ty).
+   *
+   * @param tx the translation X coordinate
+   * @param ty the translation Y coordinate
+   */
+  public void translate(double tx, double ty)
+  {
+    transform.translate(tx, ty);
+
+    // Update the clip. We special-case rectangular clips here, because they
+    // are so common (e.g. in Swing).
+    if (clip != null)
+      {
+        if (clip instanceof Rectangle)
+          {
+            Rectangle r = (Rectangle) clip;
+            r.x -= tx;
+            r.y -= ty;
+          }
+        else
+          {
+            AffineTransform clipTransform = new AffineTransform();
+            clipTransform.translate(-tx, -ty);
+            updateClip(clipTransform);
+          }
+      }
+  }
+
+  /**
+   * Rotates the coordinate system by <code>theta</code> degrees.
+   *
+   * @param theta the angle be which to rotate the coordinate system
+   */
+  public void rotate(double theta)
+  {
+    transform.rotate(theta);
+    if (clip != null)
+      {
+        AffineTransform clipTransform = new AffineTransform();
+        clipTransform.rotate(-theta);
+        updateClip(clipTransform);
+      }
+    updateOptimization();
+  }
+
+  /**
+   * Rotates the coordinate system by <code>theta</code> around the point
+   * (x, y).
+   *
+   * @param theta the angle by which to rotate the coordinate system
+   * @param x the point around which to rotate, X coordinate
+   * @param y the point around which to rotate, Y coordinate
+   */
+  public void rotate(double theta, double x, double y)
+  {
+    transform.rotate(theta, x, y);
+    if (clip != null)
+      {
+        AffineTransform clipTransform = new AffineTransform();
+        clipTransform.rotate(-theta, x, y);
+        updateClip(clipTransform);
+      }
+    updateOptimization();
+  }
+
+  /**
+   * Scales the coordinate system by the factors <code>scaleX</code> and
+   * <code>scaleY</code>.
+   *
+   * @param scaleX the factor by which to scale the X axis
+   * @param scaleY the factor by which to scale the Y axis
+   */
+  public void scale(double scaleX, double scaleY)
+  {
+    transform.scale(scaleX, scaleY);
+    if (clip != null)
+      {
+        AffineTransform clipTransform = new AffineTransform();
+        clipTransform.scale(1 / scaleX, 1 / scaleY);
+        updateClip(clipTransform);
+      }
+    updateOptimization();
+  }
+
+  /**
+   * Shears the coordinate system by <code>shearX</code> and
+   * <code>shearY</code>.
+   *
+   * @param shearX the X shearing
+   * @param shearY the Y shearing
+   */
+  public void shear(double shearX, double shearY)
+  {
+    transform.shear(shearX, shearY);
+    if (clip != null)
+      {
+        AffineTransform clipTransform = new AffineTransform();
+        clipTransform.shear(-shearX, -shearY);
+        updateClip(clipTransform);
+      }
+    updateOptimization();
+  }
+
+  /**
+   * Transforms the coordinate system using the specified transform
+   * <code>t</code>.
+   *
+   * @param t the transform
+   */
+  public void transform(AffineTransform t)
+  {
+    transform.concatenate(t);
+    try
+      {
+        AffineTransform clipTransform = t.createInverse();
+        updateClip(clipTransform);
+      }
+    catch (NoninvertibleTransformException ex)
+      {
+        // TODO: How can we deal properly with this?
+        ex.printStackTrace();
+      }
+    updateOptimization();
+  }
+
+  /**
+   * Sets the transformation for this Graphics object.
+   *
+   * @param t the transformation to set
+   */
+  public void setTransform(AffineTransform t)
+  {
+    // Transform clip into target space using the old transform.
+    updateClip(transform);
+    transform.setTransform(t);
+    // Transform the clip back into user space using the inverse new transform.
+    try
+      {
+        updateClip(transform.createInverse());
+      }
+    catch (NoninvertibleTransformException ex)
+      {
+        // TODO: How can we deal properly with this?
+        ex.printStackTrace();
+      }
+    updateOptimization();
+  }
+
+  /**
+   * Returns the transformation of this coordinate system.
+   *
+   * @return the transformation of this coordinate system
+   */
+  public AffineTransform getTransform()
+  {
+    return (AffineTransform) transform.clone();
+  }
+
+  /**
+   * Returns the current foreground.
+   *
+   * @return the current foreground
+   */
+  public Paint getPaint()
+  {
+    return paint;
+  }
+
+
+  /**
+   * Returns the current composite.
+   *
+   * @return the current composite
+   */
+  public Composite getComposite()
+  {
+    return composite;
+  }
+
+  /**
+   * Sets the current background.
+   *
+   * @param color the background to set.
+   */
+  public void setBackground(Color color)
+  {
+    background = color;
+  }
+
+  /**
+   * Returns the current background.
+   *
+   * @return the current background
+   */
+  public Color getBackground()
+  {
+    return background;
+  }
+
+  /**
+   * Returns the current stroke.
+   *
+   * @return the current stroke
+   */
+  public Stroke getStroke()
+  {
+    return stroke;
+  }
+
+  /**
+   * Intersects the clip of this graphics object with the specified clip.
+   *
+   * @param s the clip with which the current clip should be intersected
+   */
+  public void clip(Shape s)
+  {
+    // Initialize clip if not already present.
+    if (clip == null)
+      setClip(s);
+
+    // This is so common, let's optimize this.
+    else if (clip instanceof Rectangle && s instanceof Rectangle)
+      {
+        Rectangle clipRect = (Rectangle) clip;
+        Rectangle r = (Rectangle) s;
+        computeIntersection(r.x, r.y, r.width, r.height, clipRect);
+        // Call setClip so that subclasses get notified.
+        setClip(clipRect);
+      }
+   else
+     {
+       Area current;
+       if (clip instanceof Area)
+         current = (Area) clip;
+       else
+         current = new Area(clip);
+
+       Area intersect;
+       if (s instanceof Area)
+         intersect = (Area) s;
+       else
+         intersect = new Area(s);
+
+       current.intersect(intersect);
+       clip = current;
+       isOptimized = false;
+       // Call setClip so that subclasses get notified.
+       setClip(clip);
+     }
+  }
+
+  public FontRenderContext getFontRenderContext()
+  {
+    // Protect our own transform from beeing modified.
+    AffineTransform tf = new AffineTransform(transform);
+    // TODO: Determine antialias and fractionalmetrics parameters correctly.
+    return new FontRenderContext(tf, false, true);
+  }
+
+  /**
+   * Draws the specified glyph vector at the specified location.
+   *
+   * @param gv the glyph vector to draw
+   * @param x the location, x coordinate
+   * @param y the location, y coordinate
+   */
+  public void drawGlyphVector(GlyphVector gv, float x, float y)
+  {
+    translate(x, y);
+    fillShape(gv.getOutline(), true);
+    translate(-x, -y);
+  }
+
+  /**
+   * Creates a copy of this graphics object.
+   *
+   * @return a copy of this graphics object
+   */
+  public Graphics create()
+  {
+    AbstractGraphics2D copy = (AbstractGraphics2D) clone();
+    return copy;
+  }
+
+  /**
+   * Creates and returns a copy of this Graphics object. This should
+   * be overridden by subclasses if additional state must be handled when
+   * cloning. This is called by {@link #create()}.
+   *
+   * @return a copy of this Graphics object
+   */
+  protected Object clone()
+  {
+    try
+      {
+        AbstractGraphics2D copy = (AbstractGraphics2D) super.clone();
+        // Copy the clip. If it's a Rectangle, preserve that for optimization.
+        if (clip instanceof Rectangle)
+          copy.clip = new Rectangle((Rectangle) clip);
+        else if (clip != null)
+          copy.clip = new GeneralPath(clip);
+        else
+          copy.clip = null;
+
+        copy.renderingHints = new RenderingHints(null);
+        copy.renderingHints.putAll(renderingHints);
+        copy.transform = new AffineTransform(transform);
+        // The remaining state is inmmutable and doesn't need to be copied.
+        return copy;
+      }
+    catch (CloneNotSupportedException ex)
+      {
+        AWTError err = new AWTError("Unexpected exception while cloning");
+        err.initCause(ex);
+        throw err;
+      }
+  }
+
+  /**
+   * Returns the current foreground.
+   */
+  public Color getColor()
+  {
+    if (isForegroundColorNull)
+      return null;
+
+    return this.foreground;
+  }
+
+  /**
+   * Sets the current foreground.
+   *
+   * @param color the foreground to set
+   */
+  public void setColor(Color color)
+  {
+    this.setPaint(color);
+  }
+
+  public void setPaintMode()
+  {
+    // FIXME: Implement this.
+    throw new UnsupportedOperationException("Not yet implemented");
+  }
+
+  public void setXORMode(Color color)
+  {
+    // FIXME: Implement this.
+    throw new UnsupportedOperationException("Not yet implemented");
+  }
+
+  /**
+   * Returns the current font.
+   *
+   * @return the current font
+   */
+  public Font getFont()
+  {
+    return font;
+  }
+
+  /**
+   * Sets the font on this graphics object. When <code>f == null</code>, the
+   * current setting is not changed.
+   *
+   * @param f the font to set
+   */
+  public void setFont(Font f)
+  {
+    if (f != null)
+      font = f;
+  }
+
+  /**
+   * Returns the font metrics for the specified font.
+   *
+   * @param font the font for which to fetch the font metrics
+   *
+   * @return the font metrics for the specified font
+   */
+  public FontMetrics getFontMetrics(Font font)
+  {
+    return Toolkit.getDefaultToolkit().getFontMetrics(font);
+  }
+
+  /**
+   * Returns the bounds of the current clip.
+   *
+   * @return the bounds of the current clip
+   */
+  public Rectangle getClipBounds()
+  {
+    Rectangle b = null;
+    if (clip != null)
+      b = clip.getBounds();
+    return b;
+  }
+
+  /**
+   * Intersects the current clipping region with the specified rectangle.
+   *
+   * @param x the x coordinate of the rectangle
+   * @param y the y coordinate of the rectangle
+   * @param width the width of the rectangle
+   * @param height the height of the rectangle
+   */
+  public void clipRect(int x, int y, int width, int height)
+  {
+    clip(new Rectangle(x, y, width, height));
+  }
+
+  /**
+   * Sets the clip to the specified rectangle.
+   *
+   * @param x the x coordinate of the clip rectangle
+   * @param y the y coordinate of the clip rectangle
+   * @param width the width of the clip rectangle
+   * @param height the height of the clip rectangle
+   */
+  public void setClip(int x, int y, int width, int height)
+  {
+    setClip(new Rectangle(x, y, width, height));
+  }
+
+  /**
+   * Returns the current clip.
+   *
+   * @return the current clip
+   */
+  public Shape getClip()
+  {
+    return clip;
+  }
+
+  /**
+   * Sets the current clipping area to <code>clip</code>.
+   *
+   * @param c the clip to set
+   */
+  public void setClip(Shape c)
+  {
+    clip = c;
+    if (! (clip instanceof Rectangle))
+      isOptimized = false;
+    else
+      updateOptimization();
+  }
+
+  public void copyArea(int x, int y, int width, int height, int dx, int dy)
+  {
+    if (isOptimized)
+      rawCopyArea(x, y, width, height, dx, dy);
+    else
+      copyAreaImpl(x, y, width, height, dx, dy);
+  }
+
+  /**
+   * Draws a line from (x1, y1) to (x2, y2).
+   *
+   * This implementation transforms the coordinates and forwards the call to
+   * {@link #rawDrawLine}.
+   */
+  public void drawLine(int x1, int y1, int x2, int y2)
+  {
+    if (isOptimized)
+      {
+        int tx = (int) transform.getTranslateX();
+        int ty = (int) transform.getTranslateY();
+        rawDrawLine(x1 + tx, y1 + ty, x2 + tx, y2 + ty);
+      }
+    else
+      {
+        ShapeCache sc = shapeCache;
+        if (sc.line == null)
+          sc.line = new Line2D.Float();
+        sc.line.setLine(x1, y1, x2, y2);
+        draw(sc.line);
+      }
+  }
+
+  public void drawRect(int x, int y, int w, int h)
+  {
+    if (isOptimized)
+      {
+        int tx = (int) transform.getTranslateX();
+        int ty = (int) transform.getTranslateY();
+        rawDrawRect(x + tx, y + ty, w, h);
+      }
+    else
+      {
+        ShapeCache sc = shapeCache;
+        if (sc.rect == null)
+          sc.rect = new Rectangle();
+        sc.rect.setBounds(x, y, w, h);
+        draw(sc.rect);
+      }
+  }
+
+  /**
+   * Fills a rectangle with the current paint.
+   *
+   * @param x the upper left corner, X coordinate
+   * @param y the upper left corner, Y coordinate
+   * @param width the width of the rectangle
+   * @param height the height of the rectangle
+   */
+  public void fillRect(int x, int y, int width, int height)
+  {
+    if (isOptimized)
+      {
+        rawFillRect(x + (int) transform.getTranslateX(),
+                    y + (int) transform.getTranslateY(), width, height);
+      }
+    else
+      {
+        ShapeCache sc = shapeCache;
+        if (sc.rect == null)
+          sc.rect = new Rectangle();
+        sc.rect.setBounds(x, y, width, height);
+        fill(sc.rect);
+      }
+  }
+
+  /**
+   * Fills a rectangle with the current background color.
+   *
+   * This implementation temporarily sets the foreground color to the
+   * background and forwards the call to {@link #fillRect(int, int, int, int)}.
+   *
+   * @param x the upper left corner, X coordinate
+   * @param y the upper left corner, Y coordinate
+   * @param width the width of the rectangle
+   * @param height the height of the rectangle
+   */
+  public void clearRect(int x, int y, int width, int height)
+  {
+    if (isOptimized)
+      rawClearRect(x, y, width, height);
+    else
+      {
+        Paint savedForeground = getPaint();
+        setPaint(getBackground());
+        fillRect(x, y, width, height);
+        setPaint(savedForeground);
+      }
+  }
+
+  /**
+   * Draws a rounded rectangle.
+   *
+   * @param x the x coordinate of the rectangle
+   * @param y the y coordinate of the rectangle
+   * @param width the width of the rectangle
+   * @param height the height of the rectangle
+   * @param arcWidth the width of the arcs
+   * @param arcHeight the height of the arcs
+   */
+  public void drawRoundRect(int x, int y, int width, int height, int arcWidth,
+                            int arcHeight)
+  {
+    ShapeCache sc = shapeCache;
+    if (sc.roundRect == null)
+      sc.roundRect = new RoundRectangle2D.Float();
+    sc.roundRect.setRoundRect(x, y, width, height, arcWidth, arcHeight);
+    draw(sc.roundRect);
+  }
+
+  /**
+   * Fills a rounded rectangle.
+   *
+   * @param x the x coordinate of the rectangle
+   * @param y the y coordinate of the rectangle
+   * @param width the width of the rectangle
+   * @param height the height of the rectangle
+   * @param arcWidth the width of the arcs
+   * @param arcHeight the height of the arcs
+   */
+  public void fillRoundRect(int x, int y, int width, int height, int arcWidth,
+                            int arcHeight)
+  {
+    ShapeCache sc = shapeCache;
+    if (sc.roundRect == null)
+      sc.roundRect = new RoundRectangle2D.Float();
+    sc.roundRect.setRoundRect(x, y, width, height, arcWidth, arcHeight);
+    fill(sc.roundRect);
+  }
+
+  /**
+   * Draws the outline of an oval.
+   *
+   * @param x the upper left corner of the bounding rectangle of the ellipse
+   * @param y the upper left corner of the bounding rectangle of the ellipse
+   * @param width the width of the ellipse
+   * @param height the height of the ellipse
+   */
+  public void drawOval(int x, int y, int width, int height)
+  {
+    ShapeCache sc = shapeCache;
+    if (sc.ellipse == null)
+      sc.ellipse = new Ellipse2D.Float();
+    sc.ellipse.setFrame(x, y, width, height);
+    draw(sc.ellipse);
+  }
+
+  /**
+   * Fills an oval.
+   *
+   * @param x the upper left corner of the bounding rectangle of the ellipse
+   * @param y the upper left corner of the bounding rectangle of the ellipse
+   * @param width the width of the ellipse
+   * @param height the height of the ellipse
+   */
+  public void fillOval(int x, int y, int width, int height)
+  {
+    ShapeCache sc = shapeCache;
+    if (sc.ellipse == null)
+      sc.ellipse = new Ellipse2D.Float();
+    sc.ellipse.setFrame(x, y, width, height);
+    fill(sc.ellipse);
+  }
+
+  /**
+   * Draws an arc.
+   */
+  public void drawArc(int x, int y, int width, int height, int arcStart,
+                      int arcAngle)
+  {
+    ShapeCache sc = shapeCache;
+    if (sc.arc == null)
+      sc.arc = new Arc2D.Float();
+    sc.arc.setArc(x, y, width, height, arcStart, arcAngle, Arc2D.OPEN);
+    draw(sc.arc);
+  }
+
+  /**
+   * Fills an arc.
+   */
+  public void fillArc(int x, int y, int width, int height, int arcStart,
+                      int arcAngle)
+  {
+    ShapeCache sc = shapeCache;
+    if (sc.arc == null)
+      sc.arc = new Arc2D.Float();
+    sc.arc.setArc(x, y, width, height, arcStart, arcAngle, Arc2D.PIE);
+    draw(sc.arc);
+  }
+
+  public void drawPolyline(int[] xPoints, int[] yPoints, int npoints)
+  {
+    ShapeCache sc = shapeCache;
+    if (sc.polyline == null)
+      sc.polyline = new GeneralPath();
+    GeneralPath p = sc.polyline;
+    p.reset();
+    if (npoints > 0)
+      p.moveTo(xPoints[0], yPoints[0]);
+    for (int i = 1; i < npoints; i++)
+      p.lineTo(xPoints[i], yPoints[i]);
+    fill(p);
+  }
+
+  /**
+   * Draws the outline of a polygon.
+   */
+  public void drawPolygon(int[] xPoints, int[] yPoints, int npoints)
+  {
+    ShapeCache sc = shapeCache;
+    if (sc.polygon == null)
+      sc.polygon = new Polygon();
+    sc.polygon.reset();
+    sc.polygon.xpoints = xPoints;
+    sc.polygon.ypoints = yPoints;
+    sc.polygon.npoints = npoints;
+    draw(sc.polygon);
+  }
+
+  /**
+   * Fills the outline of a polygon.
+   */
+  public void fillPolygon(int[] xPoints, int[] yPoints, int npoints)
+  {
+    ShapeCache sc = shapeCache;
+    if (sc.polygon == null)
+      sc.polygon = new Polygon();
+    sc.polygon.reset();
+    sc.polygon.xpoints = xPoints;
+    sc.polygon.ypoints = yPoints;
+    sc.polygon.npoints = npoints;
+    fill(sc.polygon);
+  }
+
+  /**
+   * Draws the specified image at the specified location. This forwards
+   * to {@link #drawImage(Image, AffineTransform, ImageObserver)}.
+   *
+   * @param image the image to render
+   * @param x the x location to render to
+   * @param y the y location to render to
+   * @param observer the image observer to receive notification
+   */
+  public boolean drawImage(Image image, int x, int y, ImageObserver observer)
+  {
+    boolean ret;
+    if (isOptimized)
+      {
+        ret = rawDrawImage(image, x + (int) transform.getTranslateX(),
+                           y + (int) transform.getTranslateY(), observer);
+      }
+    else
+      {
+        AffineTransform t = new AffineTransform();
+        t.translate(x, y);
+        ret = drawImage(image, t, observer);
+      }
+    return ret;
+  }
+
+  /**
+   * Draws the specified image at the specified location. The image
+   * is scaled to the specified width and height. This forwards
+   * to {@link #drawImage(Image, AffineTransform, ImageObserver)}.
+   *
+   * @param image the image to render
+   * @param x the x location to render to
+   * @param y the y location to render to
+   * @param width the target width of the image
+   * @param height the target height of the image
+   * @param observer the image observer to receive notification
+   */
+  public boolean drawImage(Image image, int x, int y, int width, int height,
+                           ImageObserver observer)
+  {
+    AffineTransform t = new AffineTransform();
+    int imWidth = image.getWidth(observer);
+    int imHeight = image.getHeight(observer);
+    if (imWidth == width && imHeight == height)
+      {
+        // No need to scale, fall back to non-scaling loops.
+        return drawImage(image, x, y, observer);
+      }
+    else
+      {
+        Image scaled = prepareImage(image, width, height);
+        // Ideally, this should notify the observer about the scaling progress.
+        return drawImage(scaled, x, y, observer);
+      }
+  }
+
+  /**
+   * Draws the specified image at the specified location. This forwards
+   * to {@link #drawImage(Image, AffineTransform, ImageObserver)}.
+   *
+   * @param image the image to render
+   * @param x the x location to render to
+   * @param y the y location to render to
+   * @param bgcolor the background color to use for transparent pixels
+   * @param observer the image observer to receive notification
+   */
+  public boolean drawImage(Image image, int x, int y, Color bgcolor,
+                           ImageObserver observer)
+  {
+    AffineTransform t = new AffineTransform();
+    t.translate(x, y);
+    // TODO: Somehow implement the background option.
+    return drawImage(image, t, observer);
+  }
+
+  /**
+   * Draws the specified image at the specified location. The image
+   * is scaled to the specified width and height. This forwards
+   * to {@link #drawImage(Image, AffineTransform, ImageObserver)}.
+   *
+   * @param image the image to render
+   * @param x the x location to render to
+   * @param y the y location to render to
+   * @param width the target width of the image
+   * @param height the target height of the image
+   * @param bgcolor the background color to use for transparent pixels
+   * @param observer the image observer to receive notification
+   */
+  public boolean drawImage(Image image, int x, int y, int width, int height,
+                           Color bgcolor, ImageObserver observer)
+  {
+    AffineTransform t = new AffineTransform();
+    t.translate(x, y);
+    double scaleX = (double) image.getWidth(observer) / (double) width;
+    double scaleY = (double) image.getHeight(observer) / (double) height;
+    t.scale(scaleX, scaleY);
+    // TODO: Somehow implement the background option.
+    return drawImage(image, t, observer);
+  }
+
+  /**
+   * Draws an image fragment to a rectangular area of the target.
+   *
+   * @param image the image to render
+   * @param dx1 the first corner of the destination rectangle
+   * @param dy1 the first corner of the destination rectangle
+   * @param dx2 the second corner of the destination rectangle
+   * @param dy2 the second corner of the destination rectangle
+   * @param sx1 the first corner of the source rectangle
+   * @param sy1 the first corner of the source rectangle
+   * @param sx2 the second corner of the source rectangle
+   * @param sy2 the second corner of the source rectangle
+   * @param observer the image observer to be notified
+   */
+  public boolean drawImage(Image image, int dx1, int dy1, int dx2, int dy2,
+                           int sx1, int sy1, int sx2, int sy2,
+                           ImageObserver observer)
+  {
+    int sx = Math.min(sx1, sx1);
+    int sy = Math.min(sy1, sy2);
+    int sw = Math.abs(sx1 - sx2);
+    int sh = Math.abs(sy1 - sy2);
+    int dx = Math.min(dx1, dx1);
+    int dy = Math.min(dy1, dy2);
+    int dw = Math.abs(dx1 - dx2);
+    int dh = Math.abs(dy1 - dy2);
+
+    AffineTransform t = new AffineTransform();
+    t.translate(sx - dx, sy - dy);
+    double scaleX = (double) sw / (double) dw;
+    double scaleY = (double) sh / (double) dh;
+    t.scale(scaleX, scaleY);
+    Rectangle areaOfInterest = new Rectangle(sx, sy, sw, sh);
+    return drawImageImpl(image, t, observer, areaOfInterest);
+  }
+
+  /**
+   * Draws an image fragment to a rectangular area of the target.
+   *
+   * @param image the image to render
+   * @param dx1 the first corner of the destination rectangle
+   * @param dy1 the first corner of the destination rectangle
+   * @param dx2 the second corner of the destination rectangle
+   * @param dy2 the second corner of the destination rectangle
+   * @param sx1 the first corner of the source rectangle
+   * @param sy1 the first corner of the source rectangle
+   * @param sx2 the second corner of the source rectangle
+   * @param sy2 the second corner of the source rectangle
+   * @param bgcolor the background color to use for transparent pixels
+   * @param observer the image observer to be notified
+   */
+  public boolean drawImage(Image image, int dx1, int dy1, int dx2, int dy2,
+                           int sx1, int sy1, int sx2, int sy2, Color bgcolor,
+                           ImageObserver observer)
+  {
+    // FIXME: Do something with bgcolor.
+    return drawImage(image, dx1, dy1, dx2, dy2, sx1, sy1, sx2, sy2, observer);
+  }
+
+  /**
+   * Disposes this graphics object.
+   */
+  public void dispose()
+  {
+    // Nothing special to do here.
+  }
+
+  /**
+   * Fills the specified shape. Override this if your backend can efficiently
+   * fill shapes. This is possible on many systems via a polygon fill
+   * method or something similar. But keep in mind that Shapes can be quite
+   * complex (non-convex, with holes etc), which is not necessarily supported
+   * by all polygon fillers. Also note that you must perform clipping
+   * before filling the shape.
+   *
+   * @param s the shape to fill
+   * @param isFont <code>true</code> if the shape is a font outline
+   */
+  protected void fillShape(Shape s, boolean isFont)
+  {
+    // Determine if we need to antialias stuff.
+    boolean antialias = false;
+    if (isFont)
+      {
+        Object v = renderingHints.get(RenderingHints.KEY_TEXT_ANTIALIASING);
+        // We default to antialiasing for text rendering.
+        antialias = v == RenderingHints.VALUE_TEXT_ANTIALIAS_ON
+                    || (v == RenderingHints.VALUE_TEXT_ANTIALIAS_DEFAULT
+                         && DEFAULT_TEXT_AA);
+      }
+    else
+      {
+        Object v = renderingHints.get(RenderingHints.KEY_ANTIALIASING);
+        antialias = (v == RenderingHints.VALUE_ANTIALIAS_ON);
+      }
+    ScanlineConverter sc = getScanlineConverter();
+    int resolution = 0;
+    int yRes = 0;
+    if (antialias)
+      {
+        // Adjust resolution according to rendering hints.
+        resolution = 2;
+        yRes = 4;
+      }
+    sc.renderShape(this, s, clip, transform, resolution, yRes, renderingHints);
+    freeScanlineConverter(sc);
+  }
+
+  /**
+   * Returns the color model of this Graphics object.
+   *
+   * @return the color model of this Graphics object
+   */
+  protected abstract ColorModel getColorModel();
+
+  /**
+   * Returns the bounds of the target.
+   *
+   * @return the bounds of the target
+   */
+  protected abstract Rectangle getDeviceBounds();
+
+  /**
+   * Draws a line in optimization mode. The implementation should respect the
+   * clip and translation. It can assume that the clip is a rectangle and that
+   * the transform is only a translating transform.
+   *
+   * @param x0 the starting point, X coordinate
+   * @param y0 the starting point, Y coordinate
+   * @param x1 the end point, X coordinate
+   * @param y1 the end point, Y coordinate
+   */
+  protected void rawDrawLine(int x0, int y0, int x1, int y1)
+  {
+    ShapeCache sc = shapeCache;
+    if (sc.line == null)
+      sc.line = new Line2D.Float();
+    sc.line.setLine(x0, y0, x1, y1);
+    draw(sc.line);
+  }
+
+  protected void rawDrawRect(int x, int y, int w, int h)
+  {
+    ShapeCache sc = shapeCache;
+    if (sc.rect == null)
+      sc.rect = new Rectangle();
+    sc.rect.setBounds(x, y, w, h);
+    draw(sc.rect);
+  }
+
+  /**
+   * Clears a rectangle in optimization mode. The implementation should respect the
+   * clip and translation. It can assume that the clip is a rectangle and that
+   * the transform is only a translating transform.
+   *
+   * @param x the upper left corner, X coordinate
+   * @param y the upper left corner, Y coordinate
+   * @param w the width
+   * @param h the height
+   */
+  protected void rawClearRect(int x, int y, int w, int h)
+  {
+    Paint savedForeground = getPaint();
+    setPaint(getBackground());
+    rawFillRect(x, y, w, h);
+    setPaint(savedForeground);
+  }
+
+  /**
+   * Fills a rectangle in optimization mode. The implementation should respect
+   * the clip but can assume that it is a rectangle.
+   *
+   * @param x the upper left corner, X coordinate
+   * @param y the upper left corner, Y coordinate
+   * @param w the width
+   * @param h the height
+   */
+  protected void rawFillRect(int x, int y, int w, int h)
+  {
+    ShapeCache sc = shapeCache;
+    if (sc.rect == null)
+      sc.rect = new Rectangle();
+    sc.rect.setBounds(x, y, w, h);
+    fill(sc.rect);
+  }
+
+  /**
+   * Draws an image in optimization mode. The implementation should respect
+   * the clip but can assume that it is a rectangle.
+   *
+   * @param image the image to be painted
+   * @param x the location, X coordinate
+   * @param y the location, Y coordinate
+   * @param obs the image observer to be notified
+   *
+   * @return <code>true</code> when the image is painted completely,
+   *         <code>false</code> if it is still rendered
+   */
+  protected boolean rawDrawImage(Image image, int x, int y, ImageObserver obs)
+  {
+    AffineTransform t = new AffineTransform();
+    t.translate(x, y);
+    return drawImage(image, t, obs);
+  }
+
+  /**
+   * Copies a rectangular region to another location.
+   *
+   * @param x the upper left corner, X coordinate
+   * @param y the upper left corner, Y coordinate
+   * @param w the width
+   * @param h the height
+   * @param dx
+   * @param dy
+   */
+  protected void rawCopyArea(int x, int y, int w, int h, int dx, int dy)
+  {
+    copyAreaImpl(x, y, w, h, dx, dy);
+  }
+
+  // Private implementation methods.
+
+  /**
+   * Copies a rectangular area of the target raster to a different location.
+   */
+  private void copyAreaImpl(int x, int y, int w, int h, int dx, int dy)
+  {
+    // FIXME: Implement this properly.
+    throw new UnsupportedOperationException("Not implemented yet.");
+  }
+
+  /**
+   * Paints a scanline between x0 and x1. Override this when your backend
+   * can efficiently draw/fill horizontal lines.
+   *
+   * @param x0 the left offset
+   * @param x1 the right offset
+   * @param y the scanline
+   */
+  public void renderScanline(int y, ScanlineCoverage c)
+  {
+    PaintContext pCtx = getPaintContext();
+
+    int x0 = c.getMinX();
+    int x1 = c.getMaxX();
+    Raster paintRaster = pCtx.getRaster(x0, y, x1 - x0, 1);
+
+    // Do the anti aliasing thing.
+    float coverageAlpha = 0;
+    float maxCoverage = c.getMaxCoverage();
+    ColorModel cm = pCtx.getColorModel();
+    DataBuffer db = paintRaster.getDataBuffer();
+    Point loc = new Point(paintRaster.getMinX(), paintRaster.getMinY());
+    SampleModel sm = paintRaster.getSampleModel();
+    WritableRaster writeRaster = Raster.createWritableRaster(sm, db, loc);
+    WritableRaster alphaRaster = cm.getAlphaRaster(writeRaster);
+    int pixel;
+    ScanlineCoverage.Iterator iter = c.iterate();
+    while (iter.hasNext())
+      {
+        ScanlineCoverage.Range range = iter.next();
+        coverageAlpha = range.getCoverage() / maxCoverage;
+        if (coverageAlpha < 1.0)
+          {
+            for (int x = range.getXPos(); x < range.getXPosEnd(); x++)
+              {
+                pixel = alphaRaster.getSample(x, y, 0);
+                pixel = (int) (pixel * coverageAlpha);
+                alphaRaster.setSample(x, y, 0, pixel);
+              }
+          }
+      }
+    ColorModel paintColorModel = pCtx.getColorModel();
+    CompositeContext cCtx = composite.createContext(paintColorModel,
+                                                    getColorModel(),
+                                                    renderingHints);
+    WritableRaster raster = getDestinationRaster();
+    WritableRaster targetChild = raster.createWritableTranslatedChild(-x0, -y);
+
+    cCtx.compose(paintRaster, targetChild, targetChild);
+    updateRaster(raster, x0, y, x1 - x0, 1);
+    cCtx.dispose();
+  }
+
+
+  /**
+   * Initializes this graphics object. This must be called by subclasses in
+   * order to correctly initialize the state of this object.
+   */
+  protected void init()
+  {
+    setPaint(Color.BLACK);
+    setFont(FONT);
+    isOptimized = true;
+  }
+
+  /**
+   * Returns a WritableRaster that is used by this class to perform the
+   * rendering in. It is not necessary that the target surface immediately
+   * reflects changes in the raster. Updates to the raster are notified via
+   * {@link #updateRaster}.
+   *
+   * @return the destination raster
+   */
+  protected WritableRaster getDestinationRaster()
+  {
+    // TODO: Ideally we would fetch the xdrawable's surface pixels for
+    // initialization of the raster.
+    Rectangle db = getDeviceBounds();
+    if (destinationRaster == null)
+      {
+        int[] bandMasks = new int[]{ 0xFF0000, 0xFF00, 0xFF };
+        destinationRaster = Raster.createPackedRaster(DataBuffer.TYPE_INT,
+                                                      db.width, db.height,
+                                                      bandMasks, null);
+        // Initialize raster with white.
+        int x0 = destinationRaster.getMinX();
+        int x1 = destinationRaster.getWidth() + x0;
+        int y0 = destinationRaster.getMinY();
+        int y1 = destinationRaster.getHeight() + y0;
+        int numBands = destinationRaster.getNumBands();
+        for (int y = y0; y < y1; y++)
+          {
+            for (int x = x0; x < x1; x++)
+              {
+                for (int b = 0; b < numBands; b++)
+                  destinationRaster.setSample(x, y, b, 255);
+              }
+          }
+      }
+    return destinationRaster;
+  }
+
+  /**
+   * Notifies the backend that the raster has changed in the specified
+   * rectangular area. The raster that is provided in this method is always
+   * the same as the one returned in {@link #getDestinationRaster}.
+   * Backends that reflect changes to this raster directly don't need to do
+   * anything here.
+   *
+   * @param raster the updated raster, identical to the raster returned
+   *        by {@link #getDestinationRaster()}
+   * @param x the upper left corner of the updated region, X coordinate
+   * @param y the upper lef corner of the updated region, Y coordinate
+   * @param w the width of the updated region
+   * @param h the height of the updated region
+   */
+  protected void updateRaster(Raster raster, int x, int y, int w, int h)
+  {
+    // Nothing to do here. Backends that need to update their surface
+    // to reflect the change should override this method.
+  }
+
+  // Some helper methods.
+
+  /**
+   * Helper method to check and update the optimization conditions.
+   */
+  private void updateOptimization()
+  {
+    int transformType = transform.getType();
+    boolean optimizedTransform = false;
+    if (transformType == AffineTransform.TYPE_IDENTITY
+        || transformType == AffineTransform.TYPE_TRANSLATION)
+      optimizedTransform = true;
+
+    boolean optimizedClip = (clip == null || clip instanceof Rectangle);
+    isOptimized = optimizedClip
+                  && optimizedTransform && paint instanceof Color
+                  && composite == AlphaComposite.SrcOver
+                  && stroke.equals(new BasicStroke());
+  }
+
+  /**
+   * Calculates the intersection of two rectangles. The result is stored
+   * in <code>rect</code>. This is basically the same
+   * like {@link Rectangle#intersection(Rectangle)}, only that it does not
+   * create new Rectangle instances. The tradeoff is that you loose any data in
+   * <code>rect</code>.
+   *
+   * @param x upper-left x coodinate of first rectangle
+   * @param y upper-left y coodinate of first rectangle
+   * @param w width of first rectangle
+   * @param h height of first rectangle
+   * @param rect a Rectangle object of the second rectangle
+   *
+   * @throws NullPointerException if rect is null
+   *
+   * @return a rectangle corresponding to the intersection of the
+   *         two rectangles. An empty rectangle is returned if the rectangles
+   *         do not overlap
+   */
+  private static Rectangle computeIntersection(int x, int y, int w, int h,
+                                               Rectangle rect)
+  {
+    int x2 = rect.x;
+    int y2 = rect.y;
+    int w2 = rect.width;
+    int h2 = rect.height;
+
+    int dx = (x > x2) ? x : x2;
+    int dy = (y > y2) ? y : y2;
+    int dw = (x + w < x2 + w2) ? (x + w - dx) : (x2 + w2 - dx);
+    int dh = (y + h < y2 + h2) ? (y + h - dy) : (y2 + h2 - dy);
+
+    if (dw >= 0 && dh >= 0)
+      rect.setBounds(dx, dy, dw, dh);
+    else
+      rect.setBounds(0, 0, 0, 0);
+
+    return rect;
+  }
+
+  /**
+   * Helper method to transform the clip. This is called by the various
+   * transformation-manipulation methods to update the clip (which is in
+   * userspace) accordingly.
+   *
+   * The transform usually is the inverse transform that was applied to the
+   * graphics object.
+   *
+   * @param t the transform to apply to the clip
+   */
+  private void updateClip(AffineTransform t)
+  {
+    if (! (clip instanceof GeneralPath))
+      clip = new GeneralPath(clip);
+
+    GeneralPath p = (GeneralPath) clip;
+    p.transform(t);
+  }
+
+  /**
+   * Returns a free scanline converter from the pool.
+   *
+   * @return a scanline converter
+   */
+  private ScanlineConverter getScanlineConverter()
+  {
+    synchronized (scanlineConverters)
+      {
+        ScanlineConverter sc;
+        if (scanlineConverters.size() > 0)
+          {
+            sc = scanlineConverters.removeFirst();
+          }
+        else
+          {
+            sc = new ScanlineConverter();
+          }
+        return sc;
+      }
+  }
+
+  /**
+   * Puts a scanline converter back in the pool.
+   *
+   * @param sc
+   */
+  private void freeScanlineConverter(ScanlineConverter sc)
+  {
+    synchronized (scanlineConverters)
+      {
+        scanlineConverters.addLast(sc);
+      }
+  }
+
+  private PaintContext getPaintContext()
+  {
+    if (this.paintContext == null)
+      {
+        this.paintContext =
+          this.foreground.createContext(getColorModel(),
+                                        getDeviceBounds(),
+                                        getClipBounds(),
+                                        getTransform(),
+                                        getRenderingHints());
+      }
+
+    return this.paintContext;
+  }
+
+  /**
+   * Scales an image to the specified width and height. This should also
+   * be used to implement
+   * {@link Toolkit#prepareImage(Image, int, int, ImageObserver)}.
+   * This uses {@link Toolkit#createImage(ImageProducer)} to create the actual
+   * image.
+   *
+   * @param image the image to prepare
+   * @param w the width
+   * @param h the height
+   *
+   * @return the scaled image
+   */
+  public static Image prepareImage(Image image, int w, int h)
+  {
+    // Try to find cached scaled image.
+    HashMap<Dimension,Image> scaledTable = imageCache.get(image);
+    Dimension size = new Dimension(w, h);
+    Image scaled = null;
+    if (scaledTable != null)
+      {
+        scaled = scaledTable.get(size);
+      }
+    if (scaled == null)
+      {
+        // No cached scaled image. Start scaling image now.
+        ImageProducer source = image.getSource();
+        ReplicateScaleFilter scaler = new ReplicateScaleFilter(w, h);
+        FilteredImageSource filteredSource =
+          new FilteredImageSource(source, scaler);
+        // Ideally, this should asynchronously scale the image.
+        Image scaledImage =
+          Toolkit.getDefaultToolkit().createImage(filteredSource);
+        scaled = scaledImage;
+        // Put scaled image in cache.
+        if (scaledTable == null)
+          {
+            scaledTable = new HashMap<Dimension,Image>();
+            imageCache.put(image, scaledTable);
+          }
+        scaledTable.put(size, scaledImage);
+      }
+    return scaled;
+  }
+
+}
diff --git a/libjava/classpath/gnu/java/awt/java2d/ActiveEdges.java b/libjava/classpath/gnu/java/awt/java2d/ActiveEdges.java
new file mode 100644
index 000000000..efe1966e3
--- /dev/null
+++ b/libjava/classpath/gnu/java/awt/java2d/ActiveEdges.java
@@ -0,0 +1,197 @@
+/* ActiveEdges.java -- A collection of active edges for scanline conversion
+   Copyright (C) 2006 Free Software Foundation, Inc.
+
+This file is part of GNU Classpath.
+
+GNU Classpath is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2, or (at your option)
+any later version.
+
+GNU Classpath is distributed in the hope that it will be useful, but
+WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with GNU Classpath; see the file COPYING.  If not, write to the
+Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
+02110-1301 USA.
+
+Linking this library statically or dynamically with other modules is
+making a combined work based on this library.  Thus, the terms and
+conditions of the GNU General Public License cover the whole
+combination.
+
+As a special exception, the copyright holders of this library give you
+permission to link this library with independent modules to produce an
+executable, regardless of the license terms of these independent
+modules, and to copy and distribute the resulting executable under
+terms of your choice, provided that you also meet, for each linked
+independent module, the terms and conditions of the license of that
+module.  An independent module is a module which is not derived from
+or based on this library.  If you modify this library, you may extend
+this exception to your version of the library, but you are not
+obligated to do so.  If you do not wish to do so, delete this
+exception statement from your version. */
+
+
+package gnu.java.awt.java2d;
+
+import gnu.java.lang.CPStringBuilder;
+
+/**
+ * A collection of active edges for scanline conversion.
+ */
+final class ActiveEdges
+{
+
+  /**
+   * The active edges. This can contain null values at arbirary locations.
+   * The method #sort() packs this together.
+   */
+  private PolyEdge[] activeEdges;
+
+  /**
+   * The actual number of active edges. The array can be bigger than this
+   * number.
+   */
+  private int numActiveEdges;
+
+  /**
+   * Creates a new ActiveEdges object.
+   */
+  ActiveEdges()
+  {
+    activeEdges = new PolyEdge[8];
+    numActiveEdges = 0;
+  }
+
+  /**
+   * Clears out all active edges. This is cheap as it simply resets the
+   * counter to 0. It does not release all references to PolyEdge instances.
+   */
+  void clear()
+  {
+    numActiveEdges = 0;
+  }
+
+  /**
+   * Adds the specified edge to the list of active edges. This does not yet
+   * sort the edges and therefore does destroy any order of the list.
+   *
+   * @param edge the edge to add
+   */
+  void add(PolyEdge edge)
+  {
+    // Grow array when necessary.
+    int oldSize = activeEdges.length;
+    if (numActiveEdges >= oldSize)
+      {
+        int newSize = oldSize + oldSize / 4 + 1;
+        PolyEdge[] newEdges = new PolyEdge[newSize];
+        System.arraycopy(activeEdges, 0, newEdges, 0, oldSize);
+        activeEdges = newEdges;
+      }
+    activeEdges[numActiveEdges] = edge;
+    numActiveEdges++;
+  }
+
+  /**
+   * Intersects all active edges, sorts them according to their intersection
+   * points and packs the array to remove unneeded edges. This does also
+   * remove any edges that do not intersect the scanline (i.e. they end above
+   * of the scanline).
+   *
+   * @param y the scanline height
+   */
+  void intersectSortAndPack(int n, int y)
+  {
+    // Intersect and pack in one go.
+    int last = 0;
+    PolyEdge tmp;
+    for (int i = 0; i < numActiveEdges; i++)
+      {
+        PolyEdge edge = activeEdges[i];
+        // Clear out edge that ends above the scanline.
+        if (edge != null && edge.y1 >= y)
+          {
+            assert edge.y1 >= y && edge.y0 <= y : "edge must cross scanline";
+            edge.intersect(n, y);
+            activeEdges[last] = edge;
+            last++;
+
+            // Bubble up the added edge.
+            for (int j = last - 1; j > 0; j--)
+              {
+                if (activeEdges[j].xIntersection
+                    < activeEdges[j - 1].xIntersection)
+                  {
+                    tmp = activeEdges[j];
+                    activeEdges[j] = activeEdges[j - 1];
+                    activeEdges[j - 1] = tmp;
+                  }
+                else
+                  {
+                    // The beginning of the list is already sorted.
+                    break;
+                  }
+              }
+          }
+      }
+    numActiveEdges = last;
+
+  }
+
+  /**
+   * Returns the number of active edges. This is only reliable after a
+   * call to {@link #intersectSortAndPack(int, int)}.
+   *
+   * @return the number of active edges
+   */
+  int getNumActiveEdges()
+  {
+    return numActiveEdges;
+  }
+
+  /**
+   * Returns the active edge at the position <code>i</code>.
+   *
+   * @param i the index
+   *
+   * @return the active edge at the specified index
+   */
+  PolyEdge getActiveEdge(int i)
+  {
+    return activeEdges[i];
+  }
+
+  /**
+   * Removes all edges that end above the specified height.
+   *
+   * @param y the cut-off height
+   */
+  void remove(int y)
+  {
+    for (int i = 0; i < numActiveEdges; i++)
+      {
+        PolyEdge edge = activeEdges[i];
+        if (edge != null && edge.y1 < y)
+          {
+            activeEdges[i] = null;
+          }
+      }
+  }
+
+  public String toString()
+  {
+    CPStringBuilder s = new CPStringBuilder();
+    s.append("[ActiveEdges] ");
+    for (int i = 0; i < numActiveEdges; i++)
+      {
+        s.append(activeEdges[i]);
+        s.append(',');
+      }
+    return s.toString();
+  }
+}
diff --git a/libjava/classpath/gnu/java/awt/java2d/AlphaCompositeContext.java b/libjava/classpath/gnu/java/awt/java2d/AlphaCompositeContext.java
new file mode 100644
index 000000000..f1f082abe
--- /dev/null
+++ b/libjava/classpath/gnu/java/awt/java2d/AlphaCompositeContext.java
@@ -0,0 +1,316 @@
+/* AlphaCompositeContext.java -- CompositeContext impl for AlphaComposite
+   Copyright (C) 2006 Free Software Foundation, Inc.
+
+This file is part of GNU Classpath.
+
+GNU Classpath is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2, or (at your option)
+any later version.
+
+GNU Classpath is distributed in the hope that it will be useful, but
+WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with GNU Classpath; see the file COPYING.  If not, write to the
+Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
+02110-1301 USA.
+
+Linking this library statically or dynamically with other modules is
+making a combined work based on this library.  Thus, the terms and
+conditions of the GNU General Public License cover the whole
+combination.
+
+As a special exception, the copyright holders of this library give you
+permission to link this library with independent modules to produce an
+executable, regardless of the license terms of these independent
+modules, and to copy and distribute the resulting executable under
+terms of your choice, provided that you also meet, for each linked
+independent module, the terms and conditions of the license of that
+module.  An independent module is a module which is not derived from
+or based on this library.  If you modify this library, you may extend
+this exception to your version of the library, but you are not
+obligated to do so.  If you do not wish to do so, delete this
+exception statement from your version. */
+
+
+package gnu.java.awt.java2d;
+
+import java.awt.AWTError;
+import java.awt.AlphaComposite;
+import java.awt.CompositeContext;
+import java.awt.image.ColorModel;
+import java.awt.image.Raster;
+import java.awt.image.WritableRaster;
+
+/**
+ * A CompositeContext implementation for {@link AlphaComposite}.
+ *
+ * @author Roman Kennke (kennke@aicas.com)
+ */
+public class AlphaCompositeContext
+  implements CompositeContext
+{
+
+  /**
+   * The Composite object for which we perform compositing.
+   */
+  private AlphaComposite composite;
+
+  /**
+   * The source color model.
+   */
+  private ColorModel srcColorModel;
+
+  /**
+   * The destination color model.
+   */
+  private ColorModel dstColorModel;
+
+  /**
+   * The blending factor for the source.
+   */
+  private float fs;
+
+  /**
+   * The blending factor for the destination.
+   */
+  private float fd;
+
+  /**
+   * Creates a new AlphaCompositeContext.
+   *
+   * @param aComp the AlphaComposite object
+   * @param srcCM the source color model
+   * @param dstCM the destination color model
+   */
+  public AlphaCompositeContext(AlphaComposite aComp, ColorModel srcCM,
+                               ColorModel dstCM)
+  {
+    composite = aComp;
+    srcColorModel = srcCM;
+    dstColorModel = dstCM;
+
+
+    // Determine the blending factors according to the rule in the
+    // AlphaComposite. For some rules the factors must be determined
+    // dynamically because they depend on the actual pixel value.
+    switch (composite.getRule())
+    {
+      case AlphaComposite.CLEAR:
+        fs = 0.F;
+        fd= 0.F;
+        break;
+      case AlphaComposite.DST:
+        fs = 0.F;
+        fd= 1.F;
+        break;
+      case AlphaComposite.DST_ATOP:
+        fs = 1.F; // Determined later as 1 - alpha_dst;
+        fd = 1.F; // Determined later as alpha_src;
+        break;
+      case AlphaComposite.DST_IN:
+        fs = 0.F;
+        fd = 0.F; // Determined later as alpha_src;
+        break;
+      case AlphaComposite.DST_OUT:
+        fs = 0.F;
+        fd = 0.F; // Determined later as 1 - alpha_src;
+        break;
+      case AlphaComposite.DST_OVER:
+        fs = 1.F; // Determined later as 1 - alpha_dst.
+        fd= 1.F;
+        break;
+      case AlphaComposite.SRC:
+        fs = 1.F;
+        fd= 0.F;
+        break;
+      case AlphaComposite.SRC_ATOP:
+        fs = 1.F; // Determined later as alpha_dst;
+        fd = 1.F; // Determined later as 1 - alpha_src;
+        break;
+      case AlphaComposite.SRC_IN:
+        fs = 0.F; // Determined later as alpha_dst;
+        fd = 0.F;
+        break;
+      case AlphaComposite.SRC_OUT:
+        fs = 0.F; // Determined later as 1 - alpha_dst;
+        fd = 0.F;
+        break;
+      case AlphaComposite.SRC_OVER:
+        fs = 1.F;
+        fd= 1.F; // Determined later as 1 - alpha_src.
+        break;
+      case AlphaComposite.XOR:
+        fs = 1.F; // Determined later as 1 - alpha_dst.
+        fd= 1.F; // Determined later as 1 - alpha_src.
+        break;
+      default:
+        throw new AWTError("Illegal AlphaComposite rule");
+    }
+
+  }
+
+  /**
+   * Releases all resources held by this composite object.
+   */
+  public void dispose()
+  {
+    // Nothing to do here yet.
+  }
+
+  /**
+   * Performs compositing according to the rules specified in the
+   * AlphaComposite from the constructor.
+   */
+  public void compose(Raster src, Raster dstIn, WritableRaster dstOut)
+  {
+
+    // TODO: This implementation is very general and highly inefficient. There
+    // are two possible ways to optimize this:
+    // 1. Special cased implementations for common ColorModels and transfer
+    //    types.
+    // 2. Native implementation.
+
+    int x0 = src.getMinX();
+    int y0 = src.getMinY();
+    int width = src.getWidth();
+    int height = src.getHeight();
+    int x1 = x0 + width;
+    int y1 = y0 + height;
+
+    Object srcPixel = null;
+    Object dstPixel = null;
+
+    // Prepare the array that holds the color and alpha components of the
+    // source pixels.
+    float[] srcComponents;
+    int srcComponentsLength = srcColorModel.getNumComponents();
+    if (! srcColorModel.hasAlpha())
+      srcComponentsLength += 1;
+    srcComponents = new float[srcComponentsLength];
+
+    // Prepare the array that holds the color and alpha components of the
+    // destination pixels.
+    float[] dstComponents;
+    int dstComponentsLength = dstColorModel.getNumComponents();
+    if (! dstColorModel.hasAlpha())
+      dstComponentsLength += 1;
+    dstComponents = new float[dstComponentsLength];
+
+    if (srcComponentsLength != dstComponentsLength)
+      throw new AWTError("The color models of the source and destination have"
+                         + "incompatible number of color components");
+
+    int srcTransferType = srcColorModel.getTransferType();
+    int dstTransferType = dstColorModel.getTransferType();
+
+    for (int y = y0; y < y1; y++)
+      {
+        for (int x = x0; x < x1; x++)
+          {
+            // Fetch source pixel.
+            srcPixel = src.getDataElements(x, y, (int[]) srcPixel);
+            // Fetch destination pixel.
+            dstPixel = dstIn.getDataElements(x, y, dstPixel);
+            // Get normalized components. This is the only type that is
+            // guaranteed to be supported by all ColorModels.
+            srcComponents =
+              srcColorModel.getNormalizedComponents(srcPixel, srcComponents, 0);
+            if (! srcColorModel.hasAlpha())
+              srcComponents[srcComponentsLength - 1] = 1.0F;
+            dstComponents =
+              dstColorModel.getNormalizedComponents(dstPixel, dstComponents, 0);
+            if (! dstColorModel.hasAlpha())
+              dstComponents[dstComponentsLength - 1] = 1.0F;
+
+            // Prepare the input.
+            float compositeAlpha = composite.getAlpha();
+            srcComponents[srcComponentsLength - 1] *= compositeAlpha;
+            if (srcColorModel.isAlphaPremultiplied())
+              {
+                for (int i = srcComponentsLength - 2; i >= 0; i--)
+                  srcComponents[i] *= compositeAlpha;
+              }
+            else
+              {
+                for (int i = srcComponentsLength - 2; i >= 0; i--)
+                  srcComponents[i] *= srcComponents[srcComponentsLength - 1];
+              }
+            if (! dstColorModel.isAlphaPremultiplied())
+              {
+                for (int i = dstComponentsLength - 2; i >= 0; i--)
+                  dstComponents[i] *= dstComponents[dstComponents.length - 1];
+              }
+
+            // Determine the blending factors according to the rule in the
+            // AlphaComposite. For some rules the factors must be determined
+            // dynamically because they depend on the actual pixel value.
+            float srcAlpha = srcComponents[srcComponentsLength - 1];
+            float dstAlpha = dstComponents[dstComponentsLength - 1];
+            switch (composite.getRule())
+            {
+              case AlphaComposite.DST_ATOP:
+                fs = 1.F - dstAlpha;
+                fd = srcAlpha;
+                break;
+              case AlphaComposite.DST_IN:
+                fd = srcAlpha;
+                break;
+              case AlphaComposite.DST_OUT:
+                fd = 1.F - srcAlpha;
+                break;
+              case AlphaComposite.DST_OVER:
+                fs = 1.F - dstAlpha;
+                break;
+              case AlphaComposite.SRC_ATOP:
+                fs = srcAlpha;
+                fd = 1.F - srcAlpha;
+                break;
+              case AlphaComposite.SRC_IN:
+                fs = dstAlpha;
+                break;
+              case AlphaComposite.SRC_OUT:
+                fs = 1.F - dstAlpha;
+                break;
+              case AlphaComposite.SRC_OVER:
+                fd= 1.F - srcAlpha;
+                break;
+              case AlphaComposite.XOR:
+                fs = 1.F - dstAlpha;
+                fd= 1.F - srcAlpha;
+                break;
+              default:
+                // For the other cases the factors have already been determined
+                // in the constructor.
+            }
+
+            // Apply the blending equation to the pixels.
+            for (int i = 0; i < srcComponentsLength; i++)
+              {
+                dstComponents[i] = srcComponents[i] * fs
+                                   + dstComponents[i] * fd;
+              }
+
+            // Convert the result back when the destination is not
+            // alpha-premultiplied.
+            dstAlpha = dstComponents[dstComponentsLength - 1];
+            if (!dstColorModel.isAlphaPremultiplied() && dstAlpha != 0.F)
+              {
+                for (int i = 0; i < dstComponentsLength - 1; i++)
+                  {
+                    dstComponents[i] = dstComponents[i] / dstAlpha;
+                  }
+              }
+
+            // Store the result in the destination raster.
+            dstPixel = dstColorModel.getDataElements(dstComponents, 0,
+                                                     dstPixel);
+            dstOut.setDataElements(x, y, dstPixel);
+          } // End X loop.
+      } // End Y loop.
+  }
+
+}
diff --git a/libjava/classpath/gnu/java/awt/java2d/CubicSegment.java b/libjava/classpath/gnu/java/awt/java2d/CubicSegment.java
new file mode 100644
index 000000000..8197c94c5
--- /dev/null
+++ b/libjava/classpath/gnu/java/awt/java2d/CubicSegment.java
@@ -0,0 +1,184 @@
+/* CubicSegment.java -- Cubic segment used for BasicStroke
+   Copyright (C) 2006 Free Software Foundation, Inc.
+
+This file is part of GNU Classpath.
+
+GNU Classpath is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2, or (at your option)
+any later version.
+
+GNU Classpath is distributed in the hope that it will be useful, but
+WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with GNU Classpath; see the file COPYING.  If not, write to the
+Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
+02110-1301 USA.
+
+Linking this library statically or dynamically with other modules is
+making a combined work based on this library.  Thus, the terms and
+conditions of the GNU General Public License cover the whole
+combination.
+
+As a special exception, the copyright holders of this library give you
+permission to link this library with independent modules to produce an
+executable, regardless of the license terms of these independent
+modules, and to copy and distribute the resulting executable under
+terms of your choice, provided that you also meet, for each linked
+independent module, the terms and conditions of the license of that
+module.  An independent module is a module which is not derived from
+or based on this library.  If you modify this library, you may extend
+this exception to your version of the library, but you are not
+obligated to do so.  If you do not wish to do so, delete this
+exception statement from your version. */
+
+
+package gnu.java.awt.java2d;
+
+
+import java.awt.geom.CubicCurve2D;
+import java.awt.geom.Point2D;
+
+/**
+ * Cubic Bezier curve segment
+ */
+public class CubicSegment extends Segment
+{
+  public Point2D cp1; // control points
+  public Point2D cp2; // control points
+
+  /**
+   * Constructor - takes coordinates of the starting point,
+   * first control point, second control point and end point,
+   * respecively.
+   */
+  public CubicSegment(double x1, double y1, double c1x, double c1y,
+                      double c2x, double c2y, double x2, double y2)
+  {
+    super();
+    P1 = new Point2D.Double(x1, y1);
+    P2 = new Point2D.Double(x2, y2);
+    cp1 = new Point2D.Double(c1x, c1y);
+    cp2 = new Point2D.Double(c2x, c2y);
+  }
+
+  public CubicSegment(Point2D p1, Point2D cp1, Point2D cp2, Point2D p2)
+  {
+    super();
+    P1 = p1;
+    P2 = p2;
+    this.cp1 = cp1;
+    this.cp2 = cp2;
+  }
+
+  /**
+   * Clones this segment
+   */
+  public Object clone()
+  {
+    CubicSegment segment = null;
+
+    try
+      {
+        segment = (CubicSegment) super.clone();
+
+        segment.P1 = (Point2D) P1.clone();
+        segment.P2 = (Point2D) P2.clone();
+        segment.cp1 = (Point2D) cp1.clone();
+        segment.cp2 = (Point2D) cp2.clone();
+      }
+    catch (CloneNotSupportedException cnse)
+      {
+        InternalError ie = new InternalError();
+        ie.initCause(cnse);
+        throw ie;
+      }
+
+    return segment;
+  }
+
+  /**
+   * Get the "top" and "bottom" segments of this segment. First array element is
+   * p0 + normal, second is p0 - normal.
+   */
+  public Segment[] getDisplacedSegments(double radius)
+  {
+    // It is, apparently, impossible to derive a curve parallel to a bezier
+    // curve (unless it's a straight line), so we have no choice but to
+    // approximate the displaced segments. Similar to FlattenPathIterator.
+
+    Segment segmentTop = null;
+    Segment segmentBottom = null;
+    this.radius = radius;
+
+    CubicCurve2D[] curves = new CubicCurve2D[10];
+    curves[0] = new CubicCurve2D.Double(P1.getX(), P1.getY(), cp1.getX(),
+                                        cp1.getY(), cp2.getX(), cp2.getY(),
+                                        P2.getX(), P2.getY());
+    int numCurves = 1;
+
+    // Hard-coded a recursion limit of 10 and flatness of 1... should we make
+    // this an option somewhere?
+    while (numCurves > 0)
+      {
+        // The curve is flat enough, or we've reached our recursion limit,
+        // so take the current start/end points and add it as a line segment
+        // to our final approximated curves
+        if (curves[numCurves - 1].getFlatnessSq() <= (radius / 3) || numCurves == 10)
+          {
+            Segment[] displaced = new LineSegment(
+                                                  curves[numCurves - 1].getP1(),
+                                                  curves[numCurves - 1].getP2()).getDisplacedSegments(radius);
+            if (segmentTop == null)
+              {
+                segmentTop = displaced[0];
+                segmentBottom = displaced[1];
+              }
+            else
+              {
+                segmentTop.add(displaced[0]);
+                segmentBottom.add(displaced[1]);
+              }
+            numCurves--;
+          }
+
+        // Otherwise, subdivide again and continue
+        else
+          {
+            CubicCurve2D left = new CubicCurve2D.Double();
+            CubicCurve2D right = new CubicCurve2D.Double();
+            curves[numCurves - 1].subdivide(left, right);
+            curves[numCurves - 1] = right;
+            curves[numCurves] = left;
+            curves[numCurves - 1] = right;
+            curves[numCurves] = left;
+            numCurves++;
+          }
+      }
+
+    return new Segment[] { segmentTop, segmentBottom };
+  }
+
+  public void reverse()
+  {
+    Point2D temp = P1;
+    P1 = P2;
+    P2 = temp;
+    temp = cp1;
+    cp1 = cp2;
+    cp2 = temp;
+  }
+
+  public double[] cp1()
+  {
+    return new double[]{cp1.getX(), cp1.getY()};
+  }
+
+  public double[] cp2()
+  {
+    return new double[]{cp2.getX(), cp2.getY()};
+  }
+} // class CubicSegment
diff --git a/libjava/classpath/gnu/java/awt/java2d/ImagePaint.java b/libjava/classpath/gnu/java/awt/java2d/ImagePaint.java
new file mode 100644
index 000000000..7e5fb5638
--- /dev/null
+++ b/libjava/classpath/gnu/java/awt/java2d/ImagePaint.java
@@ -0,0 +1,192 @@
+/* ImagePaint.java -- Supplies the pixels for image rendering
+   Copyright (C) 2006 Free Software Foundation, Inc.
+
+This file is part of GNU Classpath.
+
+GNU Classpath is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2, or (at your option)
+any later version.
+
+GNU Classpath is distributed in the hope that it will be useful, but
+WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with GNU Classpath; see the file COPYING.  If not, write to the
+Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
+02110-1301 USA.
+
+Linking this library statically or dynamically with other modules is
+making a combined work based on this library.  Thus, the terms and
+conditions of the GNU General Public License cover the whole
+combination.
+
+As a special exception, the copyright holders of this library give you
+permission to link this library with independent modules to produce an
+executable, regardless of the license terms of these independent
+modules, and to copy and distribute the resulting executable under
+terms of your choice, provided that you also meet, for each linked
+independent module, the terms and conditions of the license of that
+module.  An independent module is a module which is not derived from
+or based on this library.  If you modify this library, you may extend
+this exception to your version of the library, but you are not
+obligated to do so.  If you do not wish to do so, delete this
+exception statement from your version. */
+
+
+package gnu.java.awt.java2d;
+
+import java.awt.Paint;
+import java.awt.PaintContext;
+import java.awt.Rectangle;
+import java.awt.RenderingHints;
+import java.awt.Transparency;
+import java.awt.geom.AffineTransform;
+import java.awt.geom.Rectangle2D;
+import java.awt.image.ColorModel;
+import java.awt.image.Raster;
+import java.awt.image.RenderedImage;
+import java.awt.image.WritableRaster;
+
+/**
+ * This class is used as a temporary Paint object to supply the pixel values
+ * for image rendering using the normal scanline conversion implementation.
+ *
+ * @author Roman Kennke (kennke@aicas.com)
+ */
+public class ImagePaint
+  implements Paint
+{
+
+  /**
+   * The PaintContext implementation for the ImagePaint.
+   */
+  private class ImagePaintContext
+    implements PaintContext
+  {
+
+    /**
+     * The target raster.
+     */
+    private WritableRaster target;
+
+    /**
+     * Nothing to do here.
+     */
+    public void dispose()
+    {
+      // Nothing to do here.
+    }
+
+    /**
+     * Returns the color model.
+     *
+     * @return the color model
+     */
+    public ColorModel getColorModel()
+    {
+      return image.getColorModel();
+    }
+
+    /**
+     * Supplies the pixel to be rendered.
+     *
+     * @see PaintContext#getRaster(int, int, int, int)
+     */
+    public Raster getRaster(int x1, int y1, int w, int h)
+    {
+      ensureRasterSize(w, h);
+      int x2 = x1 + w;
+      int y2 = y1 + h;
+      float[] src = new float[2];
+      float[] dest = new float[2];
+      Raster source = image.getData();
+      int minX = source.getMinX();
+      int maxX = source.getWidth() + minX;
+      int minY = source.getMinY();
+      int maxY = source.getHeight() + minY;
+      Object pixel = null;
+      for (int y = y1; y < y2; y++)
+        {
+          for (int x = x1; x < x2; x++)
+            {
+              src[0] = x;
+              src[1] = y;
+              transform.transform(src, 0, dest, 0, 1);
+              int dx = (int) dest[0];
+              int dy = (int) dest[1];
+              // Pixels outside the source image are not of interest, skip
+              // them.
+              if (dx >= minX && dx < maxX && dy >= minY && dy < maxY)
+                {
+                  pixel = source.getDataElements(dx, dy, pixel);
+                  target.setDataElements(x - x1, y - y1, pixel);
+                }
+            }
+        }
+      return target;
+    }
+
+    /**
+     * Ensures that the target raster exists and has at least the specified
+     * size.
+     *
+     * @param w the requested target width
+     * @param h the requested target height
+     */
+    private void ensureRasterSize(int w, int h)
+    {
+      if (target == null || target.getWidth() < w || target.getHeight() < h)
+        {
+          Raster s = image.getData();
+          target = s.createCompatibleWritableRaster(w, h);
+        }
+    }
+  }
+
+  /**
+   * The image to render.
+   */
+  RenderedImage image;
+
+  /**
+   * The transform from image space to device space. This is the inversed
+   * transform of the concatenated
+   * transform image space -> user space -> device space transform.
+   */
+  AffineTransform transform;
+
+  /**
+   * Creates a new ImagePaint for rendering the specified image using the
+   * specified device space -> image space transform. This transform
+   * is the inversed transform of the usual image space -> user space -> device
+   * space transform.
+   *
+   * The ImagePaint will only render the image in the specified area of
+   * interest (which is specified in image space).
+   *
+   * @param i the image to render
+   * @param t the device space to user space transform
+   */
+  ImagePaint(RenderedImage i, AffineTransform t)
+  {
+    image = i;
+    transform = t;
+  }
+
+  public PaintContext createContext(ColorModel cm, Rectangle deviceBounds,
+                                    Rectangle2D userBounds,
+                                    AffineTransform xform,
+                                    RenderingHints hints)
+  {
+    return new ImagePaintContext();
+  }
+
+  public int getTransparency()
+  {
+    return Transparency.OPAQUE;
+  }
+
+}
diff --git a/libjava/classpath/gnu/java/awt/java2d/LineSegment.java b/libjava/classpath/gnu/java/awt/java2d/LineSegment.java
new file mode 100644
index 000000000..904037989
--- /dev/null
+++ b/libjava/classpath/gnu/java/awt/java2d/LineSegment.java
@@ -0,0 +1,118 @@
+/* LineSegment.java -- Line segment used for BasicStroke
+   Copyright (C) 2006 Free Software Foundation, Inc.
+
+This file is part of GNU Classpath.
+
+GNU Classpath is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2, or (at your option)
+any later version.
+
+GNU Classpath is distributed in the hope that it will be useful, but
+WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with GNU Classpath; see the file COPYING.  If not, write to the
+Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
+02110-1301 USA.
+
+Linking this library statically or dynamically with other modules is
+making a combined work based on this library.  Thus, the terms and
+conditions of the GNU General Public License cover the whole
+combination.
+
+As a special exception, the copyright holders of this library give you
+permission to link this library with independent modules to produce an
+executable, regardless of the license terms of these independent
+modules, and to copy and distribute the resulting executable under
+terms of your choice, provided that you also meet, for each linked
+independent module, the terms and conditions of the license of that
+module.  An independent module is a module which is not derived from
+or based on this library.  If you modify this library, you may extend
+this exception to your version of the library, but you are not
+obligated to do so.  If you do not wish to do so, delete this
+exception statement from your version. */
+
+
+package gnu.java.awt.java2d;
+
+
+import java.awt.geom.Point2D;
+
+public class LineSegment extends Segment
+{
+  public LineSegment(double x1, double y1, double x2, double y2)
+  {
+    super();
+    P1 = new Point2D.Double(x1, y1);
+    P2 = new Point2D.Double(x2, y2);
+  }
+
+  public LineSegment(Point2D p1, Point2D p2)
+  {
+    super();
+    P1 = (Point2D) p1.clone();
+    P2 = (Point2D) p2.clone();
+  }
+
+  /**
+   * Clones this segment
+   */
+  public Object clone()
+  {
+    LineSegment segment = null;
+
+    try
+      {
+        segment = (LineSegment) super.clone();
+        segment.P1 = (Point2D) P1.clone();
+        segment.P2 = (Point2D) P2.clone();
+      }
+    catch (CloneNotSupportedException cnse)
+      {
+        InternalError ie = new InternalError();
+        ie.initCause(cnse);
+        throw ie;
+      }
+
+    return segment;
+  }
+
+  /**
+   * Get the "top" and "bottom" segments of this segment.
+   * First array element is p0 + normal, second is p0 - normal.
+   */
+  public Segment[] getDisplacedSegments(double radius)
+  {
+    this.radius = radius;
+    double x0 = P1.getX();
+    double y0 = P1.getY();
+    double x1 = P2.getX();
+    double y1 = P2.getY();
+    double[] p = normal(x0, y0, x1, y1);
+    Segment s1 = (new LineSegment(x0 + p[0], y0 + p[1],
+                                  x1 + p[0], y1 + p[1] ));
+    Segment s2 = (new LineSegment(x0 - p[0], y0 - p[1],
+                                  x1 - p[0], y1 - p[1] ));
+    return new Segment[]{s1, s2};
+  }
+
+  public void reverse()
+  {
+    Point2D p = P1;
+    P1 = P2;
+    P2 = p;
+  }
+
+  public double[] cp1()
+  {
+    return new double[]{P2.getX(), P2.getY()};
+  }
+
+  public double[] cp2()
+  {
+    return new double[]{P1.getX(), P1.getY()};
+  }
+} // class LineSegment
diff --git a/libjava/classpath/gnu/java/awt/java2d/PixelCoverage.java b/libjava/classpath/gnu/java/awt/java2d/PixelCoverage.java
new file mode 100644
index 000000000..356021b3d
--- /dev/null
+++ b/libjava/classpath/gnu/java/awt/java2d/PixelCoverage.java
@@ -0,0 +1,132 @@
+package gnu.java.awt.java2d;
+
+/**
+ * Stores and handles the pixel converage for a scanline. The pixel coverage
+ * is stored as sorted list of buckets, each of which holds information about
+ * the coverage for the X and Y axis. This is utilized to compute the actual
+ * coverage for each pixel on the scanline and finding chunks of pixels with
+ * equal coverage.
+ */
+final class PixelCoverage
+{
+
+  /**
+   * One bucket in the list.
+   */
+  private static final class Bucket
+  {
+    /**
+     * The X coordinate on the scanline to which this bucket belongs.
+     */
+    int xPos;
+
+    /**
+     * The X coverage.
+     */
+    int xCov;
+
+    /**
+     * The Y coverage.
+     */
+    int yCov;
+
+    /**
+     * Implements a linked list. This points to the next element of the list.
+     */
+    Bucket next;
+
+    /**
+     * Implements a linked list. This points to the previous element of the
+     * list.
+     */
+    Bucket prev;
+  }
+
+  /**
+   * The head of the sorted list of buckets.
+   */
+  private Bucket head;
+
+  /**
+   * The current bucket. We make use of the fact that the scanline converter
+   * always scans the scanline (and thus this list) from left to right to
+   * quickly find buckets or insertion points.
+   */
+  private Bucket current;
+
+  /**
+   * The bucket after the last valid bucket. Unused buckets are not thrown
+   * away and garbage collected. Instead, we keep them at the tail of the list
+   * and reuse them when necessary.
+   */
+  private Bucket last;
+
+  /**
+   * Indicates the the next scan of the scanline begins and that the next
+   * request will be at the beginning of this list. This makes searching and
+   * sorting of this list very quick.
+   */
+  void rewind()
+  {
+    current = head;
+  }
+
+  /**
+   * Clears the list. This does not throw away the old buckets but only
+   * resets the end-pointer of the list to the first element. All buckets are
+   * then unused and are reused when the list is filled again.
+   */
+  void clear()
+  {
+    last = head;
+  }
+
+  /**
+   * This adds the specified x and y coverage to the pixel at the specified
+   * X position.
+   *
+   * @param x the X position
+   * @param xc the x coverage
+   * @param yc the y coverage
+   */
+  void add(int x, int xc, int yc)
+  {
+    Bucket bucket = findOrInsert(x);
+    bucket.xCov += xc;
+    bucket.yCov += yc;
+  }
+
+  /**
+   * Finds the bucket in the list with the specified X coordinate.
+   * If no such bucket is found, then a new one is fetched (either a cached
+   * bucket from the end of the list or a newly allocated one) inserted at the
+   * correct position and returned.
+   *
+   * @param x the X coordinate
+   *
+   * @return a bucket to hold the coverage data
+   */
+  private Bucket findOrInsert(int x)
+  {
+    // First search for a matching bucket.
+    if (head == null)
+      {
+        // Special case: the list is still empty.
+        head = new Bucket();
+        current = head;
+        return head;
+      }
+
+    // This performs a linear search, starting from the current bucket.
+    // This is reasonably efficient because access to this list is always done
+    // in a linear fashion and we are not more then 1 or 2 buckets away from
+    // the one we're looking for.
+    Bucket match = current;
+    while (match != null && match.xPos != x)
+      {
+
+      }
+
+    return match;
+  }
+}
diff --git a/libjava/classpath/gnu/java/awt/java2d/Pixelizer.java b/libjava/classpath/gnu/java/awt/java2d/Pixelizer.java
new file mode 100644
index 000000000..43e53bf63
--- /dev/null
+++ b/libjava/classpath/gnu/java/awt/java2d/Pixelizer.java
@@ -0,0 +1,56 @@
+/* Pixelizer.java -- Interface for the target of the rasterizer
+   Copyright (C) 2007 Free Software Foundation, Inc.
+
+This file is part of GNU Classpath.
+
+GNU Classpath is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2, or (at your option)
+any later version.
+
+GNU Classpath is distributed in the hope that it will be useful, but
+WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with GNU Classpath; see the file COPYING.  If not, write to the
+Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
+02110-1301 USA.
+
+Linking this library statically or dynamically with other modules is
+making a combined work based on this library.  Thus, the terms and
+conditions of the GNU General Public License cover the whole
+combination.
+
+As a special exception, the copyright holders of this library give you
+permission to link this library with independent modules to produce an
+executable, regardless of the license terms of these independent
+modules, and to copy and distribute the resulting executable under
+terms of your choice, provided that you also meet, for each linked
+independent module, the terms and conditions of the license of that
+module.  An independent module is a module which is not derived from
+or based on this library.  If you modify this library, you may extend
+this exception to your version of the library, but you are not
+obligated to do so.  If you do not wish to do so, delete this
+exception statement from your version. */
+
+package gnu.java.awt.java2d;
+
+/**
+ * A pixelizer is responsible for actually manipulating the pixel of a drawing
+ * surface after the scanline conversion process. It receives coverage
+ * information for a scanline and adjusts the surface pixels accordingly.
+ */
+public interface Pixelizer
+{
+
+  /**
+   * Renders the pixel for one scanline at the Y location <code>y</code>
+   * and using the coverage information in <code>sc</code>.
+   *
+   * @param y the scanline Y coordinate
+   * @param sc the coverage information
+   */
+  void renderScanline(int y, ScanlineCoverage sc);
+}
diff --git a/libjava/classpath/gnu/java/awt/java2d/PolyEdge.java b/libjava/classpath/gnu/java/awt/java2d/PolyEdge.java
new file mode 100644
index 000000000..eb0cc7f8f
--- /dev/null
+++ b/libjava/classpath/gnu/java/awt/java2d/PolyEdge.java
@@ -0,0 +1,171 @@
+/* PolyEdge.java -- An edge in a polygon, used for polygon filling
+   Copyright (C) 2006 Free Software Foundation, Inc.
+
+This file is part of GNU Classpath.
+
+GNU Classpath is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2, or (at your option)
+any later version.
+
+GNU Classpath is distributed in the hope that it will be useful, but
+WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with GNU Classpath; see the file COPYING.  If not, write to the
+Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
+02110-1301 USA.
+
+Linking this library statically or dynamically with other modules is
+making a combined work based on this library.  Thus, the terms and
+conditions of the GNU General Public License cover the whole
+combination.
+
+As a special exception, the copyright holders of this library give you
+permission to link this library with independent modules to produce an
+executable, regardless of the license terms of these independent
+modules, and to copy and distribute the resulting executable under
+terms of your choice, provided that you also meet, for each linked
+independent module, the terms and conditions of the license of that
+module.  An independent module is a module which is not derived from
+or based on this library.  If you modify this library, you may extend
+this exception to your version of the library, but you are not
+obligated to do so.  If you do not wish to do so, delete this
+exception statement from your version. */
+
+
+package gnu.java.awt.java2d;
+
+import gnu.java.math.Fixed;
+
+/**
+ * An edge in a polygon.
+ *
+ * @author Roman Kennke (kennke@aicas.com)
+ */
+final class PolyEdge
+  implements Comparable
+{
+
+  /**
+   * The start and end coordinates of the edge. y0 is always smaller or equal
+   * than y1.
+   *
+   * These values are stored as fixed-point decimals.
+   */
+  public int x0, y0, x1, y1;
+
+  /**
+   * The slope of the edge. This is dx / dy.
+   *
+   * This is a fixed point decimal.
+   */
+  private int slope;
+
+  /**
+   * The intersection of this edge with the current scanline.
+   *
+   * This is a fixed point decimal.
+   */
+  int xIntersection;
+
+  /**
+   * Indicates whether this edge is from the clip or from the target shape.
+   */
+  boolean isClip;
+
+  /**
+   * Implements a linked list for the edge pool.
+   */
+  PolyEdge poolNext;
+
+  /**
+   * Implements a linked list for the scanline edge lists.
+   */
+  PolyEdge scanlineNext;
+
+  /**
+   * Create an uninitialized edge.
+   */
+  PolyEdge()
+  {
+    // Nothing to do here.
+  }
+
+  /**
+   * Creates a new PolyEdge with the specified coordinates.
+   *
+   * @param x0 the starting point, x coordinate
+   * @param y0 the starting point, y coordinate
+   * @param x1 the end point, x coordinate
+   * @param y1 the end point, y coordinate
+   */
+  PolyEdge(int n, int x0, int y0, int x1, int y1, boolean clip)
+  {
+    init(n, x0, y0, x1, y1, clip);
+  }
+
+  /**
+   * (Re-) Initializes this edge.
+   *
+   * @param x0
+   * @param y0
+   * @param x1
+   * @param y1
+   */
+  void init(int n, int x0, int y0, int x1, int y1, boolean clip)
+  {
+    isClip = clip;
+    if (y0 < y1)
+      {
+        this.x0 = x0;
+        this.y0 = y0;
+        this.x1 = x1;
+        this.y1 = y1;
+      }
+    else
+      {
+        this.x0 = x1;
+        this.y0 = y1;
+        this.x1 = x0;
+        this.y1 = y0;
+      }
+    slope = Fixed.div(n, this.x1 - this.x0, this.y1 - this.y0);
+  }
+
+  /**
+   * Sorts PolyEdges by the x coordinate from the minimum x value.
+   */
+  public int compareTo(Object o)
+  {
+    PolyEdge other = (PolyEdge) o;
+    int comp = 0;
+    if (x0 < other.x0)
+      comp = -1;
+    else if (x0 > other.x0)
+      comp = 1;
+    return comp;
+  }
+
+  /**
+   * Intersects this edge with the scanline at height y. The result is
+   * stored in {@link #xIntersection}.
+   *
+   * @param y the scanline
+   */
+  void intersect(int n, int y)
+  {
+    int dy = y - y0;
+    int dx = Fixed.mul(n, slope, dy);
+    xIntersection = x0 + dx;
+  }
+
+  public String toString()
+  {
+    return "Edge: " + x0 + ", " + y0 + ", " + x1 + ", " + y1 + ", slope: "
+           + slope + ", xIntersection: " + xIntersection
+           + ", isClip: " + isClip;
+  }
+}
diff --git a/libjava/classpath/gnu/java/awt/java2d/PolyEdgeComparator.java b/libjava/classpath/gnu/java/awt/java2d/PolyEdgeComparator.java
new file mode 100644
index 000000000..6706f2294
--- /dev/null
+++ b/libjava/classpath/gnu/java/awt/java2d/PolyEdgeComparator.java
@@ -0,0 +1,70 @@
+/* PolyEdgeComparator.java -- Sorts PolyEdges by their current intersection
+                              points
+   Copyright (C) 2006 Free Software Foundation, Inc.
+
+This file is part of GNU Classpath.
+
+GNU Classpath is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2, or (at your option)
+any later version.
+
+GNU Classpath is distributed in the hope that it will be useful, but
+WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with GNU Classpath; see the file COPYING.  If not, write to the
+Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
+02110-1301 USA.
+
+Linking this library statically or dynamically with other modules is
+making a combined work based on this library.  Thus, the terms and
+conditions of the GNU General Public License cover the whole
+combination.
+
+As a special exception, the copyright holders of this library give you
+permission to link this library with independent modules to produce an
+executable, regardless of the license terms of these independent
+modules, and to copy and distribute the resulting executable under
+terms of your choice, provided that you also meet, for each linked
+independent module, the terms and conditions of the license of that
+module.  An independent module is a module which is not derived from
+or based on this library.  If you modify this library, you may extend
+this exception to your version of the library, but you are not
+obligated to do so.  If you do not wish to do so, delete this
+exception statement from your version. */
+
+
+package gnu.java.awt.java2d;
+
+import java.util.Comparator;
+
+/**
+ * Sorts {@link PolyEdge}s by their current intersection points.
+ *
+ * @author Roman Kennke (kennke@aicas.com)
+ */
+public class PolyEdgeComparator
+    implements Comparator
+{
+
+  /**
+   * The current scanline.
+   */
+  int y;
+
+  public int compare(Object o1, Object o2)
+  {
+    PolyEdge edge1 = (PolyEdge) o1;
+    PolyEdge edge2 = (PolyEdge) o2;
+    int comp = 0;
+    if (edge1.xIntersection < edge2.xIntersection)
+      comp = -1;
+    else if (edge1.xIntersection > edge2.xIntersection)
+      comp = 1;
+    return comp;
+  }
+
+}
diff --git a/libjava/classpath/gnu/java/awt/java2d/QuadSegment.java b/libjava/classpath/gnu/java/awt/java2d/QuadSegment.java
new file mode 100644
index 000000000..b8d0ff52e
--- /dev/null
+++ b/libjava/classpath/gnu/java/awt/java2d/QuadSegment.java
@@ -0,0 +1,260 @@
+/* QuadSegment.java -- QuadCurve segment used for BasicStroke
+   Copyright (C) 2006 Free Software Foundation, Inc.
+
+This file is part of GNU Classpath.
+
+GNU Classpath is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2, or (at your option)
+any later version.
+
+GNU Classpath is distributed in the hope that it will be useful, but
+WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with GNU Classpath; see the file COPYING.  If not, write to the
+Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
+02110-1301 USA.
+
+Linking this library statically or dynamically with other modules is
+making a combined work based on this library.  Thus, the terms and
+conditions of the GNU General Public License cover the whole
+combination.
+
+As a special exception, the copyright holders of this library give you
+permission to link this library with independent modules to produce an
+executable, regardless of the license terms of these independent
+modules, and to copy and distribute the resulting executable under
+terms of your choice, provided that you also meet, for each linked
+independent module, the terms and conditions of the license of that
+module.  An independent module is a module which is not derived from
+or based on this library.  If you modify this library, you may extend
+this exception to your version of the library, but you are not
+obligated to do so.  If you do not wish to do so, delete this
+exception statement from your version. */
+
+
+package gnu.java.awt.java2d;
+
+
+import java.awt.geom.Point2D;
+import java.awt.geom.QuadCurve2D;
+
+/**
+ * Quadratic Bezier curve segment
+ *
+ * Note: Most peers don't support quadratics directly, so it might make
+ * sense to represent them as cubics internally and just be done with it.
+ * I think we should be peer-agnostic, however, and stay faithful to the
+ * input geometry types as far as possible.
+ */
+public class QuadSegment extends Segment
+{
+  public Point2D cp; // control point
+
+  /**
+   * Constructor, takes the coordinates of the start, control,
+   * and end point, respectively.
+   */
+  public QuadSegment(double x1, double y1, double cx, double cy, double x2,
+                     double y2)
+  {
+    super();
+    P1 = new Point2D.Double(x1, y1);
+    P2 = new Point2D.Double(x2, y2);
+    cp = new Point2D.Double(cx, cy);
+  }
+
+  public QuadSegment(Point2D p1, Point2D cp, Point2D p2)
+  {
+    super();
+    P1 = p1;
+    P2 = p2;
+    this.cp = cp;
+  }
+
+  public QuadSegment(QuadCurve2D curve)
+  {
+    super();
+    P1 = curve.getP1();
+    P2 = curve.getP2();
+    this.cp = curve.getCtrlPt();
+  }
+
+  /**
+   * Clones this segment
+   */
+  public Object clone()
+  {
+    QuadSegment segment = null;
+
+    try
+      {
+        segment = (QuadSegment) super.clone();
+
+        segment.P1 = (Point2D) P1.clone();
+        segment.P2 = (Point2D) P2.clone();
+        segment.cp = (Point2D) cp.clone();
+      }
+    catch (CloneNotSupportedException cnse)
+      {
+        InternalError ie = new InternalError();
+        ie.initCause(cnse);
+        throw ie;
+      }
+
+    return segment;
+  }
+
+  /**
+   * Get the "top" and "bottom" segments of a given segment.
+   * First array element is p0 + normal, second is p0 - normal.
+   */
+  public Segment[] getDisplacedSegments(double radius)
+  {
+    this.radius = radius;
+    double x0 = P1.getX();
+    double y0 = P1.getY();
+    double x1 = cp.getX();
+    double y1 = cp.getY();
+    double x2 = P2.getX();
+    double y2 = P2.getY();
+
+    QuadCurve2D left = new QuadCurve2D.Double();
+    QuadCurve2D right = new QuadCurve2D.Double();
+    QuadCurve2D orig = new QuadCurve2D.Double(x0, y0, x1, y1, x2, y2);
+    orig.subdivide(left, right);
+
+    QuadSegment s1 = offsetSubdivided(left, true);
+    QuadSegment s2 = offsetSubdivided(left, false);
+
+    s1.add( offsetSubdivided(right, true) );
+    s2.add( offsetSubdivided(right, false) );
+
+    return new Segment[]{s1, s2};
+  }
+
+  private QuadSegment offsetSubdivided(QuadCurve2D curve, boolean plus)
+  {
+    double[] n1 = normal(curve.getX1(), curve.getY1(),
+                         curve.getCtrlX(), curve.getCtrlY());
+    double[] n2 = normal(curve.getCtrlX(), curve.getCtrlY(),
+                         curve.getX2(), curve.getY2());
+
+    Point2D cp;
+    QuadSegment s;
+    if(!plus)
+      {
+        n1[0] = -n1[0];
+        n1[1] = -n1[1];
+        n2[0] = -n2[0];
+        n2[1] = -n2[1];
+      }
+
+    // Handle special cases where the control point is equal to an end point
+    // or end points are equal (ie, straight lines)
+    if (curve.getP1().equals(curve.getCtrlPt()))
+      {
+        cp = curve.getCtrlPt();
+        cp.setLocation(cp.getX() + n2[0], cp.getY() + n2[1]);
+        n1[0] = n2[0];
+        n1[1] = n2[1];
+      }
+    else if (curve.getP2().equals(curve.getCtrlPt()))
+      {
+        cp = curve.getCtrlPt();
+        cp.setLocation(cp.getX() + n1[0], cp.getY() + n1[1]);
+        n2[0] = n1[0];
+        n2[1] = n1[1];
+      }
+    else if (curve.getP1().equals(curve.getP2()))
+      {
+        cp = curve.getCtrlPt();
+
+        double deltaX = curve.getX1() - curve.getCtrlX();
+        double deltaY = curve.getY1() - curve.getCtrlY();
+        double length = Math.sqrt((deltaX * deltaX) + (deltaY * deltaY));
+        double ratio = radius / length;
+        deltaX *= ratio;
+        deltaY *= ratio;
+
+        if (plus)
+          cp.setLocation(cp.getX() + deltaX, cp.getY() + deltaY);
+        else
+          cp.setLocation(cp.getX() - deltaX, cp.getY() - deltaY);
+      }
+    else if (n1[0] == n2[0] && n1[1] == n2[1])
+      {
+        cp = curve.getCtrlPt();
+        cp.setLocation(cp.getX() + n1[0], cp.getY() + n1[1]);
+      }
+    else
+      {
+        cp = lineIntersection(curve.getX1() + n1[0],
+                              curve.getY1() + n1[1],
+                              curve.getCtrlX() + n1[0],
+                              curve.getCtrlY() + n1[1],
+                              curve.getCtrlX() + n2[0],
+                              curve.getCtrlY() + n2[1],
+                              curve.getX2() + n2[0],
+                              curve.getY2() + n2[1], true);
+      }
+
+    s = new QuadSegment(curve.getX1() + n1[0], curve.getY1() + n1[1],
+                        cp.getX(), cp.getY(),
+                        curve.getX2() + n2[0], curve.getY2() + n2[1]);
+
+    return s;
+  }
+
+  private Point2D lineIntersection(double X1, double Y1,
+                                   double X2, double Y2,
+                                   double X3, double Y3,
+                                   double X4, double Y4,
+                                   boolean infinite)
+  {
+    double x1 = X1;
+    double y1 = Y1;
+    double rx = X2 - x1;
+    double ry = Y2 - y1;
+
+    double x2 = X3;
+    double y2 = Y3;
+    double sx = X4 - x2;
+    double sy = Y4 - y2;
+
+    double determinant = sx * ry - sy * rx;
+    double nom = (sx * (y2 - y1) + sy * (x1 - x2));
+
+    // lines can be considered parallel.
+    if (Math.abs(determinant) < 1E-6)
+      return null;
+
+    nom = nom / determinant;
+
+    // check if lines are within the bounds
+    if(!infinite && (nom > 1.0 || nom < 0.0))
+      return null;
+
+    return new Point2D.Double(x1 + nom * rx, y1 + nom * ry);
+  }
+
+  public void reverse()
+  {
+    Point2D p = P1;
+    P1 = P2;
+    P2 = p;
+  }
+
+  public double[] cp1()
+  {
+    return new double[]{cp.getX(), cp.getY()};
+  }
+
+  public double[] cp2()
+  {
+    return new double[]{cp.getX(), cp.getY()};
+  }
+}
diff --git a/libjava/classpath/gnu/java/awt/java2d/RasterGraphics.java b/libjava/classpath/gnu/java/awt/java2d/RasterGraphics.java
new file mode 100644
index 000000000..193ea4c7c
--- /dev/null
+++ b/libjava/classpath/gnu/java/awt/java2d/RasterGraphics.java
@@ -0,0 +1,118 @@
+/* RasterGraphics.java -- A Graphics2D impl for Rasters
+   Copyright (C) 2006 Free Software Foundation, Inc.
+
+This file is part of GNU Classpath.
+
+GNU Classpath is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2, or (at your option)
+any later version.
+
+GNU Classpath is distributed in the hope that it will be useful, but
+WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with GNU Classpath; see the file COPYING.  If not, write to the
+Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
+02110-1301 USA.
+
+Linking this library statically or dynamically with other modules is
+making a combined work based on this library.  Thus, the terms and
+conditions of the GNU General Public License cover the whole
+combination.
+
+As a special exception, the copyright holders of this library give you
+permission to link this library with independent modules to produce an
+executable, regardless of the license terms of these independent
+modules, and to copy and distribute the resulting executable under
+terms of your choice, provided that you also meet, for each linked
+independent module, the terms and conditions of the license of that
+module.  An independent module is a module which is not derived from
+or based on this library.  If you modify this library, you may extend
+this exception to your version of the library, but you are not
+obligated to do so.  If you do not wish to do so, delete this
+exception statement from your version. */
+
+
+package gnu.java.awt.java2d;
+
+import java.awt.GraphicsConfiguration;
+import java.awt.Rectangle;
+import java.awt.image.ColorModel;
+import java.awt.image.WritableRaster;
+
+/**
+ * A Graphics2D implementation that operates on Raster objects. This is
+ * primarily used for BufferedImages, but can theoretically be used on
+ * arbitrary WritableRasters.
+ *
+ * @author Roman Kennke (kennke@aicas.com)
+ */
+public class RasterGraphics
+  extends AbstractGraphics2D
+{
+
+  /**
+   * The raster on which we operate.
+   */
+  private WritableRaster raster;
+
+  /**
+   * The color model of this Graphics instance.
+   */
+  private ColorModel colorModel;
+
+  public RasterGraphics(WritableRaster r, ColorModel cm)
+  {
+    super();
+    raster = r;
+    colorModel = cm;
+    init();
+  }
+
+  @Override
+  public void renderScanline(int y, ScanlineCoverage c)
+  {
+    if (y >= getDeviceBounds().width)
+      return;
+
+    super.renderScanline(y, c);
+  }
+
+  /**
+   * Returns the color model of this Graphics object.
+   *
+   * @return the color model of this Graphics object
+   */
+  protected ColorModel getColorModel()
+  {
+    return colorModel;
+  }
+
+  /**
+   * Returns a WritableRaster that is used by this class to perform the
+   * rendering in. It is not necessary that the target surface immediately
+   * reflects changes in the raster. Updates to the raster are notified via
+   * {@link AbstractGraphics2D#updateRaster}.
+   *
+   * @return the destination raster
+   */
+  protected WritableRaster getDestinationRaster()
+  {
+    return raster;
+  }
+
+  public GraphicsConfiguration getDeviceConfiguration()
+  {
+    // TODO Auto-generated method stub
+    return null;
+  }
+
+  @Override
+  protected Rectangle getDeviceBounds()
+  {
+    return this.raster.getBounds();
+  }
+}
diff --git a/libjava/classpath/gnu/java/awt/java2d/Scanline.java b/libjava/classpath/gnu/java/awt/java2d/Scanline.java
new file mode 100644
index 000000000..24c3d34d5
--- /dev/null
+++ b/libjava/classpath/gnu/java/awt/java2d/Scanline.java
@@ -0,0 +1,91 @@
+/* Scanline.java -- A scanline for the scanline converter
+   Copyright (C) 2006 Free Software Foundation, Inc.
+
+This file is part of GNU Classpath.
+
+GNU Classpath is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2, or (at your option)
+any later version.
+
+GNU Classpath is distributed in the hope that it will be useful, but
+WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with GNU Classpath; see the file COPYING.  If not, write to the
+Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
+02110-1301 USA.
+
+Linking this library statically or dynamically with other modules is
+making a combined work based on this library.  Thus, the terms and
+conditions of the GNU General Public License cover the whole
+combination.
+
+As a special exception, the copyright holders of this library give you
+permission to link this library with independent modules to produce an
+executable, regardless of the license terms of these independent
+modules, and to copy and distribute the resulting executable under
+terms of your choice, provided that you also meet, for each linked
+independent module, the terms and conditions of the license of that
+module.  An independent module is a module which is not derived from
+or based on this library.  If you modify this library, you may extend
+this exception to your version of the library, but you are not
+obligated to do so.  If you do not wish to do so, delete this
+exception statement from your version. */
+
+
+package gnu.java.awt.java2d;
+
+/**
+ * Represents a scanline in the {@link ScanlineConverter}. This is basically
+ * a sorted list of {@link PolyEdge}s that is made for maximum reuse.
+ */
+class Scanline
+{
+
+  /**
+   * The actual edges array. The fields can be null.
+   */
+  private PolyEdge edges;
+
+  /**
+   * Clears this scanline. This only resets the number of edges to 0. The
+   * actual PolyEdge objects are preserved for possible later reuse.
+   */
+  void clear()
+  {
+    edges = null;
+  }
+
+  /**
+   * Create a new Scanline.
+   */
+  Scanline()
+  {
+    // Nothing to do.
+  }
+
+  /**
+   * Inserts an edge into this scanline. This is performed in a sorted fashion,
+   * and so that it reuses as much existing resources as possible.
+   */
+  void addEdge(PolyEdge edge)
+  {
+
+    // Allocate PolyEdge when necessary or reuse an old one.
+    edge.scanlineNext = edges;
+    edges = edge;
+  }
+
+  /**
+   * Returns the edges queue.
+   *
+   * @return the edges queue
+   */
+  PolyEdge getEdges()
+  {
+    return edges;
+  }
+}
diff --git a/libjava/classpath/gnu/java/awt/java2d/ScanlineConverter.java b/libjava/classpath/gnu/java/awt/java2d/ScanlineConverter.java
new file mode 100644
index 000000000..2c3481b6c
--- /dev/null
+++ b/libjava/classpath/gnu/java/awt/java2d/ScanlineConverter.java
@@ -0,0 +1,451 @@
+/* ScanlineConverter.java -- Rasterizes Shapes
+   Copyright (C) 2006, 2007 Free Software Foundation, Inc.
+
+This file is part of GNU Classpath.
+
+GNU Classpath is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2, or (at your option)
+any later version.
+
+GNU Classpath is distributed in the hope that it will be useful, but
+WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with GNU Classpath; see the file COPYING.  If not, write to the
+Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
+02110-1301 USA.
+
+Linking this library statically or dynamically with other modules is
+making a combined work based on this library.  Thus, the terms and
+conditions of the GNU General Public License cover the whole
+combination.
+
+As a special exception, the copyright holders of this library give you
+permission to link this library with independent modules to produce an
+executable, regardless of the license terms of these independent
+modules, and to copy and distribute the resulting executable under
+terms of your choice, provided that you also meet, for each linked
+independent module, the terms and conditions of the license of that
+module.  An independent module is a module which is not derived from
+or based on this library.  If you modify this library, you may extend
+this exception to your version of the library, but you are not
+obligated to do so.  If you do not wish to do so, delete this
+exception statement from your version. */
+
+
+package gnu.java.awt.java2d;
+
+import gnu.java.math.Fixed;
+
+import java.awt.RenderingHints;
+import java.awt.Shape;
+import java.awt.geom.AffineTransform;
+import java.awt.geom.PathIterator;
+
+/**
+ * Rasterizes {@link Shape} objects on an AbstractGraphics2D.
+ */
+public final class ScanlineConverter
+{
+
+  /**
+   * The number of digits to use for fixed point arithmetics.
+   */
+  private static int FIXED_DIGITS = 6;
+
+  /**
+   * The fixed point constant for the number one.
+   */
+  private static int ONE = Fixed.fixedValue(FIXED_DIGITS, 1);
+
+  /**
+   * The actual number of scanlines.
+   */
+  private int numScanlines;
+
+  /**
+   * The number of scanlines. This can contain more elements than we have
+   * scanlines. The real number of scanlines is stored in
+   * {@link #numScanlines}. This can also contain null values for empty
+   * scanlines.
+   */
+  private Scanline[] scanlines;
+
+  /**
+   * The upper bounds which correspond to the index 0 in the scanline array.
+   *
+   * This is a fixed point value.
+   */
+  private int upperBounds;
+
+  /**
+   * The resolution of the scanline converter.
+   *
+   * This is a fixed point value.
+   */
+  private int resolution;
+
+  /**
+   * The number of significant bits for the 'Y' resolution.
+   */
+  private int yResolution;
+
+  /**
+   * One half step according to the resolution. This is stored to avoid
+   * unnecessary operations during rendering.
+   */
+  private int halfStep;
+
+  /**
+   * This is used in {@link #addShape(PathIterator, boolean)} to
+   * receive the coordinates of the path.
+   */
+  private float[] coords;
+
+  /**
+   * The active edges.
+   */
+  private ActiveEdges activeEdges;
+
+  private PolyEdge edgePool;
+  private PolyEdge edgePoolLast;
+
+  private int minY;
+  private int maxY;
+  private int minX;
+  private int maxX;
+
+  /**
+   * Holds and manages information about the pixel coverage.
+   */
+  private ScanlineCoverage scanlineCoverage;
+
+  /**
+   * Create a new ScanlineConverter.
+   */
+  ScanlineConverter()
+  {
+    scanlines = new Scanline[10];
+    coords = new float[6];
+    activeEdges = new ActiveEdges();
+    edgePool = new PolyEdge();
+    edgePoolLast = edgePool;
+    scanlineCoverage = new ScanlineCoverage();
+  }
+
+  /**
+   * Renders the specified shape using the specified clip and transform.
+   *
+   * @param p the pixelizer that receives the coverage information
+   * @param shape the shape to render
+   * @param clip the clip
+   * @param trans the transform
+   */
+  public void renderShape(Pixelizer p, Shape shape, Shape clip,
+                          AffineTransform trans, int res, int yRes,
+                          RenderingHints hints)
+  {
+    // TODO: Do something useful with the rendering hints. Like, adjusting
+    // the resolution.
+
+    // Prepare resolution and upper bounds.
+    clear();
+    setResolution(res, yRes);
+
+    boolean haveClip = clip != null;
+
+    // Add shapes.
+    float flatness = Fixed.floatValue(FIXED_DIGITS, resolution / 2);
+    PathIterator path = shape.getPathIterator(trans, flatness);
+    addShape(path, false);
+    if (haveClip)
+      {
+        path= clip.getPathIterator(trans, flatness);
+        addShape(path, true);
+      }
+
+    setUpperBounds(minY);
+
+    PolyEdge edge = edgePool;
+    while (edge != edgePoolLast)
+      {
+        addEdge(edge);
+        edge = edge.poolNext;
+      }
+
+    int y = upperBounds;
+    int index;
+    activeEdges.clear();
+    // The render loop...
+    Scanline scanline = null;
+    int lastRealY = Fixed.intValue(FIXED_DIGITS, y);
+    while (y <= maxY)
+      {
+        // First we put together our list of active edges.
+        index = scanlineIndex(y);
+        // If we go outside the scanline array we still need to render the
+        // remaining edges until they end.
+        scanline = index < scanlines.length ? scanlines[index] : null;
+        if (scanline != null)
+          {
+            edge = scanline.getEdges();
+            while (edge != null)
+              {
+                activeEdges.add(edge);
+                edge = edge.scanlineNext;
+              }
+          }
+
+        // Then we intersect all active edges with the current scanline
+        // and sort them according to their intersection points.
+        activeEdges.intersectSortAndPack(FIXED_DIGITS, y + halfStep);
+
+        // Ok, now we can perform the actual scanlining.
+        int realY = Fixed.intValue(FIXED_DIGITS, y + resolution);
+        boolean push = lastRealY != realY;
+
+        doScanline(p, y, push, haveClip);
+
+        // Remove obsolete active edges.
+        //activeEdges.remove(y + halfStep);
+        // Go on with the next line...
+        y += resolution;
+        lastRealY = realY;
+
+      }
+  }
+
+  /**
+   * Clears all scanlines.
+   */
+  private void clear()
+  {
+    // Reset edge pool.
+    edgePoolLast = edgePool;
+
+    // Reset scanlines.
+    for (int i = scanlines.length - 1; i >= 0 ; i--)
+      {
+        Scanline sl = scanlines[i];
+        if (sl != null)
+          sl.clear();
+      }
+
+    // Reset scanline coverage.
+    scanlineCoverage.clear();
+
+    // Reset bounds.
+    minY = Integer.MAX_VALUE;
+    maxY = Integer.MIN_VALUE;
+    minX = Integer.MAX_VALUE;
+    maxX = Integer.MIN_VALUE;
+  }
+
+  /**
+   * Performs the scanlining on the current set of active edges.
+   *
+   * @param p the pixelizer to receive the pixel coverage data
+   * @param y the Y coordinate
+   * @param push true when the scanline is ready to be pushed to the
+   *        pixelizer
+   * @param haveClip true when there's a clip, false otherwise
+   */
+  private void doScanline(Pixelizer p, int y, boolean push,
+                          boolean haveClip)
+  {
+    // First, rewind the scanline coverage.
+    scanlineCoverage.rewind();
+
+    // We begin outside the clip and outside the shape. We only draw when
+    // we are inside the clip AND inside the shape.
+    boolean inClip = ! haveClip;
+    boolean inShape = false;
+    PolyEdge lastEdge = null;
+    int numEdges = activeEdges.getNumActiveEdges();
+    for (int i = 0; i < numEdges; i++)
+      {
+        PolyEdge edge = activeEdges.getActiveEdge(i);
+        if (inClip && inShape)
+          {
+            assert lastEdge != null;
+            int x0 = lastEdge.xIntersection;
+            int x1 = edge.xIntersection;
+            assert x0 <= x1;
+
+            int pix0 = Fixed.intValue(FIXED_DIGITS, x0);
+            int pix1 = Fixed.intValue(FIXED_DIGITS, x1);
+            int frac0 = ONE - Fixed.trunc(FIXED_DIGITS, x0);
+            int frac1 = ONE - Fixed.trunc(FIXED_DIGITS, x1);
+            // Only keep the first 4 digits after the point.
+            frac0 = frac0 >> (FIXED_DIGITS - yResolution);
+            frac1 = frac1 >> (FIXED_DIGITS - yResolution);
+            scanlineCoverage.add(pix0, 1 * (1 << yResolution), frac0);
+            scanlineCoverage.add(pix1, -1 * (1 << yResolution), -frac1);
+          }
+        if (edge.isClip)
+          inClip = ! inClip;
+        else
+          inShape = ! inShape;
+
+        lastEdge = edge;
+      }
+
+    // Push out the whole scanline to the pixelizer.
+    if (push && ! scanlineCoverage.isEmpty())
+      {
+        p.renderScanline(Fixed.intValue(FIXED_DIGITS, y), scanlineCoverage);
+        scanlineCoverage.clear();
+      }
+  }
+
+
+  /**
+   * Sets the resolution. A value of 0 rasterizes the shape normally without
+   * anti-aliasing. Greater values renders with a resolution of 2 ^ res.
+   *
+   * @param res the resolution
+   */
+  private void setResolution(int res, int yRes)
+  {
+    int scanlinesPerPixel = 1 << res;
+    int one = Fixed.fixedValue(FIXED_DIGITS, 1);
+    resolution = one / (scanlinesPerPixel);
+    halfStep = resolution / 2;
+
+    scanlineCoverage.setMaxCoverage(scanlinesPerPixel << yResolution);
+
+    yResolution = yRes;
+  }
+
+  /**
+   * Sets the vertical bounds of that shape that is beeing rendered.
+   *
+   * @param y0 the upper bounds
+   */
+  private void setUpperBounds(int y0)
+  {
+    upperBounds = fit(y0);
+  }
+
+  /**
+   * Add a shape to the scanline converter.
+   *
+   * @param path
+   * @param clip
+   */
+  private void addShape(PathIterator path, boolean clip)
+  {
+    int startX = 0;
+    int startY = 0;
+    int lastX = 0;
+    int lastY = 0;
+    while (! path.isDone())
+      {
+        int type = path.currentSegment(coords);
+        switch (type)
+          {
+            case PathIterator.SEG_MOVETO:
+              startX = lastX = Fixed.fixedValue(FIXED_DIGITS, coords[0]);
+              startY = lastY = Fixed.fixedValue(FIXED_DIGITS, coords[1]);
+              minY = Math.min(startY, minY);
+              maxY = Math.max(startY, maxY);
+              minX = Math.min(startX, minX);
+              maxX = Math.max(startX, maxX);
+              break;
+            case PathIterator.SEG_LINETO:
+              int x = Fixed.fixedValue(FIXED_DIGITS, coords[0]);
+              int y = Fixed.fixedValue(FIXED_DIGITS, coords[1]);
+              edgePoolAdd(lastX, lastY, x, y, clip);
+              lastX = x;
+              lastY = y;
+              minY = Math.min(lastY, minY);
+              maxY = Math.max(lastY, maxY);
+              minX = Math.min(lastX, minX);
+              maxX = Math.max(lastX, maxX);
+              break;
+            case PathIterator.SEG_CLOSE:
+              edgePoolAdd(lastX, lastY, startX, startY, clip);
+              lastX = startX;
+              lastY = startY;
+              break;
+            case PathIterator.SEG_CUBICTO:
+            case PathIterator.SEG_QUADTO:
+            default:
+              assert false;
+          }
+        path.next();
+      }
+  }
+
+  /**
+   * Adds an edge into the scanline array.
+   */
+  private void addEdge(PolyEdge edge)
+  {
+    // Determine index.
+    int upper = Math.min(edge.y0, edge.y1);
+    // Fit to raster.
+    int index = scanlineIndex(upper);
+    // Grow array when necessary.
+    if (index >= scanlines.length)
+      {
+        int oldSize = scanlines.length;
+        int newSize = Math.max(oldSize + oldSize / 2 + 1, index + 10);
+        Scanline[] newScanlines = new Scanline[newSize];
+        System.arraycopy(scanlines, 0, newScanlines, 0, oldSize);
+        scanlines = newScanlines;
+      }
+
+    // Add edge.
+    if (scanlines[index] == null)
+      {
+        scanlines[index] = new Scanline();
+      }
+    scanlines[index].addEdge(edge);
+  }
+
+  /**
+   * Fits an Y coordinate to the grid.
+   *
+   * @param y the Y coordinate to fit
+   *
+   * @return the fitted Y coordinate
+   */
+  private int fit(int y)
+  {
+    int val1 = Fixed.div(FIXED_DIGITS, y, resolution);
+    int rounded = Fixed.round(FIXED_DIGITS, val1);
+    return Fixed.mul(FIXED_DIGITS, rounded, resolution);
+  }
+
+  /**
+   * Calculates the scanline index for the specified y coordinate.
+   *
+   * @param y the y coordinate as fixed point value
+   *
+   * @return the scanline index
+   */
+  private int scanlineIndex(int y)
+  {
+    int fitted = fit(y);
+    // Cleverly skip the fixed point conversions here.
+    return (fitted - upperBounds)/ resolution;
+  }
+
+  private void edgePoolAdd(int x0, int y0, int x1, int y1, boolean clip)
+  {
+    // Don't need no horizontal edges.
+    if (y0 != y1)
+      {
+        edgePoolLast.init(FIXED_DIGITS, x0, y0, x1, y1, clip);
+        if (edgePoolLast.poolNext == null)
+          {
+            edgePoolLast.poolNext = new PolyEdge();
+          }
+        edgePoolLast = edgePoolLast.poolNext;
+      }
+  }
+}
diff --git a/libjava/classpath/gnu/java/awt/java2d/ScanlineCoverage.java b/libjava/classpath/gnu/java/awt/java2d/ScanlineCoverage.java
new file mode 100644
index 000000000..9ffb63e1d
--- /dev/null
+++ b/libjava/classpath/gnu/java/awt/java2d/ScanlineCoverage.java
@@ -0,0 +1,630 @@
+/* ScanlineCoverage.java -- Manages coverage information for a scanline
+   Copyright (C) 2007 Free Software Foundation, Inc.
+
+This file is part of GNU Classpath.
+
+GNU Classpath is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2, or (at your option)
+any later version.
+
+GNU Classpath is distributed in the hope that it will be useful, but
+WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with GNU Classpath; see the file COPYING.  If not, write to the
+Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
+02110-1301 USA.
+
+Linking this library statically or dynamically with other modules is
+making a combined work based on this library.  Thus, the terms and
+conditions of the GNU General Public License cover the whole
+combination.
+
+As a special exception, the copyright holders of this library give you
+permission to link this library with independent modules to produce an
+executable, regardless of the license terms of these independent
+modules, and to copy and distribute the resulting executable under
+terms of your choice, provided that you also meet, for each linked
+independent module, the terms and conditions of the license of that
+module.  An independent module is a module which is not derived from
+or based on this library.  If you modify this library, you may extend
+this exception to your version of the library, but you are not
+obligated to do so.  If you do not wish to do so, delete this
+exception statement from your version. */
+
+package gnu.java.awt.java2d;
+
+/**
+ * Stores and handles the pixel converage for a scanline. The pixel coverage
+ * is stored as sorted list of {@linke Covergage} entries, each of which holds
+ * information about the coverage for the X and Y axis. This is utilized to
+ * compute the actual coverage for each pixel on the scanline and finding
+ * chunks of pixels with equal coverage quickly.
+ */
+public final class ScanlineCoverage
+{
+
+  /**
+   * Iterates over the coverage list and calculates the actual coverage
+   * ranges on a scanline.
+   */
+  public final class Iterator
+  {
+    /**
+     * This instance is reused in the iteration.
+     */
+    private Range range;
+
+    /**
+     * The pointer to the current item in the iteration.
+     */
+    private Coverage currentItem;
+
+    /**
+     * The current coverage value.
+     */
+    private int currentCoverage;
+
+    /**
+     * True when the current pixel coverage has already been handled, false
+     * otherwise.
+     */
+    private boolean handledPixelCoverage;
+
+    /**
+     * Creates a new CoverageIterator.
+     */
+    Iterator()
+    {
+      range = new Range();
+    }
+
+    /**
+     * Returns the next coverage range on the scanline. The returned object
+     * will always be the same object, but with different values. Keep that
+     * in mind when dealing with this object.
+     *
+     * @return the next coverage range on the scanline
+     */
+    public Range next()
+    {
+      // TODO: Lump together the single-pixel coverage and the
+      // between-pixel coverage when the pixel coverage delta is 0.
+      if (handledPixelCoverage == false)
+        {
+          // Handle single pixel coverage.
+          range.setXPos(currentItem.xPos);
+          range.setLength(1);
+          range.setCoverage(currentCoverage + currentItem.pixelCoverage);
+          handledPixelCoverage = true;
+        }
+      else
+        {
+          // Handle pixel span coverage.
+          currentCoverage += currentItem.covDelta;
+          range.setCoverage(currentCoverage);
+          range.setXPos(currentItem.xPos + 1);
+          currentItem = currentItem.next;
+          range.setLength(currentItem.xPos - range.xPos);
+          handledPixelCoverage = false;
+        }
+      return range;
+    }
+
+    /**
+     * Returns {@ true} when there are more coverage ranges to iterate,
+     * {@ false} otherwise.
+     *
+     * @return {@ true} when there are more coverage ranges to iterate,
+     *         {@ false} otherwise
+     */
+    public boolean hasNext()
+    {
+      boolean hasNext;
+      if (currentItem != null && handledPixelCoverage == false)
+        {
+          // We have at least one more coverage item when there's a pixel
+          // coverage piece left.
+          hasNext = true;
+        }
+      else if (currentItem == null || currentItem.next == null
+          || currentItem.next == last)
+        {
+          hasNext = false;
+        }
+      else
+        {
+          hasNext = true;
+        }
+      return hasNext;
+    }
+
+    /**
+     * Resets this iterator to the start of the list.
+     */
+    void reset()
+    {
+      currentItem = head;
+      currentCoverage = 0;
+      handledPixelCoverage = false;
+    }
+  }
+
+  /**
+   * A data object that carries information about pixel coverage on a scanline.
+   * The data consists of a starting X position on the scanline, the
+   * length of the range in pixels and the actual coverage value.
+   **/
+  public static final class Range
+  {
+    /**
+     * The X position on the scanline, in pixels.
+     */
+    private int xPos;
+
+    /**
+     * The length of the range, in pixels.
+     */
+    private int length;
+
+    /**
+     * The actual coverage. The relation depends on
+     * {@link ScanlineCoverage#maxCoverage}.
+     */
+    private int coverage;
+
+    /**
+     * Creates a new CoverageRange object.
+     */
+    Range()
+    {
+      // Nothing to do. The values get initialized in the corresponding
+      // setters.
+    }
+
+    /**
+     * Sets the X start position (left) on the scanline. This value is
+     * considered to be in pixels and device space.
+     *
+     * @param x the x position
+     */
+    void setXPos(int x)
+    {
+      xPos = x;
+    }
+
+    /**
+     * Returns the X start position (left) on the scanline. This value
+     * is considered to be in pixels and device space.
+     *
+     * @return the X position on the scanline
+     */
+    public int getXPos()
+    {
+      return xPos;
+    }
+
+    /**
+     * Sets the length of the pixel range. This is in pixel units.
+     *
+     * @param l the length of the range
+     */
+    void setLength(int l)
+    {
+      length = l;
+    }
+
+    /**
+     * Returns the length of the range in pixel units.
+     *
+     * @return the length of the range in pixel units
+     */
+    public int getLength()
+    {
+      return length;
+    }
+
+    /**
+     * Returns the first X position after the range.
+     *
+     * @return the first X position after the range
+     */
+    public int getXPosEnd()
+    {
+      return xPos + length;
+    }
+
+    /**
+     * Sets the coverage of the pixel range. The relation of that value
+     * depends on {@link ScanlineCoverage#maxCoverage}.
+     *
+     * @param cov the coverage value for the pixel range
+     */
+    void setCoverage(int cov)
+    {
+      coverage = cov;
+    }
+
+    /**
+     * Returns the coverage of the pixel range. The relation of this value
+     * depends on {@link ScanlineCoverage#getMaxCoverage()}.
+     *
+     * @return the coverage of the pixel range
+     */
+    public int getCoverage()
+    {
+      return coverage;
+    }
+
+    /**
+     * Returns a string representation.
+     */
+    public String toString()
+    {
+      return "Coverage range: xPos=" + xPos + ", length=" + length
+             + ", coverage: " + coverage;
+    }
+  }
+
+  /**
+   * One bucket in the list.
+   */
+  private static final class Coverage
+  {
+    /**
+     * The X coordinate on the scanline to which this bucket belongs.
+     */
+    int xPos;
+
+    /**
+     * The coverage delta from the pixel at xPos to xPos + 1.
+     */
+    int covDelta;
+
+    /**
+     * The delta for the pixel at xPos. This is added to the pixel at xPos,
+     * but not to the following pixel.
+     */
+    int pixelCoverage;
+
+    /**
+     * Implements a linked list. This points to the next element of the list.
+     */
+    Coverage next;
+
+    /**
+     * Returns the X coordinate for this entry.
+     *
+     * @return the X coordinate for this entry
+     */
+    public int getXPos()
+    {
+      return xPos;
+    }
+
+    /**
+     * Returns the coverage delta for this entry.
+     *
+     * @return the coverage delta for this entry
+     */
+    public int getCoverageDelta()
+    {
+      return covDelta;
+    }
+
+    /**
+     * Returns a string representation.
+     *
+     * @return a string representation
+     */
+    public String toString()
+    {
+      return "Coverage: xPos: " + xPos + ", covDelta: " + covDelta;
+    }
+
+    /**
+     * Returns a string representation of this entry and all the following
+     * in the linked list.
+     *
+     * @return a string representation of this entry and all the following
+     *         in the linked list
+     */
+    public String list()
+    {
+      String str = toString();
+      if (next != null)
+        str = str + " --> " + next.list();
+      return str;
+    }
+  }
+
+  /**
+   * The head of the sorted list of buckets.
+   */
+  private Coverage head;
+
+  /**
+   * The current bucket. We make use of the fact that the scanline converter
+   * always scans the scanline (and thus this list) from left to right to
+   * quickly find buckets or insertion points.
+   */
+  private Coverage current;
+
+  /**
+   * The item that is before current in the list.
+   */
+  private Coverage currentPrev;
+
+  /**
+   * The bucket after the last valid bucket. Unused buckets are not thrown
+   * away and garbage collected. Instead, we keep them at the tail of the list
+   * and reuse them when necessary.
+   */
+  private Coverage last;
+
+  /**
+   * The last valid entry.
+   */
+  private Coverage lastPrev;
+
+  /**
+   * The minimum X coordinate of this scanline.
+   */
+  private int minX;
+
+  /**
+   * The maximum X coordinate of this scanline.
+   */
+  private int maxX;
+
+  /**
+   * The maximum coverage value.
+   */
+  private int maxCoverage;
+
+  /**
+   * The iterator over the ranges of this scanline.
+   */
+  private Iterator iterator;
+
+  /**
+   * Creates a new ScanlineCoverage instance.
+   */
+  public ScanlineCoverage()
+  {
+    iterator = new Iterator();
+  }
+
+  /**
+   * Indicates the the next scan of the scanline begins and that the next
+   * request will be at the beginning of this list. This makes searching and
+   * sorting of this list very quick.
+   */
+  public void rewind()
+  {
+    current = head;
+    currentPrev = null;
+  }
+
+  /**
+   * Clears the list. This does not throw away the old buckets but only
+   * resets the end-pointer of the list to the first element. All buckets are
+   * then unused and are reused when the list is filled again.
+   */
+  public void clear()
+  {
+    last = head;
+    lastPrev = null;
+    current = head;
+    currentPrev = null;
+    minX = Integer.MAX_VALUE;
+    maxX = Integer.MIN_VALUE;
+  }
+
+  /**
+   * This adds the specified coverage to the pixel at the specified
+   * X position.
+   *
+   * @param x the X position
+   * @param xc the x coverage
+   * @param yc the y coverage
+   */
+  public void add(int x, int xc, int yc)
+  {
+    Coverage bucket = findOrInsert(x);
+    bucket.covDelta += xc;
+    bucket.pixelCoverage += yc;
+    minX = Math.min(minX, x);
+    maxX = Math.max(maxX, x);
+  }
+
+  /**
+   * Returns the maximum coverage value for the scanline.
+   *
+   * @return the maximum coverage value for the scanline
+   */
+  public int getMaxCoverage()
+  {
+    return maxCoverage;
+  }
+
+  /**
+   * Sets the maximum coverage value for the scanline.
+   *
+   * @param maxCov the maximum coverage value for the scanline
+   */
+  void setMaxCoverage(int maxCov)
+  {
+    maxCoverage = maxCov;
+  }
+
+  /**
+   * Returns the maximum X coordinate of the current scanline.
+   *
+   * @return the maximum X coordinate of the current scanline
+   */
+  public int getMaxX()
+  {
+    return maxX;
+  }
+
+  /**
+   * Returns the minimum X coordinate of the current scanline.
+   *
+   * @return the minimum X coordinate of the current scanline
+   */
+  public int getMinX()
+  {
+    return minX;
+  }
+
+  /**
+   * Finds the bucket in the list with the specified X coordinate.
+   * If no such bucket is found, then a new one is fetched (either a cached
+   * bucket from the end of the list or a newly allocated one) inserted at the
+   * correct position and returned.
+   *
+   * @param x the X coordinate
+   *
+   * @return a bucket to hold the coverage data
+   */
+  private Coverage findOrInsert(int x)
+  {
+    // First search for a matching bucket.
+    if (head == null)
+      {
+        // Special case: the list is still empty.
+        // Testpoint 1.
+        head = new Coverage();
+        head.xPos = x;
+        current = head;
+        currentPrev = null;
+        return head;
+      }
+
+    // This performs a linear search, starting from the current bucket.
+    // This is reasonably efficient because access to this list is always done
+    // in a linear fashion and we are usually not more then 1 or 2 buckets away
+    // from the one we're looking for.
+    Coverage match = current;
+    Coverage prev = currentPrev;
+    while (match != last && match.xPos < x)
+      {
+        prev = match;
+        match = match.next;
+      }
+
+    // At this point we have either found an entry with xPos >= x, or reached
+    // the end of the list (match == last || match == null).
+    if (match == null)
+      {
+        // End of the list. No cached items to reuse.
+        // Testpoint 2.
+        match = new Coverage();
+        match.xPos = x;
+        if (prev != null)
+          prev.next = match;
+        current = match;
+        currentPrev = prev;
+        return match;
+      }
+    else if (match == last)
+      {
+        // End of the list. Reuse this item. Expand list.
+        // Testpoint 3.
+        last = match.next;
+        lastPrev = match;
+        match.xPos = x;
+        match.covDelta = 0;
+        match.pixelCoverage = 0;
+        // Keep link to last element or null, indicating the end of the list.
+        current = match;
+        currentPrev = prev;
+        return match;
+      }
+
+    if (x == match.xPos)
+      {
+        // Special case: We have another coverage entry at the same location
+        // as an already existing entry. Return this.
+        // Testpoint 4.
+        current = match;
+        currentPrev = prev;
+        return match;
+      }
+    else // x <= match.xPos
+      {
+        assert (x <= match.xPos);
+        assert (prev == null ||x > prev.xPos);
+
+        // Create new entry, or reuse existing one.
+        Coverage cov;
+        if (last != null)
+          {
+            // Testpoint 5.
+            cov = last;
+            last = cov.next;
+            lastPrev.next = last;
+          }
+        else
+          {
+            // Testpoint 6.
+            cov = new Coverage();
+          }
+
+        cov.xPos = x;
+        cov.covDelta = 0;
+        cov.pixelCoverage = 0;
+
+        // Insert this item in the list.
+        if (prev != null)
+          {
+            // Testpoint 5 & 6.
+            prev.next = cov;
+            cov.next = match;
+            current = cov;
+            currentPrev = prev;
+          }
+        else
+          {
+            // Testpoint 7.
+            assert (match == head);
+            // Insert at head.
+            head = cov;
+            head.next = match;
+            current = head;
+            currentPrev = null;
+          }
+        return cov;
+      }
+  }
+
+  /**
+   * (Re-)Starts iterating the coverage values for the scanline.
+   * Use the returned iterator to get the consecutive coverage ranges.
+   *
+   * @return the iterator
+   */
+  public Iterator iterate()
+  {
+    iterator.reset();
+    return iterator;
+  }
+
+  /**
+   * Returns {@ true} if this object has no entries for the current scanline,
+   * {@ false} otherwise.
+   *
+   * @return {@ true} if this object has no entries for the current scanline,
+   *         {@ false} otherwise
+   */
+  public boolean isEmpty()
+  {
+    return head == null || head == last
+           || head.next == null || head.next == last;
+  }
+
+}
diff --git a/libjava/classpath/gnu/java/awt/java2d/Segment.java b/libjava/classpath/gnu/java/awt/java2d/Segment.java
new file mode 100644
index 000000000..1d9a57001
--- /dev/null
+++ b/libjava/classpath/gnu/java/awt/java2d/Segment.java
@@ -0,0 +1,158 @@
+/* Segment.java -- Abstract segment used for BasicStroke
+   Copyright (C) 2006 Free Software Foundation, Inc.
+
+This file is part of GNU Classpath.
+
+GNU Classpath is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2, or (at your option)
+any later version.
+
+GNU Classpath is distributed in the hope that it will be useful, but
+WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with GNU Classpath; see the file COPYING.  If not, write to the
+Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
+02110-1301 USA.
+
+Linking this library statically or dynamically with other modules is
+making a combined work based on this library.  Thus, the terms and
+conditions of the GNU General Public License cover the whole
+combination.
+
+As a special exception, the copyright holders of this library give you
+permission to link this library with independent modules to produce an
+executable, regardless of the license terms of these independent
+modules, and to copy and distribute the resulting executable under
+terms of your choice, provided that you also meet, for each linked
+independent module, the terms and conditions of the license of that
+module.  An independent module is a module which is not derived from
+or based on this library.  If you modify this library, you may extend
+this exception to your version of the library, but you are not
+obligated to do so.  If you do not wish to do so, delete this
+exception statement from your version. */
+
+
+package gnu.java.awt.java2d;
+
+import java.awt.geom.Point2D;
+
+public abstract class Segment implements Cloneable
+{
+  // Start and end points of THIS segment
+  public Point2D P1;
+  public Point2D P2;
+
+  // Segments can be linked together internally as a linked list
+  public Segment first;
+  public Segment next;
+  public Segment last;
+
+  // Half the stroke width
+  protected double radius;
+
+  /**
+   * Create a new, empty segment
+   */
+  public Segment()
+  {
+    P1 = P2 = null;
+    first = this;
+    next = null;
+    last = this;
+  }
+
+  /**
+   * Add a segment to the polygon
+   * @param newsegment segment to add
+   */
+  public void add(Segment newsegment)
+  {
+    newsegment.first = first;
+    last.next = newsegment;
+    last = last.next.last;
+  }
+
+  /**
+   * Reverses the orientation of the whole polygon
+   */
+  public void reverseAll()
+  {
+    reverse();
+    first = last;
+    Segment v = next;
+    Segment former = this;
+    next = null;
+
+    while (v != null)
+      {
+        v.reverse();
+        v.last = this;
+        Segment oldnext = v.next;
+        v.next = former;
+
+        former = v;
+        v = oldnext; // move to the next in list
+      }
+  }
+
+  public String toString()
+  {
+    return "Segment:"+P1+", "+P2;
+  }
+
+  /**
+   * Get the normal vector to the slope of the line.
+   * @return vector of length radius, normal to the (x0,y0)-(x1,y1) vector)
+   */
+  protected double[] normal(double x0, double y0, double x1, double y1)
+  {
+    double dx = (x1 - x0);
+    double dy = (y1 - y0);
+    if( dy == 0 )
+      {
+        dy = radius * ((dx > 0)?1:-1);
+        dx = 0;
+      }
+    else if( dx == 0 )
+      {
+        dx = radius * ((dy > 0)?-1:1);
+        dy = 0;
+      }
+    else
+      {
+        double N = Math.sqrt(dx * dx + dy * dy);
+        double odx = dx;
+        dx = -radius * dy / N;
+        dy = radius * odx / N;
+      }
+    return new double[]{ dx, dy };
+  }
+
+  /**
+   * Reverse the current segment
+   */
+  public abstract void reverse();
+
+  /**
+   * Get the "top" and "bottom" segments of a segment.
+   * First array element is p0 + normal, second is p0 - normal.
+   */
+  public abstract Segment[] getDisplacedSegments(double radius);
+
+  /**
+   * Returns the coordinates of the first control point, or the start point
+   * for a line segment.
+   */
+  public abstract double[] cp1();
+
+  /**
+   * Returns the coordinates of the second control point, or the end point
+   * for a line segment.
+   */
+  public abstract double[] cp2();
+
+}
diff --git a/libjava/classpath/gnu/java/awt/java2d/ShapeCache.java b/libjava/classpath/gnu/java/awt/java2d/ShapeCache.java
new file mode 100644
index 000000000..89a9ac4ab
--- /dev/null
+++ b/libjava/classpath/gnu/java/awt/java2d/ShapeCache.java
@@ -0,0 +1,90 @@
+/* ShapeCache.java -- Caches certain Shapes for reuse in AbstractGraphics2D
+   Copyright (C) 2006 Free Software Foundation, Inc.
+
+This file is part of GNU Classpath.
+
+GNU Classpath is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2, or (at your option)
+any later version.
+
+GNU Classpath is distributed in the hope that it will be useful, but
+WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with GNU Classpath; see the file COPYING.  If not, write to the
+Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
+02110-1301 USA.
+
+Linking this library statically or dynamically with other modules is
+making a combined work based on this library.  Thus, the terms and
+conditions of the GNU General Public License cover the whole
+combination.
+
+As a special exception, the copyright holders of this library give you
+permission to link this library with independent modules to produce an
+executable, regardless of the license terms of these independent
+modules, and to copy and distribute the resulting executable under
+terms of your choice, provided that you also meet, for each linked
+independent module, the terms and conditions of the license of that
+module.  An independent module is a module which is not derived from
+or based on this library.  If you modify this library, you may extend
+this exception to your version of the library, but you are not
+obligated to do so.  If you do not wish to do so, delete this
+exception statement from your version. */
+
+
+package gnu.java.awt.java2d;
+
+import java.awt.Polygon;
+import java.awt.Rectangle;
+import java.awt.geom.Arc2D;
+import java.awt.geom.Ellipse2D;
+import java.awt.geom.GeneralPath;
+import java.awt.geom.Line2D;
+import java.awt.geom.RoundRectangle2D;
+
+/**
+ * Caches certain Shape objects for reuse in AbstractGraphics2D. This avoids
+ * massive creation of such objects.
+ */
+public class ShapeCache
+{
+
+  /**
+   * A cached Line2D.
+   */
+  public Line2D line;
+
+  /**
+   * A cached Rectangle.
+   */
+  public Rectangle rect;
+
+  /**
+   * A cached RoundRectangle2D.
+   */
+  public RoundRectangle2D roundRect;
+
+  /**
+   * A cached Ellipse2D.
+   */
+  public Ellipse2D ellipse;
+
+  /**
+   * A cached Arc2D.
+   */
+  public Arc2D arc;
+
+  /**
+   * A cached Polygon.
+   */
+  public Polygon polygon;
+
+  /**
+   * A cached polyline.
+   */
+  public GeneralPath polyline;
+}
diff --git a/libjava/classpath/gnu/java/awt/java2d/ShapeWrapper.java b/libjava/classpath/gnu/java/awt/java2d/ShapeWrapper.java
new file mode 100644
index 000000000..f4e77f450
--- /dev/null
+++ b/libjava/classpath/gnu/java/awt/java2d/ShapeWrapper.java
@@ -0,0 +1,119 @@
+/* ShapeWrapper.java -- Protects shapes by wrapping them
+   Copyright (C) 2007 Free Software Foundation, Inc.
+
+This file is part of GNU Classpath.
+
+GNU Classpath is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2, or (at your option)
+any later version.
+
+GNU Classpath is distributed in the hope that it will be useful, but
+WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with GNU Classpath; see the file COPYING.  If not, write to the
+Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
+02110-1301 USA.
+
+Linking this library statically or dynamically with other modules is
+making a combined work based on this library.  Thus, the terms and
+conditions of the GNU General Public License cover the whole
+combination.
+
+As a special exception, the copyright holders of this library give you
+permission to link this library with independent modules to produce an
+executable, regardless of the license terms of these independent
+modules, and to copy and distribute the resulting executable under
+terms of your choice, provided that you also meet, for each linked
+independent module, the terms and conditions of the license of that
+module.  An independent module is a module which is not derived from
+or based on this library.  If you modify this library, you may extend
+this exception to your version of the library, but you are not
+obligated to do so.  If you do not wish to do so, delete this
+exception statement from your version. */
+
+package gnu.java.awt.java2d;
+
+import java.awt.Rectangle;
+import java.awt.Shape;
+import java.awt.geom.AffineTransform;
+import java.awt.geom.PathIterator;
+import java.awt.geom.Point2D;
+import java.awt.geom.Rectangle2D;
+
+/**
+ * Protects any other shape from beeing modified by wrapping it.
+ */
+public class ShapeWrapper
+  implements Shape
+{
+
+  /**
+   * The shape to be protected.
+   */
+  private Shape shape;
+
+  /**
+   * Creates a new ShapeWrapper.
+   *
+   * @param other the shape to be protected
+   */
+  public ShapeWrapper(Shape other)
+  {
+    shape = other;
+  }
+
+  public boolean contains(double x, double y)
+  {
+    return shape.contains(x, y);
+  }
+
+  public boolean contains(Point2D p)
+  {
+    return shape.contains(p);
+  }
+
+  public boolean contains(double x, double y, double w, double h)
+  {
+    return shape.contains(x, y, w, h);
+  }
+
+  public boolean contains(Rectangle2D r)
+  {
+    return shape.contains(r);
+  }
+
+  public Rectangle getBounds()
+  {
+    return shape.getBounds();
+  }
+
+  public Rectangle2D getBounds2D()
+  {
+    return shape.getBounds2D();
+  }
+
+  public PathIterator getPathIterator(AffineTransform transform)
+  {
+    return shape.getPathIterator(transform);
+  }
+
+  public PathIterator getPathIterator(AffineTransform transform, double flatness)
+  {
+    return shape.getPathIterator(transform, flatness);
+  }
+
+  public boolean intersects(double x, double y, double w, double h)
+  {
+    return shape.intersects(x, y, w, h);
+  }
+
+  public boolean intersects(Rectangle2D r)
+  {
+    return shape.intersects(r);
+  }
+
+}
diff --git a/libjava/classpath/gnu/java/awt/java2d/TextCacheKey.java b/libjava/classpath/gnu/java/awt/java2d/TextCacheKey.java
new file mode 100644
index 000000000..0a60c6226
--- /dev/null
+++ b/libjava/classpath/gnu/java/awt/java2d/TextCacheKey.java
@@ -0,0 +1,153 @@
+/* TextCacheKey.java -- Key to use for caching texts with their rendered layout
+   Copyright (C) 2007 Free Software Foundation, Inc.
+
+This file is part of GNU Classpath.
+
+GNU Classpath is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2, or (at your option)
+any later version.
+
+GNU Classpath is distributed in the hope that it will be useful, but
+WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with GNU Classpath; see the file COPYING.  If not, write to the
+Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
+02110-1301 USA.
+
+Linking this library statically or dynamically with other modules is
+making a combined work based on this library.  Thus, the terms and
+conditions of the GNU General Public License cover the whole
+combination.
+
+As a special exception, the copyright holders of this library give you
+permission to link this library with independent modules to produce an
+executable, regardless of the license terms of these independent
+modules, and to copy and distribute the resulting executable under
+terms of your choice, provided that you also meet, for each linked
+independent module, the terms and conditions of the license of that
+module.  An independent module is a module which is not derived from
+or based on this library.  If you modify this library, you may extend
+this exception to your version of the library, but you are not
+obligated to do so.  If you do not wish to do so, delete this
+exception statement from your version. */
+
+package gnu.java.awt.java2d;
+
+import java.awt.Font;
+import java.awt.font.FontRenderContext;
+
+/**
+ * A key object to be used when caching pre-rendered text.
+ */
+public class TextCacheKey
+{
+
+  /**
+   * The actual string.
+   */
+  private String string;
+
+  /**
+   * The font render context.
+   */
+  private FontRenderContext fontRenderContext;
+
+  /**
+   * The font.
+   */
+  private Font font;
+
+  /**
+   * Creates a new TextCacheKey.
+   *
+   * This is intended to be used as search key. It is important to initialize
+   * the values using the setter methods before using this key, otherwise
+   * it will throw NPEs.
+   */
+  public TextCacheKey()
+  {
+    // No-arg constructor.
+  }
+
+  /**
+   * Creates a new TextCacheKey with initial values.
+   *
+   * @param s the string
+   * @param f the font
+   * @param frc the font render context
+   */
+  public TextCacheKey(String s, Font f, FontRenderContext frc)
+  {
+    string = s;
+    font = f;
+    fontRenderContext = frc;
+  }
+
+  /**
+   * Re-sets the string. This is intented to be used in search keys only.
+   *
+   * @param s the string to set
+   */
+  public void setString(String s)
+  {
+    string = s;
+  }
+
+  /**
+   * Sets the font render context.
+   * This is intented to be used in search keys only.
+   *
+   * @param frc the new font render context
+   */
+  public void setFontRenderContext(FontRenderContext frc)
+  {
+    fontRenderContext = frc;
+  }
+
+  /**
+   * Sets the font.
+   * This is intented to be used in search keys only.
+   *
+   * @param f the font to set
+   */
+  public void setFont(Font f)
+  {
+    font = f;
+  }
+
+  /**
+   * Determines if two objects are equal.
+   *
+   * @see Object#equals(Object)
+   */
+  public boolean equals(Object o)
+  {
+    boolean eq;
+    if (o instanceof TextCacheKey)
+      {
+        TextCacheKey other = (TextCacheKey) o;
+        eq = other.string.equals(string)
+             && other.font.equals(font)
+             && other.fontRenderContext.equals(fontRenderContext);
+      }
+    else
+      {
+        eq = false;
+      }
+    return eq;
+  }
+
+  /**
+   * Computes a hashcode for this key.
+   *
+   * @see Object#hashCode()
+   */
+  public int hashCode()
+  {
+    return string.hashCode() ^ font.hashCode() ^ fontRenderContext.hashCode();
+  }
+}
diff --git a/libjava/classpath/gnu/java/awt/java2d/TexturePaintContext.java b/libjava/classpath/gnu/java/awt/java2d/TexturePaintContext.java
new file mode 100644
index 000000000..2523d2311
--- /dev/null
+++ b/libjava/classpath/gnu/java/awt/java2d/TexturePaintContext.java
@@ -0,0 +1,211 @@
+/* TexturePaintContext.java -- PaintContext impl for TexturePaint
+   Copyright (C) 2006 Free Software Foundation, Inc.
+
+This file is part of GNU Classpath.
+
+GNU Classpath is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2, or (at your option)
+any later version.
+
+GNU Classpath is distributed in the hope that it will be useful, but
+WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with GNU Classpath; see the file COPYING.  If not, write to the
+Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
+02110-1301 USA.
+
+Linking this library statically or dynamically with other modules is
+making a combined work based on this library.  Thus, the terms and
+conditions of the GNU General Public License cover the whole
+combination.
+
+As a special exception, the copyright holders of this library give you
+permission to link this library with independent modules to produce an
+executable, regardless of the license terms of these independent
+modules, and to copy and distribute the resulting executable under
+terms of your choice, provided that you also meet, for each linked
+independent module, the terms and conditions of the license of that
+module.  An independent module is a module which is not derived from
+or based on this library.  If you modify this library, you may extend
+this exception to your version of the library, but you are not
+obligated to do so.  If you do not wish to do so, delete this
+exception statement from your version. */
+
+
+package gnu.java.awt.java2d;
+
+import java.awt.AWTError;
+import java.awt.PaintContext;
+import java.awt.Rectangle;
+import java.awt.TexturePaint;
+import java.awt.geom.AffineTransform;
+import java.awt.geom.NoninvertibleTransformException;
+import java.awt.geom.Rectangle2D;
+import java.awt.image.BufferedImage;
+import java.awt.image.ColorModel;
+import java.awt.image.Raster;
+import java.awt.image.WritableRaster;
+
+/**
+ * A {@link PaintContext} implementation for {@link TexturePaint}, done in
+ * pure Java.
+ *
+ * @author Roman Kennke (kennke@aicas.com)
+ */
+public class TexturePaintContext
+  implements PaintContext
+{
+
+  /**
+   * The TexturePaint object.
+   */
+  private BufferedImage image;
+
+  /**
+   * The Raster that holds the texture.
+   */
+  private WritableRaster paintRaster;
+
+  /**
+   * The transform from userspace into device space.
+   */
+  private AffineTransform transform;
+
+  /**
+   * Creates a new TexturePaintContext for the specified TexturePaint object.
+   * This initializes the Raster which is returned by
+   * {@link #getRaster(int, int, int, int)}.
+   *
+   * @param t the texture paint object
+   * @param db the bounds of the target raster in device space
+   * @param ub the bounds of the target raster in user space
+   * @param xform the transformation from user space to device space
+   */
+  public TexturePaintContext(TexturePaint t, Rectangle db,
+                             Rectangle2D ub, AffineTransform xform)
+  {
+    image = t.getImage();
+
+    try
+      {
+        // Prepare transform for mapping from device space into image space.
+        // In order to achieve this we take the transform for userspace->
+        // devicespace, append the correct scale and translation according
+        // to the anchor (which gives us the image->userspace->devicespace
+        // transform), and invert that (which gives use the device->user->image
+        // transform).
+        Rectangle2D anchor = t.getAnchorRect();
+        BufferedImage image = t.getImage();
+        double scaleX = anchor.getWidth() / image.getWidth();
+        double scaleY = anchor.getHeight() / image.getHeight();
+        transform = (AffineTransform) xform.clone();
+        transform.scale(scaleX, scaleY);
+        transform.translate(-anchor.getMinX(), -anchor.getMinY());
+        transform = transform.createInverse();
+      }
+    catch (NoninvertibleTransformException ex)
+      {
+        AWTError err =
+          new AWTError("Unexpected NoninvertibleTransformException");
+        err.initCause(ex);
+        throw err;
+      }
+  }
+
+  /**
+   * Disposes the PaintContext. Nothing is to do here, since we don't use
+   * any native resources in that implementation.
+   */
+  public void dispose()
+  {
+    // Nothing to do here.
+  }
+
+  /**
+   * Returns the color model of this PaintContext. This implementation returnes
+   * the color model used by the BufferedImage in the TexturePaint object,
+   * this avoids costly color model transformations (at least at this point).
+   *
+   * @return the color model of this PaintContext
+   */
+  public ColorModel getColorModel()
+  {
+    return image.getColorModel();
+  }
+
+  /**
+   * Returns the Raster that is used for painting.
+   *
+   * @param x1 the x location of the raster inside the user bounds of this paint
+   *        context
+   * @param y1 the y location of the raster inside the user bounds of this paint
+   *        context
+   * @param w the width
+   * @param h the height
+   *
+   * @return the Raster that is used for painting
+   *
+   */
+  public Raster getRaster(int x1, int y1, int w, int h)
+  {
+    ensureRasterSize(w, h);
+    int x2 = x1 + w;
+    int y2 = y1 + h;
+    float[] src = new float[2];
+    float[] dest = new float[2];
+    Raster source = image.getData();
+    int minX = source.getMinX();
+    int width = source.getWidth();
+    int minY = source.getMinY();
+    int height = source.getHeight();
+    Object pixel = null;
+    for (int y = y1; y < y2; y++)
+      {
+        for (int x = x1; x < x2; x++)
+          {
+            // Transform the coordinates from device space into image space.
+            src[0] = x;
+            src[1] = y;
+            transform.transform(src, 0, dest, 0, 1);
+            int dx = (int) dest[0];
+            int dy = (int) dest[1];
+
+            // The modulo operation gives us the replication effect.
+            dx = ((dx - minX) % width) + minX;
+            dy = ((dy - minY) % height) + minY;
+
+            // Handle possible negative values (replicating above the top-left)
+            if (dx < 0)
+              dx += width;
+            if (dy < 0)
+              dy += height;
+
+            // Copy the pixel.
+            pixel = source.getDataElements(dx, dy, pixel);
+            paintRaster.setDataElements(x - x1, y - y1, pixel);
+          }
+      }
+    return paintRaster;
+  }
+
+  /**
+   * Ensures that the target raster exists and has at least the specified
+   * size.
+   *
+   * @param w the requested target width
+   * @param h the requested target height
+   */
+  private void ensureRasterSize(int w, int h)
+  {
+    if (paintRaster == null || paintRaster.getWidth() < w
+        || paintRaster.getHeight() < h)
+      {
+        Raster s = image.getData();
+        paintRaster = s.createCompatibleWritableRaster(w, h);
+      }
+  }
+}