Makefile.am: Added gnu/awt/xlib/XFontPeer.java.

	* Makefile.am: Added gnu/awt/xlib/XFontPeer.java.
	* Makefile.in: Re-generated.
	* gnu/awt/xlib/XFontPeer.java: New file.
	* gnu/awt/xlib/XGraphics.java (setFont): Test for null font.
	(setClip): Commented out debug printout.
	* gnu/awt/xlib/XToolkit.java: Change superclass to ClasspathToolkit.
	(getFontPeer): Return XFontPeer.
	(getLocalGraphicsEnvironment): New method.
	(getClasspathFontPeer): New method.
	(createFont): New method.

From-SVN: r76891

3 files changed, 376 insertions, 7 deletions

diff --git a/libjava/gnu/awt/xlib/XFontPeer.java b/libjava/gnu/awt/xlib/XFontPeer.java
new file mode 100644
index 0000000..523cc22
--- /dev/null
+++ b/libjava/gnu/awt/xlib/XFontPeer.java
@@ -0,0 +1,277 @@
+/* Copyright (C) 2000, 2002, 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.awt.xlib;
+
+import java.awt.*;
+import gnu.java.awt.ClasspathToolkit;
+import gnu.java.awt.peer.ClasspathFontPeer;
+import java.util.Locale;
+import java.awt.font.*;
+import java.awt.geom.*;
+import java.text.CharacterIterator;
+
+/**
+ * Classpath-compatible peer for a font
+ */
+public class XFontPeer extends ClasspathFontPeer
+{
+  public XFontPeer (String name, int style)
+  {
+    this (name, style, 12 /* kludge */);
+  }
+  
+  public XFontPeer (String name, int style, float size)
+  {
+    super (name, style, (int)size);
+  }
+  
+  /**
+   * Implementation of {@link Font#canDisplay(char)}
+   *
+   * @param font the font this peer is being called from. This may be
+   * useful if you are sharing peers between Font objects. Otherwise it may
+   * be ignored.
+   */
+  public boolean canDisplay (Font font, char c)
+  {
+    throw new UnsupportedOperationException ();
+  }
+  
+  /**
+   * Implementation of {@link Font#canDisplay(String)},
+   * {@link Font#canDisplay(char [], int, int)}, and
+   * {@link Font#canDisplay(CharacterIterator, int, int)}.
+   *
+   * @param font the font this peer is being called from. This may be
+   * useful if you are sharing peers between Font objects. Otherwise it may
+   * be ignored.
+   */
+  public int canDisplayUpTo (Font font, CharacterIterator i, int start, int limit)
+  {
+    throw new UnsupportedOperationException ();
+  }
+  
+  /**
+   * Implementation of {@link
+   * Font#createGlyphVector(FontRenderContext, String)}, {@link
+   * Font#createGlyphVector(FontRenderContext, char[])}, and {@link
+   * Font#createGlyphVector(FontRenderContext, CharacterIterator)}.
+   *
+   * @param font the font object that the created GlyphVector will return
+   * when it gets asked for its font. This argument is needed because the
+   * public API of {@link GlyphVector} works with {@link java.awt.Font},
+   * not with font peers.
+   */
+  public GlyphVector createGlyphVector (Font font, FontRenderContext frc, CharacterIterator ci)
+  {
+    throw new UnsupportedOperationException ();
+  }
+  
+  /**
+   * Implementation of {@link Font#createGlyphVector(FontRenderContext,
+   * int[])}.
+   *
+   * @param font the font object that the created GlyphVector will return
+   * when it gets asked for its font. This argument is needed because the
+   * public API of {@link GlyphVector} works with {@link java.awt.Font},
+   * not with font peers.
+   */
+  public GlyphVector createGlyphVector (Font font, FontRenderContext ctx, int[] glyphCodes)
+  {
+    throw new UnsupportedOperationException ();
+  }
+  
+  /**
+   * Implementation of {@link Font#getBaselineFor(char)}
+   *
+   * @param font the font this peer is being called from. This may be
+   * useful if you are sharing peers between Font objects. Otherwise it may
+   * be ignored.
+   */
+  public byte getBaselineFor (Font font, char c)
+  {
+    throw new UnsupportedOperationException ();
+  }
+  
+  /**
+   * Implementation of {@link Font#getFontMetrics()}
+   *
+   * @param font the font this peer is being called from. This may be
+   * useful if you are sharing peers between Font objects. Otherwise it may
+   * be ignored.
+   */
+  public FontMetrics getFontMetrics (Font font)
+  {
+    throw new UnsupportedOperationException ();
+  }
+  
+  /** Returns a name for the specified glyph. This is useful for
+   * generating PostScript or PDF files that embed some glyphs of a
+   * font. If the implementation follows glyph naming conventions
+   * specified by Adobe, search engines can extract the original text
+   * from the generated PostScript and PDF files.
+   *
+   * <p>This method is currently not used by GNU Classpath. However,
+   * it would be very useful for someone wishing to write a good
+   * PostScript or PDF stream provider for the
+   * <code>javax.print</code> package.
+   *
+   * <p><b>Names are not unique:</b> Under some rare circumstances,
+   * the same name can be returned for different glyphs. It is
+   * therefore recommended that printer drivers check whether the same
+   * name has already been returned for antoher glyph, and make the
+   * name unique by adding the string ".alt" followed by the glyph
+   * index.</p>
+   *
+   * <p>This situation would occur for an OpenType or TrueType font
+   * that has a <code>post</code> table of format 3 and provides a
+   * mapping from glyph IDs to Unicode sequences through a
+   * <code>Zapf</code> table. If the same sequence of Unicode
+   * codepoints leads to different glyphs (depending on contextual
+   * position, for example, or on typographic sophistication level),
+   * the same name would get synthesized for those glyphs. To avoid
+   * this, the font peer would have to go through the names of all
+   * glyphs, which would make this operation very inefficient with
+   * large fonts.
+   *
+   * @param font the font containing the glyph whose name is
+   * requested.
+   *
+   * @param glyphIndex the glyph whose name the caller wants to
+   * retrieve.
+   *
+   * @return the glyph name, or <code>null</code> if a font does not
+   * provide glyph names.
+   */
+  public String getGlyphName (Font font, int glyphIndex)
+  {
+    throw new UnsupportedOperationException ();
+  }
+  
+  /**
+   * Implementation of {@link Font#getLineMetrics(CharacterIterator, int,
+   * int, FontRenderContext)}
+   *
+   * @param font the font this peer is being called from. This may be
+   * useful if you are sharing peers between Font objects. Otherwise it may
+   * be ignored.
+   */
+  public LineMetrics getLineMetrics (Font font, CharacterIterator ci, int begin, int limit, FontRenderContext rc)
+  {
+    throw new UnsupportedOperationException ();
+  }
+  
+  /**
+   * Implementation of {@link Font#getMaxCharBounds(FontRenderContext)}
+   *
+   * @param font the font this peer is being called from. This may be
+   * useful if you are sharing peers between Font objects. Otherwise it may
+   * be ignored.
+   */
+  public Rectangle2D getMaxCharBounds (Font font, FontRenderContext rc)
+  {
+    throw new UnsupportedOperationException ();
+  }
+  
+  /**
+   * Implementation of {@link Font#getMissingGlyphCode()}
+   *
+   * @param font the font this peer is being called from. This may be
+   * useful if you are sharing peers between Font objects. Otherwise it may
+   * be ignored.
+   */
+  public int getMissingGlyphCode (Font font)
+  {
+    throw new UnsupportedOperationException ();
+  }
+  
+  /**
+   * Implementation of {@link Font#getNumGlyphs()}
+   *
+   * @param font the font this peer is being called from. This may be
+   * useful if you are sharing peers between Font objects. Otherwise it may
+   * be ignored.
+   */
+  public int getNumGlyphs (Font font)
+  {
+    throw new UnsupportedOperationException ();
+  }
+  
+  /**
+   * Implementation of {@link Font#getPSName()}
+   *
+   * @param font the font this peer is being called from. This may be
+   * useful if you are sharing peers between Font objects. Otherwise it may
+   * be ignored.
+   */
+  public String getPostScriptName (Font font)
+  {
+    throw new UnsupportedOperationException ();
+  }
+  
+  /**
+   * Implementation of {@link Font#getStringBounds(CharacterIterator, int,
+   * int, FontRenderContext)}
+   *
+   * @param font the font this peer is being called from. This may be
+   * useful if you are sharing peers between Font objects. Otherwise it may
+   * be ignored.
+   */
+  public Rectangle2D getStringBounds (Font font, CharacterIterator ci, int begin, int limit, FontRenderContext frc)
+  {
+    throw new UnsupportedOperationException ();
+  }
+  
+  /** Returns the name of this font face inside the family, for example
+   * <i>&#x201c;Light&#x201d;</i>.
+   *
+   * <p>This method is currently not used by {@link Font}. However,
+   * this name would be needed by any serious desktop publishing
+   * application.
+   *
+   * @param font the font whose sub-family name is requested.
+   *
+   * @param locale the locale for which to localize the name.  If
+   * <code>locale</code> is <code>null</code>, the returned name is
+   * localized to the user&#x2019;s default locale.
+   *
+   * @return the name of the face inside its family, or
+   * <code>null</code> if the font does not provide a sub-family name.
+   */
+  public String getSubFamilyName (Font font, Locale locale)
+  {
+    throw new UnsupportedOperationException ();
+  }
+  
+  /**
+   * Implementation of {@link Font#hasUniformLineMetrics()}
+   *
+   * @param font the font this peer is being called from. This may be
+   * useful if you are sharing peers between Font objects. Otherwise it may
+   * be ignored.
+   */
+  public boolean hasUniformLineMetrics (Font font)
+  {
+    throw new UnsupportedOperationException ();
+  }
+  
+  /**
+   * Implementation of {@link Font#layoutGlyphVector(FontRenderContext,
+   * char[], int, int, int)}.
+   *
+   * @param font the font object that the created GlyphVector will return
+   * when it gets asked for its font. This argument is needed because the
+   * public API of {@link GlyphVector} works with {@link java.awt.Font},
+   * not with font peers.
+   */
+  public GlyphVector layoutGlyphVector (Font font, FontRenderContext frc, char[] chars, int start, int limit, int flags)
+  {
+    throw new UnsupportedOperationException ();
+  }
+}
diff --git a/libjava/gnu/awt/xlib/XGraphics.java b/libjava/gnu/awt/xlib/XGraphics.java
index e27b0a1..0e14e25b 100644
--- a/libjava/gnu/awt/xlib/XGraphics.java
+++ b/libjava/gnu/awt/xlib/XGraphics.java
@@ -98,10 +98,13 @@ public class XGraphics implements Cloneable, DirectRasterGraphics
     
   public void setFont(Font font)
   {
-    if ((metrics != null) && font.equals(metrics.getFont())) return;
-
+    if (font == null)
+      return;
+    if ((metrics != null) && font.equals(metrics.getFont()))
+      return;
     metrics = config.getXFontMetrics(font);
-    context.setFont(metrics.xfont);
+    if (metrics != null)
+      context.setFont(metrics.xfont);
   }
     
   public FontMetrics getFontMetrics(Font font)
@@ -130,12 +133,15 @@ public class XGraphics implements Cloneable, DirectRasterGraphics
        expose. */
     Rectangle newClipBounds = clip.getBounds();
     
+    /* FIXME: decide whether this test code is worth anything
+     * (as of 2004-01-29, it prints frequently)
     if ((clipBounds != null) && !clipBounds.contains(newClipBounds))
       {
 	System.err.println("warning: old clip ("+ clipBounds +") does " +
 			   "not fully contain new clip (" +
 			   newClipBounds + ")");
       }
+     */
     clipBounds = newClipBounds;
     Rectangle[] rects = { clipBounds };
     context.setClipRectangles(rects);
diff --git a/libjava/gnu/awt/xlib/XToolkit.java b/libjava/gnu/awt/xlib/XToolkit.java
index 3da993f..1856d97 100644
--- a/libjava/gnu/awt/xlib/XToolkit.java
+++ b/libjava/gnu/awt/xlib/XToolkit.java
@@ -11,20 +11,23 @@ package gnu.awt.xlib;
 import java.awt.*;
 import java.awt.dnd.*;
 import java.awt.dnd.peer.*;
+import java.awt.font.*;
 import java.awt.im.*;
 import java.awt.peer.*;
 import java.awt.image.ImageProducer;
 import java.awt.image.ImageObserver;
 import java.net.*;
 import java.awt.datatransfer.Clipboard;
-import java.util.Properties;
+import java.io.InputStream;
 import java.util.Map;
-
+import java.util.Properties;
 import gnu.gcj.xlib.Display;
 import gnu.gcj.xlib.Screen;
 import gnu.gcj.xlib.Visual;
+import gnu.java.awt.ClasspathToolkit;
+import gnu.java.awt.peer.ClasspathFontPeer;
 
-public class XToolkit extends Toolkit
+public class XToolkit extends ClasspathToolkit
 {
   static XToolkit INSTANCE;
   
@@ -158,7 +161,7 @@ public class XToolkit extends Toolkit
 
   protected java.awt.peer.FontPeer getFontPeer(String name, int style) 
   {
-    return null;
+    return new XFontPeer (name,style);
   }
 
   public Dimension getScreenSize()
@@ -345,4 +348,87 @@ public class XToolkit extends Toolkit
   {
     throw new UnsupportedOperationException("not implemented");
   }
+  
+  /** Returns a shared instance of the local, platform-specific
+   * graphics environment.
+   *
+   * <p>This method is specific to GNU Classpath. It gets called by
+   * the Classpath implementation of {@link
+   * GraphicsEnvironment.getLocalGraphcisEnvironment()}.
+   */
+  public GraphicsEnvironment getLocalGraphicsEnvironment ()
+  {
+    throw new java.lang.UnsupportedOperationException ();
+  }
+  
+  /** Acquires an appropriate {@link ClasspathFontPeer}, for use in
+   * classpath's implementation of {@link java.awt.Font}.
+   *
+   * @param name The logical name of the font. This may be either a face
+   * name or a logical font name, or may even be null. A default
+   * implementation of name decoding is provided in
+   * {@link ClasspathFontPeer}, but may be overridden in other toolkits.
+   *
+   * @param attrs Any extra {@link java.awt.font.TextAttribute} attributes
+   * this font peer should have, such as size, weight, family name, or
+   * transformation.
+   */
+  public ClasspathFontPeer getClasspathFontPeer (String name, Map attrs)
+  {
+    int style = Font.PLAIN;
+    float size = 12;
+
+    if (attrs.containsKey (TextAttribute.WEIGHT))
+      {
+        Float weight = (Float) attrs.get (TextAttribute.WEIGHT);
+        if (weight.floatValue () >= TextAttribute.WEIGHT_BOLD.floatValue ())
+          style += Font.BOLD;
+      }
+
+    if (attrs.containsKey (TextAttribute.POSTURE))
+      {
+        Float posture = (Float) attrs.get (TextAttribute.POSTURE);
+        if (posture.floatValue () >= TextAttribute.POSTURE_OBLIQUE.floatValue ())
+          style += Font.ITALIC;
+      }
+
+    if (attrs.containsKey (TextAttribute.SIZE))
+      {
+        Float fsize = (Float) attrs.get (TextAttribute.SIZE);
+        size = fsize.floatValue ();
+      }
+
+    return new XFontPeer (name,style,size);
+  }
+  
+  /** Creates a font, reading the glyph definitions from a stream.
+   *
+   * <p>This method provides the platform-specific implementation for
+   * the static factory method {@link Font#createFont(int,
+   * java.io.InputStream)}.
+   *
+   * @param format the format of the font data, such as {@link
+   * Font#TRUETYPE_FONT}. An implementation may ignore this argument
+   * if it is able to automatically recognize the font format from the
+   * provided data.
+   *
+   * @param stream an input stream from where the font data is read
+   * in. The stream will be advanced to the position after the font
+   * data, but not closed.
+   *
+   * @throws IllegalArgumentException if <code>format</code> is
+   * not supported.
+   *
+   * @throws FontFormatException if <code>stream</code> does not
+   * contain data in the expected format, or if required tables are
+   * missing from a font.
+   *
+   * @throws IOException if a problem occurs while reading in the
+   * contents of <code>stream</code>.
+   */
+  public Font createFont (int format, InputStream stream)
+  {
+    throw new java.lang.UnsupportedOperationException ();
+  }
+  
 }