Source for gnu.java.awt.peer.ClasspathFontPeer

   1: /* ClasspathFontPeer.java -- Font peer used by GNU Classpath.
   2:    Copyright (C) 2003, 2004 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;
  40: 
  41: import gnu.java.awt.ClasspathToolkit;
  42: 
  43: import java.awt.Font;
  44: import java.awt.FontMetrics;
  45: import java.awt.Toolkit;
  46: import java.awt.font.FontRenderContext;
  47: import java.awt.font.GlyphVector;
  48: import java.awt.font.LineMetrics;
  49: import java.awt.font.TextAttribute;
  50: import java.awt.font.TransformAttribute;
  51: import java.awt.geom.AffineTransform;
  52: import java.awt.geom.Rectangle2D;
  53: import java.awt.peer.FontPeer;
  54: import java.text.AttributedCharacterIterator;
  55: import java.text.CharacterIterator;
  56: import java.util.HashMap;
  57: import java.util.Locale;
  58: import java.util.Map;
  59: 
  60: /**
  61:  * A peer for fonts that are used inside Classpath. The purpose of
  62:  * this interface is to abstract from platform-specific font handling
  63:  * in the Classpath implementation of java.awt.Font and related
  64:  * classes.
  65:  *
  66:  * <p><b>State kept by the peer:</b> a peer is generated for each Font
  67:  * object in the default implementation. If you wish to share peers between
  68:  * fonts, you will need to subclass both ClasspathFontPeer and
  69:  * {@link ClasspathToolKit}.</p>
  70:  * 
  71:  * <p><b>Thread Safety:</b> Methods of this interface may be called
  72:  * from arbitrary threads at any time. Implementations of the
  73:  * <code>ClasspathFontPeer</code> interface are required to perform
  74:  * the necessary synchronization.</p>
  75:  *
  76:  * @see java.awt.Font#getPeer
  77:  * @see java.awt.Toolkit#getFontPeer
  78:  *
  79:  * @author Sascha Brawer (brawer@dandelis.ch)
  80:  * @author Graydon Hoare (graydon@redhat.com)
  81:  */
  82: public abstract class ClasspathFontPeer
  83:   implements FontPeer
  84: {
  85: 
  86:   /*************************************************************************/
  87:   
  88:   /*
  89:    * Instance Variables
  90:    */
  91:   
  92:   /**
  93:    * The 3 names of this font. all fonts have 3 names, some of which
  94:    * may be equal:
  95:    *
  96:    * logical -- name the font was constructed from
  97:    * family  -- a designer or brand name (Helvetica)
  98:    * face -- specific instance of a design (Helvetica Regular)
  99:    *
 100:    * @see isLogicalFontName 
 101:    */
 102:   
 103:   protected String logicalName;
 104:   protected String familyName;
 105:   protected String faceName;
 106:   
 107:   /**
 108:    * The font style, which is a combination (by OR-ing) of the font style
 109:    * constants PLAIN, BOLD and ITALIC, in this class.
 110:    */
 111:   protected int style;
 112:   
 113:   /**
 114:    * The font point size. A point is 1/72 of an inch.
 115:    */
 116:   protected float size;
 117: 
 118:   /**
 119:    * The affine transformation the font is currently subject to.
 120:    */
 121:   protected AffineTransform transform;
 122: 
 123:   protected static ClasspathToolkit tk()
 124:   {
 125:     return (ClasspathToolkit)(Toolkit.getDefaultToolkit ());
 126:   }
 127: 
 128:   /* 
 129:    * Confusingly, a Logical Font is a concept unrelated to
 130:    * a Font's Logical Name. 
 131:    *
 132:    * A Logical Font is one of 6 built-in, abstract font types
 133:    * which must be supported by any java environment: SansSerif,
 134:    * Serif, Monospaced, Dialog, and DialogInput. 
 135:    *
 136:    * A Font's Logical Name is the name the font was constructed
 137:    * from. This might be the name of a Logical Font, or it might
 138:    * be the name of a Font Face.
 139:    */
 140: 
 141:   protected static boolean isLogicalFontName(String name)
 142:   {
 143:     String uname = name.toUpperCase ();
 144:     return (uname.equals ("SANSSERIF") ||
 145:             uname.equals ("SERIF") ||
 146:             uname.equals ("MONOSPACED") ||
 147:             uname.equals ("DIALOG") ||
 148:             uname.equals ("DIALOGINPUT"));
 149:   }
 150: 
 151:   protected static String logicalFontNameToFaceName (String name)
 152:   {
 153:     String uname = name.toUpperCase ();
 154:     if (uname.equals("SANSSERIF"))
 155:       return "Helvetica";
 156:     else if (uname.equals ("SERIF"))
 157:       return "Times";
 158:     else if (uname.equals ("MONOSPACED"))
 159:       return "Courier";
 160:     else if (uname.equals ("DIALOG"))
 161:       return "Helvetica";
 162:     else if (uname.equals ("DIALOGINPUT"))
 163:       return "Helvetica";
 164:     else
 165:       return "Helvetica";
 166:   }
 167: 
 168:   protected static String faceNameToFamilyName (String name)
 169:   {
 170:     return name;
 171:   }
 172: 
 173:   public static void copyStyleToAttrs (int style, Map attrs)
 174:   {
 175:     if ((style & Font.BOLD) == Font.BOLD)
 176:       attrs.put (TextAttribute.WEIGHT, TextAttribute.WEIGHT_BOLD);
 177:     else
 178:       attrs.put (TextAttribute.WEIGHT, TextAttribute.WEIGHT_REGULAR);
 179: 
 180:     if ((style & Font.ITALIC) == Font.ITALIC)
 181:       attrs.put (TextAttribute.POSTURE, TextAttribute.POSTURE_OBLIQUE);
 182:     else
 183:       attrs.put (TextAttribute.POSTURE, TextAttribute.POSTURE_REGULAR);
 184:   }
 185: 
 186:   protected static void copyFamilyToAttrs (String fam, Map attrs)
 187:   {
 188:     if (fam != null)
 189:       attrs.put (TextAttribute.FAMILY, fam);
 190:   }
 191:   
 192:   public static void copySizeToAttrs (float size, Map attrs)
 193:   {
 194:     attrs.put (TextAttribute.SIZE, new Float (size));
 195:   }
 196:   
 197:   protected static void copyTransformToAttrs (AffineTransform trans, Map attrs)
 198:   {
 199:     if (trans != null)
 200:       attrs.put(TextAttribute.TRANSFORM, new TransformAttribute (trans));
 201:   }
 202: 
 203: 
 204:   protected void setStandardAttributes (String name, String family, int style, 
 205:                                         float size, AffineTransform trans)
 206:   {
 207:     this.logicalName = name;
 208: 
 209:     if (isLogicalFontName (name))
 210:       this.faceName = logicalFontNameToFaceName (name);
 211:     else
 212:       this.faceName = name;
 213: 
 214:     if (family != null)
 215:       this.familyName = family;
 216:     else
 217:       this.familyName = faceNameToFamilyName (faceName);
 218:     
 219:     this.style = style;
 220:     this.size = size;
 221:     this.transform = trans;
 222:   }
 223: 
 224: 
 225:   protected void setStandardAttributes (String name, Map attribs)
 226:   {
 227:     String family = this.familyName;
 228:     AffineTransform trans = this.transform;
 229:     float size = this.size;
 230:     int style = this.style;
 231: 
 232:     if (attribs.containsKey (TextAttribute.FAMILY))
 233:       family = (String) attribs.get (TextAttribute.FAMILY);
 234: 
 235:     if (name == null)
 236:       name = "SansSerif";
 237: 
 238:     if (attribs.containsKey (TextAttribute.WEIGHT))
 239:       {
 240:         Float weight = (Float) attribs.get (TextAttribute.WEIGHT);
 241:         if (weight.floatValue () >= TextAttribute.WEIGHT_BOLD.floatValue ())
 242:           style += Font.BOLD;
 243:       }
 244: 
 245:     if (attribs.containsKey (TextAttribute.POSTURE))
 246:       {
 247:         Float posture = (Float) attribs.get (TextAttribute.POSTURE);
 248:         if (posture.floatValue () >= TextAttribute.POSTURE_OBLIQUE.floatValue ())
 249:           style += Font.ITALIC;
 250:       }
 251: 
 252:     if (attribs.containsKey (TextAttribute.SIZE))
 253:       {
 254:         Float sz = (Float) attribs.get (TextAttribute.SIZE);
 255:         size = sz.floatValue ();
 256: 
 257:         // Pango doesn't accept 0 as a font size.
 258:         if (size < 1)
 259:           size = 1;
 260:       }
 261:     else
 262:       size = 12;
 263: 
 264:     if (attribs.containsKey (TextAttribute.TRANSFORM))
 265:       {
 266:         TransformAttribute ta = (TransformAttribute) 
 267:           attribs.get(TextAttribute.TRANSFORM);
 268:         trans = ta.getTransform ();        
 269:       }
 270: 
 271:     setStandardAttributes (name, family, style, size, trans);
 272:   }
 273: 
 274:   protected void getStandardAttributes (Map attrs)
 275:   {    
 276:     copyFamilyToAttrs (this.familyName, attrs);
 277:     copySizeToAttrs (this.size, attrs);
 278:     copyStyleToAttrs (this.style, attrs);
 279:     copyTransformToAttrs (this.transform, attrs);
 280:   }
 281: 
 282: 
 283:   /* Begin public API */
 284: 
 285:   public ClasspathFontPeer (String name, Map attrs)
 286:   {
 287:     setStandardAttributes (name, attrs);
 288:   }
 289: 
 290:   public ClasspathFontPeer (String name, int style, int size)
 291:   {
 292:     setStandardAttributes (name, (String)null, style, 
 293:                            (float)size, (AffineTransform)null);
 294:   }
 295: 
 296:   /** 
 297:    * Implementation of {@link Font#getName}
 298:    *
 299:    * @param font the font this peer is being called from. This may be
 300:    * useful if you are sharing peers between Font objects. Otherwise it may
 301:    * be ignored.
 302:    */
 303: 
 304:   public String getName (Font font) 
 305:   { 
 306:     return logicalName; 
 307:   }
 308: 
 309:   /** 
 310:    * Implementation of {@link Font#getFamily()}
 311:    *
 312:    * @param font the font this peer is being called from. This may be
 313:    * useful if you are sharing peers between Font objects. Otherwise it may
 314:    * be ignored.
 315:    */
 316: 
 317:   public String getFamily (Font font) 
 318:   { 
 319:     return familyName; 
 320:   }
 321: 
 322:   /** 
 323:    * Implementation of {@link Font#getFamily(Locale)}
 324:    *
 325:    * @param font the font this peer is being called from. This may be
 326:    * useful if you are sharing peers between Font objects. Otherwise it may
 327:    * be ignored.
 328:    */
 329: 
 330:   public String getFamily (Font font, Locale lc) 
 331:   { 
 332:     return familyName; 
 333:   }
 334: 
 335:   /** 
 336:    * Implementation of {@link Font#getFontName()}
 337:    *
 338:    * @param font the font this peer is being called from. This may be
 339:    * useful if you are sharing peers between Font objects. Otherwise it may
 340:    * be ignored.
 341:    */
 342: 
 343:   public String getFontName (Font font) 
 344:   { 
 345:     return faceName; 
 346:   }
 347: 
 348:   /** 
 349:    * Implementation of {@link Font#getFontName(Locale)}
 350:    *
 351:    * @param font the font this peer is being called from. This may be
 352:    * useful if you are sharing peers between Font objects. Otherwise it may
 353:    * be ignored.
 354:    */
 355: 
 356:   public String getFontName (Font font, Locale lc) 
 357:   { 
 358:     return faceName; 
 359:   }
 360: 
 361:   /** 
 362:    * Implementation of {@link Font#getSize}
 363:    *
 364:    * @param font the font this peer is being called from. This may be
 365:    * useful if you are sharing peers between Font objects. Otherwise it may
 366:    * be ignored.
 367:    */
 368: 
 369:   public float getSize (Font font) 
 370:   { 
 371:     return size; 
 372:   }
 373: 
 374:   /** 
 375:    * Implementation of {@link Font#isPlain}
 376:    *
 377:    * @param font the font this peer is being called from. This may be
 378:    * useful if you are sharing peers between Font objects. Otherwise it may
 379:    * be ignored.
 380:    */
 381:   
 382:   public boolean isPlain (Font font) 
 383:   { 
 384:     return style == Font.PLAIN; 
 385:   }
 386: 
 387:   /** 
 388:    * Implementation of {@link Font#isBold}
 389:    *
 390:    * @param font the font this peer is being called from. This may be
 391:    * useful if you are sharing peers between Font objects. Otherwise it may
 392:    * be ignored.
 393:    */
 394:   
 395:   public boolean isBold (Font font) 
 396:   { 
 397:     return ((style & Font.BOLD) == Font.BOLD); 
 398:   }
 399: 
 400:   /** 
 401:    * Implementation of {@link Font#isItalic}
 402:    *
 403:    * @param font the font this peer is being called from. This may be
 404:    * useful if you are sharing peers between Font objects. Otherwise it may
 405:    * be ignored.
 406:    */
 407: 
 408:   public boolean isItalic (Font font) 
 409:   { 
 410:     return ((style & Font.ITALIC) == Font.ITALIC); 
 411:   }
 412: 
 413:   /** 
 414:    * Implementation of {@link Font#deriveFont(int, float)}
 415:    *
 416:    * @param font the font this peer is being called from. This may be
 417:    * useful if you are sharing peers between Font objects. Otherwise it may
 418:    * be ignored.
 419:    */
 420: 
 421:   public Font deriveFont (Font font, int style, float size)
 422:   {
 423:     Map attrs = new HashMap ();
 424:     getStandardAttributes (attrs);
 425:     copyStyleToAttrs (style, attrs);
 426:     copySizeToAttrs (size, attrs);
 427:     return tk().getFont (logicalName, attrs);
 428:   }
 429: 
 430:   /** 
 431:    * Implementation of {@link Font#deriveFont(float)}
 432:    *
 433:    * @param font the font this peer is being called from. This may be
 434:    * useful if you are sharing peers between Font objects. Otherwise it may
 435:    * be ignored.
 436:    */
 437: 
 438:   public Font deriveFont (Font font, float size)
 439:   {
 440:     Map attrs = new HashMap ();
 441:     getStandardAttributes (attrs);
 442:     copySizeToAttrs (size, attrs);
 443:     return tk().getFont (logicalName, attrs);
 444:   }
 445: 
 446:   /** 
 447:    * Implementation of {@link Font#deriveFont(int)}
 448:    *
 449:    * @param font the font this peer is being called from. This may be
 450:    * useful if you are sharing peers between Font objects. Otherwise it may
 451:    * be ignored.
 452:    */
 453: 
 454:   public Font deriveFont (Font font, int style)
 455:   {
 456:     Map attrs = new HashMap ();
 457:     getStandardAttributes (attrs);
 458:     copyStyleToAttrs (style, attrs);
 459:     return tk().getFont (logicalName, attrs);
 460:   }
 461: 
 462:   /** 
 463:    * Implementation of {@link Font#deriveFont(int, AffineTransform)}
 464:    *
 465:    * @param font the font this peer is being called from. This may be
 466:    * useful if you are sharing peers between Font objects. Otherwise it may
 467:    * be ignored.
 468:    */
 469: 
 470:   public Font deriveFont (Font font, int style, AffineTransform t)
 471:   {
 472:     Map attrs = new HashMap ();
 473:     getStandardAttributes (attrs);
 474:     copyStyleToAttrs (style, attrs);
 475:     copyTransformToAttrs (t, attrs);
 476:     return tk().getFont (logicalName, attrs);
 477:   }
 478: 
 479:   /** 
 480:    * Implementation of {@link Font#deriveFont(AffineTransform)}
 481:    *
 482:    * @param font the font this peer is being called from. This may be
 483:    * useful if you are sharing peers between Font objects. Otherwise it may
 484:    * be ignored.
 485:    */
 486: 
 487:   public Font deriveFont (Font font, AffineTransform t)
 488:   {
 489:     Map attrs = new HashMap ();
 490:     getStandardAttributes (attrs);
 491:     copyTransformToAttrs (t, attrs);
 492:     return tk().getFont (logicalName, attrs);
 493:   }
 494: 
 495:   /** 
 496:    * Implementation of {@link Font#deriveFont(Map)}
 497:    *
 498:    * @param font the font this peer is being called from. This may be
 499:    * useful if you are sharing peers between Font objects. Otherwise it may
 500:    * be ignored.
 501:    */
 502: 
 503:   public Font deriveFont (Font font, Map attrs)
 504:   {
 505:     return tk().getFont (logicalName, attrs);
 506:   }
 507: 
 508:   /** 
 509:    * Implementation of {@link Font#getAttributes()}
 510:    *
 511:    * @param font the font this peer is being called from. This may be
 512:    * useful if you are sharing peers between Font objects. Otherwise it may
 513:    * be ignored.
 514:    */
 515: 
 516:   public Map getAttributes (Font font)
 517:   {
 518:     HashMap h = new HashMap ();
 519:     getStandardAttributes (h);
 520:     return h;
 521:   }
 522: 
 523:   /** 
 524:    * Implementation of {@link Font#getAvailableAttributes()}
 525:    *
 526:    * @param font the font this peer is being called from. This may be
 527:    * useful if you are sharing peers between Font objects. Otherwise it may
 528:    * be ignored.
 529:    */
 530: 
 531:   public AttributedCharacterIterator.Attribute[] getAvailableAttributes(Font font)
 532:   {
 533:     AttributedCharacterIterator.Attribute a[] = 
 534:       new AttributedCharacterIterator.Attribute[5];
 535:     a[0] = TextAttribute.FAMILY;
 536:     a[1] = TextAttribute.SIZE;
 537:     a[2] = TextAttribute.POSTURE;
 538:     a[3] = TextAttribute.WEIGHT;
 539:     a[4] = TextAttribute.TRANSFORM;
 540:     return a;
 541:   }
 542: 
 543:   /** 
 544:    * Implementation of {@link Font#getTransform()}
 545:    *
 546:    * @param font the font this peer is being called from. This may be
 547:    * useful if you are sharing peers between Font objects. Otherwise it may
 548:    * be ignored.
 549:    */
 550: 
 551:   public AffineTransform getTransform (Font font)
 552:   {
 553:     if (transform == null)
 554:       transform = new AffineTransform ();
 555:     return transform;
 556:   }
 557: 
 558:   /** 
 559:    * Implementation of {@link Font#isTransformed()}
 560:    *
 561:    * @param font the font this peer is being called from. This may be
 562:    * useful if you are sharing peers between Font objects. Otherwise it may
 563:    * be ignored.
 564:    */
 565: 
 566:   public boolean isTransformed (Font font)
 567:   {
 568:     return ! transform.isIdentity ();
 569:   }
 570: 
 571:   /** 
 572:    * Implementation of {@link Font#getItalicAngle()}
 573:    *
 574:    * @param font the font this peer is being called from. This may be
 575:    * useful if you are sharing peers between Font objects. Otherwise it may
 576:    * be ignored.
 577:    */
 578: 
 579:   public float getItalicAngle (Font font)
 580:   {
 581:     if ((style & Font.ITALIC) == Font.ITALIC)
 582:       return TextAttribute.POSTURE_OBLIQUE.floatValue ();
 583:     else
 584:       return TextAttribute.POSTURE_REGULAR.floatValue ();
 585:   }
 586: 
 587: 
 588:   /** 
 589:    * Implementation of {@link Font#getStyle()}
 590:    *
 591:    * @param font the font this peer is being called from. This may be
 592:    * useful if you are sharing peers between Font objects. Otherwise it may
 593:    * be ignored.
 594:    */
 595: 
 596:   public int getStyle (Font font) 
 597:   { 
 598:     return style; 
 599:   }
 600: 
 601: 
 602: 
 603: 
 604:   /* Remaining methods are abstract */
 605: 
 606:   /** 
 607:    * Implementation of {@link Font#canDisplay(char)}
 608:    *
 609:    * @param font the font this peer is being called from. This may be
 610:    * useful if you are sharing peers between Font objects. Otherwise it may
 611:    * be ignored.
 612:    */
 613: 
 614:   public abstract boolean canDisplay (Font font, char c);
 615: 
 616:   /** 
 617:    * Implementation of {@link Font#canDisplay(String)},
 618:    * {@link Font#canDisplay(char [], int, int)}, and
 619:    * {@link Font#canDisplay(CharacterIterator, int, int)}.
 620:    *
 621:    * @param font the font this peer is being called from. This may be
 622:    * useful if you are sharing peers between Font objects. Otherwise it may
 623:    * be ignored.
 624:    */
 625: 
 626:   public abstract int canDisplayUpTo (Font font, CharacterIterator i, int start, int limit);
 627: 
 628: 
 629:   /**
 630:    * Returns the name of this font face inside the family, for example
 631:    * <i>&#x201c;Light&#x201d;</i>.
 632:    *
 633:    * <p>This method is currently not used by {@link Font}. However,
 634:    * this name would be needed by any serious desktop publishing
 635:    * application.
 636:    *
 637:    * @param font the font whose sub-family name is requested.
 638:    *
 639:    * @param locale the locale for which to localize the name.  If
 640:    * <code>locale</code> is <code>null</code>, the returned name is
 641:    * localized to the user&#x2019;s default locale.
 642:    *
 643:    * @return the name of the face inside its family, or
 644:    * <code>null</code> if the font does not provide a sub-family name.
 645:    */
 646: 
 647:   public abstract String getSubFamilyName (Font font, Locale locale);
 648:   
 649: 
 650:   /** 
 651:    * Implementation of {@link Font#getPSName()}
 652:    *
 653:    * @param font the font this peer is being called from. This may be
 654:    * useful if you are sharing peers between Font objects. Otherwise it may
 655:    * be ignored.
 656:    */
 657: 
 658:   public abstract String getPostScriptName (Font font);
 659: 
 660: 
 661:   /** 
 662:    * Implementation of {@link Font#getNumGlyphs()}
 663:    *
 664:    * @param font the font this peer is being called from. This may be
 665:    * useful if you are sharing peers between Font objects. Otherwise it may
 666:    * be ignored.
 667:    */
 668: 
 669:   public abstract int getNumGlyphs (Font font);
 670: 
 671: 
 672:   /** 
 673:    * Implementation of {@link Font#getMissingGlyphCode()}
 674:    *
 675:    * @param font the font this peer is being called from. This may be
 676:    * useful if you are sharing peers between Font objects. Otherwise it may
 677:    * be ignored.
 678:    */
 679: 
 680:   public abstract int getMissingGlyphCode (Font font);
 681: 
 682: 
 683:   /** 
 684:    * Implementation of {@link Font#getBaselineFor(char)}
 685:    *
 686:    * @param font the font this peer is being called from. This may be
 687:    * useful if you are sharing peers between Font objects. Otherwise it may
 688:    * be ignored.
 689:    */
 690: 
 691:   public abstract byte getBaselineFor (Font font, char c);
 692: 
 693: 
 694:   /**
 695:    * Returns a name for the specified glyph. This is useful for
 696:    * generating PostScript or PDF files that embed some glyphs of a
 697:    * font. If the implementation follows glyph naming conventions
 698:    * specified by Adobe, search engines can extract the original text
 699:    * from the generated PostScript and PDF files.
 700:    *
 701:    * <p>This method is currently not used by GNU Classpath. However,
 702:    * it would be very useful for someone wishing to write a good
 703:    * PostScript or PDF stream provider for the
 704:    * <code>javax.print</code> package.
 705:    *
 706:    * <p><b>Names are not unique:</b> Under some rare circumstances,
 707:    * the same name can be returned for different glyphs. It is
 708:    * therefore recommended that printer drivers check whether the same
 709:    * name has already been returned for antoher glyph, and make the
 710:    * name unique by adding the string ".alt" followed by the glyph
 711:    * index.</p>
 712:    *
 713:    * <p>This situation would occur for an OpenType or TrueType font
 714:    * that has a <code>post</code> table of format 3 and provides a
 715:    * mapping from glyph IDs to Unicode sequences through a
 716:    * <code>Zapf</code> table. If the same sequence of Unicode
 717:    * codepoints leads to different glyphs (depending on contextual
 718:    * position, for example, or on typographic sophistication level),
 719:    * the same name would get synthesized for those glyphs. To avoid
 720:    * this, the font peer would have to go through the names of all
 721:    * glyphs, which would make this operation very inefficient with
 722:    * large fonts.
 723:    *
 724:    * @param font the font containing the glyph whose name is
 725:    * requested.
 726:    *
 727:    * @param glyphIndex the glyph whose name the caller wants to
 728:    * retrieve.
 729:    *
 730:    * @return the glyph name, or <code>null</code> if a font does not
 731:    * provide glyph names.
 732:    */
 733: 
 734:   public abstract String getGlyphName (Font font, int glyphIndex);
 735: 
 736: 
 737:   /** 
 738:    * Implementation of {@link
 739:    * Font#createGlyphVector(FontRenderContext, String)}, {@link
 740:    * Font#createGlyphVector(FontRenderContext, char[])}, and {@link
 741:    * Font#createGlyphVector(FontRenderContext, CharacterIterator)}.
 742:    *
 743:    * @param font the font object that the created GlyphVector will return
 744:    * when it gets asked for its font. This argument is needed because the
 745:    * public API of {@link GlyphVector} works with {@link java.awt.Font},
 746:    * not with font peers.
 747:    */
 748: 
 749:   public abstract GlyphVector createGlyphVector (Font font,
 750:                                                  FontRenderContext frc,
 751:                                                  CharacterIterator ci);
 752:   
 753: 
 754:   /** 
 755:    * Implementation of {@link Font#createGlyphVector(FontRenderContext,
 756:    * int[])}.
 757:    *
 758:    * @param font the font object that the created GlyphVector will return
 759:    * when it gets asked for its font. This argument is needed because the
 760:    * public API of {@link GlyphVector} works with {@link java.awt.Font},
 761:    * not with font peers.
 762:    */
 763: 
 764:   public abstract GlyphVector createGlyphVector (Font font, 
 765:                                                  FontRenderContext ctx, 
 766:                                                  int[] glyphCodes);
 767: 
 768: 
 769:   /** 
 770:    * Implementation of {@link Font#layoutGlyphVector(FontRenderContext,
 771:    * char[], int, int, int)}.
 772:    *
 773:    * @param font the font object that the created GlyphVector will return
 774:    * when it gets asked for its font. This argument is needed because the
 775:    * public API of {@link GlyphVector} works with {@link java.awt.Font},
 776:    * not with font peers.
 777:    */
 778: 
 779:   public abstract GlyphVector layoutGlyphVector (Font font, 
 780:                                                  FontRenderContext frc, 
 781:                                                  char[] chars, int start, 
 782:                                                  int limit, int flags);
 783: 
 784: 
 785:   /** 
 786:    * Implementation of {@link Font#getFontMetrics()}
 787:    *
 788:    * @param font the font this peer is being called from. This may be
 789:    * useful if you are sharing peers between Font objects. Otherwise it may
 790:    * be ignored.
 791:    */
 792: 
 793:   public abstract FontMetrics getFontMetrics (Font font);
 794: 
 795: 
 796:   /** 
 797:    * Implementation of {@link Font#hasUniformLineMetrics()}
 798:    *
 799:    * @param font the font this peer is being called from. This may be
 800:    * useful if you are sharing peers between Font objects. Otherwise it may
 801:    * be ignored.
 802:    */
 803: 
 804:   public abstract boolean hasUniformLineMetrics (Font font);
 805: 
 806: 
 807:   /** 
 808:    * Implementation of {@link Font#getLineMetrics(CharacterIterator, int,
 809:    * int, FontRenderContext)}
 810:    *
 811:    * @param font the font this peer is being called from. This may be
 812:    * useful if you are sharing peers between Font objects. Otherwise it may
 813:    * be ignored.
 814:    */
 815: 
 816:   public abstract LineMetrics getLineMetrics (Font font, 
 817:                                               CharacterIterator ci, 
 818:                                               int begin, int limit, 
 819:                                               FontRenderContext rc);
 820: 
 821:   /** 
 822:    * Implementation of {@link Font#getMaxCharBounds(FontRenderContext)}
 823:    *
 824:    * @param font the font this peer is being called from. This may be
 825:    * useful if you are sharing peers between Font objects. Otherwise it may
 826:    * be ignored.
 827:    */
 828: 
 829:   public abstract Rectangle2D getMaxCharBounds (Font font, 
 830:                                                 FontRenderContext rc);
 831: 
 832:   /** 
 833:    * Implementation of {@link Font#getStringBounds(CharacterIterator, int,
 834:    * int, FontRenderContext)}
 835:    *
 836:    * @param font the font this peer is being called from. This may be
 837:    * useful if you are sharing peers between Font objects. Otherwise it may
 838:    * be ignored.
 839:    */
 840: 
 841:   public abstract Rectangle2D getStringBounds (Font font, 
 842:                                                CharacterIterator ci, 
 843:                                                int begin, int limit, 
 844:                                                FontRenderContext frc);
 845: 
 846: }