libjava/classpath/gnu/java/awt/peer/gtk/GdkFontPeer.java

   1 /* GdkFontPeer.java -- Implements FontPeer with GTK+
   2    Copyright (C) 1999, 2004, 2005, 2006  Free Software Foundation, Inc.
   3
   4 This file is part of GNU Classpath.
   5
   6 GNU Classpath is free software; you can redistribute it and/or modify
   7 it under the terms of the GNU General Public License as published by
   8 the Free Software Foundation; either version 2, or (at your option)
   9 any later version.
  10
  11 GNU Classpath is distributed in the hope that it will be useful, but
  12 WITHOUT ANY WARRANTY; without even the implied warranty of
  13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14 General Public License for more details.
  15
  16 You should have received a copy of the GNU General Public License
  17 along with GNU Classpath; see the file COPYING.  If not, write to the
  18 Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
  19 02110-1301 USA.
  20
  21 Linking this library statically or dynamically with other modules is
  22 making a combined work based on this library.  Thus, the terms and
  23 conditions of the GNU General Public License cover the whole
  24 combination.
  25
  26 As a special exception, the copyright holders of this library give you
  27 permission to link this library with independent modules to produce an
  28 executable, regardless of the license terms of these independent
  29 modules, and to copy and distribute the resulting executable under
  30 terms of your choice, provided that you also meet, for each linked
  31 independent module, the terms and conditions of the license of that
  32 module.  An independent module is a module which is not derived from
  33 or based on this library.  If you modify this library, you may extend
  34 this exception to your version of the library, but you are not
  35 obligated to do so.  If you do not wish to do so, delete this
  36 exception statement from your version. */
  37
  38
  39 package gnu.java.awt.peer.gtk;
  40
  41 import gnu.classpath.Configuration;
  42 import gnu.classpath.Pointer;
  43
  44 import gnu.java.awt.ClasspathToolkit;
  45 import gnu.java.awt.peer.ClasspathFontPeer;
  46 import gnu.java.awt.font.opentype.NameDecoder;
  47
  48 import gnu.java.lang.CPStringBuilder;
  49
  50 import java.awt.Font;
  51 import java.awt.FontMetrics;
  52 import java.awt.Toolkit;
  53 import java.awt.font.FontRenderContext;
  54 import java.awt.font.GlyphVector;
  55 import java.awt.font.GlyphMetrics;
  56 import java.awt.font.LineMetrics;
  57 import java.awt.font.TextLayout;
  58 import java.awt.geom.Rectangle2D;
  59 import java.text.CharacterIterator;
  60 import java.util.Locale;
  61 import java.util.Map;
  62 import java.nio.ByteBuffer;
  63 import java.util.HashMap;
  64
  65 public class GdkFontPeer extends ClasspathFontPeer
  66 {
  67   static final FontRenderContext DEFAULT_CTX =
  68     new FontRenderContext(null, false, false);
  69
  70   /**
  71    * Caches TextLayout instances for use in charsWidth() and drawString().
  72    * The size of the cache has been chosen so that relativly large GUIs with
  73    * text documents are still efficient.
  74    */
  75   HashMap<String,TextLayout> textLayoutCache = new GtkToolkit.LRUCache<String,TextLayout>(500);
  76
  77   private class GdkFontMetrics extends FontMetrics
  78   {
  79
  80     public GdkFontMetrics (Font font)
  81     {
  82       super(initFont(font));
  83     }
  84
  85     public int stringWidth (String str)
  86     {
  87       TextLayout tl = textLayoutCache.get(str);
  88       if (tl == null)
  89         {
  90           tl = new TextLayout(str, font, DEFAULT_CTX);
  91           textLayoutCache.put(str, tl);
  92         }
  93       return (int) tl.getAdvance();
  94     }
  95
  96     public int charWidth (char ch)
  97     {
  98       return stringWidth (new String (new char[] { ch }));
  99     }
 100
 101     public int charsWidth (char data[], int off, int len)
 102     {
 103       return stringWidth (new String (data, off, len));
 104     }
 105
 106     public int getHeight()
 107     {
 108       return (int) height;
 109     }
 110
 111     public int getLeading ()
 112     {
 113       return (int) (height - (ascent + descent));
 114     }
 115
 116     public int getAscent ()
 117     {
 118       return (int) ascent;
 119     }
 120
 121     public int getMaxAscent ()
 122     {
 123       return (int) ascent;
 124     }
 125
 126     public int getDescent ()
 127     {
 128       return (int) descent;
 129     }
 130
 131     public int getMaxDescent ()
 132     {
 133       return (int) maxDescent;
 134     }
 135
 136     public int getMaxAdvance ()
 137     {
 138       return (int) maxAdvance;
 139     }
 140   }
 141
 142   static native void initStaticState();
 143   private final int native_state = GtkGenericPeer.getUniqueInteger ();
 144
 145   /**
 146    * Cache GlyphMetrics objects.
 147    */
 148   private HashMap<Integer,GlyphMetrics> metricsCache;
 149
 150   private static final int FONT_METRICS_ASCENT = 0;
 151   private static final int FONT_METRICS_MAX_ASCENT = 1;
 152   private static final int FONT_METRICS_DESCENT = 2;
 153   private static final int FONT_METRICS_MAX_DESCENT = 3;
 154   private static final int FONT_METRICS_MAX_ADVANCE = 4;
 155   private static final int FONT_METRICS_HEIGHT = 5;
 156   private static final int FONT_METRICS_UNDERLINE_OFFSET = 6;
 157   private static final int FONT_METRICS_UNDERLINE_THICKNESS = 7;
 158
 159   float ascent;
 160   float descent;
 161   float maxAscent;
 162   float maxDescent;
 163   float maxAdvance;
 164   float height;
 165   float underlineOffset;
 166   float underlineThickness;
 167
 168   GdkFontMetrics metrics;
 169
 170   static
 171   {
 172     if (true) // GCJ LOCAL
 173       {
 174         System.loadLibrary("gtkpeer");
 175       }
 176
 177     initStaticState ();
 178
 179   }
 180
 181   private ByteBuffer nameTable = null;
 182
 183   /**
 184    * The pointer to the native font data.
 185    *
 186    * This field is manipulated by native code. Don't change or remove
 187    * without adjusting the native code.
 188    */
 189   private Pointer nativeFont;
 190
 191   private native void initState ();
 192   private native void dispose ();
 193   private native void setFont (String family, int style, int size);
 194
 195   native synchronized void getFontMetrics(double [] metrics);
 196   native synchronized void getTextMetrics(String str, double [] metrics);
 197
 198   native void releasePeerGraphicsResource();
 199
 200
 201   protected void finalize ()
 202   {
 203     releasePeerGraphicsResource();
 204     dispose ();
 205   }
 206
 207   /*
 208    * Helpers for the 3-way overloading that this class seems to suffer
 209    * from. Remove them if you feel like they're a performance bottleneck,
 210    * for the time being I prefer my code not be written and debugged in
 211    * triplicate.
 212    */
 213
 214   private String buildString(CharacterIterator iter)
 215   {
 216     CPStringBuilder sb = new CPStringBuilder();
 217     for(char c = iter.first(); c != CharacterIterator.DONE; c = iter.next())
 218       sb.append(c);
 219     return sb.toString();
 220   }
 221
 222   private String buildString(CharacterIterator iter, int begin, int limit)
 223   {
 224     CPStringBuilder sb = new CPStringBuilder();
 225     int i = 0;
 226     for(char c = iter.first(); c != CharacterIterator.DONE; c = iter.next(), i++)
 227       {
 228         if (begin <= i)
 229           sb.append(c);
 230         if (limit <= i)
 231           break;
 232       }
 233     return sb.toString();
 234   }
 235
 236   private String buildString(char[] chars, int begin, int limit)
 237   {
 238     return new String(chars, begin, limit - begin);
 239   }
 240
 241   /* Public API */
 242
 243   public GdkFontPeer (String name, int style)
 244   {
 245     // All fonts get a default size of 12 if size is not specified.
 246     this(name, style, 12);
 247   }
 248
 249   public GdkFontPeer (String name, int style, int size)
 250   {
 251     super(name, style, size);
 252     initState ();
 253     setFont (this.familyName, this.style, (int)this.size);
 254     metricsCache = new HashMap<Integer,GlyphMetrics>();
 255     setupMetrics();
 256   }
 257
 258   public GdkFontPeer (String name, Map attributes)
 259   {
 260     super(name, attributes);
 261     initState ();
 262     setFont (this.familyName, this.style, (int)this.size);
 263     metricsCache = new HashMap<Integer,GlyphMetrics>();
 264     setupMetrics();
 265   }
 266
 267
 268   /**
 269    * Makes sure to return a Font based on the given Font that has as
 270    * peer a GdkFontPeer. Used in the initializer.
 271    */
 272   static Font initFont(Font font)
 273   {
 274     if (font == null)
 275       return new Font("Dialog", Font.PLAIN, 12);
 276     else if (font.getPeer() instanceof GdkFontPeer)
 277       return font;
 278     else
 279       {
 280         ClasspathToolkit toolkit;
 281         toolkit = (ClasspathToolkit) Toolkit.getDefaultToolkit();
 282         return toolkit.getFont(font.getName(), font.getAttributes());
 283       }
 284   }
 285
 286   private void setupMetrics()
 287   {
 288     double [] hires = new double[8];
 289     getFontMetrics(hires);
 290     ascent = (float) hires[FONT_METRICS_ASCENT];
 291     maxAscent = (float) hires[FONT_METRICS_MAX_ASCENT];
 292     descent = (float) hires[FONT_METRICS_DESCENT];
 293     maxDescent = (float) hires[FONT_METRICS_MAX_DESCENT];
 294     maxAdvance = (float) hires[FONT_METRICS_MAX_ADVANCE];
 295     height = (float) hires[FONT_METRICS_HEIGHT];
 296     underlineOffset = (float) hires[FONT_METRICS_UNDERLINE_OFFSET];
 297     underlineThickness = (float) hires[FONT_METRICS_UNDERLINE_THICKNESS];
 298   }
 299
 300   /**
 301    * Unneeded, but implemented anyway.
 302    */
 303   public String getSubFamilyName(Font font, Locale locale)
 304   {
 305     String name;
 306
 307     if (locale == null)
 308       locale = Locale.getDefault();
 309
 310     name = getName(NameDecoder.NAME_SUBFAMILY, locale);
 311     if (name == null)
 312       {
 313         name = getName(NameDecoder.NAME_SUBFAMILY, Locale.ENGLISH);
 314         if ("Regular".equals(name))
 315           name = null;
 316       }
 317
 318     return name;
 319   }
 320
 321   /**
 322    * Returns the bytes belonging to a TrueType/OpenType table,
 323    * Parameters n,a,m,e identify the 4-byte ASCII tag of the table.
 324    *
 325    * Returns null if the font is not TT, the table is nonexistant,
 326    * or if some other unexpected error occured.
 327    *
 328    */
 329   private native byte[] getTrueTypeTable(byte n, byte a, byte m, byte e);
 330
 331   /**
 332    * Returns the PostScript name of the font, defaults to the familyName if
 333    * a PS name could not be retrieved.
 334    */
 335   public String getPostScriptName(Font font)
 336   {
 337     String name = getName(NameDecoder.NAME_POSTSCRIPT,
 338                           /* any language */ null);
 339     if( name == null )
 340       return this.familyName;
 341
 342     return name;
 343   }
 344
 345   /**
 346    * Extracts a String from the font&#x2019;s name table.
 347    *
 348    * @param name the numeric TrueType or OpenType name ID.
 349    *
 350    * @param locale the locale for which names shall be localized, or
 351    * <code>null</code> if the locale does mot matter because the name
 352    * is known to be language-independent (for example, because it is
 353    * the PostScript name).
 354    */
 355   private String getName(int name, Locale locale)
 356   {
 357     if (nameTable == null)
 358       {
 359         byte[] data = getTrueTypeTable((byte)'n', (byte) 'a',
 360                                        (byte) 'm', (byte) 'e');
 361         if( data == null )
 362           return null;
 363
 364         nameTable = ByteBuffer.wrap( data );
 365       }
 366
 367     return NameDecoder.getName(nameTable, name, locale);
 368   }
 369
 370   public boolean canDisplay (Font font, int c)
 371   {
 372     // FIXME: inquire with pango
 373     return true;
 374   }
 375
 376   public int canDisplayUpTo (Font font, CharacterIterator i, int start, int limit)
 377   {
 378     // FIXME: inquire with pango
 379     return -1;
 380   }
 381
 382   public GlyphVector createGlyphVector (Font font,
 383                                         FontRenderContext ctx,
 384                                         CharacterIterator i)
 385   {
 386     return new FreetypeGlyphVector(font, buildString (i), ctx);
 387   }
 388
 389   public GlyphVector createGlyphVector (Font font,
 390                                         FontRenderContext ctx,
 391                                         int[] glyphCodes)
 392   {
 393     return new FreetypeGlyphVector(font, glyphCodes, ctx);
 394   }
 395
 396   public byte getBaselineFor (Font font, char c)
 397   {
 398     // FIXME: Actually check.
 399     return Font.ROMAN_BASELINE;
 400   }
 401
 402   private class GdkFontLineMetrics extends LineMetrics
 403   {
 404     private int nchars;
 405     public GdkFontLineMetrics (GdkFontPeer fp, int n)
 406     {
 407       nchars = n;
 408     }
 409
 410     public float getAscent()
 411     {
 412       return ascent;
 413     }
 414
 415     public int getBaselineIndex()
 416     {
 417       // FIXME
 418       return Font.ROMAN_BASELINE;
 419     }
 420
 421     public float[] getBaselineOffsets()
 422     {
 423       return new float[3];
 424     }
 425
 426     public float getDescent()
 427     {
 428       return descent;
 429     }
 430
 431     public float getHeight()
 432     {
 433       return height;
 434     }
 435
 436     public float getLeading()
 437     {
 438       return height - (ascent + descent);
 439     }
 440
 441     public int getNumChars()
 442     {
 443       return nchars;
 444     }
 445
 446     public float getStrikethroughOffset()
 447     {
 448       // FreeType doesn't seem to provide a value here.
 449       return ascent / 2;
 450     }
 451
 452     public float getStrikethroughThickness()
 453     {
 454       // FreeType doesn't seem to provide a value here.
 455       return 1.f;
 456     }
 457
 458     public float getUnderlineOffset()
 459     {
 460       return underlineOffset;
 461     }
 462
 463     public float getUnderlineThickness()
 464     {
 465       return underlineThickness;
 466     }
 467
 468   }
 469
 470   public LineMetrics getLineMetrics (Font font, CharacterIterator ci,
 471                                      int begin, int limit, FontRenderContext rc)
 472   {
 473     return new GdkFontLineMetrics (this, limit - begin);
 474   }
 475
 476   public Rectangle2D getMaxCharBounds (Font font, FontRenderContext rc)
 477   {
 478     throw new UnsupportedOperationException ();
 479   }
 480
 481   public int getMissingGlyphCode (Font font)
 482   {
 483     throw new UnsupportedOperationException ();
 484   }
 485
 486   public String getGlyphName (Font font, int glyphIndex)
 487   {
 488     throw new UnsupportedOperationException ();
 489   }
 490
 491   public int getNumGlyphs (Font font)
 492   {
 493     byte[] data = getTrueTypeTable((byte)'m', (byte) 'a',
 494                                    (byte)'x', (byte) 'p');
 495     if( data == null )
 496       return -1;
 497
 498     ByteBuffer buf = ByteBuffer.wrap( data );
 499     return buf.getShort(4);
 500   }
 501
 502   public boolean hasUniformLineMetrics (Font font)
 503   {
 504     return true;
 505   }
 506
 507   public GlyphVector layoutGlyphVector (Font font, FontRenderContext frc,
 508                                         char[] chars, int start, int limit,
 509                                         int flags)
 510   {
 511     return new FreetypeGlyphVector(font, chars, start, limit - start,
 512                                    frc, flags);
 513   }
 514
 515   public LineMetrics getLineMetrics (Font font, String str,
 516                                      FontRenderContext frc)
 517   {
 518     return new GdkFontLineMetrics (this, str.length ());
 519   }
 520
 521   public FontMetrics getFontMetrics (Font font)
 522   {
 523     if (metrics == null)
 524       metrics = new GdkFontMetrics(font);
 525     return metrics;
 526   }
 527
 528   /**
 529    * Returns a cached GlyphMetrics object for a given glyphcode,
 530    * or null if it doesn't exist in the cache.
 531    */
 532   GlyphMetrics getGlyphMetrics( int glyphCode )
 533   {
 534     return metricsCache.get(new Integer(glyphCode));
 535   }
 536
 537   /**
 538    * Put a GlyphMetrics object in the cache.
 539    */
 540   void putGlyphMetrics( int glyphCode, GlyphMetrics metrics )
 541   {
 542     metricsCache.put( new Integer( glyphCode ), metrics );
 543   }
 544
 545 }