Created
March 11, 2014 12:23
-
-
Save ksob/9484568 to your computer and use it in GitHub Desktop.
BaseFont.java (iText 2.0.8)
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| /* | |
| * $Id: BaseFont.java 3061 2007-12-03 20:08:33Z xlv $ | |
| * $Name$ | |
| * | |
| * 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.lowagie.text.pdf; | |
| import java.io.IOException; | |
| import java.io.InputStream; | |
| import java.util.ArrayList; | |
| import java.util.HashMap; | |
| import java.util.Iterator; | |
| import java.util.StringTokenizer; | |
| import com.lowagie.text.DocumentException; | |
| /** | |
| * Base class for the several font types supported | |
| * | |
| * @author Paulo Soares (psoares@consiste.pt) | |
| */ | |
| 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; | |
| /** java.awt.Font property */ | |
| public static final int AWT_ASCENT = 9; | |
| /** java.awt.Font property */ | |
| public static final int AWT_DESCENT = 10; | |
| /** java.awt.Font property */ | |
| public static final int AWT_LEADING = 11; | |
| /** java.awt.Font property */ | |
| public static final int AWT_MAXADVANCE = 12; | |
| /** | |
| * The undeline 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 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}; | |
| /** 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/lowagie/text/pdf/fonts/"; | |
| /** The fake CID code that represents a newline. */ | |
| public static final char CID_NEWLINE = '\u7fff'; | |
| protected ArrayList subsetRanges; | |
| /** The font type. | |
| */ | |
| int fontType; | |
| /** a not defined character in a custom PDF encoding */ | |
| public static final String notdef = ".notdef"; | |
| /** table of characters widths for this encoding */ | |
| protected int widths[] = new int[256]; | |
| /** encoding names */ | |
| protected String differences[] = new String[256]; | |
| /** same as differences but with the unicode codes */ | |
| protected char unicodeDifferences[] = new char[256]; | |
| protected int charBBoxes[][] = new int[256][]; | |
| /** encoding used with this font */ | |
| protected String encoding; | |
| /** true if the font is to be embedded in the PDF */ | |
| protected boolean embedded; | |
| /** | |
| * true if the font must use it's 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 HashMap fontCache = new HashMap(); | |
| /** list of the 14 built in fonts. */ | |
| protected static final HashMap BuiltinFonts14 = new HashMap(); | |
| /** Forces the output of the width array. Only matters for the 14 | |
| * built-in fonts. | |
| */ | |
| protected boolean forceWidthsOutput = false; | |
| /** Converts <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; | |
| 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 | |
| * @throws DocumentException error in the stream compression | |
| */ | |
| public StreamFont(byte contents[], int lengths[]) 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(); | |
| } | |
| 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. | |
| * @throws DocumentException | |
| */ | |
| public StreamFont(byte contents[], String subType) throws DocumentException { | |
| try { | |
| bytes = contents; | |
| put(PdfName.LENGTH, new PdfNumber(bytes.length)); | |
| if (subType != null) | |
| put(PdfName.SUBTYPE, new PdfName(subType)); | |
| flateCompress(); | |
| } | |
| catch (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". | |
| * <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 it's 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); | |
| } | |
| /** 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 it's 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 | |
| */ | |
| 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 it's 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 | |
| */ | |
| public static BaseFont createFont(String name, String encoding, boolean embedded, boolean cached, byte ttfAfm[], byte pfb[], boolean noThrow) throws DocumentException, IOException { | |
| String nameBase = getBaseName(name); | |
| encoding = "ISO-8859-2"; //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) { | |
| 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); | |
| 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); | |
| else { | |
| fontBuilt = new TrueTypeFont(name, encoding, embedded, ttfAfm); | |
| 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; | |
| } | |
| /** | |
| * 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); | |
| } | |
| /** | |
| * 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 = (int)order.charAt(1); | |
| else | |
| orderK = Integer.parseInt(order); | |
| orderK %= 256; | |
| specialMap.put((int)uni, orderK); | |
| differences[orderK] = name; | |
| unicodeDifferences[orderK] = uni; | |
| widths[orderK] = getRawWidth((int)uni, name); | |
| charBBoxes[orderK] = getRawCharBBox((int)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((int)c); | |
| if (name == null) | |
| name = notdef; | |
| differences[k] = name; | |
| unicodeDifferences[k] = c; | |
| widths[k] = getRawWidth((int)c, name); | |
| charBBoxes[k] = getRawCharBBox((int)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(char char1, char 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(char char1, char 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(char 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(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 witdth 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 dexcent 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 dexcent in points | |
| */ | |
| public float getDescentPoint(String text, float fontSize) | |
| { | |
| return (float)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 (float)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 witdth of | |
| * @param fontSize the font size | |
| * @return the width in points | |
| */ | |
| public float getWidthPointKerned(String text, float fontSize) { | |
| float size = (float)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 witdth of | |
| * @param fontSize the font size | |
| * @return the width in points | |
| */ | |
| public float getWidthPoint(String text, float fontSize) { | |
| return (float)getWidth(text) * 0.001f * fontSize; | |
| } | |
| /** | |
| * Gets the width of a <CODE>char</CODE> in points. | |
| * @param char1 the <CODE>char</CODE> to get the witdth of | |
| * @param fontSize the font size | |
| * @return the width in points | |
| */ | |
| public float getWidthPoint(char 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 | |
| */ | |
| 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((int)c)) | |
| b[ptr++] = (byte)specialMap.get((int)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(char char1) { | |
| if (directTextToByte) | |
| return PdfEncodings.convertToBytes(char1, null); | |
| if (specialMap != null) { | |
| if (specialMap.containsKey((int)char1)) | |
| return new byte[]{(byte)specialMap.get((int)char1)}; | |
| else | |
| return new byte[0]; | |
| } | |
| return PdfEncodings.convertToBytes(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; | |
| /** 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); | |
| /** 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() { | |
| 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(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); | |
| /** 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); | |
| 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); | |
| 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); | |
| 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 font resources. | |
| * @param key the full name of the resource | |
| * @return the <CODE>InputStream</CODE> to get the resource or | |
| * <CODE>null</CODE> if not found | |
| */ | |
| public static InputStream getResourceStream(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 the <CODE>InputStream</CODE> to get the resource or | |
| * <CODE>null</CODE> if not found | |
| */ | |
| public static InputStream getResourceStream(String key, 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 { | |
| java.lang.reflect.Method getCCL = | |
| Thread.class.getMethod("getContextClassLoader", new Class[0]); | |
| if (getCCL != null) { | |
| ClassLoader contextClassLoader = | |
| (ClassLoader)getCCL.invoke(Thread.currentThread(), | |
| new Object[0]); | |
| if (contextClassLoader != null) | |
| is = contextClassLoader.getResourceAsStream(key); | |
| } | |
| } catch (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 char getUnicodeEquivalent(char 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 char getCidCode(char 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(char 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(char c, int advance) { | |
| byte b[] = convertToBytes(c); | |
| if (b.length == 0) | |
| return false; | |
| widths[0xff & b[0]] = advance; | |
| return true; | |
| } | |
| private static void addFont(PRIndirectReference fontRef, IntHashtable hits, ArrayList fonts) { | |
| PdfObject obj = PdfReader.getPdfObject(fontRef); | |
| if (obj == null || !obj.isDictionary()) | |
| return; | |
| PdfDictionary font = (PdfDictionary)obj; | |
| PdfName subtype = (PdfName)PdfReader.getPdfObject(font.get(PdfName.SUBTYPE)); | |
| if (!PdfName.TYPE1.equals(subtype) && !PdfName.TRUETYPE.equals(subtype)) | |
| return; | |
| PdfName name = (PdfName)PdfReader.getPdfObject(font.get(PdfName.BASEFONT)); | |
| fonts.add(new Object[]{PdfName.decodeName(name.toString()), fontRef}); | |
| hits.put(fontRef.getNumber(), 1); | |
| } | |
| private static void recourseFonts(PdfDictionary page, IntHashtable hits, ArrayList fonts, int level) { | |
| ++level; | |
| if (level > 50) // in case we have an endless loop | |
| return; | |
| PdfDictionary resources = (PdfDictionary)PdfReader.getPdfObject(page.get(PdfName.RESOURCES)); | |
| if (resources == null) | |
| return; | |
| PdfDictionary font = (PdfDictionary)PdfReader.getPdfObject(resources.get(PdfName.FONT)); | |
| if (font != null) { | |
| for (Iterator it = font.getKeys().iterator(); it.hasNext();) { | |
| PdfObject ft = font.get((PdfName)it.next()); | |
| if (ft == null || !ft.isIndirect()) | |
| continue; | |
| int hit = ((PRIndirectReference)ft).getNumber(); | |
| if (hits.containsKey(hit)) | |
| continue; | |
| addFont((PRIndirectReference)ft, hits, fonts); | |
| } | |
| } | |
| PdfDictionary xobj = (PdfDictionary)PdfReader.getPdfObject(resources.get(PdfName.XOBJECT)); | |
| if (xobj != null) { | |
| for (Iterator it = xobj.getKeys().iterator(); it.hasNext();) { | |
| recourseFonts((PdfDictionary)PdfReader.getPdfObject(xobj.get((PdfName)it.next())), hits, fonts, level); | |
| } | |
| } | |
| } | |
| /** | |
| * 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 getDocumentFonts(PdfReader reader) { | |
| IntHashtable hits = new IntHashtable(); | |
| ArrayList fonts = new ArrayList(); | |
| int npages = reader.getNumberOfPages(); | |
| for (int k = 1; k <= npages; ++k) | |
| recourseFonts(reader.getPageN(k), hits, fonts, 1); | |
| 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 getDocumentFonts(PdfReader reader, int page) { | |
| IntHashtable hits = new IntHashtable(); | |
| ArrayList fonts = new ArrayList(); | |
| recourseFonts(reader.getPageN(page), hits, fonts, 1); | |
| return fonts; | |
| } | |
| /** | |
| * 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(char c) { | |
| byte b[] = convertToBytes(c); | |
| if (b.length == 0) | |
| return null; | |
| else | |
| return charBBoxes[b[0] & 0xff]; | |
| } | |
| 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(); | |
| subsetRanges.add(range); | |
| } | |
| } |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment