All Downloads are FREE. Search and download functionalities are using the official Maven repository.

com.itextpdf.text.pdf.BaseFont Maven / Gradle / Ivy

/*
 * $Id: dadaf63f95c7ab7645b58e465fa0158a25588d27 $
 *
 * This file is part of the iText (R) project.
 * Copyright (c) 1998-2016 iText Group NV
 * Authors: Bruno Lowagie, Paulo Soares, et al.
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU Affero General Public License version 3
 * as published by the Free Software Foundation with the addition of the
 * following permission added to Section 15 as permitted in Section 7(a):
 * FOR ANY PART OF THE COVERED WORK IN WHICH THE COPYRIGHT IS OWNED BY
 * ITEXT GROUP. ITEXT GROUP DISCLAIMS THE WARRANTY OF NON INFRINGEMENT
 * OF THIRD PARTY RIGHTS
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
 * or FITNESS FOR A PARTICULAR PURPOSE.
 * See the GNU Affero General Public License for more details.
 * You should have received a copy of the GNU Affero General Public License
 * along with this program; if not, see http://www.gnu.org/licenses or write to
 * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
 * Boston, MA, 02110-1301 USA, or download the license from the following URL:
 * http://itextpdf.com/terms-of-use/
 *
 * The interactive user interfaces in modified source and object code versions
 * of this program must display Appropriate Legal Notices, as required under
 * Section 5 of the GNU Affero General Public License.
 *
 * In accordance with Section 7(b) of the GNU Affero General Public License,
 * a covered work must retain the producer line in every PDF that is created
 * or manipulated using iText.
 *
 * You can be released from the requirements of the license by purchasing
 * a commercial license. Buying such a license is mandatory as soon as you
 * develop commercial activities involving the iText software without
 * disclosing the source code of your own applications.
 * These activities include: offering paid services to customers as an ASP,
 * serving PDFs on the fly in a web application, shipping iText with a closed
 * source product.
 *
 * For more information, please contact iText Software Corp. at this
 * address: [email protected]
 */
package com.itextpdf.text.pdf;
import com.itextpdf.text.DocumentException;
import com.itextpdf.text.ExceptionConverter;
import com.itextpdf.text.error_messages.MessageLocalization;
import com.itextpdf.text.exceptions.InvalidPdfException;

import java.io.IOException;
import java.util.*;
import java.util.concurrent.ConcurrentHashMap;

/**
 * Base class for the several font types supported
 *
 * @author Paulo Soares
 */

public abstract class BaseFont {

    /** This is a possible value of a base 14 type 1 font */
    public static final String COURIER = "Courier";

    /** This is a possible value of a base 14 type 1 font */
    public static final String COURIER_BOLD = "Courier-Bold";

    /** This is a possible value of a base 14 type 1 font */
    public static final String COURIER_OBLIQUE = "Courier-Oblique";

    /** This is a possible value of a base 14 type 1 font */
    public static final String COURIER_BOLDOBLIQUE = "Courier-BoldOblique";

    /** This is a possible value of a base 14 type 1 font */
    public static final String HELVETICA = "Helvetica";

    /** This is a possible value of a base 14 type 1 font */
    public static final String HELVETICA_BOLD = "Helvetica-Bold";

    /** This is a possible value of a base 14 type 1 font */
    public static final String HELVETICA_OBLIQUE = "Helvetica-Oblique";

    /** This is a possible value of a base 14 type 1 font */
    public static final String HELVETICA_BOLDOBLIQUE = "Helvetica-BoldOblique";

    /** This is a possible value of a base 14 type 1 font */
    public static final String SYMBOL = "Symbol";

    /** This is a possible value of a base 14 type 1 font */
    public static final String TIMES_ROMAN = "Times-Roman";

    /** This is a possible value of a base 14 type 1 font */
    public static final String TIMES_BOLD = "Times-Bold";

    /** This is a possible value of a base 14 type 1 font */
    public static final String TIMES_ITALIC = "Times-Italic";

    /** This is a possible value of a base 14 type 1 font */
    public static final String TIMES_BOLDITALIC = "Times-BoldItalic";

    /** This is a possible value of a base 14 type 1 font */
    public static final String ZAPFDINGBATS = "ZapfDingbats";

    /** The maximum height above the baseline reached by glyphs in this
     * font, excluding the height of glyphs for accented characters.
     */
    public static final int ASCENT = 1;
    /** The y coordinate of the top of flat capital letters, measured from
     * the baseline.
     */
    public static final int CAPHEIGHT = 2;
    /** The maximum depth below the baseline reached by glyphs in this
     * font. The value is a negative number.
     */
    public static final int DESCENT = 3;
    /** 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.
     */
    public static final int ITALICANGLE = 4;
    /** The lower left x glyph coordinate.
     */
    public static final int BBOXLLX = 5;
    /** The lower left y glyph coordinate.
     */
    public static final int BBOXLLY = 6;
    /** The upper right x glyph coordinate.
     */
    public static final int BBOXURX = 7;
    /** The upper right y glyph coordinate.
     */
    public static final int BBOXURY = 8;

    /** AWT Font property */
    public static final int AWT_ASCENT = 9;
    /** AWT Font property */
    public static final int AWT_DESCENT = 10;
    /** AWT Font property */
    public static final int AWT_LEADING = 11;
    /** AWT Font property */
    public static final int AWT_MAXADVANCE = 12;
    /**
     * The underline position. Usually a negative value.
     */
    public static final int UNDERLINE_POSITION = 13;
    /**
     * The underline thickness.
     */
    public static final int UNDERLINE_THICKNESS = 14;
    /**
     * The strikethrough position.
     */
    public static final int STRIKETHROUGH_POSITION = 15;
    /**
     * The strikethrough thickness.
     */
    public static final int STRIKETHROUGH_THICKNESS = 16;
    /**
     * The recommended vertical size for subscripts for this font.
     */
    public static final int SUBSCRIPT_SIZE = 17;
    /**
     * The recommended vertical offset from the baseline for subscripts for this font. Usually a negative value.
     */
    public static final int SUBSCRIPT_OFFSET = 18;
    /**
     * The recommended vertical size for superscripts for this font.
     */
    public static final int SUPERSCRIPT_SIZE = 19;
    /**
     * The recommended vertical offset from the baseline for superscripts for this font.
     */
    public static final int SUPERSCRIPT_OFFSET = 20;
    /**
     * The weight class of the font, as defined by the font author
     * @since 5.0.2
     */
    public static final int WEIGHT_CLASS = 21;
    /**
     * The width class of the font, as defined by the font author
     * @since 5.0.2
     */
    public static final int WIDTH_CLASS = 22;
    /**
     * The entry of PDF FontDescriptor dictionary.
     * (Optional; PDF 1.5; strongly recommended for Type 3 fonts in Tagged PDF documents)
     * The weight (thickness) component of the fully-qualified font name or font specifier.
     * A value larger than 500 indicates bold font-weight.
     */
    public static final int FONT_WEIGHT = 23;
    /** The font is Type 1.
     */
    public static final int FONT_TYPE_T1 = 0;
    /** The font is True Type with a standard encoding.
     */
    public static final int FONT_TYPE_TT = 1;
    /** The font is CJK.
     */
    public static final int FONT_TYPE_CJK = 2;
    /** The font is True Type with a Unicode encoding.
     */
    public static final int FONT_TYPE_TTUNI = 3;
    /** A font already inside the document.
     */
    public static final int FONT_TYPE_DOCUMENT = 4;
    /** A Type3 font.
     */
    public static final int FONT_TYPE_T3 = 5;
    /** The Unicode encoding with horizontal writing.
     */
    public static final String IDENTITY_H = "Identity-H";
    /** The Unicode encoding with vertical writing.
     */
    public static final String IDENTITY_V = "Identity-V";

    /** A possible encoding. */
    public static final String CP1250 = "Cp1250";

    /** A possible encoding. */
    public static final String CP1252 = "Cp1252";

    /** A possible encoding. */
    public static final String CP1257 = "Cp1257";

    /** A possible encoding. */
    public static final String WINANSI = "Cp1252";

    /** A possible encoding. */
    public static final String MACROMAN = "MacRoman";

    public static final int[] CHAR_RANGE_LATIN = {0, 0x17f, 0x2000, 0x206f, 0x20a0, 0x20cf, 0xfb00, 0xfb06};
    public static final int[] CHAR_RANGE_ARABIC = {0, 0x7f, 0x0600, 0x067f, 0x20a0, 0x20cf, 0xfb50, 0xfbff, 0xfe70, 0xfeff};
    public static final int[] CHAR_RANGE_HEBREW = {0, 0x7f, 0x0590, 0x05ff, 0x20a0, 0x20cf, 0xfb1d, 0xfb4f};
    public static final int[] CHAR_RANGE_CYRILLIC = {0, 0x7f, 0x0400, 0x052f, 0x2000, 0x206f, 0x20a0, 0x20cf};

    /** default array of six numbers specifying the font matrix, mapping glyph space to text space */
    public static final double[] DEFAULT_FONT_MATRIX = {0.001, 0, 0, 0.001, 0, 0};

    /** if the font has to be embedded */
    public static final boolean EMBEDDED = true;

    /** if the font doesn't have to be embedded */
    public static final boolean NOT_EMBEDDED = false;
    /** if the font has to be cached */
    public static final boolean CACHED = true;
    /** if the font doesn't have to be cached */
    public static final boolean NOT_CACHED = false;

    /** The path to the font resources. */
    public static final String RESOURCE_PATH = "com/itextpdf/text/pdf/fonts/";
    /** The fake CID code that represents a newline. */
    public static final char CID_NEWLINE = '\u7fff';

	/**
     * Unicode Character 'PARAGRAPH SEPARATOR' (U+2029)
	 * Treated as a line feed character in XFA rich and plain text.
     * @since 5.4.3
     */
    public static final char PARAGRAPH_SEPARATOR = '\u2029';

    protected ArrayList subsetRanges;
    /** The font type.
     */
    int fontType;
    /** a not defined character in a custom PDF encoding */
    public static final String notdef = ".notdef";

    /** table of characters widths for this encoding */
    protected int widths[] = new int[256];

    /** encoding names */
    protected String differences[] = new String[256];
    /** same as differences but with the unicode codes */
    protected char unicodeDifferences[] = new char[256];

    protected int charBBoxes[][] = new int[256][];
    /** encoding used with this font */
    protected String encoding;

    /** true if the font is to be embedded in the PDF */
    protected boolean embedded;

    /**
     * The compression level for the font stream.
     * @since	2.1.3
     */
    protected int compressionLevel = PdfStream.DEFAULT_COMPRESSION;

    /**
     * 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.
     */
    protected boolean fontSpecific = true;

    /** cache for the fonts already used. */
    protected static ConcurrentHashMap fontCache = new ConcurrentHashMap();

    /** list of the 14 built in fonts. */
    protected static final HashMap BuiltinFonts14 = new HashMap();

    /** Forces the output of the width array. Only matters for the 14
     * built-in fonts.
     */
    protected boolean forceWidthsOutput = false;

    /** Converts char directly to byte
     * by casting.
     */
    protected boolean directTextToByte = false;

    /** Indicates if all the glyphs and widths for that particular
     * encoding should be included in the document.
     */
    protected boolean subset = true;

    protected boolean fastWinansi = false;

    /**
     * Custom encodings use this map to key the Unicode character
     * to the single byte code.
     */
    protected IntHashtable specialMap;

    protected boolean vertical = false;

    static {
        BuiltinFonts14.put(COURIER, PdfName.COURIER);
        BuiltinFonts14.put(COURIER_BOLD, PdfName.COURIER_BOLD);
        BuiltinFonts14.put(COURIER_BOLDOBLIQUE, PdfName.COURIER_BOLDOBLIQUE);
        BuiltinFonts14.put(COURIER_OBLIQUE, PdfName.COURIER_OBLIQUE);
        BuiltinFonts14.put(HELVETICA, PdfName.HELVETICA);
        BuiltinFonts14.put(HELVETICA_BOLD, PdfName.HELVETICA_BOLD);
        BuiltinFonts14.put(HELVETICA_BOLDOBLIQUE, PdfName.HELVETICA_BOLDOBLIQUE);
        BuiltinFonts14.put(HELVETICA_OBLIQUE, PdfName.HELVETICA_OBLIQUE);
        BuiltinFonts14.put(SYMBOL, PdfName.SYMBOL);
        BuiltinFonts14.put(TIMES_ROMAN, PdfName.TIMES_ROMAN);
        BuiltinFonts14.put(TIMES_BOLD, PdfName.TIMES_BOLD);
        BuiltinFonts14.put(TIMES_BOLDITALIC, PdfName.TIMES_BOLDITALIC);
        BuiltinFonts14.put(TIMES_ITALIC, PdfName.TIMES_ITALIC);
        BuiltinFonts14.put(ZAPFDINGBATS, PdfName.ZAPFDINGBATS);
    }

    /** Generates the PDF stream with the Type1 and Truetype fonts returning
     * a PdfStream.
     */
    static class StreamFont extends PdfStream {

        /** Generates the PDF stream with the Type1 and Truetype fonts returning
         * a PdfStream.
         * @param contents the content of the stream
         * @param lengths an array of int that describes the several lengths of each part of the font
         * @param compressionLevel	the compression level of the Stream
         * @throws DocumentException error in the stream compression
         * @since	2.1.3 (replaces the constructor without param compressionLevel)
         */
        public StreamFont(byte contents[], int lengths[], int compressionLevel) throws DocumentException {
            try {
                bytes = contents;
                put(PdfName.LENGTH, new PdfNumber(bytes.length));
                for (int k = 0; k < lengths.length; ++k) {
                    put(new PdfName("Length" + (k + 1)), new PdfNumber(lengths[k]));
                }
                flateCompress(compressionLevel);
            }
            catch (Exception e) {
                throw new DocumentException(e);
            }
        }

        /**
         * Generates the PDF stream for a font.
         * @param contents the content of a stream
         * @param subType the subtype of the font.
         * @param compressionLevel	the compression level of the Stream
         * @throws DocumentException error in the stream compression
         * @since	2.1.3 (replaces the constructor without param compressionLevel)
         */
        public StreamFont(byte contents[], String subType, int compressionLevel) throws DocumentException {
            try {
                bytes = contents;
                put(PdfName.LENGTH, new PdfNumber(bytes.length));
                if (subType != null)
                    put(PdfName.SUBTYPE, new PdfName(subType));
                flateCompress(compressionLevel);
            }
            catch (Exception e) {
                throw new DocumentException(e);
            }
        }
    }

    /**
     *Creates new BaseFont
     */
    protected BaseFont() {
    }

    /**
     * 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.
     * @return	a BaseFont object (Helvetica, Winansi, not embedded)
     * @throws	IOException			This shouldn't occur ever
     * @throws	DocumentException	This shouldn't occur ever
     * @since	2.1.1
     */
    public static BaseFont createFont() throws DocumentException, IOException {
        return createFont(BaseFont.HELVETICA, BaseFont.WINANSI, BaseFont.NOT_EMBEDDED);
    }

    /**
     * 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);
     * 
* @param name the name of the font or its location on file * @param encoding the encoding to be applied to this font * @param embedded true if the font is to be embedded in the PDF * @return returns a new font. This font may come from the cache * @throws DocumentException the font is invalid * @throws IOException the font file could not be read */ public static BaseFont createFont(String name, String encoding, boolean embedded) throws DocumentException, IOException { return createFont(name, encoding, embedded, true, null, null, false); } /** * 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);
     * 
* @param name the name of the font or its location on file * @param encoding the encoding to be applied to this font * @param embedded true if the font is to be embedded in the PDF * @param forceRead in some cases (TrueTypeFont, Type1Font), the full font file will be read and kept in memory if forceRead is true * @return returns a new font. This font may come from the cache * @throws DocumentException the font is invalid * @throws IOException the font file could not be read * @since 2.1.5 */ public static BaseFont createFont(String name, String encoding, boolean embedded, boolean forceRead) throws DocumentException, IOException { return createFont(name, encoding, embedded, true, null, null, forceRead); } /** 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"
     * 
* @param name the name of the font or its location on file * @param encoding the encoding to be applied to this font * @param embedded true if the font is to be embedded in the PDF * @param 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 * @param ttfAfm the true type font or the afm in a byte array * @param pfb the pfb in a byte array * @return 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 * @throws IOException the font file could not be read * @since iText 0.80 */ public static BaseFont createFont(String name, String encoding, boolean embedded, boolean cached, byte ttfAfm[], byte pfb[]) throws DocumentException, IOException { return createFont(name, encoding, embedded, cached, ttfAfm, pfb, false); } /** 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"
     * 
* @param name the name of the font or its location on file * @param encoding the encoding to be applied to this font * @param embedded true if the font is to be embedded in the PDF * @param 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 * @param ttfAfm the true type font or the afm in a byte array * @param pfb the pfb in a byte array * @param 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 * @return 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 * @throws IOException the font file could not be read * @since 2.0.3 */ public static BaseFont createFont(String name, String encoding, boolean embedded, boolean cached, byte ttfAfm[], byte pfb[], boolean noThrow) throws DocumentException, IOException { return createFont(name, encoding, embedded, cached, ttfAfm, pfb, noThrow, false); } /** 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"
     * 
* @param name the name of the font or its location on file * @param encoding the encoding to be applied to this font * @param embedded true if the font is to be embedded in the PDF * @param 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 * @param ttfAfm the true type font or the afm in a byte array * @param pfb the pfb in a byte array * @param 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 * @param forceRead in some cases (TrueTypeFont, Type1Font), the full font file will be read and kept in memory if forceRead is true * @return 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 * @throws IOException the font file could not be read * @since 2.1.5 */ public static BaseFont createFont(String name, String encoding, boolean embedded, boolean cached, byte ttfAfm[], byte pfb[], boolean noThrow, boolean forceRead) throws DocumentException, IOException { String nameBase = getBaseName(name); encoding = normalizeEncoding(encoding); boolean isBuiltinFonts14 = BuiltinFonts14.containsKey(name); boolean isCJKFont = isBuiltinFonts14 ? false : CJKFont.isCJKFont(nameBase, encoding); if (isBuiltinFonts14 || isCJKFont) embedded = false; else if (encoding.equals(IDENTITY_H) || encoding.equals(IDENTITY_V)) embedded = true; BaseFont fontFound = null; BaseFont fontBuilt = null; String key = name + "\n" + encoding + "\n" + embedded; if (cached) { fontFound = fontCache.get(key); if (fontFound != null) return fontFound; } if (isBuiltinFonts14 || name.toLowerCase().endsWith(".afm") || name.toLowerCase().endsWith(".pfm")) { fontBuilt = new Type1Font(name, encoding, embedded, ttfAfm, pfb, forceRead); fontBuilt.fastWinansi = encoding.equals(CP1252); } else if (nameBase.toLowerCase().endsWith(".ttf") || nameBase.toLowerCase().endsWith(".otf") || nameBase.toLowerCase().indexOf(".ttc,") > 0) { if (encoding.equals(IDENTITY_H) || encoding.equals(IDENTITY_V)) fontBuilt = new TrueTypeFontUnicode(name, encoding, embedded, ttfAfm, forceRead); else { fontBuilt = new TrueTypeFont(name, encoding, embedded, ttfAfm, false, forceRead); fontBuilt.fastWinansi = encoding.equals(CP1252); } } else if (isCJKFont) fontBuilt = new CJKFont(name, encoding, embedded); else if (noThrow) return null; else throw new DocumentException(MessageLocalization.getComposedMessage("font.1.with.2.is.not.recognized", name, encoding)); if (cached) { fontFound = fontCache.get(key); if (fontFound != null) return fontFound; fontCache.putIfAbsent(key, fontBuilt); } return fontBuilt; } /** * Creates a font based on an existing document font. The created font font may not * behave as expected, depending on the encoding or subset. * @param fontRef the reference to the document font * @return the font */ public static BaseFont createFont(PRIndirectReference fontRef) { return new DocumentFont(fontRef); } /** * Indicates whether the font is used for verticl writing or not. * @return true if the writing mode is vertical for the given font, false otherwise. */ public boolean isVertical() { return vertical; } /** * Gets the name without the modifiers Bold, Italic or BoldItalic. * @param name the full name of the font * @return the name without the modifiers Bold, Italic or BoldItalic */ protected static String getBaseName(String name) { if (name.endsWith(",Bold")) return name.substring(0, name.length() - 5); else if (name.endsWith(",Italic")) return name.substring(0, name.length() - 7); else if (name.endsWith(",BoldItalic")) return name.substring(0, name.length() - 11); else return name; } /** * Normalize the encoding names. "winansi" is changed to "Cp1252" and * "macroman" is changed to "MacRoman". * @param enc the encoding to be normalized * @return the normalized encoding */ protected static String normalizeEncoding(String enc) { if (enc.equals("winansi") || enc.equals("")) return CP1252; else if (enc.equals("macroman")) return MACROMAN; else return enc; } /** * Creates the widths and the differences arrays */ protected void createEncoding() { if (encoding.startsWith("#")) { specialMap = new IntHashtable(); StringTokenizer tok = new StringTokenizer(encoding.substring(1), " ,\t\n\r\f"); if (tok.nextToken().equals("full")) { while (tok.hasMoreTokens()) { String order = tok.nextToken(); String name = tok.nextToken(); char uni = (char)Integer.parseInt(tok.nextToken(), 16); int orderK; if (order.startsWith("'")) orderK = order.charAt(1); else orderK = Integer.parseInt(order); orderK %= 256; specialMap.put(uni, orderK); differences[orderK] = name; unicodeDifferences[orderK] = uni; widths[orderK] = getRawWidth(uni, name); charBBoxes[orderK] = getRawCharBBox(uni, name); } } else { int k = 0; if (tok.hasMoreTokens()) k = Integer.parseInt(tok.nextToken()); while (tok.hasMoreTokens() && k < 256) { String hex = tok.nextToken(); int uni = Integer.parseInt(hex, 16) % 0x10000; String name = GlyphList.unicodeToName(uni); if (name != null) { specialMap.put(uni, k); differences[k] = name; unicodeDifferences[k] = (char)uni; widths[k] = getRawWidth(uni, name); charBBoxes[k] = getRawCharBBox(uni, name); ++k; } } } for (int k = 0; k < 256; ++k) { if (differences[k] == null) { differences[k] = notdef; } } } else if (fontSpecific) { for (int k = 0; k < 256; ++k) { widths[k] = getRawWidth(k, null); charBBoxes[k] = getRawCharBBox(k, null); } } else { String s; String name; char c; byte b[] = new byte[1]; for (int k = 0; k < 256; ++k) { b[0] = (byte)k; s = PdfEncodings.convertToString(b, encoding); if (s.length() > 0) { c = s.charAt(0); } else { c = '?'; } name = GlyphList.unicodeToName(c); if (name == null) name = notdef; differences[k] = name; unicodeDifferences[k] = c; widths[k] = getRawWidth(c, name); charBBoxes[k] = getRawCharBBox(c, 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. * @param c the unicode char * @param name the glyph name * @return the width of the char */ abstract int getRawWidth(int c, String name); /** * Gets the kerning between two Unicode chars. * @param char1 the first char * @param char2 the second char * @return the kerning to be applied in normalized 1000 units */ public abstract int getKerning(int char1, int char2); /** * Sets the kerning between two Unicode chars. * @param char1 the first char * @param char2 the second char * @param kern the kerning to apply in normalized 1000 units * @return true if the kerning was applied, false otherwise */ public abstract boolean setKerning(int char1, int char2, int kern); /** * Gets the width of a char in normalized 1000 units. * @param char1 the unicode char to get the width of * @return the width in normalized 1000 units */ public int getWidth(int char1) { if (fastWinansi) { if (char1 < 128 || char1 >= 160 && char1 <= 255) return widths[char1]; else return widths[PdfEncodings.winansi.get(char1)]; } else { int total = 0; byte mbytes[] = convertToBytes(/*(char)*/char1); for (int k = 0; k < mbytes.length; ++k) total += widths[0xff & mbytes[k]]; return total; } } /** * Gets the width of a String in normalized 1000 units. * @param text the String to get the width of * @return the width in normalized 1000 units */ public int getWidth(String text) { int total = 0; if (fastWinansi) { int len = text.length(); for (int k = 0; k < len; ++k) { char char1 = text.charAt(k); if (char1 < 128 || char1 >= 160 && char1 <= 255) total += widths[char1]; else total += widths[PdfEncodings.winansi.get(char1)]; } return total; } else { byte mbytes[] = convertToBytes(text); for (int k = 0; k < mbytes.length; ++k) total += widths[0xff & mbytes[k]]; } return total; } /** * 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. * @param text the String to get the descent of * @return the descent in normalized 1000 units */ public int getDescent(String text) { int min = 0; char chars[] = text.toCharArray(); for (int k = 0; k < chars.length; ++k) { int bbox[] = getCharBBox(chars[k]); if (bbox != null && bbox[1] < min) min = bbox[1]; } return min; } /** * 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. * @param text the String to get the ascent of * @return the ascent in normalized 1000 units */ public int getAscent(String text) { int max = 0; char chars[] = text.toCharArray(); for (int k = 0; k < chars.length; ++k) { int bbox[] = getCharBBox(chars[k]); if (bbox != null && bbox[3] > max) max = bbox[3]; } return max; } /** * 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. * @param text the String to get the descent of * @param fontSize the size of the font * @return the descent in points */ public float getDescentPoint(String text, float fontSize) { return getDescent(text) * 0.001f * 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. * @param text the String to get the ascent of * @param fontSize the size of the font * @return the ascent in points */ public float getAscentPoint(String text, float fontSize) { return getAscent(text) * 0.001f * fontSize; } // ia> /** * Gets the width of a String in points taking kerning * into account. * @param text the String to get the width of * @param fontSize the font size * @return the width in points */ public float getWidthPointKerned(String text, float fontSize) { float size = getWidth(text) * 0.001f * fontSize; if (!hasKernPairs()) return size; int len = text.length() - 1; int kern = 0; char c[] = text.toCharArray(); for (int k = 0; k < len; ++k) { kern += getKerning(c[k], c[k + 1]); } return size + kern * 0.001f * fontSize; } /** * Gets the width of a String in points. * @param text the String to get the width of * @param fontSize the font size * @return the width in points */ public float getWidthPoint(String text, float fontSize) { return getWidth(text) * 0.001f * fontSize; } /** * Gets the width of a char in points. * @param char1 the char to get the width of * @param fontSize the font size * @return the width in points */ public float getWidthPoint(int char1, float fontSize) { return getWidth(char1) * 0.001f * fontSize; } /** * Converts a String to a
byte array according * to the font's encoding. * @param text the String to be converted * @return an array of byte representing the conversion according to the font's encoding */ public byte[] convertToBytes(String text) { if (directTextToByte) return PdfEncodings.convertToBytes(text, null); if (specialMap != null) { byte[] b = new byte[text.length()]; int ptr = 0; int length = text.length(); for (int k = 0; k < length; ++k) { char c = text.charAt(k); if (specialMap.containsKey(c)) b[ptr++] = (byte)specialMap.get(c); } if (ptr < length) { byte[] b2 = new byte[ptr]; System.arraycopy(b, 0, b2, 0, ptr); return b2; } else return b; } return PdfEncodings.convertToBytes(text, encoding); } /** * Converts a char to a byte array according * to the font's encoding. * @param char1 the char to be converted * @return an array of byte representing the conversion according to the font's encoding */ byte[] convertToBytes(int char1) { if (directTextToByte) return PdfEncodings.convertToBytes((char)char1, null); if (specialMap != null) { if (specialMap.containsKey(char1)) return new byte[]{(byte)specialMap.get(char1)}; else return new byte[0]; } return PdfEncodings.convertToBytes((char)char1, encoding); } /** Outputs to the writer the font dictionaries and streams. * @param writer the writer for this document * @param ref the font indirect reference * @param params several parameters that depend on the font type * @throws IOException on error * @throws DocumentException error in generating the object */ abstract void writeFont(PdfWriter writer, PdfIndirectReference ref, Object params[]) throws DocumentException, IOException; /** * 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). * @return a PdfStream with the font program * @since 2.1.3 */ abstract PdfStream getFullFontStream() throws IOException, DocumentException; /** Gets the encoding used to convert String into byte[]. * @return the encoding name */ public String getEncoding() { return encoding; } /** 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. * @param key the parameter to be extracted * @param fontSize the font size in points * @return the parameter in points */ public abstract float getFontDescriptor(int key, float fontSize); /** Sets the font parameter identified by key. Valid values * for key are ASCENT, AWT_ASCENT, CAPHEIGHT, * DESCENT, AWT_DESCENT, * ITALICANGLE, BBOXLLX, BBOXLLY, BBOXURX * and BBOXURY. * @param key the parameter to be updated * @param value the parameter value */ public void setFontDescriptor(int key, float value) {} /** Gets the font type. The font types can be: FONT_TYPE_T1, * FONT_TYPE_TT, FONT_TYPE_CJK and FONT_TYPE_TTUNI. * @return the font type */ public int getFontType() { return fontType; } /** Gets the embedded flag. * @return true if the font is embedded. */ public boolean isEmbedded() { return embedded; } /** Gets the symbolic flag of the font. * @return true if the font is symbolic */ public boolean isFontSpecific() { return fontSpecific; } /** Creates a unique subset prefix to be added to the font name when the font is embedded and subset. * @return the subset prefix */ public static String createSubsetPrefix() { StringBuilder s = new StringBuilder(""); for (int k = 0; k < 6; ++k) s.append((char)(Math.random() * 26 + 'A')); return s + "+"; } /** Gets the Unicode character corresponding to the byte output to the pdf stream. * @param index the byte index * @return the Unicode character */ char getUnicodeDifferences(int index) { return unicodeDifferences[index]; } /** Gets the postscript font name. * @return the postscript font name */ public abstract String getPostscriptFontName(); /** * 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. * @param name the new font name */ public abstract void setPostscriptFontName(String name); public String getSubfamily() { return ""; } /** 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}. * @return the full name of the font */ public abstract String[][] getFullFontName(); /** 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}. * @return the full name of the font * @since 2.0.8 */ public abstract String[][] getAllNameEntries(); /** 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}. * @param name the name of the font * @param encoding the encoding of the font * @param ttfAfm the true type font or the afm in a byte array * @throws DocumentException on error * @throws IOException on error * @return the full name of the font */ public static String[][] getFullFontName(String name, String encoding, byte ttfAfm[]) throws DocumentException, IOException { String nameBase = getBaseName(name); BaseFont fontBuilt = null; if (nameBase.toLowerCase().endsWith(".ttf") || nameBase.toLowerCase().endsWith(".otf") || nameBase.toLowerCase().indexOf(".ttc,") > 0) fontBuilt = new TrueTypeFont(name, CP1252, false, ttfAfm, true, false); else fontBuilt = createFont(name, encoding, false, false, ttfAfm, null); return fontBuilt.getFullFontName(); } /** Gets all the names from the font. Only the required tables are read. * @param name the name of the font * @param encoding the encoding of the font * @param ttfAfm the true type font or the afm in a byte array * @throws DocumentException on error * @throws IOException on error * @return an array of Object[] built with {getPostscriptFontName(), getFamilyFontName(), getFullFontName()} */ public static Object[] getAllFontNames(String name, String encoding, byte ttfAfm[]) throws DocumentException, IOException { String nameBase = getBaseName(name); BaseFont fontBuilt = null; if (nameBase.toLowerCase().endsWith(".ttf") || nameBase.toLowerCase().endsWith(".otf") || nameBase.toLowerCase().indexOf(".ttc,") > 0) fontBuilt = new TrueTypeFont(name, CP1252, false, ttfAfm, true, false); else fontBuilt = createFont(name, encoding, false, false, ttfAfm, null); return new Object[]{fontBuilt.getPostscriptFontName(), fontBuilt.getFamilyFontName(), fontBuilt.getFullFontName()}; } /** Gets all the entries of the namestable from the font. Only the required tables are read. * @param name the name of the font * @param encoding the encoding of the font * @param ttfAfm the true type font or the afm in a byte array * @throws DocumentException on error * @throws IOException on error * @return an array of Object[] built with {getPostscriptFontName(), getFamilyFontName(), getFullFontName()} * @since 2.0.8 */ public static String[][] getAllNameEntries(String name, String encoding, byte ttfAfm[]) throws DocumentException, IOException { String nameBase = getBaseName(name); BaseFont fontBuilt = null; if (nameBase.toLowerCase().endsWith(".ttf") || nameBase.toLowerCase().endsWith(".otf") || nameBase.toLowerCase().indexOf(".ttc,") > 0) fontBuilt = new TrueTypeFont(name, CP1252, false, ttfAfm, true, false); else fontBuilt = createFont(name, encoding, false, false, ttfAfm, null); return fontBuilt.getAllNameEntries(); } /** 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}. * @return the family name of the font */ public abstract String[][] getFamilyFontName(); /** Gets the code pages supported by the font. This has only meaning * with True Type fonts. * @return the code pages supported by the font */ public String[] getCodePagesSupported() { return new String[0]; } /** Enumerates the postscript font names present inside a * True Type Collection. * @param ttcFile the file name of the font * @throws DocumentException on error * @throws IOException on error * @return the postscript font names */ public static String[] enumerateTTCNames(String ttcFile) throws DocumentException, IOException { return new EnumerateTTC(ttcFile).getNames(); } /** Enumerates the postscript font names present inside a * True Type Collection. * @param ttcArray the font as a byte array * @throws DocumentException on error * @throws IOException on error * @return the postscript font names */ public static String[] enumerateTTCNames(byte ttcArray[]) throws DocumentException, IOException { return new EnumerateTTC(ttcArray).getNames(); } /** Gets the font width array. * @return the font width array */ public int[] getWidths() { return widths; } /** Gets the array with the names of the characters. * @return the array with the names of the characters */ public String[] getDifferences() { return differences; } /** Gets the array with the unicode characters. * @return the array with the unicode characters */ public char[] getUnicodeDifferences() { return unicodeDifferences; } /** Gets the state of the property. * @return value of property forceWidthsOutput */ public boolean isForceWidthsOutput() { return forceWidthsOutput; } /** Set to true to force the generation of the * widths array. * @param forceWidthsOutput true to force the generation of the * widths array */ public void setForceWidthsOutput(boolean forceWidthsOutput) { this.forceWidthsOutput = forceWidthsOutput; } /** Gets the direct conversion of char to byte. * @return value of property directTextToByte. * @see #setDirectTextToByte(boolean directTextToByte) */ public boolean isDirectTextToByte() { return 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(). * @param directTextToByte New value of property directTextToByte. */ public void setDirectTextToByte(boolean directTextToByte) { this.directTextToByte = directTextToByte; } /** Indicates if all the glyphs and widths for that particular * encoding should be included in the document. * @return false to include all the glyphs and widths. */ public boolean isSubset() { return 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 {@link #addSubsetRange(int[])} was not called the full font will be included * otherwise just the characters ranges will be included. * @param subset new value of property subset */ public void setSubset(boolean subset) { this.subset = subset; } /** Gets the Unicode equivalent to a CID. * The (inexistent) CID is translated as '\n'. * It has only meaning with CJK fonts with Identity encoding. * @param c the CID code * @return the Unicode equivalent */ public int getUnicodeEquivalent(int c) { return c; } /** Gets the CID code given an Unicode. * It has only meaning with CJK fonts. * @param c the Unicode * @return the CID equivalent */ public int getCidCode(int c) { return c; } /** Checks if the font has any kerning pairs. * @return true if the font has any kerning pairs */ public abstract boolean hasKernPairs(); /** * Checks if a character exists in this font. * @param c the character to check * @return true if the character has a glyph, * false otherwise */ public boolean charExists(int c) { byte b[] = convertToBytes(c); return b.length > 0; } /** * Sets the character advance. * @param c the character * @param advance the character advance normalized to 1000 units * @return true if the advance was set, * false otherwise */ public boolean setCharAdvance(int c, int advance) { byte b[] = convertToBytes(c); if (b.length == 0) return false; widths[0xff & b[0]] = advance; return true; } private static void addFont(PRIndirectReference fontRef, IntHashtable hits, ArrayList fonts) { PdfObject obj = PdfReader.getPdfObject(fontRef); if (obj == null || !obj.isDictionary()) return; PdfDictionary font = (PdfDictionary)obj; PdfName subtype = font.getAsName(PdfName.SUBTYPE); if (!PdfName.TYPE1.equals(subtype) && !PdfName.TRUETYPE.equals(subtype) && !PdfName.TYPE0.equals(subtype)) return; PdfName name = font.getAsName(PdfName.BASEFONT); fonts.add(new Object[]{PdfName.decodeName(name.toString()), fontRef}); hits.put(fontRef.getNumber(), 1); } private static void recourseFonts(PdfDictionary page, IntHashtable hits, ArrayList fonts, int level, HashSet visitedResources) { ++level; if (level > 50) // in case we have an endless loop return; if (page == null) return; PdfDictionary resources = page.getAsDict(PdfName.RESOURCES); if (resources == null) return; PdfDictionary font = resources.getAsDict(PdfName.FONT); if (font != null) { for (PdfName key : font.getKeys()) { PdfObject ft = font.get(key); if (ft == null || !ft.isIndirect()) continue; int hit = ((PRIndirectReference)ft).getNumber(); if (hits.containsKey(hit)) continue; addFont((PRIndirectReference)ft, hits, fonts); } } PdfDictionary xobj = resources.getAsDict(PdfName.XOBJECT); if (xobj != null) { if (visitedResources.add(xobj)){ for (PdfName key : xobj.getKeys()) { PdfObject po = xobj.getDirectObject(key); if (po instanceof PdfDictionary) recourseFonts((PdfDictionary)po, hits, fonts, level, visitedResources); } visitedResources.remove(xobj); } else throw new ExceptionConverter(new InvalidPdfException(MessageLocalization.getComposedMessage("illegal.resources.tree"))); } } /** * 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. * @param reader the document where the fonts are to be listed from * @return the list of fonts and references */ public static ArrayList getDocumentFonts(PdfReader reader) { IntHashtable hits = new IntHashtable(); ArrayList fonts = new ArrayList(); int npages = reader.getNumberOfPages(); for (int k = 1; k <= npages; ++k) recourseFonts(reader.getPageN(k), hits, fonts, 1, new HashSet()); return fonts; } /** * 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. * @param reader the document where the fonts are to be listed from * @param page the page to list the fonts from * @return the list of fonts and references */ public static ArrayList getDocumentFonts(PdfReader reader, int page) { IntHashtable hits = new IntHashtable(); ArrayList fonts = new ArrayList(); recourseFonts(reader.getPageN(page), hits, fonts, 1, new HashSet()); return fonts; } /** * 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]. * @param c the character to get the contour bounding box from * @return an array of four floats with the bounding box in the format [llx,lly,urx,ury] or * null */ public int[] getCharBBox(int c) { byte b[] = convertToBytes(c); if (b.length == 0) return null; else return charBBoxes[b[0] & 0xff]; } /** * get default array of six numbers specifying the font matrix, mapping glyph space to text space * @return an array of six values * null */ public double[] getFontMatrix() { return DEFAULT_FONT_MATRIX; } protected abstract int[] getRawCharBBox(int c, String name); /** * 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. */ public void correctArabicAdvance() { for (char c = '\u064b'; c <= '\u0658'; ++c) setCharAdvance(c, 0); setCharAdvance('\u0670', 0); for (char c = '\u06d6'; c <= '\u06dc'; ++c) setCharAdvance(c, 0); for (char c = '\u06df'; c <= '\u06e4'; ++c) setCharAdvance(c, 0); for (char c = '\u06e7'; c <= '\u06e8'; ++c) setCharAdvance(c, 0); for (char c = '\u06ea'; c <= '\u06ed'; ++c) setCharAdvance(c, 0); } /** * 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. * @param range the character range */ public void addSubsetRange(int[] range) { if (subsetRanges == null) subsetRanges = new ArrayList(); subsetRanges.add(range); } /** * Returns the compression level used for the font streams. * @return the compression level (0 = best speed, 9 = best compression, -1 is default) * @since 2.1.3 */ public int getCompressionLevel() { return compressionLevel; } /** * Sets the compression level to be used for the font streams. * @param compressionLevel a value between 0 (best speed) and 9 (best compression) * @since 2.1.3 */ public void setCompressionLevel(int compressionLevel) { if (compressionLevel < PdfStream.NO_COMPRESSION || compressionLevel > PdfStream.BEST_COMPRESSION) this.compressionLevel = PdfStream.DEFAULT_COMPRESSION; else this.compressionLevel = compressionLevel; } }




© 2015 - 2024 Weber Informatics LLC | Privacy Policy