libjava/classpath/gnu/java/awt/peer/ClasspathFontPeer.java

   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 }