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.

1 files changed, 162 insertions, 0 deletions

diff --git a/libjava/gnu/gcj/xlib/GC.java b/libjava/gnu/gcj/xlib/GC.java
new file mode 100644
index 000000000..1a47cf66d
--- /dev/null
+++ b/libjava/gnu/gcj/xlib/GC.java
@@ -0,0 +1,162 @@
+/* Copyright (C) 2000, 2003  Free Software Foundation
+
+   This file is part of libgcj.
+
+This software is copyrighted work licensed under the terms of the
+Libgcj License.  Please consult the file "LIBGCJ_LICENSE" for
+details.  */
+
+package gnu.gcj.xlib;
+
+import gnu.gcj.RawData;
+import java.awt.Rectangle;
+
+/**
+ * An X11 graphics context.  Unlike a traditional X11 graphics
+ * context, the target drawable is part of the GC state.
+ *
+ * Implementation notes: There is no need to do coalescing of changes
+ * since Xlib will do this for us.  The implementation relies on the
+ * Xlib GC cache and will not try to be clever.
+ *
+ * @author Rolf W. Rasmussen <rolfwr@ii.uib.no>
+ */
+public class GC implements Cloneable
+{
+  /** Protected constructor, because GC.create(target) should be used instead.
+   */
+  protected GC(Drawable target)
+  {
+    this.target = target;
+    initStructure(null);
+  }
+
+  /** Try to get a suitable GC from the drawable's cache.
+   * If there isn't one, create one.
+   */
+  public Object clone()
+  {
+    try
+      {
+	GC gcClone = target.getGCFromCache ();
+	if (gcClone==null)
+	  {
+	    gcClone = (GC) super.clone();
+	    gcClone.structure = null;
+	  }
+	gcClone.initStructure(this);
+	gcClone.updateClip(clipRectangles);
+	return gcClone;
+      } 
+    catch (CloneNotSupportedException ex)
+      {
+	// This should never happen.
+	throw new InternalError ();
+      }
+  }
+
+  private native void initStructure(GC copyFrom);
+
+  public GC create()
+  {
+    return (GC) clone();
+  }
+  
+  /** Create a GC, or if one is already cached for target, return that.
+   * @param target The Drawable for which a GC is needed
+   * @return The new or retrieved GC
+   */
+  static public GC create (Drawable target)
+  {
+    GC returnValue = target.getGCFromCache ();
+    if (returnValue == null)
+      returnValue = new GC (target);
+    return returnValue;
+  }
+
+  public void finalize()
+  {
+    disposeImpl();
+  }
+
+  /** Save this GC in the drawable's cache.
+   *  The "real" dispose (disposeImpl) is called when the
+   *  drawable is finialized, to free X server resources.
+   */
+  public void dispose()
+  {
+    target.putGCInCache (this);
+  }
+
+  public synchronized native void disposeImpl();
+
+  public native void setForeground(long pixel);
+  public native void setFont(gnu.gcj.xlib.Font font);
+
+  /**
+   * Set the clip region for the graphics operations performed by the
+   * GC.
+   *
+   * This is one of the few costly operations of this class.  It is
+   * suggested that the clip is only set or changed if really
+   * necessary.  Higher level APIs can make such optimizations
+   * transparent.
+   *
+   * @param rectangles the union of these rectangles describe the clip
+   * region.
+   */
+  public void setClipRectangles(Rectangle[] rectangles)
+  {
+    clipRectangles = rectangles;
+    updateClip(clipRectangles);
+  }
+
+  public native void drawString(String text, int x, int y);
+  public native void drawLine(int x1, int y1, int x2, int y2);
+  public native void drawRectangle(int x, int y, int w, int h);
+
+  public native void fillRectangle(int x, int y, int w, int h);
+  public native void fillPolygon(int[] xPoints, int[] yPoints, int nPoints,
+				 int translateX, int translateY);
+  
+  public native void drawArc(int x, int y, int w, int h,
+			     int startAngle, int arcAngle);
+  public native void fillArc(int x, int y, int w, int h,
+			     int startAngle, int arcAngle);
+
+  /** 
+   * 
+   * Clear area using the background pixel or pixmap of the drawable.
+   * Note that this operation does not adhere to the current clip.
+   */
+  public native void clearArea(int x, int y, int w, int h,
+			       boolean exposures);
+
+  /** Draw a point using the current foreground color
+   * @param x The x coordinate at which to draw
+   * @param t The y coordinate at which to draw
+   */
+  public native void drawPoint (int x, int y);
+
+  public native void putImage(XImage image,
+			      int srcX, int srcY,
+			      int destX, int destY,
+			      int width, int height);
+
+  public native void copyArea (Drawable source,
+                               int srcX, int srcY,
+                               int destX, int destY,
+                               int width, int height);
+  
+  public Drawable getDrawable()
+  {
+    return target;
+  }
+
+  private native void updateClip(Rectangle[] rectangles);
+
+  private Drawable target;
+  private RawData structure;
+  private Rectangle[] clipRectangles;
+}
+