Class Font

java.lang.Object
com.codename1.ui.CN1Constants
com.codename1.ui.CN
com.codename1.ui.Font
public class Font extends CN

Codename One currently supports 3 font types:

  • System fonts - these are very simplistic builtin fonts. They work on all platforms and come in one of 3 sizes. However, they are ubiquitous and work in every platform in all languages. A system font can be created using int, int).

  • TTF files - you can just place a TTF file in the src directory of the project and it will appear in the Codename One Designer as an option. You can load such a font using java.lang.String).

  • Native fonts - these aren't supported on all platforms but generally they allow you to use a set of platform native good looking fonts. E.g. on Android the devices Roboto font will be used and on iOS Helvetica Neue will be used. You can load such a font using java.lang.String).

WARNING: If you use a TTF file MAKE SURE not to delete the file when there MIGHT be a reference to it. This can cause hard to track down issues!

IMPORTANT: due to copyright restrictions we cannot distribute Helvetica and thus can't simulate it. In the simulator you will see Roboto as the fallback in some cases and not the device font unless you are running on a Mac. Notice that the Roboto font from Google doesn't support all languages and thus special characters might not work on the simulator but would work on the device.

The sample code below demonstrates a catalog of available fonts, the scr

private Label createForFont(Font fnt, String s) {
  Label l = new Label(s);
  l.getUnselectedStyle().setFont(fnt);
  return l;
}

public void showForm() {
  GridLayout gr = new GridLayout(5);
  gr.setAutoFit(true);
  Form hi = new Form("Fonts", gr);

  int fontSize = Display.getInstance().convertToPixels(3);

  // requires Handlee-Regular.ttf in the src folder root!
  Font ttfFont = Font.createTrueTypeFont("Handlee", "Handlee-Regular.ttf").
                      derive(fontSize, Font.STYLE_PLAIN);

  Font smallPlainSystemFont = Font.createSystemFont(Font.FACE_SYSTEM, Font.STYLE_PLAIN, Font.SIZE_SMALL);
  Font mediumPlainSystemFont = Font.createSystemFont(Font.FACE_SYSTEM, Font.STYLE_PLAIN, Font.SIZE_MEDIUM);
  Font largePlainSystemFont = Font.createSystemFont(Font.FACE_SYSTEM, Font.STYLE_PLAIN, Font.SIZE_LARGE);
  Font smallBoldSystemFont = Font.createSystemFont(Font.FACE_SYSTEM, Font.STYLE_BOLD, Font.SIZE_SMALL);
  Font mediumBoldSystemFont = Font.createSystemFont(Font.FACE_SYSTEM, Font.STYLE_BOLD, Font.SIZE_MEDIUM);
  Font largeBoldSystemFont = Font.createSystemFont(Font.FACE_SYSTEM, Font.STYLE_BOLD, Font.SIZE_LARGE);
  Font smallItalicSystemFont = Font.createSystemFont(Font.FACE_SYSTEM, Font.STYLE_ITALIC, Font.SIZE_SMALL);
  Font mediumItalicSystemFont = Font.createSystemFont(Font.FACE_SYSTEM, Font.STYLE_ITALIC, Font.SIZE_MEDIUM);
  Font largeItalicSystemFont = Font.createSystemFont(Font.FACE_SYSTEM, Font.STYLE_ITALIC, Font.SIZE_LARGE);

  Font smallPlainMonospaceFont = Font.createSystemFont(Font.FACE_MONOSPACE, Font.STYLE_PLAIN, Font.SIZE_SMALL);
  Font mediumPlainMonospaceFont = Font.createSystemFont(Font.FACE_MONOSPACE, Font.STYLE_PLAIN, Font.SIZE_MEDIUM);
  Font largePlainMonospaceFont = Font.createSystemFont(Font.FACE_MONOSPACE, Font.STYLE_PLAIN, Font.SIZE_LARGE);
  Font smallBoldMonospaceFont = Font.createSystemFont(Font.FACE_MONOSPACE, Font.STYLE_BOLD, Font.SIZE_SMALL);
  Font mediumBoldMonospaceFont = Font.createSystemFont(Font.FACE_MONOSPACE, Font.STYLE_BOLD, Font.SIZE_MEDIUM);
  Font largeBoldMonospaceFont = Font.createSystemFont(Font.FACE_MONOSPACE, Font.STYLE_BOLD, Font.SIZE_LARGE);
  Font smallItalicMonospaceFont = Font.createSystemFont(Font.FACE_MONOSPACE, Font.STYLE_ITALIC, Font.SIZE_SMALL);
  Font mediumItalicMonospaceFont = Font.createSystemFont(Font.FACE_MONOSPACE, Font.STYLE_ITALIC, Font.SIZE_MEDIUM);
  Font largeItalicMonospaceFont = Font.createSystemFont(Font.FACE_MONOSPACE, Font.STYLE_ITALIC, Font.SIZE_LARGE);

  Font smallPlainProportionalFont = Font.createSystemFont(Font.FACE_PROPORTIONAL, Font.STYLE_PLAIN, Font.SIZE_SMALL);
  Font mediumPlainProportionalFont = Font.createSystemFont(Font.FACE_PROPORTIONAL, Font.STYLE_PLAIN, Font.SIZE_MEDIUM);
  Font largePlainProportionalFont = Font.createSystemFont(Font.FACE_PROPORTIONAL, Font.STYLE_PLAIN, Font.SIZE_LARGE);
  Font smallBoldProportionalFont = Font.createSystemFont(Font.FACE_PROPORTIONAL, Font.STYLE_BOLD, Font.SIZE_SMALL);
  Font mediumBoldProportionalFont = Font.createSystemFont(Font.FACE_PROPORTIONAL, Font.STYLE_BOLD, Font.SIZE_MEDIUM);
  Font largeBoldProportionalFont = Font.createSystemFont(Font.FACE_PROPORTIONAL, Font.STYLE_BOLD, Font.SIZE_LARGE);
  Font smallItalicProportionalFont = Font.createSystemFont(Font.FACE_PROPORTIONAL, Font.STYLE_ITALIC, Font.SIZE_SMALL);
  Font mediumItalicProportionalFont = Font.createSystemFont(Font.FACE_PROPORTIONAL, Font.STYLE_ITALIC, Font.SIZE_MEDIUM);
  Font largeItalicProportionalFont = Font.createSystemFont(Font.FACE_PROPORTIONAL, Font.STYLE_ITALIC, Font.SIZE_LARGE);

  String[] nativeFontTypes = {
      "native:MainThin", "native:MainLight", "native:MainRegular", "native:MainBold", "native:MainBlack",
      "native:ItalicThin", "native:ItalicLight", "native:ItalicRegular", "native:ItalicBold", "native:ItalicBlack"};

  for(String s : nativeFontTypes) {
      Font tt  = Font.createTrueTypeFont(s, s).derive(fontSize, Font.STYLE_PLAIN);
      hi.add(createForFont(tt, s));
  }

  hi.add(createForFont(ttfFont, "Handlee TTF Font")).
          add(createForFont(smallPlainSystemFont, "smallPlainSystemFont")).
          add(createForFont(mediumPlainSystemFont, "mediumPlainSystemFont")).
          add(createForFont(largePlainSystemFont, "largePlainSystemFont")).
          add(createForFont(smallBoldSystemFont, "smallBoldSystemFont")).
          add(createForFont(mediumBoldSystemFont, "mediumBoldSystemFont")).
          add(createForFont(largeBoldSystemFont, "largeBoldSystemFont")).
          add(createForFont(smallPlainSystemFont, "smallItalicSystemFont")).
          add(createForFont(mediumItalicSystemFont, "mediumItalicSystemFont")).
          add(createForFont(largeItalicSystemFont, "largeItalicSystemFont")).

          add(createForFont(smallPlainMonospaceFont, "smallPlainMonospaceFont")).
          add(createForFont(mediumPlainMonospaceFont, "mediumPlainMonospaceFont")).
          add(createForFont(largePlainMonospaceFont, "largePlainMonospaceFont")).
          add(createForFont(smallBoldMonospaceFont, "smallBoldMonospaceFont")).
          add(createForFont(mediumBoldMonospaceFont, "mediumBoldMonospaceFont")).
          add(createForFont(largeBoldMonospaceFont, "largeBoldMonospaceFont")).
          add(createForFont(smallItalicMonospaceFont, "smallItalicMonospaceFont")).
          add(createForFont(mediumItalicMonospaceFont, "mediumItalicMonospaceFont")).
          add(createForFont(largeItalicMonospaceFont, "largeItalicMonospaceFont")).

          add(createForFont(smallPlainProportionalFont, "smallPlainProportionalFont")).
          add(createForFont(mediumPlainProportionalFont, "mediumPlainProportionalFont")).
          add(createForFont(largePlainProportionalFont, "largePlainProportionalFont")).
          add(createForFont(smallBoldProportionalFont, "smallBoldProportionalFont")).
          add(createForFont(mediumBoldProportionalFont, "mediumBoldProportionalFont")).
          add(createForFont(largeBoldProportionalFont, "largeBoldProportionalFont")).
          add(createForFont(smallItalicProportionalFont, "smallItalicProportionalFont")).
          add(createForFont(mediumItalicProportionalFont, "mediumItalicProportionalFont")).
          add(createForFont(largeItalicProportionalFont, "largeItalicProportionalFont"));

  hi.show();
}

The demo code on the iPad simulator on a Mac

The demo code on an Android 5.1 OPO device (OnePlus One)

The Font class also supports bitmap fonts but this support is strictly aimed at legacy applications. We no longer maintain that functionality.

  • Method Details

    • getBitmapFont

      public static Font getBitmapFont(String fontName)

      Returns a previously loaded bitmap font from cache

      Parameters
      • fontName: the font name is the logical name of the font
      Returns

      the font object

      Deprecated

      bitmap font functionality is now deprecated

      See also
      • #clearBitmapCache

    • clearBitmapCache

      public static void clearBitmapCache()

      Bitmap fonts are cached this method allows us to flush the cache thus allows us to reload a font

      Deprecated

      bitmap font functionality is now deprecated

    • isTrueTypeFileSupported

      public static boolean isTrueTypeFileSupported()

      Returns true if the underlying platform supports loading truetype fonts from a file.

      Returns
      Returns:
      true if the underlying platform supports loading truetype fonts from a file

    • isCreationByStringSupported

      public static boolean isCreationByStringSupported()

      Returns true if the underlying platform allows creating a font based on a user submitted string.

      Returns
      Returns:
      true if the underlying platform allows creating a font based on a user submitted string

    • isNativeFontSchemeSupported

      public static boolean isNativeFontSchemeSupported()

      Indicates whether the implementation supports loading a font "natively" to handle one of the common native prefixes

      Returns

      true if the "native:" prefix is supported by loadTrueTypeFont

    • createTrueTypeFont

      public static Font createTrueTypeFont(String fontName)

      Shorthand for createTrueTypeFont(name, name) which is useful for cases such as native: fonts. If a TTF file is passed this method will throw an exception!

      Parameters
      • fontName: the native font name. Notice that TTF file names are prohibited
      Returns

      a font object

    • createTrueTypeFont

      public static Font createTrueTypeFont(String fontName, float sizeMm)

      Shorthand for createTrueTypeFont(name, name) & derive(size) which is useful for cases such as native: fonts.

      Parameters

      • fontName: the native font name

      • sizeMm: the size in mm

      Returns

      a font object

    • createTrueTypeFont

      public static Font createTrueTypeFont(String fontName, float size, byte sizeUnit)

      Shorthand for createTrueTypeFont(name, name) & derive(size) which is useful for cases such as native: fonts.

      Parameters

      • fontName: the native font name

      • size: the size in the specified unit.

      • sizeUnit: @param sizeUnit The unit type of the size. One of com.codename1.ui.plaf.Style#UNIT_TYPE_DIPS,

      •             `com.codename1.ui.plaf.Style#UNIT_TYPE_PIXELS`,

      •             `com.codename1.ui.plaf.Style#UNIT_TYPE_REM`,

      •             `com.codename1.ui.plaf.Style#UNIT_TYPE_VW`,

      •             `com.codename1.ui.plaf.Style#UNIT_TYPE_VH`,

      •             `com.codename1.ui.plaf.Style#UNIT_TYPE_VMIN`,

      •             `com.codename1.ui.plaf.Style#UNIT_TYPE_VMAX`.
      Returns

      a font object

      Since

      8.0

    • createTrueTypeFont

      public static Font createTrueTypeFont(String fontName, String fileName)

      Creates a true type font with the given name/filename (font name might be different from the file name and is required by some devices e.g. iOS). The font file must reside in the src root of the project in order to be detectable. The file name should contain no slashes or any such value.

      Important some platforms e.g. iOS don't support changing the weight of the font and require you to use the font name matching the weight, so the weight argument to derive will be ignored!

      This system also supports a special "native:" prefix that uses system native fonts e.g. HelveticaNeue on iOS and Roboto on Android. It supports the following types: native:MainThin, native:MainLight, native:MainRegular, native:MainBold, native:MainBlack, native:ItalicThin, native:ItalicLight, native:ItalicRegular, native:ItalicBold, native:ItalicBlack. Important due to copyright restrictions we cannot distribute Helvetica and thus can't simulate it. In the simulator you will see Roboto and not the device font unless you are running on a Mac

      Parameters

      • fontName: the name of the font

      • fileName: the file name of the font as it appears in the src directory of the project, it MUST end with the .ttf extension!

      Returns

      the font object created or null if true type fonts aren't supported on this platform

    • create

      public static Font create(String lookup)

      Creates a new font instance based on the platform specific string name of the font. This method isn't supported on some platforms.

      Parameters
      • lookup: @param lookup a set of platform specific names delimited by commas, the first succefully loaded font will be used
      Returns

      newly created font or null if creation failed

    • createBitmapFont

      public static Font createBitmapFont(String name, Image bitmap, int[] cutOffsets, int[] charWidth, String charsets)

      Creates a bitmap font with the given arguments and places said font in the cache

      Parameters

      • name: the name for the font in the cache

      • bitmap: a transparency map in red and black that indicates the characters

      • cutOffsets: character offsets matching the bitmap pixels and characters in the font

      • charWidth: @param charWidth The width of the character when drawing... this should not be confused with the number of cutOffset[o + 1] - cutOffset[o]. They are completely different since a character can be "wider" and "seep" into the next region. This is especially true with italic characters all of which "lean" outside of their bounds.

      • charsets: the set of characters in the font

      Returns

      a font object to draw bitmap fonts

      Deprecated

      bitmap font functionality is now deprecated

    • createBitmapFont

      public static Font createBitmapFont(Image bitmap, int[] cutOffsets, int[] charWidth, String charsets)

      Creates a bitmap font with the given arguments

      Parameters

      • bitmap: a transparency map in red and black that indicates the characters

      • cutOffsets: character offsets matching the bitmap pixels and characters in the font

      • charWidth: @param charWidth The width of the character when drawing... this should not be confused with the number of cutOffset[o + 1] - cutOffset[o]. They are completely different since a character can be "wider" and "seep" into the next region. This is especially true with italic characters all of which "lean" outside of their bounds.

      • charsets: the set of characters in the font

      Returns

      a font object to draw bitmap fonts

      Deprecated

      bitmap font functionality is now deprecated

    • createSystemFont

      public static Font createSystemFont(int face, int style, int size)

      Creates a system native font in a similar way to common MIDP fonts

      Parameters

      • face: One of FACE_SYSTEM, FACE_PROPORTIONAL, FACE_MONOSPACE

      • style: one of STYLE_PLAIN, STYLE_ITALIC, STYLE_BOLD

      • size: One of SIZE_SMALL, SIZE_MEDIUM, SIZE_LARGE

      Returns

      A newly created system font instance

    • getDefaultFont

      public static Font getDefaultFont()

      Return the global default font instance

      Returns

      the global default font instance

    • setDefaultFont

      public static void setDefaultFont(Font f)

      Sets the global default font instance

      Parameters
      • f: the global default font instance

    • isBitmapFontEnabled

      public static boolean isBitmapFontEnabled()

      Indicates whether bitmap fonts should be enabled when loading or the fallback system font should be used instead. This allows easy toggling of font loading.

      Returns

      true by default indicating that bitmap font loading is enabled

    • setBitmapFontEnabled

      public static void setBitmapFontEnabled(boolean enabled)

      Indicates whether bitmap fonts should be enabled by default when loading or the fallback system font should be used instead. This allows easy toggling of font loading.

      Parameters
      • enabled: true to enable bitmap font loading (if they exist in the resource)

    • derive

      public Font derive(float size, int weight, byte unitType)

      Creates a font based on this truetype font with the given pixel, WARNING! This method will only work in the case of truetype fonts!

      Important some platforms e.g. iOS don't support changing the weight of the font and require you to use the font name matching the weight, so the weight argument to derive will be ignored!

      Parameters

      • size: the size of the font in the specified unit type.

      • weight: PLAIN, BOLD or ITALIC weight based on the constants in this class

      • unitType: @param unitType The unit type of the size. One of com.codename1.ui.plaf.Style#UNIT_TYPE_DIPS, com.codename1.ui.plaf.Style#UNIT_TYPE_PIXELS, com.codename1.ui.plaf.Style#UNIT_TYPE_REM, com.codename1.ui.plaf.Style#UNIT_TYPE_VW, com.codename1.ui.plaf.Style#UNIT_TYPE_VH, com.codename1.ui.plaf.Style#UNIT_TYPE_VMIN, com.codename1.ui.plaf.Style#UNIT_TYPE_VMAX.

      Returns

      scaled font instance

      Since

      8.0

    • derive

      public Font derive(float sizePixels, int weight)

      Creates a font based on this truetype font with the given pixel, WARNING! This method will only work in the case of truetype fonts!

      Important some platforms e.g. iOS don't support changing the weight of the font and require you to use the font name matching the weight, so the weight argument to derive will be ignored!

      Parameters

      • sizePixels: the size of the font in pixels

      • weight: PLAIN, BOLD or ITALIC weight based on the constants in this class

      Returns

      scaled font instance

    • isTTFNativeFont

      public boolean isTTFNativeFont()

      Indicates if this is a TTF native font that can be derived and manipulated. This is true for a font loaded from file (TTF) or using the native: font name

      Returns

      true if this is a native font

    • addContrast

      public void addContrast(byte value)

      Increase the contrast of the bitmap font for rendering on top of a surface whose color is darker. This is useful when drawing anti-aliased bitmap fonts using a light color (e.g. white) on top of a dark surface (e.g. black), the font often breaks down if its contrast is not increased due to the way alpha blending appears to the eye.

      Notice that this method only works in one way, contrast cannot be decreased properly in a font and it should be cleared and reloaed with a Look and Feel switch.

      Parameters
      • value: the value to increase
      Deprecated

      bitmap font functionality is now deprecated

    • charsWidth

      public int charsWidth(char[] ch, int offset, int length)

      Return the width of the given characters in this font instance

      Parameters

      • ch: array of characters

      • offset: characters offsets

      • length: characters length

      Returns

      the width of the given characters in this font instance

    • substringWidth

      public int substringWidth(String str, int offset, int len)

      Return the width of the given string subset in this font instance

      Parameters

      • str: the given string

      • offset: the string offset

      • len: the len od string

      Returns

      the width of the given string subset in this font instance

    • stringWidth

      public int stringWidth(String str)

      Return the width of the given string in this font instance

      Parameters
      • str: the given string *
      Returns

      the width of the given string in this font instance

    • charWidth

      public int charWidth(char ch)

      Return the width of the specific character when rendered alone

      Parameters
      • ch: the specific character
      Returns

      the width of the specific character when rendered alone

    • getHeight

      public int getHeight()

      Return the total height of the font

      Returns

      the total height of the font

    • getFace

      public int getFace()

      Return Optional operation returning the font face for system fonts

      Returns

      Optional operation returning the font face for system fonts

    • getSize

      public int getSize()

      Return Optional operation returning the font size for system fonts

      Returns

      Optional operation returning the font size for system fonts

    • getStyle

      public int getStyle()

      Return Optional operation returning the font style for system fonts

      Returns

      Optional operation returning the font style for system fonts

    • getCharset

      public String getCharset()

      Returns a string containing all the characters supported by this font. Will return null for system fonts.

      Returns
      Returns:
      String containing the characters supported by a bitmap font or null otherwise.

    • getNativeFont

      public Object getNativeFont()

      Returns the internal implementation specific font object

      Returns

      platform specific font object for use by implementation classes or native code

    • equals

      public boolean equals(Object o)
      Indicates whether some other object is "equal to" this one. The equals method implements an equivalence relation: It is reflexive: for any reference value x, x.equals(x) should return true. It is symmetric: for any reference values x and y, x.equals(y) should return true if and only if y.equals(x) returns true. It is transitive: for any reference values x, y, and z, if x.equals(y) returns true and y.equals(z) returns true, then x.equals(z) should return true. It is consistent: for any reference values x and y, multiple invocations of x.equals(y) consistently return true or consistently return false, provided no information used in equals comparisons on the object is modified. For any non-null reference value x, x.equals(null) should return false. The equals method for class Object implements the most discriminating possible equivalence relation on objects; that is, for any reference values x and y, this method returns true if and only if x and y refer to the same object (x==y has the value true).
      Overrides:
      equals in class Object

    • hashCode

      public int hashCode()
      Returns a hash code value for the object. This method is supported for the benefit of hashtables such as those provided by java.util.Hashtable. The general contract of hashCode is: Whenever it is invoked on the same object more than once during an execution of a Java application, the hashCode method must consistently return the same integer, provided no information used in equals comparisons on the object is modified. This integer need not remain consistent from one execution of an application to another execution of the same application. If two objects are equal according to the equals(Object) method, then calling the hashCode method on each of the two objects must produce the same integer result. It is not required that if two objects are unequal according to the equals(java.lang.Object) method, then calling the hashCode method on each of the two objects must produce distinct integer results. However, the programmer should be aware that producing distinct integer results for unequal objects may improve the performance of hashtables. As much as is reasonably practical, the hashCode method defined by class Object does return distinct integers for distinct objects. (This is typically implemented by converting the internal address of the object into an integer, but this implementation technique is not required by the JavaTM programming language.)
      Overrides:
      hashCode in class Object

    • getAscent

      public int getAscent()

      The ascent is the amount by which the character ascends above the baseline.

      Returns

      the ascent in pixels

    • getDescent

      public int getDescent()

      The descent is the amount by which the character descends below the baseline

      Returns

      the descent in pixels

    • getPixelSize

      public float getPixelSize()

      Returns the size with which the font object was created in case of truetype fonts/derived fonts. This is useful since a platform might change things slightly based on platform constraints but this value should be 100% consistent

      Returns

      the size requested in the derive method