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