You are viewing a plain text version of this content. The canonical link for it is here.
Posted to fop-commits@xmlgraphics.apache.org by rm...@apache.org on 2015/06/12 17:52:56 UTC
svn commit: r1685112 [2/2] - in /xmlgraphics/fop/branches/Temp_PCLSoftFonts:
./ src/java/org/apache/fop/fonts/truetype/
src/java/org/apache/fop/render/java2d/ src/java/org/apache/fop/render/pcl/
src/java/org/apache/fop/render/pcl/fonts/ src/java/org/ap...
Added: xmlgraphics/fop/branches/Temp_PCLSoftFonts/src/java/org/apache/fop/render/pcl/fonts/truetype/PCLTTFFontReader.java
URL: http://svn.apache.org/viewvc/xmlgraphics/fop/branches/Temp_PCLSoftFonts/src/java/org/apache/fop/render/pcl/fonts/truetype/PCLTTFFontReader.java?rev=1685112&view=auto
==============================================================================
--- xmlgraphics/fop/branches/Temp_PCLSoftFonts/src/java/org/apache/fop/render/pcl/fonts/truetype/PCLTTFFontReader.java (added)
+++ xmlgraphics/fop/branches/Temp_PCLSoftFonts/src/java/org/apache/fop/render/pcl/fonts/truetype/PCLTTFFontReader.java Fri Jun 12 15:52:55 2015
@@ -0,0 +1,619 @@
+/*
+ * 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.pcl.fonts.truetype;
+
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.UnsupportedEncodingException;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Map.Entry;
+
+import org.apache.fop.fonts.CustomFont;
+import org.apache.fop.fonts.Typeface;
+import org.apache.fop.fonts.truetype.FontFileReader;
+import org.apache.fop.fonts.truetype.OFDirTabEntry;
+import org.apache.fop.fonts.truetype.OFFontLoader;
+import org.apache.fop.fonts.truetype.OFMtxEntry;
+import org.apache.fop.fonts.truetype.OFTableName;
+import org.apache.fop.fonts.truetype.OpenFont;
+import org.apache.fop.fonts.truetype.TTFFile;
+import org.apache.fop.render.java2d.CustomFontMetricsMapper;
+import org.apache.fop.render.pcl.fonts.PCLByteWriterUtil;
+import org.apache.fop.render.pcl.fonts.PCLFontReader;
+import org.apache.fop.render.pcl.fonts.PCLFontSegment;
+import org.apache.fop.render.pcl.fonts.PCLFontSegment.SegmentID;
+import org.apache.fop.render.pcl.fonts.PCLSymbolSet;
+
+public class PCLTTFFontReader extends PCLFontReader {
+ protected TTFFile ttfFont;
+ protected InputStream fontStream;
+ protected FontFileReader reader;
+ private PCLTTFPCLTFontTable pcltTable;
+ private PCLTTFOS2FontTable os2Table;
+ private PCLTTFPOSTFontTable postTable;
+ private PCLTTFTableFactory ttfTableFactory;
+
+ private static final int HMTX_RESTRICT_SIZE = 50000;
+
+ private static final Map<Integer, Integer> FONT_WEIGHT = new HashMap<Integer, Integer>() {
+ private static final long serialVersionUID = 1L;
+ {
+ put(100, -6); // 100 Thin
+ put(200, -4); // 200 Extra-Light
+ put(300, -3); // 300 Light
+ put(400, 0); // 400 Normal (Regular)
+ put(500, 0); // 500 Medium
+ put(600, 2); // 600 Semi-bold
+ put(700, 3); // 700 Bold
+ put(800, 4); // 800 Extra-bold
+ put(900, 5); // 900 Black (Heavy)
+ }
+ };
+
+ private static final Map<Integer, Integer> FONT_SERIF = new HashMap<Integer, Integer>() {
+ private static final long serialVersionUID = 1L;
+ {
+ /** The following are the best guess conversion between serif styles. Unfortunately
+ * there appears to be no standard and so each specification has it's own set of values.
+ * Please change if better fit found. **/
+ put(0, 0); // Any = Normal Sans
+ put(1, 64); // No Fit = Sans Serif
+ put(2, 9); // Cove = Script Nonconnecting
+ put(3, 12); // Obtuse Cove = Script Broken Letter
+ put(4, 10); // Square Cove = Script Joining
+ put(5, 0); // Obtuse Square Cove = Sans Serif Square
+ put(6, 128); // Square = Serif
+ put(7, 2); // Thin = Serif Line
+ put(8, 7); // Bone = Rounded Bracket
+ put(9, 11); // Exeraggerated = Script Calligraphic
+ put(10, 3); // Triangle = Serif Triangle
+ put(11, 0); // Normal Sans = Sans Serif Square
+ put(12, 4); // Obtuse Sans = Serif Swath
+ put(13, 6); // Perp Sans = Serif Bracket
+ put(14, 8); // Flared = Flair Serif
+ put(15, 1); // Rounded = Sans Serif Round
+ }
+ };
+
+ private static final Map<Integer, Integer> FONT_WIDTH = new HashMap<Integer, Integer>() {
+ private static final long serialVersionUID = 1L;
+ {
+ /** The conversions between TTF and PCL are not 1 to 1 **/
+ put(1, -5); // 1 = Ultra Compressed
+ put(2, -4); // 2 = Extra Compressed
+ put(3, -3); // 3 = Compresses
+ put(4, -2); // 4 = Condensed
+ put(5, 0); // 5 = Normal
+ put(6, 2); // 6 = Expanded
+ put(7, 3); // 5 = Extra Expanded
+ }
+ };
+
+ private int scaleFactor = -1;
+ private PCLSymbolSet symbolSet = PCLSymbolSet.Bound_Generic;
+
+ public PCLTTFFontReader(Typeface font, PCLByteWriterUtil pclByteWriter) throws IOException {
+ super(font, pclByteWriter);
+ loadFont();
+ }
+
+ protected void loadFont() throws IOException {
+ if (typeface instanceof CustomFontMetricsMapper) {
+ CustomFontMetricsMapper fontMetrics = (CustomFontMetricsMapper) typeface;
+ CustomFont customFont = (CustomFont) fontMetrics.getRealFont();
+ fontStream = customFont.getInputStream();
+ reader = new FontFileReader(fontStream);
+
+ ttfFont = new TTFFile();
+ String header = OFFontLoader.readHeader(reader);
+ ttfFont.readFont(reader, header, customFont.getFullName());
+ readFontTables();
+ } else {
+ // TODO - Handle when typeface is not in the expected format for a PCL TrueType object
+ }
+ }
+
+ protected void readFontTables() throws IOException {
+ PCLTTFTable fontTable;
+ fontTable = readFontTable(OFTableName.PCLT);
+ if (fontTable instanceof PCLTTFPCLTFontTable) {
+ pcltTable = (PCLTTFPCLTFontTable) fontTable;
+ }
+ fontTable = readFontTable(OFTableName.OS2);
+ if (fontTable instanceof PCLTTFOS2FontTable) {
+ os2Table = (PCLTTFOS2FontTable) fontTable;
+ }
+ fontTable = readFontTable(OFTableName.POST);
+ if (fontTable instanceof PCLTTFPOSTFontTable) {
+ postTable = (PCLTTFPOSTFontTable) fontTable;
+ }
+ }
+
+ private PCLTTFTable readFontTable(OFTableName tableName) throws IOException {
+ if (ttfFont.seekTab(reader, tableName, 0)) {
+ return getTTFTableFactory().newInstance(tableName);
+ }
+ return null;
+ }
+
+ private PCLTTFTableFactory getTTFTableFactory() {
+ if (ttfTableFactory == null) {
+ ttfTableFactory = PCLTTFTableFactory.getInstance(reader);
+ }
+ return ttfTableFactory;
+ }
+
+ @Override
+ public int getDescriptorSize() {
+ return 72; // Descriptor size (leave at 72 for our purposes)
+ }
+
+ @Override
+ public int getHeaderFormat() {
+ return 15; // TrueType Scalable Font
+ }
+
+ @Override
+ public int getFontType() {
+ if (symbolSet == PCLSymbolSet.Unbound) {
+ return 11; // Font Type - Unbound TrueType Scalable font
+ } else {
+ return 2; // 0-255 (except 0, 7 and 27)
+ }
+ }
+
+ @Override
+ public int getStyleMSB() {
+ if (pcltTable != null) {
+ return getMSB(pcltTable.getStyle());
+ }
+ return 3;
+ }
+
+ @Override
+ public int getBaselinePosition() {
+ return 0; // Baseline position must be set to 0 for TTF fonts
+ }
+
+ @Override
+ public int getCellWidth() {
+ int[] bbox = ttfFont.getBBoxRaw();
+ return bbox[2] - bbox[0];
+ }
+
+ @Override
+ public int getCellHeight() {
+ int[] bbox = ttfFont.getBBoxRaw();
+ return bbox[3] - bbox[1];
+ }
+
+ @Override
+ public int getOrientation() {
+ return 0; // Scalable fonts (TrueType) must be 0
+ }
+
+ @Override
+ public int getSpacing() {
+ if (os2Table != null) {
+ return (os2Table.getPanose()[4] == 9) ? 0 : 1;
+ } else if (postTable != null) {
+ return postTable.getIsFixedPitch();
+ }
+ return 1;
+ }
+
+ @Override
+ public int getSymbolSet() {
+ if (pcltTable != null) {
+ return pcltTable.getSymbolSet();
+ } else {
+ return symbolSet.getKind1();
+ }
+ }
+
+ @Override
+ public int getPitch() {
+ int pitch = ttfFont.getCharWidthRaw(0x20);
+ if (pitch < 0) {
+ // No advance width found for the space character
+ return 0;
+ }
+ return pitch;
+ }
+
+ @Override
+ public int getHeight() {
+ return 0; // Fixed zero value for TrueType fonts
+ }
+
+ @Override
+ public int getXHeight() {
+ if (pcltTable != null) {
+ return pcltTable.getXHeight();
+ } else if (os2Table != null) {
+ return os2Table.getXHeight();
+ }
+ return 0;
+ }
+
+ @Override
+ public int getWidthType() {
+ if (pcltTable != null) {
+ return pcltTable.getWidthType();
+ } else if (os2Table != null) {
+ return convertTTFWidthClass(os2Table.getWidthClass());
+ }
+ return 0;
+ }
+
+ private int convertTTFWidthClass(int widthClass) {
+ if (FONT_WIDTH.containsKey(widthClass)) {
+ return FONT_WIDTH.get(widthClass);
+ } else {
+ return 0; // No match - return normal
+ }
+ }
+
+ @Override
+ public int getStyleLSB() {
+ if (pcltTable != null) {
+ return getLSB(pcltTable.getStyle());
+ }
+ return 224;
+ }
+
+ @Override
+ public int getStrokeWeight() {
+ if (pcltTable != null) {
+ return pcltTable.getStrokeWeight();
+ } else if (os2Table != null) {
+ return convertTTFWeightClass(os2Table.getWeightClass());
+ }
+ return 0;
+ }
+
+ private int convertTTFWeightClass(int weightClass) {
+ if (FONT_WEIGHT.containsKey(weightClass)) {
+ return FONT_WEIGHT.get(weightClass);
+ } else {
+ return 0; // No match - return normal
+ }
+ }
+
+ @Override
+ public int getTypefaceLSB() {
+ if (pcltTable != null) {
+ return getLSB(pcltTable.getTypeFamily());
+ }
+ return 254;
+ }
+
+ @Override
+ public int getTypefaceMSB() {
+ if (pcltTable != null) {
+ return getMSB(pcltTable.getTypeFamily());
+ }
+ return 0;
+ }
+
+ @Override
+ public int getSerifStyle() {
+ if (pcltTable != null) {
+ return pcltTable.getSerifStyle();
+ } else {
+ return convertFromTTFSerifStyle();
+ }
+ }
+
+ private int convertFromTTFSerifStyle() {
+ if (os2Table != null) {
+ int serifStyle = os2Table.getPanose()[1];
+ return FONT_SERIF.get(serifStyle);
+ }
+ return 0;
+ }
+
+ @Override
+ public int getQuality() {
+ return 2; // Letter quality
+ }
+
+ @Override
+ public int getPlacement() {
+ return 0; // Fixed value of 0 for TrueType (scalable fonts)
+ }
+
+ @Override
+ public int getUnderlinePosition() {
+ return 0; // Scalable fonts has a fixed value of 0 - See Master Underline Position
+ }
+
+ @Override
+ public int getUnderlineThickness() {
+ return 0; // Scalable fonts has a fixed value of 0 - See Master Underline Thickness
+ }
+
+ @Override
+ public int getTextHeight() {
+ return 2048;
+ }
+
+ @Override
+ public int getTextWidth() {
+ if (os2Table != null) {
+ return os2Table.getAvgCharWidth();
+ }
+ return 0;
+ }
+
+ @Override
+ public int getFirstCode() {
+ return 32;
+ }
+
+ @Override
+ public int getLastCode() {
+ return 255; // Bound font with a maximum of 255 characters
+ }
+
+ @Override
+ public int getPitchExtended() {
+ return 0; // Zero for Scalable fonts
+ }
+
+ @Override
+ public int getHeightExtended() {
+ return 0; // Zero for Scalable fonts
+ }
+
+ @Override
+ public int getCapHeight() {
+ if (pcltTable != null) {
+ return pcltTable.getStrokeWeight();
+ } else if (os2Table != null) {
+ return os2Table.getCapHeight();
+ }
+ return 0;
+ }
+
+ @Override
+ public int getFontNumber() {
+ if (pcltTable != null) {
+ return (int) pcltTable.getFontNumber();
+ }
+ return 0;
+ }
+
+ @Override
+ public String getFontName() {
+ if (pcltTable != null) {
+ return pcltTable.getTypeface();
+ } else {
+ return ttfFont.getFullName();
+ }
+ }
+
+ @Override
+ public int getScaleFactor() throws IOException {
+ if (scaleFactor == -1) {
+ OFTableName headTag = OFTableName.HEAD;
+ if (ttfFont.seekTab(reader, headTag, 0)) {
+ reader.readTTFLong(); // Version
+ reader.readTTFLong(); // Font revision
+ reader.readTTFLong(); // Check sum adjustment
+ reader.readTTFLong(); // Magic number
+ reader.readTTFShort(); // Flags
+ scaleFactor = reader.readTTFUShort(); // Units per em
+ return scaleFactor;
+ }
+ } else {
+ return scaleFactor;
+ }
+ return 0;
+ }
+
+ @Override
+ public int getMasterUnderlinePosition() throws IOException {
+ return (int) Math.round(getScaleFactor() * 0.2);
+ }
+
+ @Override
+ public int getMasterUnderlineThickness() throws IOException {
+ return (int) Math.round(getScaleFactor() * 0.05);
+ }
+
+ @Override
+ public int getFontScalingTechnology() {
+ return 1; // TrueType scalable font
+ }
+
+ @Override
+ public int getVariety() {
+ return 0; // TrueType fonts must be set to zero
+ }
+
+ public List<PCLFontSegment> getFontSegments() throws IOException {
+ List<PCLFontSegment> fontSegments = new ArrayList<PCLFontSegment>();
+ fontSegments.add(new PCLFontSegment(SegmentID.CC, getCharacterComplement()));
+ fontSegments.add(new PCLFontSegment(SegmentID.PA, pclByteWriter.toByteArray(os2Table.getPanose())));
+ fontSegments.add(new PCLFontSegment(SegmentID.GT, getGlobalTrueTypeData()));
+ fontSegments.add(new PCLFontSegment(SegmentID.CP, ttfFont.getCopyrightNotice().getBytes("US-ASCII")));
+ fontSegments.add(new PCLFontSegment(SegmentID.NULL, new byte[0]));
+ return fontSegments;
+ }
+
+ /**
+ * See Font Header Format 11-35 (Character Complement Array) in the PCL 5 Specification. Defined as an array of 8
+ * bytes specific to certain character sets. In this case specifying 0 for all values (default complement) means the
+ * font is compatible with any character sets. '110' on least significant bits signifies unicode. See specification
+ * for further customization.
+ */
+ private byte[] getCharacterComplement() {
+ byte[] ccUnicode = new byte[8];
+ ccUnicode[7] = 6;
+ return ccUnicode;
+ }
+
+ private byte[] getGlobalTrueTypeData() throws IOException {
+ ByteArrayOutputStream baos = new ByteArrayOutputStream();
+ Map<OFDirTabEntry, Integer> tableOffsets = new HashMap<OFDirTabEntry, Integer>();
+ // Version
+ baos.write(pclByteWriter.unsignedInt(1)); // Major
+ baos.write(pclByteWriter.unsignedInt(0)); // Minor
+ int numTables = 5; // head, hhea, hmtx, maxp and gdir
+ // Optional Hint Tables
+ OFDirTabEntry headTable = ttfFont.getDirectoryEntry(OFTableName.CVT);
+ if (headTable != null) {
+ numTables++;
+ }
+ OFDirTabEntry fpgmTable = ttfFont.getDirectoryEntry(OFTableName.FPGM);
+ if (fpgmTable != null) {
+ numTables++;
+ }
+ OFDirTabEntry prepTable = ttfFont.getDirectoryEntry(OFTableName.PREP);
+ if (prepTable != null) {
+ numTables++;
+ }
+ baos.write(pclByteWriter.unsignedInt(numTables)); // numTables
+ int maxPowerNumTables = pclByteWriter.maxPower2(numTables);
+ int searchRange = maxPowerNumTables * 16;
+ baos.write(pclByteWriter.unsignedInt(searchRange));
+ baos.write(pclByteWriter.unsignedInt(pclByteWriter.log(maxPowerNumTables, 2))); // Entry Selector
+ baos.write(pclByteWriter.unsignedInt(numTables * 16 - searchRange)); // Range shift
+
+ // Add default data tables
+ writeTrueTypeTable(baos, OFTableName.HEAD, tableOffsets);
+ writeTrueTypeTable(baos, OFTableName.HHEA, tableOffsets);
+ writeTrueTypeTable(baos, OFTableName.HMTX, tableOffsets);
+ writeTrueTypeTable(baos, OFTableName.MAXP, tableOffsets);
+
+ // Write the blank GDIR directory which is built in memory on the printer
+ writeGDIR(baos);
+
+ // Add optional data tables (for hints)
+ writeTrueTypeTable(baos, OFTableName.CVT, tableOffsets);
+ writeTrueTypeTable(baos, OFTableName.FPGM, tableOffsets);
+ writeTrueTypeTable(baos, OFTableName.PREP, tableOffsets);
+
+ baos = copyTables(tableOffsets, baos);
+
+ return baos.toByteArray();
+ }
+
+ private void writeTrueTypeTable(ByteArrayOutputStream baos, OFTableName table,
+ Map<OFDirTabEntry, Integer> tableOffsets) throws IOException, UnsupportedEncodingException {
+ OFDirTabEntry tabEntry = ttfFont.getDirectoryEntry(table);
+ if (tabEntry != null) {
+ baos.write(tabEntry.getTag());
+ baos.write(pclByteWriter.unsignedLongInt(tabEntry.getChecksum()));
+ tableOffsets.put(tabEntry, baos.size());
+ baos.write(pclByteWriter.unsignedLongInt(0)); // Offset to be set later
+ long length = (tabEntry.getLength() > HMTX_RESTRICT_SIZE)
+ ? HMTX_RESTRICT_SIZE
+ : tabEntry.getLength();
+ baos.write(pclByteWriter.unsignedLongInt(length));
+ }
+ }
+
+ private void writeGDIR(ByteArrayOutputStream baos) throws UnsupportedEncodingException, IOException {
+ baos.write("gdir".getBytes("ISO-8859-1"));
+ baos.write(pclByteWriter.unsignedLongInt(0)); // Checksum
+ baos.write(pclByteWriter.unsignedLongInt(0)); // Offset
+ baos.write(pclByteWriter.unsignedLongInt(0)); // Length
+ }
+
+ private ByteArrayOutputStream copyTables(Map<OFDirTabEntry, Integer> tableOffsets, ByteArrayOutputStream baos)
+ throws IOException {
+ Map<Integer, byte[]> offsetValues = new HashMap<Integer, byte[]>();
+ //for (OFDirTabEntry table : tableOffsets.keySet()) {
+ for (Entry<OFDirTabEntry, Integer> table : tableOffsets.entrySet()) {
+ byte[] tableData = reader.getBytes((int) table.getKey().getOffset(), (int) table.getKey().getLength());
+ if (tableData.length > HMTX_RESTRICT_SIZE) {
+ byte[] truncated = new byte[HMTX_RESTRICT_SIZE];
+ System.arraycopy(tableData, 0, truncated, 0, HMTX_RESTRICT_SIZE);
+ tableData = truncated;
+ }
+ // Update the offset in the table directory
+ offsetValues.put(table.getValue(), pclByteWriter.unsignedLongInt(baos.size()));
+ // Write the table data to the end of the TrueType segment output
+ baos.write(tableData);
+ }
+ baos = updateOffsets(baos, offsetValues);
+ return baos;
+ }
+
+ private ByteArrayOutputStream updateOffsets(ByteArrayOutputStream baos, Map<Integer, byte[]> offsets)
+ throws IOException {
+ byte[] softFont = baos.toByteArray();
+ for (int offset : offsets.keySet()) {
+ pclByteWriter.updateDataAtLocation(softFont, offsets.get(offset), offset);
+ }
+ baos = new ByteArrayOutputStream();
+ baos.write(softFont);
+ return baos;
+ }
+
+ @Override
+ public Map<Integer, int[]> getCharacterOffsets() throws IOException {
+ List<OFMtxEntry> mtx = ttfFont.getMtx();
+ OFTableName glyfTag = OFTableName.GLYF;
+ Map<Integer, int[]> charOffsets = new HashMap<Integer, int[]>();
+ OFDirTabEntry tabEntry = ttfFont.getDirectoryEntry(glyfTag);
+ if (ttfFont.seekTab(reader, glyfTag, 0)) {
+ for (int i = 1; i < mtx.size(); i++) {
+ OFMtxEntry entry = mtx.get(i);
+ OFMtxEntry nextEntry;
+ int nextOffset = 0;
+ int charCode = 0;
+ if (entry.getUnicodeIndex().size() > 0) {
+ charCode = (Integer) entry.getUnicodeIndex().get(0);
+ } else {
+ charCode = entry.getIndex();
+ }
+
+ if (i < mtx.size() - 1) {
+ nextEntry = mtx.get(i + 1);
+ nextOffset = (int) nextEntry.getOffset();
+ } else {
+ nextOffset = (int) ttfFont.getLastGlyfLocation();
+ }
+ int glyphOffset = (int) entry.getOffset();
+ int glyphLength = nextOffset - glyphOffset;
+
+ charOffsets.put(charCode, new int[]{(int) tabEntry.getOffset() + glyphOffset, glyphLength});
+ }
+ }
+ return charOffsets;
+ }
+
+ @Override
+ public OpenFont getFontFile() {
+ return ttfFont;
+ }
+
+ @Override
+ public FontFileReader getFontFileReader() {
+ return reader;
+ }
+}
Added: xmlgraphics/fop/branches/Temp_PCLSoftFonts/src/java/org/apache/fop/render/pcl/fonts/truetype/PCLTTFOS2FontTable.java
URL: http://svn.apache.org/viewvc/xmlgraphics/fop/branches/Temp_PCLSoftFonts/src/java/org/apache/fop/render/pcl/fonts/truetype/PCLTTFOS2FontTable.java?rev=1685112&view=auto
==============================================================================
--- xmlgraphics/fop/branches/Temp_PCLSoftFonts/src/java/org/apache/fop/render/pcl/fonts/truetype/PCLTTFOS2FontTable.java (added)
+++ xmlgraphics/fop/branches/Temp_PCLSoftFonts/src/java/org/apache/fop/render/pcl/fonts/truetype/PCLTTFOS2FontTable.java Fri Jun 12 15:52:55 2015
@@ -0,0 +1,77 @@
+/*
+ * 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.pcl.fonts.truetype;
+
+import java.io.IOException;
+
+import org.apache.fop.fonts.truetype.FontFileReader;
+
+public class PCLTTFOS2FontTable extends PCLTTFTable {
+ private int avgCharWidth;
+ private int xHeight;
+ private int widthClass;
+ private int weightClass;
+ private int capHeight;
+ private int[] panose = new int[10];
+
+ public PCLTTFOS2FontTable(FontFileReader in) throws IOException {
+ super(in);
+ int version = reader.readTTFUShort(); // Version
+ avgCharWidth = reader.readTTFShort();
+ weightClass = reader.readTTFShort();
+ widthClass = reader.readTTFShort();
+ skipShort(reader, 12);
+ for (int i = 0; i < 10; i++) {
+ panose[i] = reader.readTTFByte();
+ }
+ skipLong(reader, 4);
+ skipByte(reader, 4);
+ skipShort(reader, 8);
+ if (version >= 2) {
+ skipLong(reader, 2);
+ xHeight = reader.readTTFShort();
+ capHeight = reader.readTTFShort();
+ }
+ }
+
+ public int getAvgCharWidth() {
+ return avgCharWidth;
+ }
+
+ public int getXHeight() {
+ return xHeight;
+ }
+
+ public int getWidthClass() {
+ return widthClass;
+ }
+
+ public int getWeightClass() {
+ return weightClass;
+ }
+
+ public int getCapHeight() {
+ return capHeight;
+ }
+
+ public int[] getPanose() {
+ return panose;
+ }
+}
Added: xmlgraphics/fop/branches/Temp_PCLSoftFonts/src/java/org/apache/fop/render/pcl/fonts/truetype/PCLTTFPCLTFontTable.java
URL: http://svn.apache.org/viewvc/xmlgraphics/fop/branches/Temp_PCLSoftFonts/src/java/org/apache/fop/render/pcl/fonts/truetype/PCLTTFPCLTFontTable.java?rev=1685112&view=auto
==============================================================================
--- xmlgraphics/fop/branches/Temp_PCLSoftFonts/src/java/org/apache/fop/render/pcl/fonts/truetype/PCLTTFPCLTFontTable.java (added)
+++ xmlgraphics/fop/branches/Temp_PCLSoftFonts/src/java/org/apache/fop/render/pcl/fonts/truetype/PCLTTFPCLTFontTable.java Fri Jun 12 15:52:55 2015
@@ -0,0 +1,115 @@
+/*
+ * 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.pcl.fonts.truetype;
+
+import java.io.IOException;
+
+import org.apache.fop.fonts.truetype.FontFileReader;
+
+public class PCLTTFPCLTFontTable extends PCLTTFTable {
+ private long version;
+ private long fontNumber;
+ private int pitch;
+ private int xHeight;
+ private int style;
+ private int typeFamily;
+ private int capHeight;
+ private int symbolSet;
+ private String typeface;
+ private String characterComplement;
+ private String filename;
+ private int strokeWeight;
+ private int widthType;
+ private int serifStyle;
+
+ public PCLTTFPCLTFontTable(FontFileReader in) throws IOException {
+ super(in);
+ version = reader.readTTFULong();
+ fontNumber = reader.readTTFULong();
+ pitch = reader.readTTFUShort();
+ xHeight = reader.readTTFUShort();
+ style = reader.readTTFUShort();
+ typeFamily = reader.readTTFUShort();
+ capHeight = reader.readTTFUShort();
+ symbolSet = reader.readTTFUShort();
+ typeface = reader.readTTFString(16);
+ characterComplement = reader.readTTFString(8);
+ filename = reader.readTTFString(6);
+ strokeWeight = reader.readTTFUShort();
+ widthType = reader.readTTFUShort();
+ serifStyle = reader.readTTFUByte();
+ }
+
+ public long getVersion() {
+ return version;
+ }
+
+ public long getFontNumber() {
+ return fontNumber;
+ }
+
+ public int getPitch() {
+ return pitch;
+ }
+
+ public int getXHeight() {
+ return xHeight;
+ }
+
+ public int getStyle() {
+ return style;
+ }
+
+ public int getTypeFamily() {
+ return typeFamily;
+ }
+
+ public int getCapHeight() {
+ return capHeight;
+ }
+
+ public int getSymbolSet() {
+ return symbolSet;
+ }
+
+ public String getTypeface() {
+ return typeface;
+ }
+
+ public String getCharacterComplement() {
+ return characterComplement;
+ }
+
+ public String getFilename() {
+ return filename;
+ }
+
+ public int getStrokeWeight() {
+ return strokeWeight;
+ }
+
+ public int getWidthType() {
+ return widthType;
+ }
+
+ public int getSerifStyle() {
+ return serifStyle;
+ }
+}
Added: xmlgraphics/fop/branches/Temp_PCLSoftFonts/src/java/org/apache/fop/render/pcl/fonts/truetype/PCLTTFPOSTFontTable.java
URL: http://svn.apache.org/viewvc/xmlgraphics/fop/branches/Temp_PCLSoftFonts/src/java/org/apache/fop/render/pcl/fonts/truetype/PCLTTFPOSTFontTable.java?rev=1685112&view=auto
==============================================================================
--- xmlgraphics/fop/branches/Temp_PCLSoftFonts/src/java/org/apache/fop/render/pcl/fonts/truetype/PCLTTFPOSTFontTable.java (added)
+++ xmlgraphics/fop/branches/Temp_PCLSoftFonts/src/java/org/apache/fop/render/pcl/fonts/truetype/PCLTTFPOSTFontTable.java Fri Jun 12 15:52:55 2015
@@ -0,0 +1,51 @@
+/*
+ * 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.pcl.fonts.truetype;
+
+import java.io.IOException;
+
+import org.apache.fop.fonts.truetype.FontFileReader;
+
+public class PCLTTFPOSTFontTable extends PCLTTFTable {
+ private int underlinePosition;
+ private int underlineThickness;
+ private int isFixedPitch;
+
+ public PCLTTFPOSTFontTable(FontFileReader in) throws IOException {
+ super(in);
+ reader.readTTFLong(); // Version
+ reader.readTTFLong(); // Italic Angle
+ underlinePosition = reader.readTTFShort();
+ underlineThickness = reader.readTTFShort();
+ isFixedPitch = (int) reader.readTTFULong();
+ }
+
+ public int getUnderlinePosition() {
+ return underlinePosition;
+ }
+
+ public int getUnderlineThickness() {
+ return underlineThickness;
+ }
+
+ public int getIsFixedPitch() {
+ return isFixedPitch;
+ }
+}
Added: xmlgraphics/fop/branches/Temp_PCLSoftFonts/src/java/org/apache/fop/render/pcl/fonts/truetype/PCLTTFTable.java
URL: http://svn.apache.org/viewvc/xmlgraphics/fop/branches/Temp_PCLSoftFonts/src/java/org/apache/fop/render/pcl/fonts/truetype/PCLTTFTable.java?rev=1685112&view=auto
==============================================================================
--- xmlgraphics/fop/branches/Temp_PCLSoftFonts/src/java/org/apache/fop/render/pcl/fonts/truetype/PCLTTFTable.java (added)
+++ xmlgraphics/fop/branches/Temp_PCLSoftFonts/src/java/org/apache/fop/render/pcl/fonts/truetype/PCLTTFTable.java Fri Jun 12 15:52:55 2015
@@ -0,0 +1,47 @@
+/*
+ * 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.pcl.fonts.truetype;
+
+import java.io.IOException;
+
+import org.apache.fop.fonts.truetype.FontFileReader;
+
+public class PCLTTFTable {
+ protected FontFileReader reader;
+
+ public PCLTTFTable(FontFileReader reader) {
+ this.reader = reader;
+ }
+
+ protected void skipShort(FontFileReader reader, int skips)
+ throws IOException {
+ reader.skip(skips * 2);
+ }
+
+ protected void skipLong(FontFileReader reader, int skips)
+ throws IOException {
+ reader.skip(skips * 4);
+ }
+
+ protected void skipByte(FontFileReader reader, int skips)
+ throws IOException {
+ reader.skip(skips);
+ }
+}
Added: xmlgraphics/fop/branches/Temp_PCLSoftFonts/src/java/org/apache/fop/render/pcl/fonts/truetype/PCLTTFTableFactory.java
URL: http://svn.apache.org/viewvc/xmlgraphics/fop/branches/Temp_PCLSoftFonts/src/java/org/apache/fop/render/pcl/fonts/truetype/PCLTTFTableFactory.java?rev=1685112&view=auto
==============================================================================
--- xmlgraphics/fop/branches/Temp_PCLSoftFonts/src/java/org/apache/fop/render/pcl/fonts/truetype/PCLTTFTableFactory.java (added)
+++ xmlgraphics/fop/branches/Temp_PCLSoftFonts/src/java/org/apache/fop/render/pcl/fonts/truetype/PCLTTFTableFactory.java Fri Jun 12 15:52:55 2015
@@ -0,0 +1,49 @@
+/*
+ * 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.pcl.fonts.truetype;
+
+import java.io.IOException;
+
+import org.apache.fop.fonts.truetype.FontFileReader;
+import org.apache.fop.fonts.truetype.OFTableName;
+
+public final class PCLTTFTableFactory {
+ private FontFileReader reader;
+
+ private PCLTTFTableFactory(FontFileReader reader) {
+ this.reader = reader;
+ }
+
+ public static PCLTTFTableFactory getInstance(FontFileReader reader) {
+ return new PCLTTFTableFactory(reader);
+ }
+
+ public PCLTTFTable newInstance(OFTableName tableName)
+ throws IOException {
+ if (tableName == OFTableName.PCLT) {
+ return new PCLTTFPCLTFontTable(reader);
+ } else if (tableName == OFTableName.OS2) {
+ return new PCLTTFOS2FontTable(reader);
+ } else if (tableName == OFTableName.POST) {
+ return new PCLTTFPOSTFontTable(reader);
+ }
+ return null;
+ }
+}
Added: xmlgraphics/fop/branches/Temp_PCLSoftFonts/test/java/org/apache/fop/render/pcl/fonts/MockPCLTTFFontReader.java
URL: http://svn.apache.org/viewvc/xmlgraphics/fop/branches/Temp_PCLSoftFonts/test/java/org/apache/fop/render/pcl/fonts/MockPCLTTFFontReader.java?rev=1685112&view=auto
==============================================================================
--- xmlgraphics/fop/branches/Temp_PCLSoftFonts/test/java/org/apache/fop/render/pcl/fonts/MockPCLTTFFontReader.java (added)
+++ xmlgraphics/fop/branches/Temp_PCLSoftFonts/test/java/org/apache/fop/render/pcl/fonts/MockPCLTTFFontReader.java Fri Jun 12 15:52:55 2015
@@ -0,0 +1,51 @@
+/*
+ * 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.pcl.fonts;
+
+import java.io.IOException;
+
+import org.apache.fop.fonts.CustomFont;
+import org.apache.fop.fonts.Typeface;
+import org.apache.fop.fonts.truetype.FontFileReader;
+import org.apache.fop.fonts.truetype.TTFFile;
+import org.apache.fop.render.java2d.CustomFontMetricsMapper;
+import org.apache.fop.render.pcl.fonts.truetype.PCLTTFFontReader;
+
+public class MockPCLTTFFontReader extends PCLTTFFontReader {
+
+ public MockPCLTTFFontReader(Typeface font, PCLByteWriterUtil pclByteWriter) throws IOException {
+ super(font, pclByteWriter);
+ }
+
+ @Override
+ protected void loadFont() throws IOException {
+ if (typeface instanceof CustomFontMetricsMapper) {
+ CustomFontMetricsMapper fontMetrics = (CustomFontMetricsMapper) typeface;
+ CustomFont customFont = (CustomFont) fontMetrics.getRealFont();
+ fontStream = customFont.getInputStream();
+ reader = new FontFileReader(fontStream);
+
+ ttfFont = new TTFFile();
+ ttfFont.readFont(reader, customFont.getFullName());
+ readFontTables();
+ } else {
+ // TODO - Handle when typeface is not in the expected format for a PCL TrueType object
+ }
+ }
+}
Added: xmlgraphics/fop/branches/Temp_PCLSoftFonts/test/java/org/apache/fop/render/pcl/fonts/PCLByteWriterUtilTestCase.java
URL: http://svn.apache.org/viewvc/xmlgraphics/fop/branches/Temp_PCLSoftFonts/test/java/org/apache/fop/render/pcl/fonts/PCLByteWriterUtilTestCase.java?rev=1685112&view=auto
==============================================================================
--- xmlgraphics/fop/branches/Temp_PCLSoftFonts/test/java/org/apache/fop/render/pcl/fonts/PCLByteWriterUtilTestCase.java (added)
+++ xmlgraphics/fop/branches/Temp_PCLSoftFonts/test/java/org/apache/fop/render/pcl/fonts/PCLByteWriterUtilTestCase.java Fri Jun 12 15:52:55 2015
@@ -0,0 +1,74 @@
+/*
+ * 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.pcl.fonts;
+
+import java.io.IOException;
+
+import org.junit.Before;
+import org.junit.Test;
+
+import static org.junit.Assert.assertArrayEquals;
+
+public class PCLByteWriterUtilTestCase {
+ private PCLByteWriterUtil byteWriter;
+
+ @Before
+ public void setUp() {
+ byteWriter = new PCLByteWriterUtil();
+ }
+
+ @Test
+ public void testWriteMethods() throws IOException {
+ byte[] output = byteWriter.writeCommand("(s4X");
+ // 27 = PCL escape character with rest in ASCII format
+ byte[] command = {27, 40, 115, 52, 88};
+ assertArrayEquals(command, output);
+
+ byte[] resultB = byteWriter.unsignedLongInt(102494);
+ byte[] compareB = {0, 1, -112, 94};
+ assertArrayEquals(compareB, resultB);
+
+ byte[] resultC = byteWriter.unsignedInt(1024);
+ byte[] compareC = {4, 0};
+ assertArrayEquals(compareC, resultC);
+ }
+
+ @Test
+ public void testUtilMethods() throws IOException {
+ byte[] anArray = {1, 2, 3, 4, 5, 9, 10};
+ byte[] insertArray = {6, 7, 8};
+ byte[] result = byteWriter.insertIntoArray(5, anArray, insertArray);
+ byte[] compareA = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
+ assertArrayEquals(compareA, result);
+
+ byte[] reverse = {10, 9, 8, 7, 6};
+ byteWriter.updateDataAtLocation(compareA, reverse, 5);
+ byte[] compareB = {1, 2, 3, 4, 5, 10, 9, 8, 7, 6};
+ assertArrayEquals(compareB, compareA);
+
+ byte[] anArrayC = {1, 2, 3, 4, 5};
+ byte[] resultC = byteWriter.padBytes(anArrayC, 10);
+ byte[] compareC = {1, 2, 3, 4, 5, 0, 0, 0, 0, 0};
+ assertArrayEquals(compareC, resultC);
+
+ byte[] resultD = byteWriter.padBytes(anArrayC, 10, 1);
+ byte[] compareD = {1, 2, 3, 4, 5, 1, 1, 1, 1, 1};
+ assertArrayEquals(compareD, resultD);
+ }
+}
Added: xmlgraphics/fop/branches/Temp_PCLSoftFonts/test/java/org/apache/fop/render/pcl/fonts/PCLFontReaderFactoryTestCase.java
URL: http://svn.apache.org/viewvc/xmlgraphics/fop/branches/Temp_PCLSoftFonts/test/java/org/apache/fop/render/pcl/fonts/PCLFontReaderFactoryTestCase.java?rev=1685112&view=auto
==============================================================================
--- xmlgraphics/fop/branches/Temp_PCLSoftFonts/test/java/org/apache/fop/render/pcl/fonts/PCLFontReaderFactoryTestCase.java (added)
+++ xmlgraphics/fop/branches/Temp_PCLSoftFonts/test/java/org/apache/fop/render/pcl/fonts/PCLFontReaderFactoryTestCase.java Fri Jun 12 15:52:55 2015
@@ -0,0 +1,52 @@
+/*
+ * 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.pcl.fonts;
+
+import java.io.File;
+import java.io.FileInputStream;
+import java.net.URI;
+
+import org.junit.Test;
+
+import static org.junit.Assert.assertTrue;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+
+import org.apache.fop.fonts.CustomFont;
+import org.apache.fop.fonts.FontType;
+import org.apache.fop.render.java2d.CustomFontMetricsMapper;
+import org.apache.fop.render.pcl.fonts.truetype.PCLTTFFontReader;
+
+public class PCLFontReaderFactoryTestCase {
+ private static final String TEST_FONT_TTF = "./test/resources/fonts/ttf/DejaVuLGCSerif.ttf";
+
+ @Test
+ public void verifyTypeIdentification() throws Exception {
+ CustomFont sbFont = mock(CustomFont.class);
+ when(sbFont.getInputStream()).thenReturn(new FileInputStream(new File(TEST_FONT_TTF)));
+ when(sbFont.getEmbedFileURI()).thenReturn(new URI(TEST_FONT_TTF));
+ CustomFontMetricsMapper customFont = new CustomFontMetricsMapper(sbFont);
+ when(customFont.getFontType()).thenReturn(FontType.TRUETYPE);
+ // Have to mock the input stream twice otherwise get a Stream is closed exception
+ when(((CustomFont) customFont.getRealFont()).getInputStream()).thenReturn(
+ new FileInputStream(new File(TEST_FONT_TTF)));
+ PCLFontReaderFactory fontReaderFactory = PCLFontReaderFactory.getInstance(null);
+ assertTrue(fontReaderFactory.createInstance(customFont) instanceof PCLTTFFontReader);
+ }
+}
Added: xmlgraphics/fop/branches/Temp_PCLSoftFonts/test/java/org/apache/fop/render/pcl/fonts/PCLTTFFontReaderTestCase.java
URL: http://svn.apache.org/viewvc/xmlgraphics/fop/branches/Temp_PCLSoftFonts/test/java/org/apache/fop/render/pcl/fonts/PCLTTFFontReaderTestCase.java?rev=1685112&view=auto
==============================================================================
--- xmlgraphics/fop/branches/Temp_PCLSoftFonts/test/java/org/apache/fop/render/pcl/fonts/PCLTTFFontReaderTestCase.java (added)
+++ xmlgraphics/fop/branches/Temp_PCLSoftFonts/test/java/org/apache/fop/render/pcl/fonts/PCLTTFFontReaderTestCase.java Fri Jun 12 15:52:55 2015
@@ -0,0 +1,120 @@
+/*
+ * 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.pcl.fonts;
+
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.IOException;
+import java.util.List;
+import java.util.Map;
+
+import org.junit.Before;
+import org.junit.Test;
+
+import static org.junit.Assert.assertArrayEquals;
+import static org.junit.Assert.assertEquals;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+
+import org.apache.fop.fonts.CustomFont;
+import org.apache.fop.render.java2d.CustomFontMetricsMapper;
+import org.apache.fop.render.pcl.fonts.PCLFontSegment.SegmentID;
+import org.apache.fop.render.pcl.fonts.truetype.PCLTTFFontReader;
+
+public class PCLTTFFontReaderTestCase {
+
+ private CustomFontMetricsMapper customFont = mock(CustomFontMetricsMapper.class);
+ private PCLByteWriterUtil byteWriter;
+ private static final String TEST_FONT_A = "./test/resources/fonts/ttf/DejaVuLGCSerif.ttf";
+
+ @Before
+ public void setUp() {
+ byteWriter = new PCLByteWriterUtil();
+ }
+
+ @Test
+ public void verifyFontAData() throws Exception {
+ CustomFont sbFont = mock(CustomFont.class);
+ when(sbFont.getInputStream()).thenReturn(new FileInputStream(new File(TEST_FONT_A)));
+ when(customFont.getRealFont()).thenReturn(sbFont);
+ PCLTTFFontReader reader = new MockPCLTTFFontReader(customFont, byteWriter);
+ verifyFontData(reader);
+ validateOffsets(reader);
+ validateFontSegments(reader);
+ }
+
+ /**
+ * Compares the input font data against a sample of the data read and calculated by the reader. The assertions are
+ * made against data taken from the TrueType Font Analyzer tool.
+ * @param reader The reader
+ */
+ private void verifyFontData(PCLTTFFontReader reader) {
+ assertEquals(reader.getCellWidth(), 5015); // Bounding box X2 - X1
+ assertEquals(reader.getCellHeight(), 3254); // Bounding box Y2 - Y1
+ assertEquals(reader.getCapHeight(), 0); // OS2Table.capHeight
+ assertEquals(reader.getFontName(), "DejaVu LGC Serif"); // Full name read by TTFFont object
+ assertEquals(reader.getFirstCode(), 32); // Always 32 for bound font
+ assertEquals(reader.getLastCode(), 255); // Always 255 for bound font
+
+ // Values that require conversion tables (See PCLTTFFontReader.java)
+ assertEquals(reader.getStrokeWeight(), 0); // Weight Class 400 (regular) should be equivalent 0
+ assertEquals(reader.getSerifStyle(), 128); // Serif Style 0 should equal 0
+ assertEquals(reader.getWidthType(), 0); // Width Class 5 (regular) should be equivalent 0
+ }
+
+ private void validateOffsets(PCLTTFFontReader reader) throws IOException {
+ // Offsets are stored with their character ID with the array [offset, length]
+ Map<Integer, int[]> offsets = reader.getCharacterOffsets();
+
+ // Test data
+ int[] charC = {27644, 144}; // Char index = 99
+ int[] charDollar = {16044, 264}; // Char index = 36
+ int[] charOne = {17808, 176}; // Char index = 49
+ int[] charUpperD = {21236, 148}; // Char index = 68
+ int[] charUpperJ = {22140, 176}; // Char index = 74
+
+ assertArrayEquals(offsets.get(99), charC);
+ assertArrayEquals(offsets.get(36), charDollar);
+ assertArrayEquals(offsets.get(49), charOne);
+ assertArrayEquals(offsets.get(68), charUpperD);
+ assertArrayEquals(offsets.get(74), charUpperJ);
+ }
+
+ /**
+ * Verifies the font segment data copied originally from the TrueType font. Data was verified using TrueType Font
+ * Analyzer and PCLParaphernalia tool.
+ * @param reader The reader
+ * @throws IOException
+ */
+ private void validateFontSegments(PCLTTFFontReader reader) throws IOException {
+ List<PCLFontSegment> segments = reader.getFontSegments();
+ assertEquals(segments.size(), 5);
+ for (PCLFontSegment segment : segments) {
+ if (segment.getIdentifier() == SegmentID.PA) {
+ // Panose
+ assertEquals(segment.getData().length, 10);
+ byte[] panose = {2, 6, 6, 3, 5, 6, 5, 2, 2, 4};
+ assertArrayEquals(segment.getData(), panose);
+ } else if (segment.getIdentifier() == SegmentID.NULL) {
+ // Terminating segment
+ assertEquals(segment.getData().length, 0);
+ }
+ }
+ }
+}
Added: xmlgraphics/fop/branches/Temp_PCLSoftFonts/test/java/org/apache/fop/render/pcl/fonts/truetype/PCLTTFCharacterWriterTestCase.java
URL: http://svn.apache.org/viewvc/xmlgraphics/fop/branches/Temp_PCLSoftFonts/test/java/org/apache/fop/render/pcl/fonts/truetype/PCLTTFCharacterWriterTestCase.java?rev=1685112&view=auto
==============================================================================
--- xmlgraphics/fop/branches/Temp_PCLSoftFonts/test/java/org/apache/fop/render/pcl/fonts/truetype/PCLTTFCharacterWriterTestCase.java (added)
+++ xmlgraphics/fop/branches/Temp_PCLSoftFonts/test/java/org/apache/fop/render/pcl/fonts/truetype/PCLTTFCharacterWriterTestCase.java Fri Jun 12 15:52:55 2015
@@ -0,0 +1,76 @@
+/*
+ * 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.pcl.fonts.truetype;
+
+import java.io.File;
+import java.io.FileInputStream;
+
+import org.junit.Test;
+
+import static org.junit.Assert.assertArrayEquals;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+
+import org.apache.fop.fonts.CustomFont;
+import org.apache.fop.fonts.truetype.FontFileReader;
+import org.apache.fop.fonts.truetype.OFFontLoader;
+import org.apache.fop.fonts.truetype.TTFFile;
+import org.apache.fop.render.java2d.CustomFontMetricsMapper;
+import org.apache.fop.render.pcl.fonts.PCLByteWriterUtil;
+import org.apache.fop.render.pcl.fonts.PCLSoftFont;
+
+public class PCLTTFCharacterWriterTestCase {
+
+ private PCLTTFCharacterWriter characterWriter;
+ private PCLSoftFont softFont;
+ private CustomFontMetricsMapper customFont = mock(CustomFontMetricsMapper.class);
+ private static final String TEST_FONT_A = "./test/resources/fonts/ttf/DejaVuLGCSerif.ttf";
+
+ @Test
+ public void verifyCharacterDefinition() throws Exception {
+ CustomFont sbFont = mock(CustomFont.class);
+ when(customFont.getRealFont()).thenReturn(sbFont);
+ softFont = new PCLSoftFont(1, customFont);
+ TTFFile openFont = new TTFFile();
+ FontFileReader reader = new FontFileReader(new FileInputStream(new File(TEST_FONT_A)));
+ String header = OFFontLoader.readHeader(reader);
+ openFont.readFont(reader, header);
+ softFont.setOpenFont(openFont);
+ softFont.setReader(reader);
+
+ characterWriter = new PCLTTFCharacterWriter(softFont);
+ byte[] charDefinition = characterWriter.writeCharacterDefinitions("f");
+ PCLByteWriterUtil pclByteWriter = new PCLByteWriterUtil();
+ // Character command
+ byte[] command = pclByteWriter.writeCommand(String.format("*c%dE", 32));
+ assertArrayEquals(getBytes(charDefinition, 0, 6), command);
+ // Character definition command
+ byte[] charDefCommand = pclByteWriter.writeCommand(String.format("(s%dW", 210));
+ assertArrayEquals(getBytes(charDefinition, 6, 7), charDefCommand);
+ }
+
+ private byte[] getBytes(byte[] byteArray, int offset, int length) {
+ byte[] result = new byte[length];
+ int count = 0;
+ for (int i = offset; i < offset + length; i++) {
+ result[count++] = byteArray[i];
+ }
+ return result;
+ }
+}
---------------------------------------------------------------------
To unsubscribe, e-mail: fop-commits-unsubscribe@xmlgraphics.apache.org
For additional commands, e-mail: fop-commits-help@xmlgraphics.apache.org