com.lowagie.text.pdf

## Class BaseFont

- java.lang.Object
- - com.lowagie.text.pdf.BaseFont

- Direct Known Subclasses:
    CJKFont, DocumentFont, TrueTypeFont, Type1Font, Type3Font

      public abstract class BaseFont
      extends java.lang.Object

  Base class for the several font types supported
  Author:
    Paulo Soares (psoares@consiste.pt)

- - ### Nested Class Summary

    Nested Classes
    Modifier and Type | Class and Description
    --- | ---
    `(package private) static class` | `BaseFont.StreamFont` Generates the PDF stream with the Type1 and Truetype fonts returning a PdfStream.

  - ### Field Summary

    Fields
    Modifier and Type | Field and Description
    --- | ---
    `static int` | `ASCENT` The maximum height above the baseline reached by glyphs in this font, excluding the height of glyphs for accented characters.
    `static int` | `AWT_ASCENT` java.awt.Font property
    `static int` | `AWT_DESCENT` java.awt.Font property
    `static int` | `AWT_LEADING` java.awt.Font property
    `static int` | `AWT_MAXADVANCE` java.awt.Font property
    `static int` | `BBOXLLX` The lower left x glyph coordinate.
    `static int` | `BBOXLLY` The lower left y glyph coordinate.
    `static int` | `BBOXURX` The upper right x glyph coordinate.
    `static int` | `BBOXURY` The upper right y glyph coordinate.
    `protected static java.util.HashMap` | `BuiltinFonts14` list of the 14 built in fonts.
    `static boolean` | `CACHED` if the font has to be cached
    `static int` | `CAPHEIGHT` The y coordinate of the top of flat capital letters, measured from the baseline.
    `static int[]` | `CHAR_RANGE_ARABIC`
    `static int[]` | `CHAR_RANGE_CYRILLIC`
    `static int[]` | `CHAR_RANGE_HEBREW`
    `static int[]` | `CHAR_RANGE_LATIN`
    `protected int[][]` | `charBBoxes`
    `static char` | `CID_NEWLINE` The fake CID code that represents a newline.
    `protected int` | `compressionLevel` The compression level for the font stream.
    `static java.lang.String` | `COURIER` This is a possible value of a base 14 type 1 font
    `static java.lang.String` | `COURIER_BOLD` This is a possible value of a base 14 type 1 font
    `static java.lang.String` | `COURIER_BOLDOBLIQUE` This is a possible value of a base 14 type 1 font
    `static java.lang.String` | `COURIER_OBLIQUE` This is a possible value of a base 14 type 1 font
    `static java.lang.String` | `CP1250` A possible encoding.
    `static java.lang.String` | `CP1252` A possible encoding.
    `static java.lang.String` | `CP1257` A possible encoding.
    `static int` | `DESCENT` The maximum depth below the baseline reached by glyphs in this font.
    `protected java.lang.String[]` | `differences` encoding names
    `protected boolean` | `directTextToByte` Converts `char` directly to `byte` by casting.
    `protected boolean` | `embedded` true if the font is to be embedded in the PDF
    `static boolean` | `EMBEDDED` if the font has to be embedded
    `protected java.lang.String` | `encoding` encoding used with this font
    `protected boolean` | `fastWinansi`
    `static int` | `FONT_TYPE_CJK` The font is CJK.
    `static int` | `FONT_TYPE_DOCUMENT` A font already inside the document.
    `static int` | `FONT_TYPE_T1` The font is Type 1.
    `static int` | `FONT_TYPE_T3` A Type3 font.
    `static int` | `FONT_TYPE_TT` The font is True Type with a standard encoding.
    `static int` | `FONT_TYPE_TTUNI` The font is True Type with a Unicode encoding.
    `protected static java.util.HashMap` | `fontCache` cache for the fonts already used.
    `protected boolean` | `fontSpecific` true if the font must use its built in encoding.
    `(package private) int` | `fontType` The font type.
    `protected boolean` | `forceWidthsOutput` Forces the output of the width array.
    `static java.lang.String` | `HELVETICA` This is a possible value of a base 14 type 1 font
    `static java.lang.String` | `HELVETICA_BOLD` This is a possible value of a base 14 type 1 font
    `static java.lang.String` | `HELVETICA_BOLDOBLIQUE` This is a possible value of a base 14 type 1 font
    `static java.lang.String` | `HELVETICA_OBLIQUE` This is a possible value of a base 14 type 1 font
    `static java.lang.String` | `IDENTITY_H` The Unicode encoding with horizontal writing.
    `static java.lang.String` | `IDENTITY_V` The Unicode encoding with vertical writing.
    `static int` | `ITALICANGLE` The angle, expressed in degrees counterclockwise from the vertical, of the dominant vertical strokes of the font.
    `static java.lang.String` | `MACROMAN` A possible encoding.
    `static boolean` | `NOT_CACHED` if the font doesn't have to be cached
    `static boolean` | `NOT_EMBEDDED` if the font doesn't have to be embedded
    `static java.lang.String` | `notdef` a not defined character in a custom PDF encoding
    `static java.lang.String` | `RESOURCE_PATH` The path to the font resources.
    `protected IntHashtable` | `specialMap` Custom encodings use this map to key the Unicode character to the single byte code.
    `static int` | `STRIKETHROUGH_POSITION` The strikethrough position.
    `static int` | `STRIKETHROUGH_THICKNESS` The strikethrough thickness.
    `static int` | `SUBSCRIPT_OFFSET` The recommended vertical offset from the baseline for subscripts for this font.
    `static int` | `SUBSCRIPT_SIZE` The recommended vertical size for subscripts for this font.
    `protected boolean` | `subset` Indicates if all the glyphs and widths for that particular encoding should be included in the document.
    `protected java.util.ArrayList` | `subsetRanges`
    `static int` | `SUPERSCRIPT_OFFSET` The recommended vertical offset from the baseline for superscripts for this font.
    `static int` | `SUPERSCRIPT_SIZE` The recommended vertical size for superscripts for this font.
    `static java.lang.String` | `SYMBOL` This is a possible value of a base 14 type 1 font
    `static java.lang.String` | `TIMES_BOLD` This is a possible value of a base 14 type 1 font
    `static java.lang.String` | `TIMES_BOLDITALIC` This is a possible value of a base 14 type 1 font
    `static java.lang.String` | `TIMES_ITALIC` This is a possible value of a base 14 type 1 font
    `static java.lang.String` | `TIMES_ROMAN` This is a possible value of a base 14 type 1 font
    `static int` | `UNDERLINE_POSITION` The underline position.
    `static int` | `UNDERLINE_THICKNESS` The underline thickness.
    `protected char[]` | `unicodeDifferences` same as differences but with the unicode codes
    `protected int[]` | `widths` table of characters widths for this encoding
    `static java.lang.String` | `WINANSI` A possible encoding.
    `static java.lang.String` | `ZAPFDINGBATS` This is a possible value of a base 14 type 1 font

  - ### Constructor Summary

    Constructors
    Modifier | Constructor and Description
    --- | ---
    `protected` | `BaseFont()` Creates new BaseFont

  - ### Method Summary

    Methods
    Modifier and Type | Method and Description
    --- | ---
    `private static void` | `addFont(PRIndirectReference fontRef, IntHashtable hits, java.util.ArrayList fonts)`
    `void` | `addSubsetRange(int[] range)` Adds a character range when subsetting.
    `boolean` | `charExists(int c)` Checks if a character exists in this font.
    `(package private) byte[]` | `convertToBytes(int char1)` Converts a `char` to a byte array according to the font's encoding.
    `(package private) byte[]` | `convertToBytes(java.lang.String text)` Converts a `String` to a byte array according to the font's encoding.
    `void` | `correctArabicAdvance()` iText expects Arabic Diactrics (tashkeel) to have zero advance but some fonts, most notably those that come with Windows, like times.ttf, have non-zero advance for those characters.
    `protected void` | `createEncoding()` Creates the `widths` and the `differences` arrays
    `static BaseFont` | `createFont()` Creates a new font.
    `static BaseFont` | `createFont(PRIndirectReference fontRef)` Creates a font based on an existing document font.
    `static BaseFont` | `createFont(java.lang.String name, java.lang.String encoding, boolean embedded)` Creates a new font.
    `static BaseFont` | `createFont(java.lang.String name, java.lang.String encoding, boolean embedded, boolean forceRead)` Creates a new font.
    `static BaseFont` | `createFont(java.lang.String name, java.lang.String encoding, boolean embedded, boolean cached, byte[] ttfAfm, byte[] pfb)` Creates a new font.
    `static BaseFont` | `createFont(java.lang.String name, java.lang.String encoding, boolean embedded, boolean cached, byte[] ttfAfm, byte[] pfb, boolean noThrow)` Creates a new font.
    `static BaseFont` | `createFont(java.lang.String name, java.lang.String encoding, boolean embedded, boolean cached, byte[] ttfAfm, byte[] pfb, boolean noThrow, boolean forceRead)` Creates a new font.
    `static java.lang.String` | `createSubsetPrefix()` Creates a unique subset prefix to be added to the font name when the font is embedded and subset.
    `static java.lang.String[]` | `enumerateTTCNames(byte[] ttcArray)` Enumerates the postscript font names present inside a True Type Collection.
    `static java.lang.String[]` | `enumerateTTCNames(java.lang.String ttcFile)` Enumerates the postscript font names present inside a True Type Collection.
    `static java.lang.Object[]` | `getAllFontNames(java.lang.String name, java.lang.String encoding, byte[] ttfAfm)` Gets all the names from the font.
    `abstract java.lang.String[][]` | `getAllNameEntries()` Gets all the entries of the names-table.
    `static java.lang.String[][]` | `getAllNameEntries(java.lang.String name, java.lang.String encoding, byte[] ttfAfm)` Gets all the entries of the namestable from the font.
    `int` | `getAscent(java.lang.String text)` Gets the ascent of a `String` in normalized 1000 units.
    `float` | `getAscentPoint(java.lang.String text, float fontSize)` Gets the ascent of a `String` in points.
    `protected static java.lang.String` | `getBaseName(java.lang.String name)` Gets the name without the modifiers Bold, Italic or BoldItalic.
    `int[]` | `getCharBBox(int c)` Gets the smallest box enclosing the character contours.
    `int` | `getCidCode(int c)` Gets the CID code given an Unicode.
    `java.lang.String[]` | `getCodePagesSupported()` Gets the code pages supported by the font.
    `int` | `getCompressionLevel()` Returns the compression level used for the font streams.
    `int` | `getDescent(java.lang.String text)` Gets the descent of a `String` in normalized 1000 units.
    `float` | `getDescentPoint(java.lang.String text, float fontSize)` Gets the descent of a `String` in points.
    `java.lang.String[]` | `getDifferences()` Gets the array with the names of the characters.
    `static java.util.ArrayList` | `getDocumentFonts(PdfReader reader)` Gets a list of all document fonts.
    `static java.util.ArrayList` | `getDocumentFonts(PdfReader reader, int page)` Gets a list of the document fonts in a particular page.
    `java.lang.String` | `getEncoding()` Gets the encoding used to convert `String` into `byte[]`.
    `abstract java.lang.String[][]` | `getFamilyFontName()` Gets the family name of the font.
    `abstract float` | `getFontDescriptor(int key, float fontSize)` Gets the font parameter identified by `key`.
    `int` | `getFontType()` Gets the font type.
    `abstract java.lang.String[][]` | `getFullFontName()` Gets the full name of the font.
    `static java.lang.String[][]` | `getFullFontName(java.lang.String name, java.lang.String encoding, byte[] ttfAfm)` Gets the full name of the font.
    `(package private) abstract PdfStream` | `getFullFontStream()` Returns a PdfStream object with the full font program (if possible).
    `abstract int` | `getKerning(int char1, int char2)` Gets the kerning between two Unicode chars.
    `abstract java.lang.String` | `getPostscriptFontName()` Gets the postscript font name.
    `protected abstract int[]` | `getRawCharBBox(int c, java.lang.String name)`
    `(package private) abstract int` | `getRawWidth(int c, java.lang.String name)` Gets the width from the font according to the Unicode char `c` or the `name`.
    `static java.io.InputStream` | `getResourceStream(java.lang.String key)` Gets the font resources.
    `static java.io.InputStream` | `getResourceStream(java.lang.String key, java.lang.ClassLoader loader)` Gets the font resources.
    `char[]` | `getUnicodeDifferences()` Gets the array with the unicode characters.
    `(package private) char` | `getUnicodeDifferences(int index)` Gets the Unicode character corresponding to the byte output to the pdf stream.
    `int` | `getUnicodeEquivalent(int c)` Gets the Unicode equivalent to a CID.
    `int` | `getWidth(int char1)` Gets the width of a `char` in normalized 1000 units.
    `int` | `getWidth(java.lang.String text)` Gets the width of a `String` in normalized 1000 units.
    `float` | `getWidthPoint(int char1, float fontSize)` Gets the width of a `char` in points.
    `float` | `getWidthPoint(java.lang.String text, float fontSize)` Gets the width of a `String` in points.
    `float` | `getWidthPointKerned(java.lang.String text, float fontSize)` Gets the width of a `String` in points taking kerning into account.
    `int[]` | `getWidths()` Gets the font width array.
    `abstract boolean` | `hasKernPairs()` Checks if the font has any kerning pairs.
    `boolean` | `isDirectTextToByte()` Gets the direct conversion of `char` to `byte`.
    `boolean` | `isEmbedded()` Gets the embedded flag.
    `boolean` | `isFontSpecific()` Gets the symbolic flag of the font.
    `boolean` | `isForceWidthsOutput()` Gets the state of the property.
    `boolean` | `isSubset()` Indicates if all the glyphs and widths for that particular encoding should be included in the document.
    `protected static java.lang.String` | `normalizeEncoding(java.lang.String enc)` Normalize the encoding names.
    `private static void` | `recourseFonts(PdfDictionary page, IntHashtable hits, java.util.ArrayList fonts, int level)`
    `boolean` | `setCharAdvance(int c, int advance)` Sets the character advance.
    `void` | `setCompressionLevel(int compressionLevel)` Sets the compression level to be used for the font streams.
    `void` | `setDirectTextToByte(boolean directTextToByte)` Sets the conversion of `char` directly to `byte` by casting.
    `void` | `setForceWidthsOutput(boolean forceWidthsOutput)` Set to `true` to force the generation of the widths array.
    `abstract boolean` | `setKerning(int char1, int char2, int kern)` Sets the kerning between two Unicode chars.
    `abstract void` | `setPostscriptFontName(java.lang.String name)` Sets the font name that will appear in the pdf font dictionary.
    `void` | `setSubset(boolean subset)` Indicates if all the glyphs and widths for that particular encoding should be included in the document.
    `(package private) abstract void` | `writeFont(PdfWriter writer, PdfIndirectReference ref, java.lang.Object[] params)` Outputs to the writer the font dictionaries and streams.

    - ### Methods inherited from class java.lang.Object

      `clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

- - ### Field Detail

    - #### COURIER

          public static final java.lang.String COURIER

      This is a possible value of a base 14 type 1 font
      See Also:
        Constant Field Values

    - #### COURIER_BOLD

          public static final java.lang.String COURIER_BOLD

      This is a possible value of a base 14 type 1 font
      See Also:
        Constant Field Values

    - #### COURIER_OBLIQUE

          public static final java.lang.String COURIER_OBLIQUE

      This is a possible value of a base 14 type 1 font
      See Also:
        Constant Field Values

    - #### COURIER_BOLDOBLIQUE

          public static final java.lang.String COURIER_BOLDOBLIQUE

      This is a possible value of a base 14 type 1 font
      See Also:
        Constant Field Values

    - #### HELVETICA

          public static final java.lang.String HELVETICA

      This is a possible value of a base 14 type 1 font
      See Also:
        Constant Field Values

    - #### HELVETICA_BOLD

          public static final java.lang.String HELVETICA_BOLD

      This is a possible value of a base 14 type 1 font
      See Also:
        Constant Field Values

    - #### HELVETICA_OBLIQUE

          public static final java.lang.String HELVETICA_OBLIQUE

      This is a possible value of a base 14 type 1 font
      See Also:
        Constant Field Values

    - #### HELVETICA_BOLDOBLIQUE

          public static final java.lang.String HELVETICA_BOLDOBLIQUE

      This is a possible value of a base 14 type 1 font
      See Also:
        Constant Field Values

    - #### SYMBOL

          public static final java.lang.String SYMBOL

      This is a possible value of a base 14 type 1 font
      See Also:
        Constant Field Values

    - #### TIMES_ROMAN

          public static final java.lang.String TIMES_ROMAN

      This is a possible value of a base 14 type 1 font
      See Also:
        Constant Field Values

    - #### TIMES_BOLD

          public static final java.lang.String TIMES_BOLD

      This is a possible value of a base 14 type 1 font
      See Also:
        Constant Field Values

    - #### TIMES_ITALIC

          public static final java.lang.String TIMES_ITALIC

      This is a possible value of a base 14 type 1 font
      See Also:
        Constant Field Values

    - #### TIMES_BOLDITALIC

          public static final java.lang.String TIMES_BOLDITALIC

      This is a possible value of a base 14 type 1 font
      See Also:
        Constant Field Values

    - #### ZAPFDINGBATS

          public static final java.lang.String ZAPFDINGBATS

      This is a possible value of a base 14 type 1 font
      See Also:
        Constant Field Values

    - #### ASCENT

          public static final int ASCENT

      The maximum height above the baseline reached by glyphs in this font, excluding the height of glyphs for accented characters.
      See Also:
        Constant Field Values

    - #### CAPHEIGHT

          public static final int CAPHEIGHT

      The y coordinate of the top of flat capital letters, measured from the baseline.
      See Also:
        Constant Field Values

    - #### DESCENT

          public static final int DESCENT

      The maximum depth below the baseline reached by glyphs in this font. The value is a negative number.
      See Also:
        Constant Field Values

    - #### ITALICANGLE

          public static final int ITALICANGLE

      The angle, expressed in degrees counterclockwise from the vertical, of the dominant vertical strokes of the font. The value is negative for fonts that slope to the right, as almost all italic fonts do.
      See Also:
        Constant Field Values

    - #### BBOXLLX

          public static final int BBOXLLX

      The lower left x glyph coordinate.
      See Also:
        Constant Field Values

    - #### BBOXLLY

          public static final int BBOXLLY

      The lower left y glyph coordinate.
      See Also:
        Constant Field Values

    - #### BBOXURX

          public static final int BBOXURX

      The upper right x glyph coordinate.
      See Also:
        Constant Field Values

    - #### BBOXURY

          public static final int BBOXURY

      The upper right y glyph coordinate.
      See Also:
        Constant Field Values

    - #### AWT_ASCENT

          public static final int AWT_ASCENT

      java.awt.Font property
      See Also:
        Constant Field Values

    - #### AWT_DESCENT

          public static final int AWT_DESCENT

      java.awt.Font property
      See Also:
        Constant Field Values

    - #### AWT_LEADING

          public static final int AWT_LEADING

      java.awt.Font property
      See Also:
        Constant Field Values

    - #### AWT_MAXADVANCE

          public static final int AWT_MAXADVANCE

      java.awt.Font property
      See Also:
        Constant Field Values

    - #### UNDERLINE_POSITION

          public static final int UNDERLINE_POSITION

      The underline position. Usually a negative value.
      See Also:
        Constant Field Values

    - #### UNDERLINE_THICKNESS

          public static final int UNDERLINE_THICKNESS

      The underline thickness.
      See Also:
        Constant Field Values

    - #### STRIKETHROUGH_POSITION

          public static final int STRIKETHROUGH_POSITION

      The strikethrough position.
      See Also:
        Constant Field Values

    - #### STRIKETHROUGH_THICKNESS

          public static final int STRIKETHROUGH_THICKNESS

      The strikethrough thickness.
      See Also:
        Constant Field Values

    - #### SUBSCRIPT_SIZE

          public static final int SUBSCRIPT_SIZE

      The recommended vertical size for subscripts for this font.
      See Also:
        Constant Field Values

    - #### SUBSCRIPT_OFFSET

          public static final int SUBSCRIPT_OFFSET

      The recommended vertical offset from the baseline for subscripts for this font. Usually a negative value.
      See Also:
        Constant Field Values

    - #### SUPERSCRIPT_SIZE

          public static final int SUPERSCRIPT_SIZE

      The recommended vertical size for superscripts for this font.
      See Also:
        Constant Field Values

    - #### SUPERSCRIPT_OFFSET

          public static final int SUPERSCRIPT_OFFSET

      The recommended vertical offset from the baseline for superscripts for this font.
      See Also:
        Constant Field Values

    - #### FONT_TYPE_T1

          public static final int FONT_TYPE_T1

      The font is Type 1.
      See Also:
        Constant Field Values

    - #### FONT_TYPE_TT

          public static final int FONT_TYPE_TT

      The font is True Type with a standard encoding.
      See Also:
        Constant Field Values

    - #### FONT_TYPE_CJK

          public static final int FONT_TYPE_CJK

      The font is CJK.
      See Also:
        Constant Field Values

    - #### FONT_TYPE_TTUNI

          public static final int FONT_TYPE_TTUNI

      The font is True Type with a Unicode encoding.
      See Also:
        Constant Field Values

    - #### FONT_TYPE_DOCUMENT

          public static final int FONT_TYPE_DOCUMENT

      A font already inside the document.
      See Also:
        Constant Field Values

    - #### FONT_TYPE_T3

          public static final int FONT_TYPE_T3

      A Type3 font.
      See Also:
        Constant Field Values

    - #### IDENTITY_H

          public static final java.lang.String IDENTITY_H

      The Unicode encoding with horizontal writing.
      See Also:
        Constant Field Values

    - #### IDENTITY_V

          public static final java.lang.String IDENTITY_V

      The Unicode encoding with vertical writing.
      See Also:
        Constant Field Values

    - #### CP1250

          public static final java.lang.String CP1250

      A possible encoding.
      See Also:
        Constant Field Values

    - #### CP1252

          public static final java.lang.String CP1252

      A possible encoding.
      See Also:
        Constant Field Values

    - #### CP1257

          public static final java.lang.String CP1257

      A possible encoding.
      See Also:
        Constant Field Values

    - #### WINANSI

          public static final java.lang.String WINANSI

      A possible encoding.
      See Also:
        Constant Field Values

    - #### MACROMAN

          public static final java.lang.String MACROMAN

      A possible encoding.
      See Also:
        Constant Field Values

    - #### CHAR_RANGE_LATIN

          public static final int[] CHAR_RANGE_LATIN

    - #### CHAR_RANGE_ARABIC

          public static final int[] CHAR_RANGE_ARABIC

    - #### CHAR_RANGE_HEBREW

          public static final int[] CHAR_RANGE_HEBREW

    - #### CHAR_RANGE_CYRILLIC

          public static final int[] CHAR_RANGE_CYRILLIC

    - #### EMBEDDED

          public static final boolean EMBEDDED

      if the font has to be embedded
      See Also:
        Constant Field Values

    - #### NOT_EMBEDDED

          public static final boolean NOT_EMBEDDED

      if the font doesn't have to be embedded
      See Also:
        Constant Field Values

    - #### CACHED

          public static final boolean CACHED

      if the font has to be cached
      See Also:
        Constant Field Values

    - #### NOT_CACHED

          public static final boolean NOT_CACHED

      if the font doesn't have to be cached
      See Also:
        Constant Field Values

    - #### RESOURCE_PATH

          public static final java.lang.String RESOURCE_PATH

      The path to the font resources.
      See Also:
        Constant Field Values

    - #### CID_NEWLINE

          public static final char CID_NEWLINE

      The fake CID code that represents a newline.
      See Also:
        Constant Field Values

    - #### subsetRanges

          protected java.util.ArrayList subsetRanges

    - #### fontType

          int fontType

      The font type.

    - #### notdef

          public static final java.lang.String notdef

      a not defined character in a custom PDF encoding
      See Also:
        Constant Field Values

    - #### widths

          protected int[] widths

      table of characters widths for this encoding

    - #### differences

          protected java.lang.String[] differences

      encoding names

    - #### unicodeDifferences

          protected char[] unicodeDifferences

      same as differences but with the unicode codes

    - #### charBBoxes

          protected int[][] charBBoxes

    - #### encoding

          protected java.lang.String encoding

      encoding used with this font

    - #### embedded

          protected boolean embedded

      true if the font is to be embedded in the PDF

    - #### compressionLevel

          protected int compressionLevel

      The compression level for the font stream.
      Since:
        2.1.3

    - #### fontSpecific

          protected boolean fontSpecific

      true if the font must use its built in encoding. In that case the `encoding` is only used to map a char to the position inside the font, not to the expected char name.

    - #### fontCache

          protected static java.util.HashMap fontCache

      cache for the fonts already used.

    - #### BuiltinFonts14

          protected static final java.util.HashMap BuiltinFonts14

      list of the 14 built in fonts.

    - #### forceWidthsOutput

          protected boolean forceWidthsOutput

      Forces the output of the width array. Only matters for the 14 built-in fonts.

    - #### directTextToByte

          protected boolean directTextToByte

      Converts `char` directly to `byte` by casting.

    - #### subset

          protected boolean subset

      Indicates if all the glyphs and widths for that particular encoding should be included in the document.

    - #### fastWinansi

          protected boolean fastWinansi

    - #### specialMap

          protected IntHashtable specialMap

      Custom encodings use this map to key the Unicode character to the single byte code.

  - ### Constructor Detail

    - #### BaseFont

          protected BaseFont()

      Creates new BaseFont

  - ### Method Detail

    - #### createFont

          public static BaseFont createFont()
                                     throws DocumentException,
                                            java.io.IOException

      Creates a new font. This will always be the default Helvetica font (not embedded). This method is introduced because Helvetica is used in many examples.
      Returns:
        a BaseFont object (Helvetica, Winansi, not embedded)
      Throws:
        `java.io.IOException` - This shouldn't occur ever
        `DocumentException` - This shouldn't occur ever
      Since:
        2.1.1

    - #### createFont

          public static BaseFont createFont(java.lang.String name,
                            java.lang.String encoding,
                            boolean embedded)
                                     throws DocumentException,
                                            java.io.IOException

      Creates a new font. This font can be one of the 14 built in types, a Type1 font referred to by an AFM or PFM file, a TrueType font (simple or collection) or a CJK font from the Adobe Asian Font Pack. TrueType fonts and CJK fonts can have an optional style modifier appended to the name. These modifiers are: Bold, Italic and BoldItalic. An example would be "STSong-Light,Bold". Note that this modifiers do not work if the font is embedded. Fonts in TrueType collections are addressed by index such as "msgothic.ttc,1". This would get the second font (indexes start at 0), in this case "MS PGothic".

      The fonts are cached and if they already exist they are extracted from the cache, not parsed again.

      Besides the common encodings described by name, custom encodings can also be made. These encodings will only work for the single byte fonts Type1 and TrueType. The encoding string starts with a '#' followed by "simple" or "full". If "simple" there is a decimal for the first character position and then a list of hex values representing the Unicode codes that compose that encoding.
      The "simple" encoding is recommended for TrueType fonts as the "full" encoding risks not matching the character with the right glyph if not done with care.
      The "full" encoding is specially aimed at Type1 fonts where the glyphs have to be described by non standard names like the Tex math fonts. Each group of three elements compose a code position: the one byte code order in decimal or as 'x' (x cannot be the space), the name and the Unicode character used to access the glyph. The space must be assigned to character position 32 otherwise text justification will not work.

      Example for a "simple" encoding that includes the Unicode character space, A, B and ecyrillic:

           "# simple 32 0020 0041 0042 0454"

      Example for a "full" encoding for a Type1 Tex font:

           "# full 'A' nottriangeqlleft 0041 'B' dividemultiply 0042 32 space 0020"

      This method calls:

           createFont(name, encoding, embedded, true, null, null);

      Parameters:
        `name` - the name of the font or its location on file
        `encoding` - the encoding to be applied to this font
        `embedded` - true if the font is to be embedded in the PDF
      Returns:
        returns a new font. This font may come from the cache
      Throws:
        `DocumentException` - the font is invalid
        `java.io.IOException` - the font file could not be read

    - #### createFont

          public static BaseFont createFont(java.lang.String name,
                            java.lang.String encoding,
                            boolean embedded,
                            boolean forceRead)
                                     throws DocumentException,
                                            java.io.IOException

      Creates a new font. This font can be one of the 14 built in types, a Type1 font referred to by an AFM or PFM file, a TrueType font (simple or collection) or a CJK font from the Adobe Asian Font Pack. TrueType fonts and CJK fonts can have an optional style modifier appended to the name. These modifiers are: Bold, Italic and BoldItalic. An example would be "STSong-Light,Bold". Note that this modifiers do not work if the font is embedded. Fonts in TrueType collections are addressed by index such as "msgothic.ttc,1". This would get the second font (indexes start at 0), in this case "MS PGothic".

      The fonts are cached and if they already exist they are extracted from the cache, not parsed again.

      Besides the common encodings described by name, custom encodings can also be made. These encodings will only work for the single byte fonts Type1 and TrueType. The encoding string starts with a '#' followed by "simple" or "full". If "simple" there is a decimal for the first character position and then a list of hex values representing the Unicode codes that compose that encoding.
      The "simple" encoding is recommended for TrueType fonts as the "full" encoding risks not matching the character with the right glyph if not done with care.
      The "full" encoding is specially aimed at Type1 fonts where the glyphs have to be described by non standard names like the Tex math fonts. Each group of three elements compose a code position: the one byte code order in decimal or as 'x' (x cannot be the space), the name and the Unicode character used to access the glyph. The space must be assigned to character position 32 otherwise text justification will not work.

      Example for a "simple" encoding that includes the Unicode character space, A, B and ecyrillic:

           "# simple 32 0020 0041 0042 0454"

      Example for a "full" encoding for a Type1 Tex font:

           "# full 'A' nottriangeqlleft 0041 'B' dividemultiply 0042 32 space 0020"

      This method calls:

           createFont(name, encoding, embedded, true, null, null);

      Parameters:
        `name` - the name of the font or its location on file
        `encoding` - the encoding to be applied to this font
        `embedded` - true if the font is to be embedded in the PDF
        `forceRead` - in some cases (TrueTypeFont, Type1Font), the full font file will be read and kept in memory if forceRead is true
      Returns:
        returns a new font. This font may come from the cache
      Throws:
        `DocumentException` - the font is invalid
        `java.io.IOException` - the font file could not be read
      Since:
        2.1.5

    - #### createFont

          public static BaseFont createFont(java.lang.String name,
                            java.lang.String encoding,
                            boolean embedded,
                            boolean cached,
                            byte[] ttfAfm,
                            byte[] pfb)
                                     throws DocumentException,
                                            java.io.IOException

      Creates a new font. This font can be one of the 14 built in types, a Type1 font referred to by an AFM or PFM file, a TrueType font (simple or collection) or a CJK font from the Adobe Asian Font Pack. TrueType fonts and CJK fonts can have an optional style modifier appended to the name. These modifiers are: Bold, Italic and BoldItalic. An example would be "STSong-Light,Bold". Note that this modifiers do not work if the font is embedded. Fonts in TrueType collections are addressed by index such as "msgothic.ttc,1". This would get the second font (indexes start at 0), in this case "MS PGothic".

      The fonts may or may not be cached depending on the flag `cached`. If the `byte` arrays are present the font will be read from them instead of the name. A name is still required to identify the font type.

      Besides the common encodings described by name, custom encodings can also be made. These encodings will only work for the single byte fonts Type1 and TrueType. The encoding string starts with a '#' followed by "simple" or "full". If "simple" there is a decimal for the first character position and then a list of hex values representing the Unicode codes that compose that encoding.
      The "simple" encoding is recommended for TrueType fonts as the "full" encoding risks not matching the character with the right glyph if not done with care.
      The "full" encoding is specially aimed at Type1 fonts where the glyphs have to be described by non standard names like the Tex math fonts. Each group of three elements compose a code position: the one byte code order in decimal or as 'x' (x cannot be the space), the name and the Unicode character used to access the glyph. The space must be assigned to character position 32 otherwise text justification will not work.

      Example for a "simple" encoding that includes the Unicode character space, A, B and ecyrillic:

           "# simple 32 0020 0041 0042 0454"

      Example for a "full" encoding for a Type1 Tex font:

           "# full 'A' nottriangeqlleft 0041 'B' dividemultiply 0042 32 space 0020"

      Parameters:
        `name` - the name of the font or its location on file
        `encoding` - the encoding to be applied to this font
        `embedded` - true if the font is to be embedded in the PDF
        `cached` - true if the font comes from the cache or is added to the cache if new, false if the font is always created new
        `ttfAfm` - the true type font or the afm in a byte array
        `pfb` - the pfb in a byte array
      Returns:
        returns a new font. This font may come from the cache but only if cached is true, otherwise it will always be created new
      Throws:
        `DocumentException` - the font is invalid
        `java.io.IOException` - the font file could not be read
      Since:
        iText 0.80

    - #### createFont

          public static BaseFont createFont(java.lang.String name,
                            java.lang.String encoding,
                            boolean embedded,
                            boolean cached,
                            byte[] ttfAfm,
                            byte[] pfb,
                            boolean noThrow)
                                     throws DocumentException,
                                            java.io.IOException

      Creates a new font. This font can be one of the 14 built in types, a Type1 font referred to by an AFM or PFM file, a TrueType font (simple or collection) or a CJK font from the Adobe Asian Font Pack. TrueType fonts and CJK fonts can have an optional style modifier appended to the name. These modifiers are: Bold, Italic and BoldItalic. An example would be "STSong-Light,Bold". Note that this modifiers do not work if the font is embedded. Fonts in TrueType collections are addressed by index such as "msgothic.ttc,1". This would get the second font (indexes start at 0), in this case "MS PGothic".

      The fonts may or may not be cached depending on the flag `cached`. If the `byte` arrays are present the font will be read from them instead of the name. A name is still required to identify the font type.

      Besides the common encodings described by name, custom encodings can also be made. These encodings will only work for the single byte fonts Type1 and TrueType. The encoding string starts with a '#' followed by "simple" or "full". If "simple" there is a decimal for the first character position and then a list of hex values representing the Unicode codes that compose that encoding.
      The "simple" encoding is recommended for TrueType fonts as the "full" encoding risks not matching the character with the right glyph if not done with care.
      The "full" encoding is specially aimed at Type1 fonts where the glyphs have to be described by non standard names like the Tex math fonts. Each group of three elements compose a code position: the one byte code order in decimal or as 'x' (x cannot be the space), the name and the Unicode character used to access the glyph. The space must be assigned to character position 32 otherwise text justification will not work.

      Example for a "simple" encoding that includes the Unicode character space, A, B and ecyrillic:

           "# simple 32 0020 0041 0042 0454"

      Example for a "full" encoding for a Type1 Tex font:

           "# full 'A' nottriangeqlleft 0041 'B' dividemultiply 0042 32 space 0020"

      Parameters:
        `name` - the name of the font or its location on file
        `encoding` - the encoding to be applied to this font
        `embedded` - true if the font is to be embedded in the PDF
        `cached` - true if the font comes from the cache or is added to the cache if new, false if the font is always created new
        `ttfAfm` - the true type font or the afm in a byte array
        `pfb` - the pfb in a byte array
        `noThrow` - if true will not throw an exception if the font is not recognized and will return null, if false will throw an exception if the font is not recognized. Note that even if true an exception may be thrown in some circumstances. This parameter is useful for FontFactory that may have to check many invalid font names before finding the right one
      Returns:
        returns a new font. This font may come from the cache but only if cached is true, otherwise it will always be created new
      Throws:
        `DocumentException` - the font is invalid
        `java.io.IOException` - the font file could not be read
      Since:
        2.0.3

    - #### createFont

          public static BaseFont createFont(java.lang.String name,
                            java.lang.String encoding,
                            boolean embedded,
                            boolean cached,
                            byte[] ttfAfm,
                            byte[] pfb,
                            boolean noThrow,
                            boolean forceRead)
                                     throws DocumentException,
                                            java.io.IOException

      Creates a new font. This font can be one of the 14 built in types, a Type1 font referred to by an AFM or PFM file, a TrueType font (simple or collection) or a CJK font from the Adobe Asian Font Pack. TrueType fonts and CJK fonts can have an optional style modifier appended to the name. These modifiers are: Bold, Italic and BoldItalic. An example would be "STSong-Light,Bold". Note that this modifiers do not work if the font is embedded. Fonts in TrueType collections are addressed by index such as "msgothic.ttc,1". This would get the second font (indexes start at 0), in this case "MS PGothic".

      The fonts may or may not be cached depending on the flag `cached`. If the `byte` arrays are present the font will be read from them instead of the name. A name is still required to identify the font type.

      Besides the common encodings described by name, custom encodings can also be made. These encodings will only work for the single byte fonts Type1 and TrueType. The encoding string starts with a '#' followed by "simple" or "full". If "simple" there is a decimal for the first character position and then a list of hex values representing the Unicode codes that compose that encoding.
      The "simple" encoding is recommended for TrueType fonts as the "full" encoding risks not matching the character with the right glyph if not done with care.
      The "full" encoding is specially aimed at Type1 fonts where the glyphs have to be described by non standard names like the Tex math fonts. Each group of three elements compose a code position: the one byte code order in decimal or as 'x' (x cannot be the space), the name and the Unicode character used to access the glyph. The space must be assigned to character position 32 otherwise text justification will not work.

      Example for a "simple" encoding that includes the Unicode character space, A, B and ecyrillic:

           "# simple 32 0020 0041 0042 0454"

      Example for a "full" encoding for a Type1 Tex font:

           "# full 'A' nottriangeqlleft 0041 'B' dividemultiply 0042 32 space 0020"

      Parameters:
        `name` - the name of the font or its location on file
        `encoding` - the encoding to be applied to this font
        `embedded` - true if the font is to be embedded in the PDF
        `cached` - true if the font comes from the cache or is added to the cache if new, false if the font is always created new
        `ttfAfm` - the true type font or the afm in a byte array
        `pfb` - the pfb in a byte array
        `noThrow` - if true will not throw an exception if the font is not recognized and will return null, if false will throw an exception if the font is not recognized. Note that even if true an exception may be thrown in some circumstances. This parameter is useful for FontFactory that may have to check many invalid font names before finding the right one
        `forceRead` - in some cases (TrueTypeFont, Type1Font), the full font file will be read and kept in memory if forceRead is true
      Returns:
        returns a new font. This font may come from the cache but only if cached is true, otherwise it will always be created new
      Throws:
        `DocumentException` - the font is invalid
        `java.io.IOException` - the font file could not be read
      Since:
        2.1.5

    - #### createFont

          public static BaseFont createFont(PRIndirectReference fontRef)

      Creates a font based on an existing document font. The created font font may not behave as expected, depending on the encoding or subset.
      Parameters:
        `fontRef` - the reference to the document font
      Returns:
        the font

    - #### getBaseName

          protected static java.lang.String getBaseName(java.lang.String name)

      Gets the name without the modifiers Bold, Italic or BoldItalic.
      Parameters:
        `name` - the full name of the font
      Returns:
        the name without the modifiers Bold, Italic or BoldItalic

    - #### normalizeEncoding

          protected static java.lang.String normalizeEncoding(java.lang.String enc)

      Normalize the encoding names. "winansi" is changed to "Cp1252" and "macroman" is changed to "MacRoman".
      Parameters:
        `enc` - the encoding to be normalized
      Returns:
        the normalized encoding

    - #### createEncoding

          protected void createEncoding()

      Creates the `widths` and the `differences` arrays

    - #### getRawWidth

          abstract int getRawWidth(int c,
                        java.lang.String name)

      Gets the width from the font according to the Unicode char `c` or the `name`. If the `name` is null it's a symbolic font.
      Parameters:
        `c` - the unicode char
        `name` - the glyph name
      Returns:
        the width of the char

    - #### getKerning

          public abstract int getKerning(int char1,
                       int char2)

      Gets the kerning between two Unicode chars.
      Parameters:
        `char1` - the first char
        `char2` - the second char
      Returns:
        the kerning to be applied in normalized 1000 units

    - #### setKerning

          public abstract boolean setKerning(int char1,
                           int char2,
                           int kern)

      Sets the kerning between two Unicode chars.
      Parameters:
        `char1` - the first char
        `char2` - the second char
        `kern` - the kerning to apply in normalized 1000 units
      Returns:
        `true` if the kerning was applied, `false` otherwise

    - #### getWidth

          public int getWidth(int char1)

      Gets the width of a `char` in normalized 1000 units.
      Parameters:
        `char1` - the unicode `char` to get the width of
      Returns:
        the width in normalized 1000 units

    - #### getWidth

          public int getWidth(java.lang.String text)

      Gets the width of a `String` in normalized 1000 units.
      Parameters:
        `text` - the `String` to get the width of
      Returns:
        the width in normalized 1000 units

    - #### getDescent

          public int getDescent(java.lang.String text)

      Gets the descent of a `String` in normalized 1000 units. The descent will always be less than or equal to zero even if all the characters have an higher descent.
      Parameters:
        `text` - the `String` to get the descent of
      Returns:
        the descent in normalized 1000 units

    - #### getAscent

          public int getAscent(java.lang.String text)

      Gets the ascent of a `String` in normalized 1000 units. The ascent will always be greater than or equal to zero even if all the characters have a lower ascent.
      Parameters:
        `text` - the `String` to get the ascent of
      Returns:
        the ascent in normalized 1000 units

    - #### getDescentPoint

          public float getDescentPoint(java.lang.String text,
                              float fontSize)

      Gets the descent of a `String` in points. The descent will always be less than or equal to zero even if all the characters have an higher descent.
      Parameters:
        `text` - the `String` to get the descent of
        `fontSize` - the size of the font
      Returns:
        the descent in points

    - #### getAscentPoint

          public float getAscentPoint(java.lang.String text,
                             float fontSize)

      Gets the ascent of a `String` in points. The ascent will always be greater than or equal to zero even if all the characters have a lower ascent.
      Parameters:
        `text` - the `String` to get the ascent of
        `fontSize` - the size of the font
      Returns:
        the ascent in points

    - #### getWidthPointKerned

          public float getWidthPointKerned(java.lang.String text,
                                  float fontSize)

      Gets the width of a `String` in points taking kerning into account.
      Parameters:
        `text` - the `String` to get the width of
        `fontSize` - the font size
      Returns:
        the width in points

    - #### getWidthPoint

          public float getWidthPoint(java.lang.String text,
                            float fontSize)

      Gets the width of a `String` in points.
      Parameters:
        `text` - the `String` to get the width of
        `fontSize` - the font size
      Returns:
        the width in points

    - #### getWidthPoint

          public float getWidthPoint(int char1,
                            float fontSize)

      Gets the width of a `char` in points.
      Parameters:
        `char1` - the `char` to get the width of
        `fontSize` - the font size
      Returns:
        the width in points

    - #### convertToBytes

          byte[] convertToBytes(java.lang.String text)

      Converts a `String` to a byte array according to the font's encoding.
      Parameters:
        `text` - the `String` to be converted
      Returns:
        an array of `byte` representing the conversion according to the font's encoding

    - #### convertToBytes

          byte[] convertToBytes(int char1)

      Converts a `char` to a byte array according to the font's encoding.
      Parameters:
        `char1` - the `char` to be converted
      Returns:
        an array of `byte` representing the conversion according to the font's encoding

    - #### writeFont

          abstract void writeFont(PdfWriter writer,
                       PdfIndirectReference ref,
                       java.lang.Object[] params)
                           throws DocumentException,
                                  java.io.IOException

      Outputs to the writer the font dictionaries and streams.
      Parameters:
        `writer` - the writer for this document
        `ref` - the font indirect reference
        `params` - several parameters that depend on the font type
      Throws:
        `java.io.IOException` - on error
        `DocumentException` - error in generating the object

    - #### getFullFontStream

          abstract PdfStream getFullFontStream()
                                        throws java.io.IOException,
                                               DocumentException

      Returns a PdfStream object with the full font program (if possible). This method will return null for some types of fonts (CJKFont, Type3Font) or if there is no font program available (standard Type 1 fonts).
      Returns:
        a PdfStream with the font program
      Throws:
        `java.io.IOException`
        `DocumentException`
      Since:
        2.1.3

    - #### getEncoding

          public java.lang.String getEncoding()

      Gets the encoding used to convert `String` into `byte[]`.
      Returns:
        the encoding name

    - #### getFontDescriptor

          public abstract float getFontDescriptor(int key,
                                float fontSize)

      Gets the font parameter identified by `key`. Valid values for `key` are `ASCENT`, `AWT_ASCENT`, `CAPHEIGHT`, `DESCENT`, `AWT_DESCENT`, `ITALICANGLE`, `BBOXLLX`, `BBOXLLY`, `BBOXURX` and `BBOXURY`.
      Parameters:
        `key` - the parameter to be extracted
        `fontSize` - the font size in points
      Returns:
        the parameter in points

    - #### getFontType

          public int getFontType()

      Gets the font type. The font types can be: FONT_TYPE_T1, FONT_TYPE_TT, FONT_TYPE_CJK and FONT_TYPE_TTUNI.
      Returns:
        the font type

    - #### isEmbedded

          public boolean isEmbedded()

      Gets the embedded flag.
      Returns:
        `true` if the font is embedded.

    - #### isFontSpecific

          public boolean isFontSpecific()

      Gets the symbolic flag of the font.
      Returns:
        `true` if the font is symbolic

    - #### createSubsetPrefix

          public static java.lang.String createSubsetPrefix()

      Creates a unique subset prefix to be added to the font name when the font is embedded and subset.
      Returns:
        the subset prefix

    - #### getUnicodeDifferences

          char getUnicodeDifferences(int index)

      Gets the Unicode character corresponding to the byte output to the pdf stream.
      Parameters:
        `index` - the byte index
      Returns:
        the Unicode character

    - #### getPostscriptFontName

          public abstract java.lang.String getPostscriptFontName()

      Gets the postscript font name.
      Returns:
        the postscript font name

    - #### setPostscriptFontName

          public abstract void setPostscriptFontName(java.lang.String name)

      Sets the font name that will appear in the pdf font dictionary. Use with care as it can easily make a font unreadable if not embedded.
      Parameters:
        `name` - the new font name

    - #### getFullFontName

          public abstract java.lang.String[][] getFullFontName()

      Gets the full name of the font. If it is a True Type font each array element will have {Platform ID, Platform Encoding ID, Language ID, font name}. The interpretation of this values can be found in the Open Type specification, chapter 2, in the 'name' table.
      For the other fonts the array has a single element with {"", "", "", font name}.
      Returns:
        the full name of the font

    - #### getAllNameEntries

          public abstract java.lang.String[][] getAllNameEntries()

      Gets all the entries of the names-table. If it is a True Type font each array element will have {Name ID, Platform ID, Platform Encoding ID, Language ID, font name}. The interpretation of this values can be found in the Open Type specification, chapter 2, in the 'name' table.
      For the other fonts the array has a single element with {"4", "", "", "", font name}.
      Returns:
        the full name of the font
      Since:
        2.0.8

    - #### getFullFontName

          public static java.lang.String[][] getFullFontName(java.lang.String name,
                                             java.lang.String encoding,
                                             byte[] ttfAfm)
                                                      throws DocumentException,
                                                             java.io.IOException

      Gets the full name of the font. If it is a True Type font each array element will have {Platform ID, Platform Encoding ID, Language ID, font name}. The interpretation of this values can be found in the Open Type specification, chapter 2, in the 'name' table.
      For the other fonts the array has a single element with {"", "", "", font name}.
      Parameters:
        `name` - the name of the font
        `encoding` - the encoding of the font
        `ttfAfm` - the true type font or the afm in a byte array
      Returns:
        the full name of the font
      Throws:
        `DocumentException` - on error
        `java.io.IOException` - on error

    - #### getAllFontNames

          public static java.lang.Object[] getAllFontNames(java.lang.String name,
                                           java.lang.String encoding,
                                           byte[] ttfAfm)
                                                    throws DocumentException,
                                                           java.io.IOException

      Gets all the names from the font. Only the required tables are read.
      Parameters:
        `name` - the name of the font
        `encoding` - the encoding of the font
        `ttfAfm` - the true type font or the afm in a byte array
      Returns:
        an array of Object[] built with {getPostscriptFontName(), getFamilyFontName(), getFullFontName()}
      Throws:
        `DocumentException` - on error
        `java.io.IOException` - on error

    - #### getAllNameEntries

          public static java.lang.String[][] getAllNameEntries(java.lang.String name,
                                               java.lang.String encoding,
                                               byte[] ttfAfm)
                                                        throws DocumentException,
                                                               java.io.IOException

      Gets all the entries of the namestable from the font. Only the required tables are read.
      Parameters:
        `name` - the name of the font
        `encoding` - the encoding of the font
        `ttfAfm` - the true type font or the afm in a byte array
      Returns:
        an array of Object[] built with {getPostscriptFontName(), getFamilyFontName(), getFullFontName()}
      Throws:
        `DocumentException` - on error
        `java.io.IOException` - on error
      Since:
        2.0.8

    - #### getFamilyFontName

          public abstract java.lang.String[][] getFamilyFontName()

      Gets the family name of the font. If it is a True Type font each array element will have {Platform ID, Platform Encoding ID, Language ID, font name}. The interpretation of this values can be found in the Open Type specification, chapter 2, in the 'name' table.
      For the other fonts the array has a single element with {"", "", "", font name}.
      Returns:
        the family name of the font

    - #### getCodePagesSupported

          public java.lang.String[] getCodePagesSupported()

      Gets the code pages supported by the font. This has only meaning with True Type fonts.
      Returns:
        the code pages supported by the font

    - #### enumerateTTCNames

          public static java.lang.String[] enumerateTTCNames(java.lang.String ttcFile)
                                                      throws DocumentException,
                                                             java.io.IOException

      Enumerates the postscript font names present inside a True Type Collection.
      Parameters:
        `ttcFile` - the file name of the font
      Returns:
        the postscript font names
      Throws:
        `DocumentException` - on error
        `java.io.IOException` - on error

    - #### enumerateTTCNames

          public static java.lang.String[] enumerateTTCNames(byte[] ttcArray)
                                                      throws DocumentException,
                                                             java.io.IOException

      Enumerates the postscript font names present inside a True Type Collection.
      Parameters:
        `ttcArray` - the font as a `byte` array
      Returns:
        the postscript font names
      Throws:
        `DocumentException` - on error
        `java.io.IOException` - on error

    - #### getWidths

          public int[] getWidths()

      Gets the font width array.
      Returns:
        the font width array

    - #### getDifferences

          public java.lang.String[] getDifferences()

      Gets the array with the names of the characters.
      Returns:
        the array with the names of the characters

    - #### getUnicodeDifferences

          public char[] getUnicodeDifferences()

      Gets the array with the unicode characters.
      Returns:
        the array with the unicode characters

    - #### isForceWidthsOutput

          public boolean isForceWidthsOutput()

      Gets the state of the property.
      Returns:
        value of property forceWidthsOutput

    - #### setForceWidthsOutput

          public void setForceWidthsOutput(boolean forceWidthsOutput)

      Set to `true` to force the generation of the widths array.
      Parameters:
        `forceWidthsOutput` - `true` to force the generation of the widths array

    - #### isDirectTextToByte

          public boolean isDirectTextToByte()

      Gets the direct conversion of `char` to `byte`.
      Returns:
        value of property directTextToByte.
      See Also:
        `setDirectTextToByte(boolean directTextToByte)`

    - #### setDirectTextToByte

          public void setDirectTextToByte(boolean directTextToByte)

      Sets the conversion of `char` directly to `byte` by casting. This is a low level feature to put the bytes directly in the content stream without passing through String.getBytes().
      Parameters:
        `directTextToByte` - New value of property directTextToByte.

    - #### isSubset

          public boolean isSubset()

      Indicates if all the glyphs and widths for that particular encoding should be included in the document.
      Returns:
        `false` to include all the glyphs and widths.

    - #### setSubset

          public void setSubset(boolean subset)

      Indicates if all the glyphs and widths for that particular encoding should be included in the document. When set to `true` only the glyphs used will be included in the font. When set to `false` and `addSubsetRange(int[])` was not called the full font will be included otherwise just the characters ranges will be included.
      Parameters:
        `subset` - new value of property subset

    - #### getResourceStream

          public static java.io.InputStream getResourceStream(java.lang.String key)

      Gets the font resources.
      Parameters:
        `key` - the full name of the resource
      Returns:
        the `InputStream` to get the resource or `null` if not found

    - #### getResourceStream

          public static java.io.InputStream getResourceStream(java.lang.String key,
                                              java.lang.ClassLoader loader)

      Gets the font resources.
      Parameters:
        `key` - the full name of the resource
        `loader` - the ClassLoader to load the resource or null to try the ones available
      Returns:
        the `InputStream` to get the resource or `null` if not found

    - #### getUnicodeEquivalent

          public int getUnicodeEquivalent(int c)

      Gets the Unicode equivalent to a CID. The (inexistent) CID is translated as '\n'. It has only meaning with CJK fonts with Identity encoding.
      Parameters:
        `c` - the CID code
      Returns:
        the Unicode equivalent

    - #### getCidCode

          public int getCidCode(int c)

      Gets the CID code given an Unicode. It has only meaning with CJK fonts.
      Parameters:
        `c` - the Unicode
      Returns:
        the CID equivalent

    - #### hasKernPairs

          public abstract boolean hasKernPairs()

      Checks if the font has any kerning pairs.
      Returns:
        `true` if the font has any kerning pairs

    - #### charExists

          public boolean charExists(int c)

      Checks if a character exists in this font.
      Parameters:
        `c` - the character to check
      Returns:
        `true` if the character has a glyph, `false` otherwise

    - #### setCharAdvance

          public boolean setCharAdvance(int c,
                               int advance)

      Sets the character advance.
      Parameters:
        `c` - the character
        `advance` - the character advance normalized to 1000 units
      Returns:
        `true` if the advance was set, `false` otherwise

    - #### addFont

          private static void addFont(PRIndirectReference fontRef,
                     IntHashtable hits,
                     java.util.ArrayList fonts)

    - #### recourseFonts

          private static void recourseFonts(PdfDictionary page,
                           IntHashtable hits,
                           java.util.ArrayList fonts,
                           int level)

    - #### getDocumentFonts

          public static java.util.ArrayList getDocumentFonts(PdfReader reader)

      Gets a list of all document fonts. Each element of the `ArrayList` contains a `Object[]{String,PRIndirectReference}` with the font name and the indirect reference to it.
      Parameters:
        `reader` - the document where the fonts are to be listed from
      Returns:
        the list of fonts and references

    - #### getDocumentFonts

          public static java.util.ArrayList getDocumentFonts(PdfReader reader,
                                             int page)

      Gets a list of the document fonts in a particular page. Each element of the `ArrayList` contains a `Object[]{String,PRIndirectReference}` with the font name and the indirect reference to it.
      Parameters:
        `reader` - the document where the fonts are to be listed from
        `page` - the page to list the fonts from
      Returns:
        the list of fonts and references

    - #### getCharBBox

          public int[] getCharBBox(int c)

      Gets the smallest box enclosing the character contours. It will return `null` if the font has not the information or the character has no contours, as in the case of the space, for example. Characters with no contours may also return [0,0,0,0].
      Parameters:
        `c` - the character to get the contour bounding box from
      Returns:
        an array of four floats with the bounding box in the format [llx,lly,urx,ury] or `null`

    - #### getRawCharBBox

          protected abstract int[] getRawCharBBox(int c,
                             java.lang.String name)

    - #### correctArabicAdvance

          public void correctArabicAdvance()

      iText expects Arabic Diactrics (tashkeel) to have zero advance but some fonts, most notably those that come with Windows, like times.ttf, have non-zero advance for those characters. This method makes those character to have zero width advance and work correctly in the iText Arabic shaping and reordering context.

    - #### addSubsetRange

          public void addSubsetRange(int[] range)

      Adds a character range when subsetting. The range is an `int` array where the first element is the start range inclusive and the second element is the end range inclusive. Several ranges are allowed in the same array.
      Parameters:
        `range` - the character range

    - #### getCompressionLevel

          public int getCompressionLevel()

      Returns the compression level used for the font streams.
      Returns:
        the compression level (0 = best speed, 9 = best compression, -1 is default)
      Since:
        2.1.3

    - #### setCompressionLevel

          public void setCompressionLevel(int compressionLevel)

      Sets the compression level to be used for the font streams.
      Parameters:
        `compressionLevel` - a value between 0 (best speed) and 9 (best compression)
      Since:
        2.1.3