| /* |
| * 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.nio.IntBuffer; |
| import java.util.ArrayList; |
| import java.util.List; |
| |
| import org.apache.fop.complexscripts.util.CharAssociation; |
| import org.apache.fop.complexscripts.util.GlyphContextTester; |
| import org.apache.fop.complexscripts.util.GlyphSequence; |
| import org.apache.fop.complexscripts.util.GlyphTester; |
| import org.apache.fop.complexscripts.util.ScriptContextTester; |
| |
| // CSOFF: LineLengthCheck |
| |
| /** |
| * <p>The <code>GlyphProcessingState</code> implements a common, base state object used during glyph substitution |
| * and positioning processing.</p> |
| * |
| * <p>This work was originally authored by Glenn Adams (gadams@apache.org).</p> |
| */ |
| |
| public class GlyphProcessingState { |
| |
| /** governing glyph definition table */ |
| protected GlyphDefinitionTable gdef; |
| /** governing script */ |
| protected String script; |
| /** governing language */ |
| protected String language; |
| /** governing feature */ |
| protected String feature; |
| /** current input glyph sequence */ |
| protected GlyphSequence igs; |
| /** current index in input sequence */ |
| protected int index; |
| /** last (maximum) index of input sequence (exclusive) */ |
| protected int indexLast; |
| /** consumed, updated after each successful subtable application */ |
| protected int consumed; |
| /** lookup flags */ |
| protected int lookupFlags; |
| /** class match set */ |
| protected int classMatchSet; |
| /** script specific context tester or null */ |
| protected ScriptContextTester sct; |
| /** glyph context tester or null */ |
| protected GlyphContextTester gct; |
| /** ignore base glyph tester */ |
| protected GlyphTester ignoreBase; |
| /** ignore ligature glyph tester */ |
| protected GlyphTester ignoreLigature; |
| /** ignore mark glyph tester */ |
| protected GlyphTester ignoreMark; |
| /** default ignore glyph tester */ |
| protected GlyphTester ignoreDefault; |
| /** current subtable */ |
| private GlyphSubtable subtable; |
| |
| /** |
| * Construct default (reset) glyph processing state. |
| */ |
| public GlyphProcessingState() { |
| } |
| |
| /** |
| * Construct glyph processing state. |
| * @param gs input glyph sequence |
| * @param script script identifier |
| * @param language language identifier |
| * @param feature feature identifier |
| * @param sct script context tester (or null) |
| */ |
| protected GlyphProcessingState(GlyphSequence gs, String script, String language, String feature, ScriptContextTester sct) { |
| this.script = script; |
| this.language = language; |
| this.feature = feature; |
| this.igs = gs; |
| this.indexLast = gs.getGlyphCount(); |
| this.sct = sct; |
| this.gct = (sct != null) ? sct.getTester(feature) : null; |
| this.ignoreBase = new GlyphTester() { public boolean test(int gi, int flags) { return isIgnoredBase(gi, flags); } }; |
| this.ignoreLigature = new GlyphTester() { public boolean test(int gi, int flags) { return isIgnoredLigature(gi, flags); } }; |
| this.ignoreMark = new GlyphTester() { public boolean test(int gi, int flags) { return isIgnoredMark(gi, flags); } }; |
| } |
| |
| /** |
| * Construct glyph processing state using an existing state object using shallow copy |
| * except as follows: input glyph sequence is copied deep except for its characters array. |
| * @param s existing processing state to copy from |
| */ |
| protected GlyphProcessingState(GlyphProcessingState s) { |
| this (new GlyphSequence(s.igs), s.script, s.language, s.feature, s.sct); |
| setPosition(s.index); |
| } |
| |
| /** |
| * Reset glyph processing state. |
| * @param gs input glyph sequence |
| * @param script script identifier |
| * @param language language identifier |
| * @param feature feature identifier |
| * @param sct script context tester (or null) |
| * @return this instance |
| */ |
| protected GlyphProcessingState reset(GlyphSequence gs, String script, String language, String feature, ScriptContextTester sct) { |
| this.gdef = null; |
| this.script = script; |
| this.language = language; |
| this.feature = feature; |
| this.igs = gs; |
| this.index = 0; |
| this.indexLast = gs.getGlyphCount(); |
| this.consumed = 0; |
| this.lookupFlags = 0; |
| this.classMatchSet = 0; // @SuppressFBWarnings("URF_UNREAD_PUBLIC_OR_PROTECTED_FIELD") |
| this.sct = sct; |
| this.gct = (sct != null) ? sct.getTester(feature) : null; |
| this.ignoreBase = new GlyphTester() { public boolean test(int gi, int flags) { return isIgnoredBase(gi, flags); } }; |
| this.ignoreLigature = new GlyphTester() { public boolean test(int gi, int flags) { return isIgnoredLigature(gi, flags); } }; |
| this.ignoreMark = new GlyphTester() { public boolean test(int gi, int flags) { return isIgnoredMark(gi, flags); } }; |
| this.ignoreDefault = null; |
| this.subtable = null; |
| return this; |
| } |
| |
| /** |
| * Set governing glyph definition table. |
| * @param gdef glyph definition table (or null, to unset) |
| */ |
| public void setGDEF(GlyphDefinitionTable gdef) { |
| if (this.gdef == null) { |
| this.gdef = gdef; |
| } else if (gdef == null) { |
| this.gdef = null; |
| } |
| } |
| |
| /** |
| * Obtain governing glyph definition table. |
| * @return glyph definition table (or null, to not set) |
| */ |
| public GlyphDefinitionTable getGDEF() { |
| return gdef; |
| } |
| |
| /** |
| * Set governing lookup flags |
| * @param flags lookup flags (or zero, to unset) |
| */ |
| public void setLookupFlags(int flags) { |
| if (this.lookupFlags == 0) { |
| this.lookupFlags = flags; |
| } else if (flags == 0) { |
| this.lookupFlags = 0; |
| } |
| } |
| |
| /** |
| * Obtain governing lookup flags. |
| * @return lookup flags (zero may indicate unset or no flags) |
| */ |
| public int getLookupFlags() { |
| return lookupFlags; |
| } |
| |
| /** |
| * Obtain governing class match set. |
| * @param gi glyph index that may be used to determine which match set applies |
| * @return class match set (zero may indicate unset or no set) |
| */ |
| public int getClassMatchSet(int gi) { |
| return 0; |
| } |
| |
| /** |
| * Set default ignore tester. |
| * @param ignoreDefault glyph tester (or null, to unset) |
| */ |
| public void setIgnoreDefault(GlyphTester ignoreDefault) { |
| if (this.ignoreDefault == null) { |
| this.ignoreDefault = ignoreDefault; |
| } else if (ignoreDefault == null) { |
| this.ignoreDefault = null; |
| } |
| } |
| |
| /** |
| * Obtain governing default ignores tester. |
| * @return default ignores tester |
| */ |
| public GlyphTester getIgnoreDefault() { |
| return ignoreDefault; |
| } |
| |
| /** |
| * Update glyph subtable specific state. Each time a |
| * different glyph subtable is to be applied, it is used |
| * to update this state prior to application, after which |
| * this state is to be reset. |
| * @param st glyph subtable to use for update |
| */ |
| public void updateSubtableState(GlyphSubtable st) { |
| if (this.subtable != st) { |
| setGDEF(st.getGDEF()); |
| setLookupFlags(st.getFlags()); |
| setIgnoreDefault(getIgnoreTester(getLookupFlags())); |
| this.subtable = st; |
| } |
| } |
| |
| /** |
| * Obtain current position index in input glyph sequence. |
| * @return current index |
| */ |
| public int getPosition() { |
| return index; |
| } |
| |
| /** |
| * Set (seek to) position index in input glyph sequence. |
| * @param index to seek to |
| * @throws IndexOutOfBoundsException if index is less than zero |
| * or exceeds last valid position |
| */ |
| public void setPosition(int index) throws IndexOutOfBoundsException { |
| if ((index >= 0) && (index <= indexLast)) { |
| this.index = index; |
| } else { |
| throw new IndexOutOfBoundsException(); |
| } |
| } |
| |
| /** |
| * Obtain last valid position index in input glyph sequence. |
| * @return current last index |
| */ |
| public int getLastPosition() { |
| return indexLast; |
| } |
| |
| /** |
| * Determine if at least one glyph remains in |
| * input sequence. |
| * @return true if one or more glyph remains |
| */ |
| public boolean hasNext() { |
| return hasNext(1); |
| } |
| |
| /** |
| * Determine if at least <code>count</code> glyphs remain in |
| * input sequence. |
| * @param count of glyphs to test |
| * @return true if at least <code>count</code> glyphs are available |
| */ |
| public boolean hasNext(int count) { |
| return (index + count) <= indexLast; |
| } |
| |
| /** |
| * Update the current position index based upon previously consumed |
| * glyphs, i.e., add the consuemd count to the current position index. |
| * If no glyphs were previously consumed, then forces exactly one |
| * glyph to be consumed. |
| * @return the new (updated) position index |
| */ |
| public int next() { |
| if (index < indexLast) { |
| // force consumption of at least one input glyph |
| if (consumed == 0) { |
| consumed = 1; |
| } |
| index += consumed; |
| consumed = 0; |
| if (index > indexLast) { |
| index = indexLast; |
| } |
| } |
| return index; |
| } |
| |
| /** |
| * Determine if at least one backtrack (previous) glyph is present |
| * in input sequence. |
| * @return true if one or more glyph remains |
| */ |
| public boolean hasPrev() { |
| return hasPrev(1); |
| } |
| |
| /** |
| * Determine if at least <code>count</code> backtrack (previous) glyphs |
| * are present in input sequence. |
| * @param count of glyphs to test |
| * @return true if at least <code>count</code> glyphs are available |
| */ |
| public boolean hasPrev(int count) { |
| return (index - count) >= 0; |
| } |
| |
| /** |
| * Update the current position index based upon previously consumed |
| * glyphs, i.e., subtract the consuemd count from the current position index. |
| * If no glyphs were previously consumed, then forces exactly one |
| * glyph to be consumed. This method is used to traverse an input |
| * glyph sequence in reverse order. |
| * @return the new (updated) position index |
| */ |
| public int prev() { |
| if (index > 0) { |
| // force consumption of at least one input glyph |
| if (consumed == 0) { |
| consumed = 1; |
| } |
| index -= consumed; |
| consumed = 0; |
| if (index < 0) { |
| index = 0; |
| } |
| } |
| return index; |
| } |
| |
| /** |
| * Record the consumption of <code>count</code> glyphs such that |
| * this consumption never exceeds the number of glyphs in the input glyph |
| * sequence. |
| * @param count of glyphs to consume |
| * @return newly adjusted consumption count |
| * @throws IndexOutOfBoundsException if count would cause consumption |
| * to exceed count of glyphs in input glyph sequence |
| */ |
| public int consume(int count) throws IndexOutOfBoundsException { |
| if ((consumed + count) <= indexLast) { |
| consumed += count; |
| return consumed; |
| } else { |
| throw new IndexOutOfBoundsException(); |
| } |
| } |
| |
| /** |
| * Determine if any consumption has occurred. |
| * @return true if consumption count is greater than zero |
| */ |
| public boolean didConsume() { |
| return consumed > 0; |
| } |
| |
| /** |
| * Obtain reference to input glyph sequence, which must not be modified. |
| * @return input glyph sequence |
| */ |
| public GlyphSequence getInput() { |
| return igs; |
| } |
| |
| /** |
| * Obtain glyph at specified offset from current position. |
| * @param offset from current position |
| * @return glyph at specified offset from current position |
| * @throws IndexOutOfBoundsException if no glyph available at offset |
| */ |
| public int getGlyph(int offset) throws IndexOutOfBoundsException { |
| int i = index + offset; |
| if ((i >= 0) && (i < indexLast)) { |
| return igs.getGlyph(i); |
| } else { |
| throw new IndexOutOfBoundsException("attempting index at " + i); |
| } |
| } |
| |
| /** |
| * Obtain glyph at current position. |
| * @return glyph at current position |
| * @throws IndexOutOfBoundsException if no glyph available |
| */ |
| public int getGlyph() throws IndexOutOfBoundsException { |
| return getGlyph(0); |
| } |
| |
| /** |
| * Set (replace) glyph at specified offset from current position. |
| * @param offset from current position |
| * @param glyph to set at specified offset from current position |
| * @throws IndexOutOfBoundsException if specified offset is not valid position |
| */ |
| public void setGlyph(int offset, int glyph) throws IndexOutOfBoundsException { |
| int i = index + offset; |
| if ((i >= 0) && (i < indexLast)) { |
| igs.setGlyph(i, glyph); |
| } else { |
| throw new IndexOutOfBoundsException("attempting index at " + i); |
| } |
| } |
| |
| /** |
| * Obtain character association of glyph at specified offset from current position. |
| * @param offset from current position |
| * @return character association of glyph at current position |
| * @throws IndexOutOfBoundsException if offset results in an invalid index into input glyph sequence |
| */ |
| public CharAssociation getAssociation(int offset) throws IndexOutOfBoundsException { |
| int i = index + offset; |
| if ((i >= 0) && (i < indexLast)) { |
| return igs.getAssociation(i); |
| } else { |
| throw new IndexOutOfBoundsException("attempting index at " + i); |
| } |
| } |
| |
| /** |
| * Obtain character association of glyph at current position. |
| * @return character association of glyph at current position |
| * @throws IndexOutOfBoundsException if no glyph available |
| */ |
| public CharAssociation getAssociation() throws IndexOutOfBoundsException { |
| return getAssociation(0); |
| } |
| |
| /** |
| * Obtain <code>count</code> glyphs starting at specified offset from current position. If |
| * <code>reverseOrder</code> is true, then glyphs are returned in reverse order starting at specified offset |
| * and going in reverse towards beginning of input glyph sequence. |
| * @param offset from current position |
| * @param count number of glyphs to obtain |
| * @param reverseOrder true if to obtain in reverse order |
| * @param ignoreTester glyph tester to use to determine which glyphs are ignored (or null, in which case none are ignored) |
| * @param glyphs array to use to fetch glyphs |
| * @param counts int[2] array to receive fetched glyph counts, where counts[0] will |
| * receive the number of glyphs obtained, and counts[1] will receive the number of glyphs |
| * ignored |
| * @return array of glyphs |
| * @throws IndexOutOfBoundsException if offset or count results in an |
| * invalid index into input glyph sequence |
| */ |
| public int[] getGlyphs(int offset, int count, boolean reverseOrder, GlyphTester ignoreTester, int[] glyphs, int[] counts) throws IndexOutOfBoundsException { |
| if (count < 0) { |
| count = getGlyphsAvailable(offset, reverseOrder, ignoreTester) [ 0 ]; |
| } |
| int start = index + offset; |
| if (start < 0) { |
| throw new IndexOutOfBoundsException("will attempt index at " + start); |
| } else if (!reverseOrder && ((start + count) > indexLast)) { |
| throw new IndexOutOfBoundsException("will attempt index at " + (start + count)); |
| } else if (reverseOrder && ((start + 1) < count)) { |
| throw new IndexOutOfBoundsException("will attempt index at " + (start - count)); |
| } |
| if (glyphs == null) { |
| glyphs = new int [ count ]; |
| } else if (glyphs.length != count) { |
| throw new IllegalArgumentException("glyphs array is non-null, but its length (" + glyphs.length + "), is not equal to count (" + count + ")"); |
| } |
| if (!reverseOrder) { |
| return getGlyphsForward(start, count, ignoreTester, glyphs, counts); |
| } else { |
| return getGlyphsReverse(start, count, ignoreTester, glyphs, counts); |
| } |
| } |
| |
| private int[] getGlyphsForward(int start, int count, GlyphTester ignoreTester, int[] glyphs, int[] counts) throws IndexOutOfBoundsException { |
| int counted = 0; |
| int ignored = 0; |
| for (int i = start, n = indexLast; (i < n) && (counted < count); i++) { |
| int gi = getGlyph(i - index); |
| if (gi == 65535) { |
| ignored++; |
| } else { |
| if ((ignoreTester == null) || !ignoreTester.test(gi, getLookupFlags())) { |
| glyphs [ counted++ ] = gi; |
| } else { |
| ignored++; |
| } |
| } |
| } |
| if ((counts != null) && (counts.length > 1)) { |
| counts[0] = counted; |
| counts[1] = ignored; |
| } |
| return glyphs; |
| } |
| |
| private int[] getGlyphsReverse(int start, int count, GlyphTester ignoreTester, int[] glyphs, int[] counts) throws IndexOutOfBoundsException { |
| int counted = 0; |
| int ignored = 0; |
| for (int i = start; (i >= 0) && (counted < count); i--) { |
| int gi = getGlyph(i - index); |
| if (gi == 65535) { |
| ignored++; |
| } else { |
| if ((ignoreTester == null) || !ignoreTester.test(gi, getLookupFlags())) { |
| glyphs [ counted++ ] = gi; |
| } else { |
| ignored++; |
| } |
| } |
| } |
| if ((counts != null) && (counts.length > 1)) { |
| counts[0] = counted; |
| counts[1] = ignored; |
| } |
| return glyphs; |
| } |
| |
| /** |
| * Obtain <code>count</code> glyphs starting at specified offset from current position. If |
| * offset is negative, then glyphs are returned in reverse order starting at specified offset |
| * and going in reverse towards beginning of input glyph sequence. |
| * @param offset from current position |
| * @param count number of glyphs to obtain |
| * @param glyphs array to use to fetch glyphs |
| * @param counts int[2] array to receive fetched glyph counts, where counts[0] will |
| * receive the number of glyphs obtained, and counts[1] will receive the number of glyphs |
| * ignored |
| * @return array of glyphs |
| * @throws IndexOutOfBoundsException if offset or count results in an |
| * invalid index into input glyph sequence |
| */ |
| public int[] getGlyphs(int offset, int count, int[] glyphs, int[] counts) throws IndexOutOfBoundsException { |
| return getGlyphs(offset, count, offset < 0, ignoreDefault, glyphs, counts); |
| } |
| |
| /** |
| * Obtain all glyphs starting from current position to end of input glyph sequence. |
| * @return array of available glyphs |
| * @throws IndexOutOfBoundsException if no glyph available |
| */ |
| public int[] getGlyphs() throws IndexOutOfBoundsException { |
| return getGlyphs(0, indexLast - index, false, null, null, null); |
| } |
| |
| /** |
| * Obtain <code>count</code> ignored glyphs starting at specified offset from current position. If |
| * <code>reverseOrder</code> is true, then glyphs are returned in reverse order starting at specified offset |
| * and going in reverse towards beginning of input glyph sequence. |
| * @param offset from current position |
| * @param count number of glyphs to obtain |
| * @param reverseOrder true if to obtain in reverse order |
| * @param ignoreTester glyph tester to use to determine which glyphs are ignored (or null, in which case none are ignored) |
| * @param glyphs array to use to fetch glyphs |
| * @param counts int[2] array to receive fetched glyph counts, where counts[0] will |
| * receive the number of glyphs obtained, and counts[1] will receive the number of glyphs |
| * ignored |
| * @return array of glyphs |
| * @throws IndexOutOfBoundsException if offset or count results in an |
| * invalid index into input glyph sequence |
| */ |
| public int[] getIgnoredGlyphs(int offset, int count, boolean reverseOrder, GlyphTester ignoreTester, int[] glyphs, int[] counts) throws IndexOutOfBoundsException { |
| return getGlyphs(offset, count, reverseOrder, new NotGlyphTester(ignoreTester), glyphs, counts); |
| } |
| |
| /** |
| * Obtain <code>count</code> ignored glyphs starting at specified offset from current position. If <code>offset</code> is |
| * negative, then fetch in reverse order. |
| * @param offset from current position |
| * @param count number of glyphs to obtain |
| * @return array of glyphs |
| * @throws IndexOutOfBoundsException if offset or count results in an |
| * invalid index into input glyph sequence |
| */ |
| public int[] getIgnoredGlyphs(int offset, int count) throws IndexOutOfBoundsException { |
| return getIgnoredGlyphs(offset, count, offset < 0, ignoreDefault, null, null); |
| } |
| |
| /** |
| * Determine if glyph at specified offset from current position is ignored. If <code>offset</code> is |
| * negative, then test in reverse order. |
| * @param offset from current position |
| * @param ignoreTester glyph tester to use to determine which glyphs are ignored (or null, in which case none are ignored) |
| * @return true if glyph is ignored |
| * @throws IndexOutOfBoundsException if offset results in an |
| * invalid index into input glyph sequence |
| */ |
| public boolean isIgnoredGlyph(int offset, GlyphTester ignoreTester) throws IndexOutOfBoundsException { |
| return (ignoreTester != null) && ignoreTester.test(getGlyph(offset), getLookupFlags()); |
| } |
| |
| /** |
| * Determine if glyph at specified offset from current position is ignored. If <code>offset</code> is |
| * negative, then test in reverse order. |
| * @param offset from current position |
| * @return true if glyph is ignored |
| * @throws IndexOutOfBoundsException if offset results in an |
| * invalid index into input glyph sequence |
| */ |
| public boolean isIgnoredGlyph(int offset) throws IndexOutOfBoundsException { |
| return isIgnoredGlyph(offset, ignoreDefault); |
| } |
| |
| /** |
| * Determine if glyph at current position is ignored. |
| * @return true if glyph is ignored |
| * @throws IndexOutOfBoundsException if offset results in an |
| * invalid index into input glyph sequence |
| */ |
| public boolean isIgnoredGlyph() throws IndexOutOfBoundsException { |
| return isIgnoredGlyph(getPosition()); |
| } |
| |
| /** |
| * Determine number of glyphs available starting at specified offset from current position. If |
| * <code>reverseOrder</code> is true, then search backwards in input glyph sequence. |
| * @param offset from current position |
| * @param reverseOrder true if to obtain in reverse order |
| * @param ignoreTester glyph tester to use to determine which glyphs to count (or null, in which case none are ignored) |
| * @return an int[2] array where counts[0] is the number of glyphs available, and counts[1] is the number of glyphs ignored |
| * @throws IndexOutOfBoundsException if offset or count results in an |
| * invalid index into input glyph sequence |
| */ |
| public int[] getGlyphsAvailable(int offset, boolean reverseOrder, GlyphTester ignoreTester) throws IndexOutOfBoundsException { |
| int start = index + offset; |
| if ((start < 0) || (start > indexLast)) { |
| return new int[] { 0, 0 }; |
| } else if (!reverseOrder) { |
| return getGlyphsAvailableForward(start, ignoreTester); |
| } else { |
| return getGlyphsAvailableReverse(start, ignoreTester); |
| } |
| } |
| |
| private int[] getGlyphsAvailableForward(int start, GlyphTester ignoreTester) throws IndexOutOfBoundsException { |
| int counted = 0; |
| int ignored = 0; |
| if (ignoreTester == null) { |
| counted = indexLast - start; |
| } else { |
| for (int i = start, n = indexLast; i < n; i++) { |
| int gi = getGlyph(i - index); |
| if (gi == 65535) { |
| ignored++; |
| } else { |
| if (ignoreTester.test(gi, getLookupFlags())) { |
| ignored++; |
| } else { |
| counted++; |
| } |
| } |
| } |
| } |
| return new int[] { counted, ignored }; |
| } |
| |
| private int[] getGlyphsAvailableReverse(int start, GlyphTester ignoreTester) throws IndexOutOfBoundsException { |
| int counted = 0; |
| int ignored = 0; |
| if (ignoreTester == null) { |
| counted = start + 1; |
| } else { |
| for (int i = start; i >= 0; i--) { |
| int gi = getGlyph(i - index); |
| if (gi == 65535) { |
| ignored++; |
| } else { |
| if (ignoreTester.test(gi, getLookupFlags())) { |
| ignored++; |
| } else { |
| counted++; |
| } |
| } |
| } |
| } |
| return new int[] { counted, ignored }; |
| } |
| |
| /** |
| * Determine number of glyphs available starting at specified offset from current position. If |
| * <code>reverseOrder</code> is true, then search backwards in input glyph sequence. Uses the |
| * default ignores tester. |
| * @param offset from current position |
| * @param reverseOrder true if to obtain in reverse order |
| * @return an int[2] array where counts[0] is the number of glyphs available, and counts[1] is the number of glyphs ignored |
| * @throws IndexOutOfBoundsException if offset or count results in an |
| * invalid index into input glyph sequence |
| */ |
| public int[] getGlyphsAvailable(int offset, boolean reverseOrder) throws IndexOutOfBoundsException { |
| return getGlyphsAvailable(offset, reverseOrder, ignoreDefault); |
| } |
| |
| /** |
| * Determine number of glyphs available starting at specified offset from current position. If |
| * offset is negative, then search backwards in input glyph sequence. Uses the |
| * default ignores tester. |
| * @param offset from current position |
| * @return an int[2] array where counts[0] is the number of glyphs available, and counts[1] is the number of glyphs ignored |
| * @throws IndexOutOfBoundsException if offset or count results in an |
| * invalid index into input glyph sequence |
| */ |
| public int[] getGlyphsAvailable(int offset) throws IndexOutOfBoundsException { |
| return getGlyphsAvailable(offset, offset < 0); |
| } |
| |
| /** |
| * Obtain <code>count</code> character associations of glyphs starting at specified offset from current position. If |
| * <code>reverseOrder</code> is true, then associations are returned in reverse order starting at specified offset |
| * and going in reverse towards beginning of input glyph sequence. |
| * @param offset from current position |
| * @param count number of associations to obtain |
| * @param reverseOrder true if to obtain in reverse order |
| * @param ignoreTester glyph tester to use to determine which glyphs are ignored (or null, in which case none are ignored) |
| * @param associations array to use to fetch associations |
| * @param counts int[2] array to receive fetched association counts, where counts[0] will |
| * receive the number of associations obtained, and counts[1] will receive the number of glyphs whose |
| * associations were ignored |
| * @return array of associations |
| * @throws IndexOutOfBoundsException if offset or count results in an |
| * invalid index into input glyph sequence |
| */ |
| public CharAssociation[] getAssociations(int offset, int count, boolean reverseOrder, GlyphTester ignoreTester, CharAssociation[] associations, int[] counts) |
| throws IndexOutOfBoundsException { |
| if (count < 0) { |
| count = getGlyphsAvailable(offset, reverseOrder, ignoreTester) [ 0 ]; |
| } |
| int start = index + offset; |
| if (start < 0) { |
| throw new IndexOutOfBoundsException("will attempt index at " + start); |
| } else if (!reverseOrder && ((start + count) > indexLast)) { |
| throw new IndexOutOfBoundsException("will attempt index at " + (start + count)); |
| } else if (reverseOrder && ((start + 1) < count)) { |
| throw new IndexOutOfBoundsException("will attempt index at " + (start - count)); |
| } |
| if (associations == null) { |
| associations = new CharAssociation [ count ]; |
| } else if (associations.length != count) { |
| throw new IllegalArgumentException("associations array is non-null, but its length (" + associations.length + "), is not equal to count (" + count + ")"); |
| } |
| if (!reverseOrder) { |
| return getAssociationsForward(start, count, ignoreTester, associations, counts); |
| } else { |
| return getAssociationsReverse(start, count, ignoreTester, associations, counts); |
| } |
| } |
| |
| private CharAssociation[] getAssociationsForward(int start, int count, GlyphTester ignoreTester, CharAssociation[] associations, int[] counts) |
| throws IndexOutOfBoundsException { |
| int counted = 0; |
| int ignored = 0; |
| for (int i = start, n = indexLast, k = 0; i < n; i++) { |
| int gi = getGlyph(i - index); |
| if (gi == 65535) { |
| ignored++; |
| } else { |
| if ((ignoreTester == null) || !ignoreTester.test(gi, getLookupFlags())) { |
| if (k < count) { |
| associations [ k++ ] = getAssociation(i - index); |
| counted++; |
| } else { |
| break; |
| } |
| } else { |
| ignored++; |
| } |
| } |
| } |
| if ((counts != null) && (counts.length > 1)) { |
| counts[0] = counted; |
| counts[1] = ignored; |
| } |
| return associations; |
| } |
| |
| private CharAssociation[] getAssociationsReverse(int start, int count, GlyphTester ignoreTester, CharAssociation[] associations, int[] counts) |
| throws IndexOutOfBoundsException { |
| int counted = 0; |
| int ignored = 0; |
| for (int i = start, k = 0; i >= 0; i--) { |
| int gi = getGlyph(i - index); |
| if (gi == 65535) { |
| ignored++; |
| } else { |
| if ((ignoreTester == null) || !ignoreTester.test(gi, getLookupFlags())) { |
| if (k < count) { |
| associations [ k++ ] = getAssociation(i - index); |
| counted++; |
| } else { |
| break; |
| } |
| } else { |
| ignored++; |
| } |
| } |
| } |
| if ((counts != null) && (counts.length > 1)) { |
| counts[0] = counted; |
| counts[1] = ignored; |
| } |
| return associations; |
| } |
| |
| /** |
| * Obtain <code>count</code> character associations of glyphs starting at specified offset from current position. If |
| * offset is negative, then search backwards in input glyph sequence. Uses the |
| * default ignores tester. |
| * @param offset from current position |
| * @param count number of associations to obtain |
| * @return array of associations |
| * @throws IndexOutOfBoundsException if offset or count results in an |
| * invalid index into input glyph sequence |
| */ |
| public CharAssociation[] getAssociations(int offset, int count) throws IndexOutOfBoundsException { |
| return getAssociations(offset, count, offset < 0, ignoreDefault, null, null); |
| } |
| |
| /** |
| * Obtain <code>count</code> character associations of ignored glyphs starting at specified offset from current position. If |
| * <code>reverseOrder</code> is true, then glyphs are returned in reverse order starting at specified offset |
| * and going in reverse towards beginning of input glyph sequence. |
| * @param offset from current position |
| * @param count number of character associations to obtain |
| * @param reverseOrder true if to obtain in reverse order |
| * @param ignoreTester glyph tester to use to determine which glyphs are ignored (or null, in which case none are ignored) |
| * @param associations array to use to fetch associations |
| * @param counts int[2] array to receive fetched association counts, where counts[0] will |
| * receive the number of associations obtained, and counts[1] will receive the number of glyphs whose |
| * associations were ignored |
| * @return array of associations |
| * @throws IndexOutOfBoundsException if offset or count results in an |
| * invalid index into input glyph sequence |
| */ |
| public CharAssociation[] getIgnoredAssociations(int offset, int count, boolean reverseOrder, GlyphTester ignoreTester, CharAssociation[] associations, int[] counts) |
| throws IndexOutOfBoundsException { |
| return getAssociations(offset, count, reverseOrder, new NotGlyphTester(ignoreTester), associations, counts); |
| } |
| |
| /** |
| * Obtain <code>count</code> character associations of ignored glyphs starting at specified offset from current position. If |
| * offset is negative, then search backwards in input glyph sequence. Uses the |
| * default ignores tester. |
| * @param offset from current position |
| * @param count number of character associations to obtain |
| * @return array of associations |
| * @throws IndexOutOfBoundsException if offset or count results in an |
| * invalid index into input glyph sequence |
| */ |
| public CharAssociation[] getIgnoredAssociations(int offset, int count) throws IndexOutOfBoundsException { |
| return getIgnoredAssociations(offset, count, offset < 0, ignoreDefault, null, null); |
| } |
| |
| /** |
| * Replace subsequence of input glyph sequence starting at specified offset from current position and of |
| * length <code>count</code> glyphs with a subsequence of the sequence <code>gs</code> starting from the specified |
| * offset <code>gsOffset</code> of length <code>gsCount</code> glyphs. |
| * @param offset from current position |
| * @param count number of glyphs to replace, which, if negative means all glyphs from offset to end of input sequence |
| * @param gs glyph sequence from which to obtain replacement glyphs |
| * @param gsOffset offset of first glyph in replacement sequence |
| * @param gsCount count of glyphs in replacement sequence starting at <code>gsOffset</code> |
| * @return true if replacement occurred, or false if replacement would result in no change to input glyph sequence |
| * @throws IndexOutOfBoundsException if offset or count results in an |
| * invalid index into input glyph sequence |
| */ |
| public boolean replaceInput(int offset, int count, GlyphSequence gs, int gsOffset, int gsCount) throws IndexOutOfBoundsException { |
| int nig = (igs != null) ? igs.getGlyphCount() : 0; |
| int position = getPosition() + offset; |
| if (position < 0) { |
| position = 0; |
| } else if (position > nig) { |
| position = nig; |
| } |
| if ((count < 0) || ((position + count) > nig)) { |
| count = nig - position; |
| } |
| int nrg = (gs != null) ? gs.getGlyphCount() : 0; |
| if (gsOffset < 0) { |
| gsOffset = 0; |
| } else if (gsOffset > nrg) { |
| gsOffset = nrg; |
| } |
| if ((gsCount < 0) || ((gsOffset + gsCount) > nrg)) { |
| gsCount = nrg - gsOffset; |
| } |
| int ng = nig + gsCount - count; |
| IntBuffer gb = IntBuffer.allocate(ng); |
| List al = new ArrayList(ng); |
| for (int i = 0, n = position; i < n; i++) { |
| gb.put(igs.getGlyph(i)); |
| al.add(igs.getAssociation(i)); |
| } |
| for (int i = gsOffset, n = gsOffset + gsCount; i < n; i++) { |
| gb.put(gs.getGlyph(i)); |
| al.add(gs.getAssociation(i)); |
| } |
| for (int i = position + count, n = nig; i < n; i++) { |
| gb.put(igs.getGlyph(i)); |
| al.add(igs.getAssociation(i)); |
| } |
| gb.flip(); |
| if (igs.compareGlyphs(gb) != 0) { |
| this.igs = new GlyphSequence(igs.getCharacters(), gb, al); |
| this.indexLast = gb.limit(); |
| return true; |
| } else { |
| return false; |
| } |
| } |
| |
| /** |
| * Replace subsequence of input glyph sequence starting at specified offset from current position and of |
| * length <code>count</code> glyphs with all glyphs in the replacement sequence <code>gs</code>. |
| * @param offset from current position |
| * @param count number of glyphs to replace, which, if negative means all glyphs from offset to end of input sequence |
| * @param gs glyph sequence from which to obtain replacement glyphs |
| * @return true if replacement occurred, or false if replacement would result in no change to input glyph sequence |
| * @throws IndexOutOfBoundsException if offset or count results in an |
| * invalid index into input glyph sequence |
| */ |
| public boolean replaceInput(int offset, int count, GlyphSequence gs) throws IndexOutOfBoundsException { |
| return replaceInput(offset, count, gs, 0, gs.getGlyphCount()); |
| } |
| |
| /** |
| * Erase glyphs in input glyph sequence starting at specified offset from current position, where each glyph |
| * in the specified <code>glyphs</code> array is matched, one at a time, and when a (forward searching) match is found |
| * in the input glyph sequence, the matching glyph is replaced with the glyph index 65535. |
| * @param offset from current position |
| * @param glyphs array of glyphs to erase |
| * @return the number of glyphs erased, which may be less than the number of specified glyphs |
| * @throws IndexOutOfBoundsException if offset or count results in an |
| * invalid index into input glyph sequence |
| */ |
| public int erase(int offset, int[] glyphs) throws IndexOutOfBoundsException { |
| int start = index + offset; |
| if ((start < 0) || (start > indexLast)) { |
| throw new IndexOutOfBoundsException("will attempt index at " + start); |
| } else { |
| int erased = 0; |
| for (int i = start - index, n = indexLast - start; i < n; i++) { |
| int gi = getGlyph(i); |
| if (gi == glyphs [ erased ]) { |
| setGlyph(i, 65535); |
| erased++; |
| } |
| } |
| return erased; |
| } |
| } |
| |
| /** |
| * Determine if is possible that the current input sequence satisfies a script specific |
| * context testing predicate. If no predicate applies, then application is always possible. |
| * @return true if no script specific context tester applies or if a specified tester returns |
| * true for the current input sequence context |
| */ |
| public boolean maybeApplicable() { |
| if (gct == null) { |
| return true; |
| } else { |
| return gct.test(script, language, feature, igs, index, getLookupFlags()); |
| } |
| } |
| |
| /** |
| * Apply default application semantices; namely, consume one glyph. |
| */ |
| public void applyDefault() { |
| consumed += 1; |
| } |
| |
| /** |
| * Determine if specified glyph is a base glyph according to the governing |
| * glyph definition table. |
| * @param gi glyph index to test |
| * @return true if glyph definition table records glyph as a base glyph; otherwise, false |
| */ |
| public boolean isBase(int gi) { |
| if (gdef != null) { |
| return gdef.isGlyphClass(gi, GlyphDefinitionTable.GLYPH_CLASS_BASE); |
| } else { |
| return false; |
| } |
| } |
| |
| /** |
| * Determine if specified glyph is an ignored base glyph according to the governing |
| * glyph definition table. |
| * @param gi glyph index to test |
| * @param flags that apply to lookup in scope |
| * @return true if glyph definition table records glyph as a base glyph; otherwise, false |
| */ |
| public boolean isIgnoredBase(int gi, int flags) { |
| return ((flags & GlyphSubtable.LF_IGNORE_BASE) != 0) && isBase(gi); |
| } |
| |
| /** |
| * Determine if specified glyph is an ligature glyph according to the governing |
| * glyph definition table. |
| * @param gi glyph index to test |
| * @return true if glyph definition table records glyph as a ligature glyph; otherwise, false |
| */ |
| public boolean isLigature(int gi) { |
| if (gdef != null) { |
| return gdef.isGlyphClass(gi, GlyphDefinitionTable.GLYPH_CLASS_LIGATURE); |
| } else { |
| return false; |
| } |
| } |
| |
| /** |
| * Determine if specified glyph is an ignored ligature glyph according to the governing |
| * glyph definition table. |
| * @param gi glyph index to test |
| * @param flags that apply to lookup in scope |
| * @return true if glyph definition table records glyph as a ligature glyph; otherwise, false |
| */ |
| public boolean isIgnoredLigature(int gi, int flags) { |
| return ((flags & GlyphSubtable.LF_IGNORE_LIGATURE) != 0) && isLigature(gi); |
| } |
| |
| /** |
| * Determine if specified glyph is a mark glyph according to the governing |
| * glyph definition table. |
| * @param gi glyph index to test |
| * @return true if glyph definition table records glyph as a mark glyph; otherwise, false |
| */ |
| public boolean isMark(int gi) { |
| if (gdef != null) { |
| return gdef.isGlyphClass(gi, GlyphDefinitionTable.GLYPH_CLASS_MARK); |
| } else { |
| return false; |
| } |
| } |
| |
| /** |
| * Determine if specified glyph is an ignored ligature glyph according to the governing |
| * glyph definition table. |
| * @param gi glyph index to test |
| * @param flags that apply to lookup in scope |
| * @return true if glyph definition table records glyph as a ligature glyph; otherwise, false |
| */ |
| public boolean isIgnoredMark(int gi, int flags) { |
| if ((flags & GlyphSubtable.LF_IGNORE_MARK) != 0) { |
| return isMark(gi); |
| } else if ((flags & GlyphSubtable.LF_MARK_ATTACHMENT_TYPE) != 0) { |
| int lac = (flags & GlyphSubtable.LF_MARK_ATTACHMENT_TYPE) >> 8; |
| int gac = gdef.getMarkAttachClass(gi); |
| return (gac != lac); |
| } else { |
| return false; |
| } |
| } |
| |
| /** |
| * Obtain an ignored glyph tester that corresponds to the specified lookup flags. |
| * @param flags lookup flags |
| * @return a glyph tester |
| */ |
| public GlyphTester getIgnoreTester(int flags) { |
| if ((flags & GlyphSubtable.LF_IGNORE_BASE) != 0) { |
| if ((flags & (GlyphSubtable.LF_IGNORE_LIGATURE | GlyphSubtable.LF_IGNORE_MARK)) == 0) { |
| return ignoreBase; |
| } else { |
| return getCombinedIgnoreTester(flags); |
| } |
| } |
| if ((flags & GlyphSubtable.LF_IGNORE_LIGATURE) != 0) { |
| if ((flags & (GlyphSubtable.LF_IGNORE_BASE | GlyphSubtable.LF_IGNORE_MARK)) == 0) { |
| return ignoreLigature; |
| } else { |
| return getCombinedIgnoreTester(flags); |
| } |
| } |
| if ((flags & GlyphSubtable.LF_IGNORE_MARK) != 0) { |
| if ((flags & (GlyphSubtable.LF_IGNORE_BASE | GlyphSubtable.LF_IGNORE_LIGATURE)) == 0) { |
| return ignoreMark; |
| } else { |
| return getCombinedIgnoreTester(flags); |
| } |
| } |
| return null; |
| } |
| |
| /** |
| * Obtain an ignored glyph tester that corresponds to the specified multiple (combined) lookup flags. |
| * @param flags lookup flags |
| * @return a glyph tester |
| */ |
| public GlyphTester getCombinedIgnoreTester(int flags) { |
| GlyphTester[] gta = new GlyphTester [ 3 ]; |
| int ngt = 0; |
| if ((flags & GlyphSubtable.LF_IGNORE_BASE) != 0) { |
| gta [ ngt++ ] = ignoreBase; |
| } |
| if ((flags & GlyphSubtable.LF_IGNORE_LIGATURE) != 0) { |
| gta [ ngt++ ] = ignoreLigature; |
| } |
| if ((flags & GlyphSubtable.LF_IGNORE_MARK) != 0) { |
| gta [ ngt++ ] = ignoreMark; |
| } |
| return getCombinedOrTester(gta, ngt); |
| } |
| |
| /** |
| * Obtain an combined OR glyph tester. |
| * @param gta an array of glyph testers |
| * @param ngt number of glyph testers present in specified array |
| * @return a combined OR glyph tester |
| */ |
| public GlyphTester getCombinedOrTester(GlyphTester[] gta, int ngt) { |
| if (ngt > 0) { |
| return new CombinedOrGlyphTester(gta, ngt); |
| } else { |
| return null; |
| } |
| } |
| |
| /** |
| * Obtain an combined AND glyph tester. |
| * @param gta an array of glyph testers |
| * @param ngt number of glyph testers present in specified array |
| * @return a combined AND glyph tester |
| */ |
| public GlyphTester getCombinedAndTester(GlyphTester[] gta, int ngt) { |
| if (ngt > 0) { |
| return new CombinedAndGlyphTester(gta, ngt); |
| } else { |
| return null; |
| } |
| } |
| |
| /** combined OR glyph tester */ |
| private static class CombinedOrGlyphTester implements GlyphTester { |
| private GlyphTester[] gta; |
| private int ngt; |
| CombinedOrGlyphTester(GlyphTester[] gta, int ngt) { |
| this.gta = gta; |
| this.ngt = ngt; |
| } |
| /** {@inheritDoc} */ |
| public boolean test(int gi, int flags) { |
| for (int i = 0, n = ngt; i < n; i++) { |
| GlyphTester gt = gta [ i ]; |
| if (gt != null) { |
| if (gt.test(gi, flags)) { |
| return true; |
| } |
| } |
| } |
| return false; |
| } |
| } |
| |
| /** combined AND glyph tester */ |
| private static class CombinedAndGlyphTester implements GlyphTester { |
| private GlyphTester[] gta; |
| private int ngt; |
| CombinedAndGlyphTester(GlyphTester[] gta, int ngt) { |
| this.gta = gta; |
| this.ngt = ngt; |
| } |
| /** {@inheritDoc} */ |
| public boolean test(int gi, int flags) { |
| for (int i = 0, n = ngt; i < n; i++) { |
| GlyphTester gt = gta [ i ]; |
| if (gt != null) { |
| if (!gt.test(gi, flags)) { |
| return false; |
| } |
| } |
| } |
| return true; |
| } |
| } |
| |
| /** NOT glyph tester */ |
| private static class NotGlyphTester implements GlyphTester { |
| private GlyphTester gt; |
| NotGlyphTester(GlyphTester gt) { |
| this.gt = gt; |
| } |
| /** {@inheritDoc} */ |
| public boolean test(int gi, int flags) { |
| if (gt != null) { |
| if (gt.test(gi, flags)) { |
| return false; |
| } |
| } |
| return true; |
| } |
| } |
| |
| } |
