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: [email protected] For additional commands, e-mail: [email protected]
