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/Type1SubsetFile.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$ */ package org.apache.fop.fonts.type1; import java.io.ByteArrayInputStream; import java.io.ByteArrayOutputStream; import java.io.IOException; import java.io.InputStream; import java.io.UnsupportedEncodingException; import java.nio.ByteBuffer; import java.nio.ByteOrder; import java.util.ArrayList; import java.util.Collections; import java.util.HashMap; import java.util.LinkedHashMap; import java.util.List; import java.util.Map; import java.util.Map.Entry; import java.util.Scanner; import java.util.Set; import org.apache.commons.io.IOUtils; import org.apache.commons.logging.Log; import org.apache.commons.logging.LogFactory; 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.PostscriptParser.PSSubroutine; import org.apache.fop.fonts.type1.PostscriptParser.PSVariable; public class Type1SubsetFile { protected static final Log LOG = LogFactory.getLog(Type1SubsetFile.class); /* The subset list of char strings */ protected HashMap<String, byte[]> subsetCharStrings; /* The list of character names in the subset font */ protected List<String> charNames; /* A list of unique subroutines references */ protected LinkedHashMap<Integer, byte[]> uniqueSubs; private SingleByteFont sbfont; /* New line character */ protected String eol = "\n"; /* An option to determine whether the subroutines are subset */ protected boolean subsetSubroutines = true; private byte[] fullFont; //List of parsed Postscript elements protected List<PSElement> headerSection; protected List<PSElement> mainSection; //Determines whether the current font uses standard encoding protected boolean standardEncoding; //Type 1 operators private static final int OP_SEAC = 6; private static final int OP_CALLSUBR = 10; private static final int OP_CALLOTHERSUBR = 16; public byte[] createSubset(InputStream in, SingleByteFont sbfont) throws IOException { fullFont = IOUtils.toByteArray(in); byte[] subsetFont = createSubset(sbfont, true); //This should never happen but ensure that subset is shorter than original font return (subsetFont.length == 0 || subsetFont.length > fullFont.length) ? fullFont : subsetFont; } /** * Creates a new subset from the given type 1 font input stream * @param sbfont The font object containing information such as the * characters from which to create the subset * @param subsetSubroutines This option will force the subset to include all * subroutines. * @return Returns the subset as a byte array * @throws IOException */ private byte[] createSubset(SingleByteFont sbfont, boolean subsetSubroutines) throws IOException { this.subsetSubroutines = subsetSubroutines; InputStream in = new ByteArrayInputStream(fullFont); //Initialise resources used for the font creation this.sbfont = sbfont; PFBParser pfbParser = new PFBParser(); PFBData pfbData = pfbParser.parsePFB(in); PostscriptParser psParser = new PostscriptParser(); charNames = new ArrayList<String>(); //Parse the header section of the font if (headerSection == null) { headerSection = psParser.parse(pfbData.getHeaderSegment()); } //Read the encoding section PSElement encoding = getElement("/Encoding", headerSection); if (encoding.getFoundUnexpected()) { //Fully embed the font as we're unable to interpret postscript on arrays return new byte[0]; } List<String> subsetEncodingEntries = readEncoding(encoding); //Decode the main section in preparation for parsing byte[] decoded = BinaryCoder.decodeBytes(pfbData.getEncryptedSegment(), 55665, 4); //Initialise the resources used to hold the subset data uniqueSubs = new LinkedHashMap<Integer, byte[]>(); subsetCharStrings = new HashMap<String, byte[]>(); //Parse the encoded main font section for elements if (mainSection == null) { mainSection = psParser.parse(decoded); } //Process and write the main section PSElement charStrings = getElement("/CharStrings", mainSection); boolean result = readMainSection(mainSection, decoded, subsetEncodingEntries, charStrings); if (!result) { /* This check handles the case where a font uses a postscript method to return a * subroutine index. As there is currently no java postscript interpreter and writing * one would be very difficult it prevents us from handling this eventuality. The way * this issue is being handled is to restart the subset process and include all * subroutines. */ uniqueSubs.clear(); subsetCharStrings.clear(); charNames.clear(); return createSubset(sbfont, false); } //Write header section ByteArrayOutputStream boasHeader = writeHeader(pfbData, encoding); ByteArrayOutputStream boasMain = writeMainSection(decoded, mainSection, charStrings); byte[] mainSectionBytes = boasMain.toByteArray(); mainSectionBytes = BinaryCoder.encodeBytes(mainSectionBytes, 55665, 4); boasMain.reset(); boasMain.write(mainSectionBytes); ByteArrayOutputStream baosTrailer = new ByteArrayOutputStream(); baosTrailer.write(pfbData.getTrailerSegment(), 0, pfbData.getTrailerSegment().length); return stitchFont(boasHeader, boasMain, baosTrailer); } public byte[] stitchFont(ByteArrayOutputStream boasHeader, ByteArrayOutputStream boasMain, ByteArrayOutputStream boasTrailer) throws IOException { int headerLength = boasHeader.size(); int mainLength = boasMain.size(); boasMain.write(128); boasMain.write(1); updateSectionSize(boasTrailer.size()).writeTo(boasMain); boasTrailer.write(128); boasTrailer.write(3); boasTrailer.writeTo(boasMain); boasHeader.write(128); boasHeader.write(2); //You need to encode the main section first before getting it's size!!! updateSectionSize(mainLength).writeTo(boasHeader); boasMain.writeTo(boasHeader); ByteArrayOutputStream fullFont = new ByteArrayOutputStream(); fullFont.write(128); fullFont.write(1); updateSectionSize(headerLength).writeTo(fullFont); boasHeader.writeTo(fullFont); return fullFont.toByteArray(); } private List<String> readEncoding(PSElement encoding) { Map<Integer, Integer> usedGlyphs = sbfont.getUsedGlyphs(); List<Integer> glyphs = new ArrayList<Integer>(usedGlyphs.keySet()); Collections.sort(glyphs); List<String> subsetEncodingEntries = new ArrayList<String>(); //Handle custom encoding if (encoding instanceof PSFixedArray) { PSFixedArray encodingArray = (PSFixedArray)encoding; for (int glyph : glyphs) { /* Search for matching entries in the original font encoding table to add * to the subset. As there may be more than one entry for a character (as * was the case in a font where some glyphs were duplicated), a name search is * performed and all matching entries are added. */ List<String> matches = searchEntries(encodingArray.getEntries(), glyph); /* If no matches are found, create a new entry for the character so * that it can be added even if it's not in the current encoding. */ if (matches.size() == 0) { matches.clear(); if (glyph == 0) { matches.add("dup 0 /.notdef put"); } else { matches.add(String.format("dup %d /%s put", glyph, sbfont.getGlyphName(glyph))); } } for (String match : matches) { subsetEncodingEntries.add(match); addToCharNames(match); } } //Handle fixed encoding } else if (encoding instanceof PSVariable) { if (((PSVariable) encoding).getValue().equals("StandardEncoding")) { standardEncoding = true; sbfont.mapUsedGlyphName(0, "/.notdef"); for (int glyph : glyphs) { //Retrieve the character name and alternates for the given glyph String name = sbfont.getGlyphName(glyph); if (glyph != 0 && name != null && !name.trim().equals("")) { sbfont.mapUsedGlyphName(glyph, "/" + name); } } } else { LOG.warn("Only Custom or StandardEncoding is supported when creating a Type 1 subset."); } } return subsetEncodingEntries; } protected List<String> searchEntries(HashMap<Integer, String> encodingEntries, int glyph) { List<String> matches = new ArrayList<String>(); for (Entry<Integer, String> entry : encodingEntries.entrySet()) { String tag = getEntryPart(entry.getValue(), 3); String name = sbfont.getGlyphName(sbfont.getUsedGlyphs().get(glyph)); if (name.equals(tag)) { matches.add(entry.getValue()); } } return matches; } protected ByteArrayOutputStream writeHeader(PFBData pfbData, PSElement encoding) throws IOException { ByteArrayOutputStream boasHeader = new ByteArrayOutputStream(); boasHeader.write(pfbData.getHeaderSegment(), 0, encoding.getStartPoint() - 1); if (!standardEncoding) { //Write out the new encoding table for the subset font String encodingArray = eol + "/Encoding 256 array" + eol + "0 1 255 {1 index exch /.notdef put } for" + eol; byte[] encodingDefinition = encodingArray.getBytes("ASCII"); boasHeader.write(encodingDefinition, 0, encodingDefinition.length); Set<Entry<Integer, String>> entrySet = sbfont.getUsedGlyphNames().entrySet(); for (Entry<Integer, String> entry : entrySet) { String arrayEntry = String.format("dup %d %s put", entry.getKey(), entry.getValue()); writeString(arrayEntry + eol, boasHeader); } writeString("readonly def" + eol, boasHeader); } else { String theEncoding = eol + "/Encoding StandardEncoding def" + eol; boasHeader.write(theEncoding.getBytes("ASCII")); } boasHeader.write(pfbData.getHeaderSegment(), encoding.getEndPoint(), pfbData.getHeaderSegment().length - encoding.getEndPoint()); return boasHeader; } ByteArrayOutputStream updateSectionSize(int size) throws IOException { //Update the size in the header for the previous section ByteArrayOutputStream boas = new ByteArrayOutputStream(); byte[] lowOrderSize = ByteBuffer.allocate(4).order(ByteOrder.LITTLE_ENDIAN).putInt( size).array(); boas.write(lowOrderSize); return boas; } private boolean readMainSection(List<PSElement> mainSection, byte[] decoded, List<String> subsetEncodingEntries, PSElement charStrings) { subsetEncodingEntries.add(0, "dup 0 /.notdef put"); /* Reads and parses the charStrings section to subset the charString * and it's referenced subroutines found in the main section for each glyph. */ PSDictionary charStringsDict = (PSDictionary)charStrings; for (String tag : sbfont.getUsedGlyphNames().values()) { if (!tag.equals("/.notdef")) { charNames.add(tag); } int[] location = charStringsDict.getBinaryEntries().get(tag); if (location == null) { continue; } byte[] charStringEntry = getBinaryEntry(location, decoded); int skipBytes = 4; PSElement element = getElement("lenIV", mainSection); if (element != null && element instanceof PSVariable) { PSVariable lenIV = (PSVariable)element; try { skipBytes = Integer.parseInt(lenIV.getValue()); } catch (NumberFormatException ex) { LOG.warn(String.format("Invalid value `%s` for lenIV found in font %s", lenIV.getValue(), sbfont.getEmbedFileURI().toString())); } } charStringEntry = BinaryCoder.decodeBytes(charStringEntry, 4330, skipBytes); PSFixedArray subroutines = (PSFixedArray)getElement("/Subrs", mainSection); if (subsetSubroutines) { /* Recursively scan the charString array for subroutines and if found, copy the * entry to our subset entries and update any references. */ charStringEntry = createSubsetCharStrings(decoded, charStringEntry, subroutines, subsetEncodingEntries); } if (charStringEntry.length == 0) { return false; } charStringEntry = BinaryCoder.encodeBytes(charStringEntry, 4330, skipBytes); subsetCharStrings.put(tag, charStringEntry); } return true; } private byte[] createSubsetCharStrings(byte[] decoded, byte[] data, PSFixedArray subroutines, List<String> subsetEncodingEntries) { List<BytesNumber> operands = new ArrayList<BytesNumber>(); for (int i = 0; i < data.length; i++) { int cur = data[i] & 0xFF; if (cur <= 31) { int dataLength = data.length; if (cur == OP_CALLSUBR) { //Found subroutine. Read subroutine and recursively scan and update references if (operands.size() == 0) { continue; } if (uniqueSubs.get(operands.get(operands.size() - 1).getNumber()) == null) { uniqueSubs.put(operands.get(operands.size() - 1).getNumber(), new byte[0]); data = addSubroutine(subroutines, operands, decoded, subsetEncodingEntries, data, i, 1, -1, operands.get( operands.size() - 1).getNumber()); } else { data = addSubroutine(subroutines, operands, decoded, subsetEncodingEntries, data, i, 1, getSubrIndex(operands.get( operands.size() - 1).getNumber()), operands.get( operands.size() - 1).getNumber()); } } else if (cur == 12) { int next = data[++i] & 0xFF; if (next == OP_SEAC) { /* This charString references two other glyphs which must also be included * for this character to be displayed properly. */ int first = operands.get(operands.size() - 2).getNumber(); int second = operands.get(operands.size() - 1).getNumber(); String charFirst = AdobeStandardEncoding.getCharFromCodePoint(first); String charSecond = AdobeStandardEncoding.getCharFromCodePoint(second); subsetEncodingEntries.add(String.format("dup %d /%s put", first, charFirst)); subsetEncodingEntries.add(String.format("dup %d /%s put", second, charSecond)); sbfont.mapUsedGlyphName(first, "/" + charFirst); sbfont.mapUsedGlyphName(second, "/" + charSecond); } else if (next == OP_CALLOTHERSUBR) { /* Search for a specific operator chain which results in a referenced * subroutine being returned from a postscript method. If it's found then * return null so the subset process can be restarted and all subroutines * can be included. */ int[] pattern = {12, 17, 10}; int count = 0; boolean matchesPattern = true; if (data.length > i + 4) { for (int pos = i + 1; pos < i + 4; pos++) { if (data[pos] != pattern[count++]) { matchesPattern = false; } } } if (matchesPattern) { return new byte[0]; } data = addSubroutine(subroutines, operands, decoded, subsetEncodingEntries, data, i, 2, -1, operands.get(0).getNumber()); } } if (data.length == 0) { return new byte[0]; } i -= dataLength - data.length; operands.clear(); } else if (cur <= 246) { operands.add(new BytesNumber(cur - 139, 1)); } else if (cur <= 250) { operands.add(new BytesNumber((cur - 247) * 256 + (data[i + 1] & 0xFF) + 108, 2)); i++; } else if (cur <= 254) { operands.add(new BytesNumber(-(cur - 251) * 256 - (data[i + 1] & 0xFF) - 108, 2)); 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)); i += 4; } } return data; } private int getSubrIndex(int subID) { int count = 0; for (Integer key : uniqueSubs.keySet()) { if (key == subID) { return count; } count++; } return -1; } private byte[] addSubroutine(PSFixedArray subroutines, List<BytesNumber> operands, byte[] decoded, List<String> subsetEncodingEntries, byte[] data, int i, int opLength, int existingSubrRef, int subrID) { if (existingSubrRef == -1) { int[] subrData = subroutines.getBinaryEntryByIndex(subrID); byte[] subroutine = getBinaryEntry(subrData, decoded); subroutine = BinaryCoder.decodeBytes(subroutine, 4330, 4); subroutine = createSubsetCharStrings(decoded, subroutine, subroutines, subsetEncodingEntries); if (subroutine.length == 0) { return new byte[0]; } //Encode data subroutine = BinaryCoder.encodeBytes(subroutine, 4330, 4); uniqueSubs.put(subrID, subroutine); } int subRef = (existingSubrRef != -1) ? existingSubrRef : uniqueSubs.size() - 1; data = constructNewRefData(i, data, operands, 1, subRef, opLength); return data; } protected ByteArrayOutputStream writeMainSection(byte[] decoded, List<PSElement> mainSection, PSElement charStrings) throws IOException { ByteArrayOutputStream main = new ByteArrayOutputStream(); PSElement subrs = getElement("/Subrs", mainSection); //Find the ID of the three most commonly subroutines defined in Type 1 fonts String rd = findVariable(decoded, mainSection, new String[] {"string currentfile exch readstring pop"}, "RD"); String nd = findVariable(decoded, mainSection, new String[] {"def", "noaccess def"}, "noaccess def"); String np = findVariable(decoded, mainSection, new String[] {"put", "noaccess put"}, "noaccess put"); main.write(decoded, 0, subrs.getStartPoint()); //Write either the subset or full list of subroutines if (subsetSubroutines) { writeString(eol + String.format("/Subrs %d array", uniqueSubs.size()), main); int count = 0; for (Entry<Integer, byte[]> entry : uniqueSubs.entrySet()) { writeString(eol + String.format("dup %d %d %s ", count++, entry.getValue().length, rd), main); main.write(entry.getValue()); writeString(" " + np, main); } writeString(eol + nd, main); } else { int fullSubrsLength = subrs.getEndPoint() - subrs.getStartPoint(); main.write(decoded, subrs.getStartPoint(), fullSubrsLength); } main.write(decoded, subrs.getEndPoint(), charStrings.getStartPoint() - subrs.getEndPoint()); //Write the subset charString array writeString(eol + String.format("/CharStrings %d dict dup begin", subsetCharStrings.size()), main); for (Entry<String, byte[]> entry : subsetCharStrings.entrySet()) { writeString(eol + String.format("%s %d %s ", entry.getKey(), entry.getValue().length, rd), main); main.write(entry.getValue()); writeString(" " + nd, main); } writeString(eol + "end", main); main.write(decoded, charStrings.getEndPoint(), decoded.length - charStrings.getEndPoint()); return main; } protected String findVariable(byte[] decoded, List<PSElement> elements, String[] matches, String fallback) throws UnsupportedEncodingException { for (PSElement element : elements) { if (element instanceof PSSubroutine) { byte[] var = new byte[element.getEndPoint() - element.getStartPoint()]; System.arraycopy(decoded, element.getStartPoint(), var, 0, element.getEndPoint() - element.getStartPoint()); String found = readVariableContents(new String(var, "ASCII")).trim(); for (String match : matches) { if (match.equals(found)) { return element.getOperator().substring(1, element.getOperator().length()); } } } } return fallback; } String readVariableContents(String variable) { int level = 0; String result = ""; int start = 0; int end = 0; boolean reading = false; List<Integer> results = new ArrayList<Integer>(); for (int i = 0; i < variable.length(); i++) { char curChar = variable.charAt(i); boolean sectionEnd = false; if (curChar == '{') { level++; sectionEnd = true; } else if (curChar == '}') { level--; sectionEnd = true; } else if (level == 1) { if (!reading) { reading = true; start = i; } end = i; } if (sectionEnd && reading) { results.add(start); results.add(end); reading = false; } } for (int i = 0; i < results.size(); i += 2) { result = result.concat(variable.substring(results.get(i), results.get(i + 1) + 1)); } return result; } private void addToCharNames(String encodingEntry) { int spaceCount = 0; int lastSpaceIndex = 0; int charIndex = 0; String charName = ""; //Extract the character name from an encoding entry for (int i = 0; i < encodingEntry.length(); i++) { boolean isSpace = encodingEntry.charAt(i) == ' '; if (isSpace) { spaceCount++; switch (spaceCount - 1) { case 1: charIndex = Integer.parseInt(encodingEntry.substring(lastSpaceIndex + 1, i)); break; case 2: charName = encodingEntry.substring(lastSpaceIndex + 1, i); break; default: break; } } if (isSpace) { lastSpaceIndex = i; } } sbfont.mapUsedGlyphName(charIndex, charName); } protected void writeString(String entry, ByteArrayOutputStream boas) throws IOException { byte[] byteEntry = entry.getBytes("ASCII"); boas.write(byteEntry); } /** * A class used to store the last number operand and also it's size in bytes */ public static final class BytesNumber { private int number; private int numBytes; private String name; public BytesNumber(int number, int numBytes) { this.number = number; this.numBytes = numBytes; } public int getNumber() { return this.number; } public int getNumBytes() { return this.numBytes; } public void setName(String name) { this.name = name; } public String getName() { return this.name; } } private byte[] constructNewRefData(int curDataPos, byte[] currentData, List<BytesNumber> operands, int opNum, int curSubsetIndexSize, int operatorLength) { //Create the new array with the modified reference byte[] newData; int operandsLenth = getOperandsLength(operands); int startRef = curDataPos - operandsLenth + getOpPosition(opNum, operands) + (1 - operatorLength); byte[] preBytes = new byte[startRef]; System.arraycopy(currentData, 0, preBytes, 0, startRef); byte[] newRefBytes = createNewRef(curSubsetIndexSize, -1); newData = concatArray(preBytes, newRefBytes); byte[] postBytes = new byte[currentData.length - (startRef + operands.get(opNum - 1).getNumBytes())]; System.arraycopy(currentData, startRef + operands.get(opNum - 1).getNumBytes(), postBytes, 0, currentData.length - (startRef + operands.get(opNum - 1).getNumBytes())); return concatArray(newData, postBytes); } int getOpPosition(int opNum, List<BytesNumber> operands) { int byteCount = 0; for (int i = 0; i < opNum - 1; i++) { byteCount += operands.get(i).getNumBytes(); } return byteCount; } int getOperandsLength(List<BytesNumber> operands) { int length = 0; for (BytesNumber number : operands) { length += number.getNumBytes(); } return length; } private byte[] createNewRef(int newRef, int forceLength) { byte[] newRefBytes; if ((forceLength == -1 && newRef <= 107) || forceLength == 1) { newRefBytes = new byte[1]; newRefBytes[0] = (byte)(newRef + 139); } else if ((forceLength == -1 && newRef <= 1131) || forceLength == 2) { newRefBytes = new byte[2]; if (newRef <= 363) { newRefBytes[0] = (byte)247; } else if (newRef <= 619) { newRefBytes[0] = (byte)248; } else if (newRef <= 875) { newRefBytes[0] = (byte)249; } else { newRefBytes[0] = (byte)250; } newRefBytes[1] = (byte)(newRef - 108); } else { newRefBytes = new byte[5]; newRefBytes[0] = (byte)255; newRefBytes[1] = (byte)(newRef >> 24); newRefBytes[2] = (byte)(newRef >> 16); newRefBytes[3] = (byte)(newRef >> 8); newRefBytes[4] = (byte)newRef; } return newRefBytes; } /** * Concatenate two byte arrays together * @param a The first array * @param b The second array * @return The concatenated array */ byte[] concatArray(byte[] a, byte[] b) { int aLen = a.length; int bLen = b.length; byte[] c = new byte[aLen + bLen]; System.arraycopy(a, 0, c, 0, aLen); System.arraycopy(b, 0, c, aLen, bLen); return c; } /** * Returns a section of a byte array determined by it's start and * end position. * @param position An array containing both the start and end position * of the section to copy. * @param decoded The array from which to copy a section of data * @return Returns the copy of the data section */ protected 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; } protected String getEntryPart(String entry, int part) { Scanner s = new Scanner(entry).useDelimiter(" "); for (int i = 1; i < part; i++) { s.next(); } return s.next(); } protected PSElement getElement(String elementID, List<PSElement> elements) { for (PSElement element : elements) { if (element.getOperator().equals(elementID)) { return element; } } return null; } /** * A class to encode and decode sections of a type 1 font file. See Adobe * Type 1 Font Format Section 7.2 for more details. */ public static class BinaryCoder { public static byte[] decodeBytes(byte[] in, int inR, int n) { byte[] out = new byte[in.length - n]; int r = inR; int c1 = 52845; int c2 = 22719; for (int i = 0; i < in.length; i++) { int cypher = in[i] & 0xFF; int plain = cypher ^ (r >> 8); if (i >= n) { out[i - n] = (byte)plain; } r = (cypher + r) * c1 + c2 & 0xFFFF; } return out; } public static byte[] encodeBytes(byte[] in, int inR, int n) { byte[] buffer = new byte[in.length + n]; for (int i = 0; i < n; i++) { buffer[i] = 0; } int r = inR; int c1 = 52845; int c2 = 22719; System.arraycopy(in, 0, buffer, n, buffer.length - n); byte[] out = new byte[buffer.length]; for (int i = 0; i < buffer.length; i++) { int plain = buffer[i] & 0xff; int cipher = plain ^ r >> 8; out[i] = (byte) cipher; r = (cipher + r) * c1 + c2 & 0xffff; } return out; } } }
⏎ org/apache/fop/fonts/type1/Type1SubsetFile.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, 22212👍, 0💬
Popular Posts:
JDK 11 jdk.localedata.jmod is the JMOD file for JDK 11 Localedata module. JDK 11 Locale Data module ...
What Is javaws.jar in JRE (Java Runtime Environment) 8? javaws.jar in JRE (Java Runtime Environment)...
What Is ojdbc8.jar for Oracle 12c R2? ojdbc8.jar for Oracle 12c R2 is the JAR files of ojdbc.jar, JD...
What Is HttpComponents httpclient-4.2.2.jar? HttpComponents httpclient-4.2.2.jar is the JAR file for...
What Is commons-io-2.11.jar? commons-io-2.11.jar is the JAR file for Commons IO 2.5, which is a libr...