com.aowagie.text.pdf.BaseFont Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of afirma-lib-itext-android Show documentation
Show all versions of afirma-lib-itext-android Show documentation
Version modificada de iText 2.1.7 con el paquete cambiado, adaptaciones menores para firma y dependencias actualizadas.
/* * $Id: BaseFont.java 3869 2009-04-17 18:03:45Z blowagie $ * * Copyright 2000-2006 by Paulo Soares. * * The contents of this file are subject to the Mozilla Public License Version 1.1 * (the "License"); you may not use this file except in compliance with the License. * You may obtain a copy of the License at http://www.mozilla.org/MPL/ * * Software distributed under the License is distributed on an "AS IS" basis, * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License * for the specific language governing rights and limitations under the License. * * The Original Code is 'iText, a free JAVA-PDF library'. * * The Initial Developer of the Original Code is Bruno Lowagie. Portions created by * the Initial Developer are Copyright (C) 1999, 2000, 2001, 2002 by Bruno Lowagie. * All Rights Reserved. * Co-Developer of the code is Paulo Soares. Portions created by the Co-Developer * are Copyright (C) 2000, 2001, 2002 by Paulo Soares. All Rights Reserved. * * Contributor(s): all the names of the contributors are added in the source code * where applicable. * * Alternatively, the contents of this file may be used under the terms of the * LGPL license (the "GNU LIBRARY GENERAL PUBLIC LICENSE"), in which case the * provisions of LGPL are applicable instead of those above. If you wish to * allow use of your version of this file only under the terms of the LGPL * License and not to allow others to use your version of this file under * the MPL, indicate your decision by deleting the provisions above and * replace them with the notice and other provisions required by the LGPL. * If you do not delete the provisions above, a recipient may use your version * of this file under either the MPL or the GNU LIBRARY GENERAL PUBLIC LICENSE. * * This library is free software; you can redistribute it and/or modify it * under the terms of the MPL as stated above or under the terms of the GNU * Library General Public License as published by the Free Software Foundation; * either version 2 of the License, or any later version. * * This library 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 Library general Public License for more * details. * * If you didn't download this code from the following link, you should check if * you aren't using an obsolete version: * http://www.lowagie.com/iText/ */ package com.aowagie.text.pdf; import java.io.IOException; import java.io.InputStream; import java.util.ArrayList; import java.util.HashMap; import java.util.LinkedHashMap; import java.util.StringTokenizer; import com.aowagie.text.DocumentException; /** * Base class for the several font types supported * * @author Paulo Soares ([email protected]) */ 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. */ static final int ASCENT = 1; /** The y coordinate of the top of flat capital letters, measured from * the baseline. */ 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. */ static final int ITALICANGLE = 4; /** The lower left x glyph coordinate. */ static final int BBOXLLX = 5; /** The lower left y glyph coordinate. */ static final int BBOXLLY = 6; /** The upper right x glyph coordinate. */ static final int BBOXURX = 7; /** The upper right y glyph coordinate. */ public static final int BBOXURY = 8; /** java.awt.Font property */ static final int AWT_ASCENT = 9; /** java.awt.Font property */ static final int AWT_DESCENT = 10; /** java.awt.Font property */ static final int AWT_LEADING = 11; /** java.awt.Font property */ static final int AWT_MAXADVANCE = 12; /** * The underline position. Usually a negative value. */ static final int UNDERLINE_POSITION = 13; /** * The underline thickness. */ static final int UNDERLINE_THICKNESS = 14; /** * The strikethrough position. */ static final int STRIKETHROUGH_POSITION = 15; /** * The strikethrough thickness. */ static final int STRIKETHROUGH_THICKNESS = 16; /** * The recommended vertical size for subscripts for this font. */ static final int SUBSCRIPT_SIZE = 17; /** * The recommended vertical offset from the baseline for subscripts for this font. Usually a negative value. */ static final int SUBSCRIPT_OFFSET = 18; /** * The recommended vertical size for superscripts for this font. */ static final int SUPERSCRIPT_SIZE = 19; /** * The recommended vertical offset from the baseline for superscripts for this font. */ static final int SUPERSCRIPT_OFFSET = 20; /** The font is Type 1. */ static final int FONT_TYPE_T1 = 0; /** The font is True Type with a standard encoding. */ static final int FONT_TYPE_TT = 1; /** The font is CJK. */ static final int FONT_TYPE_CJK = 2; /** The font is True Type with a Unicode encoding. */ static final int FONT_TYPE_TTUNI = 3; /** A font already inside the document. */ static final int FONT_TYPE_DOCUMENT = 4; /** A Type3 font. */ static final int FONT_TYPE_T3 = 5; /** The Unicode encoding with horizontal writing. */ static final String IDENTITY_H = "Identity-H"; /** The Unicode encoding with vertical writing. */ static final String IDENTITY_V = "Identity-V"; /** A possible encoding. */ public static final String CP1252 = "Cp1252"; /** A possible encoding. */ public static final String WINANSI = "Cp1252"; /** A possible encoding. */ static final String MACROMAN = "MacRoman"; /** if the font has to be embedded */ 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 */ static final boolean CACHED = true; /** The path to the font resources. */ static final String RESOURCE_PATH = "com/lowagie/text/pdf/fonts/"; /** The fake CID code that represents a newline. */ static final char CID_NEWLINE = '\u7fff'; protected ArrayList subsetRanges; /** The font type. */ int fontType; /** a not defined character in a custom PDF encoding */ 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]; private final 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 *byte array according * to the font's encoding. * @param text theencodingis 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. */ private static HashMap fontCache = new LinkedHashMap(); /** list of the 14 built in fonts. */ protected static final HashMap BuiltinFonts14 = new LinkedHashMap(); /** Forces the output of the width array. Only matters for the 14 * built-in fonts. */ protected boolean forceWidthsOutput = false; /** Convertschardirectly tobyte* 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; private boolean fastWinansi = false; /** * Custom encodings use this map to key the Unicode character * to the single byte code. */ protected IntHashtable specialMap; 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) */ StreamFont(final byte contents[], final int lengths[], final int compressionLevel) throws DocumentException { try { this.bytes = contents; put(PdfName.LENGTH, new PdfNumber(this.bytes.length)); for (int k = 0; k < lengths.length; ++k) { put(new PdfName("Length" + (k + 1)), new PdfNumber(lengths[k])); } flateCompress(compressionLevel); } catch (final 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) */ StreamFont(final byte contents[], final String subType, final int compressionLevel) throws DocumentException { try { this.bytes = contents; put(PdfName.LENGTH, new PdfNumber(this.bytes.length)); if (subType != null) { put(PdfName.SUBTYPE, new PdfName(subType)); } flateCompress(compressionLevel); } catch (final Exception e) { throw new DocumentException(e); } } } /** *Creates new BaseFont */ protected BaseFont() { } /** * 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(final String name, final String encoding, final 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 may or may not be cached depending on the flag
cached. * If thebytearrays 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(final String name, final String encoding, final boolean embedded, final boolean cached, final byte ttfAfm[], final 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 thebytearrays 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(final String name, final String encoding, final boolean embedded, final boolean cached, final byte ttfAfm[], final byte pfb[], final boolean noThrow) throws DocumentException, IOException { return createFont(name, encoding, embedded, cached, ttfAfm, pfb, false, 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 thebytearrays 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 */ private static BaseFont createFont(final String name, String encoding, boolean embedded, final boolean cached, final byte ttfAfm[], final byte pfb[], final boolean noThrow, final boolean forceRead) throws DocumentException, IOException { final String nameBase = getBaseName(name); encoding = normalizeEncoding(encoding); final boolean isBuiltinFonts14 = BuiltinFonts14.containsKey(name); final 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; final String key = name + "\n" + encoding + "\n" + embedded; if (cached) { synchronized (fontCache) { fontFound = (BaseFont)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("Font '" + name + "' with '" + encoding + "' is not recognized."); } if (cached) { synchronized (fontCache) { fontFound = (BaseFont)fontCache.get(key); if (fontFound != null) { return fontFound; } fontCache.put(key, fontBuilt); } } return fontBuilt; } /** * 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(final 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 */ private static String normalizeEncoding(final String enc) { if (enc.equals("winansi") || enc.equals("")) { return CP1252; } else if (enc.equals("macroman")) { return MACROMAN; } else { return enc; } } /** * Creates thewidthsand thedifferencesarrays */ protected void createEncoding() { if (this.encoding.startsWith("#")) { this.specialMap = new IntHashtable(); final StringTokenizer tok = new StringTokenizer(this.encoding.substring(1), " ,\t\n\r\f"); if (tok.nextToken().equals("full")) { while (tok.hasMoreTokens()) { final String order = tok.nextToken(); final String name = tok.nextToken(); final char uni = (char)Integer.parseInt(tok.nextToken(), 16); int orderK; if (order.startsWith("'")) { orderK = order.charAt(1); } else { orderK = Integer.parseInt(order); } orderK %= 256; this.specialMap.put(uni, orderK); this.differences[orderK] = name; this.unicodeDifferences[orderK] = uni; this.widths[orderK] = getRawWidth(uni, name); this.charBBoxes[orderK] = getRawCharBBox(uni, name); } } else { int k = 0; if (tok.hasMoreTokens()) { k = Integer.parseInt(tok.nextToken()); } while (tok.hasMoreTokens() && k < 256) { final String hex = tok.nextToken(); final int uni = Integer.parseInt(hex, 16) % 0x10000; final String name = GlyphList.unicodeToName(uni); if (name != null) { this.specialMap.put(uni, k); this.differences[k] = name; this.unicodeDifferences[k] = (char)uni; this.widths[k] = getRawWidth(uni, name); this.charBBoxes[k] = getRawCharBBox(uni, name); ++k; } } } for (int k = 0; k < 256; ++k) { if (this.differences[k] == null) { this.differences[k] = notdef; } } } else if (this.fontSpecific) { for (int k = 0; k < 256; ++k) { this.widths[k] = getRawWidth(k, null); this.charBBoxes[k] = getRawCharBBox(k, null); } } else { String s; String name; char c; final byte b[] = new byte[1]; for (int k = 0; k < 256; ++k) { b[0] = (byte)k; s = PdfEncodings.convertToString(b, this.encoding); if (s.length() > 0) { c = s.charAt(0); } else { c = '?'; } name = GlyphList.unicodeToName(c); if (name == null) { name = notdef; } this.differences[k] = name; this.unicodeDifferences[k] = c; this.widths[k] = getRawWidth(c, name); this.charBBoxes[k] = getRawCharBBox(c, name); } } } /** * Gets the width from the font according to the Unicode charc* or thename. If thenameis 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 * @returntrueif the kerning was applied,falseotherwise */ public abstract boolean setKerning(int char1, int char2, int kern); /** * Gets the width of acharin normalized 1000 units. * @param char1 the unicodecharto get the width of * @return the width in normalized 1000 units */ public int getWidth(final int char1) { if (this.fastWinansi) { if (char1 < 128 || char1 >= 160 && char1 <= 255) { return this.widths[char1]; } else { return this.widths[PdfEncodings.winansi.get(char1)]; } } else { int total = 0; final byte mbytes[] = convertToBytes((char)char1); for (final byte mbyte : mbytes) { total += this.widths[0xff & mbyte]; } return total; } } /** * Gets the width of aStringin normalized 1000 units. * @param text theStringto get the width of * @return the width in normalized 1000 units */ public int getWidth(final String text) { int total = 0; if (this.fastWinansi) { final int len = text.length(); for (int k = 0; k < len; ++k) { final char char1 = text.charAt(k); if (char1 < 128 || char1 >= 160 && char1 <= 255) { total += this.widths[char1]; } else { total += this.widths[PdfEncodings.winansi.get(char1)]; } } return total; } else { final byte mbytes[] = convertToBytes(text); for (final byte mbyte : mbytes) { total += this.widths[0xff & mbyte]; } } return total; } /** * Gets the ascent of aStringin 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 theStringto get the ascent of * @return the ascent in normalized 1000 units */ private int getAscent(final String text) { int max = 0; final char chars[] = text.toCharArray(); for (final char c : chars) { final int bbox[] = getCharBBox(c); if (bbox != null && bbox[3] > max) { max = bbox[3]; } } return max; } /** * Gets the width of aStringin points taking kerning * into account. * @param text theStringto get the width of * @param fontSize the font size * @return the width in points */ float getWidthPointKerned(final String text, final float fontSize) { final float size = getWidth(text) * 0.001f * fontSize; if (!hasKernPairs()) { return size; } final int len = text.length() - 1; int kern = 0; final 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 aStringin points. * @param text theStringto get the width of * @param fontSize the font size * @return the width in points */ public float getWidthPoint(final String text, final float fontSize) { return getWidth(text) * 0.001f * fontSize; } /** * Gets the width of acharin points. * @param char1 thecharto get the width of * @param fontSize the font size * @return the width in points */ float getWidthPoint(final int char1, final float fontSize) { return getWidth(char1) * 0.001f * fontSize; } /** * Converts aStringto aStringto be converted * @return an array ofbyterepresenting the conversion according to the font's encoding */ byte[] convertToBytes(final String text) { if (this.directTextToByte) { return PdfEncodings.convertToBytes(text, null); } if (this.specialMap != null) { final byte[] b = new byte[text.length()]; int ptr = 0; final int length = text.length(); for (int k = 0; k < length; ++k) { final char c = text.charAt(k); if (this.specialMap.containsKey(c)) { b[ptr++] = (byte)this.specialMap.get(c); } } if (ptr < length) { final byte[] b2 = new byte[ptr]; System.arraycopy(b, 0, b2, 0, ptr); return b2; } else { return b; } } return PdfEncodings.convertToBytes(text, this.encoding); } /** * Converts acharto a byte array according * to the font's encoding. * @param char1 thecharto be converted * @return an array ofbyterepresenting the conversion according to the font's encoding */ byte[] convertToBytes(final int char1) { if (this.directTextToByte) { return PdfEncodings.convertToBytes((char)char1, null); } if (this.specialMap != null) { if (this.specialMap.containsKey(char1)) { return new byte[]{(byte)this.specialMap.get(char1)}; } else { return new byte[0]; } } return PdfEncodings.convertToBytes((char)char1, this.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 convertStringintobyte[]. * @return the encoding name */ public String getEncoding() { return this.encoding; } /** Gets the font parameter identified bykey. Valid values * forkeyareASCENT,AWT_ASCENT,CAPHEIGHT, *DESCENT,AWT_DESCENT, *ITALICANGLE,BBOXLLX,BBOXLLY,BBOXURX* andBBOXURY. * @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); /** 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 this.fontType; } /** Gets the embedded flag. * @returntrueif the font is embedded. */ public boolean isEmbedded() { return this.embedded; } /** Gets the symbolic flag of the font. * @returntrueif the font is symbolic */ public boolean isFontSpecific() { return this.fontSpecific; } /** Creates a unique subset prefix to be added to the font name when the font is embedded and subset. * @return the subset prefix */ static String createSubsetPrefix() { String s = ""; for (int k = 0; k < 6; ++k) { s += (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(final int index) { return this.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); /** 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 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(final String name, final String encoding, final byte ttfAfm[]) throws DocumentException, IOException { final 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 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(final String ttcFile) throws DocumentException, IOException { return new EnumerateTTC(ttcFile).getNames(); } /** Gets the font width array. * @return the font width array */ public int[] getWidths() { return this.widths; } /** Gets the array with the names of the characters. * @return the array with the names of the characters */ public String[] getDifferences() { return this.differences; } /** Gets the array with the unicode characters. * @return the array with the unicode characters */ public char[] getUnicodeDifferences() { return this.unicodeDifferences; } /** Gets the state of the property. * @return value of property forceWidthsOutput */ public boolean isForceWidthsOutput() { return this.forceWidthsOutput; } /** Set totrueto force the generation of the * widths array. * @param forceWidthsOutputtrueto force the generation of the * widths array */ public void setForceWidthsOutput(final boolean forceWidthsOutput) { this.forceWidthsOutput = forceWidthsOutput; } /** Gets the direct conversion ofchartobyte. * @return value of property directTextToByte. * @see #setDirectTextToByte(boolean directTextToByte) */ public boolean isDirectTextToByte() { return this.directTextToByte; } /** Sets the conversion ofchardirectly tobyte* 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(final boolean directTextToByte) { this.directTextToByte = directTextToByte; } /** Indicates if all the glyphs and widths for that particular * encoding should be included in the document. * @returnfalseto include all the glyphs and widths. */ public boolean isSubset() { return this.subset; } /** Indicates if all the glyphs and widths for that particular * encoding should be included in the document. When set totrue* only the glyphs used will be included in the font. When set tofalse* and #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(final boolean subset) { this.subset = subset; } /** Gets the font resources. * @param key the full name of the resource * @return theInputStreamto get the resource or *nullif not found */ public static InputStream getResourceStream(final String key) { return getResourceStream(key, null); } /** Gets the font resources. * @param key the full name of the resource * @param loader the ClassLoader to load the resource or null to try the ones available * @return theInputStreamto get the resource or *nullif not found */ static InputStream getResourceStream(String key, final ClassLoader loader) { if (key.startsWith("/")) { key = key.substring(1); } InputStream is = null; if (loader != null) { is = loader.getResourceAsStream(key); if (is != null) { return is; } } // Try to use Context Class Loader to load the properties file. try { final ClassLoader contextClassLoader = Thread.currentThread().getContextClassLoader(); if (contextClassLoader != null) { is = contextClassLoader.getResourceAsStream(key); } } catch (final Throwable e) {} if (is == null) { is = BaseFont.class.getResourceAsStream("/" + key); } if (is == null) { is = ClassLoader.getSystemResourceAsStream(key); } return is; } /** 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(final 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(final int c) { return c; } /** Checks if the font has any kerning pairs. * @returntrueif the font has any kerning pairs */ public abstract boolean hasKernPairs(); /** * Checks if a character exists in this font. * @param c the character to check * @returntrueif the character has a glyph, *falseotherwise */ public boolean charExists(final int c) { final 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 * @returntrueif the advance was set, *falseotherwise */ public boolean setCharAdvance(final int c, final int advance) { final byte b[] = convertToBytes(c); if (b.length == 0) { return false; } this.widths[0xff & b[0]] = advance; return true; } private static void addFont(final PRIndirectReference fontRef, final IntHashtable hits, final ArrayList fonts) { final PdfObject obj = PdfReader.getPdfObject(fontRef); if (obj == null || !obj.isDictionary()) { return; } final PdfDictionary font = (PdfDictionary)obj; final PdfName subtype = font.getAsName(PdfName.SUBTYPE); if (!PdfName.TYPE1.equals(subtype) && !PdfName.TRUETYPE.equals(subtype)) { return; } final PdfName name = font.getAsName(PdfName.BASEFONT); fonts.add(new Object[]{PdfName.decodeName(name.toString()), fontRef}); hits.put(fontRef.getNumber(), 1); } private static void recourseFonts(final PdfDictionary page, final IntHashtable hits, final ArrayList fonts, int level) { ++level; if (level > 50) { return; } final PdfDictionary resources = page.getAsDict(PdfName.RESOURCES); if (resources == null) { return; } final PdfDictionary font = resources.getAsDict(PdfName.FONT); if (font != null) { for (final Object element : font.getKeys()) { final PdfObject ft = font.get((PdfName)element); if (ft == null || !ft.isIndirect()) { continue; } final int hit = ((PRIndirectReference)ft).getNumber(); if (hits.containsKey(hit)) { continue; } addFont((PRIndirectReference)ft, hits, fonts); } } final PdfDictionary xobj = resources.getAsDict(PdfName.XOBJECT); if (xobj != null) { for (final Object element : xobj.getKeys()) { recourseFonts(xobj.getAsDict((PdfName)element), hits, fonts, level); } } } /** * Gets the smallest box enclosing the character contours. It will return *nullif 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(final int c) { final byte b[] = convertToBytes(c); if (b.length == 0) { return null; } else { return this.charBBoxes[b[0] & 0xff]; } } protected abstract int[] getRawCharBBox(int c, String name); /** * 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 this.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(final int compressionLevel) { if (compressionLevel < PdfStream.NO_COMPRESSION || compressionLevel > PdfStream.BEST_COMPRESSION) { this.compressionLevel = PdfStream.DEFAULT_COMPRESSION; } else { this.compressionLevel = compressionLevel; } } }