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 2014/05/23 17:05:20 UTC
svn commit: r1597112 [2/2] - in /xmlgraphics/fop/trunk:
src/java/org/apache/fop/fonts/ src/java/org/apache/fop/fonts/truetype/
src/java/org/apache/fop/fonts/type1/ src/java/org/apache/fop/pdf/
src/java/org/apache/fop/render/ps/ test/java/org/apache/fop...
Added: xmlgraphics/fop/trunk/test/java/org/apache/fop/fonts/type1/PostscriptParserTestCase.java
URL: http://svn.apache.org/viewvc/xmlgraphics/fop/trunk/test/java/org/apache/fop/fonts/type1/PostscriptParserTestCase.java?rev=1597112&view=auto
==============================================================================
--- xmlgraphics/fop/trunk/test/java/org/apache/fop/fonts/type1/PostscriptParserTestCase.java (added)
+++ xmlgraphics/fop/trunk/test/java/org/apache/fop/fonts/type1/PostscriptParserTestCase.java Fri May 23 15:05:19 2014
@@ -0,0 +1,93 @@
+/*
+ * 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.fonts.type1;
+
+import java.io.IOException;
+import java.util.List;
+
+import org.junit.Before;
+import org.junit.Test;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+
+import org.apache.fop.fonts.type1.PostscriptParser.PSDictionary;
+import org.apache.fop.fonts.type1.PostscriptParser.PSElement;
+import org.apache.fop.fonts.type1.PostscriptParser.PSFixedArray;
+import org.apache.fop.fonts.type1.PostscriptParser.PSSubroutine;
+import org.apache.fop.fonts.type1.PostscriptParser.PSVariable;
+import org.apache.fop.fonts.type1.PostscriptParser.PSVariableArray;
+
+public class PostscriptParserTestCase {
+ private PostscriptParser parser;
+ private String eol = new String(new byte[] {13});
+ private String postscriptElements =
+ "/myVariable 100 def" + eol
+ + "/-| {def} executeonly def" + eol
+ + "/myFixedArray 6 array" + eol
+ + "0 1 5 {1 index exch /.notdef put } for" + eol
+ + "dup 1 /a put" + eol
+ + "dup 2 /b put" + eol
+ + "dup 3 /c put" + eol
+ + "dup 4 /d put" + eol
+ + "readonly def" + eol
+ + "/myVariableArray [ { this } { is } { a } { test } ] no access def" + eol
+ + "/refVarSubr myValue -|";
+
+ @Before
+ public void setUp() {
+ parser = new PostscriptParser();
+ }
+
+ /**
+ * Tests parsing an example Postscript document and verifying what
+ * has been read.
+ * @throws IOException
+ */
+ @Test
+ public void testPostscriptParsing() throws IOException {
+ List<PSElement> elements = parser.parse(postscriptElements.getBytes());
+ assertEquals(elements.size(), 5);
+ assertTrue(elements.get(0) instanceof PSVariable);
+ assertTrue(elements.get(2) instanceof PSFixedArray);
+ assertTrue(elements.get(3) instanceof PSVariableArray);
+ PSFixedArray fixedArray = (PSFixedArray)elements.get(2);
+ assertEquals(fixedArray.getEntries().size(), 4);
+ assertEquals(fixedArray.getEntries().get(2), "dup 2 /b put ");
+ PSVariableArray variableArray = (PSVariableArray)elements.get(3);
+ assertEquals(variableArray.getEntries().size(), 4);
+ /* Currently only variable arrays containing subroutines are supported, though
+ * this can be modified to support single values and also strip out unnecessary
+ * characters like the { } below. */
+ assertEquals(variableArray.getEntries().get(0).trim(), "{ this }");
+ }
+
+ /**
+ * Tests that the correct element is returned given the operator and element ID provided
+ */
+ @Test
+ public void testCreateElement() {
+ assertTrue(parser.createElement("/custDictionary", "dict", -1) instanceof PSDictionary);
+ assertEquals(parser.createElement("/Private", "dict", -1), null);
+ assertTrue(parser.createElement("/aFixedArray", "array", -1) instanceof PSFixedArray);
+ assertTrue(parser.createElement("/aVariableArray", "[", -1) instanceof PSVariableArray);
+ assertTrue(parser.createElement("/aSubroutine", "{", -1) instanceof PSSubroutine);
+ }
+}
Added: xmlgraphics/fop/trunk/test/java/org/apache/fop/fonts/type1/Type1SubsetFileTestCase.java
URL: http://svn.apache.org/viewvc/xmlgraphics/fop/trunk/test/java/org/apache/fop/fonts/type1/Type1SubsetFileTestCase.java?rev=1597112&view=auto
==============================================================================
--- xmlgraphics/fop/trunk/test/java/org/apache/fop/fonts/type1/Type1SubsetFileTestCase.java (added)
+++ xmlgraphics/fop/trunk/test/java/org/apache/fop/fonts/type1/Type1SubsetFileTestCase.java Fri May 23 15:05:19 2014
@@ -0,0 +1,348 @@
+/*
+ * 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.fonts.type1;
+
+import java.io.ByteArrayInputStream;
+import java.io.ByteArrayOutputStream;
+import java.io.FileInputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.net.URI;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+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.xmlgraphics.fonts.Glyphs;
+
+import org.apache.fop.fonts.SingleByteFont;
+import org.apache.fop.fonts.type1.PostscriptParser.PSDictionary;
+import org.apache.fop.fonts.type1.PostscriptParser.PSElement;
+import org.apache.fop.fonts.type1.PostscriptParser.PSFixedArray;
+import org.apache.fop.fonts.type1.Type1SubsetFile.BinaryCoder;
+import org.apache.fop.fonts.type1.Type1SubsetFile.BytesNumber;
+
+public class Type1SubsetFileTestCase {
+
+ private List<byte[]> decodedSections;
+ private static final String TEST_FONT_A = "./test/resources/fonts/type1/c0419bt_.pfb";
+
+ @Test
+ public void test() throws IOException {
+ InputStream in = new FileInputStream(TEST_FONT_A);
+ compareCharStringData(in, TEST_FONT_A, createFontASubset(in, TEST_FONT_A));
+ }
+
+ @Test
+ public void testStitchFont() throws IOException {
+ ByteArrayOutputStream baosHeader = new ByteArrayOutputStream();
+ ByteArrayOutputStream baosMain = new ByteArrayOutputStream();
+ ByteArrayOutputStream baosTrailer = new ByteArrayOutputStream();
+
+ //Header
+ for (int i = 0; i < 10; i++) {
+ baosHeader.write(123);
+ baosMain.write(123);
+ }
+ for (int i = 0; i < 10; i++) {
+ baosTrailer.write(0);
+ }
+
+ Type1SubsetFile subset = new Type1SubsetFile();
+ byte[] result = subset.stitchFont(baosHeader, baosMain, baosTrailer);
+ ByteArrayInputStream bais = new ByteArrayInputStream(result);
+ assertEquals(result.length, 50);
+ PFBParser parser = new PFBParser();
+ parser.parsePFB(bais);
+ }
+
+ @Test
+ public void testUpdateSectionSize() throws IOException {
+ Type1SubsetFile subset = new Type1SubsetFile();
+ ByteArrayOutputStream baos = subset.updateSectionSize(456);
+ byte[] lowOrderSize = baos.toByteArray();
+ assertEquals(lowOrderSize[0], -56);
+ assertEquals(lowOrderSize[1], 1);
+ }
+
+ @Test
+ public void testVariableContents() {
+ Type1SubsetFile subset = new Type1SubsetFile();
+ String result = subset.readVariableContents("/myvariable {some variable contents}");
+ assertEquals(result, "some variable contents");
+ result = subset.readVariableContents("/myvariable {hello {some more text {test} and some more}test}");
+ //Should only reads one level deep
+ assertEquals(result, "hello test");
+ }
+
+ @Test
+ public void getOpPositionAndLength() {
+ Type1SubsetFile subset = new Type1SubsetFile();
+ ArrayList<BytesNumber> ops = new ArrayList<BytesNumber>();
+ ops.add(new BytesNumber(10, 1));
+ ops.add(new BytesNumber(255, 2));
+ ops.add(new BytesNumber(100, 1));
+ ops.add(new BytesNumber(97, 1));
+ ops.add(new BytesNumber(856, 2));
+ assertEquals(subset.getOpPosition(4, ops), 4);
+ assertEquals(subset.getOperandsLength(ops), 7);
+ }
+
+ @Test
+ public void testConcatArrays() {
+ byte[] arrayA = {(byte)1, (byte)2, (byte)3, (byte)4, (byte)5};
+ byte[] arrayB = {(byte)6, (byte)7, (byte)8, (byte)9, (byte)10};
+ Type1SubsetFile subset = new Type1SubsetFile();
+ byte[] concatArray = subset.concatArray(arrayA, arrayB);
+ assertEquals(concatArray.length, 10);
+ assertEquals(concatArray[5], 6);
+ assertEquals(concatArray[3], 4);
+ }
+
+ @Test
+ public void testGetBinaryEntry() {
+ byte[] decoded = {(byte)34, (byte)23, (byte)78, (byte)55, (byte)12,
+ (byte)2, (byte)65, (byte)49, (byte)90, (byte)10};
+ int[] section = {3, 7};
+ Type1SubsetFile subset = new Type1SubsetFile();
+ byte[] segment = subset.getBinaryEntry(section, decoded);
+ assertEquals(segment.length, 4);
+ assertEquals(segment[0], 55);
+ assertEquals(segment[3], 65);
+ }
+
+ private void compareCharStringData(InputStream in, String font, byte[] subsetFont)
+ throws IOException {
+ decodedSections = new ArrayList<byte[]>();
+
+ //Reinitialise the input stream as reset only supports 1000 bytes.
+ in = new FileInputStream(font);
+ List<PSElement> origElements = parseElements(in);
+ List<PSElement> subsetElements = parseElements(new ByteArrayInputStream(subsetFont));
+
+ PSFixedArray origSubs = (PSFixedArray)findElement(origElements, "/Subrs");
+ PSFixedArray subsetSubs = (PSFixedArray)findElement(subsetElements, "/Subrs");
+ PSDictionary origCharStrings = (PSDictionary)findElement(origElements, "/CharStrings");
+ PSDictionary subsetCharStrings = (PSDictionary)findElement(subsetElements, "/CharStrings");
+ for (String element : subsetCharStrings.getEntries().keySet()) {
+ if (element.equals("/.notdef")) {
+ continue;
+ }
+ int[] origBinaryCharLocation = origCharStrings.getBinaryEntries().get(element);
+ int[] subsetBinaryCharLocation = subsetCharStrings.getBinaryEntries().get(element);
+
+ int origLength = origBinaryCharLocation[1] - origBinaryCharLocation[0];
+ int subsetLength = subsetBinaryCharLocation[1] - subsetBinaryCharLocation[0];
+ byte[] origCharData = new byte[origLength];
+ byte[] subsetCharData = new byte[subsetLength];
+ System.arraycopy(decodedSections.get(0), origBinaryCharLocation[0], origCharData, 0, origLength);
+ System.arraycopy(decodedSections.get(1), subsetBinaryCharLocation[0], subsetCharData, 0, subsetLength);
+ origCharData = BinaryCoder.decodeBytes(origCharData, 4330, 4);
+ subsetCharData = BinaryCoder.decodeBytes(subsetCharData, 4330, 4);
+ byte[] origFullCharData = readFullCharString(decodedSections.get(0), origCharData, origSubs);
+ byte[] subsetFullCharData = readFullCharString(decodedSections.get(1), subsetCharData, subsetSubs);
+ assertArrayEquals(origFullCharData, subsetFullCharData);
+ }
+ }
+
+ private byte[] createFontASubset(InputStream in, String font) throws IOException {
+ SingleByteFont sbfont = mock(SingleByteFont.class);
+ //Glyph index & selector
+ Map<Integer, Integer> glyphs = new HashMap<Integer, Integer>();
+ //Selector & unicode
+ Map<Integer, Character> usedCharsIndex = new HashMap<Integer, Character>();
+ Map<Integer, String> usedCharNames = new HashMap<Integer, String>();
+ int count = 0;
+ for (int i = 32; i < 127; i++) {
+ glyphs.put(i, count++);
+ when(sbfont.getUnicodeFromSelector(count)).thenReturn((char)i);
+ usedCharNames.put(i, String.format("/%s", Glyphs.charToGlyphName((char)i)));
+ when(sbfont.getGlyphName(i)).thenReturn(AdobeStandardEncoding.getCharFromCodePoint(i));
+ }
+ for (int i = 161; i < 204; i++) {
+ glyphs.put(i, count++);
+ usedCharsIndex.put(count, (char)i);
+ when(sbfont.getUnicodeFromSelector(count)).thenReturn((char)i);
+ usedCharNames.put(i, String.format("/%s", Glyphs.charToGlyphName((char)i)));
+ when(sbfont.getGlyphName(i)).thenReturn(AdobeStandardEncoding.getCharFromCodePoint(i));
+ }
+ int[] randomGlyphs = {205, 206, 207, 208, 225, 227, 232, 233, 234, 235, 241, 245,
+ 248, 249, 250, 251
+ };
+ for (int i = 0; i < randomGlyphs.length; i++) {
+ glyphs.put(randomGlyphs[i], count++);
+ usedCharsIndex.put(count, (char)randomGlyphs[i]);
+ when(sbfont.getUnicodeFromSelector(count)).thenReturn((char)randomGlyphs[i]);
+ usedCharNames.put(i, String.format("/%s", Glyphs.charToGlyphName((char)i)));
+ when(sbfont.getGlyphName(i)).thenReturn(AdobeStandardEncoding.getCharFromCodePoint(i));
+ }
+ for (int i = 256; i < 335; i++) {
+ glyphs.put(i, count++);
+ usedCharsIndex.put(count, (char)i);
+ when(sbfont.getUnicodeFromSelector(count)).thenReturn((char)i);
+ usedCharNames.put(i, String.format("/%s", Glyphs.charToGlyphName((char)i)));
+ when(sbfont.getGlyphName(i)).thenReturn(AdobeStandardEncoding.getCharFromCodePoint(i));
+ }
+ when(sbfont.getUsedGlyphNames()).thenReturn(usedCharNames);
+ when(sbfont.getUsedGlyphs()).thenReturn(glyphs);
+ when(sbfont.getEmbedFileURI()).thenReturn(URI.create(font));
+ Type1SubsetFile subset = new Type1SubsetFile();
+ return subset.createSubset(in, sbfont, "AAAAAA");
+ }
+
+ private List<PSElement> parseElements(InputStream in)
+ throws IOException {
+ PFBParser pfbParser = new PFBParser();
+ PFBData origData = pfbParser.parsePFB(in);
+ PostscriptParser parser = new PostscriptParser();
+ byte[] decoded = BinaryCoder.decodeBytes(origData.getEncryptedSegment(), 55665, 4);
+ decodedSections.add(decoded);
+ return parser.parse(decoded);
+ }
+
+ private PSElement findElement(List<PSElement> elements, String operator) {
+ for (PSElement element : elements) {
+ if (element.getOperator().equals(operator)) {
+ return element;
+ }
+ }
+ return null;
+ }
+
+ private byte[] readFullCharString(byte[] decoded, byte[] data, PSFixedArray subroutines) {
+ List<BytesNumber> operands = new ArrayList<BytesNumber>();
+ List<BytesNumber> fullList = new ArrayList<BytesNumber>();
+ for (int i = 0; i < data.length; i++) {
+ int cur = data[i] & 0xFF;
+ if (cur >= 0 && cur <= 31) {
+ //Found subroutine. Read subroutine, recursively scan and update references
+ if (cur == 10) {
+ if (operands.size() == 0) {
+ continue;
+ }
+ int[] subrData = subroutines.getBinaryEntryByIndex(operands.get(0).getNumber());
+ byte[] subroutine = getBinaryEntry(subrData, decoded);
+ subroutine = BinaryCoder.decodeBytes(subroutine, 4330, 4);
+ subroutine = readFullCharString(decoded, subroutine, subroutines);
+ data = replaceReference(data, subroutine, i - 1 + operands.get(0).getNumBytes(), i);
+ } else {
+ int next = -1;
+ if (cur == 12) {
+ next = data[++i] & 0xFF;
+ }
+ BytesNumber operand = new BytesNumber(cur, i);
+ operand.setName(getName(cur, next));
+ fullList.add(operand);
+ }
+ operands.clear();
+ }
+ if (cur >= 32 && cur <= 246) {
+ operands.add(new BytesNumber(cur - 139, 1));
+ fullList.add(operands.get(operands.size() - 1));
+ } else if (cur >= 247 && cur <= 250) {
+ operands.add(new BytesNumber((cur - 247) * 256 + (data[i + 1] & 0xFF) + 108, 2));
+ fullList.add(operands.get(operands.size() - 1));
+ i++;
+ } else if (cur >= 251 && cur <= 254) {
+ operands.add(new BytesNumber(-(cur - 251) * 256 - (data[i + 1] & 0xFF) - 108, 2));
+ fullList.add(operands.get(operands.size() - 1));
+ i++;
+ } else if (cur == 255) {
+ int b1 = data[i + 1] & 0xFF;
+ int b2 = data[i + 2] & 0xFF;
+ int b3 = data[i + 3] & 0xFF;
+ int b4 = data[i + 4] & 0xFF;
+ int value = b1 << 24 | b2 << 16 | b3 << 8 | b4;
+ operands.add(new BytesNumber(value, 5));
+ fullList.add(operands.get(operands.size() - 1));
+ i += 4;
+ }
+ }
+ return data;
+ }
+
+ private String getName(int operator, int next) {
+ switch (operator) {
+ case 14: return "endchar";
+ case 13: return "hsbw";
+ case 12:
+ switch (next) {
+ case 0: return "dotsection";
+ case 1: return "vstem3";
+ case 2: return "hstem3";
+ case 6: return "seac";
+ case 7: return "sbw";
+ case 16: return "callothersubr";
+ case 17: return "pop";
+ case 33: return "setcurrentpoint";
+ default: return "unknown";
+ }
+ case 9: return "closepath";
+ case 6: return "hlineto";
+ case 22: return "hmoveto";
+ case 31: return "hvcurveto";
+ case 5: return "rlineto";
+ case 21: return "rmoveto";
+ case 8: return "rrcurveto";
+ case 30: return "vhcurveto";
+ case 7: return "vlineto";
+ case 4: return "vmoveto";
+ case 1: return "hstem";
+ case 3: return "vstem";
+ case 10: return "callsubr";
+ case 11: return "return";
+ default: return "unknown";
+ }
+ }
+
+ private byte[] replaceReference(byte[] data, byte[] subroutine, int startRef, int endRef) {
+ byte[] preBytes = new byte[startRef - 1];
+ System.arraycopy(data, 0, preBytes, 0, startRef - 1);
+ byte[] postBytes = new byte[data.length - endRef - 1];
+ System.arraycopy(data, endRef + 1, postBytes, 0, data.length - endRef - 1);
+ data = concatArray(preBytes, subroutine, 1);
+ data = concatArray(data, postBytes, 0);
+ return data;
+ }
+
+ private byte[] getBinaryEntry(int[] position, byte[] decoded) {
+ int start = position[0];
+ int finish = position[1];
+ byte[] line = new byte[finish - start];
+ System.arraycopy(decoded, start, line, 0, finish - start);
+ return line;
+ }
+
+ private byte[] concatArray(byte[] a, byte[] b, int subtract) {
+ int aLen = a.length;
+ int bLen = b.length - subtract;
+ byte[] c = new byte[aLen + bLen];
+ System.arraycopy(a, 0, c, 0, aLen);
+ System.arraycopy(b, 0, c, aLen, bLen);
+ return c;
+ }
+}
Added: xmlgraphics/fop/trunk/test/resources/fonts/type1/c0419bt_.afm
URL: http://svn.apache.org/viewvc/xmlgraphics/fop/trunk/test/resources/fonts/type1/c0419bt_.afm?rev=1597112&view=auto
==============================================================================
--- xmlgraphics/fop/trunk/test/resources/fonts/type1/c0419bt_.afm (added)
+++ xmlgraphics/fop/trunk/test/resources/fonts/type1/c0419bt_.afm Fri May 23 15:05:19 2014
@@ -0,0 +1,264 @@
+StartFontMetrics 2.0
+Comment Bitstream AFM Data
+Comment Copyright 1987-1990 as an unpublished work by Bitstream Inc., Cambridge, MA.
+Comment All rights reserved
+Comment Confidential and proprietary to Bitstream Inc.
+Comment Bitstream is a registered trademark of Bitstream Inc.
+Comment bitsClassification Fixed Pitch 810
+Comment bitsFontID 0419
+Comment bitsManufacturingDate Mon Nov 5 16:16:55 1990
+Comment bitsLayoutName clayout.adobe.text228.new
+Comment UniqueID 15530419
+FontName Courier10PitchBT-Roman
+FullName Courier 10 Pitch
+FamilyName Courier 10 Pitch
+Weight Normal
+ItalicAngle 0.00
+IsFixedPitch true
+FontBBox -44 -299 664 858
+UnderlinePosition -97
+UnderlineThickness 82
+Version 1.0 [UFO]
+Notice Copyright 1987-1990 as an unpublished work by Bitstream Inc. All rights reserved. Confidential.
+EncodingScheme AdobeStandardEncoding
+CapHeight 579
+XHeight 452
+Ascender 639
+Descender -195
+StartCharMetrics 228
+C 32 ; WX 602 ; N space ; B 0 0 0 0 ;
+C 33 ; WX 602 ; N exclam ; B 210 -11 392 613 ;
+C 34 ; WX 602 ; N quotedbl ; B 154 337 448 579 ;
+C 35 ; WX 602 ; N numbersign ; B 105 -58 497 674 ;
+C 36 ; WX 602 ; N dollar ; B 98 -122 498 666 ;
+C 37 ; WX 602 ; N percent ; B 101 -2 501 618 ;
+C 38 ; WX 602 ; N ampersand ; B 88 -11 501 547 ;
+C 39 ; WX 602 ; N quoteright ; B 215 317 396 579 ;
+C 40 ; WX 602 ; N parenleft ; B 201 -196 401 597 ;
+C 41 ; WX 602 ; N parenright ; B 201 -196 400 597 ;
+C 42 ; WX 602 ; N asterisk ; B 103 201 499 579 ;
+C 43 ; WX 602 ; N plus ; B 48 49 553 566 ;
+C 44 ; WX 602 ; N comma ; B 178 -157 399 163 ;
+C 45 ; WX 602 ; N hyphen ; B 76 178 526 273 ;
+C 46 ; WX 602 ; N period ; B 204 -7 397 167 ;
+C 47 ; WX 602 ; N slash ; B 114 -55 503 699 ;
+C 48 ; WX 602 ; N zero ; B 101 -17 501 632 ;
+C 49 ; WX 602 ; N one ; B 126 0 499 630 ;
+C 50 ; WX 602 ; N two ; B 80 0 487 633 ;
+C 51 ; WX 602 ; N three ; B 90 -16 497 633 ;
+C 52 ; WX 602 ; N four ; B 88 0 493 631 ;
+C 53 ; WX 602 ; N five ; B 84 -16 503 616 ;
+C 54 ; WX 602 ; N six ; B 100 -17 499 633 ;
+C 55 ; WX 602 ; N seven ; B 101 -10 491 616 ;
+C 56 ; WX 602 ; N eight ; B 102 -17 500 633 ;
+C 57 ; WX 602 ; N nine ; B 98 -17 497 633 ;
+C 58 ; WX 602 ; N colon ; B 204 -7 397 438 ;
+C 59 ; WX 602 ; N semicolon ; B 178 -157 395 438 ;
+C 60 ; WX 602 ; N less ; B 34 68 543 547 ;
+C 61 ; WX 602 ; N equal ; B 51 189 551 426 ;
+C 62 ; WX 602 ; N greater ; B 59 68 569 547 ;
+C 63 ; WX 602 ; N question ; B 122 -8 488 613 ;
+C 64 ; WX 602 ; N at ; B 109 -53 476 668 ;
+C 65 ; WX 602 ; N A ; B 0 0 607 579 ;
+C 66 ; WX 602 ; N B ; B 42 0 558 579 ;
+C 67 ; WX 602 ; N C ; B 39 -14 541 595 ;
+C 68 ; WX 602 ; N D ; B 49 -2 558 579 ;
+C 69 ; WX 602 ; N E ; B 33 0 530 579 ;
+C 70 ; WX 602 ; N F ; B 45 0 547 579 ;
+C 71 ; WX 602 ; N G ; B 34 -16 574 596 ;
+C 72 ; WX 602 ; N H ; B 49 0 553 579 ;
+C 73 ; WX 602 ; N I ; B 94 0 508 579 ;
+C 74 ; WX 602 ; N J ; B 54 -14 574 579 ;
+C 75 ; WX 602 ; N K ; B 35 0 573 579 ;
+C 76 ; WX 602 ; N L ; B 28 0 555 579 ;
+C 77 ; WX 602 ; N M ; B 7 0 595 579 ;
+C 78 ; WX 602 ; N N ; B 16 -8 569 579 ;
+C 79 ; WX 602 ; N O ; B 36 -16 566 595 ;
+C 80 ; WX 602 ; N P ; B 43 0 547 579 ;
+C 81 ; WX 602 ; N Q ; B 36 -128 566 595 ;
+C 82 ; WX 602 ; N R ; B 29 0 588 579 ;
+C 83 ; WX 602 ; N S ; B 70 -23 527 596 ;
+C 84 ; WX 602 ; N T ; B 45 0 557 579 ;
+C 85 ; WX 602 ; N U ; B 31 -16 570 579 ;
+C 86 ; WX 602 ; N V ; B 8 -7 594 579 ;
+C 87 ; WX 602 ; N W ; B 2 0 597 579 ;
+C 88 ; WX 602 ; N X ; B 42 0 560 579 ;
+C 89 ; WX 602 ; N Y ; B 38 0 562 579 ;
+C 90 ; WX 602 ; N Z ; B 89 0 492 579 ;
+C 91 ; WX 602 ; N bracketleft ; B 202 -181 400 579 ;
+C 92 ; WX 602 ; N backslash ; B 114 -55 503 698 ;
+C 93 ; WX 602 ; N bracketright ; B 202 -181 400 579 ;
+C 94 ; WX 602 ; N asciicircum ; B 126 448 476 676 ;
+C 95 ; WX 602 ; N underscore ; B -22 -299 626 -217 ;
+C 96 ; WX 602 ; N quoteleft ; B 210 334 391 596 ;
+C 97 ; WX 602 ; N a ; B 66 -12 568 464 ;
+C 98 ; WX 602 ; N b ; B 33 -10 566 639 ;
+C 99 ; WX 602 ; N c ; B 48 -12 523 463 ;
+C 100 ; WX 602 ; N d ; B 44 -12 577 639 ;
+C 101 ; WX 602 ; N e ; B 51 -12 546 465 ;
+C 102 ; WX 602 ; N f ; B 93 0 530 640 ;
+C 103 ; WX 602 ; N g ; B 66 -196 567 452 ;
+C 104 ; WX 602 ; N h ; B 49 0 561 639 ;
+C 105 ; WX 602 ; N i ; B 82 0 540 672 ;
+C 106 ; WX 602 ; N j ; B 115 -193 452 672 ;
+C 107 ; WX 602 ; N k ; B 51 0 575 639 ;
+C 108 ; WX 602 ; N l ; B 91 0 531 639 ;
+C 109 ; WX 602 ; N m ; B 0 0 614 464 ;
+C 110 ; WX 602 ; N n ; B 51 0 563 464 ;
+C 111 ; WX 602 ; N o ; B 45 -12 557 463 ;
+C 112 ; WX 602 ; N p ; B 33 -195 566 452 ;
+C 113 ; WX 602 ; N q ; B 39 -195 572 452 ;
+C 114 ; WX 602 ; N r ; B 53 0 556 464 ;
+C 115 ; WX 602 ; N s ; B 87 -12 512 464 ;
+C 116 ; WX 602 ; N t ; B 43 -10 550 591 ;
+C 117 ; WX 602 ; N u ; B 35 -10 558 452 ;
+C 118 ; WX 602 ; N v ; B 21 -18 580 452 ;
+C 119 ; WX 602 ; N w ; B -10 -18 603 452 ;
+C 120 ; WX 602 ; N x ; B 40 0 568 452 ;
+C 121 ; WX 602 ; N y ; B 28 -195 570 452 ;
+C 122 ; WX 602 ; N z ; B 98 0 508 452 ;
+C 123 ; WX 602 ; N braceleft ; B 143 -183 468 581 ;
+C 124 ; WX 602 ; N bar ; B 259 -261 342 789 ;
+C 125 ; WX 602 ; N braceright ; B 142 -183 467 581 ;
+C 126 ; WX 602 ; N asciitilde ; B 64 249 538 366 ;
+C 161 ; WX 602 ; N exclamdown ; B 210 -29 392 595 ;
+C 162 ; WX 602 ; N cent ; B 93 -33 493 646 ;
+C 163 ; WX 602 ; N sterling ; B 127 -4 501 625 ;
+C 164 ; WX 602 ; N fraction ; B 114 -55 503 699 ;
+C 165 ; WX 602 ; N yen ; B 38 0 562 579 ;
+C 166 ; WX 602 ; N florin ; B 17 -139 541 632 ;
+C 167 ; WX 602 ; N section ; B 75 -105 526 579 ;
+C 168 ; WX 602 ; N currency ; B 60 188 548 675 ;
+C 169 ; WX 602 ; N quotesingle ; B 243 330 358 579 ;
+C 170 ; WX 602 ; N quotedblleft ; B 107 341 475 596 ;
+C 171 ; WX 602 ; N guillemotleft ; B 149 44 453 407 ;
+C 172 ; WX 602 ; N guilsinglleft ; B 232 44 370 407 ;
+C 173 ; WX 602 ; N guilsinglright ; B 231 44 370 407 ;
+C 174 ; WX 602 ; N fi ; B -1 0 602 672 ;
+C 175 ; WX 602 ; N fl ; B -1 0 602 642 ;
+C 177 ; WX 602 ; N endash ; B -22 184 626 266 ;
+C 178 ; WX 602 ; N dagger ; B 121 -15 481 595 ;
+C 179 ; WX 602 ; N daggerdbl ; B 121 -15 481 595 ;
+C 180 ; WX 602 ; N periodcentered ; B 207 214 395 402 ;
+C 182 ; WX 602 ; N paragraph ; B 57 -77 551 616 ;
+C 183 ; WX 602 ; N bullet ; B 222 256 379 413 ;
+C 184 ; WX 602 ; N quotesinglbase ; B 199 -147 380 116 ;
+C 185 ; WX 602 ; N quotedblbase ; B 114 -139 481 116 ;
+C 186 ; WX 602 ; N quotedblright ; B 122 325 489 579 ;
+C 187 ; WX 602 ; N guillemotright ; B 148 44 453 407 ;
+C 188 ; WX 602 ; N ellipsis ; B 31 -15 570 122 ;
+C 189 ; WX 602 ; N perthousand ; B -44 -2 664 618 ;
+C 191 ; WX 602 ; N questiondown ; B 118 -25 485 595 ;
+C 193 ; WX 602 ; N grave ; B 124 504 407 670 ;
+C 194 ; WX 602 ; N acute ; B 195 504 478 670 ;
+C 195 ; WX 602 ; N circumflex ; B 132 509 470 657 ;
+C 196 ; WX 602 ; N tilde ; B 123 537 478 636 ;
+C 197 ; WX 602 ; N macron ; B 130 551 472 611 ;
+C 198 ; WX 602 ; N breve ; B 113 528 488 661 ;
+C 199 ; WX 602 ; N dotaccent ; B 239 527 363 652 ;
+C 200 ; WX 602 ; N dieresis ; B 117 522 484 641 ;
+C 202 ; WX 602 ; N ring ; B 177 499 425 747 ;
+C 203 ; WX 602 ; N cedilla ; B 178 -233 431 -9 ;
+C 205 ; WX 602 ; N hungarumlaut ; B 168 504 535 661 ;
+C 206 ; WX 602 ; N ogonek ; B 248 -224 435 15 ;
+C 207 ; WX 602 ; N caron ; B 132 511 469 659 ;
+C 208 ; WX 602 ; N emdash ; B -22 184 626 266 ;
+C 225 ; WX 602 ; N AE ; B 0 0 578 579 ;
+C 227 ; WX 602 ; N ordfeminine ; B 117 110 518 596 ;
+C 232 ; WX 602 ; N Lslash ; B 28 0 555 579 ;
+C 233 ; WX 602 ; N Oslash ; B 36 -55 566 631 ;
+C 234 ; WX 602 ; N OE ; B 34 0 578 579 ;
+C 235 ; WX 602 ; N ordmasculine ; B 95 110 508 596 ;
+C 241 ; WX 602 ; N ae ; B 18 -13 579 465 ;
+C 245 ; WX 602 ; N dotlessi ; B 82 0 540 452 ;
+C 248 ; WX 602 ; N lslash ; B 91 0 531 639 ;
+C 249 ; WX 602 ; N oslash ; B 47 -22 557 475 ;
+C 250 ; WX 602 ; N oe ; B 35 -13 579 466 ;
+C 251 ; WX 602 ; N germandbls ; B 21 -11 550 640 ;
+C -1 ; WX 602 ; N Aacute ; B 0 0 607 802 ;
+C -1 ; WX 602 ; N Acircumflex ; B 0 0 607 789 ;
+C -1 ; WX 602 ; N Adieresis ; B 0 0 607 773 ;
+C -1 ; WX 602 ; N Agrave ; B 0 0 607 802 ;
+C -1 ; WX 602 ; N Aring ; B 0 0 607 858 ;
+C -1 ; WX 602 ; N Atilde ; B 0 0 607 768 ;
+C -1 ; WX 602 ; N Ccedilla ; B 39 -233 541 595 ;
+C -1 ; WX 602 ; N Eacute ; B 33 0 530 802 ;
+C -1 ; WX 602 ; N Ecircumflex ; B 33 0 530 789 ;
+C -1 ; WX 602 ; N Edieresis ; B 33 0 530 773 ;
+C -1 ; WX 602 ; N Egrave ; B 33 0 530 802 ;
+C -1 ; WX 602 ; N Iacute ; B 94 0 508 802 ;
+C -1 ; WX 602 ; N Icircumflex ; B 94 0 508 789 ;
+C -1 ; WX 602 ; N Idieresis ; B 94 0 508 773 ;
+C -1 ; WX 602 ; N Igrave ; B 94 0 508 802 ;
+C -1 ; WX 602 ; N Ntilde ; B 16 -8 569 768 ;
+C -1 ; WX 602 ; N Oacute ; B 36 -16 566 802 ;
+C -1 ; WX 602 ; N Ocircumflex ; B 36 -16 566 789 ;
+C -1 ; WX 602 ; N Odieresis ; B 36 -16 566 773 ;
+C -1 ; WX 602 ; N Ograve ; B 36 -16 566 802 ;
+C -1 ; WX 602 ; N Otilde ; B 36 -16 566 768 ;
+C -1 ; WX 602 ; N Scaron ; B 70 -23 527 791 ;
+C -1 ; WX 602 ; N Uacute ; B 31 -16 570 802 ;
+C -1 ; WX 602 ; N Ucircumflex ; B 31 -16 570 789 ;
+C -1 ; WX 602 ; N Udieresis ; B 31 -16 570 773 ;
+C -1 ; WX 602 ; N Ugrave ; B 31 -16 570 802 ;
+C -1 ; WX 602 ; N Ydieresis ; B 38 0 562 773 ;
+C -1 ; WX 602 ; N Zcaron ; B 89 0 492 791 ;
+C -1 ; WX 602 ; N aacute ; B 66 -12 568 670 ;
+C -1 ; WX 602 ; N acircumflex ; B 66 -12 568 657 ;
+C -1 ; WX 602 ; N adieresis ; B 66 -12 568 641 ;
+C -1 ; WX 602 ; N agrave ; B 66 -12 568 670 ;
+C -1 ; WX 602 ; N aring ; B 66 -12 568 743 ;
+C -1 ; WX 602 ; N atilde ; B 66 -12 568 636 ;
+C -1 ; WX 602 ; N ccedilla ; B 48 -233 523 463 ;
+C -1 ; WX 602 ; N eacute ; B 51 -12 546 670 ;
+C -1 ; WX 602 ; N ecircumflex ; B 51 -12 546 657 ;
+C -1 ; WX 602 ; N edieresis ; B 51 -12 546 641 ;
+C -1 ; WX 602 ; N egrave ; B 51 -12 546 670 ;
+C -1 ; WX 602 ; N iacute ; B 82 0 540 670 ;
+C -1 ; WX 602 ; N icircumflex ; B 82 0 540 657 ;
+C -1 ; WX 602 ; N idieresis ; B 82 0 540 641 ;
+C -1 ; WX 602 ; N igrave ; B 82 0 540 670 ;
+C -1 ; WX 602 ; N ntilde ; B 51 0 563 636 ;
+C -1 ; WX 602 ; N oacute ; B 45 -12 557 670 ;
+C -1 ; WX 602 ; N ocircumflex ; B 45 -12 557 657 ;
+C -1 ; WX 602 ; N odieresis ; B 45 -12 557 641 ;
+C -1 ; WX 602 ; N ograve ; B 45 -12 557 670 ;
+C -1 ; WX 602 ; N otilde ; B 45 -12 557 636 ;
+C -1 ; WX 602 ; N scaron ; B 87 -12 512 659 ;
+C -1 ; WX 602 ; N uacute ; B 35 -10 558 670 ;
+C -1 ; WX 602 ; N ucircumflex ; B 35 -10 558 657 ;
+C -1 ; WX 602 ; N udieresis ; B 35 -10 558 641 ;
+C -1 ; WX 602 ; N ugrave ; B 35 -10 558 670 ;
+C -1 ; WX 602 ; N ydieresis ; B 28 -195 570 641 ;
+C -1 ; WX 602 ; N zcaron ; B 98 0 508 659 ;
+C -1 ; WX 602 ; N trademark ; B 56 337 547 616 ;
+C -1 ; WX 602 ; N copyright ; B 11 45 591 625 ;
+C -1 ; WX 602 ; N logicalnot ; B 48 170 553 445 ;
+C -1 ; WX 602 ; N registered ; B 11 45 591 625 ;
+C -1 ; WX 602 ; N minus ; B 76 262 526 354 ;
+C -1 ; WX 602 ; N Eth ; B 20 -2 558 579 ;
+C -1 ; WX 602 ; N Thorn ; B 55 0 518 579 ;
+C -1 ; WX 602 ; N Yacute ; B 38 0 562 802 ;
+C -1 ; WX 602 ; N brokenbar ; B 271 -172 331 699 ;
+C -1 ; WX 602 ; N degree ; B 143 349 459 665 ;
+C -1 ; WX 602 ; N divide ; B 51 99 551 516 ;
+C -1 ; WX 602 ; N eth ; B 45 -12 557 640 ;
+C -1 ; WX 602 ; N mu ; B 32 -201 534 452 ;
+C -1 ; WX 602 ; N multiply ; B 105 125 493 511 ;
+C -1 ; WX 602 ; N onehalf ; B 59 -89 539 680 ;
+C -1 ; WX 602 ; N onequarter ; B 59 -94 539 680 ;
+C -1 ; WX 602 ; N onesuperior ; B 164 240 462 633 ;
+C -1 ; WX 602 ; N plusminus ; B 105 44 497 619 ;
+C -1 ; WX 602 ; N thorn ; B 33 -195 566 639 ;
+C -1 ; WX 602 ; N threequarters ; B 59 -94 539 680 ;
+C -1 ; WX 602 ; N threesuperior ; B 140 222 461 633 ;
+C -1 ; WX 602 ; N twosuperior ; B 145 240 451 632 ;
+C -1 ; WX 602 ; N yacute ; B 28 -195 570 670 ;
+EndCharMetrics
+StartKernData
+StartKernPairs 0
+EndKernPairs
+StartTrackKern 0
+EndTrackKern
+EndKernData
+EndFontMetrics
Added: xmlgraphics/fop/trunk/test/resources/fonts/type1/c0419bt_.pfb
URL: http://svn.apache.org/viewvc/xmlgraphics/fop/trunk/test/resources/fonts/type1/c0419bt_.pfb?rev=1597112&view=auto
==============================================================================
Binary file - no diff available.
Propchange: xmlgraphics/fop/trunk/test/resources/fonts/type1/c0419bt_.pfb
------------------------------------------------------------------------------
svn:mime-type = application/octet-stream
---------------------------------------------------------------------
To unsubscribe, e-mail: fop-commits-unsubscribe@xmlgraphics.apache.org
For additional commands, e-mail: fop-commits-help@xmlgraphics.apache.org