org.faceless.pdf2

## Class OpenTypeFont

- java.lang.Object
- - org.faceless.pdf2.PDFFont
  - - org.faceless.pdf2.OpenTypeFont

- All Implemented Interfaces:
    Cloneable

      public final class OpenTypeFont
      extends PDFFont

  A subclass of `PDFFont` that represents an OpenType font. OpenType fonts are a superset of TrueType fonts, but also include fonts where the glyphs are defined using Adobes "Compact Font" format (which are supported since version 2.3 of the library).

  OpenType fonts can be stored by reference only (the font is not embedded into the file), or can be embedded using either one or two bytes per glyph. One byte is only really suitable when the font is using a subset of the ASCII character set - eg. western european characters only. If the font is going to be used to display non-roman characters, two bytes should be used.

  Since:
    2.0 (prior to 2.0 this class was called TrueTypeFont)

- - ### Constructor Summary

    Constructors
    Constructor and Description
    `OpenTypeFont(InputStream in, int bytesperglyph)` Create a new OpenTypeFont from the specified InputStream.
    `OpenTypeFont(OpenTypeFont font)` Create a new OpenTypeFont that is a copy of the specified OpenTypeFont.

  - ### Method Summary

    All Methods Instance Methods Concrete Methods
    Modifier and Type | Method and Description
    --- | ---
    `float` | `getAscender()` Get the Ascender for the font (the maximum height above the baseline the font extends), as a proportion of the point size.
    `String[]` | `getAvailableFeatures()` Return the list of available features for this font.
    `float` | `getDefaultLeading()` Get the default leading for this font - the preferred distance between two successive baselines of text.
    `float` | `getDescender()` Get the Descender for the font (the maximum height below the baseline the font extends), as a proportion of the point size.
    `String` | `getEmbeddingRestrictions()` Returns `null` if the font can be embedded without any restrictions, or a non-null String if the font has embedding restrictions.
    `float` | `getRight(String s)` Get the right-most X co-ordinate if this String was rendered in 1 point high text at position (0,0).
    `float` | `getStrikeoutPosition()` Get the strikeout position, as a proportion of the font size.
    `float` | `getStrikeoutThickness()` Get the strikeout thickness, as a proportion of the font size.
    `float` | `getSubscriptPosition()` Get the recommended position of a sub-script version of this font, as a proportion of the sub-scripted font size.
    `float` | `getSubscriptSize()` Get the recommended size of a super/sub script version of this font, as a proportion of the normal font size.
    `float` | `getSuperscriptPosition()` Get the recommended position of a super-script version of this font, as a proportion of the sub-scripted font size.
    `float` | `getUnderlinePosition()` Get the underline position, as a proportion of the font size.
    `float` | `getUnderlineThickness()` Get the underline thickness, as a proportion of the font size.
    `float` | `getXHeight()` Get the X-Height of the font - normally the height of a lower-case 'x' character
    `boolean` | `isBold()` Return true if the font is bold
    `boolean` | `isItalic()` Return true if the font is italic
    `boolean` | `isMonospace()` Return true if every character has the same width (like Courier), false if every character is potentially a different width (like Times-Roman)
    `boolean` | `isSerif()` Return true if the font is serif
    `void` | `setEmbed(boolean embed)` Whether to embed the font in the PDF.
    `void` | `setFeature(String feature, boolean on)` Set or clear an optional feature on a font.
    `void` | `setSubset(boolean subset)` Whether to "subset" the font by removing unused glyph definitions from the font when it's embedded in the file.
    `String` | `toString()`

    - ### Methods inherited from class org.faceless.pdf2.PDFFont

      `getBaseName, getBottom, getCharWidth, getCharWidth, getFeature, getKerning, getKerning, getLeft, getTop, isDefined, isDefined, isHorizontal, ligaturize, ligaturize, requote, requote, versionBold, versionItalic, versionNonBold, versionNonItalic, versionRegular`

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

      `equals, getClass, hashCode, notify, notifyAll, wait, wait, wait`

- - ### Constructor Detail

    - #### OpenTypeFont

          public OpenTypeFont(OpenTypeFont font)

      Create a new OpenTypeFont that is a copy of the specified OpenTypeFont. If a new copy of the font is required, this method is much faster than reloading the font from disk. The new font will have the default settings for subset, embed and enabled features, ignoring those values from the original font.
      Parameters:
        `font` - the OpenTypeFont to copy.
      Since:
        2.11.10

    - #### OpenTypeFont

          public OpenTypeFont(InputStream in,
                              int bytesperglyph)
                       throws IOException

      Create a new OpenTypeFont from the specified InputStream. The InputStream is closed after use.
      Parameters:
        `in` - the InputStream to read the font from.
        `bytesperglyph` - the number of bytes to use for each glyph. Must be 1 or 2. Thanks to compression there is surprisingly little difference in terms of size in the resulting file, so if in doubt, use 2.
      Throws:
        `IOException`
      Since:
        2.0

  - ### Method Detail

    - #### setSubset

          public void setSubset(boolean subset)

      Whether to "subset" the font by removing unused glyph definitions from the font when it's embedded in the file. This is generally a good thing, unless the font will be used to display text that's not known at PDF creation time (i.e. it's used in a form).
      Parameters:
        `subset` - whether to subset the font (the default is true)

    - #### setEmbed

          public void setEmbed(boolean embed)

      Whether to embed the font in the PDF. Embedding the Font will result in larger files, but the PDF will be readable anywhere - choosing not to embed the font will mean a matching font is required on the system viewing the PDF. If that font is missing, the document cannot guarantee to be displayed correctly. 2-byte fonts are always embedded.
      Parameters:
        `embed` - whether to embed the font (the default is true)

    - #### getEmbeddingRestrictions

          public String getEmbeddingRestrictions()

      Returns `null` if the font can be embedded without any restrictions, or a non-null String if the font has embedding restrictions. Note the library will not prevent you from using a font with embedding restrictions unless you have set the `OutputProfile.Feature.FontEmbeddingRestrictions` feature - it's your responsibility to ensure you have the right to embed the font. The content of the String is undefined but is intended to detail the restriction type.
      Since:
        2.7.8

    - #### getDefaultLeading

          public float getDefaultLeading()

      Description copied from class: `PDFFont`

      Get the default leading for this font - the preferred distance between two successive baselines of text. Values are a ratio of the font size, and are typically between 1 and 1.3

      Note that the values of the different spacing-between-lines methods have changed - in versions 1.0.4 and earlier this routine normally returned 1 and the spacing was set by the `PDFStyle.setTextLineSpacing(float)` method. Since 1.1, the values for these two methods are effectively reversed. See the relevant method comments in the `PDFStyle` class for more information.

      Specified by:
        `getDefaultLeading` in class `PDFFont`

    - #### getDescender

          public float getDescender()

      Description copied from class: `PDFFont`
      Get the Descender for the font (the maximum height below the baseline the font extends), as a proportion of the point size. The returned value is usually negative.
      Specified by:
        `getDescender` in class `PDFFont`

    - #### getAscender

          public float getAscender()

      Description copied from class: `PDFFont`
      Get the Ascender for the font (the maximum height above the baseline the font extends), as a proportion of the point size.
      Specified by:
        `getAscender` in class `PDFFont`

    - #### getUnderlinePosition

          public float getUnderlinePosition()

      Description copied from class: `PDFFont`
      Get the underline position, as a proportion of the font size. Like the `getDescender()` method, the returned value is almost always negative, indicating below the baseline.
      Specified by:
        `getUnderlinePosition` in class `PDFFont`

    - #### getUnderlineThickness

          public float getUnderlineThickness()

      Description copied from class: `PDFFont`
      Get the underline thickness, as a proportion of the font size.
      Specified by:
        `getUnderlineThickness` in class `PDFFont`

    - #### getStrikeoutPosition

          public float getStrikeoutPosition()

      Description copied from class: `PDFFont`
      Get the strikeout position, as a proportion of the font size.
      Specified by:
        `getStrikeoutPosition` in class `PDFFont`

    - #### getStrikeoutThickness

          public float getStrikeoutThickness()

      Description copied from class: `PDFFont`
      Get the strikeout thickness, as a proportion of the font size.
      Specified by:
        `getStrikeoutThickness` in class `PDFFont`

    - #### getSuperscriptPosition

          public float getSuperscriptPosition()

      Description copied from class: `PDFFont`

      Get the recommended position of a super-script version of this font, as a proportion of the sub-scripted font size. Value is always positive.

      For some fonts (like CJK or barcode fonts) where there is no concept of super or subscript, this value is entirely arbitrary.

      Specified by:
        `getSuperscriptPosition` in class `PDFFont`

    - #### getSubscriptPosition

          public float getSubscriptPosition()

      Description copied from class: `PDFFont`

      Get the recommended position of a sub-script version of this font, as a proportion of the sub-scripted font size. Value is almost always zero or negative.

      For some fonts (like CJK or barcode fonts) where there is no concept of super or subscript, this value is entirely arbitrary.

      Specified by:
        `getSubscriptPosition` in class `PDFFont`

    - #### getSubscriptSize

          public float getSubscriptSize()

      Description copied from class: `PDFFont`

      Get the recommended size of a super/sub script version of this font, as a proportion of the normal font size. Typical value is around 0.6.

      For some fonts (like CJK or barcode fonts) where there is no concept of super or subscript, this value is entirely arbitrary.

      Specified by:
        `getSubscriptSize` in class `PDFFont`

    - #### getXHeight

          public float getXHeight()

      Description copied from class: `PDFFont`
      Get the X-Height of the font - normally the height of a lower-case 'x' character
      Specified by:
        `getXHeight` in class `PDFFont`

    - #### isMonospace

          public boolean isMonospace()

      Description copied from class: `PDFFont`
      Return true if every character has the same width (like Courier), false if every character is potentially a different width (like Times-Roman)
      Specified by:
        `isMonospace` in class `PDFFont`

    - #### isItalic

          public boolean isItalic()

      Description copied from class: `PDFFont`
      Return true if the font is italic
      Specified by:
        `isItalic` in class `PDFFont`

    - #### isBold

          public boolean isBold()

      Description copied from class: `PDFFont`
      Return true if the font is bold
      Specified by:
        `isBold` in class `PDFFont`

    - #### isSerif

          public boolean isSerif()

      Description copied from class: `PDFFont`
      Return true if the font is serif
      Specified by:
        `isSerif` in class `PDFFont`

    - #### setFeature

          public void setFeature(String feature,
                                 boolean on)

      Set or clear an optional feature on a font. Some OpenType fonts have GPOS and GSUB tables which can be used to modify the glyphs that are displayed. This is required to display some languages correctly.

      To enable this type of glyph shaping, the font must be created using a 2-byte encoding and the "opentype" feature must first be set. This will cause the default set of OpenType features to be used for layout. The full list of features available in the font can be seen by calling the `getAvailableFeatures()` method (go here for their explanations), and individual features may then be turned on or off as required. Features that are required for correct layout (the case for Indic and Arabic scripts) will be selected by default when the "opentype" feature is set.

      By default, OpenType layout is not used, as it is considerably slower. When it is used the `PDFFont.ligaturize(char[], int, int, java.util.Locale)` method becomes a no-op, as ligatures will be applied using these tables. The langauge of the Locale can affect which operations are run, so this should be used with care.

      Lastly the "correctleading" feature can be set to use the correct calculation for `getDefaultLeading()` rather than the one originally used in the PDF Library. For many fonts the two calculations will give similar, often identical results, but for some fonts it won't so we can't change this calculation by default without forcing a re-layout of many existing documents. However we recommend setting this feature for all new documents. The initial value of this feature can be set to true by setting the `OpenTypeCorrectLeading` `property`

      Overrides:
        `setFeature` in class `PDFFont`
      Parameters:
        `feature` - the feature name
        `on` - whether to set or clear the feature
      Since:
        2.11.22
      See Also:
        `PDFFont.requote(char[], int, int, java.util.Locale)`, `PDFFont.getAvailableFeatures()`, `PDFStyle.setFontFeature(java.lang.String, boolean)`

    - #### getAvailableFeatures

          public String[] getAvailableFeatures()

      Description copied from class: `PDFFont`
      Return the list of available features for this font.
      Overrides:
        `getAvailableFeatures` in class `PDFFont`
      Returns:
        a list of feature names that can be passed to `PDFStyle.setFontFeature(java.lang.String, boolean)`
      See Also:
        `PDFStyle.setFontFeature(java.lang.String, boolean)`

    - #### getRight

          public float getRight(String s)

      Description copied from class: `PDFFont`
      Get the right-most X co-ordinate if this String was rendered in 1 point high text at position (0,0). This method will make it's calculation based on the features set on this font: the `PDFStyle.getTextLength(java.lang.String)` method can be used to perform the same calculation based on the values set in the style.
      Overrides:
        `getRight` in class `PDFFont`

    - #### toString

          public String toString()

Copyright © 2001-2015 Big Faceless Organization