libjava/java/awt/Font.java

   1 /* Font.java -- Font object
   2    Copyright (C) 1999, 2002 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 java.awt;
  40
  41 import java.awt.peer.FontPeer;
  42 import java.io.Serializable;
  43 import java.util.StringTokenizer;
  44
  45 /**
  46   * This class represents a windowing system font.
  47   *
  48   * @author Aaron M. Renn (arenn@urbanophile.com)
  49   * @author Warren Levy <warrenl@cygnus.com>
  50   */
  51 public class Font implements Serializable
  52 {
  53
  54 /*
  55  * Static Variables
  56  */
  57
  58 /**
  59   * Constant indicating a "plain" font.
  60   */
  61 public static final int PLAIN = 0;
  62
  63 /**
  64   * Constant indicating a "bold" font.
  65   */
  66 public static final int BOLD = 1;
  67
  68 /**
  69   * Constant indicating an "italic" font.
  70   */
  71 public static final int ITALIC = 2;
  72
  73 public static final int ROMAN_BASELINE = 0;
  74 public static final int CENTER_BASELINE = 1;
  75 public static final int HANGING_BASELINE = 2;
  76
  77
  78   /**
  79    * Indicates to <code>createFont</code> that the supplied font data
  80    * is in TrueType format.
  81    *
  82    * <p><em>Specification Note:</em> The Sun JavaDoc for J2SE 1.4 does
  83    * not indicate whether this value also subsumes OpenType. OpenType
  84    * is essentially the same format as TrueType, but allows to define
  85    * glyph shapes in the same way as PostScript, using cubic bezier
  86    * curves.
  87    *
  88    * @since 1.3
  89    */
  90   public static final int TRUETYPE_FONT = 0;
  91
  92
  93   /**
  94    * A flag for <code>layoutGlyphVector</code>, indicating that the
  95    * orientation of a text run is from left to right.
  96    *
  97    * @since 1.4
  98    */
  99   public static final int LAYOUT_LEFT_TO_RIGHT = 0;
 100
 101
 102   /**
 103    * A flag for <code>layoutGlyphVector</code>, indicating that the
 104    * orientation of a text run is from right to left.
 105    *
 106    * @since 1.4
 107    */
 108   public static final int LAYOUT_RIGHT_TO_LEFT = 1;
 109
 110
 111   /**
 112    * A flag for <code>layoutGlyphVector</code>, indicating that the
 113    * text does not contain valid characters before the
 114    * <code>start</code> position.  If this flag is set,
 115    * <code>layoutGlyphVector</code> does not examine the text before
 116    * <code>start</code>, even if this would be necessary to select the
 117    * correct glyphs (e.g., for Arabic text).
 118    *
 119    * @since 1.4
 120    */
 121   public static final int LAYOUT_NO_START_CONTEXT = 2;
 122
 123
 124   /**
 125    * A flag for <code>layoutGlyphVector</code>, indicating that the
 126    * text does not contain valid characters after the
 127    * <code>limit</code> position.  If this flag is set,
 128    * <code>layoutGlyphVector</code> does not examine the text after
 129    * <code>limit</code>, even if this would be necessary to select the
 130    * correct glyphs (e.g., for Arabic text).
 131    *
 132    * @since 1.4
 133    */
 134   public static final int LAYOUT_NO_LIMIT_CONTEXT = 4;
 135
 136
 137 // Serialization constant
 138 private static final long serialVersionUID = -4206021311591459213L;
 139
 140 /*************************************************************************/
 141
 142 /*
 143  * Instance Variables
 144  */
 145
 146 /**
 147   * The name of this font
 148   */
 149 protected String name;
 150
 151 /**
 152   * The font style, which is a combination (by summing, not OR-ing) of
 153   * the font style constants in this class.
 154   */
 155 protected int style;
 156
 157 /**
 158   * The font point size.
 159   */
 160 protected int size;
 161
 162 protected float pointSize;
 163
 164 // The native peer for this font
 165 private FontPeer peer;
 166
 167 /*************************************************************************/
 168
 169 /*
 170  * Static Methods
 171  */
 172
 173 /**
 174   * Creates a <code>Font</code> object from the specified string, which
 175   * is in one of the following formats:
 176   * <p>
 177   * <ul>
 178   * <li>fontname-style-pointsize
 179   * <li>fontname-style
 180   * <li>fontname-pointsize
 181   * <li>fontname
 182   * </ul>
 183   * <p>
 184   * The style should be one of BOLD, ITALIC, or BOLDITALIC.  The default
 185   * style if none is specified is PLAIN.  The default size if none
 186   * is specified is 12.
 187   */
 188 public static Font
 189 decode(String fontspec)
 190 {
 191   String name = null;
 192   int style = PLAIN;
 193   int size = 12;
 194
 195   StringTokenizer st = new StringTokenizer(fontspec, "-");
 196   while (st.hasMoreTokens())
 197     {
 198       String token = st.nextToken();
 199       if (name == null)
 200         {
 201           name = token;
 202           continue;
 203         }
 204
 205       if (token.toUpperCase().equals("BOLD"))
 206         {
 207           style = BOLD;
 208           continue;
 209         }
 210       if (token.toUpperCase().equals("ITALIC"))
 211         {
 212           style = ITALIC;
 213           continue;
 214         }
 215       if (token.toUpperCase().equals("BOLDITALIC"))
 216         {
 217           style = BOLD + ITALIC;
 218           continue;
 219         }
 220
 221       int tokenval = 0;
 222       try
 223         {
 224           tokenval = Integer.parseInt(token);
 225         }
 226       catch(NumberFormatException e) { ; }
 227
 228       if (tokenval != 0)
 229         size = tokenval;
 230     }
 231
 232   return(new Font(name, style, size));
 233 }
 234
 235 /*************************************************************************/
 236
 237 /**
 238   * Returns a <code>Font</code> object from the passed property name.
 239   *
 240   * @param propname The name of the system property.
 241   * @param default Value to use if the property is not found.
 242   *
 243   * @return The requested font, or <code>default</code> if the property
 244   * not exist or is malformed.
 245   */
 246 public static Font
 247 getFont(String propname, Font defval)
 248 {
 249   String propval = System.getProperty(propname);
 250   if (propval != null)
 251     return(decode(propval));
 252
 253   return(defval);
 254 }
 255
 256 /*************************************************************************/
 257
 258 /**
 259   * Returns a <code>Font</code> object from the passed property name.
 260   *
 261   * @param propname The name of the system property.
 262   *
 263   * @return The requested font, or <code>null</code> if the property
 264   * not exist or is malformed.
 265   */
 266 public static Font
 267 getFont(String propname)
 268 {
 269   return(getFont(propname, null));
 270 }
 271
 272 /*************************************************************************/
 273
 274 /*
 275  * Constructors
 276  */
 277
 278 /**
 279   * Initializes a new instance of <code>Font</code> with the specified
 280   * attributes.
 281   *
 282   * @param name The name of the font.
 283   * @param style The font style.
 284   * @param size The font point size.
 285   */
 286 public
 287 Font(String name, int style, int size)
 288 {
 289   this.name = name;
 290   this.style = style;
 291   this.size = size;
 292   this.pointSize = size;
 293 }
 294
 295 /*************************************************************************/
 296
 297 /*
 298  * Instance Methods
 299  */
 300
 301 /**
 302   * Returns the name of the font.
 303   *
 304   * @return The name of the font.
 305   */
 306 public String
 307 getName()
 308 {
 309   return(name);
 310 }
 311
 312 /*************************************************************************/
 313
 314 /**
 315   * Returns the style of the font.
 316   *
 317   * @return The font style.
 318   */
 319 public int
 320 getSize()
 321 {
 322   return(size);
 323 }
 324
 325 public float
 326 getSize2D()
 327 {
 328   return pointSize;
 329 }
 330
 331 /*************************************************************************/
 332
 333 /**
 334   * Tests whether or not this is a plain font.  This will be true if
 335   * and only if neither the bold nor the italics style is set.
 336   *
 337   * @return <code>true</code> if this is a plain font, <code>false</code>
 338   * otherwise.
 339   */
 340 public boolean
 341 isPlain()
 342 {
 343   if (style == PLAIN)
 344     return(true);
 345   else
 346     return(false);
 347 }
 348
 349 /*************************************************************************/
 350
 351 /**
 352   * Tests whether or not this font is bold.
 353   *
 354   * @return <code>true</code> if this font is bold, <code>false</code>
 355   * otherwise.
 356   */
 357 public boolean
 358 isBold()
 359 {
 360   if ((style == BOLD) || (style == (BOLD+ITALIC)))
 361     return(true);
 362   else
 363     return(false);
 364 }
 365
 366 /*************************************************************************/
 367
 368 /**
 369   * Tests whether or not this font is italic.
 370   *
 371   * @return <code>true</code> if this font is italic, <code>false</code>
 372   * otherwise.
 373   */
 374 public boolean
 375 isItalic()
 376 {
 377   if ((style == ITALIC) || (style == (BOLD+ITALIC)))
 378     return(true);
 379   else
 380     return(false);
 381 }
 382
 383 /*************************************************************************/
 384
 385 /**
 386   * Returns the system specific font family name.
 387   *
 388   * @return The system specific font family name.
 389   */
 390 public String
 391 getFamily()
 392 {
 393   // FIXME: How do I implement this?
 394   return(name);
 395 }
 396
 397 public int
 398 getStyle()
 399 {
 400   return style;
 401 }
 402
 403 /*************************************************************************/
 404
 405 /**
 406   * Returns a native peer object for this font.
 407   *
 408   * @return A native peer object for this font.
 409   */
 410 public FontPeer
 411 getPeer()
 412 {
 413   if (peer != null)
 414     return(peer);
 415
 416   peer = Toolkit.getDefaultToolkit().getFontPeer(name, style);
 417   return(peer);
 418 }
 419
 420 /*************************************************************************/
 421
 422 /**
 423   * Returns a hash value for this font.
 424   *
 425   * @return A hash for this font.
 426   */
 427 public int
 428 hashCode()
 429 {
 430   return((new String(name + size + style)).hashCode());
 431 }
 432
 433 /*************************************************************************/
 434
 435 /**
 436   * Tests whether or not the specified object is equal to this font.  This
 437   * will be true if and only if:
 438   * <P>
 439   * <ul>
 440   * <li>The object is not <code>null</code>.
 441   * <li>The object is an instance of <code>Font</code>.
 442   * <li>The object has the same name, style, and size as this object.
 443   * </ul>
 444   *
 445   * @return <code>true</code> if the specified object is equal to this
 446   * object, <code>false</code> otherwise.
 447   */
 448 public boolean
 449 equals(Object obj)
 450 {
 451   if (obj == null)
 452     return(false);
 453
 454   if (!(obj instanceof Font))
 455     return(false);
 456
 457   Font f = (Font)obj;
 458
 459   if (!f.name.equals(name))
 460     return(false);
 461
 462   if (f.size != size)
 463     return(false);
 464
 465   if (f.style != style)
 466     return(false);
 467
 468   return(true);
 469 }
 470
 471 /*************************************************************************/
 472
 473 /**
 474   * Returns a string representation of this font.
 475   *
 476   * @return A string representation of this font.
 477   */
 478 public String
 479 toString()
 480 {
 481   return(getClass().getName() + "(name=" + name + ",style=" + style +
 482          ",size=" + size + ")");
 483 }
 484
 485 } // class Font
 486