Base class for all advanced typographic glyph tables.
* *This work was originally authored by Glenn Adams (gadams@apache.org).
*/ 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/*LookupTable 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/*UseSpec 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 RuleLookup 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/*Rule 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/*GlyphSequenceRule class implements a subclass of Rule
* 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 ClassSequenceRule class implements a subclass of Rule
* 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 CoverageSequenceRule class implements a subclass of Rule
* 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 ChainedGlyphSequenceRule class implements a subclass of GlyphSequenceRule
* 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 ChainedClassSequenceRule class implements a subclass of ClassSequenceRule
* 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 ChainedCoverageSequenceRule class implements a subclass of CoverageSequenceRule
* 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 RuleSet 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/*HomogenousRuleSet 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());
}
}
}
}
}
}