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/complexscripts/fonts/GlyphTable.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.complexscripts.fonts; import java.util.ArrayList; import java.util.Arrays; import java.util.HashMap; import java.util.LinkedHashMap; import java.util.LinkedList; import java.util.List; import java.util.ListIterator; import java.util.Map; import java.util.Set; import java.util.TreeSet; import org.apache.commons.logging.Log; import org.apache.commons.logging.LogFactory; import org.apache.fop.complexscripts.scripts.ScriptProcessor; import org.apache.fop.complexscripts.util.GlyphSequence; import org.apache.fop.complexscripts.util.ScriptContextTester; // CSOFF: LineLengthCheck /** * <p>Base class for all advanced typographic glyph tables.</p> * * <p>This work was originally authored by Glenn Adams (gadams@apache.org).</p> */ public class GlyphTable { /** logging instance */ private static final Log log = LogFactory.getLog(GlyphTable.class); /** substitution glyph table type */ public static final int GLYPH_TABLE_TYPE_SUBSTITUTION = 1; /** positioning glyph table type */ public static final int GLYPH_TABLE_TYPE_POSITIONING = 2; /** justification glyph table type */ public static final int GLYPH_TABLE_TYPE_JUSTIFICATION = 3; /** baseline glyph table type */ public static final int GLYPH_TABLE_TYPE_BASELINE = 4; /** definition glyph table type */ public static final int GLYPH_TABLE_TYPE_DEFINITION = 5; // (optional) glyph definition table in table types other than glyph definition table private GlyphTable gdef; // map from lookup specs to lists of strings, each of which identifies a lookup table (consisting of one or more subtables) private Map<LookupSpec, List<String>> lookups; // map from lookup identifiers to lookup tables private Map<String, LookupTable> lookupTables; // cache for lookups matching private Map<LookupSpec, Map<LookupSpec, List<LookupTable>>> matchedLookups; // if true, then prevent further subtable addition private boolean frozen; protected Map<String, ScriptProcessor> processors; /** * Instantiate glyph table with specified lookups. * @param gdef glyph definition table that applies * @param lookups map from lookup specs to lookup tables */ public GlyphTable(GlyphTable gdef, Map<LookupSpec, List<String>> lookups, Map<String, ScriptProcessor> processors) { this.processors = processors; if ((gdef != null) && !(gdef instanceof GlyphDefinitionTable)) { throw new AdvancedTypographicTableFormatException("bad glyph definition table"); } else if (lookups == null) { throw new AdvancedTypographicTableFormatException("lookups must be non-null map"); } else { this.gdef = gdef; this.lookups = lookups; this.lookupTables = new LinkedHashMap<String, LookupTable>(); this.matchedLookups = new HashMap<LookupSpec, Map<LookupSpec, List<LookupTable>>>(); } } /** * Obtain glyph definition table. * @return (possibly null) glyph definition table */ public GlyphDefinitionTable getGlyphDefinitions() { return (GlyphDefinitionTable) gdef; } /** * Obtain list of all lookup specifications. * @return (possibly empty) list of all lookup specifications */ public List<LookupSpec> getLookups() { return matchLookupSpecs("*", "*", "*"); } /** * Obtain ordered list of all lookup tables, where order is by lookup identifier, which * lexicographic ordering follows the lookup list order. * @return (possibly empty) ordered list of all lookup tables */ public List<LookupTable> getLookupTables() { TreeSet<String> lids = new TreeSet<String>(lookupTables.keySet()); List<LookupTable> ltl = new ArrayList<LookupTable>(lids.size()); for (Object lid1 : lids) { String lid = (String) lid1; ltl.add(lookupTables.get(lid)); } return ltl; } /** * Obtain lookup table by lookup id. This method is used by test code, and provides * access to embedded lookups not normally accessed by {script, language, feature} lookup spec. * @param lid lookup id * @return table associated with lookup id or null if none */ public LookupTable getLookupTable(String lid) { return lookupTables.get(lid); } /** * Add a subtable. * @param subtable a (non-null) glyph subtable */ protected void addSubtable(GlyphSubtable subtable) { // ensure table is not frozen if (frozen) { throw new IllegalStateException("glyph table is frozen, subtable addition prohibited"); } // set subtable's table reference to this table subtable.setTable(this); // add subtable to this table's subtable collection String lid = subtable.getLookupId(); if (lookupTables.containsKey(lid)) { LookupTable lt = lookupTables.get(lid); lt.addSubtable(subtable); } else { LookupTable lt = new LookupTable(lid, subtable); lookupTables.put(lid, lt); } } /** * Freeze subtables, i.e., do not allow further subtable addition, and * create resulting cached state. */ protected void freezeSubtables() { if (!frozen) { for (Object o : lookupTables.values()) { LookupTable lt = (LookupTable) o; lt.freezeSubtables(lookupTables); } frozen = true; } } /** * Match lookup specifications according to <script,language,feature> tuple, where * '*' is a wildcard for a tuple component. * @param script a script identifier * @param language a language identifier * @param feature a feature identifier * @return a (possibly empty) array of matching lookup specifications */ public List<LookupSpec> matchLookupSpecs(String script, String language, String feature) { Set<LookupSpec> keys = lookups.keySet(); List<LookupSpec> matches = new ArrayList<LookupSpec>(); for (Object key : keys) { LookupSpec ls = (LookupSpec) key; if (!"*".equals(script)) { if (!ls.getScript().equals(script)) { continue; } } if (!"*".equals(language)) { if (!ls.getLanguage().equals(language)) { continue; } } if (!"*".equals(feature)) { if (!ls.getFeature().equals(feature)) { continue; } } matches.add(ls); } return matches; } /** * Match lookup specifications according to <script,language,feature> tuple, where * '*' is a wildcard for a tuple component. * @param script a script identifier * @param language a language identifier * @param feature a feature identifier * @return a (possibly empty) map from matching lookup specifications to lists of corresponding lookup tables */ public Map<LookupSpec, List<LookupTable>> matchLookups(String script, String language, String feature) { LookupSpec lsm = new LookupSpec(script, language, feature, true, true); Map<LookupSpec, List<LookupTable>> lm = matchedLookups.get(lsm); if (lm == null) { lm = new LinkedHashMap(); List<LookupSpec> lsl = matchLookupSpecs(script, language, feature); for (Object aLsl : lsl) { LookupSpec ls = (LookupSpec) aLsl; lm.put(ls, findLookupTables(ls)); } matchedLookups.put(lsm, lm); } if (lm.isEmpty() && !OTFScript.isDefault(script) && !OTFScript.isWildCard(script)) { return matchLookups(OTFScript.DEFAULT, OTFLanguage.DEFAULT, feature); } else { return lm; } } /** * Obtain ordered list of glyph lookup tables that match a specific lookup specification. * @param ls a (non-null) lookup specification * @return a (possibly empty) ordered list of lookup tables whose corresponding lookup specifications match the specified lookup spec */ public List<LookupTable> findLookupTables(LookupSpec ls) { TreeSet<LookupTable> lts = new TreeSet<LookupTable>(); List<String> ids; if ((ids = lookups.get(ls)) != null) { for (Object id : ids) { String lid = (String) id; LookupTable lt; if ((lt = lookupTables.get(lid)) != null) { lts.add(lt); } } } return new ArrayList<LookupTable>(lts); } /** * Assemble ordered array of lookup table use specifications according to the specified features and candidate lookups, * where the order of the array is in accordance to the order of the applicable lookup list. * @param features array of feature identifiers to apply * @param lookups a mapping from lookup specifications to lists of look tables from which to select lookup tables according to the specified features * @return ordered array of assembled lookup table use specifications */ public UseSpec[] assembleLookups(String[] features, Map<LookupSpec, List<LookupTable>> lookups) { TreeSet<UseSpec> uss = new TreeSet<UseSpec>(); for (String feature : features) { for (Object o : lookups.entrySet()) { Map.Entry<LookupSpec, List<LookupTable>> e = (Map.Entry<LookupSpec, List<LookupTable>>) o; LookupSpec ls = e.getKey(); if (ls.getFeature().equals(feature)) { List<LookupTable> ltl = e.getValue(); if (ltl != null) { for (Object aLtl : ltl) { LookupTable lt = (LookupTable) aLtl; uss.add(new UseSpec(lt, feature)); } } } } } return uss.toArray(new UseSpec [ uss.size() ]); } /** * Determine if table supports specific feature, i.e., supports at least one lookup. * * @param script to qualify feature lookup * @param language to qualify feature lookup * @param feature to test * @return true if feature supported (has at least one lookup) */ public boolean hasFeature(String script, String language, String feature) { UseSpec[] usa = assembleLookups(new String[] { feature }, matchLookups(script, language, feature)); return usa.length > 0; } /** {@inheritDoc} */ public String toString() { StringBuffer sb = new StringBuffer(super.toString()); sb.append("{"); sb.append("lookups={"); sb.append(lookups.toString()); sb.append("},lookupTables={"); sb.append(lookupTables.toString()); sb.append("}}"); return sb.toString(); } /** * Obtain glyph table type from name. * @param name of table type to map to type value * @return glyph table type (as an integer constant) */ public static int getTableTypeFromName(String name) { int t; String s = name.toLowerCase(); if ("gsub".equals(s)) { t = GLYPH_TABLE_TYPE_SUBSTITUTION; } else if ("gpos".equals(s)) { t = GLYPH_TABLE_TYPE_POSITIONING; } else if ("jstf".equals(s)) { t = GLYPH_TABLE_TYPE_JUSTIFICATION; } else if ("base".equals(s)) { t = GLYPH_TABLE_TYPE_BASELINE; } else if ("gdef".equals(s)) { t = GLYPH_TABLE_TYPE_DEFINITION; } else { t = -1; } return t; } /** * Resolve references to lookup tables in a collection of rules sets. * @param rsa array of rule sets * @param lookupTables map from lookup table identifers, e.g. "lu4", to lookup tables */ public static void resolveLookupReferences(RuleSet[] rsa, Map<String, LookupTable> lookupTables) { if ((rsa != null) && (lookupTables != null)) { for (RuleSet rs : rsa) { if (rs != null) { rs.resolveLookupReferences(lookupTables); } } } } /** * A structure class encapsulating a lookup specification as a <script,language,feature> tuple. */ public static class LookupSpec implements Comparable { private final String script; private final String language; private final String feature; /** * Instantiate lookup spec. * @param script a script identifier * @param language a language identifier * @param feature a feature identifier */ public LookupSpec(String script, String language, String feature) { this (script, language, feature, false, false); } /** * Instantiate lookup spec. * @param script a script identifier * @param language a language identifier * @param feature a feature identifier * @param permitEmpty if true then permit empty script, language, or feature * @param permitWildcard if true then permit wildcard script, language, or feature */ LookupSpec(String script, String language, String feature, boolean permitEmpty, boolean permitWildcard) { if ((script == null) || (!permitEmpty && (script.length() == 0))) { throw new AdvancedTypographicTableFormatException("script must be non-empty string"); } else if ((language == null) || (!permitEmpty && (language.length() == 0))) { throw new AdvancedTypographicTableFormatException("language must be non-empty string"); } else if ((feature == null) || (!permitEmpty && (feature.length() == 0))) { throw new AdvancedTypographicTableFormatException("feature must be non-empty string"); } else if (!permitWildcard && script.equals("*")) { throw new AdvancedTypographicTableFormatException("script must not be wildcard"); } else if (!permitWildcard && language.equals("*")) { throw new AdvancedTypographicTableFormatException("language must not be wildcard"); } else if (!permitWildcard && feature.equals("*")) { throw new AdvancedTypographicTableFormatException("feature must not be wildcard"); } this.script = script.trim(); this.language = language.trim(); this.feature = feature.trim(); } /** @return script identifier */ public String getScript() { return script; } /** @return language identifier */ public String getLanguage() { return language; } /** @return feature identifier */ public String getFeature() { return feature; } /** {@inheritDoc} */ public int hashCode() { int hc = 0; hc = 7 * hc + (hc ^ script.hashCode()); hc = 11 * hc + (hc ^ language.hashCode()); hc = 17 * hc + (hc ^ feature.hashCode()); return hc; } /** {@inheritDoc} */ public boolean equals(Object o) { if (o instanceof LookupSpec) { LookupSpec l = (LookupSpec) o; if (!l.script.equals(script)) { return false; } else if (!l.language.equals(language)) { return false; } else { return l.feature.equals(feature); } } else { return false; } } /** {@inheritDoc} */ public int compareTo(Object o) { int d; if (o instanceof LookupSpec) { LookupSpec ls = (LookupSpec) o; if ((d = script.compareTo(ls.script)) == 0) { if ((d = language.compareTo(ls.language)) == 0) { if ((d = feature.compareTo(ls.feature)) == 0) { d = 0; } } } } else { d = -1; } return d; } /** {@inheritDoc} */ public String toString() { StringBuffer sb = new StringBuffer(super.toString()); sb.append("{"); sb.append("<'" + script + "'"); sb.append(",'" + language + "'"); sb.append(",'" + feature + "'"); sb.append(">}"); return sb.toString(); } } /** * The <code>LookupTable</code> class comprising an identifier and an ordered list * of glyph subtables, each of which employ the same lookup identifier. */ public static class LookupTable implements Comparable { private final String id; // lookup identifier private final int idOrdinal; // parsed lookup identifier ordinal private final List<GlyphSubtable> subtables; // list of subtables private boolean doesSub; // performs substitutions private boolean doesPos; // performs positioning private boolean frozen; // if true, then don't permit further subtable additions // frozen state private GlyphSubtable[] subtablesArray; private static GlyphSubtable[] subtablesArrayEmpty = new GlyphSubtable[0]; /** * Instantiate a LookupTable. * @param id the lookup table's identifier * @param subtable an initial subtable (or null) */ public LookupTable(String id, GlyphSubtable subtable) { this (id, makeSingleton(subtable)); } /** * Instantiate a LookupTable. * @param id the lookup table's identifier * @param subtables a pre-poplated list of subtables or null */ public LookupTable(String id, List<GlyphSubtable> subtables) { assert id != null; assert id.length() != 0; assert id.startsWith("lu"); this.id = id; this.idOrdinal = Integer.parseInt(id.substring(2)); this.subtables = new LinkedList<GlyphSubtable>(); if (subtables != null) { for (Object subtable : subtables) { GlyphSubtable st = (GlyphSubtable) subtable; addSubtable(st); } } } /** @return the subtables as an array */ public GlyphSubtable[] getSubtables() { if (frozen) { return (subtablesArray != null) ? subtablesArray : subtablesArrayEmpty; } else { if (doesSub) { return subtables.toArray(new GlyphSubstitutionSubtable [ subtables.size() ]); } else if (doesPos) { return subtables.toArray(new GlyphPositioningSubtable [ subtables.size() ]); } else { return null; } } } /** * Add a subtable into this lookup table's collecion of subtables according to its * natural order. * @param subtable to add * @return true if subtable was not already present, otherwise false */ public boolean addSubtable(GlyphSubtable subtable) { boolean added = false; // ensure table is not frozen if (frozen) { throw new IllegalStateException("glyph table is frozen, subtable addition prohibited"); } // validate subtable to ensure consistency with current subtables validateSubtable(subtable); // insert subtable into ordered list for (ListIterator<GlyphSubtable> lit = subtables.listIterator(0); lit.hasNext(); ) { GlyphSubtable st = lit.next(); int d; if ((d = subtable.compareTo(st)) < 0) { // insert within list lit.set(subtable); lit.add(st); added = true; } else if (d == 0) { // duplicate entry is ignored added = false; subtable = null; } } // append at end of list if (!added && (subtable != null)) { subtables.add(subtable); added = true; } return added; } private void validateSubtable(GlyphSubtable subtable) { if (subtable == null) { throw new AdvancedTypographicTableFormatException("subtable must be non-null"); } if (subtable instanceof GlyphSubstitutionSubtable) { if (doesPos) { throw new AdvancedTypographicTableFormatException("subtable must be positioning subtable, but is: " + subtable); } else { doesSub = true; } } if (subtable instanceof GlyphPositioningSubtable) { if (doesSub) { throw new AdvancedTypographicTableFormatException("subtable must be substitution subtable, but is: " + subtable); } else { doesPos = true; } } if (subtables.size() > 0) { GlyphSubtable st = subtables.get(0); if (!st.isCompatible(subtable)) { throw new AdvancedTypographicTableFormatException("subtable " + subtable + " is not compatible with subtable " + st); } } } /** * Freeze subtables, i.e., do not allow further subtable addition, and * create resulting cached state. In addition, resolve any references to * lookup tables that appear in this lookup table's subtables. * @param lookupTables map from lookup table identifers, e.g. "lu4", to lookup tables */ public void freezeSubtables(Map<String, LookupTable> lookupTables) { if (!frozen) { GlyphSubtable[] sta = getSubtables(); resolveLookupReferences(sta, lookupTables); this.subtablesArray = sta; this.frozen = true; } } private void resolveLookupReferences(GlyphSubtable[] subtables, Map<String, LookupTable> lookupTables) { if (subtables != null) { for (GlyphSubtable st : subtables) { if (st != null) { st.resolveLookupReferences(lookupTables); } } } } /** * Determine if this glyph table performs substitution. * @return true if it performs substitution */ public boolean performsSubstitution() { return doesSub; } /** * Perform substitution processing using this lookup table's subtables. * @param gs an input glyph sequence * @param script a script identifier * @param language a language identifier * @param feature a feature identifier * @param sct a script specific context tester (or null) * @return the substituted (output) glyph sequence */ public GlyphSequence substitute(GlyphSequence gs, String script, String language, String feature, ScriptContextTester sct) { if (performsSubstitution()) { return GlyphSubstitutionSubtable.substitute(gs, script, language, feature, (GlyphSubstitutionSubtable[]) subtablesArray, sct); } else { return gs; } } /** * Perform substitution processing on an existing glyph substitution state object using this lookup table's subtables. * @param ss a glyph substitution state object * @param sequenceIndex if non negative, then apply subtables only at specified sequence index * @return the substituted (output) glyph sequence */ public GlyphSequence substitute(GlyphSubstitutionState ss, int sequenceIndex) { if (performsSubstitution()) { return GlyphSubstitutionSubtable.substitute(ss, (GlyphSubstitutionSubtable[]) subtablesArray, sequenceIndex); } else { return ss.getInput(); } } /** * Determine if this glyph table performs positioning. * @return true if it performs positioning */ public boolean performsPositioning() { return doesPos; } /** * Perform positioning processing using this lookup table's subtables. * @param gs an input glyph sequence * @param script a script identifier * @param language a language identifier * @param feature a feature identifier * @param fontSize size in device units * @param widths array of default advancements for each glyph in font * @param adjustments accumulated adjustments array (sequence) of 4-tuples of placement [PX,PY] and advance [AX,AY] adjustments, in that order, * with one 4-tuple for each element of glyph sequence * @param sct a script specific context tester (or null) * @return true if some adjustment is not zero; otherwise, false */ public boolean position(GlyphSequence gs, String script, String language, String feature, int fontSize, int[] widths, int[][] adjustments, ScriptContextTester sct) { if (performsPositioning()) { return GlyphPositioningSubtable.position(gs, script, language, feature, fontSize, (GlyphPositioningSubtable[]) subtablesArray, widths, adjustments, sct); } else { return false; } } /** * Perform positioning processing on an existing glyph positioning state object using this lookup table's subtables. * @param ps a glyph positioning state object * @param sequenceIndex if non negative, then apply subtables only at specified sequence index * @return true if some adjustment is not zero; otherwise, false */ public boolean position(GlyphPositioningState ps, int sequenceIndex) { if (performsPositioning()) { return GlyphPositioningSubtable.position(ps, (GlyphPositioningSubtable[]) subtablesArray, sequenceIndex); } else { return false; } } /** {@inheritDoc} */ public int hashCode() { return idOrdinal; } /** * {@inheritDoc} * @return true if identifier of the specified lookup table is the same * as the identifier of this lookup table */ public boolean equals(Object o) { if (o instanceof LookupTable) { LookupTable lt = (LookupTable) o; return idOrdinal == lt.idOrdinal; } else { return false; } } /** * {@inheritDoc} * @return the result of comparing the identifier of the specified lookup table with * the identifier of this lookup table; lookup table identifiers take the form * "lu(DIGIT)+", with comparison based on numerical ordering of numbers expressed by * (DIGIT)+. */ public int compareTo(Object o) { if (o instanceof LookupTable) { LookupTable lt = (LookupTable) o; int i = idOrdinal; int j = lt.idOrdinal; if (i < j) { return -1; } else if (i > j) { return 1; } else { return 0; } } else { return -1; } } /** {@inheritDoc} */ public String toString() { StringBuffer sb = new StringBuffer(); sb.append("{ "); sb.append("id = " + id); sb.append(", subtables = " + subtables); sb.append(" }"); return sb.toString(); } private static List<GlyphSubtable> makeSingleton(GlyphSubtable subtable) { if (subtable == null) { return null; } else { List<GlyphSubtable> stl = new ArrayList<GlyphSubtable>(1); stl.add(subtable); return stl; } } } /** * The <code>UseSpec</code> class comprises a lookup table reference * and the feature that selected the lookup table. */ public static class UseSpec implements Comparable { /** lookup table to apply */ private final LookupTable lookupTable; /** feature that caused selection of the lookup table */ private final String feature; /** * Construct a glyph lookup table use specification. * @param lookupTable a glyph lookup table * @param feature a feature that caused lookup table selection */ public UseSpec(LookupTable lookupTable, String feature) { this.lookupTable = lookupTable; this.feature = feature; } /** @return the lookup table */ public LookupTable getLookupTable() { return lookupTable; } /** @return the feature that selected this lookup table */ public String getFeature() { return feature; } /** * Perform substitution processing using this use specification's lookup table. * @param gs an input glyph sequence * @param script a script identifier * @param language a language identifier * @param sct a script specific context tester (or null) * @return the substituted (output) glyph sequence */ public GlyphSequence substitute(GlyphSequence gs, String script, String language, ScriptContextTester sct) { return lookupTable.substitute(gs, script, language, feature, sct); } /** * Perform positioning processing using this use specification's lookup table. * @param gs an input glyph sequence * @param script a script identifier * @param language a language identifier * @param fontSize size in device units * @param widths array of default advancements for each glyph in font * @param adjustments accumulated adjustments array (sequence) of 4-tuples of placement [PX,PY] and advance [AX,AY] adjustments, in that order, * with one 4-tuple for each element of glyph sequence * @param sct a script specific context tester (or null) * @return true if some adjustment is not zero; otherwise, false */ public boolean position(GlyphSequence gs, String script, String language, int fontSize, int[] widths, int[][] adjustments, ScriptContextTester sct) { return lookupTable.position(gs, script, language, feature, fontSize, widths, adjustments, sct); } /** {@inheritDoc} */ public int hashCode() { return lookupTable.hashCode(); } /** {@inheritDoc} */ public boolean equals(Object o) { if (o instanceof UseSpec) { UseSpec u = (UseSpec) o; return lookupTable.equals(u.lookupTable); } else { return false; } } /** {@inheritDoc} */ public int compareTo(Object o) { if (o instanceof UseSpec) { UseSpec u = (UseSpec) o; return lookupTable.compareTo(u.lookupTable); } else { return -1; } } } /** * The <code>RuleLookup</code> class implements a rule lookup record, comprising * a glyph sequence index and a lookup table index (in an applicable lookup list). */ public static class RuleLookup { private final int sequenceIndex; // index into input glyph sequence private final int lookupIndex; // lookup list index private LookupTable lookup; // resolved lookup table /** * Instantiate a RuleLookup. * @param sequenceIndex the index into the input sequence * @param lookupIndex the lookup table index */ public RuleLookup(int sequenceIndex, int lookupIndex) { this.sequenceIndex = sequenceIndex; this.lookupIndex = lookupIndex; this.lookup = null; } /** @return the sequence index */ public int getSequenceIndex() { return sequenceIndex; } /** @return the lookup index */ public int getLookupIndex() { return lookupIndex; } /** @return the lookup table */ public LookupTable getLookup() { return lookup; } /** * Resolve references to lookup tables. * @param lookupTables map from lookup table identifers, e.g. "lu4", to lookup tables */ public void resolveLookupReferences(Map<String, LookupTable> lookupTables) { if (lookupTables != null) { String lid = "lu" + Integer.toString(lookupIndex); LookupTable lt = lookupTables.get(lid); if (lt != null) { this.lookup = lt; } else { log.warn("unable to resolve glyph lookup table reference '" + lid + "' amongst lookup tables: " + lookupTables.values()); } } } /** {@inheritDoc} */ public String toString() { return "{ sequenceIndex = " + sequenceIndex + ", lookupIndex = " + lookupIndex + " }"; } } /** * The <code>Rule</code> class implements an array of rule lookup records. */ public abstract static class Rule { private final RuleLookup[] lookups; // rule lookups private final int inputSequenceLength; // input sequence length /** * Instantiate a Rule. * @param lookups the rule's lookups * @param inputSequenceLength the number of glyphs in the input sequence for this rule */ protected Rule(RuleLookup[] lookups, int inputSequenceLength) { assert lookups != null; this.lookups = lookups; this.inputSequenceLength = inputSequenceLength; } /** @return the lookups */ public RuleLookup[] getLookups() { return lookups; } /** @return the input sequence length */ public int getInputSequenceLength() { return inputSequenceLength; } /** * Resolve references to lookup tables, e.g., in RuleLookup, to the lookup tables themselves. * @param lookupTables map from lookup table identifers, e.g. "lu4", to lookup tables */ public void resolveLookupReferences(Map<String, LookupTable> lookupTables) { if (lookups != null) { for (RuleLookup l : lookups) { if (l != null) { l.resolveLookupReferences(lookupTables); } } } } /** {@inheritDoc} */ public String toString() { return "{ lookups = " + Arrays.toString(lookups) + ", inputSequenceLength = " + inputSequenceLength + " }"; } } /** * The <code>GlyphSequenceRule</code> class implements a subclass of <code>Rule</code> * that supports matching on a specific glyph sequence. */ public static class GlyphSequenceRule extends Rule { private final int[] glyphs; // glyphs /** * Instantiate a GlyphSequenceRule. * @param lookups the rule's lookups * @param inputSequenceLength number of glyphs constituting input sequence (to be consumed) * @param glyphs the rule's glyph sequence to match, starting with second glyph in sequence */ public GlyphSequenceRule(RuleLookup[] lookups, int inputSequenceLength, int[] glyphs) { super(lookups, inputSequenceLength); assert glyphs != null; this.glyphs = glyphs; } /** * Obtain glyphs. N.B. that this array starts with the second * glyph of the input sequence. * @return the glyphs */ public int[] getGlyphs() { return glyphs; } /** * Obtain glyphs augmented by specified first glyph entry. * @param firstGlyph to fill in first glyph entry * @return the glyphs augmented by first glyph */ public int[] getGlyphs(int firstGlyph) { int[] ga = new int [ glyphs.length + 1 ]; ga [ 0 ] = firstGlyph; System.arraycopy(glyphs, 0, ga, 1, glyphs.length); return ga; } /** {@inheritDoc} */ public String toString() { StringBuffer sb = new StringBuffer(); sb.append("{ "); sb.append("lookups = " + Arrays.toString(getLookups())); sb.append(", glyphs = " + Arrays.toString(glyphs)); sb.append(" }"); return sb.toString(); } } /** * The <code>ClassSequenceRule</code> class implements a subclass of <code>Rule</code> * that supports matching on a specific glyph class sequence. */ public static class ClassSequenceRule extends Rule { private final int[] classes; // glyph classes /** * Instantiate a ClassSequenceRule. * @param lookups the rule's lookups * @param inputSequenceLength number of glyphs constituting input sequence (to be consumed) * @param classes the rule's glyph class sequence to match, starting with second glyph in sequence */ public ClassSequenceRule(RuleLookup[] lookups, int inputSequenceLength, int[] classes) { super(lookups, inputSequenceLength); assert classes != null; this.classes = classes; } /** * Obtain glyph classes. N.B. that this array starts with the class of the second * glyph of the input sequence. * @return the classes */ public int[] getClasses() { return classes; } /** * Obtain glyph classes augmented by specified first class entry. * @param firstClass to fill in first class entry * @return the classes augmented by first class */ public int[] getClasses(int firstClass) { int[] ca = new int [ classes.length + 1 ]; ca [ 0 ] = firstClass; System.arraycopy(classes, 0, ca, 1, classes.length); return ca; } /** {@inheritDoc} */ public String toString() { StringBuffer sb = new StringBuffer(); sb.append("{ "); sb.append("lookups = " + Arrays.toString(getLookups())); sb.append(", classes = " + Arrays.toString(classes)); sb.append(" }"); return sb.toString(); } } /** * The <code>CoverageSequenceRule</code> class implements a subclass of <code>Rule</code> * that supports matching on a specific glyph coverage sequence. */ public static class CoverageSequenceRule extends Rule { private final GlyphCoverageTable[] coverages; // glyph coverages /** * Instantiate a ClassSequenceRule. * @param lookups the rule's lookups * @param inputSequenceLength number of glyphs constituting input sequence (to be consumed) * @param coverages the rule's glyph coverage sequence to match, starting with first glyph in sequence */ public CoverageSequenceRule(RuleLookup[] lookups, int inputSequenceLength, GlyphCoverageTable[] coverages) { super(lookups, inputSequenceLength); assert coverages != null; this.coverages = coverages; } /** @return the coverages */ public GlyphCoverageTable[] getCoverages() { return coverages; } /** {@inheritDoc} */ public String toString() { StringBuffer sb = new StringBuffer(); sb.append("{ "); sb.append("lookups = " + Arrays.toString(getLookups())); sb.append(", coverages = " + Arrays.toString(coverages)); sb.append(" }"); return sb.toString(); } } /** * The <code>ChainedGlyphSequenceRule</code> class implements a subclass of <code>GlyphSequenceRule</code> * that supports matching on a specific glyph sequence in a specific chained contextual. */ public static class ChainedGlyphSequenceRule extends GlyphSequenceRule { private final int[] backtrackGlyphs; // backtrack glyphs private final int[] lookaheadGlyphs; // lookahead glyphs /** * Instantiate a ChainedGlyphSequenceRule. * @param lookups the rule's lookups * @param inputSequenceLength number of glyphs constituting input sequence (to be consumed) * @param glyphs the rule's input glyph sequence to match, starting with second glyph in sequence * @param backtrackGlyphs the rule's backtrack glyph sequence to match, starting with first glyph in sequence * @param lookaheadGlyphs the rule's lookahead glyph sequence to match, starting with first glyph in sequence */ public ChainedGlyphSequenceRule(RuleLookup[] lookups, int inputSequenceLength, int[] glyphs, int[] backtrackGlyphs, int[] lookaheadGlyphs) { super(lookups, inputSequenceLength, glyphs); assert backtrackGlyphs != null; assert lookaheadGlyphs != null; this.backtrackGlyphs = backtrackGlyphs; this.lookaheadGlyphs = lookaheadGlyphs; } /** @return the backtrack glyphs */ public int[] getBacktrackGlyphs() { return backtrackGlyphs; } /** @return the lookahead glyphs */ public int[] getLookaheadGlyphs() { return lookaheadGlyphs; } /** {@inheritDoc} */ public String toString() { StringBuffer sb = new StringBuffer(); sb.append("{ "); sb.append("lookups = " + Arrays.toString(getLookups())); sb.append(", glyphs = " + Arrays.toString(getGlyphs())); sb.append(", backtrackGlyphs = " + Arrays.toString(backtrackGlyphs)); sb.append(", lookaheadGlyphs = " + Arrays.toString(lookaheadGlyphs)); sb.append(" }"); return sb.toString(); } } /** * The <code>ChainedClassSequenceRule</code> class implements a subclass of <code>ClassSequenceRule</code> * that supports matching on a specific glyph class sequence in a specific chained contextual. */ public static class ChainedClassSequenceRule extends ClassSequenceRule { private final int[] backtrackClasses; // backtrack classes private final int[] lookaheadClasses; // lookahead classes /** * Instantiate a ChainedClassSequenceRule. * @param lookups the rule's lookups * @param inputSequenceLength number of glyphs constituting input sequence (to be consumed) * @param classes the rule's input glyph class sequence to match, starting with second glyph in sequence * @param backtrackClasses the rule's backtrack glyph class sequence to match, starting with first glyph in sequence * @param lookaheadClasses the rule's lookahead glyph class sequence to match, starting with first glyph in sequence */ public ChainedClassSequenceRule(RuleLookup[] lookups, int inputSequenceLength, int[] classes, int[] backtrackClasses, int[] lookaheadClasses) { super(lookups, inputSequenceLength, classes); assert backtrackClasses != null; assert lookaheadClasses != null; this.backtrackClasses = backtrackClasses; this.lookaheadClasses = lookaheadClasses; } /** @return the backtrack classes */ public int[] getBacktrackClasses() { return backtrackClasses; } /** @return the lookahead classes */ public int[] getLookaheadClasses() { return lookaheadClasses; } /** {@inheritDoc} */ public String toString() { StringBuffer sb = new StringBuffer(); sb.append("{ "); sb.append("lookups = " + Arrays.toString(getLookups())); sb.append(", classes = " + Arrays.toString(getClasses())); sb.append(", backtrackClasses = " + Arrays.toString(backtrackClasses)); sb.append(", lookaheadClasses = " + Arrays.toString(lookaheadClasses)); sb.append(" }"); return sb.toString(); } } /** * The <code>ChainedCoverageSequenceRule</code> class implements a subclass of <code>CoverageSequenceRule</code> * that supports matching on a specific glyph class sequence in a specific chained contextual. */ public static class ChainedCoverageSequenceRule extends CoverageSequenceRule { private final GlyphCoverageTable[] backtrackCoverages; // backtrack coverages private final GlyphCoverageTable[] lookaheadCoverages; // lookahead coverages /** * Instantiate a ChainedCoverageSequenceRule. * @param lookups the rule's lookups * @param inputSequenceLength number of glyphs constituting input sequence (to be consumed) * @param coverages the rule's input glyph class sequence to match, starting with first glyph in sequence * @param backtrackCoverages the rule's backtrack glyph class sequence to match, starting with first glyph in sequence * @param lookaheadCoverages the rule's lookahead glyph class sequence to match, starting with first glyph in sequence */ public ChainedCoverageSequenceRule(RuleLookup[] lookups, int inputSequenceLength, GlyphCoverageTable[] coverages, GlyphCoverageTable[] backtrackCoverages, GlyphCoverageTable[] lookaheadCoverages) { super(lookups, inputSequenceLength, coverages); assert backtrackCoverages != null; assert lookaheadCoverages != null; this.backtrackCoverages = backtrackCoverages; this.lookaheadCoverages = lookaheadCoverages; } /** @return the backtrack coverages */ public GlyphCoverageTable[] getBacktrackCoverages() { return backtrackCoverages; } /** @return the lookahead coverages */ public GlyphCoverageTable[] getLookaheadCoverages() { return lookaheadCoverages; } /** {@inheritDoc} */ public String toString() { StringBuffer sb = new StringBuffer(); sb.append("{ "); sb.append("lookups = " + Arrays.toString(getLookups())); sb.append(", coverages = " + Arrays.toString(getCoverages())); sb.append(", backtrackCoverages = " + Arrays.toString(backtrackCoverages)); sb.append(", lookaheadCoverages = " + Arrays.toString(lookaheadCoverages)); sb.append(" }"); return sb.toString(); } } /** * The <code>RuleSet</code> class implements a collection of rules, which * may or may not be the same rule type. */ public static class RuleSet { private final Rule[] rules; // set of rules /** * Instantiate a Rule Set. * @param rules the rules * @throws AdvancedTypographicTableFormatException if rules or some element of rules is null */ public RuleSet(Rule[] rules) throws AdvancedTypographicTableFormatException { // enforce rules array instance if (rules == null) { throw new AdvancedTypographicTableFormatException("rules[] is null"); } this.rules = rules; } /** @return the rules */ public Rule[] getRules() { return rules; } /** * Resolve references to lookup tables, e.g., in RuleLookup, to the lookup tables themselves. * @param lookupTables map from lookup table identifers, e.g. "lu4", to lookup tables */ public void resolveLookupReferences(Map<String, LookupTable> lookupTables) { if (rules != null) { for (Rule r : rules) { if (r != null) { r.resolveLookupReferences(lookupTables); } } } } /** {@inheritDoc} */ public String toString() { return "{ rules = " + Arrays.toString(rules) + " }"; } } /** * The <code>HomogenousRuleSet</code> class implements a collection of rules, which * must be the same rule type (i.e., same concrete rule class) or null. */ public static class HomogeneousRuleSet extends RuleSet { /** * Instantiate a Homogeneous Rule Set. * @param rules the rules * @throws AdvancedTypographicTableFormatException if some rule[i] is not an instance of rule[0] */ public HomogeneousRuleSet(Rule[] rules) throws AdvancedTypographicTableFormatException { super(rules); // find first non-null rule Rule r0 = null; for (int i = 1, n = rules.length; (r0 == null) && (i < n); i++) { if (rules[i] != null) { r0 = rules[i]; } } // enforce rule instance homogeneity if (r0 != null) { Class c = r0.getClass(); for (int i = 1, n = rules.length; i < n; i++) { Rule r = rules[i]; if ((r != null) && !c.isInstance(r)) { throw new AdvancedTypographicTableFormatException("rules[" + i + "] is not an instance of " + c.getName()); } } } } } }
⏎ org/apache/fop/complexscripts/fonts/GlyphTable.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, 63855👍, 0💬
Popular Posts:
itextpdf.jar is a component in iText 5 Java library to provide core functionalities. iText Java libr...
What Is jaxb-impl-2.1.12.jar? Java Architecture for XML Binding (JAXB) is a Java API that allows Jav...
JDK 11 java.rmi.jmod is the JMOD file for JDK 11 RMI (Remote Method Invocation) module. JDK 11 RMI m...
JRE 8 rt.jar is the JAR file for JRE 8 RT (Runtime) libraries. JRE (Java Runtime) 8 is the runtime e...
Java Servlet 3.0 Specification API. JAR File Size and Download Location: File name: servlet-api.jar,...