Categories:
Audio (13)
Biotech (29)
Bytecode (36)
Database (77)
Framework (7)
Game (7)
General (507)
Graphics (53)
I/O (35)
IDE (2)
JAR Tools (101)
JavaBeans (21)
JDBC (121)
JDK (426)
JSP (20)
Logging (108)
Mail (58)
Messaging (8)
Network (84)
PDF (97)
Report (7)
Scripting (84)
Security (32)
Server (121)
Servlet (26)
SOAP (24)
Testing (54)
Web (15)
XML (309)
Collections:
Other Resources:
What Is fop.jar in fop-2.7-bin.zip
What Is fop.jar? I got it from the fop-2.7-bin.zip.
✍: FYIcenter.com
fop.jar in fop-2.7-bin.zip is the JAR file for FOP 2.7, which
is a print formatter driven by XSL formatting objects (XSL-FO).
You can obtain fop.jar from the build folder of the fop-2.7-bin.zip file.
Below is the information about the fop.jar (2.2) file:
JAR File Size and Download Location:
JAR name: fop.jar, fop-2.7.jar Target JDK version: 1.7 File name: fop.jar File size: 4442817 bytes Release date: 20-Jan-2022 Download: Apache FOP Website
Java source code files for fop.jar:
⏎ org/apache/fop/fonts/type1/AFMParser.java
/* * 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: AFMParser.java 1761019 2016-09-16 10:43:45Z ssteiner $ */ package org.apache.fop.fonts.type1; import java.awt.Rectangle; import java.io.BufferedReader; import java.io.IOException; import java.io.InputStream; import java.io.Reader; import java.lang.reflect.InvocationTargetException; import java.lang.reflect.Method; import java.util.HashMap; import java.util.Map; import java.util.Stack; import org.apache.commons.io.IOUtils; import org.apache.commons.logging.Log; import org.apache.commons.logging.LogFactory; import org.apache.fop.fonts.NamedCharacter; /** * Parses the contents of a Type 1 AFM font metrics file into an object structure ({@link AFMFile}). */ public class AFMParser { private static Log log = LogFactory.getLog(AFMParser.class); private static final String START_FONT_METRICS = "StartFontMetrics"; //private static final String END_FONT_METRICS = "EndFontMetrics"; private static final String FONT_NAME = "FontName"; private static final String FULL_NAME = "FullName"; private static final String FAMILY_NAME = "FamilyName"; private static final String WEIGHT = "Weight"; private static final String FONT_BBOX = "FontBBox"; private static final String ENCODING_SCHEME = "EncodingScheme"; private static final String CHARACTER_SET = "CharacterSet"; private static final String IS_BASE_FONT = "IsBaseFont"; private static final String IS_CID_FONT = "IsCIDFont"; private static final String CAP_HEIGHT = "CapHeight"; private static final String X_HEIGHT = "XHeight"; private static final String ASCENDER = "Ascender"; private static final String DESCENDER = "Descender"; private static final String STDHW = "StdHW"; private static final String STDVW = "StdVW"; private static final String UNDERLINE_POSITION = "UnderlinePosition"; private static final String UNDERLINE_THICKNESS = "UnderlineThickness"; private static final String ITALIC_ANGLE = "ItalicAngle"; private static final String IS_FIXED_PITCH = "IsFixedPitch"; private static final String START_DIRECTION = "StartDirection"; private static final String END_DIRECTION = "EndDirection"; private static final String START_CHAR_METRICS = "StartCharMetrics"; private static final String END_CHAR_METRICS = "EndCharMetrics"; private static final String C = "C"; private static final String CH = "CH"; private static final String WX = "WX"; private static final String W0X = "W0X"; private static final String W1X = "W1X"; private static final String WY = "WY"; private static final String W0Y = "W0Y"; private static final String W1Y = "W1Y"; private static final String W = "W"; private static final String W0 = "W0"; private static final String W1 = "W1"; private static final String N = "N"; private static final String B = "B"; private static final String START_TRACK_KERN = "StartTrackKern"; private static final String END_TRACK_KERN = "EndTrackKern"; //private static final String START_KERN_PAIRS = "StartKernPairs"; //private static final String START_KERN_PAIRS0 = "StartKernPairs0"; private static final String START_KERN_PAIRS1 = "StartKernPairs1"; //private static final String END_KERN_PAIRS = "EndKernPairs"; private static final String START_COMPOSITES = "StartComposites"; private static final String START_COMP_FONT_METRICS = "StartCompFontMetrics"; private static final String KP = "KP"; private static final String KPH = "KPH"; private static final String KPX = "KPX"; private static final String KPY = "KPY"; private static final int PARSE_NORMAL = 0; private static final int PARSE_CHAR_METRICS = 1; private static final Map<String, ValueHandler> VALUE_PARSERS; private static final Map<String, Integer> PARSE_MODE_CHANGES; static { VALUE_PARSERS = new HashMap<String, ValueHandler>(); VALUE_PARSERS.put(START_FONT_METRICS, new StartFontMetrics()); VALUE_PARSERS.put(FONT_NAME, new StringSetter(FONT_NAME)); VALUE_PARSERS.put(FULL_NAME, new StringSetter(FULL_NAME)); VALUE_PARSERS.put(FAMILY_NAME, new StringSetter(FAMILY_NAME)); VALUE_PARSERS.put(WEIGHT, new StringSetter(WEIGHT)); VALUE_PARSERS.put(ENCODING_SCHEME, new StringSetter(ENCODING_SCHEME)); VALUE_PARSERS.put(FONT_BBOX, new FontBBox()); VALUE_PARSERS.put(CHARACTER_SET, new StringSetter(CHARACTER_SET)); VALUE_PARSERS.put(IS_BASE_FONT, new IsBaseFont()); VALUE_PARSERS.put(IS_CID_FONT, new IsCIDFont()); VALUE_PARSERS.put(CAP_HEIGHT, new NumberSetter(CAP_HEIGHT)); VALUE_PARSERS.put(X_HEIGHT, new NumberSetter(X_HEIGHT)); VALUE_PARSERS.put(ASCENDER, new NumberSetter(ASCENDER)); VALUE_PARSERS.put(DESCENDER, new NumberSetter(DESCENDER)); VALUE_PARSERS.put(STDHW, new NumberSetter(STDHW)); VALUE_PARSERS.put(STDVW, new NumberSetter(STDVW)); VALUE_PARSERS.put(START_DIRECTION, new StartDirection()); VALUE_PARSERS.put(END_DIRECTION, new EndDirection()); VALUE_PARSERS.put(UNDERLINE_POSITION, new WritingDirNumberSetter(UNDERLINE_POSITION)); VALUE_PARSERS.put(UNDERLINE_THICKNESS, new WritingDirNumberSetter(UNDERLINE_THICKNESS)); VALUE_PARSERS.put(ITALIC_ANGLE, new WritingDirDoubleSetter(ITALIC_ANGLE)); VALUE_PARSERS.put(IS_FIXED_PITCH, new WritingDirBooleanSetter(IS_FIXED_PITCH)); VALUE_PARSERS.put(C, new IntegerSetter("CharCode")); VALUE_PARSERS.put(CH, new NotImplementedYet(CH)); VALUE_PARSERS.put(WX, new DoubleSetter("WidthX")); VALUE_PARSERS.put(W0X, new DoubleSetter("WidthX")); VALUE_PARSERS.put(W1X, new NotImplementedYet(W1X)); VALUE_PARSERS.put(WY, new DoubleSetter("WidthY")); VALUE_PARSERS.put(W0Y, new DoubleSetter("WidthY")); VALUE_PARSERS.put(W1Y, new NotImplementedYet(W1Y)); VALUE_PARSERS.put(W, new NotImplementedYet(W)); VALUE_PARSERS.put(W0, new NotImplementedYet(W0)); VALUE_PARSERS.put(W1, new NotImplementedYet(W1)); VALUE_PARSERS.put(N, new NamedCharacterSetter("Character")); VALUE_PARSERS.put(B, new CharBBox()); VALUE_PARSERS.put(START_TRACK_KERN, new NotImplementedYet(START_TRACK_KERN)); VALUE_PARSERS.put(START_KERN_PAIRS1, new NotImplementedYet(START_KERN_PAIRS1)); VALUE_PARSERS.put(START_COMPOSITES, new NotImplementedYet(START_COMPOSITES)); VALUE_PARSERS.put(START_COMP_FONT_METRICS, new NotImplementedYet(START_COMP_FONT_METRICS)); VALUE_PARSERS.put(KP, new NotImplementedYet(KP)); VALUE_PARSERS.put(KPH, new NotImplementedYet(KPH)); VALUE_PARSERS.put(KPX, new KPXHandler()); VALUE_PARSERS.put(KPY, new NotImplementedYet(KPY)); PARSE_MODE_CHANGES = new HashMap<String, Integer>(); PARSE_MODE_CHANGES.put(START_CHAR_METRICS, PARSE_CHAR_METRICS); PARSE_MODE_CHANGES.put(END_CHAR_METRICS, PARSE_NORMAL); } /** * Main constructor. */ public AFMParser() { } /** * Parses an AFM file from a stream. * @param in the stream to read from * @param afmFileName the name of the AFM file * @return the parsed AFM file * @throws IOException if an I/O error occurs */ public AFMFile parse(InputStream in, String afmFileName) throws IOException { Reader reader = new java.io.InputStreamReader(in, "US-ASCII"); try { return parse(new BufferedReader(reader), afmFileName); } finally { IOUtils.closeQuietly(reader); } } /** * Parses an AFM file from a BufferedReader. * @param reader the BufferedReader instance to read from * @param afmFileName the name of the AFM file * @return the parsed AFM file * @throws IOException if an I/O error occurs */ public AFMFile parse(BufferedReader reader, String afmFileName) throws IOException { Stack<Object> stack = new Stack<Object>(); int parseMode = PARSE_NORMAL; while (true) { String line = reader.readLine(); if (line == null) { break; } String key = null; switch (parseMode) { case PARSE_NORMAL: key = parseLine(line, stack); break; case PARSE_CHAR_METRICS: key = parseCharMetrics(line, stack, afmFileName); break; default: throw new IllegalStateException("Invalid parse mode"); } Integer newParseMode = PARSE_MODE_CHANGES.get(key); if (newParseMode != null) { parseMode = newParseMode; } } return (AFMFile)stack.pop(); } private String parseLine(String line, Stack<Object> stack) throws IOException { int startpos = 0; //Find key startpos = skipToNonWhiteSpace(line, startpos); int endpos = skipToWhiteSpace(line, startpos); String key = line.substring(startpos, endpos); //Parse value startpos = skipToNonWhiteSpace(line, endpos); ValueHandler vp = VALUE_PARSERS.get(key); if (vp != null) { vp.parse(line, startpos, stack); } return key; } private String parseCharMetrics(String line, Stack<Object> stack, String afmFileName) throws IOException { String trimmedLine = line.trim(); if (END_CHAR_METRICS.equals(trimmedLine)) { return trimmedLine; } AFMFile afm = (AFMFile) stack.peek(); String encoding = afm.getEncodingScheme(); CharMetricsHandler charMetricsHandler = CharMetricsHandler.getHandler(VALUE_PARSERS, encoding); AFMCharMetrics chm = charMetricsHandler.parse(trimmedLine, stack, afmFileName); afm.addCharMetrics(chm); return null; } private static int skipToNonWhiteSpace(String line, int startpos) { int pos = startpos; while (pos < line.length() && isWhitespace(line.charAt(pos))) { pos++; } return pos; } private static int skipToWhiteSpace(String line, int startpos) { int pos = startpos; while (pos < line.length() && !isWhitespace(line.charAt(pos))) { pos++; } return pos; } private static boolean isWhitespace(char ch) { return ch == ' ' || ch == '\t'; } // ---------------- Value Handlers --------------------------- interface ValueHandler { void parse(String line, int startpos, Stack<Object> stack) throws IOException; } private abstract static class AbstractValueHandler implements ValueHandler { protected int findValue(String line, int startpos) { return skipToWhiteSpace(line, startpos); } protected String getStringValue(String line, int startpos) { return line.substring(startpos); } protected Number getNumberValue(String line, int startpos) { try { return getIntegerValue(line, startpos); } catch (NumberFormatException nfe) { return getDoubleValue(line, startpos); } } protected int getIntegerValue(String line, int startpos) { int endpos = findValue(line, startpos); return Integer.parseInt(line.substring(startpos, endpos)); } protected double getDoubleValue(String line, int startpos) { int endpos = findValue(line, startpos); return Double.parseDouble(line.substring(startpos, endpos)); } protected Boolean getBooleanValue(String line, int startpos) { return Boolean.valueOf(getStringValue(line, startpos)); } } private static class StartFontMetrics extends AbstractValueHandler { public void parse(String line, int startpos, Stack<Object> stack) throws IOException { int endpos = findValue(line, startpos); double version = Double.parseDouble(line.substring(startpos, endpos)); if (version < 2) { throw new IOException( "AFM version must be at least 2.0 but it is " + version + "!"); } AFMFile afm = new AFMFile(); stack.push(afm); } } private abstract static class BeanSetter extends AbstractValueHandler { protected String method; public BeanSetter(String variable) { this.method = "set" + variable; } protected void setValue(Object target, Class<?> argType, Object value) { Class<?> c = target.getClass(); try { Method mth = c.getMethod(method, argType); mth.invoke(target, value); } catch (NoSuchMethodException e) { throw new RuntimeException("Bean error: " + e.getMessage(), e); } catch (IllegalAccessException e) { throw new RuntimeException("Bean error: " + e.getMessage(), e); } catch (InvocationTargetException e) { throw new RuntimeException("Bean error: " + e.getMessage(), e); } } } private static class StringSetter extends BeanSetter { public StringSetter(String variable) { super(variable); } public void parse(String line, int startpos, Stack<Object> stack) throws IOException { String s = getStringValue(line, startpos); Object obj = stack.peek(); setValue(obj, String.class, s); } } private static class NamedCharacterSetter extends BeanSetter { public NamedCharacterSetter(String variable) { super(variable); } public void parse(String line, int startpos, Stack<Object> stack) throws IOException { NamedCharacter ch = new NamedCharacter(getStringValue(line, startpos)); Object obj = stack.peek(); setValue(obj, NamedCharacter.class, ch); } } private static class NumberSetter extends BeanSetter { public NumberSetter(String variable) { super(variable); } protected Object getContextObject(Stack<Object> stack) { return stack.peek(); } public void parse(String line, int startpos, Stack<Object> stack) throws IOException { Number num = getNumberValue(line, startpos); setValue(getContextObject(stack), Number.class, num); } } private static class IntegerSetter extends NumberSetter { public IntegerSetter(String variable) { super(variable); } public void parse(String line, int startpos, Stack<Object> stack) throws IOException { int value = getIntegerValue(line, startpos); setValue(getContextObject(stack), int.class, value); } } private static class DoubleSetter extends NumberSetter { public DoubleSetter(String variable) { super(variable); } public void parse(String line, int startpos, Stack<Object> stack) throws IOException { double value = getDoubleValue(line, startpos); setValue(getContextObject(stack), double.class, value); } } private static class WritingDirNumberSetter extends NumberSetter { public WritingDirNumberSetter(String variable) { super(variable); } protected Object getContextObject(Stack<Object> stack) { if (stack.peek() instanceof AFMWritingDirectionMetrics) { return (AFMWritingDirectionMetrics)stack.peek(); } else { AFMFile afm = (AFMFile)stack.peek(); AFMWritingDirectionMetrics wdm = afm.getWritingDirectionMetrics(0); if (wdm == null) { wdm = new AFMWritingDirectionMetrics(); afm.setWritingDirectionMetrics(0, wdm); } return wdm; } } } private static class WritingDirDoubleSetter extends WritingDirNumberSetter { public WritingDirDoubleSetter(String variable) { super(variable); } public void parse(String line, int startpos, Stack<Object> stack) throws IOException { double value = getDoubleValue(line, startpos); setValue(getContextObject(stack), double.class, value); } } private static class BooleanSetter extends AbstractValueHandler { private String method; public BooleanSetter(String variable) { this.method = "set" + variable.substring(2); //Cut "Is" in front } protected Object getContextObject(Stack<Object> stack) { return (AFMFile)stack.peek(); } public void parse(String line, int startpos, Stack<Object> stack) throws IOException { Boolean b = getBooleanValue(line, startpos); Object target = getContextObject(stack); Class<?> c = target.getClass(); try { Method mth = c.getMethod(method, boolean.class); mth.invoke(target, b); } catch (NoSuchMethodException e) { throw new RuntimeException("Bean error: " + e.getMessage(), e); } catch (IllegalAccessException e) { throw new RuntimeException("Bean error: " + e.getMessage(), e); } catch (InvocationTargetException e) { throw new RuntimeException("Bean error: " + e.getMessage(), e); } } } private static class WritingDirBooleanSetter extends BooleanSetter { public WritingDirBooleanSetter(String variable) { super(variable); } protected Object getContextObject(Stack<Object> stack) { if (stack.peek() instanceof AFMWritingDirectionMetrics) { return (AFMWritingDirectionMetrics)stack.peek(); } else { AFMFile afm = (AFMFile)stack.peek(); AFMWritingDirectionMetrics wdm = afm.getWritingDirectionMetrics(0); if (wdm == null) { wdm = new AFMWritingDirectionMetrics(); afm.setWritingDirectionMetrics(0, wdm); } return wdm; } } } private static class FontBBox extends AbstractValueHandler { public void parse(String line, int startpos, Stack<Object> stack) throws IOException { Rectangle rect = parseBBox(line, startpos); AFMFile afm = (AFMFile)stack.peek(); afm.setFontBBox(rect); } protected Rectangle parseBBox(String line, int startpos) { Rectangle rect = new Rectangle(); int endpos; endpos = findValue(line, startpos); rect.x = Integer.parseInt(line.substring(startpos, endpos)); startpos = skipToNonWhiteSpace(line, endpos); endpos = findValue(line, startpos); rect.y = Integer.parseInt(line.substring(startpos, endpos)); startpos = skipToNonWhiteSpace(line, endpos); endpos = findValue(line, startpos); int v = Integer.parseInt(line.substring(startpos, endpos)); rect.width = v - rect.x; startpos = skipToNonWhiteSpace(line, endpos); endpos = findValue(line, startpos); v = Integer.parseInt(line.substring(startpos, endpos)); rect.height = v - rect.y; startpos = skipToNonWhiteSpace(line, endpos); return rect; } } private static class CharBBox extends FontBBox { public void parse(String line, int startpos, Stack<Object> stack) throws IOException { Rectangle rect = parseBBox(line, startpos); AFMCharMetrics metrics = (AFMCharMetrics)stack.peek(); metrics.setBBox(rect); } } private static class IsBaseFont extends AbstractValueHandler { public void parse(String line, int startpos, Stack<Object> stack) throws IOException { if (getBooleanValue(line, startpos)) { throw new IOException("Only base fonts are currently supported!"); } } } private static class IsCIDFont extends AbstractValueHandler { public void parse(String line, int startpos, Stack<Object> stack) throws IOException { if (getBooleanValue(line, startpos)) { throw new IOException("CID fonts are currently not supported!"); } } } private static class NotImplementedYet extends AbstractValueHandler { private String key; public NotImplementedYet(String key) { this.key = key; } public void parse(String line, int startpos, Stack stack) throws IOException { log.warn("Support for '" + key + "' has not been implemented, yet!" + " Some font data in the AFM file will be ignored."); } } private static class StartDirection extends AbstractValueHandler { public void parse(String line, int startpos, Stack<Object> stack) throws IOException { int index = getIntegerValue(line, startpos); AFMWritingDirectionMetrics wdm = new AFMWritingDirectionMetrics(); AFMFile afm = (AFMFile)stack.peek(); afm.setWritingDirectionMetrics(index, wdm); stack.push(wdm); } } private static class EndDirection extends AbstractValueHandler { public void parse(String line, int startpos, Stack<Object> stack) throws IOException { if (!(stack.pop() instanceof AFMWritingDirectionMetrics)) { throw new IOException("AFM format error: nesting incorrect"); } } } private static class KPXHandler extends AbstractValueHandler { public void parse(String line, int startpos, Stack<Object> stack) throws IOException { AFMFile afm = (AFMFile)stack.peek(); int endpos; endpos = findValue(line, startpos); String name1 = line.substring(startpos, endpos); startpos = skipToNonWhiteSpace(line, endpos); endpos = findValue(line, startpos); String name2 = line.substring(startpos, endpos); startpos = skipToNonWhiteSpace(line, endpos); endpos = findValue(line, startpos); double kx = Double.parseDouble(line.substring(startpos, endpos)); startpos = skipToNonWhiteSpace(line, endpos); afm.addXKerning(name1, name2, kx); } } }
⏎ org/apache/fop/fonts/type1/AFMParser.java
Or download all of them as a single archive file:
File name: fop-2.7-src.zip File size: 3401312 bytes Release date: 2022-01-20 Download
⇒ "fop" Command in fop-2.7-bin.zip
2016-07-07, 22179👍, 0💬
Popular Posts:
How to show the XML parsing flow with sax\DocumentTracer.java provided in the Apache Xerces package?...
commons-lang-2.6.jar is the JAR file for Apache Commons Lang 2.6, which provides a host of helper ut...
JDK 7 tools.jar is the JAR file for JDK 7 tools. It contains Java classes to support different JDK t...
The Digester package lets you configure an XML -> Java object mapping module, which triggers certain...
JRE 8 deploy.jar is the JAR file for JRE 8 Java Control Panel and other deploy tools. JRE (Java Runt...