iText 5 itextpdf.jar Source Code
itextpdf.jar is a component in iText 5 Java library to provide core functionalities.
iText Java library allows you to generate and manage PDF documents.
The Source Code files are provided at iText GitHub site.
You can compile it to generate your JAR file, using pom.xml as the build configuration file.
The source code of itextpdf-5.5.14.jar is provided below:
✍: FYIcenter.com
⏎ com/itextpdf/text/pdf/BaseFont.java
/*
*
* This file is part of the iText (R) project.
Copyright (c) 1998-2020 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: sales@itextpdf.com
*/
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<int[]> 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
* <CODE>encoding</CODE> 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<String, BaseFont> fontCache = new ConcurrentHashMap<String, BaseFont>();
/** list of the 14 built in fonts. */
protected static final HashMap<String, PdfName> BuiltinFonts14 = new HashMap<String, PdfName>();
/** Forces the output of the width array. Only matters for the 14
* built-in fonts.
*/
protected boolean forceWidthsOutput = false;
/** Converts <CODE>char</CODE> directly to <CODE>byte</CODE>
* 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".
* <P>
* The fonts are cached and if they already exist they are extracted from the cache,
* not parsed again.
* <P>
* 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.<br>
* 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.<br>
* 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.
* <P>
* Example for a "simple" encoding that includes the Unicode
* character space, A, B and ecyrillic:
* <PRE>
* "# simple 32 0020 0041 0042 0454"
* </PRE>
* <P>
* Example for a "full" encoding for a Type1 Tex font:
* <PRE>
* "# full 'A' nottriangeqlleft 0041 'B' dividemultiply 0042 32 space 0020"
* </PRE>
* <P>
* This method calls:<br>
* <PRE>
* createFont(name, encoding, embedded, true, null, null);
* </PRE>
* @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".
* <P>
* The fonts are cached and if they already exist they are extracted from the cache,
* not parsed again.
* <P>
* 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.<br>
* 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.<br>
* 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.
* <P>
* Example for a "simple" encoding that includes the Unicode
* character space, A, B and ecyrillic:
* <PRE>
* "# simple 32 0020 0041 0042 0454"
* </PRE>
* <P>
* Example for a "full" encoding for a Type1 Tex font:
* <PRE>
* "# full 'A' nottriangeqlleft 0041 'B' dividemultiply 0042 32 space 0020"
* </PRE>
* <P>
* This method calls:<br>
* <PRE>
* createFont(name, encoding, embedded, true, null, null);
* </PRE>
* @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".
* <P>
* The fonts may or may not be cached depending on the flag <CODE>cached</CODE>.
* If the <CODE>byte</CODE> arrays are present the font will be
* read from them instead of the name. A name is still required to identify
* the font type.
* <P>
* 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.<br>
* 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.<br>
* 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.
* <P>
* Example for a "simple" encoding that includes the Unicode
* character space, A, B and ecyrillic:
* <PRE>
* "# simple 32 0020 0041 0042 0454"
* </PRE>
* <P>
* Example for a "full" encoding for a Type1 Tex font:
* <PRE>
* "# full 'A' nottriangeqlleft 0041 'B' dividemultiply 0042 32 space 0020"
* </PRE>
* @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".
* <P>
* The fonts may or may not be cached depending on the flag <CODE>cached</CODE>.
* If the <CODE>byte</CODE> arrays are present the font will be
* read from them instead of the name. A name is still required to identify
* the font type.
* <P>
* 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.<br>
* 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.<br>
* 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.
* <P>
* Example for a "simple" encoding that includes the Unicode
* character space, A, B and ecyrillic:
* <PRE>
* "# simple 32 0020 0041 0042 0454"
* </PRE>
* <P>
* Example for a "full" encoding for a Type1 Tex font:
* <PRE>
* "# full 'A' nottriangeqlleft 0041 'B' dividemultiply 0042 32 space 0020"
* </PRE>
* @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".
* <P>
* The fonts may or may not be cached depending on the flag <CODE>cached</CODE>.
* If the <CODE>byte</CODE> arrays are present the font will be
* read from them instead of the name. A name is still required to identify
* the font type.
* <P>
* 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.<br>
* 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.<br>
* 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.
* <P>
* Example for a "simple" encoding that includes the Unicode
* character space, A, B and ecyrillic:
* <PRE>
* "# simple 32 0020 0041 0042 0454"
* </PRE>
* <P>
* Example for a "full" encoding for a Type1 Tex font:
* <PRE>
* "# full 'A' nottriangeqlleft 0041 'B' dividemultiply 0042 32 space 0020"
* </PRE>
* @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 <code>true</code> if the writing mode is vertical for the given font, <code>false</code> 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 <CODE>widths</CODE> and the <CODE>differences</CODE> 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 <CODE>c</CODE>
* or the <CODE>name</CODE>. If the <CODE>name</CODE> 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 <code>true</code> if the kerning was applied, <code>false</code> otherwise
*/
public abstract boolean setKerning(int char1, int char2, int kern);
/**
* Gets the width of a <CODE>char</CODE> in normalized 1000 units.
* @param char1 the unicode <CODE>char</CODE> 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 <CODE>String</CODE> in normalized 1000 units.
* @param text the <CODE>String</CODE> 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 <CODE>String</CODE> 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 <CODE>String</CODE> 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 <CODE>String</CODE> 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 <CODE>String</CODE> 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 <CODE>String</CODE> 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 <CODE>String</CODE> 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 <CODE>String</CODE> 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 <CODE>String</CODE> 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 <CODE>String</CODE> in points taking kerning
* into account.
* @param text the <CODE>String</CODE> 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 <CODE>String</CODE> in points.
* @param text the <CODE>String</CODE> 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 <CODE>char</CODE> in points.
* @param char1 the <CODE>char</CODE> 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 <CODE>String</CODE> to a </CODE>byte</CODE> array according
* to the font's encoding.
* @param text the <CODE>String</CODE> to be converted
* @return an array of <CODE>byte</CODE> 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 <CODE>char</CODE> to a </CODE>byte</CODE> array according
* to the font's encoding.
* @param char1 the <CODE>char</CODE> to be converted
* @return an array of <CODE>byte</CODE> 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 <CODE>String</CODE> into <CODE>byte[]</CODE>.
* @return the encoding name
*/
public String getEncoding() {
return encoding;
}
/** Gets the font parameter identified by <CODE>key</CODE>. Valid values
* for <CODE>key</CODE> are <CODE>ASCENT</CODE>, <CODE>AWT_ASCENT</CODE>, <CODE>CAPHEIGHT</CODE>,
* <CODE>DESCENT</CODE>, <CODE>AWT_DESCENT</CODE>,
* <CODE>ITALICANGLE</CODE>, <CODE>BBOXLLX</CODE>, <CODE>BBOXLLY</CODE>, <CODE>BBOXURX</CODE>
* and <CODE>BBOXURY</CODE>.
* @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 <CODE>key</CODE>. Valid values
* for <CODE>key</CODE> are <CODE>ASCENT</CODE>, <CODE>AWT_ASCENT</CODE>, <CODE>CAPHEIGHT</CODE>,
* <CODE>DESCENT</CODE>, <CODE>AWT_DESCENT</CODE>,
* <CODE>ITALICANGLE</CODE>, <CODE>BBOXLLX</CODE>, <CODE>BBOXLLY</CODE>, <CODE>BBOXURX</CODE>
* and <CODE>BBOXURY</CODE>.
* @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 <CODE>true</CODE> if the font is embedded.
*/
public boolean isEmbedded() {
return embedded;
}
/** Gets the symbolic flag of the font.
* @return <CODE>true</CODE> 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.<br>
* 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.<br>
* 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.<br>
* 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.<br>
* 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 <CODE>byte</CODE> 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 <CODE>true</CODE> to force the generation of the
* widths array.
* @param forceWidthsOutput <CODE>true</CODE> to force the generation of the
* widths array
*/
public void setForceWidthsOutput(boolean forceWidthsOutput) {
this.forceWidthsOutput = forceWidthsOutput;
}
/** Gets the direct conversion of <CODE>char</CODE> to <CODE>byte</CODE>.
* @return value of property directTextToByte.
* @see #setDirectTextToByte(boolean directTextToByte)
*/
public boolean isDirectTextToByte() {
return directTextToByte;
}
/** Sets the conversion of <CODE>char</CODE> directly to <CODE>byte</CODE>
* 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 <CODE>false</CODE> 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 <CODE>true</CODE>
* only the glyphs used will be included in the font. When set to <CODE>false</CODE>
* 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 <FF00> 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 <CODE>true</CODE> 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 <CODE>true</CODE> if the character has a glyph,
* <CODE>false</CODE> 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 <CODE>true</CODE> if the advance was set,
* <CODE>false</CODE> 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<Object[]> 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<Object[]> fonts, int level, HashSet<PdfDictionary> 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 <CODE>ArrayList</CODE>
* contains a <CODE>Object[]{String,PRIndirectReference}</CODE> 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<Object[]> getDocumentFonts(PdfReader reader) {
IntHashtable hits = new IntHashtable();
ArrayList<Object[]> fonts = new ArrayList<Object[]>();
int npages = reader.getNumberOfPages();
for (int k = 1; k <= npages; ++k)
recourseFonts(reader.getPageN(k), hits, fonts, 1, new HashSet<PdfDictionary>());
return fonts;
}
/**
* Gets a list of the document fonts in a particular page. Each element of the <CODE>ArrayList</CODE>
* contains a <CODE>Object[]{String,PRIndirectReference}</CODE> 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<Object[]> getDocumentFonts(PdfReader reader, int page) {
IntHashtable hits = new IntHashtable();
ArrayList<Object[]> fonts = new ArrayList<Object[]>();
recourseFonts(reader.getPageN(page), hits, fonts, 1, new HashSet<PdfDictionary>());
return fonts;
}
static PdfDictionary createBuiltInFontDictionary(String name) {
return createBuiltInFontDictionary(BuiltinFonts14.get(name));
}
private static PdfDictionary createBuiltInFontDictionary(PdfName name) {
if (name == null) {
return null;
}
PdfDictionary dictionary = new PdfDictionary();
dictionary.put(PdfName.TYPE, PdfName.FONT);
dictionary.put(PdfName.BASEFONT, name);
dictionary.put(PdfName.SUBTYPE, PdfName.TYPE1);
return dictionary;
}
/**
* Gets the smallest box enclosing the character contours. It will return
* <CODE>null</CODE> 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
* <code>null</code>
*/
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
* <code>null</code>
*/
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 <CODE>int</CODE> 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<int[]>();
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;
}
}
⏎ com/itextpdf/text/pdf/BaseFont.java
Or download all of them as a single archive file:
File name: itextpdf-5.5.14-fyi.zip File size: 2163839 bytes Release date: 2009-10-09 Download
⇒ iText-2.1.6.jar - iText, a JAVA-PDF library
⇐ iText layout.jar Source Code
2021-07-03, 111284👍, 0💬
