org.apache.fop.render.pdf.pdfbox.FOPPDFSingleByteFont Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of fop-pdf-images Show documentation
Show all versions of fop-pdf-images Show documentation
Apache FOP PDF Images plug-in extends FOP in order to add support for using PDF images in fo:external-graphic elements when generating PDF files.
/*
* 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.
*/
package org.apache.fop.render.pdf.pdfbox;
import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.TreeMap;
import org.apache.fontbox.cff.CFFType1Font;
import org.apache.fontbox.cmap.CMap;
import org.apache.fontbox.ttf.CmapSubtable;
import org.apache.fontbox.ttf.TrueTypeFont;
import org.apache.pdfbox.cos.COSArray;
import org.apache.pdfbox.cos.COSBase;
import org.apache.pdfbox.cos.COSDictionary;
import org.apache.pdfbox.cos.COSName;
import org.apache.pdfbox.cos.COSNumber;
import org.apache.pdfbox.pdmodel.common.PDStream;
import org.apache.pdfbox.pdmodel.font.PDFont;
import org.apache.pdfbox.pdmodel.font.PDFontDescriptor;
import org.apache.pdfbox.pdmodel.font.PDTrueTypeFont;
import org.apache.pdfbox.pdmodel.font.PDType1CFont;
import org.apache.pdfbox.pdmodel.font.PDType1Font;
import org.apache.pdfbox.pdmodel.font.encoding.BuiltInEncoding;
import org.apache.pdfbox.pdmodel.font.encoding.Encoding;
import org.apache.fop.fonts.EmbeddingMode;
import org.apache.fop.fonts.FontType;
import org.apache.fop.fonts.SingleByteEncoding;
import org.apache.fop.fonts.SingleByteFont;
import org.apache.fop.pdf.PDFDictionary;
import org.apache.fop.pdf.PDFText;
public class FOPPDFSingleByteFont extends SingleByteFont implements FOPPDFFont {
private int fontCount;
private FontContainer font;
protected PDFDictionary ref;
protected Map charMapGlobal = new LinkedHashMap();
private Map newWidth = new HashMap();
private Map charStringsDict;
private List newCmap = new ArrayList();
private Map encodingMap = new TreeMap();
private int encodingSkip;
private MergeFonts mergeFonts;
private String shortFontName;
private final Map fontMap = new HashMap();
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());
shortFontName = MergeFontsPDFWriter.getName(font.font.getName());
loadFontFile(font);
float[] bBoxF = font.getBoundingBox();
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();
FOPPDFMultiByteFont.setProperties(this, font.font);
if (font.getWidths() != null) {
//if width contains 0 we cant rely on codeToNameMap
boolean usesZero = font.getWidths().contains(0);
Set codeToName = getCodeToName(font.getEncoding()).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());
newWidth.put(i, w);
} else {
newWidth.put(i, 0);
}
}
}
mapping = new FOPPDFEncoding();
encodingSkip = font.getLastChar() + 1;
addEncoding(font);
}
private Map getCodeToName(Encoding encoding) {
Map codeToName = new HashMap();
if (encoding != null) {
COSBase cos = null;
if (!(encoding instanceof BuiltInEncoding)) {
cos = encoding.getCOSObject();
}
if (cos instanceof COSDictionary) {
COSDictionary enc = (COSDictionary) cos;
COSName baseEncodingName = (COSName) enc.getDictionaryObject(COSName.BASE_ENCODING);
if (baseEncodingName != null) {
Encoding baseEncoding = Encoding.getInstance(baseEncodingName);
codeToName.putAll(baseEncoding.getCodeToNameMap());
}
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(FontContainer font) throws IOException {
if (font.getEncoding() != null) {
return font.getEncoding();
}
if (font.getToUnicodeCMap() == null) {
throw new IOException("No cmap found in " + font.font.getName());
}
return font.getToUnicodeCMap();
}
private PDStream readFontFile(PDFont font) throws IOException {
PDFontDescriptor fd = 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.getName() + " no font file");
}
return ff;
}
private void loadFontFile(FontContainer font) throws IOException {
PDStream ff = readFontFile(font.font);
mergeFontFile(ff.createInputStream(), font);
if (font.font instanceof PDTrueTypeFont) {
TrueTypeFont ttfont = ((PDTrueTypeFont) font.font).getTrueTypeFont();
CmapSubtable[] cmapList = ttfont.getCmap().getCmaps();
for (CmapSubtable c : cmapList) {
MergeTTFonts.Cmap tempCmap = getNewCmap(c.getPlatformId(), c.getPlatformEncodingId());
for (int i = 0; i < 256 * 256; i++) {
int gid = c.getGlyphId(i);
if (gid != 0) {
tempCmap.glyphIdToCharacterCode.put(i, gid);
}
}
}
FOPPDFMultiByteFont.mergeMaxp(ttfont, ((MergeTTFonts)mergeFonts).maxp);
}
}
private MergeTTFonts.Cmap getNewCmap(int platformID, int platformEncodingID) {
for (MergeTTFonts.Cmap cmap : newCmap) {
if (cmap.platformId == platformID && cmap.platformEncodingId == platformEncodingID) {
return cmap;
}
}
MergeTTFonts.Cmap cmap = new MergeTTFonts.Cmap(platformID, platformEncodingID);
newCmap.add(cmap);
return cmap;
}
@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() {
return shortFontName;
}
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 {
FontContainer font = getFont(fontData);
if ((font.font instanceof PDType1Font || font.font instanceof PDType1CFont) && differentGlyphData(font.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 getCharStringsDict(PDFont font) throws IOException {
if (font instanceof PDType1Font) {
return ((PDType1Font)font).getType1Font().getCharStringsDict();
}
CFFType1Font cffFont = ((PDType1CFont) font).getCFFType1Font();
List bytes = cffFont.getCharStringBytes();
Map map = new HashMap();
for (int i = 0; i < bytes.size(); i++) {
map.put(cffFont.getCharset().getNameForGID(i), bytes.get(i));
}
return map;
}
private boolean differentGlyphData(PDFont otherFont) throws IOException {
if (charStringsDict == null) {
charStringsDict = getCharStringsDict(font.font);
}
Map otherFontMap = getCharStringsDict(otherFont);
for (Map.Entry s : otherFontMap.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(FontContainer font) throws IOException {
int w = 0;
int skipGlyphIndex = getLastChar() + 1;
Object cmap = getCmap(font);
Set codeToName = getCodeToName(font.getEncoding()).keySet();
for (int i = font.getFirstChar(); i <= font.getLastChar(); i++) {
boolean addedWidth = false;
int glyphIndexPos = skipGlyphIndex;
if (font.font instanceof PDTrueTypeFont) {
glyphIndexPos = i;
}
int neww = 0;
if (font.getWidths() != null) {
neww = font.getWidths().get(i - font.getFirstChar());
if (!newWidth.containsKey(i) || newWidth.get(i) == 0) {
if (getFontType() == FontType.TYPE1
|| font.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;
return c.toUnicode(i);
}
Encoding enc = (Encoding)cmap;
return enc.getName(i);
}
public String getEncodingName() {
return font.getBaseEncodingName();
}
private void addEncoding(FontContainer fontForEnc) {
List added = new ArrayList(encodingMap.values());
Map codeToName = getCodeToName(fontForEnc.getEncoding());
for (int i = fontForEnc.getFirstChar(); i <= fontForEnc.getLastChar(); i++) {
if (codeToName.keySet().contains(i)) {
String s = codeToName.get(i);
if (!added.contains(s) || !encodingMap.containsKey(i)) {
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 v = encodingMap.values();
return v.toArray(new String[v.size()]);
}
public char[] getUnicodeCharMap() {
if (cmap) {
if (font.getToUnicode() == null) {
return new char[0];
}
List cmapStrings = new ArrayList();
Map cm = new HashMap();
for (Map.Entry 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 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 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, FontContainer pdFont) throws IOException {
if (mergeFonts == null) {
if (getFontType() == FontType.TRUETYPE) {
mergeFonts = new MergeTTFonts(newCmap);
} else if (getFontType() == FontType.TYPE1) {
mergeFonts = new MergeType1Fonts();
} else {
mergeFonts = new MergeCFFFonts();
}
}
Map chars = new HashMap();
chars.put(0, 0);
mergeFonts.readFont(ff, shortFontName, pdFont, chars, false);
fontCount++;
}
public InputStream getInputStream() throws IOException {
return new ByteArrayInputStream(mergeFonts.getMergedFontSubset());
}
protected FontContainer getFont(COSDictionary fontData) throws IOException {
if (!fontMap.containsKey(fontData)) {
if (fontMap.size() > 10) {
fontMap.clear();
}
fontMap.put(fontData, new FontContainer(fontData));
}
return fontMap.get(fontData);
}
public String getMappedWord(List word, byte[] bytes, FontContainer oldFont) {
StringBuffer newOct = new StringBuffer();
int i = 0;
for (String str : word) {
Integer mapped = getMapping(bytes[i], oldFont);
if (mapped == null) {
char c = str.charAt(0);
if (str.length() > 1) {
c = (char) str.hashCode();
}
if (hasChar(c)) {
mapped = (int)mapChar(c);
} else {
return null;
}
}
PDFText.escapeStringChar((char)mapped.intValue(), newOct);
i++;
}
return "(" + newOct.toString() + ")";
}
private Integer getMapping(byte i, FontContainer oldFont) {
if (oldFont.getEncoding() != null) {
String name = oldFont.getEncoding().getName(i);
if (!name.equals(".notdef") && charMapGlobal.containsKey(name)) {
return charMapGlobal.get(name);
}
}
return null;
}
}
© 2015 - 2025 Weber Informatics LLC | Privacy Policy