EMMA Coverage Report (generated Wed Aug 16 18:51:55 GMT 2006)
[all classes][gnu.java.awt.peer]

COVERAGE SUMMARY FOR SOURCE FILE [ClasspathFontPeer.java]

nameclass, %method, %block, %line, %
ClasspathFontPeer.java100% (1/1)41%  (14/34)48%  (244/511)49%  (68.7/140)

COVERAGE BREAKDOWN BY CLASS AND METHOD

nameclass, %method, %block, %line, %
     
class ClasspathFontPeer100% (1/1)41%  (14/34)48%  (244/511)49%  (68.7/140)
ClasspathFontPeer (String, Map): void 100% (1/1)100% (7/7)100% (3/3)
ClasspathFontPeer (String, int, int): void 0%   (0/1)0%   (0/11)0%   (0/4)
copyFamilyToAttrs (String, Map): void 0%   (0/1)0%   (0/8)0%   (0/3)
copySizeToAttrs (float, Map): void 100% (1/1)100% (9/9)100% (2/2)
copyStyleToAttrs (int, Map): void 100% (1/1)82%  (27/33)86%  (6/7)
copyTransformToAttrs (AffineTransform, Map): void 0%   (0/1)0%   (0/11)0%   (0/3)
deriveFont (Font, AffineTransform): Font 0%   (0/1)0%   (0/16)0%   (0/4)
deriveFont (Font, Map): Font 0%   (0/1)0%   (0/6)0%   (0/1)
deriveFont (Font, float): Font 0%   (0/1)0%   (0/16)0%   (0/4)
deriveFont (Font, int): Font 0%   (0/1)0%   (0/16)0%   (0/4)
deriveFont (Font, int, AffineTransform): Font 0%   (0/1)0%   (0/19)0%   (0/5)
deriveFont (Font, int, float): Font 0%   (0/1)0%   (0/19)0%   (0/5)
faceNameToFamilyName (String): String 100% (1/1)100% (2/2)100% (1/1)
getAttributes (Font): Map 0%   (0/1)0%   (0/9)0%   (0/3)
getAvailableAttributes (Font): AttributedCharacterIterator$Attribute [] 0%   (0/1)0%   (0/25)0%   (0/8)
getFamily (Font): String 100% (1/1)100% (3/3)100% (1/1)
getFamily (Font, Locale): String 0%   (0/1)0%   (0/3)0%   (0/1)
getFontName (Font): String 100% (1/1)100% (3/3)100% (1/1)
getFontName (Font, Locale): String 0%   (0/1)0%   (0/3)0%   (0/1)
getItalicAngle (Font): float 0%   (0/1)0%   (0/12)0%   (0/3)
getName (Font): String 100% (1/1)100% (3/3)100% (1/1)
getSize (Font): float 100% (1/1)100% (3/3)100% (1/1)
getStandardAttributes (Map): void 0%   (0/1)0%   (0/17)0%   (0/5)
getStyle (Font): int 100% (1/1)100% (3/3)100% (1/1)
getTransform (Font): AffineTransform 100% (1/1)100% (11/11)100% (3/3)
isBold (Font): boolean 0%   (0/1)0%   (0/10)0%   (0/1)
isItalic (Font): boolean 0%   (0/1)0%   (0/10)0%   (0/1)
isLogicalFontName (String): boolean 100% (1/1)94%  (29/31)96%  (6.7/7)
isPlain (Font): boolean 0%   (0/1)0%   (0/7)0%   (0/1)
isTransformed (Font): boolean 0%   (0/1)0%   (0/8)0%   (0/1)
logicalFontNameToFaceName (String): String 100% (1/1)90%  (37/41)86%  (12/14)
setStandardAttributes (String, Map): void 100% (1/1)81%  (79/98)75%  (21/28)
setStandardAttributes (String, String, int, float, AffineTransform): void 100% (1/1)80%  (28/35)82%  (9/11)
tk (): ClasspathToolkit 0%   (0/1)0%   (0/3)0%   (0/1)

1/* ClasspathFontPeer.java -- Font peer used by GNU Classpath.
2   Copyright (C) 2003, 2004 Free Software Foundation, Inc.
3 
4This file is part of GNU Classpath.
5 
6GNU Classpath is free software; you can redistribute it and/or modify
7it under the terms of the GNU General Public License as published by
8the Free Software Foundation; either version 2, or (at your option)
9any later version.
10 
11GNU Classpath is distributed in the hope that it will be useful, but
12WITHOUT ANY WARRANTY; without even the implied warranty of
13MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
14General Public License for more details.
15 
16You should have received a copy of the GNU General Public License
17along with GNU Classpath; see the file COPYING.  If not, write to the
18Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
1902110-1301 USA.
20 
21Linking this library statically or dynamically with other modules is
22making a combined work based on this library.  Thus, the terms and
23conditions of the GNU General Public License cover the whole
24combination.
25 
26As a special exception, the copyright holders of this library give you
27permission to link this library with independent modules to produce an
28executable, regardless of the license terms of these independent
29modules, and to copy and distribute the resulting executable under
30terms of your choice, provided that you also meet, for each linked
31independent module, the terms and conditions of the license of that
32module.  An independent module is a module which is not derived from
33or based on this library.  If you modify this library, you may extend
34this exception to your version of the library, but you are not
35obligated to do so.  If you do not wish to do so, delete this
36exception statement from your version. */
37 
38 
39package gnu.java.awt.peer;
40 
41import gnu.java.awt.ClasspathToolkit;
42 
43import java.awt.Font;
44import java.awt.FontMetrics;
45import java.awt.Toolkit;
46import java.awt.font.FontRenderContext;
47import java.awt.font.GlyphVector;
48import java.awt.font.LineMetrics;
49import java.awt.font.TextAttribute;
50import java.awt.font.TransformAttribute;
51import java.awt.geom.AffineTransform;
52import java.awt.geom.Rectangle2D;
53import java.awt.peer.FontPeer;
54import java.text.AttributedCharacterIterator;
55import java.text.CharacterIterator;
56import java.util.HashMap;
57import java.util.Locale;
58import 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 */
82public 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            uname.equals ("DEFAULT"));
150  }
151 
152  protected static String logicalFontNameToFaceName (String name)
153  {
154    String uname = name.toUpperCase ();
155    if (uname.equals("SANSSERIF"))
156      return "Helvetica";
157    else if (uname.equals ("SERIF"))
158      return "Times";
159    else if (uname.equals ("MONOSPACED"))
160      return "Courier";
161    else if (uname.equals ("DIALOG"))
162      return "Helvetica";
163    else if (uname.equals ("DIALOGINPUT"))
164      return "Helvetica";
165    else if (uname.equals ("DEFAULT"))
166      return "Dialog.plain";
167    else
168      return "Helvetica";
169  }
170 
171  protected static String faceNameToFamilyName (String name)
172  {
173    return name;
174  }
175 
176  public static void copyStyleToAttrs (int style, Map attrs)
177  {
178    if ((style & Font.BOLD) == Font.BOLD)
179      attrs.put (TextAttribute.WEIGHT, TextAttribute.WEIGHT_BOLD);
180    else
181      attrs.put (TextAttribute.WEIGHT, TextAttribute.WEIGHT_REGULAR);
182 
183    if ((style & Font.ITALIC) == Font.ITALIC)
184      attrs.put (TextAttribute.POSTURE, TextAttribute.POSTURE_OBLIQUE);
185    else
186      attrs.put (TextAttribute.POSTURE, TextAttribute.POSTURE_REGULAR);
187  }
188 
189  protected static void copyFamilyToAttrs (String fam, Map attrs)
190  {
191    if (fam != null)
192      attrs.put (TextAttribute.FAMILY, fam);
193  }
194  
195  public static void copySizeToAttrs (float size, Map attrs)
196  {
197    attrs.put (TextAttribute.SIZE, new Float (size));
198  }
199  
200  protected static void copyTransformToAttrs (AffineTransform trans, Map attrs)
201  {
202    if (trans != null)
203      attrs.put(TextAttribute.TRANSFORM, new TransformAttribute (trans));
204  }
205 
206 
207  protected void setStandardAttributes (String name, String family, int style, 
208                                        float size, AffineTransform trans)
209  {
210    this.logicalName = name;
211 
212    if (isLogicalFontName (name))
213      this.faceName = logicalFontNameToFaceName (name);
214    else
215      this.faceName = name;
216 
217    if (family != null)
218      this.familyName = family;
219    else
220      this.familyName = faceNameToFamilyName (faceName);
221    
222    this.style = style;
223    this.size = size;
224    this.transform = trans;
225  }
226 
227 
228  protected void setStandardAttributes (String name, Map attribs)
229  {
230    String family = this.familyName;
231    AffineTransform trans = this.transform;
232    float size = this.size;
233    int style = this.style;
234 
235    if (attribs.containsKey (TextAttribute.FAMILY))
236      family = (String) attribs.get (TextAttribute.FAMILY);
237 
238    if (name == null)
239      name = "Default";
240 
241    if (attribs.containsKey (TextAttribute.WEIGHT))
242      {
243        Float weight = (Float) attribs.get (TextAttribute.WEIGHT);
244        if (weight.floatValue () >= TextAttribute.WEIGHT_BOLD.floatValue ())
245          style += Font.BOLD;
246      }
247 
248    if (attribs.containsKey (TextAttribute.POSTURE))
249      {
250        Float posture = (Float) attribs.get (TextAttribute.POSTURE);
251        if (posture.floatValue () >= TextAttribute.POSTURE_OBLIQUE.floatValue ())
252          style += Font.ITALIC;
253      }
254 
255    if (attribs.containsKey (TextAttribute.SIZE))
256      {
257        Float sz = (Float) attribs.get (TextAttribute.SIZE);
258        size = sz.floatValue ();
259 
260        // Pango doesn't accept 0 as a font size.
261        if (size < 1)
262          size = 1;
263      }
264    else
265      size = 12;
266 
267    if (attribs.containsKey (TextAttribute.TRANSFORM))
268      {
269        TransformAttribute ta = (TransformAttribute) 
270          attribs.get(TextAttribute.TRANSFORM);
271        trans = ta.getTransform ();        
272      }
273 
274    setStandardAttributes (name, family, style, size, trans);
275  }
276 
277  protected void getStandardAttributes (Map attrs)
278  {    
279    copyFamilyToAttrs (this.familyName, attrs);
280    copySizeToAttrs (this.size, attrs);
281    copyStyleToAttrs (this.style, attrs);
282    copyTransformToAttrs (this.transform, attrs);
283  }
284 
285 
286  /* Begin public API */
287 
288  public ClasspathFontPeer (String name, Map attrs)
289  {
290    setStandardAttributes (name, attrs);
291  }
292 
293  public ClasspathFontPeer (String name, int style, int size)
294  {
295    setStandardAttributes (name, (String)null, style, 
296                           (float)size, (AffineTransform)null);
297  }
298 
299  /** 
300   * Implementation of {@link Font#getName}
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 getName (Font font) 
308  { 
309    return logicalName; 
310  }
311 
312  /** 
313   * Implementation of {@link Font#getFamily()}
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) 
321  { 
322    return familyName; 
323  }
324 
325  /** 
326   * Implementation of {@link Font#getFamily(Locale)}
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 getFamily (Font font, Locale lc) 
334  { 
335    return familyName; 
336  }
337 
338  /** 
339   * Implementation of {@link Font#getFontName()}
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) 
347  { 
348    return faceName; 
349  }
350 
351  /** 
352   * Implementation of {@link Font#getFontName(Locale)}
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 String getFontName (Font font, Locale lc) 
360  { 
361    return faceName; 
362  }
363 
364  /** 
365   * Implementation of {@link Font#getSize}
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 float getSize (Font font) 
373  { 
374    return size; 
375  }
376 
377  /** 
378   * Implementation of {@link Font#isPlain}
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 isPlain (Font font) 
386  { 
387    return style == Font.PLAIN; 
388  }
389 
390  /** 
391   * Implementation of {@link Font#isBold}
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 isBold (Font font) 
399  { 
400    return ((style & Font.BOLD) == Font.BOLD); 
401  }
402 
403  /** 
404   * Implementation of {@link Font#isItalic}
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 boolean isItalic (Font font) 
412  { 
413    return ((style & Font.ITALIC) == Font.ITALIC); 
414  }
415 
416  /** 
417   * Implementation of {@link Font#deriveFont(int, float)}
418   *
419   * @param font the font this peer is being called from. This may be
420   * useful if you are sharing peers between Font objects. Otherwise it may
421   * be ignored.
422   */
423 
424  public Font deriveFont (Font font, int style, float size)
425  {
426    Map attrs = new HashMap ();
427    getStandardAttributes (attrs);
428    copyStyleToAttrs (style, attrs);
429    copySizeToAttrs (size, attrs);
430    return tk().getFont (logicalName, attrs);
431  }
432 
433  /** 
434   * Implementation of {@link Font#deriveFont(float)}
435   *
436   * @param font the font this peer is being called from. This may be
437   * useful if you are sharing peers between Font objects. Otherwise it may
438   * be ignored.
439   */
440 
441  public Font deriveFont (Font font, float size)
442  {
443    Map attrs = new HashMap ();
444    getStandardAttributes (attrs);
445    copySizeToAttrs (size, attrs);
446    return tk().getFont (logicalName, attrs);
447  }
448 
449  /** 
450   * Implementation of {@link Font#deriveFont(int)}
451   *
452   * @param font the font this peer is being called from. This may be
453   * useful if you are sharing peers between Font objects. Otherwise it may
454   * be ignored.
455   */
456 
457  public Font deriveFont (Font font, int style)
458  {
459    Map attrs = new HashMap ();
460    getStandardAttributes (attrs);
461    copyStyleToAttrs (style, attrs);
462    return tk().getFont (logicalName, attrs);
463  }
464 
465  /** 
466   * Implementation of {@link Font#deriveFont(int, AffineTransform)}
467   *
468   * @param font the font this peer is being called from. This may be
469   * useful if you are sharing peers between Font objects. Otherwise it may
470   * be ignored.
471   */
472 
473  public Font deriveFont (Font font, int style, AffineTransform t)
474  {
475    Map attrs = new HashMap ();
476    getStandardAttributes (attrs);
477    copyStyleToAttrs (style, attrs);
478    copyTransformToAttrs (t, attrs);
479    return tk().getFont (logicalName, attrs);
480  }
481 
482  /** 
483   * Implementation of {@link Font#deriveFont(AffineTransform)}
484   *
485   * @param font the font this peer is being called from. This may be
486   * useful if you are sharing peers between Font objects. Otherwise it may
487   * be ignored.
488   */
489 
490  public Font deriveFont (Font font, AffineTransform t)
491  {
492    Map attrs = new HashMap ();
493    getStandardAttributes (attrs);
494    copyTransformToAttrs (t, attrs);
495    return tk().getFont (logicalName, attrs);
496  }
497 
498  /** 
499   * Implementation of {@link Font#deriveFont(Map)}
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 Font deriveFont (Font font, Map attrs)
507  {
508    return tk().getFont (logicalName, attrs);
509  }
510 
511  /** 
512   * Implementation of {@link Font#getAttributes()}
513   *
514   * @param font the font this peer is being called from. This may be
515   * useful if you are sharing peers between Font objects. Otherwise it may
516   * be ignored.
517   */
518 
519  public Map getAttributes (Font font)
520  {
521    HashMap h = new HashMap ();
522    getStandardAttributes (h);
523    return h;
524  }
525 
526  /** 
527   * Implementation of {@link Font#getAvailableAttributes()}
528   *
529   * @param font the font this peer is being called from. This may be
530   * useful if you are sharing peers between Font objects. Otherwise it may
531   * be ignored.
532   */
533 
534  public AttributedCharacterIterator.Attribute[] getAvailableAttributes(Font font)
535  {
536    AttributedCharacterIterator.Attribute a[] = 
537      new AttributedCharacterIterator.Attribute[5];
538    a[0] = TextAttribute.FAMILY;
539    a[1] = TextAttribute.SIZE;
540    a[2] = TextAttribute.POSTURE;
541    a[3] = TextAttribute.WEIGHT;
542    a[4] = TextAttribute.TRANSFORM;
543    return a;
544  }
545 
546  /** 
547   * Implementation of {@link Font#getTransform()}
548   *
549   * @param font the font this peer is being called from. This may be
550   * useful if you are sharing peers between Font objects. Otherwise it may
551   * be ignored.
552   */
553 
554  public AffineTransform getTransform (Font font)
555  {
556    if (transform == null)
557      transform = new AffineTransform ();
558    return transform;
559  }
560 
561  /** 
562   * Implementation of {@link Font#isTransformed()}
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 boolean isTransformed (Font font)
570  {
571    return ! transform.isIdentity ();
572  }
573 
574  /** 
575   * Implementation of {@link Font#getItalicAngle()}
576   *
577   * @param font the font this peer is being called from. This may be
578   * useful if you are sharing peers between Font objects. Otherwise it may
579   * be ignored.
580   */
581 
582  public float getItalicAngle (Font font)
583  {
584    if ((style & Font.ITALIC) == Font.ITALIC)
585      return TextAttribute.POSTURE_OBLIQUE.floatValue ();
586    else
587      return TextAttribute.POSTURE_REGULAR.floatValue ();
588  }
589 
590 
591  /** 
592   * Implementation of {@link Font#getStyle()}
593   *
594   * @param font the font this peer is being called from. This may be
595   * useful if you are sharing peers between Font objects. Otherwise it may
596   * be ignored.
597   */
598 
599  public int getStyle (Font font) 
600  { 
601    return style; 
602  }
603 
604 
605 
606 
607  /* Remaining methods are abstract */
608 
609  /** 
610   * Implementation of {@link Font#canDisplay(char)}
611   *
612   * @param font the font this peer is being called from. This may be
613   * useful if you are sharing peers between Font objects. Otherwise it may
614   * be ignored.
615   */
616 
617  public abstract boolean canDisplay (Font font, char c);
618 
619  /** 
620   * Implementation of {@link Font#canDisplay(String)},
621   * {@link Font#canDisplay(char [], int, int)}, and
622   * {@link Font#canDisplay(CharacterIterator, int, int)}.
623   *
624   * @param font the font this peer is being called from. This may be
625   * useful if you are sharing peers between Font objects. Otherwise it may
626   * be ignored.
627   */
628 
629  public abstract int canDisplayUpTo (Font font, CharacterIterator i, int start, int limit);
630 
631 
632  /**
633   * Returns the name of this font face inside the family, for example
634   * <i>&#x201c;Light&#x201d;</i>.
635   *
636   * <p>This method is currently not used by {@link Font}. However,
637   * this name would be needed by any serious desktop publishing
638   * application.
639   *
640   * @param font the font whose sub-family name is requested.
641   *
642   * @param locale the locale for which to localize the name.  If
643   * <code>locale</code> is <code>null</code>, the returned name is
644   * localized to the user&#x2019;s default locale.
645   *
646   * @return the name of the face inside its family, or
647   * <code>null</code> if the font does not provide a sub-family name.
648   */
649 
650  public abstract String getSubFamilyName (Font font, Locale locale);
651  
652 
653  /** 
654   * Implementation of {@link Font#getPSName()}
655   *
656   * @param font the font this peer is being called from. This may be
657   * useful if you are sharing peers between Font objects. Otherwise it may
658   * be ignored.
659   */
660 
661  public abstract String getPostScriptName (Font font);
662 
663 
664  /** 
665   * Implementation of {@link Font#getNumGlyphs()}
666   *
667   * @param font the font this peer is being called from. This may be
668   * useful if you are sharing peers between Font objects. Otherwise it may
669   * be ignored.
670   */
671 
672  public abstract int getNumGlyphs (Font font);
673 
674 
675  /** 
676   * Implementation of {@link Font#getMissingGlyphCode()}
677   *
678   * @param font the font this peer is being called from. This may be
679   * useful if you are sharing peers between Font objects. Otherwise it may
680   * be ignored.
681   */
682 
683  public abstract int getMissingGlyphCode (Font font);
684 
685 
686  /** 
687   * Implementation of {@link Font#getBaselineFor(char)}
688   *
689   * @param font the font this peer is being called from. This may be
690   * useful if you are sharing peers between Font objects. Otherwise it may
691   * be ignored.
692   */
693 
694  public abstract byte getBaselineFor (Font font, char c);
695 
696 
697  /**
698   * Returns a name for the specified glyph. This is useful for
699   * generating PostScript or PDF files that embed some glyphs of a
700   * font. If the implementation follows glyph naming conventions
701   * specified by Adobe, search engines can extract the original text
702   * from the generated PostScript and PDF files.
703   *
704   * <p>This method is currently not used by GNU Classpath. However,
705   * it would be very useful for someone wishing to write a good
706   * PostScript or PDF stream provider for the
707   * <code>javax.print</code> package.
708   *
709   * <p><b>Names are not unique:</b> Under some rare circumstances,
710   * the same name can be returned for different glyphs. It is
711   * therefore recommended that printer drivers check whether the same
712   * name has already been returned for antoher glyph, and make the
713   * name unique by adding the string ".alt" followed by the glyph
714   * index.</p>
715   *
716   * <p>This situation would occur for an OpenType or TrueType font
717   * that has a <code>post</code> table of format 3 and provides a
718   * mapping from glyph IDs to Unicode sequences through a
719   * <code>Zapf</code> table. If the same sequence of Unicode
720   * codepoints leads to different glyphs (depending on contextual
721   * position, for example, or on typographic sophistication level),
722   * the same name would get synthesized for those glyphs. To avoid
723   * this, the font peer would have to go through the names of all
724   * glyphs, which would make this operation very inefficient with
725   * large fonts.
726   *
727   * @param font the font containing the glyph whose name is
728   * requested.
729   *
730   * @param glyphIndex the glyph whose name the caller wants to
731   * retrieve.
732   *
733   * @return the glyph name, or <code>null</code> if a font does not
734   * provide glyph names.
735   */
736 
737  public abstract String getGlyphName (Font font, int glyphIndex);
738 
739 
740  /** 
741   * Implementation of {@link
742   * Font#createGlyphVector(FontRenderContext, String)}, {@link
743   * Font#createGlyphVector(FontRenderContext, char[])}, and {@link
744   * Font#createGlyphVector(FontRenderContext, CharacterIterator)}.
745   *
746   * @param font the font object that the created GlyphVector will return
747   * when it gets asked for its font. This argument is needed because the
748   * public API of {@link GlyphVector} works with {@link java.awt.Font},
749   * not with font peers.
750   */
751 
752  public abstract GlyphVector createGlyphVector (Font font,
753                                                 FontRenderContext frc,
754                                                 CharacterIterator ci);
755  
756 
757  /** 
758   * Implementation of {@link Font#createGlyphVector(FontRenderContext,
759   * int[])}.
760   *
761   * @param font the font object that the created GlyphVector will return
762   * when it gets asked for its font. This argument is needed because the
763   * public API of {@link GlyphVector} works with {@link java.awt.Font},
764   * not with font peers.
765   */
766 
767  public abstract GlyphVector createGlyphVector (Font font, 
768                                                 FontRenderContext ctx, 
769                                                 int[] glyphCodes);
770 
771 
772  /** 
773   * Implementation of {@link Font#layoutGlyphVector(FontRenderContext,
774   * char[], int, int, int)}.
775   *
776   * @param font the font object that the created GlyphVector will return
777   * when it gets asked for its font. This argument is needed because the
778   * public API of {@link GlyphVector} works with {@link java.awt.Font},
779   * not with font peers.
780   */
781 
782  public abstract GlyphVector layoutGlyphVector (Font font, 
783                                                 FontRenderContext frc, 
784                                                 char[] chars, int start, 
785                                                 int limit, int flags);
786 
787 
788  /** 
789   * Implementation of {@link Font#getFontMetrics()}
790   *
791   * @param font the font this peer is being called from. This may be
792   * useful if you are sharing peers between Font objects. Otherwise it may
793   * be ignored.
794   */
795 
796  public abstract FontMetrics getFontMetrics (Font font);
797 
798 
799  /** 
800   * Implementation of {@link Font#hasUniformLineMetrics()}
801   *
802   * @param font the font this peer is being called from. This may be
803   * useful if you are sharing peers between Font objects. Otherwise it may
804   * be ignored.
805   */
806 
807  public abstract boolean hasUniformLineMetrics (Font font);
808 
809 
810  /** 
811   * Implementation of {@link Font#getLineMetrics(CharacterIterator, int,
812   * int, 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 LineMetrics getLineMetrics (Font font, 
820                                              CharacterIterator ci, 
821                                              int begin, int limit, 
822                                              FontRenderContext rc);
823 
824  /** 
825   * Implementation of {@link Font#getMaxCharBounds(FontRenderContext)}
826   *
827   * @param font the font this peer is being called from. This may be
828   * useful if you are sharing peers between Font objects. Otherwise it may
829   * be ignored.
830   */
831 
832  public abstract Rectangle2D getMaxCharBounds (Font font, 
833                                                FontRenderContext rc);
834 
835  /** 
836   * Implementation of {@link Font#getStringBounds(CharacterIterator, int,
837   * int, FontRenderContext)}
838   *
839   * @param font the font this peer is being called from. This may be
840   * useful if you are sharing peers between Font objects. Otherwise it may
841   * be ignored.
842   */
843 
844  public abstract Rectangle2D getStringBounds (Font font, 
845                                               CharacterIterator ci, 
846                                               int begin, int limit, 
847                                               FontRenderContext frc);
848 
849}

[all classes][gnu.java.awt.peer]
EMMA 2.0.6427 (unsupported private build) (C) Vladimir Roubtsov