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