| /* |
| * Licensed to the Apache Software Foundation (ASF) under one or more |
| * contributor license agreements. See the NOTICE file distributed with |
| * this work for additional information regarding copyright ownership. |
| * The ASF licenses this file to You under the Apache License, Version 2.0 |
| * (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.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| /* $Id$ */ |
| |
| package org.apache.fop.render.pdf.pdfbox; |
| |
| import java.awt.Rectangle; |
| import java.awt.geom.AffineTransform; |
| import java.io.ByteArrayInputStream; |
| import java.io.IOException; |
| import java.io.InputStream; |
| import java.io.OutputStream; |
| import java.text.DecimalFormat; |
| import java.util.ArrayList; |
| import java.util.Arrays; |
| import java.util.Collection; |
| import java.util.Collections; |
| import java.util.HashMap; |
| import java.util.HashSet; |
| import java.util.Iterator; |
| import java.util.LinkedHashMap; |
| import java.util.List; |
| import java.util.Locale; |
| import java.util.Map; |
| import java.util.Set; |
| import java.util.TreeMap; |
| import java.util.regex.Pattern; |
| |
| import org.apache.commons.io.IOUtils; |
| import org.apache.commons.logging.Log; |
| import org.apache.commons.logging.LogFactory; |
| import org.apache.fontbox.cff.CFFFont; |
| import org.apache.fontbox.cff.CFFFontROS; |
| import org.apache.fontbox.cff.charset.CFFCharset; |
| import org.apache.fontbox.cff.encoding.CFFEncoding; |
| import org.apache.fontbox.cmap.CMap; |
| import org.apache.fontbox.ttf.CMAPEncodingEntry; |
| import org.apache.fontbox.ttf.GlyphData; |
| import org.apache.fontbox.ttf.MaximumProfileTable; |
| import org.apache.fontbox.ttf.TrueTypeFont; |
| import org.apache.pdfbox.cos.COSArray; |
| import org.apache.pdfbox.cos.COSBase; |
| import org.apache.pdfbox.cos.COSBoolean; |
| import org.apache.pdfbox.cos.COSDictionary; |
| import org.apache.pdfbox.cos.COSFloat; |
| import org.apache.pdfbox.cos.COSInteger; |
| import org.apache.pdfbox.cos.COSName; |
| import org.apache.pdfbox.cos.COSNull; |
| import org.apache.pdfbox.cos.COSNumber; |
| import org.apache.pdfbox.cos.COSObject; |
| import org.apache.pdfbox.cos.COSStream; |
| import org.apache.pdfbox.cos.COSString; |
| import org.apache.pdfbox.encoding.DictionaryEncoding; |
| import org.apache.pdfbox.encoding.Encoding; |
| import org.apache.pdfbox.encoding.EncodingManager; |
| import org.apache.pdfbox.pdfparser.PDFStreamParser; |
| import org.apache.pdfbox.pdmodel.PDDocument; |
| import org.apache.pdfbox.pdmodel.PDDocumentCatalog; |
| import org.apache.pdfbox.pdmodel.PDPage; |
| import org.apache.pdfbox.pdmodel.PDPageNode; |
| import org.apache.pdfbox.pdmodel.PDResources; |
| import org.apache.pdfbox.pdmodel.common.COSObjectable; |
| import org.apache.pdfbox.pdmodel.common.COSStreamArray; |
| import org.apache.pdfbox.pdmodel.common.PDRectangle; |
| import org.apache.pdfbox.pdmodel.common.PDStream; |
| import org.apache.pdfbox.pdmodel.font.PDCIDFont; |
| import org.apache.pdfbox.pdmodel.font.PDCIDFontType0Font; |
| import org.apache.pdfbox.pdmodel.font.PDCIDFontType2Font; |
| import org.apache.pdfbox.pdmodel.font.PDFont; |
| import org.apache.pdfbox.pdmodel.font.PDFontDescriptorDictionary; |
| import org.apache.pdfbox.pdmodel.font.PDFontFactory; |
| import org.apache.pdfbox.pdmodel.font.PDSimpleFont; |
| import org.apache.pdfbox.pdmodel.font.PDTrueTypeFont; |
| import org.apache.pdfbox.pdmodel.font.PDType0Font; |
| import org.apache.pdfbox.pdmodel.font.PDType1Font; |
| import org.apache.pdfbox.pdmodel.interactive.annotation.PDAnnotation; |
| import org.apache.pdfbox.pdmodel.interactive.form.PDAcroForm; |
| import org.apache.pdfbox.util.operator.PDFOperator; |
| |
| import org.apache.fop.events.EventBroadcaster; |
| import org.apache.fop.fonts.CIDFontType; |
| import org.apache.fop.fonts.CustomFont; |
| import org.apache.fop.fonts.EmbeddingMode; |
| import org.apache.fop.fonts.FontInfo; |
| import org.apache.fop.fonts.FontType; |
| import org.apache.fop.fonts.MultiByteFont; |
| import org.apache.fop.fonts.SingleByteEncoding; |
| import org.apache.fop.fonts.SingleByteFont; |
| import org.apache.fop.fonts.Typeface; |
| import org.apache.fop.fonts.truetype.FontFileReader; |
| import org.apache.fop.fonts.truetype.OTFSubSetFile; |
| import org.apache.fop.pdf.PDFArray; |
| import org.apache.fop.pdf.PDFDictionary; |
| import org.apache.fop.pdf.PDFDocument; |
| import org.apache.fop.pdf.PDFName; |
| import org.apache.fop.pdf.PDFNumber; |
| import org.apache.fop.pdf.PDFObject; |
| import org.apache.fop.pdf.PDFPage; |
| import org.apache.fop.pdf.PDFRoot; |
| import org.apache.fop.pdf.PDFStream; |
| import org.apache.fop.pdf.PDFText; |
| import org.apache.fop.pdf.RefPDFFont; |
| import org.apache.fop.util.CharUtilities; |
| |
| /** |
| * This class provides an adapter for transferring content from a PDFBox PDDocument to |
| * FOP's PDFDocument. It is used to parse PDF using PDFBox and write content using |
| * FOP's PDF library. |
| */ |
| public class PDFBoxAdapter { |
| |
| /** logging instance */ |
| protected static final Log log = LogFactory.getLog(PDFBoxAdapter.class); |
| |
| private static final Set FILTER_FILTER = new java.util.HashSet( |
| Arrays.asList(new String[] {"Filter", "DecodeParms"})); |
| private static final Pattern SUBSET_PATTERN = Pattern.compile("[A-Z][A-Z][A-Z][A-Z][A-Z][A-Z]\\+.+"); |
| |
| private final PDFPage targetPage; |
| private final PDFDocument pdfDoc; |
| |
| private final Map clonedVersion; |
| |
| private final Map<COSDictionary, PDSimpleFont> fontMap = new HashMap<COSDictionary, PDSimpleFont>(); |
| private Map<COSName, String> newXObj = new HashMap<COSName, String>(); |
| private Collection<String> parentFonts; |
| |
| /** |
| * Creates a new PDFBoxAdapter. |
| * @param targetPage The target FOP PDF page object |
| * @param objectCache the object cache for reusing objects shared by multiple pages. |
| */ |
| public PDFBoxAdapter(PDFPage targetPage, Map objectCache) { |
| this.targetPage = targetPage; |
| this.pdfDoc = this.targetPage.getDocument(); |
| this.clonedVersion = objectCache; |
| } |
| |
| private Object cloneForNewDocument(Object base) throws IOException { |
| return cloneForNewDocument(base, base); |
| } |
| |
| private Object cloneForNewDocument(Object base, Object keyBase) throws IOException { |
| return cloneForNewDocument(base, keyBase, Collections.EMPTY_LIST); |
| } |
| |
| private Object cloneForNewDocument(Object base, Object keyBase, Collection exclude) throws IOException { |
| if (base == null) { |
| return null; |
| } |
| Object cached = getCachedClone(keyBase); |
| if (cached != null) { |
| // we are done, it has already been converted. |
| return cached; |
| } else if (base instanceof List) { |
| PDFArray array = new PDFArray(); |
| cacheClonedObject(keyBase, array); |
| List list = (List)base; |
| for (Object o : list) { |
| array.add(cloneForNewDocument(o, o, exclude)); |
| } |
| return array; |
| } else if (base instanceof COSObjectable && !(base instanceof COSBase)) { |
| Object o = ((COSObjectable)base).getCOSObject(); |
| Object retval = cloneForNewDocument(o, o, exclude); |
| return cacheClonedObject(keyBase, retval); |
| } else if (base instanceof COSObject) { |
| return readCOSObject((COSObject) base, exclude); |
| } else if (base instanceof COSArray) { |
| PDFArray newArray = new PDFArray(); |
| cacheClonedObject(keyBase, newArray); |
| COSArray array = (COSArray)base; |
| for (int i = 0; i < array.size(); i++) { |
| newArray.add(cloneForNewDocument(array.get(i), array.get(i), exclude)); |
| } |
| return newArray; |
| } else if (base instanceof COSStreamArray) { |
| COSStreamArray array = (COSStreamArray)base; |
| PDFArray newArray = new PDFArray(); |
| cacheClonedObject(keyBase, newArray); |
| for (int i = 0, c = array.getStreamCount(); i < c; i++) { |
| newArray.add(cloneForNewDocument(array.get(i))); |
| } |
| return newArray; |
| } else if (base instanceof COSStream) { |
| return readCOSStream((COSStream) base, keyBase); |
| } else if (base instanceof COSDictionary) { |
| return readCOSDictionary((COSDictionary) base, keyBase, exclude); |
| } else if (base instanceof COSName) { |
| PDFName newName = new PDFName(((COSName)base).getName()); |
| return cacheClonedObject(keyBase, newName); |
| } else if (base instanceof COSInteger) { |
| PDFNumber number = new PDFNumber(); |
| number.setNumber(((COSInteger)base).longValue()); |
| return cacheClonedObject(keyBase, number); |
| } else if (base instanceof COSFloat) { |
| PDFNumber number = new PDFNumber(); |
| number.setNumber(((COSFloat)base).floatValue()); |
| return cacheClonedObject(keyBase, number); |
| } else if (base instanceof COSBoolean) { |
| //TODO Do we need a PDFBoolean here? |
| Boolean retval = ((COSBoolean)base).getValueAsObject(); |
| if (keyBase instanceof COSObject) { |
| return cacheClonedObject(keyBase, new PDFBoolean(retval)); |
| } else { |
| return cacheClonedObject(keyBase, retval); |
| } |
| } else if (base instanceof COSString) { |
| return readCOSString((COSString) base, keyBase); |
| } else if (base instanceof COSNull) { |
| return cacheClonedObject(keyBase, null); |
| } else { |
| throw new UnsupportedOperationException("NYI: " + base.getClass().getName()); |
| } |
| } |
| |
| private PDFDictionary readCOSDictionary(COSDictionary dic, Object keyBase, Collection exclude) throws IOException { |
| PDFDictionary newDict = new PDFDictionary(); |
| cacheClonedObject(keyBase, newDict); |
| for (Map.Entry<COSName, COSBase> e : dic.entrySet()) { |
| if (!exclude.contains(e.getKey())) { |
| newDict.put(e.getKey().getName(), cloneForNewDocument(e.getValue(), e.getValue(), exclude)); |
| } |
| } |
| return newDict; |
| } |
| |
| private Object readCOSObject(COSObject object, Collection exclude) throws IOException { |
| if (log.isTraceEnabled()) { |
| log.trace("Cloning indirect object: " |
| + object.getObjectNumber().longValue() |
| + " " + object.getGenerationNumber().longValue()); |
| } |
| Object obj = cloneForNewDocument(object.getObject(), object, exclude); |
| if (obj instanceof PDFObject) { |
| PDFObject pdfobj = (PDFObject)obj; |
| //pdfDoc.registerObject(pdfobj); |
| if (!pdfobj.hasObjectNumber()) { |
| throw new IllegalStateException("PDF object was not registered!"); |
| } |
| if (log.isTraceEnabled()) { |
| log.trace("Object registered: " |
| + pdfobj.getObjectNumber() |
| + " " + pdfobj.getGeneration() |
| + " for COSObject: " |
| + object.getObjectNumber().longValue() |
| + " " + object.getGenerationNumber().longValue()); |
| } |
| } |
| return obj; |
| } |
| |
| private Object readCOSString(COSString string, Object keyBase) { |
| //retval = ((COSString)base).getString(); //this is unsafe for binary content |
| byte[] bytes = string.getBytes(); |
| //Be on the safe side and use the byte array to avoid encoding problems |
| //as PDFBox doesn't indicate whether the string is just |
| //a string (PDF 1.4, 3.2.3) or a text string (PDF 1.4, 3.8.1). |
| if (keyBase instanceof COSObject) { |
| return cacheClonedObject(keyBase, new PDFString(bytes)); |
| } else { |
| if (PDFString.isUSASCII(bytes)) { |
| return cacheClonedObject(keyBase, string.getString()); |
| } else { |
| return cacheClonedObject(keyBase, bytes); |
| } |
| } |
| } |
| |
| private Object readCOSStream(COSStream originalStream, Object keyBase) throws IOException { |
| InputStream in; |
| Set filter; |
| if (pdfDoc.isEncryptionActive()) { |
| in = originalStream.getUnfilteredStream(); |
| filter = FILTER_FILTER; |
| } else { |
| //transfer encoded data (don't reencode) |
| in = originalStream.getFilteredStream(); |
| filter = Collections.EMPTY_SET; |
| } |
| PDFStream stream = new PDFStream(); |
| OutputStream out = stream.getBufferOutputStream(); |
| IOUtils.copyLarge(in, out); |
| transferDict(originalStream, stream, filter); |
| return cacheClonedObject(keyBase, stream); |
| } |
| |
| private Object getCachedClone(Object base) { |
| return clonedVersion.get(getBaseKey(base)); |
| } |
| |
| private Object cacheClonedObject(Object base, Object cloned) { |
| Object key = getBaseKey(base); |
| if (key == null) { |
| return cloned; |
| } |
| PDFObject pdfobj = (PDFObject) cloned; |
| if (!pdfobj.hasObjectNumber()) { |
| pdfDoc.registerObject(pdfobj); |
| if (log.isTraceEnabled()) { |
| log.trace(key + ": " + pdfobj.getClass().getName() + " registered as " |
| + pdfobj.getObjectNumber() + " " + pdfobj.getGeneration()); |
| } |
| } |
| clonedVersion.put(key, cloned); |
| return cloned; |
| } |
| |
| private Object getBaseKey(Object base) { |
| if (base instanceof COSObject) { |
| COSObject obj = (COSObject)base; |
| return obj.getObjectNumber().intValue() + " " + obj.getGenerationNumber().intValue(); |
| } else { |
| return null; |
| } |
| } |
| |
| private void transferDict(COSDictionary orgDict, PDFStream targetDict, |
| Set filter) throws IOException { |
| transferDict(orgDict, targetDict, filter, false); |
| } |
| |
| private void transferDict(COSDictionary orgDict, PDFStream targetDict, |
| Set filter, boolean inclusive) throws IOException { |
| Set<COSName> keys = orgDict.keySet(); |
| for (COSName key : keys) { |
| if (inclusive && !filter.contains(key.getName())) { |
| continue; |
| } else if (!inclusive && filter.contains(key.getName())) { |
| continue; |
| } |
| targetDict.put(key.getName(), |
| cloneForNewDocument(orgDict.getItem(key))); |
| } |
| } |
| |
| private String getUniqueFontName(COSDictionary fontData) throws IOException { |
| PDSimpleFont font = getFont(fontData); |
| String extra = ""; |
| String name = getName(font.getBaseFont()) + "_" + ((COSName)fontData.getItem(COSName.SUBTYPE)).getName(); |
| if (font instanceof PDType0Font |
| && ((PDType0Font) font).getDescendantFont() instanceof PDCIDFontType0Font |
| && ((PDCIDFontType0Font) ((PDType0Font) font).getDescendantFont()).getType1CFont() != null) { |
| CFFFont cffFont = |
| ((PDCIDFontType0Font) ((PDType0Font) font).getDescendantFont()).getType1CFont().getCFFFont(); |
| if (cffFont instanceof CFFFontROS |
| && ((CFFFontROS)cffFont).getFdSelect().getClass().getName() |
| .equals("org.apache.fontbox.cff.CFFParser$Format0FDSelect")) { |
| extra += "format0"; |
| } |
| return name + extra; |
| } |
| if (font instanceof PDType0Font |
| && font.getToUnicode() != null |
| && ((PDType0Font) font).getDescendantFont() instanceof PDCIDFontType2Font) { |
| if (!isSubsetFont(font.getBaseFont())) { |
| extra = "f3"; |
| } |
| return name + extra; |
| } |
| if (font instanceof PDTrueTypeFont && isSubsetFont(font.getBaseFont())) { |
| TrueTypeFont tt = ((PDTrueTypeFont) font).getTTFFont(); |
| for (CMAPEncodingEntry c : tt.getCMAP().getCmaps()) { |
| if (c.getGlyphId(1) > 0) { |
| extra = "cid"; |
| } |
| } |
| return name + extra; |
| } |
| // if (!isSubsetFont(font.getBaseFont())) { |
| // return font.getBaseFont() + "_" + ((COSName)fontData.getItem(COSName.SUBTYPE)).getName(); |
| // } |
| if (font instanceof PDType1Font) { |
| if (((PDType1Font) font).getType1CFont() == null |
| || ((PDType1Font) font).getType1CFont().getCFFFont() == null) { |
| if (font.getFontDescriptor() instanceof PDFontDescriptorDictionary) { |
| return name; |
| } |
| return null; |
| } |
| CFFEncoding encoding = ((PDType1Font)font).getType1CFont().getCFFFont().getEncoding(); |
| String eClass = encoding.getClass().getName(); |
| if (eClass.equals("org.apache.fontbox.cff.CFFParser$Format1Encoding")) { |
| extra = "f1enc"; |
| } else if (eClass.equals("org.apache.fontbox.cff.CFFParser$Format0Encoding")) { |
| extra = "f0enc"; |
| } |
| CFFCharset cs = ((PDType1Font)font).getType1CFont().getCFFFont().getCharset(); |
| if (cs.getEntries().get(0).getSID() < OTFSubSetFile.NUM_STANDARD_STRINGS) { |
| extra += "stdcs"; |
| } |
| if (cs.getClass().getName().equals("org.apache.fontbox.cff.CFFParser$Format1Charset")) { |
| extra += "f1cs"; |
| } |
| return name + extra; |
| } |
| return null; |
| } |
| |
| private static boolean isSubsetFont(String s) { |
| return SUBSET_PATTERN.matcher(s).matches(); |
| } |
| |
| private static String getName(String name) { |
| if (isSubsetFont(name)) { |
| return name.split("\\+")[1].replace(" ", ""); |
| } |
| return name.replace(" ", ""); |
| } |
| |
| interface FOPPDFFont extends RefPDFFont { |
| String getFontName(); |
| void setRef(PDFDictionary d); |
| String addFont(COSDictionary fontdata) throws IOException; |
| int size(); |
| } |
| |
| public class FOPPDFMultiByteFont extends MultiByteFont implements FOPPDFFont { |
| protected PDFDictionary ref; |
| private Map<Integer, Integer> newWidth = new TreeMap<Integer, Integer>(); |
| private Map<String, Integer> charMapGlobal = new LinkedHashMap<String, Integer>(); |
| private MergeTTFonts mergeTTFonts = new MergeTTFonts(); |
| private MergeCFFFonts mergeCFFFonts = new MergeCFFFonts(); |
| private Map<String, GlyphData> glyphs = new HashMap<String, GlyphData>(); |
| |
| public FOPPDFMultiByteFont(COSDictionary fontData, String name) throws IOException { |
| super(null, EmbeddingMode.SUBSET); |
| //this stops fop modifying font later on |
| setEmbeddingMode(EmbeddingMode.FULL); |
| readFontBBox(fontData); |
| setFontName(name); |
| addFont(fontData); |
| } |
| |
| public String addFont(COSDictionary fontData) throws IOException { |
| PDSimpleFont font = getFont(fontData); |
| setProperties(this, font); |
| PDSimpleFont mainFont = font; |
| TrueTypeFont ttf = null; |
| if (font instanceof PDType0Font) { |
| PDCIDFont cidFont = (PDCIDFont) ((PDType0Font) font).getDescendantFont(); |
| setDefaultWidth((int) cidFont.getDefaultWidth()); |
| mainFont = cidFont; |
| if (cidFont instanceof PDCIDFontType0Font) { |
| setCIDType(CIDFontType.CIDTYPE0); |
| setFontType(FontType.CIDTYPE0); |
| } else { |
| ttf = ((PDCIDFontType2Font) cidFont).getTTFFont(); |
| } |
| } else { |
| ttf = ((PDTrueTypeFont) font).getTTFFont(); |
| setDefaultWidth(1000); |
| } |
| GlyphData[] glyphData = new GlyphData[0]; |
| if (ttf != null) { |
| glyphData = ttf.getGlyph().getGlyphs(); |
| } |
| Map<Integer, Integer> oldToNewGIMap = new HashMap<Integer, Integer>(); |
| if (charMapGlobal.isEmpty()) { |
| oldToNewGIMap.put(0, 0); // .notdef glyph |
| } |
| CMap c = mainFont.getToUnicodeCMap(); |
| if (c == null) { |
| c = font.getToUnicodeCMap(); |
| } |
| Map<Integer, String> mapping = getMapping(mainFont, c, glyphData.length); |
| if (glyphData.length > 0 && differentGlyphData(glyphData, mapping)) { |
| // return null; |
| } |
| Map<Integer, String> gidToGlyph = new TreeMap<Integer, String>(mapping); |
| if (mainFont instanceof PDTrueTypeFont) { |
| CMAPEncodingEntry cmap = ttf.getCMAP().getCmaps()[0]; |
| gidToGlyph.clear(); |
| int[] gidToCode = cmap.getGlyphIdToCharacterCode(); |
| for (int i = 1; i < glyphData.length; i++) { |
| String mappedChar = mapping.get(gidToCode[i]); |
| gidToGlyph.put(i, mappedChar); |
| } |
| } |
| readCharMap(font, gidToGlyph, glyphData, mainFont, oldToNewGIMap); |
| FontFileReader ffr = readFontFile(mainFont); |
| if (ttf != null) { |
| mergeMaxp(ttf, mergeTTFonts.maxp); |
| int sizeNoCompGlyphs = oldToNewGIMap.size(); |
| mergeTTFonts.readFont(ffr, oldToNewGIMap, true); |
| if (oldToNewGIMap.size() > sizeNoCompGlyphs) { |
| cidSet.mapChar(256 * 256, (char) 0); |
| } |
| } else { |
| mergeCFFFonts.readType1CFont(new ByteArrayInputStream(ffr.getAllBytes()), getEmbedFontName()); |
| } |
| return getFontName(); |
| } |
| |
| private void readCharMap(PDSimpleFont font, Map<Integer, String> gidToGlyph, GlyphData[] glyphData, |
| PDSimpleFont mainFont, Map<Integer, Integer> oldToNewGIMap) { |
| int widthPos = font.getFirstChar() + 1; |
| for (Map.Entry<Integer, String> i : gidToGlyph.entrySet()) { |
| String mappedChar = i.getValue(); |
| int key = i.getKey(); |
| boolean skipWidth = (mappedChar == null) || mappedChar.length() == 0; |
| if (skipWidth) { |
| mappedChar = (char)charMapGlobal.size() + "tmp"; |
| } else if (mappedChar.length() > 1) { |
| mappedChar = "" + (char)mappedChar.hashCode(); |
| } |
| if (!charMapGlobal.containsKey(mappedChar)) { |
| if (glyphData.length > 0 |
| && glyphData[key] == null |
| && !CharUtilities.isAdjustableSpace(mappedChar.charAt(0))) { |
| continue; |
| } |
| boolean addToEnd = charMapGlobal.containsValue(key); |
| if (addToEnd) { |
| addPrivateUseMapping(mappedChar.charAt(0), charMapGlobal.size() + 1); |
| charMapGlobal.put(mappedChar, charMapGlobal.size() + 1); |
| } else { |
| addPrivateUseMapping(mappedChar.charAt(0), key); |
| charMapGlobal.put(mappedChar, key); |
| } |
| int glyph = 0; |
| if (hasChar(mappedChar.charAt(0))) { |
| glyph = (int) mapChar(mappedChar.charAt(0)); |
| } |
| oldToNewGIMap.put(key, glyph); |
| if (!skipWidth) { |
| if (!(mainFont instanceof PDTrueTypeFont)) { |
| widthPos = key; |
| } |
| float w = font.getFontWidth(widthPos); |
| if (w >= 0) { |
| if (mainFont instanceof PDCIDFontType0Font) { |
| newWidth.put(key, (int)w); |
| } else { |
| newWidth.put(glyph, (int)w); |
| } |
| } |
| } |
| } |
| if (!skipWidth) { |
| widthPos++; |
| } |
| } |
| } |
| |
| private Map<Integer, String> getMapping(PDSimpleFont font, CMap c, int len) throws IOException { |
| Map<Integer, String> mapping = new HashMap<Integer, String>(); |
| if (font instanceof PDCIDFontType0Font) { |
| Collection<CFFFont.Mapping> mappings = |
| ((PDCIDFontType0Font) font).getType1CFont().getCFFFont().getMappings(); |
| for (CFFFont.Mapping m : mappings) { |
| String character = Encoding.getCharacterForName(m.getName()); |
| mapping.put(m.getSID(), character); |
| } |
| } |
| if (c != null) { |
| int last = font.getLastChar(); |
| if (last == -1) { |
| last = len; |
| } |
| int size = 1; |
| if (c.hasTwoByteMappings()) { |
| size = 2; |
| } |
| for (int i = font.getFirstChar(); i <= last; i++) { |
| String l = c.lookup(i, size); |
| if (l != null) { |
| mapping.put(i, l); |
| } |
| } |
| } |
| return mapping; |
| } |
| |
| private boolean differentGlyphData(GlyphData[] data, Map<Integer, String> mapping) throws IOException { |
| Map<String, Integer> tmpMap = new HashMap<String, Integer>(); |
| for (Map.Entry<Integer, String> entry : mapping.entrySet()) { |
| if (!tmpMap.containsKey(entry.getValue())) { |
| tmpMap.put(entry.getValue(), entry.getKey()); |
| } |
| } |
| mapping.clear(); |
| for (Map.Entry<String, Integer> entry : tmpMap.entrySet()) { |
| mapping.put(entry.getValue(), entry.getKey()); |
| } |
| |
| for (Map.Entry<Integer, String> n : mapping.entrySet()) { |
| if (data[n.getKey()] != null) { |
| if (glyphs.containsKey(n.getValue()) && !glyphs.get(n.getValue()).equals(data[n.getKey()])) { |
| return true; |
| } |
| glyphs.put(n.getValue(), data[n.getKey()]); |
| } |
| } |
| return false; |
| } |
| |
| private FontFileReader readFontFile(PDFont font) throws IOException { |
| PDFontDescriptorDictionary fd = (PDFontDescriptorDictionary) font.getFontDescriptor(); |
| PDStream ff = fd.getFontFile3(); |
| if (ff == null) { |
| ff = fd.getFontFile2(); |
| if (ff == null) { |
| ff = fd.getFontFile(); |
| } |
| } |
| InputStream is = ff.createInputStream(); |
| return new FontFileReader(new ByteArrayInputStream(IOUtils.toByteArray(is))); |
| } |
| |
| public Map<Integer, Integer> getWidthsMap() { |
| return newWidth; |
| } |
| |
| public PDFDictionary getRef() { |
| return ref; |
| } |
| |
| public void setRef(PDFDictionary d) { |
| ref = d; |
| } |
| |
| public int size() { |
| if (getFontType() == FontType.CIDTYPE0) { |
| return 1; |
| } |
| return 0; |
| } |
| |
| private void readFontBBox(COSBase b) throws IOException { |
| if (b instanceof COSDictionary) { |
| COSDictionary dict = (COSDictionary)b; |
| for (Map.Entry<COSName, COSBase> n : dict.entrySet()) { |
| readFontBBox(n.getValue()); |
| if (n.getKey() == COSName.FONT_BBOX) { |
| COSArray w = (COSArray)n.getValue(); |
| float[] bboxf = w.toFloatArray(); |
| int[] bbox = new int[bboxf.length]; |
| for (int i = 0; i < bbox.length; i++) { |
| bbox[i] = (int)bboxf[i]; |
| } |
| setFontBBox(bbox); |
| } |
| } |
| } else if (b instanceof COSObject) { |
| COSObject o = (COSObject)b; |
| readFontBBox(o.getObject()); |
| } else if (b instanceof COSArray) { |
| COSArray o = (COSArray)b; |
| for (int i = 0; i < o.size(); i++) { |
| readFontBBox(o.get(i)); |
| } |
| } |
| } |
| |
| public boolean isEmbeddable() { |
| return true; |
| } |
| |
| public InputStream getInputStream() throws IOException { |
| if (getFontType() == FontType.CIDTYPE0) { |
| mergeCFFFonts.writeFont(); |
| return new ByteArrayInputStream(mergeCFFFonts.getFontSubset()); |
| } |
| mergeTTFonts.writeFont(null); |
| return new ByteArrayInputStream(mergeTTFonts.getFontSubset()); |
| } |
| } |
| |
| public static class Cmap { |
| int platformId; |
| int platformEncodingId; |
| Map<Integer, Integer> glyphIdToCharacterCode = new TreeMap<Integer, Integer>(); |
| } |
| |
| public class FOPPDFSingleByteFont extends SingleByteFont implements FOPPDFFont { |
| private int fontCount; |
| private PDSimpleFont font; |
| protected PDFDictionary ref; |
| private Map<String, Integer> charMapGlobal = new LinkedHashMap<String, Integer>(); |
| private Map<Integer, Integer> newWidth = new HashMap<Integer, Integer>(); |
| private Map<String, byte[]> charStringsDict; |
| private Cmap newCmap = new Cmap(); |
| private Map<Integer, String> encodingMap = new TreeMap<Integer, String>(); |
| private int encodingSkip; |
| private MergeTTFonts mergeTTFonts = new MergeTTFonts(); |
| private MergeCFFFonts mergeCFFFonts = new MergeCFFFonts(); |
| private MergeType1Fonts mergeType1Fonts = new MergeType1Fonts(); |
| private String embedName; |
| |
| public FOPPDFSingleByteFont(COSDictionary fontData, String name) throws IOException { |
| super(null, EmbeddingMode.FULL); |
| if (fontData.getItem(COSName.SUBTYPE) == COSName.TRUE_TYPE) { |
| setFontType(FontType.TRUETYPE); |
| } |
| width = new int[0]; |
| font = getFont(fontData); |
| setFirstChar(font.getFirstChar()); |
| setLastChar(font.getLastChar()); |
| loadFontFile(font); |
| float[] bBoxF = font.getFontBoundingBox().getCOSArray().toFloatArray(); |
| int[] bBox = new int[bBoxF.length]; |
| for (int i = 0; i < bBox.length; i++) { |
| bBox[i] = (int)bBoxF[i]; |
| } |
| setFontBBox(bBox); |
| |
| setFontName(name); |
| Object cmap = getCmap(font); |
| for (int i = font.getFirstChar(); i <= font.getLastChar(); i++) { |
| String mappedChar = getChar(cmap, i); |
| if (mappedChar != null && !charMapGlobal.containsKey(mappedChar)) { |
| charMapGlobal.put(mappedChar, i); |
| } |
| } |
| //mark font as used |
| notifyMapOperation(); |
| setProperties(this, font); |
| if (font.getWidths() != null) { |
| //if width contains 0 we cant rely on codeToNameMap |
| boolean usesZero = font.getWidths().contains(0); |
| Set<Integer> codeToName = getCodeToName(font.getFontEncoding()).keySet(); |
| for (int i = getFirstChar(); |
| i <= Math.min(getLastChar(), getFirstChar() + font.getWidths().size()); i++) { |
| if (usesZero || codeToName.contains(i)) { |
| int w = font.getWidths().get(i - getFirstChar()).intValue(); |
| newWidth.put(i, w); |
| } else { |
| newWidth.put(i, 0); |
| } |
| } |
| } |
| mapping = new FOPPDFEncoding(); |
| encodingSkip = font.getLastChar() + 1; |
| addEncoding(font); |
| } |
| |
| private Map<Integer, String> getCodeToName(Encoding encoding) { |
| Map<Integer, String> codeToName = new HashMap<Integer, String>(); |
| if (encoding != null) { |
| COSBase cos = encoding.getCOSObject(); |
| if (cos instanceof COSDictionary) { |
| COSDictionary enc = (COSDictionary) cos; |
| COSName baseEncodingName = (COSName) enc.getDictionaryObject(COSName.BASE_ENCODING); |
| if (baseEncodingName != null) { |
| try { |
| Encoding baseEncoding = EncodingManager.INSTANCE.getEncoding(baseEncodingName); |
| codeToName.putAll(baseEncoding.getCodeToNameMap()); |
| } catch (IOException e) { |
| throw new RuntimeException(e); |
| } |
| } |
| COSArray differences = (COSArray)enc.getDictionaryObject(COSName.DIFFERENCES); |
| int currentIndex = -1; |
| for (int i = 0; differences != null && i < differences.size(); i++) { |
| COSBase next = differences.getObject(i); |
| if (next instanceof COSNumber) { |
| currentIndex = ((COSNumber)next).intValue(); |
| } else if (next instanceof COSName) { |
| COSName name = (COSName)next; |
| codeToName.put(currentIndex++, name.getName()); |
| } |
| } |
| } else { |
| return encoding.getCodeToNameMap(); |
| } |
| } |
| return codeToName; |
| } |
| |
| private Object getCmap(PDSimpleFont font) throws IOException { |
| if (font.getFontEncoding() != null) { |
| return font.getFontEncoding(); |
| } |
| return font.getToUnicodeCMap(); |
| } |
| |
| private PDStream readFontFile(PDSimpleFont font) throws IOException { |
| PDFontDescriptorDictionary fd = (PDFontDescriptorDictionary) font.getFontDescriptor(); |
| setFlags(fd.getFlags()); |
| PDStream ff = fd.getFontFile3(); |
| if (ff == null) { |
| ff = fd.getFontFile2(); |
| if (ff == null) { |
| ff = fd.getFontFile(); |
| } |
| } else { |
| setFontType(FontType.TYPE1C); |
| } |
| if (ff == null) { |
| throw new IOException(font.getBaseFont() + " no font file"); |
| } |
| return ff; |
| } |
| |
| private void loadFontFile(PDSimpleFont font) throws IOException { |
| PDStream ff = readFontFile(font); |
| mergeFontFile(ff.createInputStream(), font); |
| if (font instanceof PDTrueTypeFont) { |
| TrueTypeFont ttfont = ((PDTrueTypeFont) font).getTTFFont(); |
| CMAPEncodingEntry[] cmapList = ttfont.getCMAP().getCmaps(); |
| for (CMAPEncodingEntry c : cmapList) { |
| newCmap.platformId = c.getPlatformId(); |
| newCmap.platformEncodingId = c.getPlatformEncodingId(); |
| for (int i = 0; i < 256 * 256; i++) { |
| if (c.getGlyphId(i) != 0) { |
| newCmap.glyphIdToCharacterCode.put(i, c.getGlyphId(i)); |
| } |
| } |
| } |
| mergeMaxp(ttfont, mergeTTFonts.maxp); |
| } |
| } |
| |
| @Override |
| public boolean hasChar(char c) { |
| return charMapGlobal.containsKey(String.valueOf(c)); |
| } |
| |
| @Override |
| public char mapChar(char c) { |
| return mapping.mapChar(c); |
| } |
| |
| public String getEmbedFontName() { |
| if (embedName == null) { |
| embedName = getName(font.getBaseFont()); |
| } |
| return embedName; |
| } |
| |
| public int[] getWidths() { |
| width = new int[getLastChar() - getFirstChar() + 1]; |
| for (int i = getFirstChar(); i <= getLastChar(); i++) { |
| if (newWidth.containsKey(i)) { |
| width[i - getFirstChar()] = newWidth.get(i); |
| } else { |
| width[i - getFirstChar()] = 0; |
| } |
| } |
| return width.clone(); |
| } |
| |
| public String addFont(COSDictionary fontData) throws IOException { |
| PDSimpleFont font = getFont(fontData); |
| if (font instanceof PDType1Font && differentGlyphData((PDType1Font) font)) { |
| return null; |
| } |
| mergeWidths(font); |
| if (font.getFirstChar() < getFirstChar()) { |
| setFirstChar(font.getFirstChar()); |
| } |
| for (int w : newWidth.keySet()) { |
| if (w > getLastChar()) { |
| setLastChar(w); |
| } |
| } |
| loadFontFile(font); |
| addEncoding(font); |
| return getFontName(); |
| } |
| |
| public int size() { |
| return fontCount; |
| } |
| |
| private Map<String, byte[]> getCharStringsDict(PDType1Font font) throws IOException { |
| if (getFontType() == FontType.TYPE1) { |
| return font.getType1Font().getCharStringsDict(); |
| } |
| return font.getType1CFont().getCFFFont().getCharStringsDict(); |
| } |
| |
| private boolean differentGlyphData(PDType1Font otherFont) throws IOException { |
| if (charStringsDict == null) { |
| charStringsDict = getCharStringsDict((PDType1Font) font); |
| } |
| for (Map.Entry<String, byte[]> s : getCharStringsDict(otherFont).entrySet()) { |
| if (charStringsDict.containsKey(s.getKey())) { |
| int numberDiff = 0; |
| byte[] b1 = charStringsDict.get(s.getKey()); |
| byte[] b2 = s.getValue(); |
| int b1Index = b1.length - 1; |
| int b2Index = b2.length - 1; |
| while (b1Index >= 0 && b2Index >= 0) { |
| if (b1[b1Index] != b2[b2Index]) { |
| numberDiff++; |
| if (numberDiff > 2) { |
| break; |
| } |
| } |
| b1Index--; |
| b2Index--; |
| } |
| if (numberDiff > 2) { |
| // log.info(getFontName() + " " + s.getKey() + " not equal " + numberdiff); |
| return true; |
| } |
| } |
| } |
| return false; |
| } |
| |
| private void mergeWidths(PDSimpleFont font) throws IOException { |
| int w = 0; |
| int skipGlyphIndex = getLastChar() + 1; |
| Object cmap = getCmap(font); |
| Set<Integer> codeToName = getCodeToName(font.getFontEncoding()).keySet(); |
| for (int i = font.getFirstChar(); i <= font.getLastChar(); i++) { |
| boolean addedWidth = false; |
| int glyphIndexPos = skipGlyphIndex; |
| if (font instanceof PDTrueTypeFont) { |
| glyphIndexPos = i; |
| } |
| int neww = 0; |
| if (font.getWidths() != null) { |
| neww = font.getWidths().get(i - font.getFirstChar()).intValue(); |
| if (!newWidth.containsKey(i) || newWidth.get(i) == 0) { |
| if (getFontType() == FontType.TYPE1 |
| || font instanceof PDTrueTypeFont |
| || codeToName.contains(i)) { |
| newWidth.put(i, neww); |
| glyphIndexPos = i; |
| } else { |
| newWidth.put(i, 0); |
| } |
| addedWidth = true; |
| } |
| } |
| String mappedChar = getChar(cmap, i); |
| if (mappedChar != null && !charMapGlobal.containsKey(mappedChar)) { |
| charMapGlobal.put(mappedChar, glyphIndexPos); |
| if (!addedWidth && w < font.getWidths().size()) { |
| newWidth.put(newWidth.size() + getFirstChar(), neww); |
| } |
| skipGlyphIndex++; |
| } |
| w++; |
| } |
| } |
| |
| private String getChar(Object cmap, int i) throws IOException { |
| if (cmap instanceof CMap) { |
| CMap c = (CMap)cmap; |
| int size = 1; |
| if (c.hasTwoByteMappings()) { |
| size = 2; |
| } |
| return c.lookup(i, size); |
| } |
| Encoding enc = (Encoding)cmap; |
| if (enc instanceof DictionaryEncoding) { |
| return enc.getName(i); |
| } |
| return enc.getCharacter(i); |
| } |
| |
| public String getEncodingName() { |
| if (font.getFontEncoding() != null) { |
| COSBase cosObject = font.getFontEncoding().getCOSObject(); |
| if (cosObject != null) { |
| if (cosObject instanceof COSDictionary) { |
| COSBase item = ((COSDictionary) cosObject).getItem(COSName.BASE_ENCODING); |
| if (item != null) { |
| return ((COSName)item).getName(); |
| } |
| } else if (cosObject instanceof COSName) { |
| return ((COSName) cosObject).getName(); |
| } else { |
| throw new RuntimeException(cosObject.toString() + " not supported"); |
| } |
| } |
| } |
| return null; |
| } |
| |
| private void addEncoding(PDSimpleFont fontForEnc) { |
| List<String> added = new ArrayList<String>(encodingMap.values()); |
| Map<Integer, String> codeToName = getCodeToName(fontForEnc.getFontEncoding()); |
| for (int i = fontForEnc.getFirstChar(); i <= fontForEnc.getLastChar(); i++) { |
| if (codeToName.keySet().contains(i)) { |
| String s = codeToName.get(i); |
| if (!added.contains(s)) { |
| if (!encodingMap.containsKey(i)) { |
| encodingMap.put(i, s); |
| } else { |
| encodingMap.put(encodingSkip, s); |
| encodingSkip++; |
| } |
| } |
| } |
| } |
| } |
| |
| class FOPPDFEncoding implements SingleByteEncoding { |
| private boolean cmap; |
| |
| public String getName() { |
| return "FOPPDFEncoding"; |
| } |
| |
| public char mapChar(char c) { |
| if (charMapGlobal.containsKey(String.valueOf(c))) { |
| return (char)charMapGlobal.get(String.valueOf(c)).intValue(); |
| } |
| return 0; |
| } |
| |
| public String[] getCharNameMap() { |
| Collection<String> v = encodingMap.values(); |
| return v.toArray(new String[v.size()]); |
| } |
| |
| public char[] getUnicodeCharMap() { |
| if (cmap) { |
| if (font.getToUnicode() == null) { |
| return new char[0]; |
| } |
| List<String> cmapStrings = new ArrayList<String>(); |
| Map<Integer, String> cm = new HashMap<Integer, String>(); |
| for (Map.Entry<String, Integer> o : charMapGlobal.entrySet()) { |
| cm.put(o.getValue(), o.getKey()); |
| } |
| for (int i = 0; i < getLastChar() + 1; i++) { |
| if (cm.containsKey(i)) { |
| cmapStrings.add(cm.get(i)); |
| } else { |
| cmapStrings.add(" "); |
| } |
| } |
| return fromStringToCharArray(cmapStrings); |
| } |
| cmap = true; |
| return toCharArray(encodingMap.keySet()); |
| } |
| |
| private char[] fromStringToCharArray(Collection<String> list) { |
| char[] ret = new char[list.size()]; |
| int i = 0; |
| for (String e : list) { |
| if (e.length() > 0) { |
| ret[i++] = e.charAt(0); |
| } |
| } |
| return ret; |
| } |
| |
| private char[] toCharArray(Collection<Integer> list) { |
| char[] ret = new char[list.size()]; |
| int i = 0; |
| for (int e : list) { |
| ret[i++] = (char)e; |
| } |
| return ret; |
| } |
| } |
| |
| public PDFDictionary getRef() { |
| return ref; |
| } |
| |
| public void setRef(PDFDictionary d) { |
| ref = d; |
| } |
| |
| public boolean isEmbeddable() { |
| return true; |
| } |
| |
| public boolean isSymbolicFont() { |
| return false; |
| } |
| |
| private void mergeFontFile(InputStream ff, PDSimpleFont pdSimpleFont) throws IOException { |
| if (getFontType() == FontType.TRUETYPE) { |
| Map<Integer, Integer> chars = new HashMap<Integer, Integer>(); |
| chars.put(0, 0); |
| mergeTTFonts.readFont(new FontFileReader(ff), chars, false); |
| } else if (getFontType() == FontType.TYPE1) { |
| mergeType1Fonts.readFont(ff, (PDType1Font) pdSimpleFont); |
| } else { |
| mergeCFFFonts.readType1CFont(ff, getEmbedFontName()); |
| } |
| fontCount++; |
| } |
| |
| public InputStream getInputStream() throws IOException { |
| if (getFontType() == FontType.TYPE1C) { |
| mergeCFFFonts.writeFont(); |
| return new ByteArrayInputStream(mergeCFFFonts.getFontSubset()); |
| } |
| if (getFontType() == FontType.TRUETYPE) { |
| mergeTTFonts.writeFont(newCmap); |
| return new ByteArrayInputStream(mergeTTFonts.getFontSubset()); |
| } |
| if (getFontType() == FontType.TYPE1) { |
| return new ByteArrayInputStream(mergeType1Fonts.writeFont()); |
| } |
| return null; |
| } |
| } |
| |
| private void setProperties(CustomFont cFont, PDSimpleFont font) { |
| if (font.getFontDescriptor() != null) { |
| cFont.setCapHeight((int) font.getFontDescriptor().getCapHeight()); |
| cFont.setAscender((int)font.getFontDescriptor().getAscent()); |
| cFont.setDescender((int)font.getFontDescriptor().getDescent()); |
| cFont.setXHeight((int)font.getFontDescriptor().getXHeight()); |
| cFont.setStemV((int)font.getFontDescriptor().getStemV()); |
| } |
| } |
| |
| private void mergeMaxp(TrueTypeFont ttf, MaximumProfileTable outMaxp) { |
| MaximumProfileTable mp = ttf.getMaximumProfile(); |
| outMaxp.setVersion(mp.getVersion()); |
| outMaxp.setNumGlyphs(outMaxp.getNumGlyphs() + mp.getNumGlyphs()); |
| outMaxp.setMaxPoints(outMaxp.getMaxPoints() + mp.getMaxPoints()); |
| outMaxp.setMaxContours(outMaxp.getMaxContours() + mp.getMaxContours()); |
| outMaxp.setMaxCompositePoints(outMaxp.getMaxCompositePoints() + mp.getMaxCompositePoints()); |
| outMaxp.setMaxCompositeContours(outMaxp.getMaxCompositeContours() + mp.getMaxCompositeContours()); |
| outMaxp.setMaxZones(outMaxp.getMaxZones() + mp.getMaxZones()); |
| outMaxp.setMaxTwilightPoints(outMaxp.getMaxTwilightPoints() + mp.getMaxTwilightPoints()); |
| outMaxp.setMaxStorage(outMaxp.getMaxStorage() + mp.getMaxStorage()); |
| outMaxp.setMaxFunctionDefs(outMaxp.getMaxFunctionDefs() + mp.getMaxFunctionDefs()); |
| outMaxp.setMaxInstructionDefs(outMaxp.getMaxInstructionDefs() + mp.getMaxInstructionDefs()); |
| outMaxp.setMaxStackElements(outMaxp.getMaxStackElements() + mp.getMaxStackElements()); |
| outMaxp.setMaxSizeOfInstructions(outMaxp.getMaxSizeOfInstructions() + mp.getMaxSizeOfInstructions()); |
| outMaxp.setMaxComponentElements(outMaxp.getMaxComponentElements() + mp.getMaxComponentElements()); |
| outMaxp.setMaxComponentDepth(outMaxp.getMaxComponentDepth() + mp.getMaxComponentDepth()); |
| } |
| |
| public class PDFWriter { |
| protected StringBuilder s = new StringBuilder(); |
| private String key; |
| private List<COSName> resourceNames; |
| |
| public PDFWriter(String key, List<COSName> resourceNames) { |
| this.key = key; |
| this.resourceNames = resourceNames; |
| } |
| |
| public String writeText(PDStream pdStream) throws IOException { |
| Iterator<Object> it = new PDFStreamParser(pdStream).getTokenIterator(); |
| List<COSBase> arguments = new ArrayList<COSBase>(); |
| while (it.hasNext()) { |
| Object o = it.next(); |
| if (o instanceof PDFOperator) { |
| PDFOperator op = (PDFOperator)o; |
| readPDFArguments(op, arguments); |
| s.append(op.getOperation() + "\n"); |
| arguments.clear(); |
| if (op.getImageParameters() != null) { |
| for (Map.Entry<COSName, COSBase> cn : op.getImageParameters().entrySet()) { |
| arguments.add(cn.getKey()); |
| arguments.add(cn.getValue()); |
| } |
| readPDFArguments(op, arguments); |
| s.append("ID " + new String(op.getImageData(), "ISO-8859-1")); |
| arguments.clear(); |
| s.append("EI\n"); |
| } |
| } else { |
| arguments.add((COSBase)o); |
| } |
| } |
| return s.toString(); |
| } |
| |
| protected void readPDFArguments(PDFOperator op, Collection<COSBase> arguments) throws IOException { |
| for (COSBase c : arguments) { |
| processArg(op, c); |
| } |
| } |
| |
| protected void processArg(PDFOperator op, COSBase c) throws IOException { |
| if (c instanceof COSInteger) { |
| s.append(((COSInteger) c).intValue()); |
| s.append(" "); |
| } else if (c instanceof COSFloat) { |
| float f = ((COSFloat) c).floatValue(); |
| s.append(new DecimalFormat("#.####").format(f)); |
| s.append(" "); |
| } else if (c instanceof COSName) { |
| COSName cn = (COSName)c; |
| s.append("/" + cn.getName()); |
| addKey(cn); |
| s.append(" "); |
| } else if (c instanceof COSString) { |
| s.append("<" + ((COSString) c).getHexString() + ">"); |
| } else if (c instanceof COSArray) { |
| s.append("["); |
| readPDFArguments(op, (Collection<COSBase>) ((COSArray) c).toList()); |
| s.append("] "); |
| } else if (c instanceof COSDictionary) { |
| Collection<COSBase> dictArgs = new ArrayList<COSBase>(); |
| for (Map.Entry<COSName, COSBase> cn : ((COSDictionary)c).entrySet()) { |
| dictArgs.add(cn.getKey()); |
| dictArgs.add(cn.getValue()); |
| } |
| s.append("<<"); |
| readPDFArguments(op, dictArgs); |
| s.append(">>"); |
| } else { |
| throw new IOException(c + " not supported"); |
| } |
| } |
| |
| protected void addKey(COSName cn) { |
| if (resourceNames.contains(cn)) { |
| s.append(key); |
| } |
| } |
| } |
| |
| public class MergeFontsPDFWriter extends PDFWriter { |
| private COSDictionary fonts; |
| private FontInfo fontInfo; |
| private Typeface font; |
| private PDSimpleFont oldFont = null; |
| private Map<COSName, String> fontsToRemove = new HashMap<COSName, String>(); |
| |
| public MergeFontsPDFWriter(COSDictionary fonts, FontInfo fontInfo, String key, List<COSName> resourceNames) { |
| super(key, resourceNames); |
| this.fonts = fonts; |
| this.fontInfo = fontInfo; |
| } |
| |
| public String writeText(PDStream pdStream) throws IOException { |
| String txt = super.writeText(pdStream); |
| if (fontsToRemove.isEmpty()) { |
| return null; |
| } |
| for (COSName cn : fontsToRemove.keySet()) { |
| fonts.removeItem(cn); |
| } |
| return txt; |
| } |
| |
| protected void readPDFArguments(PDFOperator op, Collection<COSBase> arguments) throws IOException { |
| for (COSBase c : arguments) { |
| if (c instanceof COSName) { |
| COSName cn = (COSName)c; |
| COSDictionary fontData = (COSDictionary)fonts.getDictionaryObject(cn.getName()); |
| String internalName = fontsToRemove.get(cn); |
| if (internalName == null && fontData != null) { |
| internalName = getNewFont(fontData, fontInfo, fontsToRemove.values()); |
| } |
| if (fontData == null || internalName == null) { |
| s.append("/" + cn.getName()); |
| addKey(cn); |
| if (op.getOperation().equals("Tf")) { |
| font = null; |
| oldFont = null; |
| } |
| } else { |
| s.append("/" + internalName); |
| fontsToRemove.put(cn, internalName); |
| font = fontInfo.getUsedFonts().get(internalName); |
| oldFont = getFont(fontData); |
| } |
| s.append(" "); |
| } else if (c instanceof COSString && font != null && ((FOPPDFFont)font).size() != 1) { |
| List<String> word = readCOSString((COSString)c, oldFont); |
| if (word == null) { |
| s.append(PDFText.escapeString(((COSString) c).getString())); |
| } else { |
| String x = getMappedWord(word, font, ((COSString) c).getBytes()); |
| if (x == null) { |
| s.append(PDFText.escapeString(((COSString) c).getString())); |
| } else { |
| s.append(x); |
| } |
| } |
| } else { |
| processArg(op, c); |
| } |
| } |
| } |
| |
| private String getMappedWord(List<String> word, Typeface font, byte[] bytes) throws IOException { |
| StringBuffer newOct = new StringBuffer(); |
| StringBuilder newHex = new StringBuilder(); |
| int i = 0; |
| for (String str : word) { |
| Integer mapped = getMapping(bytes[i]); |
| if (mapped == null) { |
| char c = str.charAt(0); |
| if (str.length() > 1) { |
| c = (char) str.hashCode(); |
| } |
| if (font.hasChar(c)) { |
| mapped = (int)font.mapChar(c); |
| } else { |
| return null; |
| } |
| } |
| newHex.append(String.format("%1$04x", mapped & 0xFFFF).toUpperCase(Locale.getDefault())); |
| PDFText.escapeStringChar((char)mapped.intValue(), newOct); |
| i++; |
| } |
| if (font instanceof SingleByteFont) { |
| return "(" + newOct.toString() + ")"; |
| } |
| return "<" + newHex.toString() + ">"; |
| } |
| |
| private Integer getMapping(byte i) throws IOException { |
| if (oldFont.getFontEncoding() != null && font instanceof FOPPDFSingleByteFont) { |
| String name = oldFont.getFontEncoding().getName(i); |
| if (name != null && ((FOPPDFSingleByteFont)font).charMapGlobal.containsKey(name)) { |
| return ((FOPPDFSingleByteFont)font).charMapGlobal.get(name); |
| } |
| } |
| return null; |
| } |
| |
| private List<String> readCOSString(COSString s, PDSimpleFont oldFont) throws IOException { |
| List<String> word = new ArrayList<String>(); |
| byte[] string = s.getBytes(); |
| int codeLength; |
| // String t1Str = new String(string, "UTF-8"); |
| for (int i = 0; i < string.length; i += codeLength) { |
| codeLength = 1; |
| String c = oldFont.encode(string, i, codeLength); |
| // if (oldFont instanceof PDType1Font && i < t1Str.length()) { |
| // c = ((PDType1Font)oldFont).encodetype1(string, i, codeLength); |
| // } |
| if (c == null && i + 1 < string.length) { |
| codeLength++; |
| c = oldFont.encode(string, i, codeLength); |
| } |
| if (c == null) { |
| return null; |
| } |
| word.add(c); |
| } |
| return word; |
| } |
| } |
| |
| private PDSimpleFont getFont(COSDictionary fontData) throws IOException { |
| if (!fontMap.containsKey(fontData)) { |
| if (fontMap.size() > 10) { |
| fontMap.clear(); |
| } |
| fontMap.put(fontData, (PDSimpleFont)PDFontFactory.createFont(fontData)); |
| } |
| return fontMap.get(fontData); |
| } |
| |
| /** |
| * Creates a stream (from FOP's PDF library) from a PDF page parsed with PDFBox. |
| * @param sourceDoc the source PDF the given page to be copied belongs to |
| * @param page the page to transform into a stream |
| * @param key value to use as key for the stream |
| * @param eventBroadcaster events |
| * @param atdoc adjustment for stream |
| * @param fontinfo fonts |
| * @param pos rectangle |
| * @return the stream |
| * @throws IOException if an I/O error occurs |
| */ |
| public String createStreamFromPDFBoxPage(PDDocument sourceDoc, PDPage page, String key, |
| EventBroadcaster eventBroadcaster, AffineTransform atdoc, FontInfo fontinfo, Rectangle pos) |
| throws IOException { |
| handleAcroForm(sourceDoc, page, eventBroadcaster, atdoc); |
| PDResources sourcePageResources = page.findResources(); |
| PDFDictionary pageResources = null; |
| PDStream pdStream = page.getContents(); |
| COSDictionary fonts = (COSDictionary)sourcePageResources.getCOSDictionary().getDictionaryObject(COSName.FONT); |
| COSDictionary fontsBackup = null; |
| String uniqueName = Integer.toString(key.hashCode()); |
| String newStream = null; |
| if (fonts != null && pdfDoc.isMergeFontsEnabled()) { |
| fontsBackup = new COSDictionary(fonts); |
| MergeFontsPDFWriter m = new MergeFontsPDFWriter(fonts, fontinfo, uniqueName, |
| getResourceNames(sourcePageResources.getCOSDictionary())); |
| newStream = m.writeText(pdStream); |
| parentFonts = m.fontsToRemove.values(); |
| // if (newStream != null) { |
| // for (Object f : fonts.keySet().toArray()) { |
| // COSDictionary fontdata = (COSDictionary)fonts.getDictionaryObject((COSName)f); |
| // if (getUniqueFontName(fontdata) != null) { |
| // fonts.removeItem((COSName)f); |
| // } |
| // } |
| // } |
| } |
| if (newStream == null) { |
| newStream = new PDFWriter(uniqueName, |
| getResourceNames(sourcePageResources.getCOSDictionary())).writeText(pdStream); |
| } |
| pdStream = new PDStream(sourceDoc, new ByteArrayInputStream(newStream.getBytes("ISO-8859-1"))); |
| mergeXObj(sourcePageResources.getCOSDictionary(), fontinfo, uniqueName); |
| pageResources = (PDFDictionary)cloneForNewDocument(sourcePageResources.getCOSDictionary()); |
| |
| PDFDictionary fontDict = (PDFDictionary)pageResources.get("Font"); |
| if (fontDict != null && pdfDoc.isMergeFontsEnabled()) { |
| for (Map.Entry<String, Typeface> fontEntry : fontinfo.getUsedFonts().entrySet()) { |
| Typeface font = fontEntry.getValue(); |
| if (font instanceof FOPPDFFont) { |
| FOPPDFFont pdfFont = (FOPPDFFont)font; |
| if (pdfFont.getRef() == null) { |
| pdfFont.setRef(new PDFDictionary()); |
| pdfDoc.assignObjectNumber(pdfFont.getRef()); |
| } |
| fontDict.put(fontEntry.getKey(), pdfFont.getRef()); |
| } |
| } |
| } |
| updateXObj(sourcePageResources.getCOSDictionary(), pageResources); |
| if (fontsBackup != null) { |
| sourcePageResources.getCOSDictionary().setItem(COSName.FONT, fontsBackup); |
| } |
| |
| COSStream originalPageContents = (COSStream)pdStream.getCOSObject(); |
| |
| bindOptionalContent(sourceDoc); |
| |
| PDFStream pageStream; |
| Set filter; |
| if (originalPageContents instanceof COSStreamArray) { |
| COSStreamArray array = (COSStreamArray)originalPageContents; |
| pageStream = new PDFStream(); |
| InputStream in = array.getUnfilteredStream(); |
| OutputStream out = pageStream.getBufferOutputStream(); |
| IOUtils.copyLarge(in, out); |
| filter = FILTER_FILTER; |
| } else { |
| pageStream = (PDFStream)cloneForNewDocument(originalPageContents); |
| filter = Collections.EMPTY_SET; |
| } |
| if (pageStream == null) { |
| pageStream = new PDFStream(); |
| } |
| if (originalPageContents != null) { |
| transferDict(originalPageContents, pageStream, filter); |
| } |
| |
| transferPageDict(fonts, uniqueName, sourcePageResources); |
| |
| PDRectangle mediaBox = page.findMediaBox(); |
| PDRectangle cropBox = page.findCropBox(); |
| PDRectangle viewBox = cropBox != null ? cropBox : mediaBox; |
| |
| //Handle the /Rotation entry on the page dict |
| int rotation = PDFUtil.getNormalizedRotation(page); |
| |
| //Transform to FOP's user space |
| float w = (float)pos.getWidth() / 1000f; |
| float h = (float)pos.getHeight() / 1000f; |
| if (rotation == 90 || rotation == 270) { |
| float tmp = w; |
| w = h; |
| h = tmp; |
| } |
| atdoc.setTransform(AffineTransform.getScaleInstance(w / viewBox.getWidth(), h / viewBox.getHeight())); |
| atdoc.translate(0, viewBox.getHeight()); |
| atdoc.rotate(-Math.PI); |
| atdoc.scale(-1, 1); |
| atdoc.translate(-viewBox.getLowerLeftX(), -viewBox.getLowerLeftY()); |
| |
| switch (rotation) { |
| case 90: |
| atdoc.scale(viewBox.getWidth() / viewBox.getHeight(), viewBox.getHeight() / viewBox.getWidth()); |
| atdoc.translate(0, viewBox.getWidth()); |
| atdoc.rotate(-Math.PI / 2.0); |
| atdoc.scale(viewBox.getWidth() / viewBox.getHeight(), viewBox.getHeight() / viewBox.getWidth()); |
| break; |
| case 180: |
| atdoc.translate(viewBox.getWidth(), viewBox.getHeight()); |
| atdoc.rotate(-Math.PI); |
| break; |
| case 270: |
| atdoc.translate(0, viewBox.getHeight()); |
| atdoc.rotate(Math.toRadians(270 + 180)); |
| atdoc.translate(-viewBox.getWidth(), -viewBox.getHeight()); |
| break; |
| default: |
| //no additional transformations necessary |
| break; |
| } |
| StringBuffer boxStr = new StringBuffer(); |
| boxStr.append(0).append(' ').append(0).append(' '); |
| boxStr.append(PDFNumber.doubleOut(mediaBox.getWidth())).append(' '); |
| boxStr.append(PDFNumber.doubleOut(mediaBox.getHeight())).append(" re W n\n"); |
| return boxStr.toString() + pdStream.getInputStreamAsString(); |
| } |
| |
| private void mergeXObj(COSDictionary sourcePageResources, FontInfo fontinfo, String uniqueName) throws IOException { |
| COSDictionary xobj = (COSDictionary) sourcePageResources.getDictionaryObject(COSName.XOBJECT); |
| if (xobj != null && pdfDoc.isMergeFontsEnabled()) { |
| for (Map.Entry<COSName, COSBase> i : xobj.entrySet()) { |
| COSObject v = (COSObject) i.getValue(); |
| COSStream stream = (COSStream) v.getObject(); |
| COSDictionary res = (COSDictionary) stream.getDictionaryObject(COSName.RESOURCES); |
| if (res != null) { |
| COSDictionary src = (COSDictionary) res.getDictionaryObject(COSName.FONT); |
| if (src != null) { |
| COSDictionary target = (COSDictionary) sourcePageResources.getDictionaryObject(COSName.FONT); |
| if (target == null) { |
| sourcePageResources.setItem(COSName.FONT, src); |
| } else { |
| for (Map.Entry<COSName, COSBase> entry : src.entrySet()) { |
| if (!target.keySet().contains(entry.getKey())) { |
| target.setItem(entry.getKey(), entry.getValue()); |
| } |
| } |
| } |
| PDFWriter writer = new MergeFontsPDFWriter(src, fontinfo, uniqueName, |
| getResourceNames(sourcePageResources)); |
| String c = writer.writeText(PDStream.createFromCOS(stream)); |
| if (c != null) { |
| stream.removeItem(COSName.FILTER); |
| newXObj.put(i.getKey(), c); |
| for (Object e : src.keySet().toArray()) { |
| COSName name = (COSName) e; |
| src.setItem(name.getName() + uniqueName, src.getItem(name)); |
| src.removeItem(name); |
| } |
| } |
| } |
| } |
| } |
| } |
| } |
| |
| private void updateXObj(COSDictionary sourcePageResources, PDFDictionary pageResources) throws IOException { |
| COSDictionary xobj = (COSDictionary) sourcePageResources.getDictionaryObject(COSName.XOBJECT); |
| if (xobj != null && pdfDoc.isMergeFontsEnabled()) { |
| PDFDictionary target = (PDFDictionary) pageResources.get("XObject"); |
| for (COSName entry : xobj.keySet()) { |
| if (newXObj.containsKey(entry)) { |
| PDFStream s = (PDFStream) target.get(entry.getName()); |
| s.setData(newXObj.get(entry).getBytes("UTF-8")); |
| PDFDictionary xobjr = (PDFDictionary) s.get("Resources"); |
| xobjr.put("Font", pageResources.get("Font")); |
| } |
| } |
| } |
| } |
| |
| private List<COSName> getResourceNames(COSDictionary sourcePageResources) { |
| List<COSName> resourceNames = new ArrayList<COSName>(); |
| for (COSBase e : sourcePageResources.getValues()) { |
| if (e instanceof COSObject) { |
| e = ((COSObject) e).getObject(); |
| } |
| if (e instanceof COSDictionary) { |
| COSDictionary d = (COSDictionary) e; |
| resourceNames.addAll(d.keySet()); |
| } |
| } |
| return resourceNames; |
| } |
| |
| private void transferPageDict(COSDictionary fonts, String uniqueName, PDResources sourcePageResources) |
| throws IOException { |
| if (fonts != null) { |
| for (Map.Entry<COSName, COSBase> f : fonts.entrySet()) { |
| String name = f.getKey().getName() + uniqueName; |
| targetPage.getPDFResources().addFont(name, (PDFDictionary)cloneForNewDocument(f.getValue())); |
| } |
| } |
| for (Map.Entry<COSName, COSBase> e : sourcePageResources.getCOSDictionary().entrySet()) { |
| transferDict(e, uniqueName); |
| } |
| } |
| |
| private void transferDict(Map.Entry<COSName, COSBase> dict, String uniqueName) throws IOException { |
| COSBase src; |
| if (dict.getValue() instanceof COSObject) { |
| src = ((COSObject) dict.getValue()).getObject(); |
| } else { |
| src = dict.getValue(); |
| } |
| if (dict.getKey() != COSName.FONT && src instanceof COSDictionary) { |
| String name = dict.getKey().getName(); |
| PDFDictionary newDict = (PDFDictionary) targetPage.getPDFResources().get(name); |
| if (newDict == null) { |
| newDict = new PDFDictionary(targetPage.getPDFResources()); |
| } |
| COSDictionary srcDict = (COSDictionary) src; |
| for (Map.Entry<COSName, COSBase> v : srcDict.entrySet()) { |
| newDict.put(v.getKey().getName() + uniqueName, cloneForNewDocument(v.getValue())); |
| } |
| targetPage.getPDFResources().put(name, newDict); |
| } |
| } |
| |
| private String getNewFont(COSDictionary fontData, FontInfo fontinfo, Collection<String> usedFonts) |
| throws IOException { |
| String base = getUniqueFontName(fontData); |
| if (base == null || usedFonts.contains(base) || (parentFonts != null && parentFonts.contains(base))) { |
| return null; |
| } |
| try { |
| for (Typeface t : fontinfo.getUsedFonts().values()) { |
| if (t instanceof FOPPDFFont && base.equals(t.getFontName())) { |
| return ((FOPPDFFont)t).addFont(fontData); |
| } |
| } |
| if (base.endsWith("cid") || fontData.getItem(COSName.SUBTYPE) != COSName.TYPE1 |
| && fontData.getItem(COSName.SUBTYPE) != COSName.TRUE_TYPE) { |
| fontinfo.addMetrics(base, new FOPPDFMultiByteFont(fontData, base)); |
| } else { |
| fontinfo.addMetrics(base, new FOPPDFSingleByteFont(fontData, base)); |
| } |
| } catch (IOException e) { |
| log.warn(e.getMessage()); |
| return null; |
| } |
| fontinfo.useFont(base); |
| return base; |
| } |
| |
| private void bindOptionalContent(PDDocument sourceDoc) throws IOException { |
| /* |
| * PDOptionalContentProperties ocProperties = |
| * sourceDoc.getDocumentCatalog().getOCProperties(); PDFDictionary ocDictionary = |
| * (PDFDictionary) cloneForNewDocument(ocProperties); if (ocDictionary != null) { |
| * this.pdfDoc.getRoot().put(COSName.OCPROPERTIES.getName(), ocDictionary); } |
| */ |
| } |
| |
| private void handleAcroForm(PDDocument sourceDoc, PDPage page, |
| EventBroadcaster eventBroadcaster, AffineTransform at) throws IOException { |
| PDDocumentCatalog srcCatalog = sourceDoc.getDocumentCatalog(); |
| PDAcroForm srcAcroForm = srcCatalog.getAcroForm(); |
| List pageAnnotations = page.getAnnotations(); |
| if (srcAcroForm == null && pageAnnotations.isEmpty()) { |
| return; |
| } |
| |
| PDRectangle mediaBox = page.findMediaBox(); |
| PDRectangle cropBox = page.findCropBox(); |
| PDRectangle viewBox = cropBox != null ? cropBox : mediaBox; |
| |
| for (Object obj : pageAnnotations) { |
| PDAnnotation annot = (PDAnnotation)obj; |
| PDRectangle rect = annot.getRectangle(); |
| rect.move((float)(at.getTranslateX() - viewBox.getLowerLeftX()), |
| (float)at.getTranslateY() - viewBox.getLowerLeftY()); |
| } |
| |
| //Pseudo-cache the target page in place of the original source page. |
| //This essentially replaces the original page reference with the target page. |
| COSObject cosPage = null; |
| if (page.getCOSObject() instanceof COSObject) { |
| cosPage = (COSObject)page.getCOSObject(); |
| } else { |
| PDPageNode pageNode = page.getParent(); |
| |
| COSArray kids = (COSArray)pageNode.getDictionary().getDictionaryObject(COSName.KIDS); |
| Iterator iter = kids.iterator(); |
| while (iter.hasNext()) { |
| //Hopefully safe to cast, as kids need to be indirect objects |
| COSObject kid = (COSObject)iter.next(); |
| if (kid.getObject() == page.getCOSObject()) { |
| cosPage = kid; |
| break; |
| } |
| } |
| if (cosPage == null) { |
| throw new IOException("Illegal PDF. Page not part of parent page node."); |
| } |
| } |
| cacheClonedObject(cosPage, this.targetPage); |
| |
| COSArray annots = (COSArray) page.getCOSDictionary().getDictionaryObject(COSName.ANNOTS); |
| Set<COSObject> fields = Collections.emptySet(); |
| if (annots != null) { |
| fields = new HashSet(); |
| Iterator iter = annots.iterator(); |
| while (iter.hasNext()) { |
| COSObject annot = (COSObject) iter.next(); |
| COSObject fieldObject = annot; |
| COSDictionary field = (COSDictionary) fieldObject.getObject(); |
| if ("Widget".equals(field.getNameAsString(COSName.SUBTYPE))) { |
| COSObject parent; |
| while ((parent = (COSObject) field.getItem(COSName.PARENT)) != null) { |
| fieldObject = parent; |
| field = (COSDictionary) fieldObject.getObject(); |
| } |
| fields.add(fieldObject); |
| Collection<COSName> exclude = new ArrayList<COSName>(); |
| exclude.add(COSName.P); |
| if (((COSDictionary)annot.getObject()).getItem(COSName.getPDFName("StructParent")) != null) { |
| exclude.add(COSName.PARENT); |
| } |
| PDFObject clonedAnnot = (PDFObject) cloneForNewDocument(annot, annot, exclude); |
| targetPage.addAnnotation(clonedAnnot); |
| } |
| } |
| } |
| |
| boolean formAlreadyCopied = getCachedClone(srcAcroForm) != null; |
| PDFRoot catalog = this.pdfDoc.getRoot(); |
| PDFDictionary destAcroForm = (PDFDictionary)catalog.get(COSName.ACRO_FORM.getName()); |
| if (formAlreadyCopied) { |
| //skip, already copied |
| } else if (destAcroForm == null) { |
| if (srcAcroForm != null) { |
| //With this, only the first PDF's AcroForm is copied over. If later AcroForms have |
| //different properties besides the actual fields, these get lost. Only fields |
| //get merged. |
| Collection exclude = Collections.singletonList(COSName.FIELDS); |
| destAcroForm = (PDFDictionary)cloneForNewDocument(srcAcroForm, srcAcroForm, exclude); |
| } else { |
| //Work-around for incorrectly split PDFs which lack an AcroForm but have widgets |
| //on pages. This doesn't handle the case where field dicts have "C" entries |
| //(for the "CO" entry), so this may produce problems, but we have almost no chance |
| //to guess the calculation order. |
| destAcroForm = new PDFDictionary(pdfDoc.getRoot()); |
| } |
| pdfDoc.registerObject(destAcroForm); |
| catalog.put(COSName.ACRO_FORM.getName(), destAcroForm); |
| } |
| PDFArray clonedFields = (PDFArray) destAcroForm.get(COSName.FIELDS.getName()); |
| if (clonedFields == null) { |
| clonedFields = new PDFArray(); |
| destAcroForm.put(COSName.FIELDS.getName(), clonedFields); |
| } |
| for (COSObject field : fields) { |
| PDFDictionary clone = (PDFDictionary) cloneForNewDocument(field, field, Arrays.asList(COSName.KIDS)); |
| clonedFields.add(clone); |
| } |
| } |
| } |
