Font.java
上传用户:haobig99
上传日期:2022-06-15
资源大小:369k
文件大小:16k
源码类别:

J2ME

开发平台:

Java

  1. /*
  2.  * Copyright 2008 Sun Microsystems, Inc.  All Rights Reserved.
  3.  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  4.  *
  5.  * This code is free software; you can redistribute it and/or modify it
  6.  * under the terms of the GNU General Public License version 2 only, as
  7.  * published by the Free Software Foundation.  Sun designates this
  8.  * particular file as subject to the "Classpath" exception as provided
  9.  * by Sun in the LICENSE file that accompanied this code.
  10.  *
  11.  * This code is distributed in the hope that it will be useful, but WITHOUT
  12.  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  13.  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  14.  * version 2 for more details (a copy is included in the LICENSE file that
  15.  * accompanied this code).
  16.  *
  17.  * You should have received a copy of the GNU General Public License version
  18.  * 2 along with this work; if not, write to the Free Software Foundation,
  19.  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  20.  *
  21.  * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
  22.  * CA 95054 USA or visit www.sun.com if you need additional information or
  23.  * have any questions.
  24.  */
  25. package com.sun.lwuit;
  26. import java.io.IOException;
  27. import java.io.InputStream;
  28. import java.util.Hashtable;
  29. /**
  30.  * A simple abstraction of platform fonts and library fonts that enables the
  31.  * library to use more elaborate fonts unsupported by a specific device.
  32.  * This abstraction also supports bitmap fonts using an Ant task (more details
  33.  * about the unifier are explained in the javadoc overview document).
  34.  * <p>A bitmap font can be created manually but that is tedious, normally you would use
  35.  * the Ant task as illustrated bellow to produce a resource file containing
  36.  * the supported bitmap font. For further detail read the overview document and 
  37.  * {@link com.sun.lwuit.util.Resources}.
  38. <pre>
  39. &lt;target name="pre-init"&gt;
  40.      &lt;taskdef classpath="ImageUnifier.jar" classname="com.sun.jwt.resource.Builder" name="build" /&gt;
  41.      &lt;build dest="src/font.res"&gt;
  42.         &lt;font src="images/arial.ttf" bold="true" italic="true" size="11" /&gt;
  43.         &lt;font logicalName="Dialog" /&gt;
  44.     &lt;/build&gt;
  45. &lt;/target&gt;
  46. </pre>
  47.  * <p>The following attributes can be expressed for a font ant task:
  48.  * <ul>
  49.  * <li>name - name for the font to load from the resource file (optional: defaults to logical name or file name).
  50.  * <li>charset - defaults to the English alphabet, numbers and common signs. 
  51.  * Should contain a list of all characters that should be supported by a font. E.g. if a font would always be
  52.  * used for uppercase letters then it would save space to define the charset as: {@code "ABCDEFGHIJKLMNOPQRSTUVWXYZ" }
  53.  * <li>src - font file in the case of using a file, defaults to TrueType font
  54.  * <li>size - floating point size of the font
  55.  * <li>bold - defaults to false indicates if the font should be bold
  56.  * <li>italic - defaults to false indicates if the font should be italic
  57.  * <li>trueType - defaults to true, relevant only when src is used. If set to false type 1 fonts are assumed.
  58.  * <li>antiAliasing - defaults to true otherwise fonts will be aliased
  59.  * <li>logicalName - logical name of the font as specified by java.awt.Font in Java SE: 
  60.  * {@code Dialog, DialogInput, Monospaced, Serif, or SansSerif }
  61.  * </ul>
  62.  */
  63. public class Font {
  64.     /**
  65.      * Constant allowing us to author portable system fonts
  66.      */
  67.     public static final int FACE_MONOSPACE = 32;
  68.     /**
  69.      * Constant allowing us to author portable system fonts
  70.      */
  71.     public static final int FACE_PROPORTIONAL = 64;
  72.     /**
  73.      * Constant allowing us to author portable system fonts
  74.      */
  75.     public static final int FACE_SYSTEM = 0;
  76.     /**
  77.      * Constant allowing us to author portable system fonts
  78.      */
  79.     public static final int SIZE_LARGE = 16;
  80.     /**
  81.      * Constant allowing us to author portable system fonts
  82.      */
  83.     public static final int SIZE_MEDIUM = 0;
  84.     /**
  85.      * Constant allowing us to author portable system fonts
  86.      */
  87.     public static final int SIZE_SMALL = 8;
  88.     /**
  89.      * Constant allowing us to author portable system fonts
  90.      */
  91.     public static final int STYLE_BOLD = 1;
  92.     /**
  93.      * Constant allowing us to author portable system fonts
  94.      */
  95.     public static final int STYLE_ITALIC = 2;
  96.     
  97.     /**
  98.      * Constant allowing us to author portable system fonts
  99.      */
  100.     public static final int STYLE_UNDERLINED = 4;
  101.     /**
  102.      * Constant allowing us to author portable system fonts
  103.      */
  104.     public static final int STYLE_PLAIN = 0;
  105.     
  106.     private static Font defaultFont = new Font(null);
  107.     
  108.     private static Hashtable bitmapCache = new Hashtable();
  109.     private static boolean enableBitmapFont = true;
  110.     private Object font;
  111.     /**
  112.      * Creates a new Font
  113.      */
  114.     Font() {
  115.     }
  116.     Font(Object nativeFont) {
  117.         font = nativeFont;
  118.     }
  119.     Font(int face, int style, int size) {
  120.         font = Display.getInstance().getImplementation().createFont(face, style, size);
  121.     }
  122.     /**
  123.      * Returns a previously loaded bitmap font from cache
  124.      * 
  125.      * @param fontName the font name is the logical name of the font 
  126.      * @return the font object
  127.      * @see #clearBitmapCache
  128.      */
  129.     public static Font getBitmapFont(String fontName) {
  130.         return (Font)bitmapCache.get(fontName);
  131.     }
  132.     
  133.     
  134.     /**
  135.      * Bitmap fonts are cached this method allows us to flush the cache thus allows
  136.      * us to reload a font
  137.      */
  138.     public static void clearBitmapCache() {
  139.         bitmapCache.clear();
  140.     }
  141.     /**
  142.      * Returns true if the underlying platform supports loading truetype fonts from
  143.      * a file stream.
  144.      * 
  145.      * @return true if the underlying platform supports loading truetype fonts from
  146.      * a file stream
  147.      */
  148.     public static boolean isTrueTypeFileSupported() {
  149.         return Display.getInstance().getImplementation().isTrueTypeSupported();
  150.     }
  151.     /**
  152.      * Returns true if the underlying platform allows creating a font based on a
  153.      * user submitted string.
  154.      *
  155.      * @return true if the underlying platform allows creating a font based on a
  156.      * user submitted string
  157.      */
  158.     public static boolean isCreationByStringSupported() {
  159.         return Display.getInstance().getImplementation().isLookupFontSupported();
  160.     }
  161.     /**
  162.      * Creates a true type font from the given stream if the underlying platform supports
  163.      * truetype font loading.
  164.      *
  165.      * @param stream input stream containing the font
  166.      * @return the font object to create
  167.      * @throws IOException if font loading fails
  168.      */
  169.     public static Font createTrueTypeFont(InputStream stream) throws IOException {
  170.         return new Font(Display.getInstance().getImplementation().loadTrueTypeFont(stream));
  171.     }
  172.     /**
  173.      * Creates a new font instance based on the platform specific string name of the
  174.      * font. This method isn't supported on some platforms.
  175.      *
  176.      * @param lookup a set of platform specific names delimited by commas, the first succefully
  177.      * loaded font will be used
  178.      * @return newly created font
  179.      */
  180.     public static Font create(String lookup) {
  181.         return new Font(Display.getInstance().getImplementation().loadNativeFont(lookup));
  182.     }
  183.     /**
  184.      * Increase the contrast of the bitmap font for rendering on top of a surface
  185.      * whose color is darker. This is useful when drawing anti-aliased bitmap fonts using a light color
  186.      * (e.g. white) on top of a dark surface (e.g. black), the font often breaks down if its contrast is not
  187.      * increased due to the way alpha blending appears to the eye.
  188.      * <p>Notice that this method only works in one way, contrast cannot be decreased
  189.      * properly in a font and it should be cleared and reloaed with a Look and Feel switch.
  190.      * 
  191.      * @param value the value to increase 
  192.      */
  193.     public void addContrast(byte value) {
  194.     }
  195.     /**
  196.      * Creates a bitmap font with the given arguments and places said font in the cache
  197.      * 
  198.      * @param name the name for the font in the cache
  199.      * @param bitmap a transparency map in red and black that indicates the characters
  200.      * @param cutOffsets character offsets matching the bitmap pixels and characters in the font 
  201.      * @param charWidth The width of the character when drawing... this should not be confused with
  202.      *      the number of cutOffset[o + 1] - cutOffset[o]. They are completely different
  203.      *      since a character can be "wider" and "seep" into the next region. This is
  204.      *      especially true with italic characters all of which "lean" outside of their 
  205.      *      bounds.
  206.      * @param charsets the set of characters in the font
  207.      * @return a font object to draw bitmap fonts
  208.      */
  209.     public static Font createBitmapFont(String name, Image bitmap, int[] cutOffsets, int[] charWidth, String charsets) {
  210.         Font f = createBitmapFont(bitmap, cutOffsets, charWidth, charsets);
  211.         bitmapCache.put(name, f);
  212.         return f;
  213.     }
  214.         
  215.     /**
  216.      * Creates a bitmap font with the given arguments
  217.      * 
  218.      * @param bitmap a transparency map in red and black that indicates the characters
  219.      * @param cutOffsets character offsets matching the bitmap pixels and characters in the font 
  220.      * @param charWidth The width of the character when drawing... this should not be confused with
  221.      *      the number of cutOffset[o + 1] - cutOffset[o]. They are completely different
  222.      *      since a character can be "wider" and "seep" into the next region. This is
  223.      *      especially true with italic characters all of which "lean" outside of their 
  224.      *      bounds.
  225.      * @param charsets the set of characters in the font
  226.      * @return a font object to draw bitmap fonts
  227.      */
  228.     public static Font createBitmapFont(Image bitmap, int[] cutOffsets, int[] charWidth, String charsets) {
  229.         return new CustomFont(bitmap, cutOffsets, charWidth, charsets);
  230.     }
  231.     
  232.     /**
  233.      * Creates a system native font in a similar way to common MIDP fonts
  234.      * 
  235.      * @param face One of FACE_SYSTEM, FACE_PROPORTIONAL, FACE_MONOSPACE
  236.      * @param style one of STYLE_PLAIN, STYLE_ITALIC, STYLE_BOLD
  237.      * @param size One of SIZE_SMALL, SIZE_MEDIUM, SIZE_LARGE
  238.      * @return A newly created system font instance 
  239.      */
  240.     public static Font createSystemFont(int face, int style, int size) {
  241.         return new Font(face, style, size);
  242.     }
  243.     
  244.     /**
  245.      * Return the width of the given characters in this font instance
  246.      * 
  247.      * @param ch array of characters
  248.      * @param offset characters offsets
  249.      * @param length characters length
  250.      * @return the width of the given characters in this font instance
  251.      */
  252.     public int charsWidth(char[] ch, int offset, int length){
  253.         return Display.getInstance().getImplementation().charsWidth(font, ch, offset, length);
  254.     }
  255.     
  256.     /**
  257.      * Return the width of the given string subset in this font instance
  258.      * 
  259.      * @param str the given string
  260.      * @param offset the string offset
  261.      * @param len the len od string
  262.      * @return the width of the given string subset in this font instance
  263.      */
  264.     public int substringWidth(String str, int offset, int len){
  265.         return Display.getInstance().getImplementation().stringWidth(font, str.substring(offset, offset + len));
  266.     }
  267.     
  268.     /**
  269.      * Return the width of the given string in this font instance
  270.      * 
  271.      * @param str the given string     * 
  272.      * @return the width of the given string in this font instance
  273.      */
  274.     public int stringWidth(String str){
  275.         return Display.getInstance().getImplementation().stringWidth(font, str);
  276.     }
  277.     
  278.     /**
  279.      * Return the width of the specific character when rendered alone
  280.      * 
  281.      * @param ch the specific character
  282.      * @return the width of the specific character when rendered alone
  283.      */
  284.     public int charWidth(char ch) {
  285.         return Display.getInstance().getImplementation().charWidth(font, ch);
  286.     }
  287.     
  288.     /**
  289.      * Return the total height of the font
  290.      * 
  291.      * @return the total height of the font
  292.      */
  293.     public int getHeight() {
  294.         return Display.getInstance().getImplementation().getHeight(font);
  295.     }
  296.     
  297.     /**
  298.      * Draw the given char using the current font and color in the x,y 
  299.      * coordinates.
  300.      * 
  301.      * @param g the graphics object
  302.      * @param character the given character
  303.      * @param x the x coordinate to draw the char
  304.      * @param y the y coordinate to draw the char
  305.      */
  306.     void drawChar(Graphics g, char character, int x, int y) {
  307.     }
  308.     
  309.     /**
  310.      * Return the global default font instance
  311.      * 
  312.      * @return the global default font instance
  313.      */
  314.     public static Font getDefaultFont(){
  315.         return defaultFont;
  316.     }
  317.     /**
  318.      * Sets the global default font instance 
  319.      * 
  320.      * @param f the global default font instance 
  321.      */
  322.     public static void setDefaultFont(Font f) {
  323.         if(f != null) {
  324.             defaultFont = f;
  325.         }
  326.     }
  327.     
  328.     /**
  329.      * Draw the given char array using the current font and color in the x,y 
  330.      * coordinates
  331.      * 
  332.      * @param g the graphics object
  333.      * @param data the given char array 
  334.      * @param offset the offset in the given char array
  335.      * @param length the number of chars to draw
  336.      * @param x the x coordinate to draw the char
  337.      * @param y the y coordinate to draw the char
  338.      */
  339.     void drawChars(Graphics g, char[] data, int offset, int length, int x, int y) {
  340.     }
  341.     /**
  342.      * Return Optional operation returning the font face for system fonts
  343.      * 
  344.      * @return Optional operation returning the font face for system fonts
  345.      */
  346.     public int getFace(){
  347.         return Display.getInstance().getImplementation().getFace(font);
  348.     }
  349.     
  350.     /**
  351.      * Return Optional operation returning the font size for system fonts
  352.      * 
  353.      * @return Optional operation returning the font size for system fonts
  354.      */
  355.     public int getSize(){
  356.         return Display.getInstance().getImplementation().getSize(font);
  357.     }
  358.     /**
  359.      * Return Optional operation returning the font style for system fonts
  360.      * 
  361.      * @return Optional operation returning the font style for system fonts
  362.      */
  363.     public int getStyle() {
  364.         return Display.getInstance().getImplementation().getStyle(font);
  365.     }
  366.     
  367.     /**
  368.      * Returns a string containing all the characters supported by this font.
  369.      * Will return null for system fonts.
  370.      * 
  371.      * @return String containing the characters supported by a bitmap font or
  372.      * null otherwise.
  373.      */
  374.     public String getCharset() {
  375.         return null;
  376.     }
  377.     /**
  378.      * Indicates whether bitmap fonts should be enabled by default when loading or
  379.      * the fallback system font should be used instead. This allows easy toggling
  380.      * of font loading.
  381.      *
  382.      * @param enabled true to enable bitmap font loading (if they exist in the resource)
  383.      */
  384.     public static void setBitmapFontEnabled(boolean enabled) {
  385.         enableBitmapFont = enabled;
  386.     }
  387.     /**
  388.      * Indicates whether bitmap fonts should be enabled when loading or
  389.      * the fallback system font should be used instead. This allows easy toggling
  390.      * of font loading.
  391.      *
  392.      * @return true by default indicating that bitmap font loading is enabled
  393.      */
  394.     public static boolean isBitmapFontEnabled() {
  395.         return enableBitmapFont;
  396.     }
  397.     Object getNativeFont() {
  398.         return font;
  399.     }
  400.     
  401.     /**
  402.     * @inheritDoc
  403.     */
  404.    public boolean equals(Object o) {
  405.        if(o.getClass() == getClass()) {
  406.            Font f = (Font)o;
  407.            return f.getFace() == getFace() && f.getSize() == getSize() && f.getStyle() == getStyle();
  408.        }
  409.        return false;
  410.    }
  411. }