<!-- ... ... ... ... ... ... ... ... ... ... ... ... ... ... ... ... ... ... ... ... ... ... ... ... ... -->
<!-- ... ... ... ... ... ... ... ... ... ... ... ... ... ... ... ... ... ... ... ... ... ... ... ... ... -->
- <!-- <module name="MethodParamPad"/> produces 4316 new errors -->
+ <module name="MethodParamPad"/>
<!-- ... ... ... ... ... ... ... ... ... ... ... ... ... ... ... ... ... ... ... ... ... ... ... ... ... -->
<!-- ... ... ... ... ... ... ... ... ... ... ... ... ... ... ... ... ... ... ... ... ... ... ... ... ... -->
out.println("}");
out.println();
dumpData(out);
- out.println ("/**");
- out.println (" * Lookup bidi class for character expressed as unicode scalar value.");
- out.println (" * @param ch a unicode scalar value");
- out.println (" * @return bidi class");
- out.println (" */");
+ out.println("/**");
+ out.println(" * Lookup bidi class for character expressed as unicode scalar value.");
+ out.println(" * @param ch a unicode scalar value");
+ out.println(" * @return bidi class");
+ out.println(" */");
out.println("public static int getBidiClass ( int ch ) {");
out.println(" if ( ch <= 0x00FF ) {");
out.println(" return bcL1 [ ch - 0x0000 ];");
} else if (line.length() == 0) {
continue;
} else {
- if (line.indexOf ("#") != -1) {
- line = (line.split ("#")) [ 0 ];
+ if (line.indexOf("#") != -1) {
+ line = (line.split("#")) [ 0 ];
}
- String[] fa = line.split (";");
+ String[] fa = line.split(";");
if (fa.length == 2) {
- int[] interval = parseInterval (fa[0].trim());
- byte bidiClass = (byte) parseBidiClass (fa[1].trim());
+ int[] interval = parseInterval(fa[0].trim());
+ byte bidiClass = (byte) parseBidiClass(fa[1].trim());
if (interval[1] == interval[0]) { // singleton
int c = interval[0];
if (c <= 0x00FF) {
if (bcL1 [ c - 0x0000 ] == 0) {
bcL1 [ c - 0x0000 ] = bidiClass;
} else {
- throw new Exception ("duplicate singleton entry: " + c);
+ throw new Exception("duplicate singleton entry: " + c);
}
} else if ((c >= 0x0590) && (c <= 0x06FF)) {
if (bcR1 [ c - 0x0590 ] == 0) {
bcR1 [ c - 0x0590 ] = bidiClass;
} else {
- throw new Exception ("duplicate singleton entry: " + c);
+ throw new Exception("duplicate singleton entry: " + c);
}
} else {
- addInterval (intervals, c, c, bidiClass);
+ addInterval(intervals, c, c, bidiClass);
}
} else { // non-singleton
int s = interval[0];
if (bcL1 [ i - 0x0000 ] == 0) {
bcL1 [ i - 0x0000 ] = bidiClass;
} else {
- throw new Exception ("duplicate singleton entry: " + i);
+ throw new Exception("duplicate singleton entry: " + i);
}
} else {
- addInterval (intervals, i, e, bidiClass);
+ addInterval(intervals, i, e, bidiClass);
break;
}
}
if (bcR1 [ i - 0x0590 ] == 0) {
bcR1 [ i - 0x0590 ] = bidiClass;
} else {
- throw new Exception ("duplicate singleton entry: " + i);
+ throw new Exception("duplicate singleton entry: " + i);
}
} else {
- addInterval (intervals, i, e, bidiClass);
+ addInterval(intervals, i, e, bidiClass);
break;
}
}
} else {
- addInterval (intervals, s, e, bidiClass);
+ addInterval(intervals, s, e, bidiClass);
}
}
} else {
- throw new Exception ("bad syntax, line(" + lineNumber + "): " + line);
+ throw new Exception("bad syntax, line(" + lineNumber + "): " + line);
}
}
}
test();
}
- private static int[] parseInterval (String interval) throws Exception {
+ private static int[] parseInterval(String interval) throws Exception {
int s;
int e;
String[] fa = interval.split("\\.\\.");
if (fa.length == 1) {
- s = Integer.parseInt (fa[0], 16);
+ s = Integer.parseInt(fa[0], 16);
e = s;
} else if (fa.length == 2) {
- s = Integer.parseInt (fa[0], 16);
- e = Integer.parseInt (fa[1], 16);
+ s = Integer.parseInt(fa[0], 16);
+ e = Integer.parseInt(fa[1], 16);
} else {
- throw new Exception ("bad interval syntax: " + interval);
+ throw new Exception("bad interval syntax: " + interval);
}
if (e < s) {
- throw new Exception ("bad interval, start must be less than or equal to end: " + interval);
+ throw new Exception("bad interval, start must be less than or equal to end: " + interval);
}
return new int[] {s, e};
}
- private static int parseBidiClass (String bidiClass) {
+ private static int parseBidiClass(String bidiClass) {
int bc = 0;
- if ("L".equals (bidiClass)) {
+ if ("L".equals(bidiClass)) {
bc = BidiConstants.L;
- } else if ("LRE".equals (bidiClass)) {
+ } else if ("LRE".equals(bidiClass)) {
bc = BidiConstants.LRE;
- } else if ("LRO".equals (bidiClass)) {
+ } else if ("LRO".equals(bidiClass)) {
bc = BidiConstants.LRO;
- } else if ("R".equals (bidiClass)) {
+ } else if ("R".equals(bidiClass)) {
bc = BidiConstants.R;
- } else if ("AL".equals (bidiClass)) {
+ } else if ("AL".equals(bidiClass)) {
bc = BidiConstants.AL;
- } else if ("RLE".equals (bidiClass)) {
+ } else if ("RLE".equals(bidiClass)) {
bc = BidiConstants.RLE;
- } else if ("RLO".equals (bidiClass)) {
+ } else if ("RLO".equals(bidiClass)) {
bc = BidiConstants.RLO;
- } else if ("PDF".equals (bidiClass)) {
+ } else if ("PDF".equals(bidiClass)) {
bc = BidiConstants.PDF;
- } else if ("EN".equals (bidiClass)) {
+ } else if ("EN".equals(bidiClass)) {
bc = BidiConstants.EN;
- } else if ("ES".equals (bidiClass)) {
+ } else if ("ES".equals(bidiClass)) {
bc = BidiConstants.ES;
- } else if ("ET".equals (bidiClass)) {
+ } else if ("ET".equals(bidiClass)) {
bc = BidiConstants.ET;
- } else if ("AN".equals (bidiClass)) {
+ } else if ("AN".equals(bidiClass)) {
bc = BidiConstants.AN;
- } else if ("CS".equals (bidiClass)) {
+ } else if ("CS".equals(bidiClass)) {
bc = BidiConstants.CS;
- } else if ("NSM".equals (bidiClass)) {
+ } else if ("NSM".equals(bidiClass)) {
bc = BidiConstants.NSM;
- } else if ("BN".equals (bidiClass)) {
+ } else if ("BN".equals(bidiClass)) {
bc = BidiConstants.BN;
- } else if ("B".equals (bidiClass)) {
+ } else if ("B".equals(bidiClass)) {
bc = BidiConstants.B;
- } else if ("S".equals (bidiClass)) {
+ } else if ("S".equals(bidiClass)) {
bc = BidiConstants.S;
- } else if ("WS".equals (bidiClass)) {
+ } else if ("WS".equals(bidiClass)) {
bc = BidiConstants.WS;
- } else if ("ON".equals (bidiClass)) {
+ } else if ("ON".equals(bidiClass)) {
bc = BidiConstants.ON;
} else {
- throw new IllegalArgumentException ("unknown bidi class: " + bidiClass);
+ throw new IllegalArgumentException("unknown bidi class: " + bidiClass);
}
return bc;
}
- private static void addInterval (SortedSet intervals, int start, int end, int bidiClass) {
- intervals.add (new Interval (start, end, bidiClass));
+ private static void addInterval(SortedSet intervals, int start, int end, int bidiClass) {
+ intervals.add(new Interval(start, end, bidiClass));
}
- private static void dumpData (PrintWriter out) {
+ private static void dumpData(PrintWriter out) {
boolean first;
StringBuffer sb = new StringBuffer();
// bcL1
first = true;
sb.setLength(0);
- out.println ("private static byte[] bcL1 = {");
+ out.println("private static byte[] bcL1 = {");
for (int i = 0; i < bcL1.length; i++) {
if (! first) {
- sb.append (",");
+ sb.append(",");
} else {
first = false;
}
- sb.append (bcL1[i]);
+ sb.append(bcL1[i]);
if (sb.length() > 120) {
sb.append(',');
out.println(sb);
if (sb.length() > 0) {
out.println(sb);
}
- out.println ("};");
+ out.println("};");
out.println();
// bcR1
first = true;
sb.setLength(0);
- out.println ("private static byte[] bcR1 = {");
+ out.println("private static byte[] bcR1 = {");
for (int i = 0; i < bcR1.length; i++) {
if (! first) {
- sb.append (",");
+ sb.append(",");
} else {
first = false;
}
- sb.append (bcR1[i]);
+ sb.append(bcR1[i]);
if (sb.length() > 120) {
sb.append(',');
out.println(sb);
if (sb.length() > 0) {
out.println(sb);
}
- out.println ("};");
+ out.println("};");
out.println();
// bcS1
first = true;
sb.setLength(0);
- out.println ("private static int[] bcS1 = {");
+ out.println("private static int[] bcS1 = {");
for (int i = 0; i < bcS1.length; i++) {
if (! first) {
- sb.append (",");
+ sb.append(",");
} else {
first = false;
}
- sb.append (bcS1[i]);
+ sb.append(bcS1[i]);
if (sb.length() > 120) {
sb.append(',');
out.println(sb);
if (sb.length() > 0) {
out.println(sb);
}
- out.println ("};");
+ out.println("};");
out.println();
// bcE1
first = true;
sb.setLength(0);
- out.println ("private static int[] bcE1 = {");
+ out.println("private static int[] bcE1 = {");
for (int i = 0; i < bcE1.length; i++) {
if (! first) {
- sb.append (",");
+ sb.append(",");
} else {
first = false;
}
- sb.append (bcE1[i]);
+ sb.append(bcE1[i]);
if (sb.length() > 120) {
sb.append(',');
out.println(sb);
if (sb.length() > 0) {
out.println(sb);
}
- out.println ("};");
+ out.println("};");
out.println();
// bcC1
first = true;
sb.setLength(0);
- out.println ("private static byte[] bcC1 = {");
+ out.println("private static byte[] bcC1 = {");
for (int i = 0; i < bcC1.length; i++) {
if (! first) {
- sb.append (",");
+ sb.append(",");
} else {
first = false;
}
- sb.append (bcC1[i]);
+ sb.append(bcC1[i]);
if (sb.length() > 120) {
sb.append(',');
out.println(sb);
if (sb.length() > 0) {
out.println(sb);
}
- out.println ("};");
+ out.println("};");
out.println();
}
- private static int getBidiClass (int ch) {
+ private static int getBidiClass(int ch) {
if (ch <= 0x00FF) {
return bcL1 [ ch - 0x0000 ];
} else if ((ch >= 0x0590) && (ch <= 0x06FF)) {
return bcR1 [ ch - 0x0590 ];
} else {
- return getBidiClass (ch, bcS1, bcE1, bcC1);
+ return getBidiClass(ch, bcS1, bcE1, bcC1);
}
}
- private static int getBidiClass (int ch, int[] sa, int[] ea, byte[] ca) {
- int k = Arrays.binarySearch (sa, ch);
+ private static int getBidiClass(int ch, int[] sa, int[] ea, byte[] ca) {
+ int k = Arrays.binarySearch(sa, ch);
if (k >= 0) {
return ca [ k ];
} else {
for (int i = 0, n = testData.length / 2; i < n; i++) {
int ch = testData [ i * 2 + 0 ];
int tc = testData [ i * 2 + 1 ];
- int bc = getBidiClass (ch);
+ int bc = getBidiClass(ch);
if (bc != tc) {
- throw new Exception ("test mapping failed for character (0x" + Integer.toHexString(ch) + "): expected " + tc + ", got " + bc);
+ throw new Exception("test mapping failed for character (0x" + Integer.toHexString(ch) + "): expected " + tc + ", got " + bc);
}
}
}
int start; // CSOK: VisibilityModifier
int end; // CSOK: VisibilityModifier
int bidiClass; // CSOK: VisibilityModifier
- Interval (int start, int end, int bidiClass) {
+ Interval(int start, int end, int bidiClass) {
this.start = start;
this.end = end;
this.bidiClass = bidiClass;
}
- public int compareTo (Object o) {
+ public int compareTo(Object o) {
Interval iv = (Interval) o;
if (start < iv.start) {
return -1;
out.println(" private BidiTestData() {");
out.println(" }");
out.println();
- dumpData (out, outFileName);
+ dumpData(out, outFileName);
out.println(" public static final int NUM_TEST_SEQUENCES = " + numTestSpecs + ";");
out.println();
out.println(" public static int[] readTestData ( String prefix, int index ) {");
} else if (line.startsWith("#")) {
continue;
} else {
- parseTypeProperties (line, sm, im);
+ parseTypeProperties(line, sm, im);
}
}
// extract type data list
- List tdl = processTypeData (sm, im, new ArrayList());
+ List tdl = processTypeData(sm, im, new ArrayList());
// dump instrumentation
if (verbose) {
System.out.println();
System.out.println("Read type ranges : " + numTypeRanges);
System.out.println("Read lines : " + lineNumber);
}
- td = (int[][]) tdl.toArray (new int [ tdl.size() ] []);
+ td = (int[][]) tdl.toArray(new int [ tdl.size() ] []);
}
- private static void parseTypeProperties (String line, Map/*<Integer,List>*/ sm, Map/*<String,int[3]>*/ im) {
+ private static void parseTypeProperties(String line, Map/*<Integer,List>*/ sm, Map/*<String,int[3]>*/ im) {
String[] sa = line.split(";");
if (sa.length >= 5) {
- int uc = Integer.parseInt (sa[0], 16);
- int bc = parseBidiClassAny (sa[4]);
+ int uc = Integer.parseInt(sa[0], 16);
+ int bc = parseBidiClassAny(sa[4]);
if (bc >= 0) {
String ucName = sa[1];
- if (isBlockStart (ucName)) {
- String ucBlock = getBlockName (ucName);
- if (! im.containsKey (ucBlock)) {
- im.put (ucBlock, new int[] { uc, -1, bc });
+ if (isBlockStart(ucName)) {
+ String ucBlock = getBlockName(ucName);
+ if (! im.containsKey(ucBlock)) {
+ im.put(ucBlock, new int[] { uc, -1, bc });
} else {
- throw new IllegalArgumentException ("duplicate start of block '" + ucBlock + "' at entry: " + line);
+ throw new IllegalArgumentException("duplicate start of block '" + ucBlock + "' at entry: " + line);
}
- } else if (isBlockEnd (ucName)) {
- String ucBlock = getBlockName (ucName);
- if (im.containsKey (ucBlock)) {
- int[] ba = (int[]) im.get (ucBlock);
+ } else if (isBlockEnd(ucName)) {
+ String ucBlock = getBlockName(ucName);
+ if (im.containsKey(ucBlock)) {
+ int[] ba = (int[]) im.get(ucBlock);
assert ba.length == 3;
if (ba[1] < 0) {
ba[1] = uc;
} else {
- throw new IllegalArgumentException ("duplicate end of block '" + ucBlock + "' at entry: " + line);
+ throw new IllegalArgumentException("duplicate end of block '" + ucBlock + "' at entry: " + line);
}
} else {
- throw new IllegalArgumentException ("missing start of block '" + ucBlock + "' at entry: " + line);
+ throw new IllegalArgumentException("missing start of block '" + ucBlock + "' at entry: " + line);
}
} else {
- Integer k = Integer.valueOf (bc);
+ Integer k = Integer.valueOf(bc);
List sl;
- if (! sm.containsKey (k)) {
+ if (! sm.containsKey(k)) {
sl = new ArrayList();
- sm.put (k, sl);
+ sm.put(k, sl);
} else {
- sl = (List) sm.get (k);
+ sl = (List) sm.get(k);
}
assert sl != null;
- sl.add (Integer.valueOf (uc));
+ sl.add(Integer.valueOf(uc));
}
} else {
- throw new IllegalArgumentException ("invalid bidi class '" + sa[4] + "' at entry: " + line);
+ throw new IllegalArgumentException("invalid bidi class '" + sa[4] + "' at entry: " + line);
}
} else {
- throw new IllegalArgumentException ("invalid unicode character database entry: " + line);
+ throw new IllegalArgumentException("invalid unicode character database entry: " + line);
}
}
- private static boolean isBlockStart (String s) {
+ private static boolean isBlockStart(String s) {
return s.startsWith("<") && s.endsWith("First>");
}
- private static boolean isBlockEnd (String s) {
+ private static boolean isBlockEnd(String s) {
return s.startsWith("<") && s.endsWith("Last>");
}
- private static String getBlockName (String s) {
- String[] sa = s.substring (1, s.length() - 1).split(",");
+ private static String getBlockName(String s) {
+ String[] sa = s.substring(1, s.length() - 1).split(",");
assert (sa != null) && (sa.length > 0);
return sa[0].trim();
}
- private static List processTypeData (Map/*<Integer,List>*/ sm, Map/*<String,int[3]>*/ im, List tdl) {
+ private static List processTypeData(Map/*<Integer,List>*/ sm, Map/*<String,int[3]>*/ im, List tdl) {
for (int i = BidiConstants.FIRST, k = BidiConstants.LAST; i <= k; i++) {
Map/*<Integer,Integer>*/ rm = new TreeMap/*<Integer,Integer>*/();
// populate intervals from singleton map
- List sl = (List) sm.get (Integer.valueOf (i));
+ List sl = (List) sm.get(Integer.valueOf(i));
if (sl != null) {
for (Iterator it = sl.iterator(); it.hasNext(); ) {
Integer s = (Integer) it.next();
int uc = s.intValue();
- rm.put (Integer.valueOf (uc), Integer.valueOf (uc + 1));
+ rm.put(Integer.valueOf(uc), Integer.valueOf(uc + 1));
}
}
// populate intervals from (block) interval map
int[] ba = (int[]) it.next();
assert (ba != null) && (ba.length > 2);
if (ba[2] == i) {
- rm.put (Integer.valueOf (ba[0]), Integer.valueOf (ba[1] + 1));
+ rm.put(Integer.valueOf(ba[0]), Integer.valueOf(ba[1] + 1));
}
}
}
- tdl.add (createTypeData (i, extractRanges (rm)));
+ tdl.add(createTypeData(i, extractRanges(rm)));
}
return tdl;
}
- private static List extractRanges (Map/*<Integer,Integer>*/ rm) {
+ private static List extractRanges(Map/*<Integer,Integer>*/ rm) {
List ranges = new ArrayList();
int sLast = 0;
int eLast = 0;
int e = ((Integer) me.getValue()).intValue();
if (s > eLast) {
if (eLast > sLast) {
- ranges.add (new int[] { sLast, eLast });
+ ranges.add(new int[] { sLast, eLast });
if (verbose) {
if ((++numTypeRanges % 10) == 0) {
System.out.print("#");
}
}
if (eLast > sLast) {
- ranges.add (new int[] { sLast, eLast });
+ ranges.add(new int[] { sLast, eLast });
if (verbose) {
if ((++numTypeRanges % 10) == 0) {
System.out.print("#");
continue;
} else if (line.startsWith(PFX_TYPE) && ! ignoreDeprecatedTypeData) {
List lines = new ArrayList();
- if ((n = readType (line, b, lines)) < 0) {
+ if ((n = readType(line, b, lines)) < 0) {
break;
} else {
lineNumber += n;
- tdl.add (parseType (lines));
+ tdl.add(parseType(lines));
}
} else if (line.startsWith(PFX_LEVELS)) {
List lines = new ArrayList();
- if ((n = readLevels (line, b, lines)) < 0) {
+ if ((n = readLevels(line, b, lines)) < 0) {
break;
} else {
lineNumber += n;
- ldl.add (parseLevels (lines));
+ ldl.add(parseLevels(lines));
}
}
}
System.out.println("Read lines : " + lineNumber);
}
if (! ignoreDeprecatedTypeData) {
- td = (int[][]) tdl.toArray (new int [ tdl.size() ] []);
+ td = (int[][]) tdl.toArray(new int [ tdl.size() ] []);
}
- ld = (int[][]) ldl.toArray (new int [ ldl.size() ] []);
+ ld = (int[][]) ldl.toArray(new int [ ldl.size() ] []);
}
- private static int readType (String line, BufferedReader b, List lines) throws IOException {
- lines.add (line);
+ private static int readType(String line, BufferedReader b, List lines) throws IOException {
+ lines.add(line);
return 0;
}
- private static int readLevels (String line, BufferedReader b, List lines) throws IOException {
+ private static int readLevels(String line, BufferedReader b, List lines) throws IOException {
boolean done = false;
int n = 0;
- lines.add (line);
+ lines.add(line);
while (! done) {
- switch (testPrefix (b, PFX_LEVELS)) {
+ switch (testPrefix(b, PFX_LEVELS)) {
case 0: // within current levels
if ((line = b.readLine()) != null) {
n++;
if ((line.length() > 0) && ! line.startsWith("#")) {
- lines.add (line);
+ lines.add(line);
}
} else {
done = true;
return n;
}
- private static int testPrefix (BufferedReader b, String pfx) throws IOException {
+ private static int testPrefix(BufferedReader b, String pfx) throws IOException {
int rv = 0;
int pfxLen = pfx.length();
- b.mark (pfxLen);
+ b.mark(pfxLen);
for (int i = 0, n = pfxLen; i < n; i++) {
int c = b.read();
if (c < 0) {
rv = -1;
break;
- } else if (c != pfx.charAt (i)) {
+ } else if (c != pfx.charAt(i)) {
rv = 0;
break;
} else {
return rv;
}
- private static int[] parseType (List lines) {
+ private static int[] parseType(List lines) {
if ((lines != null) && (lines.size() >= 1)) {
String line = (String) lines.get(0);
if (line.startsWith(PFX_TYPE)) {
// @Type: BIDI_CLASS ':' LWSP CHARACTER_CLASS
- String[] sa = line.split (":");
+ String[] sa = line.split(":");
if (sa.length == 3) {
String bcs = sa[1].trim();
String crs = sa[2].trim();
- int bc = parseBidiClass (bcs);
- List rl = parseCharacterRanges (crs);
- return createTypeData (bc, rl);
+ int bc = parseBidiClass(bcs);
+ List rl = parseCharacterRanges(crs);
+ return createTypeData(bc, rl);
}
}
}
return null;
}
- private static int[] createTypeData (int bc, List ranges) {
+ private static int[] createTypeData(int bc, List ranges) {
int[] data = new int [ 1 + (2 * ranges.size()) ];
int k = 0;
data [ k++ ] = bc;
return data;
}
- private static int parseBidiClass (String bidiClass) {
+ private static int parseBidiClass(String bidiClass) {
int bc = 0;
- if ("L".equals (bidiClass)) {
+ if ("L".equals(bidiClass)) {
bc = BidiConstants.L;
- } else if ("LRE".equals (bidiClass)) {
+ } else if ("LRE".equals(bidiClass)) {
bc = BidiConstants.LRE;
- } else if ("LRO".equals (bidiClass)) {
+ } else if ("LRO".equals(bidiClass)) {
bc = BidiConstants.LRO;
- } else if ("R".equals (bidiClass)) {
+ } else if ("R".equals(bidiClass)) {
bc = BidiConstants.R;
- } else if ("AL".equals (bidiClass)) {
+ } else if ("AL".equals(bidiClass)) {
bc = BidiConstants.AL;
- } else if ("RLE".equals (bidiClass)) {
+ } else if ("RLE".equals(bidiClass)) {
bc = BidiConstants.RLE;
- } else if ("RLO".equals (bidiClass)) {
+ } else if ("RLO".equals(bidiClass)) {
bc = BidiConstants.RLO;
- } else if ("PDF".equals (bidiClass)) {
+ } else if ("PDF".equals(bidiClass)) {
bc = BidiConstants.PDF;
- } else if ("EN".equals (bidiClass)) {
+ } else if ("EN".equals(bidiClass)) {
bc = BidiConstants.EN;
- } else if ("ES".equals (bidiClass)) {
+ } else if ("ES".equals(bidiClass)) {
bc = BidiConstants.ES;
- } else if ("ET".equals (bidiClass)) {
+ } else if ("ET".equals(bidiClass)) {
bc = BidiConstants.ET;
- } else if ("AN".equals (bidiClass)) {
+ } else if ("AN".equals(bidiClass)) {
bc = BidiConstants.AN;
- } else if ("CS".equals (bidiClass)) {
+ } else if ("CS".equals(bidiClass)) {
bc = BidiConstants.CS;
- } else if ("NSM".equals (bidiClass)) {
+ } else if ("NSM".equals(bidiClass)) {
bc = BidiConstants.NSM;
- } else if ("BN".equals (bidiClass)) {
+ } else if ("BN".equals(bidiClass)) {
bc = BidiConstants.BN;
- } else if ("B".equals (bidiClass)) {
+ } else if ("B".equals(bidiClass)) {
bc = BidiConstants.B;
- } else if ("S".equals (bidiClass)) {
+ } else if ("S".equals(bidiClass)) {
bc = BidiConstants.S;
- } else if ("WS".equals (bidiClass)) {
+ } else if ("WS".equals(bidiClass)) {
bc = BidiConstants.WS;
- } else if ("ON".equals (bidiClass)) {
+ } else if ("ON".equals(bidiClass)) {
bc = BidiConstants.ON;
} else {
- throw new IllegalArgumentException ("unknown bidi class: " + bidiClass);
+ throw new IllegalArgumentException("unknown bidi class: " + bidiClass);
}
return bc;
}
- private static int parseBidiClassAny (String bidiClass) {
+ private static int parseBidiClassAny(String bidiClass) {
try {
- return parseBidiClass (bidiClass);
+ return parseBidiClass(bidiClass);
} catch (IllegalArgumentException e) {
return -1;
}
}
- private static List parseCharacterRanges (String charRanges) {
+ private static List parseCharacterRanges(String charRanges) {
List ranges = new ArrayList();
- CharacterIterator ci = new StringCharacterIterator (charRanges);
+ CharacterIterator ci = new StringCharacterIterator(charRanges);
// read initial list delimiter
- skipSpace (ci);
- if (! readStartOfList (ci)) {
- badRangeSpec ("missing initial list delimiter", charRanges);
+ skipSpace(ci);
+ if (! readStartOfList(ci)) {
+ badRangeSpec("missing initial list delimiter", charRanges);
}
// read negation token if present
boolean negated = false;
- skipSpace (ci);
- if (maybeReadNext (ci, '^')) {
+ skipSpace(ci);
+ if (maybeReadNext(ci, '^')) {
negated = true;
}
// read item
int[] r;
- skipSpace (ci);
- if ((r = maybeReadItem (ci)) != null) {
- ranges.add (r);
+ skipSpace(ci);
+ if ((r = maybeReadItem(ci)) != null) {
+ ranges.add(r);
if (verbose) {
if ((++numTypeRanges % 10) == 0) {
System.out.print("#");
}
}
} else {
- badRangeSpec ("must contain at least one item", charRanges);
+ badRangeSpec("must contain at least one item", charRanges);
}
// read more items if present
boolean more = true;
while (more) {
// read separator if present
String s;
- skipSpace (ci);
- if ((s = maybeReadSeparator (ci)) != null) {
+ skipSpace(ci);
+ if ((s = maybeReadSeparator(ci)) != null) {
if ((s.length() != 0) && ! s.equals("||")) {
- badRangeSpec ("invalid item separator \"" + s + "\"", charRanges);
+ badRangeSpec("invalid item separator \"" + s + "\"", charRanges);
}
}
// read item
- skipSpace (ci);
- if ((r = maybeReadItem (ci)) != null) {
- ranges.add (r);
+ skipSpace(ci);
+ if ((r = maybeReadItem(ci)) != null) {
+ ranges.add(r);
if (verbose) {
if ((++numTypeRanges % 10) == 0) {
System.out.print("#");
}
}
// read terminating list delimiter
- skipSpace (ci);
- if (! readEndOfList (ci)) {
- badRangeSpec ("missing terminating list delimiter", charRanges);
+ skipSpace(ci);
+ if (! readEndOfList(ci)) {
+ badRangeSpec("missing terminating list delimiter", charRanges);
}
- if (! atEnd (ci)) {
- badRangeSpec ("extraneous content prior to end of line", ci);
+ if (! atEnd(ci)) {
+ badRangeSpec("extraneous content prior to end of line", ci);
}
if (negated) {
- ranges = complementRanges (ranges);
+ ranges = complementRanges(ranges);
}
- return removeSurrogates (ranges);
+ return removeSurrogates(ranges);
}
- private static boolean atEnd (CharacterIterator ci) {
+ private static boolean atEnd(CharacterIterator ci) {
return ci.getIndex() >= ci.getEndIndex();
}
- private static boolean readStartOfList (CharacterIterator ci) {
- return maybeReadNext (ci, '[');
+ private static boolean readStartOfList(CharacterIterator ci) {
+ return maybeReadNext(ci, '[');
}
- private static void skipSpace (CharacterIterator ci) {
- while (! atEnd (ci)) {
+ private static void skipSpace(CharacterIterator ci) {
+ while (! atEnd(ci)) {
char c = ci.current();
- if (! Character.isWhitespace (c)) {
+ if (! Character.isWhitespace(c)) {
break;
} else {
ci.next();
}
}
- private static boolean maybeReadNext (CharacterIterator ci, char next) {
- while (! atEnd (ci)) {
+ private static boolean maybeReadNext(CharacterIterator ci, char next) {
+ while (! atEnd(ci)) {
char c = ci.current();
if (c == next) {
ci.next();
return false;
}
- private static int[] maybeReadItem (CharacterIterator ci) {
+ private static int[] maybeReadItem(CharacterIterator ci) {
// read first code point
int p1 = -1;
- skipSpace (ci);
- if ((p1 = maybeReadCodePoint (ci)) < 0) {
+ skipSpace(ci);
+ if ((p1 = maybeReadCodePoint(ci)) < 0) {
return null;
}
// read second code point if present
int p2 = -1;
- skipSpace (ci);
- if (maybeReadNext (ci, '-')) {
- skipSpace (ci);
- if ((p2 = maybeReadCodePoint (ci)) < 0) {
- badRangeSpec ("incomplete item range, requires second item", ci);
+ skipSpace(ci);
+ if (maybeReadNext(ci, '-')) {
+ skipSpace(ci);
+ if ((p2 = maybeReadCodePoint(ci)) < 0) {
+ badRangeSpec("incomplete item range, requires second item", ci);
}
}
if (p2 < 0) {
} else if (p1 <= p2) {
return new int[] { p1, p2 + 1 }; // convert to half open interval [ P1, P2+2 )
} else {
- badRangeSpec ("invalid item range, second item must be greater than or equal to first item", ci);
+ badRangeSpec("invalid item range, second item must be greater than or equal to first item", ci);
return null;
}
}
- private static int maybeReadCodePoint (CharacterIterator ci) {
- if (maybeReadNext (ci, '\\')) {
- if (maybeReadNext (ci, 'u')) {
- String s = maybeReadHexDigits (ci, 4);
+ private static int maybeReadCodePoint(CharacterIterator ci) {
+ if (maybeReadNext(ci, '\\')) {
+ if (maybeReadNext(ci, 'u')) {
+ String s = maybeReadHexDigits(ci, 4);
if (s != null) {
- return Integer.parseInt (s, 16);
+ return Integer.parseInt(s, 16);
} else {
- badRangeSpec ("incomplete escaped code point, requires 4 hex digits", ci);
+ badRangeSpec("incomplete escaped code point, requires 4 hex digits", ci);
}
- } else if (maybeReadNext (ci, 'U')) {
- String s = maybeReadHexDigits (ci, 8);
+ } else if (maybeReadNext(ci, 'U')) {
+ String s = maybeReadHexDigits(ci, 8);
if (s != null) {
- return Integer.parseInt (s, 16);
+ return Integer.parseInt(s, 16);
} else {
- badRangeSpec ("incomplete escaped code point, requires 8 hex digits", ci);
+ badRangeSpec("incomplete escaped code point, requires 8 hex digits", ci);
}
} else {
char c = ci.current();
if (c == CharacterIterator.DONE) {
- badRangeSpec ("incomplete escaped code point", ci);
+ badRangeSpec("incomplete escaped code point", ci);
} else {
ci.next();
return (int) c;
return -1;
}
- private static String maybeReadHexDigits (CharacterIterator ci, int numDigits) {
+ private static String maybeReadHexDigits(CharacterIterator ci, int numDigits) {
StringBuffer sb = new StringBuffer();
while ((numDigits < 0) || (sb.length() < numDigits)) {
char c = ci.current();
if (c != CharacterIterator.DONE) {
- if (isHexDigit (c)) {
+ if (isHexDigit(c)) {
ci.next();
- sb.append (c);
+ sb.append(c);
} else {
break;
}
}
}
- private static boolean isHexDigit (char c) {
+ private static boolean isHexDigit(char c) {
return ((c >= '0') && (c <= '9')) || ((c >= 'a') && (c <= 'f')) || ((c >= 'A') && (c <= 'F'));
}
- private static String maybeReadSeparator (CharacterIterator ci) {
- if (maybeReadNext (ci, '|')) {
- if (maybeReadNext (ci, '|')) {
+ private static String maybeReadSeparator(CharacterIterator ci) {
+ if (maybeReadNext(ci, '|')) {
+ if (maybeReadNext(ci, '|')) {
return "||";
} else {
return "|";
}
}
- private static boolean readEndOfList (CharacterIterator ci) {
- return maybeReadNext (ci, ']');
+ private static boolean readEndOfList(CharacterIterator ci) {
+ return maybeReadNext(ci, ']');
}
- private static List complementRanges (List ranges) {
+ private static List complementRanges(List ranges) {
Map/*<Integer,Integer>*/ rm = new TreeMap/*<Integer,Integer>*/();
for (Iterator it = ranges.iterator(); it.hasNext(); ) {
int[] r = (int[]) it.next();
- rm.put (Integer.valueOf (r[0]), Integer.valueOf (r[1]));
+ rm.put(Integer.valueOf(r[0]), Integer.valueOf(r[1]));
}
// add complement ranges save last
int s;
int e;
int cs = 0;
- List compRanges = new ArrayList (rm.size() + 1);
+ List compRanges = new ArrayList(rm.size() + 1);
for (Iterator it = rm.entrySet().iterator(); it.hasNext(); ) {
Map.Entry/*<Integer,Integer>*/ me = (Map.Entry/*<Integer,Integer>*/) it.next();
s = ((Integer) me.getKey()).intValue();
e = ((Integer) me.getValue()).intValue();
if (s > cs) {
- compRanges.add (new int[] { cs, s });
+ compRanges.add(new int[] { cs, s });
}
cs = e;
}
// add trailing complement range
if (cs < 0x110000) {
- compRanges.add (new int[] { cs, 0x110000 });
+ compRanges.add(new int[] { cs, 0x110000 });
}
return compRanges;
}
private static final int[] SURROGATES = new int[] { 0xD800, 0xE000 };
- private static List removeSurrogates (List ranges) {
- List rsl = new ArrayList (ranges.size());
+ private static List removeSurrogates(List ranges) {
+ List rsl = new ArrayList(ranges.size());
for (Iterator it = ranges.iterator(); it.hasNext(); ) {
int[] r = (int[]) it.next();
- if (intersectsRange (r, SURROGATES)) {
- rsl.addAll (removeRange (r, SURROGATES));
+ if (intersectsRange(r, SURROGATES)) {
+ rsl.addAll(removeRange(r, SURROGATES));
} else {
- rsl.add (r);
+ rsl.add(r);
}
}
return rsl;
/**
* Determine if range r2 intersects with range r1.
*/
- private static boolean intersectsRange (int[] r1, int[] r2) {
+ private static boolean intersectsRange(int[] r1, int[] r2) {
if (r1[1] <= r2[0]) { // r1 precedes r2 or abuts r2 on right
return false;
} else if (r1[0] >= r2[1]) { // r2 precedes r1 or abuts r1 on left
* Remove range r2 from range r1, leaving zero, one, or two
* remaining ranges.
*/
- private static List removeRange (int[] r1, int[] r2) {
+ private static List removeRange(int[] r1, int[] r2) {
List rl = new ArrayList();
if (r1[1] <= r2[0]) { // r1 precedes r2 or abuts r2 on right
- rl.add (r1);
+ rl.add(r1);
} else if (r1[0] >= r2[1]) { // r2 precedes r1 or abuts r1 on left
- rl.add (r1);
+ rl.add(r1);
} else if ((r1[0] < r2[0]) && (r1[1] > r2[1])) { // r1 encloses r2
- rl.add (new int[] { r1[0], r2[0] });
- rl.add (new int[] { r2[1], r1[1] });
+ rl.add(new int[] { r1[0], r2[0] });
+ rl.add(new int[] { r2[1], r1[1] });
} else if (r1[0] < r2[0]) { // r1 precedes and overlaps r2
- rl.add (new int[] { r1[0], r2[0] });
+ rl.add(new int[] { r1[0], r2[0] });
} else if (r2[1] < r1[1]) { // r2 precedes and overlaps r1
- rl.add (new int[] { r2[1], r1[1] });
+ rl.add(new int[] { r2[1], r1[1] });
}
return rl;
}
- private static void badRangeSpec (String reason, String charRanges) throws IllegalArgumentException {
+ private static void badRangeSpec(String reason, String charRanges) throws IllegalArgumentException {
if (verbose) {
System.out.println();
}
- throw new IllegalArgumentException ("bad range specification: " + reason + ": \"" + charRanges + "\"");
+ throw new IllegalArgumentException("bad range specification: " + reason + ": \"" + charRanges + "\"");
}
- private static void badRangeSpec (String reason, CharacterIterator ci) throws IllegalArgumentException {
+ private static void badRangeSpec(String reason, CharacterIterator ci) throws IllegalArgumentException {
if (verbose) {
System.out.println();
}
- throw new IllegalArgumentException ("bad range specification: " + reason + ": starting at \"" + remainder (ci) + "\"");
+ throw new IllegalArgumentException("bad range specification: " + reason + ": starting at \"" + remainder(ci) + "\"");
}
- private static String remainder (CharacterIterator ci) {
+ private static String remainder(CharacterIterator ci) {
StringBuffer sb = new StringBuffer();
for (char c; (c = ci.current()) != CharacterIterator.DONE; ) {
ci.next();
- sb.append (c);
+ sb.append(c);
}
return sb.toString();
}
* REORDER_SPEC \n
* ( TEST_SPEC \n )+
*/
- private static int[] parseLevels (List lines) {
+ private static int[] parseLevels(List lines) {
int[] la = null; // levels array
int[] ra = null; // reorder array
List tal = new ArrayList();
String line = (String) it.next();
if (line.startsWith(PFX_LEVELS)) {
if (la == null) {
- la = parseLevelSpec (line);
+ la = parseLevelSpec(line);
if (verbose) {
if ((++numLevelSpecs % 10) == 0) {
System.out.print("&");
}
}
} else {
- throw new IllegalArgumentException ("redundant levels array: \"" + line + "\"");
+ throw new IllegalArgumentException("redundant levels array: \"" + line + "\"");
}
} else if (line.startsWith(PFX_REORDER)) {
if (la == null) {
- throw new IllegalArgumentException ("missing levels array before: \"" + line + "\"");
+ throw new IllegalArgumentException("missing levels array before: \"" + line + "\"");
} else if (ra == null) {
- ra = parseReorderSpec (line, la);
+ ra = parseReorderSpec(line, la);
} else {
- throw new IllegalArgumentException ("redundant reorder array: \"" + line + "\"");
+ throw new IllegalArgumentException("redundant reorder array: \"" + line + "\"");
}
} else if ((la != null) && (ra != null)) {
- int[] ta = parseTestSpec (line, la);
+ int[] ta = parseTestSpec(line, la);
if (ta != null) {
if (verbose) {
if ((++numTestSpecs % 100) == 0) {
System.out.print("!");
}
}
- tal.add (ta);
+ tal.add(ta);
}
} else if (la == null) {
- throw new IllegalArgumentException ("missing levels array before: \"" + line + "\"");
+ throw new IllegalArgumentException("missing levels array before: \"" + line + "\"");
} else if (ra == null) {
- throw new IllegalArgumentException ("missing reorder array before: \"" + line + "\"");
+ throw new IllegalArgumentException("missing reorder array before: \"" + line + "\"");
}
}
}
if ((la != null) && (ra != null)) {
- return createLevelData (la, ra, tal);
+ return createLevelData(la, ra, tal);
} else {
return null;
}
}
- private static int[] createLevelData (int[] la, int[] ra, List tal) {
+ private static int[] createLevelData(int[] la, int[] ra, List tal) {
int nl = la.length;
int[] data = new int [ 1 + nl * 2 + ((nl + 1) * tal.size()) ];
int k = 0;
for (Iterator it = tal.iterator(); it.hasNext(); ) {
int[] ta = (int[]) it.next();
if (ta == null) {
- throw new IllegalStateException ("null test array");
+ throw new IllegalStateException("null test array");
} else if (ta.length == (nl + 1)) {
for (int i = 0, n = ta.length; i < n; i++) {
data [ k++ ] = ta [ i ];
}
} else {
- throw new IllegalStateException ("test array length error, expected " + (nl + 1) + " entries, got " + ta.length + " entries");
+ throw new IllegalStateException("test array length error, expected " + (nl + 1) + " entries, got " + ta.length + " entries");
}
}
assert k == data.length;
*
* @Levels: ( LWSP ( NUMBER | 'x' ) )+
*/
- private static int[] parseLevelSpec (String line) {
- CharacterIterator ci = new StringCharacterIterator (line);
+ private static int[] parseLevelSpec(String line) {
+ CharacterIterator ci = new StringCharacterIterator(line);
List ll = new ArrayList();
// read prefix
- skipSpace (ci);
- if (! maybeReadToken (ci, PFX_LEVELS)) {
- badLevelSpec ("missing prefix \"" + PFX_LEVELS + "\"", ci);
+ skipSpace(ci);
+ if (! maybeReadToken(ci, PFX_LEVELS)) {
+ badLevelSpec("missing prefix \"" + PFX_LEVELS + "\"", ci);
}
// read level values
boolean more = true;
while (more) {
Integer l;
- skipSpace (ci);
- if ((l = maybeReadInteger (ci)) != null) {
- ll.add (l);
- } else if (maybeReadToken (ci, "x")) {
- ll.add (Integer.valueOf (-1));
+ skipSpace(ci);
+ if ((l = maybeReadInteger(ci)) != null) {
+ ll.add(l);
+ } else if (maybeReadToken(ci, "x")) {
+ ll.add(Integer.valueOf(-1));
} else {
more = false;
}
}
// read to end of line
- skipSpace (ci);
- if (! atEnd (ci)) {
- badLevelSpec ("extraneous content prior to end of line", ci);
+ skipSpace(ci);
+ if (! atEnd(ci)) {
+ badLevelSpec("extraneous content prior to end of line", ci);
}
if (ll.size() == 0) {
- badLevelSpec ("must have at least one level value", ci);
+ badLevelSpec("must have at least one level value", ci);
}
- return createLevelsArray (ll);
+ return createLevelsArray(ll);
}
- private static Integer maybeReadInteger (CharacterIterator ci) {
+ private static Integer maybeReadInteger(CharacterIterator ci) {
// read optional minus sign if present
boolean negative;
- if (maybeReadNext (ci, '-')) {
+ if (maybeReadNext(ci, '-')) {
negative = true;
} else {
negative = false;
StringBuffer sb = new StringBuffer();
while (true) {
char c = ci.current();
- if ((c != CharacterIterator.DONE) && isDigit (c)) {
+ if ((c != CharacterIterator.DONE) && isDigit(c)) {
ci.next();
- sb.append (c);
+ sb.append(c);
} else {
break;
}
if (sb.length() == 0) {
return null;
} else {
- int value = Integer.parseInt (sb.toString());
+ int value = Integer.parseInt(sb.toString());
if (negative) {
value = -value;
}
- return Integer.valueOf (value);
+ return Integer.valueOf(value);
}
}
- private static boolean isDigit (char c) {
+ private static boolean isDigit(char c) {
return ((c >= '0') && (c <= '9'));
}
- private static boolean maybeReadToken (CharacterIterator ci, String s) {
+ private static boolean maybeReadToken(CharacterIterator ci, String s) {
int startIndex = ci.getIndex();
for (int i = 0, n = s.length(); i < n; i++) {
- char c = s.charAt (i);
+ char c = s.charAt(i);
if (ci.current() == c) {
ci.next();
} else {
- ci.setIndex (startIndex);
+ ci.setIndex(startIndex);
return false;
}
}
return true;
}
- private static void badLevelSpec (String reason, CharacterIterator ci) throws IllegalArgumentException {
+ private static void badLevelSpec(String reason, CharacterIterator ci) throws IllegalArgumentException {
if (verbose) {
System.out.println();
}
- throw new IllegalArgumentException ("bad level specification: " + reason + ": starting at \"" + remainder (ci) + "\"");
+ throw new IllegalArgumentException("bad level specification: " + reason + ": starting at \"" + remainder(ci) + "\"");
}
- private static int[] createLevelsArray (List levels) {
+ private static int[] createLevelsArray(List levels) {
int[] la = new int [ levels.size() ];
int k = 0;
for (Iterator it = levels.iterator(); it.hasNext(); ) {
*
* @Reorder: ( LWSP NUMBER )*
*/
- private static int[] parseReorderSpec (String line, int[] levels) {
- CharacterIterator ci = new StringCharacterIterator (line);
+ private static int[] parseReorderSpec(String line, int[] levels) {
+ CharacterIterator ci = new StringCharacterIterator(line);
List rl = new ArrayList();
// read prefix
- skipSpace (ci);
- if (! maybeReadToken (ci, PFX_REORDER)) {
- badReorderSpec ("missing prefix \"" + PFX_REORDER + "\"", ci);
+ skipSpace(ci);
+ if (! maybeReadToken(ci, PFX_REORDER)) {
+ badReorderSpec("missing prefix \"" + PFX_REORDER + "\"", ci);
}
// read reorder values
boolean more = true;
while (more) {
- skipSpace (ci);
+ skipSpace(ci);
Integer l;
- if ((l = maybeReadInteger (ci)) != null) {
- rl.add (l);
+ if ((l = maybeReadInteger(ci)) != null) {
+ rl.add(l);
} else {
more = false;
}
}
// read to end of line
- skipSpace (ci);
- if (! atEnd (ci)) {
- badReorderSpec ("extraneous content prior to end of line", ci);
+ skipSpace(ci);
+ if (! atEnd(ci)) {
+ badReorderSpec("extraneous content prior to end of line", ci);
}
- return createReorderArray (rl, levels);
+ return createReorderArray(rl, levels);
}
- private static void badReorderSpec (String reason, CharacterIterator ci) throws IllegalArgumentException {
+ private static void badReorderSpec(String reason, CharacterIterator ci) throws IllegalArgumentException {
if (verbose) {
System.out.println();
}
- throw new IllegalArgumentException ("bad reorder specification: " + reason + ": starting at \"" + remainder (ci) + "\"");
+ throw new IllegalArgumentException("bad reorder specification: " + reason + ": starting at \"" + remainder(ci) + "\"");
}
- private static int[] createReorderArray (List reorders, int[] levels) {
+ private static int[] createReorderArray(List reorders, int[] levels) {
int nr = reorders.size();
int nl = levels.length;
if (nr <= nl) {
}
return ra;
} else {
- throw new IllegalArgumentException ("excessive number of reorder array entries, expected no more than " + nl + ", but got " + nr + " entries");
+ throw new IllegalArgumentException("excessive number of reorder array entries, expected no more than " + nl + ", but got " + nr + " entries");
}
}
*
* BIDI_CLASS ( LWSP BIDI_CLASS )+ ';' LWSP NUMBER
*/
- private static int[] parseTestSpec (String line, int[] levels) {
- CharacterIterator ci = new StringCharacterIterator (line);
+ private static int[] parseTestSpec(String line, int[] levels) {
+ CharacterIterator ci = new StringCharacterIterator(line);
List cl = new ArrayList();
// read bidi class identifier sequence
- while (! atEnd (ci) && ! maybeReadNext (ci, ';')) {
- skipSpace (ci);
+ while (! atEnd(ci) && ! maybeReadNext(ci, ';')) {
+ skipSpace(ci);
int bc;
- if ((bc = maybeReadBidiClass (ci)) >= 0) {
- cl.add (Integer.valueOf (bc));
+ if ((bc = maybeReadBidiClass(ci)) >= 0) {
+ cl.add(Integer.valueOf(bc));
} else {
break;
}
}
// read bit set
- skipSpace (ci);
+ skipSpace(ci);
String s;
int bs = 0;
- if ((s = maybeReadHexDigits (ci, -1)) != null) {
- bs = Integer.parseInt (s, 16);
+ if ((s = maybeReadHexDigits(ci, -1)) != null) {
+ bs = Integer.parseInt(s, 16);
} else {
- badTestSpec ("missing bit set", ci);
+ badTestSpec("missing bit set", ci);
}
// read to end of line
- skipSpace (ci);
- if (! atEnd (ci)) {
- badTestSpec ("extraneous content prior to end of line", ci);
+ skipSpace(ci);
+ if (! atEnd(ci)) {
+ badTestSpec("extraneous content prior to end of line", ci);
}
- return createTestArray (cl, bs, levels);
+ return createTestArray(cl, bs, levels);
}
- private static String maybeReadIdentifier (CharacterIterator ci) {
+ private static String maybeReadIdentifier(CharacterIterator ci) {
// read keyword chars ([A-Z])
StringBuffer sb = new StringBuffer();
while (true) {
if (c == CharacterIterator.DONE) {
break;
} else if (sb.length() == 0) {
- if (Character.isUnicodeIdentifierStart (c)) {
+ if (Character.isUnicodeIdentifierStart(c)) {
ci.next();
- sb.append (c);
+ sb.append(c);
} else {
break;
}
} else {
- if (Character.isUnicodeIdentifierPart (c)) {
+ if (Character.isUnicodeIdentifierPart(c)) {
ci.next();
- sb.append (c);
+ sb.append(c);
} else {
break;
}
}
}
- private static int maybeReadBidiClass (CharacterIterator ci) {
+ private static int maybeReadBidiClass(CharacterIterator ci) {
int bc = -1;
int i = ci.getIndex();
String s;
- if ((s = maybeReadIdentifier (ci)) != null) {
+ if ((s = maybeReadIdentifier(ci)) != null) {
try {
- bc = parseBidiClass (s);
+ bc = parseBidiClass(s);
} catch (IllegalArgumentException e) {
throw e;
}
}
if (bc < 0) {
- ci.setIndex (i);
+ ci.setIndex(i);
}
return bc;
}
- private static void badTestSpec (String reason, CharacterIterator ci) throws IllegalArgumentException {
+ private static void badTestSpec(String reason, CharacterIterator ci) throws IllegalArgumentException {
if (verbose) {
System.out.println();
}
- throw new IllegalArgumentException ("bad test specification: " + reason + ": starting at \"" + remainder (ci) + "\"");
+ throw new IllegalArgumentException("bad test specification: " + reason + ": starting at \"" + remainder(ci) + "\"");
}
- private static int[] createTestArray (List classes, int bitset, int[] levels) {
+ private static int[] createTestArray(List classes, int bitset, int[] levels) {
int nc = classes.size();
if (nc <= levels.length) {
int[] ta = new int [ 1 + nc ];
}
return ta;
} else {
- throw new IllegalArgumentException ("excessive number of test array entries, expected no more than " + levels.length + ", but got " + nc + " entries");
+ throw new IllegalArgumentException("excessive number of test array entries, expected no more than " + levels.length + ", but got " + nc + " entries");
}
}
* @param out - bidi test data java class file print writer
* @param outFileName - (full path) name of bidi test data java class file
*/
- private static void dumpData (PrintWriter out, String outFileName) throws IOException {
- File f = new File (outFileName);
+ private static void dumpData(PrintWriter out, String outFileName) throws IOException {
+ File f = new File(outFileName);
File p = f.getParentFile();
if (td != null) {
String pfxTD = "TD";
- dumpResourcesDescriptor (out, pfxTD, td.length);
- dumpResourcesData (p, f.getName(), pfxTD, td);
+ dumpResourcesDescriptor(out, pfxTD, td.length);
+ dumpResourcesData(p, f.getName(), pfxTD, td);
}
if (ld != null) {
String pfxTD = "LD";
- dumpResourcesDescriptor (out, pfxTD, ld.length);
- dumpResourcesData (p, f.getName(), pfxTD, ld);
+ dumpResourcesDescriptor(out, pfxTD, ld.length);
+ dumpResourcesData(p, f.getName(), pfxTD, ld);
}
}
- private static void dumpResourcesDescriptor (PrintWriter out, String prefix, int numResources) {
- out.println (" public static final String " + prefix + "_PFX = \"" + prefix + "\";");
- out.println (" public static final int " + prefix + "_CNT = " + numResources + ";");
+ private static void dumpResourcesDescriptor(PrintWriter out, String prefix, int numResources) {
+ out.println(" public static final String " + prefix + "_PFX = \"" + prefix + "\";");
+ out.println(" public static final int " + prefix + "_CNT = " + numResources + ";");
out.println("");
}
- private static void dumpResourcesData (File btcDir, String btcName, String prefix, int[][] data) throws IOException {
- String btdName = extractDataFileName (btcName);
+ private static void dumpResourcesData(File btcDir, String btcName, String prefix, int[][] data) throws IOException {
+ String btdName = extractDataFileName(btcName);
for (int i = 0, n = data.length; i < n; i++) {
- File f = new File (btcDir, btdName + "$" + prefix + i + ".ser");
- ObjectOutputStream os = new ObjectOutputStream (new FileOutputStream (f));
- os.writeObject (data[i]);
+ File f = new File(btcDir, btdName + "$" + prefix + i + ".ser");
+ ObjectOutputStream os = new ObjectOutputStream(new FileOutputStream(f));
+ os.writeObject(data[i]);
os.close();
}
}
private static final String JAVA_EXT = ".java";
- private static String extractDataFileName (String btcName) {
- if (btcName.endsWith (JAVA_EXT)) {
- return btcName.substring (0, btcName.length() - JAVA_EXT.length());
+ private static String extractDataFileName(String btcName) {
+ if (btcName.endsWith(JAVA_EXT)) {
+ return btcName.substring(0, btcName.length() - JAVA_EXT.length());
} else {
return btcName;
}
}
String scheme = unidata.getScheme();
if (scheme == null || !(scheme.equals("file") || scheme.equals("http"))) {
- throw new FileNotFoundException
- ("URI with file or http scheme required for UNIDATA input directory");
+ throw new FileNotFoundException(
+ "URI with file or http scheme required for UNIDATA input directory");
}
File f = new File(outfilePath);
AFPLineDataInfo lineDataInfo = new AFPLineDataInfo();
lineDataInfo.setColor(borderPaintInfo.getColor());
lineDataInfo.setRotation(paintingState.getRotation());
- lineDataInfo.setX1 (Math.round(x1));
- lineDataInfo.setY1 (Math.round(y1));
+ lineDataInfo.setX1(Math.round(x1));
+ lineDataInfo.setY1(Math.round(y1));
float thickness;
if (borderPaintInfo.isHorizontal()) {
thickness = y2 - y1;
int thickness3 = (int)Math.floor(thickness / 3f);
lineDataInfo.setThickness(thickness3);
if (borderPaintInfo.isHorizontal()) {
- lineDataInfo.setX2 (Math.round(x2));
- lineDataInfo.setY2 (lineDataInfo.getY1());
+ lineDataInfo.setX2(Math.round(x2));
+ lineDataInfo.setY2(lineDataInfo.getY1());
dataStream.createLine(lineDataInfo);
int distance = thickness3 * 2;
lineDataInfo = new AFPLineDataInfo(lineDataInfo);
- lineDataInfo.setY1 (lineDataInfo.getY1() + distance);
- lineDataInfo.setY2 (lineDataInfo.getY2() + distance);
+ lineDataInfo.setY1(lineDataInfo.getY1() + distance);
+ lineDataInfo.setY2(lineDataInfo.getY2() + distance);
dataStream.createLine(lineDataInfo);
} else {
- lineDataInfo.setX2 (lineDataInfo.getX1());
- lineDataInfo.setY2 (Math.round(y2));
+ lineDataInfo.setX2(lineDataInfo.getX1());
+ lineDataInfo.setY2(Math.round(y2));
dataStream.createLine(lineDataInfo);
int distance = thickness3 * 2;
lineDataInfo = new AFPLineDataInfo(lineDataInfo);
- lineDataInfo.setX1 (lineDataInfo.getX1() + distance);
- lineDataInfo.setX2 (lineDataInfo.getX2() + distance);
+ lineDataInfo.setX1(lineDataInfo.getX1() + distance);
+ lineDataInfo.setX2(lineDataInfo.getX2() + distance);
dataStream.createLine(lineDataInfo);
}
break;
case Constants.EN_DASHED:
if (borderPaintInfo.isHorizontal()) {
int dashWidth = (int) unitConv.pt2units(BorderPainter.dashWidthCalculator(w, h));
- lineDataInfo.setX2 (lineDataInfo.getX1() + dashWidth);
- lineDataInfo.setY2 (lineDataInfo.getY1());
+ lineDataInfo.setX2(lineDataInfo.getX1() + dashWidth);
+ lineDataInfo.setY2(lineDataInfo.getY1());
int ex2 = Math.round(x2);
int spaceWidth = (int) (BorderPainter.DASHED_BORDER_SPACE_RATIO * dashWidth);
while (lineDataInfo.getX2() <= ex2) {
dataStream.createLine(lineDataInfo);
- lineDataInfo.setX1 (lineDataInfo.getX2() + spaceWidth);
- lineDataInfo.setX2 (lineDataInfo.getX1() + dashWidth);
+ lineDataInfo.setX1(lineDataInfo.getX2() + spaceWidth);
+ lineDataInfo.setX2(lineDataInfo.getX1() + dashWidth);
}
} else {
int dashWidth = (int) unitConv.pt2units(BorderPainter.dashWidthCalculator(h, w));
- lineDataInfo.setX2 (lineDataInfo.getX1());
- lineDataInfo.setY2 (lineDataInfo.getY1() + dashWidth);
+ lineDataInfo.setX2(lineDataInfo.getX1());
+ lineDataInfo.setY2(lineDataInfo.getY1() + dashWidth);
int ey2 = Math.round(y2);
int spaceWidth = (int) (BorderPainter.DASHED_BORDER_SPACE_RATIO * dashWidth);
while (lineDataInfo.getY2() <= ey2) {
dataStream.createLine(lineDataInfo);
- lineDataInfo.setY1 (lineDataInfo.getY2() + spaceWidth);
- lineDataInfo.setY2 (lineDataInfo.getY1() + dashWidth);
+ lineDataInfo.setY1(lineDataInfo.getY2() + spaceWidth);
+ lineDataInfo.setY2(lineDataInfo.getY1() + dashWidth);
}
}
break;
case Constants.EN_DOTTED:
if (borderPaintInfo.isHorizontal()) {
- lineDataInfo.setX2 (lineDataInfo.getX1() + lineDataInfo.getThickness());
- lineDataInfo.setY2 (lineDataInfo.getY1());
+ lineDataInfo.setX2(lineDataInfo.getX1() + lineDataInfo.getThickness());
+ lineDataInfo.setY2(lineDataInfo.getY1());
int ex2 = Math.round(x2);
while (lineDataInfo.getX1() + lineDataInfo.getThickness() < ex2) {
dataStream.createLine(lineDataInfo);
- lineDataInfo.setX1 (lineDataInfo.getX1() + 3 * lineDataInfo.getThickness());
- lineDataInfo.setX2 (lineDataInfo.getX1() + lineDataInfo.getThickness());
+ lineDataInfo.setX1(lineDataInfo.getX1() + 3 * lineDataInfo.getThickness());
+ lineDataInfo.setX2(lineDataInfo.getX1() + lineDataInfo.getThickness());
}
} else {
- lineDataInfo.setX2 (lineDataInfo.getX1());
- lineDataInfo.setY2 (lineDataInfo.getY1() + lineDataInfo.getThickness());
+ lineDataInfo.setX2(lineDataInfo.getX1());
+ lineDataInfo.setY2(lineDataInfo.getY1() + lineDataInfo.getThickness());
int ey2 = Math.round(y2);
while (lineDataInfo.getY1() + lineDataInfo.getThickness() < ey2) {
dataStream.createLine(lineDataInfo);
- lineDataInfo.setY1 (lineDataInfo.getY1() + 3 * lineDataInfo.getThickness());
- lineDataInfo.setY2 (lineDataInfo.getY1() + lineDataInfo.getThickness());
+ lineDataInfo.setY1(lineDataInfo.getY1() + 3 * lineDataInfo.getThickness());
+ lineDataInfo.setY2(lineDataInfo.getY1() + lineDataInfo.getThickness());
}
}
break;
case Constants.EN_RIDGE:
//TODO
int yNew;
- lineDataInfo.setX2 (Math.round(x2));
+ lineDataInfo.setX2(Math.round(x2));
float colFactor = (borderPaintInfo.getStyle() == Constants.EN_GROOVE ? 0.4f : -0.4f);
float h3 = (y2 - y1) / 3;
- lineDataInfo.setColor
- (ColorUtil.lightenColor(borderPaintInfo.getColor(), -colFactor));
- lineDataInfo.setThickness (Math.round(h3));
+ lineDataInfo.setColor(
+ ColorUtil.lightenColor(borderPaintInfo.getColor(), -colFactor));
+ lineDataInfo.setThickness(Math.round(h3));
yNew = Math.round(y1);
- lineDataInfo.setY1 (yNew);
- lineDataInfo.setY2 (yNew);
+ lineDataInfo.setY1(yNew);
+ lineDataInfo.setY2(yNew);
dataStream.createLine(lineDataInfo);
- lineDataInfo.setColor (borderPaintInfo.getColor());
+ lineDataInfo.setColor(borderPaintInfo.getColor());
yNew = Math.round(y1 + h3);
- lineDataInfo.setY1 (yNew);
- lineDataInfo.setY2 (yNew);
+ lineDataInfo.setY1(yNew);
+ lineDataInfo.setY2(yNew);
dataStream.createLine(lineDataInfo);
- lineDataInfo.setColor (ColorUtil.lightenColor(borderPaintInfo.getColor(), colFactor));
+ lineDataInfo.setColor(ColorUtil.lightenColor(borderPaintInfo.getColor(), colFactor));
yNew = Math.round(y1 + h3 + h3);
- lineDataInfo.setY1 (yNew);
- lineDataInfo.setY2 (yNew);
+ lineDataInfo.setY1(yNew);
+ lineDataInfo.setY2(yNew);
dataStream.createLine(lineDataInfo);
break;
case Constants.EN_HIDDEN:
case Constants.EN_SOLID:
default:
if (borderPaintInfo.isHorizontal()) {
- lineDataInfo.setX2 (Math.round(x2));
- lineDataInfo.setY2 (lineDataInfo.getY1());
+ lineDataInfo.setX2(Math.round(x2));
+ lineDataInfo.setY2(lineDataInfo.getY1());
} else {
- lineDataInfo.setX2 (lineDataInfo.getX1());
- lineDataInfo.setY2 (Math.round(y2));
+ lineDataInfo.setX2(lineDataInfo.getX1());
+ lineDataInfo.setY2(Math.round(y2));
}
dataStream.createLine(lineDataInfo);
}
AffineTransform at = paintingState.getData().getTransform();
AFPLineDataInfo lineDataInfo = new AFPLineDataInfo();
- lineDataInfo.setColor (paintingState.getColor());
- lineDataInfo.setRotation (paintingState.getRotation());
- lineDataInfo.setThickness (Math.round(height));
+ lineDataInfo.setColor(paintingState.getColor());
+ lineDataInfo.setRotation(paintingState.getRotation());
+ lineDataInfo.setThickness(Math.round(height));
switch (lineDataInfo.getRotation()) {
case 90:
- lineDataInfo.setX1 (Math.round((float)at.getTranslateY() + x));
+ lineDataInfo.setX1(Math.round((float)at.getTranslateY() + x));
yNew = pageWidth - Math.round((float)at.getTranslateX()) + Math.round(y);
- lineDataInfo.setY1 (yNew);
- lineDataInfo.setY2 (yNew);
- lineDataInfo.setX2 (Math.round(width + (float)at.getTranslateY() + x));
+ lineDataInfo.setY1(yNew);
+ lineDataInfo.setY2(yNew);
+ lineDataInfo.setX2(Math.round(width + (float)at.getTranslateY() + x));
break;
case 180:
- lineDataInfo.setX1 (pageWidth - Math.round((float)at.getTranslateX() - x));
+ lineDataInfo.setX1(pageWidth - Math.round((float)at.getTranslateX() - x));
yNew = pageHeight - Math.round((float)at.getTranslateY() - y);
- lineDataInfo.setY1 (yNew);
- lineDataInfo.setY2 (yNew);
- lineDataInfo.setX2 (pageWidth - Math.round((float)at.getTranslateX() - x - width));
+ lineDataInfo.setY1(yNew);
+ lineDataInfo.setY2(yNew);
+ lineDataInfo.setX2(pageWidth - Math.round((float)at.getTranslateX() - x - width));
break;
case 270:
- lineDataInfo.setX1 (pageHeight - Math.round((float)at.getTranslateY() - x));
+ lineDataInfo.setX1(pageHeight - Math.round((float)at.getTranslateY() - x));
yNew = Math.round((float)at.getTranslateX() + y);
- lineDataInfo.setY1 (yNew);
- lineDataInfo.setY2 (yNew);
- lineDataInfo.setX2 (pageHeight - Math.round((float)at.getTranslateY() - x - width));
+ lineDataInfo.setY1(yNew);
+ lineDataInfo.setY2(yNew);
+ lineDataInfo.setX2(pageHeight - Math.round((float)at.getTranslateY() - x - width));
break;
case 0:
default:
- lineDataInfo.setX1 (Math.round((float)at.getTranslateX() + x));
+ lineDataInfo.setX1(Math.round((float)at.getTranslateX() + x));
yNew = Math.round((float)at.getTranslateY() + y);
- lineDataInfo.setY1 (yNew);
- lineDataInfo.setY2 (yNew);
- lineDataInfo.setX2 (Math.round((float)at.getTranslateX() + x + width));
+ lineDataInfo.setY1(yNew);
+ lineDataInfo.setY2(yNew);
+ lineDataInfo.setX2(Math.round((float)at.getTranslateX() + x + width));
break;
}
dataStream.createLine(lineDataInfo);
* @param lineWidth the line width multiplier
*/
public void setLineWidth(float lineWidth) {
- float epsilon = Float.intBitsToFloat (0x00800000); // Float.MIN_NORMAL (JDK1.6)
- if (Math.abs (graphicsState.lineWidth - lineWidth) > epsilon) {
+ float epsilon = Float.intBitsToFloat(0x00800000); // Float.MIN_NORMAL (JDK1.6)
+ if (Math.abs(graphicsState.lineWidth - lineWidth) > epsilon) {
addObject(new GraphicsSetFractionalLineWidth(lineWidth));
graphicsState.lineWidth = lineWidth;
}
*
* @param bidiLevel the bidirectional embedding level
*/
- public void setBidiLevel (int bidiLevel) {
+ public void setBidiLevel(int bidiLevel) {
this.bidiLevel = bidiLevel;
}
*
* @param traits the map of traits
*/
- public void setTraits (Map traits) {
+ public void setTraits(Map traits) {
if (traits != null) {
this.traits = new TreeMap<Integer, Object>(traits);
} else {
int[][] gposAdjustments
= XMLUtil.getAttributeAsPositionAdjustments(lastAttributes, "position-adjust");
content.flip();
- WordArea word = new WordArea
- (offset, level, content.toString().trim(), letterAdjust,
+ WordArea word = new WordArea(
+ offset, level, content.toString().trim(), letterAdjust,
null, gposAdjustments, reversed);
AbstractTextArea text = getCurrentText();
word.setParentArea(text);
setTraits(attributes, leader, SUBSET_BOX);
setTraits(attributes, leader, SUBSET_COLOR);
setTraits(attributes, leader, SUBSET_FONT);
- leader.setBlockProgressionOffset
- (XMLUtil.getAttributeAsInt(attributes, "offset", 0));
+ leader.setBlockProgressionOffset(
+ XMLUtil.getAttributeAsInt(attributes, "offset", 0));
String ruleStyle = attributes.getValue("ruleStyle");
if (ruleStyle != null) {
leader.setRuleStyle(ruleStyle);
setTraits(attributes, viewport, SUBSET_COLOR);
viewport.setContentPosition(XMLUtil.getAttributeAsRectangle2D(attributes, "pos"));
viewport.setClip(XMLUtil.getAttributeAsBoolean(attributes, "clip", false));
- viewport.setBlockProgressionOffset
- (XMLUtil.getAttributeAsInt(attributes, "offset", 0));
+ viewport.setBlockProgressionOffset(
+ XMLUtil.getAttributeAsInt(attributes, "offset", 0));
Area parent = (Area)areaStack.peek();
parent.addChildArea(viewport);
areaStack.push(viewport);
*/
public void setWritingModeTraits(WritingModeTraitsGetter wmtg) {
if (getMainReference() != null) {
- getMainReference().setWritingModeTraits (wmtg);
+ getMainReference().setWritingModeTraits(wmtg);
}
}
* @return CTM The result of multiplying premult * this.
*/
public CTM multiply(CTM premult) {
- return new CTM ((premult.a * a) + (premult.b * c),
+ return new CTM((premult.a * a) + (premult.b * c),
(premult.a * b) + (premult.b * d),
(premult.c * a) + (premult.d * c),
(premult.c * b) + (premult.d * d),
* @param stream OutputStream
* @throws FOPException if the renderer cannot be properly initialized
*/
- public CachedRenderPagesModel (FOUserAgent userAgent, String outputFormat,
+ public CachedRenderPagesModel(FOUserAgent userAgent, String outputFormat,
FontInfo fontInfo, OutputStream stream) throws FOPException {
super(userAgent, outputFormat, fontInfo, stream);
tempBaseURI = TEMP_URI_GENERATOR.generate();
* <p> Used by bidirectional processing after line area consituent reordering.</p>
* @param inlineAreas the list of inline areas
*/
- public void setInlineAreas (List inlineAreas) {
+ public void setInlineAreas(List inlineAreas) {
for (Iterator<InlineArea> it = inlineAreas.iterator(); it.hasNext();) {
InlineArea ia = it.next();
Area pa = ia.getParentArea();
if (pa == null) {
- ia.setParentArea (this);
+ ia.setParentArea(this);
} else {
assert pa == this;
}
*/
public void setWritingModeTraits(WritingModeTraitsGetter wmtg) {
for (Span s : getSpans()) {
- s.setWritingModeTraits (wmtg);
+ s.setWritingModeTraits(wmtg);
}
}
* @param stream OutputStream
* @throws FOPException if the renderer cannot be properly initialized
*/
- public RenderPagesModel (FOUserAgent userAgent, String outputFormat,
+ public RenderPagesModel(FOUserAgent userAgent, String outputFormat,
FontInfo fontInfo, OutputStream stream) throws FOPException {
super();
* @param blockProgressionOffset a block progression offset or zero
* @param bidiLevel a resolved bidi level or -1
*/
- protected InlineArea (int blockProgressionOffset, int bidiLevel) {
+ protected InlineArea(int blockProgressionOffset, int bidiLevel) {
this.blockProgressionOffset = blockProgressionOffset;
setBidiLevel(bidiLevel);
}
* @param runs current list of inline runs
* @return modified list of inline runs, having appended new run
*/
- public List collectInlineRuns (List runs) {
+ public List collectInlineRuns(List runs) {
assert runs != null;
- runs.add (new InlineRun (this, new int[] {getBidiLevel()}));
+ runs.add(new InlineRun(this, new int[] {getBidiLevel()}));
return runs;
}
* @param ia inline area to test
* @return true if specified inline area is an ancestor or same as this area
*/
- public boolean isAncestorOrSelf (InlineArea ia) {
- return (ia == this) || isAncestor (ia);
+ public boolean isAncestorOrSelf(InlineArea ia) {
+ return (ia == this) || isAncestor(ia);
}
/**
* @param ia inline area to test
* @return true if specified inline area is an ancestor of this area
*/
- public boolean isAncestor (InlineArea ia) {
+ public boolean isAncestor(InlineArea ia) {
for (Area p = getParentArea(); p != null;) {
if (p == ia) {
return true;
if (autoSize) {
increaseIPD(childArea.getAllocIPD());
}
- updateLevel (childArea.getBidiLevel());
+ updateLevel(childArea.getBidiLevel());
int childOffset = childArea.getVirtualOffset();
minChildOffset = Math.min(minChildOffset, childOffset);
maxAfterEdge = Math.max(maxAfterEdge, childOffset + childArea.getVirtualBPD());
}
@Override
- public List collectInlineRuns (List runs) {
+ public List collectInlineRuns(List runs) {
for (Iterator<InlineArea> it = getChildAreas().iterator(); it.hasNext();) {
InlineArea ia = it.next();
- runs = ia.collectInlineRuns (runs);
+ runs = ia.collectInlineRuns(runs);
}
return runs;
}
}
}
- private void updateLevel (int newLevel) {
+ private void updateLevel(int newLevel) {
if (newLevel >= 0) {
int curLevel = getBidiLevel();
if (curLevel >= 0) {
if (newLevel < curLevel) {
- setBidiLevel (newLevel);
+ setBidiLevel(newLevel);
}
} else {
- setBidiLevel (newLevel);
+ setBidiLevel(newLevel);
}
}
}
* @param bidiLevel the bidirectional embedding level (or -1 if not defined)
*/
public SpaceArea(int blockProgressionOffset, int bidiLevel, char space, boolean adjustable) {
- super (blockProgressionOffset, bidiLevel);
+ super(blockProgressionOffset, bidiLevel);
this.space = space;
this.isAdjustable = adjustable;
}
* @param gposAdjustments array of general position adjustments or null if none apply
* @param blockProgressionOffset the offset for the next area
*/
- public void addWord
- (String word, int ipd, int[] letterAdjust, int[] levels,
+ public void addWord(
+ String word, int ipd, int[] letterAdjust, int[] levels,
int[][] gposAdjustments, int blockProgressionOffset) {
- int minWordLevel = findMinLevel (levels);
- WordArea wordArea = new WordArea
- (blockProgressionOffset, minWordLevel, word, letterAdjust, levels, gposAdjustments);
- wordArea.setIPD (ipd);
+ int minWordLevel = findMinLevel(levels);
+ WordArea wordArea = new WordArea(
+ blockProgressionOffset, minWordLevel, word, letterAdjust, levels, gposAdjustments);
+ wordArea.setIPD(ipd);
addChildArea(wordArea);
wordArea.setParentArea(this);
updateLevel(minWordLevel);
* @param adjustable is this space adjustable?
* @param level resolved bidirection level of space character
*/
- public void addSpace
- (char space, int ipd, boolean adjustable, int blockProgressionOffset, int level) {
+ public void addSpace(
+ char space, int ipd, boolean adjustable, int blockProgressionOffset, int level) {
SpaceArea spaceArea = new SpaceArea(blockProgressionOffset, level, space, adjustable);
- spaceArea.setIPD (ipd);
+ spaceArea.setIPD(ipd);
addChildArea(spaceArea);
spaceArea.setParentArea(this);
updateLevel(level);
return sb.toString();
}
- private void updateLevel (int newLevel) {
+ private void updateLevel(int newLevel) {
if (newLevel >= 0) {
int curLevel = getBidiLevel();
if (curLevel >= 0) {
if (newLevel < curLevel) {
- setBidiLevel (newLevel);
+ setBidiLevel(newLevel);
}
} else {
- setBidiLevel (newLevel);
+ setBidiLevel(newLevel);
}
}
}
- private static int findMinLevel (int[] levels) {
+ private static int findMinLevel(int[] levels) {
if (levels != null) {
int lMin = Integer.MAX_VALUE;
for (int i = 0, n = levels.length; i < n; i++) {
}
}
- private int[] makeLevels (int level, int count) {
+ private int[] makeLevels(int level, int count) {
if (level >= 0) {
int[] levels = new int [ count ];
- Arrays.fill (levels, level);
+ Arrays.fill(levels, level);
return levels;
} else {
return null;
* @return modified list of inline runs, having appended new run
*/
@Override
- public List collectInlineRuns (List runs) {
+ public List collectInlineRuns(List runs) {
assert runs != null;
- runs.add (new InlineRun (this, new int[] {getBidiLevel()}));
+ runs.add(new InlineRun(this, new int[] {getBidiLevel()}));
return runs;
}
}
* @param gposAdjustments array of general position adjustments or null if none apply
* @param reversed true if word is known to be reversed at construction time
*/
- public WordArea
- (int blockProgressionOffset, int level, String word, int[] letterAdjust, int[] levels,
+ public WordArea(
+ int blockProgressionOffset, int level, String word, int[] letterAdjust, int[] levels,
int[][] gposAdjustments, boolean reversed) {
- super (blockProgressionOffset, level);
+ super(blockProgressionOffset, level);
int length = (word != null) ? word.length() : 0;
this.word = word;
- this.letterAdjust = maybeAdjustLength (letterAdjust, length);
- this.levels = maybePopulateLevels (levels, level, length);
- this.gposAdjustments = maybeAdjustLength (gposAdjustments, length);
+ this.letterAdjust = maybeAdjustLength(letterAdjust, length);
+ this.levels = maybePopulateLevels(levels, level, length);
+ this.gposAdjustments = maybeAdjustLength(gposAdjustments, length);
this.reversed = reversed;
}
* in case word area is heterogenously leveled
* @param gposAdjustments array of general position adjustments or null if none apply
*/
- public WordArea
- (int blockProgressionOffset, int level, String word, int[] letterAdjust, int[] levels,
+ public WordArea(
+ int blockProgressionOffset, int level, String word, int[] letterAdjust, int[] levels,
int[][] gposAdjustments) {
this (blockProgressionOffset, level, word, letterAdjust, levels, gposAdjustments, false);
}
* @return a (possibly null) array of per-character (glyph) levels over the specified
* sequence
*/
- public int[] getBidiLevels (int start, int end) {
+ public int[] getBidiLevels(int start, int end) {
assert start <= end;
if (this.levels != null) {
int n = end - start;
* level
* @return a resolved bidirectional level or, if not specified, then -1
*/
- public int bidiLevelAt (int position) {
+ public int bidiLevelAt(int position) {
if (position > word.length()) {
throw new IndexOutOfBoundsException();
} else if (levels != null) {
}
@Override
- public List collectInlineRuns (List runs) {
+ public List collectInlineRuns(List runs) {
assert runs != null;
InlineRun r;
if (getBidiLevels() != null) {
- r = new InlineRun (this, getBidiLevels());
+ r = new InlineRun(this, getBidiLevels());
} else {
- r = new InlineRun (this, -1, word.length());
+ r = new InlineRun(this, -1, word.length());
}
- runs.add (r);
+ runs.add(r);
return runs;
}
* level
* @return an array of adjustments or null if none applies
*/
- public int[] glyphPositionAdjustmentsAt (int position) {
+ public int[] glyphPositionAdjustmentsAt(int position) {
if (position > word.length()) {
throw new IndexOutOfBoundsException();
} else if (gposAdjustments != null) {
* adjustments.</p>
* @param mirror if true, then perform mirroring if mirrorred characters
*/
- public void reverse (boolean mirror) {
+ public void reverse(boolean mirror) {
if (word.length() > 0) {
- word = ((new StringBuffer (word)) .reverse()) .toString();
+ word = ((new StringBuffer(word)) .reverse()) .toString();
if (levels != null) {
- reverse (levels);
+ reverse(levels);
}
if (gposAdjustments != null) {
- reverse (gposAdjustments);
+ reverse(gposAdjustments);
}
reversed = !reversed;
if (mirror) {
- word = CharMirror.mirror (word);
+ word = CharMirror.mirror(word);
}
}
}
*/
public void mirror() {
if (word.length() > 0) {
- word = CharMirror.mirror (word);
+ word = CharMirror.mirror(word);
}
}
* If int[] array is not of specified length, then create
* a new copy of the first length entries.
*/
- private static int[] maybeAdjustLength (int[] ia, int length) {
+ private static int[] maybeAdjustLength(int[] ia, int length) {
if (ia != null) {
if (ia.length == length) {
return ia;
* If int[][] matrix is not of specified length, then create
* a new shallow copy of the first length entries.
*/
- private static int[][] maybeAdjustLength (int[][] im, int length) {
+ private static int[][] maybeAdjustLength(int[][] im, int length) {
if (im != null) {
if (im.length == length) {
return im;
}
}
- private static int[] maybePopulateLevels (int[] levels, int level, int count) {
+ private static int[] maybePopulateLevels(int[] levels, int level, int count) {
if ((levels == null) && (level >= 0)) {
levels = new int[count];
- Arrays.fill (levels, level);
+ Arrays.fill(levels, level);
}
- return maybeAdjustLength (levels, count);
+ return maybeAdjustLength(levels, count);
}
- private static void reverse (int[] a) {
+ private static void reverse(int[] a) {
for (int i = 0, n = a.length, m = n / 2; i < m; i++) {
int k = n - i - 1;
int t = a [ k ];
}
}
- private static void reverse (int[][] aa) {
+ private static void reverse(int[][] aa) {
for (int i = 0, n = aa.length, m = n / 2; i < m; i++) {
int k = n - i - 1;
int[] t = aa [ k ];
}
}
- private void setLogOption (String option, String level) {
+ private void setLogOption(String option, String level) {
if (log instanceof CommandLineLogger
|| System.getProperty("org.apache.commons.logging.Log") == null) {
setLogLevel(level);
* @param ch a unicode scalar value
* @return bidi class
*/
-public static int getBidiClass (int ch) {
+public static int getBidiClass(int ch) {
if (ch <= 0x00FF) {
return bcL1 [ ch - 0x0000 ];
} else if ((ch >= 0x0590) && (ch <= 0x06FF)) {
return bcR1 [ ch - 0x0590 ];
} else {
- return getBidiClass (ch, bcS1, bcE1, bcC1);
+ return getBidiClass(ch, bcS1, bcE1, bcC1);
}
}
-private static int getBidiClass (int ch, int[] sa, int[] ea, byte[] ca) {
- int k = Arrays.binarySearch (sa, ch);
+private static int getBidiClass(int ch, int[] sa, int[] ea, byte[] ca) {
+ int k = Arrays.binarySearch(sa, ch);
if (k >= 0) {
return ca [ k ];
} else {
* Resolve inline directionality.
* @param ps a page sequence FO instance
*/
- public static void resolveInlineDirectionality (PageSequence ps) {
+ public static void resolveInlineDirectionality(PageSequence ps) {
if (log.isDebugEnabled()) {
- log.debug ("BD: RESOLVE: " + ps);
+ log.debug("BD: RESOLVE: " + ps);
}
- List ranges = pruneEmptyRanges (ps.collectDelimitedTextRanges (new Stack()));
- resolveInlineDirectionality (ranges);
+ List ranges = pruneEmptyRanges(ps.collectDelimitedTextRanges(new Stack()));
+ resolveInlineDirectionality(ranges);
}
/**
* Reorder line area.
* @param la a line area instance
*/
- public static void reorder (LineArea la) {
+ public static void reorder(LineArea la) {
// 1. collect inline levels
- List runs = collectRuns (la.getInlineAreas(), new Vector());
+ List runs = collectRuns(la.getInlineAreas(), new Vector());
if (log.isDebugEnabled()) {
- dumpRuns ("BD: REORDER: INPUT:", runs);
+ dumpRuns("BD: REORDER: INPUT:", runs);
}
// 2. split heterogeneous inlines
- runs = splitRuns (runs);
+ runs = splitRuns(runs);
if (log.isDebugEnabled()) {
- dumpRuns ("BD: REORDER: SPLIT INLINES:", runs);
+ dumpRuns("BD: REORDER: SPLIT INLINES:", runs);
}
// 3. determine minimum and maximum levels
- int[] mm = computeMinMaxLevel (runs, null);
+ int[] mm = computeMinMaxLevel(runs, null);
if (log.isDebugEnabled()) {
log.debug("BD: REORDER: { min = " + mm[0] + ", max = " + mm[1] + "}");
}
int mx = mm[1];
if (mx > 0) {
for (int l1 = mx, l2 = ((mn & 1) == 0) ? (mn + 1) : mn; l1 >= l2; l1--) {
- runs = reorderRuns (runs, l1);
+ runs = reorderRuns(runs, l1);
}
}
if (log.isDebugEnabled()) {
- dumpRuns ("BD: REORDER: REORDERED RUNS:", runs);
+ dumpRuns("BD: REORDER: REORDERED RUNS:", runs);
}
// 5. reverse word consituents (characters and glyphs) while mirroring
boolean mirror = true;
- reverseWords (runs, mirror);
+ reverseWords(runs, mirror);
if (log.isDebugEnabled()) {
- dumpRuns ("BD: REORDER: REORDERED WORDS:", runs);
+ dumpRuns("BD: REORDER: REORDERED WORDS:", runs);
}
// 6. replace line area's inline areas with reordered runs' inline areas
- replaceInlines (la, replicateSplitWords (runs));
+ replaceInlines(la, replicateSplitWords(runs));
}
- private static void resolveInlineDirectionality (List ranges) {
+ private static void resolveInlineDirectionality(List ranges) {
for (Iterator it = ranges.iterator(); it.hasNext(); ) {
DelimitedTextRange r = (DelimitedTextRange) it.next();
r.resolve();
if (log.isDebugEnabled()) {
- log.debug (r);
+ log.debug(r);
}
}
}
- private static List collectRuns (List inlines, List runs) {
+ private static List collectRuns(List inlines, List runs) {
for (Iterator it = inlines.iterator(); it.hasNext(); ) {
InlineArea ia = (InlineArea) it.next();
- runs = ia.collectInlineRuns (runs);
+ runs = ia.collectInlineRuns(runs);
}
return runs;
}
- private static List splitRuns (List runs) {
+ private static List splitRuns(List runs) {
List runsNew = new Vector();
for (Iterator it = runs.iterator(); it.hasNext(); ) {
InlineRun ir = (InlineRun) it.next();
if (ir.isHomogenous()) {
- runsNew.add (ir);
+ runsNew.add(ir);
} else {
- runsNew.addAll (ir.split());
+ runsNew.addAll(ir.split());
}
}
- if (! runsNew.equals (runs)) {
+ if (! runsNew.equals(runs)) {
runs = runsNew;
}
return runs;
}
- private static int[] computeMinMaxLevel (List runs, int[] mm) {
+ private static int[] computeMinMaxLevel(List runs, int[] mm) {
if (mm == null) {
mm = new int[] {Integer.MAX_VALUE, Integer.MIN_VALUE};
}
for (Iterator it = runs.iterator(); it.hasNext(); ) {
InlineRun ir = (InlineRun) it.next();
- ir.updateMinMax (mm);
+ ir.updateMinMax(mm);
}
return mm;
}
- private static List reorderRuns (List runs, int level) {
+ private static List reorderRuns(List runs, int level) {
assert level >= 0;
List runsNew = new Vector();
for (int i = 0, n = runs.size(); i < n; i++) {
InlineRun iri = (InlineRun) runs.get(i);
if (iri.getMinLevel() < level) {
- runsNew.add (iri);
+ runsNew.add(iri);
} else {
int s = i;
int e = s;
}
}
if (s < e) {
- runsNew.addAll (reverseRuns (runs, s, e));
+ runsNew.addAll(reverseRuns(runs, s, e));
}
i = e - 1;
}
}
- if (! runsNew.equals (runs)) {
+ if (! runsNew.equals(runs)) {
runs = runsNew;
}
return runs;
}
- private static List reverseRuns (List runs, int s, int e) {
+ private static List reverseRuns(List runs, int s, int e) {
int n = e - s;
- Vector runsNew = new Vector (n);
+ Vector runsNew = new Vector(n);
if (n > 0) {
for (int i = 0; i < n; i++) {
int k = (n - i - 1);
InlineRun ir = (InlineRun) runs.get(s + k);
ir.reverse();
- runsNew.add (ir);
+ runsNew.add(ir);
}
}
return runsNew;
}
- private static void reverseWords (List runs, boolean mirror) {
+ private static void reverseWords(List runs, boolean mirror) {
for (Iterator it = runs.iterator(); it.hasNext(); ) {
InlineRun ir = (InlineRun) it.next();
- ir.maybeReverseWord (mirror);
+ ir.maybeReverseWord(mirror);
}
}
- private static List replicateSplitWords (List runs) {
+ private static List replicateSplitWords(List runs) {
// [TBD] for each run which inline word area appears multiple times in
// runs, replicate that word
return runs;
}
- private static void replaceInlines (LineArea la, List runs) {
+ private static void replaceInlines(LineArea la, List runs) {
List<InlineArea> inlines = new ArrayList<InlineArea>();
for (Iterator it = runs.iterator(); it.hasNext(); ) {
InlineRun ir = (InlineRun) it.next();
- inlines.add (ir.getInline());
+ inlines.add(ir.getInline());
}
- la.setInlineAreas (unflattenInlines (inlines));
+ la.setInlineAreas(unflattenInlines(inlines));
}
- private static List unflattenInlines (List<InlineArea> inlines) {
- return new UnflattenProcessor (inlines) .unflatten();
+ private static List unflattenInlines(List<InlineArea> inlines) {
+ return new UnflattenProcessor(inlines) .unflatten();
}
- private static void dumpRuns (String header, List runs) {
- log.debug (header);
+ private static void dumpRuns(String header, List runs) {
+ log.debug(header);
for (Iterator it = runs.iterator(); it.hasNext(); ) {
InlineRun ir = (InlineRun) it.next();
- log.debug (ir);
+ log.debug(ir);
}
}
- private static List pruneEmptyRanges (Stack ranges) {
+ private static List pruneEmptyRanges(Stack ranges) {
Vector rv = new Vector();
for (Iterator it = ranges.iterator(); it.hasNext(); ) {
DelimitedTextRange r = (DelimitedTextRange) it.next();
if (! r.isEmpty()) {
- rv.add (r);
+ rv.add(r);
}
}
return rv;
* Primary constructor.
* @param fn node that generates this text range
*/
- public DelimitedTextRange (FONode fn) {
+ public DelimitedTextRange(FONode fn) {
this.fn = fn;
this.buffer = new StringBuffer();
this.intervals = new Vector();
* @param it character iterator
* @param fn node that generates interval being appended
*/
- public void append (CharIterator it, FONode fn) {
+ public void append(CharIterator it, FONode fn) {
if (it != null) {
int s = buffer.length();
int e = s;
while (it.hasNext()) {
char c = it.nextChar();
- buffer.append (c);
+ buffer.append(c);
e++;
}
- intervals.add (new TextInterval (fn, s, e));
+ intervals.add(new TextInterval(fn, s, e));
}
}
/**
* @param c character
* @param fn node that generates interval being appended
*/
- public void append (char c, FONode fn) {
+ public void append(char c, FONode fn) {
if (c != 0) {
int s = buffer.length();
int e = s + 1;
- buffer.append (c);
- intervals.add (new TextInterval (fn, s, e));
+ buffer.append(c);
+ intervals.add(new TextInterval(fn, s, e));
}
}
/**
*/
public void resolve() {
WritingModeTraitsGetter tg;
- if ((tg = WritingModeTraits.getWritingModeTraitsGetter (getNode())) != null) {
- resolve (tg.getInlineProgressionDirection());
+ if ((tg = WritingModeTraits.getWritingModeTraitsGetter(getNode())) != null) {
+ resolve(tg.getInlineProgressionDirection());
}
}
@Override
public String toString() {
- StringBuffer sb = new StringBuffer ("DR: " + fn.getLocalName() + " { <" + CharUtilities.toNCRefs (buffer.toString()) + ">");
- sb.append (", intervals <");
+ StringBuffer sb = new StringBuffer("DR: " + fn.getLocalName() + " { <" + CharUtilities.toNCRefs(buffer.toString()) + ">");
+ sb.append(", intervals <");
boolean first = true;
for (Iterator it = intervals.iterator(); it.hasNext(); ) {
TextInterval ti = (TextInterval) it.next();
} else {
sb.append(',');
}
- sb.append (ti.toString());
+ sb.append(ti.toString());
}
sb.append("> }");
return sb.toString();
}
- private void resolve (Direction paragraphEmbeddingLevel) {
+ private void resolve(Direction paragraphEmbeddingLevel) {
int [] levels;
- if ((levels = UnicodeBidiAlgorithm.resolveLevels (buffer, paragraphEmbeddingLevel)) != null) {
- assignLevels (levels);
- assignBlockLevel (paragraphEmbeddingLevel);
+ if ((levels = UnicodeBidiAlgorithm.resolveLevels(buffer, paragraphEmbeddingLevel)) != null) {
+ assignLevels(levels);
+ assignBlockLevel(paragraphEmbeddingLevel);
assignTextLevels();
}
}
* @param levels array of levels each corresponding to each index of the delimited
* text range
*/
- private void assignLevels (int[] levels) {
- Vector intervalsNew = new Vector (intervals.size());
+ private void assignLevels(int[] levels) {
+ Vector intervalsNew = new Vector(intervals.size());
for (Iterator it = intervals.iterator(); it.hasNext(); ) {
TextInterval ti = (TextInterval) it.next();
- intervalsNew.addAll (assignLevels (ti, levels));
+ intervalsNew.addAll(assignLevels(ti, levels));
}
- if (! intervalsNew.equals (intervals)) {
+ if (! intervalsNew.equals(intervals)) {
intervals = intervalsNew;
}
}
* @return a list of text intervals as described above
*/
private static final Log log = LogFactory.getLog(BidiResolver.class); // CSOK: ConstantNameCheck
- private List assignLevels (TextInterval ti, int[] levels) {
+ private List assignLevels(TextInterval ti, int[] levels) {
Vector tiv = new Vector();
FONode fn = ti.getNode();
int fnStart = ti.getStart(); // start of node's text in delimited text range
}
}
if ((ti.getStart() == s) && (ti.getEnd() == e)) {
- ti.setLevel (l); // reuse interval, assigning it single level
+ ti.setLevel(l); // reuse interval, assigning it single level
} else {
- ti = new TextInterval (fn, fnStart, s, e, l); // subdivide interval
+ ti = new TextInterval(fn, fnStart, s, e, l); // subdivide interval
}
if (log.isDebugEnabled()) {
- log.debug ("AL(" + l + "): " + ti);
+ log.debug("AL(" + l + "): " + ti);
}
- tiv.add (ti);
+ tiv.add(ti);
i = e;
}
return tiv;
ti.assignTextLevels();
}
}
- private void assignBlockLevel (Direction paragraphEmbeddingLevel) {
+ private void assignBlockLevel(Direction paragraphEmbeddingLevel) {
int defaultLevel = (paragraphEmbeddingLevel == Direction.RL) ? 1 : 0;
for (Iterator it = intervals.iterator(); it.hasNext(); ) {
TextInterval ti = (TextInterval) it.next();
- assignBlockLevel (ti.getNode(), defaultLevel);
+ assignBlockLevel(ti.getNode(), defaultLevel);
}
}
- private void assignBlockLevel (FONode node, int defaultLevel) {
+ private void assignBlockLevel(FONode node, int defaultLevel) {
for (FONode fn = node; fn != null; fn = fn.getParent()) {
if (fn instanceof FObj) {
FObj fo = (FObj) fn;
if (fo.isBidiRangeBlockItem()) {
if (fo.getBidiLevel() < 0) {
- fo.setBidiLevel (defaultLevel);
+ fo.setBidiLevel(defaultLevel);
}
break;
}
* @param inline which generated this inline run
* @param levels levels array
*/
- public InlineRun (InlineArea inline, int[] levels) {
+ public InlineRun(InlineArea inline, int[] levels) {
assert inline != null;
assert levels != null;
this.inline = inline;
this.levels = levels;
- setMinMax (levels);
+ setMinMax(levels);
}
/**
* Alternate constructor.
* @param level for each index
* @param count of indices
*/
- public InlineRun (InlineArea inline, int level, int count) {
- this (inline, makeLevels (level, count));
+ public InlineRun(InlineArea inline, int level, int count) {
+ this (inline, makeLevels(level, count));
}
/**
* Obtain inline area that generated this inline run.
public int getMaxLevel() {
return maxLevel;
}
- private void setMinMax (int[] levels) {
+ private void setMinMax(int[] levels) {
int mn = Integer.MAX_VALUE;
int mx = Integer.MIN_VALUE;
if ((levels != null) && (levels.length > 0)) {
}
}
if (s < e) {
- runs.add (new InlineRun (inline, l, e - s));
+ runs.add(new InlineRun(inline, l, e - s));
}
i = e;
}
* Update a min/max array to correspond with this run's min/max values.
* @param mm reference to min/max array
*/
- public void updateMinMax (int[] mm) {
+ public void updateMinMax(int[] mm) {
if (minLevel < mm[0]) {
mm[0] = minLevel;
}
* reversal.
* @param mirror if true then also mirror characters
*/
- public void maybeReverseWord (boolean mirror) {
+ public void maybeReverseWord(boolean mirror) {
if (inline instanceof WordArea) {
WordArea w = (WordArea) inline;
// if not already reversed, then reverse now
if (! w.isReversed()) {
if ((reversals & 1) != 0) {
- w.reverse (mirror);
+ w.reverse(mirror);
} else if (mirror && maybeNeedsMirroring()) {
w.mirror();
}
}
}
@Override
- public boolean equals (Object o) {
+ public boolean equals(Object o) {
if (o instanceof InlineRun) {
InlineRun ir = (InlineRun) o;
if (ir.inline != inline) {
} else {
c = '?';
}
- sb.append (c);
- sb.append ("\', levels = \'");
- sb.append (generateLevels (levels));
- sb.append ("\', min = ");
- sb.append (minLevel);
- sb.append (", max = ");
- sb.append (maxLevel);
- sb.append (", reversals = ");
- sb.append (reversals);
- sb.append (", content = <");
- sb.append (CharUtilities.toNCRefs (content));
- sb.append ("> }");
+ sb.append(c);
+ sb.append("\', levels = \'");
+ sb.append(generateLevels(levels));
+ sb.append("\', min = ");
+ sb.append(minLevel);
+ sb.append(", max = ");
+ sb.append(maxLevel);
+ sb.append(", reversals = ");
+ sb.append(reversals);
+ sb.append(", content = <");
+ sb.append(CharUtilities.toNCRefs(content));
+ sb.append("> }");
return sb.toString();
}
- private String generateLevels (int[] levels) {
+ private String generateLevels(int[] levels) {
StringBuffer lb = new StringBuffer();
int maxLevel = -1;
int numLevels = levels.length;
} else if (maxLevel < 10) {
// use string of decimal digits
for (int i = 0; i < numLevels; i++) {
- lb.append ((char) ('0' + levels [ i ]));
+ lb.append((char) ('0' + levels [ i ]));
}
} else {
// use comma separated list
} else {
lb.append(',');
}
- lb.append (levels [ i ]);
+ lb.append(levels [ i ]);
}
}
return lb.toString();
}
- private static int[] makeLevels (int level, int count) {
+ private static int[] makeLevels(int level, int count) {
int[] levels = new int [ count ];
- Arrays.fill (levels, level);
+ Arrays.fill(levels, level);
return levels;
}
}
private int start; // starting index within delimited text range
private int end; // ending index within delimited text range
private int level; // resolved level or default (-1)
- TextInterval (FONode fn, int start, int end) {
+ TextInterval(FONode fn, int start, int end) {
this (fn, start, start, end, -1);
}
- TextInterval (FONode fn, int textStart, int start, int end, int level) {
+ TextInterval(FONode fn, int textStart, int start, int end, int level) {
this.fn = fn;
this.textStart = textStart;
this.start = start;
int getLevel() {
return level;
}
- void setLevel (int level) {
+ void setLevel(int level) {
this.level = level;
}
public int length() {
if (fn instanceof FOText) {
return ((FOText) fn) .getCharSequence() .toString();
} else if (fn instanceof Character) {
- return new String (new char[] {((Character) fn) .getCharacter()});
+ return new String(new char[] {((Character) fn) .getCharacter()});
} else {
return null;
}
}
public void assignTextLevels() {
if (fn instanceof FOText) {
- ((FOText) fn) .setBidiLevel (level, start - textStart, end - textStart);
+ ((FOText) fn) .setBidiLevel(level, start - textStart, end - textStart);
} else if (fn instanceof Character) {
- ((Character) fn) .setBidiLevel (level);
+ ((Character) fn) .setBidiLevel(level);
} else if (fn instanceof AbstractPageNumberCitation) {
- ((AbstractPageNumberCitation) fn) .setBidiLevel (level);
+ ((AbstractPageNumberCitation) fn) .setBidiLevel(level);
} else if (fn instanceof AbstractGraphics) {
- ((AbstractGraphics) fn) .setBidiLevel (level);
+ ((AbstractGraphics) fn) .setBidiLevel(level);
} else if (fn instanceof Leader) {
- ((Leader) fn) .setBidiLevel (level);
+ ((Leader) fn) .setBidiLevel(level);
}
}
- public boolean equals (Object o) {
+ public boolean equals(Object o) {
if (o instanceof TextInterval) {
TextInterval ti = (TextInterval) o;
if (ti.getNode() != fn) {
} else {
c = '?';
}
- sb.append (c);
- sb.append ("[" + start + "," + end + "][" + textStart + "](" + level + ")");
+ sb.append(c);
+ sb.append("[" + start + "," + end + "][" + textStart + "](" + level + ")");
return sb.toString();
}
}
private TextArea tcNew; // new text area container being constructed
private Stack<InlineParent> icOrig; // stack of original inline parent containers
private Stack<InlineParent> icNew; // stack of new inline parent containers being constructed
- UnflattenProcessor (List<InlineArea> inlines) {
+ UnflattenProcessor(List<InlineArea> inlines) {
this.il = inlines;
this.ilNew = new ArrayList<InlineArea>();
this.iaLevelLast = -1;
List unflatten() {
if (il != null) {
for (Iterator<InlineArea> it = il.iterator(); it.hasNext(); ) {
- process (it.next());
+ process(it.next());
}
}
finishAll();
return ilNew;
}
- private void process (InlineArea ia) {
- process (findInlineContainers (ia), findTextContainer (ia), ia);
+ private void process(InlineArea ia) {
+ process(findInlineContainers(ia), findTextContainer(ia), ia);
}
- private void process (List<InlineParent> ich, TextArea tc, InlineArea ia) {
+ private void process(List<InlineParent> ich, TextArea tc, InlineArea ia) {
if ((tcNew == null) || (tc != tcNew)) {
- maybeFinishTextContainer (tc, ia);
- maybeFinishInlineContainers (ich, tc, ia);
- update (ich, tc, ia);
+ maybeFinishTextContainer(tc, ia);
+ maybeFinishInlineContainers(ich, tc, ia);
+ update(ich, tc, ia);
} else {
// skip inline area whose text container is the current new text container,
// which occurs in the context of the inline runs produced by a filled area
}
}
- private boolean shouldFinishTextContainer (TextArea tc, InlineArea ia) {
+ private boolean shouldFinishTextContainer(TextArea tc, InlineArea ia) {
if ((tcOrig != null) && (tc != tcOrig)) {
return true;
} else if ((iaLevelLast != -1) && (ia.getBidiLevel() != iaLevelLast)) {
}
}
private void finishTextContainer() {
- finishTextContainer (null, null);
+ finishTextContainer(null, null);
}
- private void finishTextContainer (TextArea tc, InlineArea ia) {
+ private void finishTextContainer(TextArea tc, InlineArea ia) {
if (tcNew != null) {
- updateIPD (tcNew);
+ updateIPD(tcNew);
if (! icNew.empty()) {
- icNew.peek().addChildArea (tcNew);
+ icNew.peek().addChildArea(tcNew);
} else {
- ilNew.add (tcNew);
+ ilNew.add(tcNew);
}
}
tcNew = null;
}
- private void maybeFinishTextContainer (TextArea tc, InlineArea ia) {
- if (shouldFinishTextContainer (tc, ia)) {
- finishTextContainer (tc, ia);
+ private void maybeFinishTextContainer(TextArea tc, InlineArea ia) {
+ if (shouldFinishTextContainer(tc, ia)) {
+ finishTextContainer(tc, ia);
}
}
- private boolean shouldFinishInlineContainer (List<InlineParent> ich, TextArea tc, InlineArea ia) {
+ private boolean shouldFinishInlineContainer(List<InlineParent> ich, TextArea tc, InlineArea ia) {
if ((ich == null) || ich.isEmpty()) {
return ! icOrig.empty();
} else {
if (! icOrig.empty()) {
InlineParent ic = ich.get(0);
InlineParent ic0 = icOrig.peek();
- return (ic != ic0) && ! isInlineParentOf (ic, ic0);
+ return (ic != ic0) && ! isInlineParentOf(ic, ic0);
} else {
return false;
}
}
}
private void finishInlineContainer() {
- finishInlineContainer (null, null, null);
+ finishInlineContainer(null, null, null);
}
- private void finishInlineContainer (List<InlineParent> ich, TextArea tc, InlineArea ia) {
+ private void finishInlineContainer(List<InlineParent> ich, TextArea tc, InlineArea ia) {
if ((ich != null) && ! ich.isEmpty()) { // finish non-matching inner inline container(s)
for (Iterator<InlineParent> it = ich.iterator(); it.hasNext(); ) {
InlineParent ic = it.next();
assert icO0 != null;
assert icN0 != null;
if (icNew.empty()) {
- ilNew.add (icN0);
+ ilNew.add(icN0);
} else {
- icNew.peek().addChildArea (icN0);
+ icNew.peek().addChildArea(icN0);
}
if (! icOrig.empty() && (icOrig.peek() == ic)) {
break;
assert icO0 != null;
assert icN0 != null;
if (icNew.empty()) {
- ilNew.add (icN0);
+ ilNew.add(icN0);
} else {
- icNew.peek().addChildArea (icN0);
+ icNew.peek().addChildArea(icN0);
}
}
}
}
- private void maybeFinishInlineContainers (List<InlineParent> ich, TextArea tc, InlineArea ia) {
- if (shouldFinishInlineContainer (ich, tc, ia)) {
- finishInlineContainer (ich, tc, ia);
+ private void maybeFinishInlineContainers(List<InlineParent> ich, TextArea tc, InlineArea ia) {
+ if (shouldFinishInlineContainer(ich, tc, ia)) {
+ finishInlineContainer(ich, tc, ia);
}
}
private void finishAll() {
finishTextContainer();
finishInlineContainer();
}
- private void update (List<InlineParent> ich, TextArea tc, InlineArea ia) {
- if (! alreadyUnflattened (ia)) {
+ private void update(List<InlineParent> ich, TextArea tc, InlineArea ia) {
+ if (! alreadyUnflattened(ia)) {
if ((ich != null) && ! ich.isEmpty()) {
- pushInlineContainers (ich);
+ pushInlineContainers(ich);
}
if (tc != null) {
- pushTextContainer (tc, ia);
+ pushTextContainer(tc, ia);
} else {
- pushNonTextInline (ia);
+ pushNonTextInline(ia);
}
iaLevelLast = ia.getBidiLevel();
tcOrig = tc;
tcOrig = null;
}
}
- private boolean alreadyUnflattened (InlineArea ia) {
+ private boolean alreadyUnflattened(InlineArea ia) {
for (Iterator<InlineArea> it = ilNew.iterator(); it.hasNext(); ) {
- if (ia.isAncestorOrSelf (it.next())) {
+ if (ia.isAncestorOrSelf(it.next())) {
return true;
}
}
return false;
}
- private void pushInlineContainers (List<InlineParent> ich) {
+ private void pushInlineContainers(List<InlineParent> ich) {
LinkedList<InlineParent> icl = new LinkedList<InlineParent>();
for (Iterator<InlineParent> it = ich.iterator(); it.hasNext(); ) {
InlineParent ic = it.next();
- if (icOrig.search (ic) >= 0) {
+ if (icOrig.search(ic) >= 0) {
break;
} else {
- icl.addFirst (ic);
+ icl.addFirst(ic);
}
}
for (Iterator<InlineParent> it = icl.iterator(); it.hasNext(); ) {
InlineParent ic = it.next();
- icOrig.push (ic);
- icNew.push (generateInlineContainer (ic));
+ icOrig.push(ic);
+ icNew.push(generateInlineContainer(ic));
}
}
- private void pushTextContainer (TextArea tc, InlineArea ia) {
+ private void pushTextContainer(TextArea tc, InlineArea ia) {
if (tc instanceof UnresolvedPageNumber) {
tcNew = tc;
} else {
if (tcNew == null) {
- tcNew = generateTextContainer (tc);
+ tcNew = generateTextContainer(tc);
}
- tcNew.addChildArea (ia);
+ tcNew.addChildArea(ia);
}
}
- private void pushNonTextInline (InlineArea ia) {
+ private void pushNonTextInline(InlineArea ia) {
if (icNew.empty()) {
- ilNew.add (ia);
+ ilNew.add(ia);
} else {
- icNew.peek().addChildArea (ia);
+ icNew.peek().addChildArea(ia);
}
}
- private InlineParent generateInlineContainer (InlineParent i) {
+ private InlineParent generateInlineContainer(InlineParent i) {
if (i instanceof BasicLinkArea) {
- return generateBasicLinkArea ((BasicLinkArea) i);
+ return generateBasicLinkArea((BasicLinkArea) i);
} else if (i instanceof FilledArea) {
- return generateFilledArea ((FilledArea) i);
+ return generateFilledArea((FilledArea) i);
} else {
- return generateInlineContainer0 (i);
+ return generateInlineContainer0(i);
}
}
- private InlineParent generateBasicLinkArea (BasicLinkArea l) {
+ private InlineParent generateBasicLinkArea(BasicLinkArea l) {
BasicLinkArea lc = new BasicLinkArea();
if (l != null) {
- initializeInlineContainer (lc, l);
- initializeLinkArea (lc, l);
+ initializeInlineContainer(lc, l);
+ initializeLinkArea(lc, l);
}
return lc;
}
- private void initializeLinkArea (BasicLinkArea lc, BasicLinkArea l) {
+ private void initializeLinkArea(BasicLinkArea lc, BasicLinkArea l) {
assert lc != null;
assert l != null;
LinkResolver r = l.getResolver();
String[] idrefs = r.getIDRefs();
if (idrefs.length > 0) {
String idref = idrefs[0];
- LinkResolver lr = new LinkResolver (idref, lc);
- lc.setResolver (lr);
- r.addDependent (lr);
+ LinkResolver lr = new LinkResolver(idref, lc);
+ lc.setResolver(lr);
+ r.addDependent(lr);
}
}
}
- private InlineParent generateFilledArea (FilledArea f) {
+ private InlineParent generateFilledArea(FilledArea f) {
FilledArea fc = new FilledArea();
if (f != null) {
- initializeInlineContainer (fc, f);
- initializeFilledArea (fc, f);
+ initializeInlineContainer(fc, f);
+ initializeFilledArea(fc, f);
}
return fc;
}
- private void initializeFilledArea (FilledArea fc, FilledArea f) {
+ private void initializeFilledArea(FilledArea fc, FilledArea f) {
assert fc != null;
assert f != null;
- fc.setIPD (f.getIPD());
- fc.setUnitWidth (f.getUnitWidth());
+ fc.setIPD(f.getIPD());
+ fc.setUnitWidth(f.getUnitWidth());
fc.setAdjustingInfo(f.getAdjustingInfo());
}
- private InlineParent generateInlineContainer0 (InlineParent i) {
+ private InlineParent generateInlineContainer0(InlineParent i) {
InlineParent ic = new InlineParent();
if (i != null) {
- initializeInlineContainer (ic, i);
+ initializeInlineContainer(ic, i);
}
return ic;
}
- private void initializeInlineContainer (InlineParent ic, InlineParent i) {
+ private void initializeInlineContainer(InlineParent ic, InlineParent i) {
assert ic != null;
assert i != null;
- ic.setTraits (i.getTraits());
- ic.setBPD (i.getBPD());
- ic.setBlockProgressionOffset (i.getBlockProgressionOffset());
+ ic.setTraits(i.getTraits());
+ ic.setBPD(i.getBPD());
+ ic.setBlockProgressionOffset(i.getBlockProgressionOffset());
}
- private TextArea generateTextContainer (TextArea t) {
+ private TextArea generateTextContainer(TextArea t) {
TextArea tc = new TextArea();
if (t != null) {
- tc.setTraits (t.getTraits());
- tc.setBPD (t.getBPD());
- tc.setBlockProgressionOffset (t.getBlockProgressionOffset());
- tc.setBaselineOffset (t.getBaselineOffset());
- tc.setTextWordSpaceAdjust (t.getTextWordSpaceAdjust());
- tc.setTextLetterSpaceAdjust (t.getTextLetterSpaceAdjust());
+ tc.setTraits(t.getTraits());
+ tc.setBPD(t.getBPD());
+ tc.setBlockProgressionOffset(t.getBlockProgressionOffset());
+ tc.setBaselineOffset(t.getBaselineOffset());
+ tc.setTextWordSpaceAdjust(t.getTextWordSpaceAdjust());
+ tc.setTextLetterSpaceAdjust(t.getTextLetterSpaceAdjust());
}
return tc;
}
- private void updateIPD (TextArea tc) {
+ private void updateIPD(TextArea tc) {
int numAdjustable = 0;
for (Iterator it = tc.getChildAreas().iterator(); it.hasNext(); ) {
InlineArea ia = (InlineArea) it.next();
}
}
if (numAdjustable > 0) {
- tc.setIPD (tc.getIPD() + (numAdjustable * tc.getTextWordSpaceAdjust()));
+ tc.setIPD(tc.getIPD() + (numAdjustable * tc.getTextWordSpaceAdjust()));
}
}
- private TextArea findTextContainer (InlineArea ia) {
+ private TextArea findTextContainer(InlineArea ia) {
assert ia != null;
TextArea t = null;
while (t == null) {
}
return t;
}
- private List<InlineParent> findInlineContainers (InlineArea ia) {
+ private List<InlineParent> findInlineContainers(InlineArea ia) {
assert ia != null;
List<InlineParent> ich = new ArrayList<InlineParent>();
Area a = ia.getParentArea();
while (a != null) {
if (a instanceof InlineArea) {
if ((a instanceof InlineParent) && ! (a instanceof TextArea)) {
- ich.add ((InlineParent) a);
+ ich.add((InlineParent) a);
}
a = ((InlineArea) a) .getParentArea();
} else {
}
return ich;
}
- private boolean isInlineParentOf (InlineParent ic0, InlineParent ic1) {
+ private boolean isInlineParentOf(InlineParent ic0, InlineParent ic1) {
assert ic0 != null;
return ic0.getParentArea() == ic1;
}
* @param cs input character sequence representing a UTF-16 encoded string
* @param defaultLevel the default paragraph level, which must be zero (LR) or one (RL)
*/
- public static int[] resolveLevels (CharSequence cs, Direction defaultLevel) {
+ public static int[] resolveLevels(CharSequence cs, Direction defaultLevel) {
int[] chars = new int [ cs.length() ];
- if (convertToScalar (cs, chars) || (defaultLevel == Direction.RL)) {
- return resolveLevels (chars, (defaultLevel == Direction.RL) ? 1 : 0, new int [ chars.length ]);
+ if (convertToScalar(cs, chars) || (defaultLevel == Direction.RL)) {
+ return resolveLevels(chars, (defaultLevel == Direction.RL) ? 1 : 0, new int [ chars.length ]);
} else {
return null;
}
* @param defaultLevel the default paragraph level, which must be zero (LR) or one (RL)
* @param levels array to receive levels, one for each character in chars array
*/
- public static int[] resolveLevels (int[] chars, int defaultLevel, int[] levels) {
- return resolveLevels (chars, getClasses (chars), defaultLevel, levels, false);
+ public static int[] resolveLevels(int[] chars, int defaultLevel, int[] levels) {
+ return resolveLevels(chars, getClasses(chars), defaultLevel, levels, false);
}
/**
* @param levels array to receive levels, one for each character in chars array
* @param useRuleL1 true if rule L1 should be used
*/
- public static int[] resolveLevels (int[] chars, int[] classes, int defaultLevel, int[] levels, boolean useRuleL1) {
+ public static int[] resolveLevels(int[] chars, int[] classes, int defaultLevel, int[] levels, boolean useRuleL1) {
int[] ica = classes;
- int[] wca = copySequence (ica);
+ int[] wca = copySequence(ica);
int[] ea = new int [ levels.length ];
- resolveExplicit (wca, defaultLevel, ea);
- resolveRuns (wca, defaultLevel, ea, levelsFromEmbeddings (ea, levels));
+ resolveExplicit(wca, defaultLevel, ea);
+ resolveRuns(wca, defaultLevel, ea, levelsFromEmbeddings(ea, levels));
if (useRuleL1) {
- resolveSeparators (ica, wca, defaultLevel, levels);
+ resolveSeparators(ica, wca, defaultLevel, levels);
}
- dump ("RL: CC(" + ((chars != null) ? chars.length : -1) + ")", chars, classes, defaultLevel, levels);
+ dump("RL: CC(" + ((chars != null) ? chars.length : -1) + ")", chars, classes, defaultLevel, levels);
return levels;
}
- private static int[] copySequence (int[] ta) {
+ private static int[] copySequence(int[] ta) {
int[] na = new int [ ta.length ];
- System.arraycopy (ta, 0, na, 0, na.length);
+ System.arraycopy(ta, 0, na, 0, na.length);
return na;
}
- private static void resolveExplicit (int[] wca, int defaultLevel, int[] ea) {
+ private static void resolveExplicit(int[] wca, int defaultLevel, int[] ea) {
int[] es = new int [ MAX_LEVELS ]; /* embeddings stack */
int ei = 0; /* embeddings stack index */
int ec = defaultLevel; /* current embedding level */
break;
default:
if ((el & OVERRIDE) != 0) {
- wca [ i ] = directionOfLevel (el);
+ wca [ i ] = directionOfLevel(el);
}
break;
}
}
}
- private static int directionOfLevel (int level) {
+ private static int directionOfLevel(int level) {
return ((level & 1) != 0) ? R : L;
}
- private static int levelOfEmbedding (int embedding) {
+ private static int levelOfEmbedding(int embedding) {
return embedding & ~OVERRIDE;
}
- private static int[] levelsFromEmbeddings (int[] ea, int[] la) {
+ private static int[] levelsFromEmbeddings(int[] ea, int[] la) {
assert ea != null;
assert la != null;
assert la.length == ea.length;
for (int i = 0, n = la.length; i < n; i++) {
- la [ i ] = levelOfEmbedding (ea [ i ]);
+ la [ i ] = levelOfEmbedding(ea [ i ]);
}
return la;
}
- private static void resolveRuns (int[] wca, int defaultLevel, int[] ea, int[] la) {
+ private static void resolveRuns(int[] wca, int defaultLevel, int[] ea, int[] la) {
if (la.length != wca.length) {
- throw new IllegalArgumentException ("levels sequence length must match classes sequence length");
+ throw new IllegalArgumentException("levels sequence length must match classes sequence length");
} else if (la.length != ea.length) {
- throw new IllegalArgumentException ("levels sequence length must match embeddings sequence length");
+ throw new IllegalArgumentException("levels sequence length must match embeddings sequence length");
} else {
for (int i = 0, n = ea.length, lPrev = defaultLevel; i < n; ) {
int s = i;
int e = s;
- int l = findNextNonRetainedFormattingLevel (wca, ea, s, lPrev);
+ int l = findNextNonRetainedFormattingLevel(wca, ea, s, lPrev);
while (e < n) {
if (la [ e ] != l) {
- if (startsWithRetainedFormattingRun (wca, ea, e)) {
- e += getLevelRunLength (ea, e);
+ if (startsWithRetainedFormattingRun(wca, ea, e)) {
+ e += getLevelRunLength(ea, e);
} else {
break;
}
e++;
}
}
- lPrev = resolveRun (wca, defaultLevel, ea, la, s, e, l, lPrev);
+ lPrev = resolveRun(wca, defaultLevel, ea, la, s, e, l, lPrev);
i = e;
}
}
}
- private static int findNextNonRetainedFormattingLevel (int[] wca, int[] ea, int start, int lPrev) {
+ private static int findNextNonRetainedFormattingLevel(int[] wca, int[] ea, int start, int lPrev) {
int s = start;
int e = wca.length;
while (s < e) {
- if (startsWithRetainedFormattingRun (wca, ea, s)) {
- s += getLevelRunLength (ea, s);
+ if (startsWithRetainedFormattingRun(wca, ea, s)) {
+ s += getLevelRunLength(ea, s);
} else {
break;
}
}
if (s < e) {
- return levelOfEmbedding (ea [ s ]);
+ return levelOfEmbedding(ea [ s ]);
} else {
return lPrev;
}
}
- private static int getLevelRunLength (int[] ea, int start) {
+ private static int getLevelRunLength(int[] ea, int start) {
assert start < ea.length;
int nl = 0;
- for (int s = start, e = ea.length, l0 = levelOfEmbedding (ea [ start ]); s < e; s++) {
- if (levelOfEmbedding (ea [ s ]) == l0) {
+ for (int s = start, e = ea.length, l0 = levelOfEmbedding(ea [ start ]); s < e; s++) {
+ if (levelOfEmbedding(ea [ s ]) == l0) {
nl++;
} else {
break;
return nl;
}
- private static boolean startsWithRetainedFormattingRun (int[] wca, int[] ea, int start) {
- int nl = getLevelRunLength (ea, start);
+ private static boolean startsWithRetainedFormattingRun(int[] wca, int[] ea, int start) {
+ int nl = getLevelRunLength(ea, start);
if (nl > 0) {
- int nc = getRetainedFormattingRunLength (wca, start);
+ int nc = getRetainedFormattingRunLength(wca, start);
return (nc >= nl);
} else {
return false;
}
}
- private static int getRetainedFormattingRunLength (int[] wca, int start) {
+ private static int getRetainedFormattingRunLength(int[] wca, int start) {
assert start < wca.length;
int nc = 0;
for (int s = start, e = wca.length; s < e; s++) {
return nc;
}
- private static int resolveRun (int[] wca, int defaultLevel, int[] ea, int[] la, int start, int end, int level, int levelPrev) {
+ private static int resolveRun(int[] wca, int defaultLevel, int[] ea, int[] la, int start, int end, int level, int levelPrev) {
// determine start of run direction
- int sor = directionOfLevel (max (levelPrev, level));
+ int sor = directionOfLevel(max(levelPrev, level));
// determine end of run direction
int le = -1;
if (end == wca.length) {
- le = max (level, defaultLevel);
+ le = max(level, defaultLevel);
} else {
for (int i = end; i < wca.length; i++) {
if (wca [ i ] != BidiConstants.BN) {
- le = max (level, la [ i ]);
+ le = max(level, la [ i ]);
break;
}
}
if (le < 0) {
- le = max (level, defaultLevel);
+ le = max(level, defaultLevel);
}
}
- int eor = directionOfLevel (le);
+ int eor = directionOfLevel(le);
if (log.isDebugEnabled()) {
- log.debug ("BR[" + padLeft (start, 3) + "," + padLeft (end, 3) + "] :" + padLeft (level, 2) + ": SOR(" + getClassName(sor) + "), EOR(" + getClassName(eor) + ")");
+ log.debug("BR[" + padLeft(start, 3) + "," + padLeft(end, 3) + "] :" + padLeft(level, 2) + ": SOR(" + getClassName(sor) + "), EOR(" + getClassName(eor) + ")");
}
- resolveWeak (wca, defaultLevel, ea, la, start, end, level, sor, eor);
- resolveNeutrals (wca, defaultLevel, ea, la, start, end, level, sor, eor);
- resolveImplicit (wca, defaultLevel, ea, la, start, end, level, sor, eor);
+ resolveWeak(wca, defaultLevel, ea, la, start, end, level, sor, eor);
+ resolveNeutrals(wca, defaultLevel, ea, la, start, end, level, sor, eor);
+ resolveImplicit(wca, defaultLevel, ea, la, start, end, level, sor, eor);
// if this run is all retained formatting, then return prior level, otherwise this run's level
- return isRetainedFormatting (wca, start, end) ? levelPrev : level;
+ return isRetainedFormatting(wca, start, end) ? levelPrev : level;
}
- private static void resolveWeak (int[] wca, int defaultLevel, int[] ea, int[] la, int start, int end, int level, int sor, int eor) {
+ private static void resolveWeak(int[] wca, int defaultLevel, int[] ea, int[] la, int start, int end, int level, int sor, int eor) {
// W1 - X BN* NSM -> X BN* X
for (int i = start, n = end, bcPrev = sor; i < n; i++) {
if (bcPrev == AL) {
wca [ i ] = AN;
}
- } else if (isStrong (bc)) {
+ } else if (isStrong(bc)) {
bcPrev = bc;
}
}
int bc = wca [ i ];
if ((bc == ET) || (bc == ES) || (bc == CS)) {
wca [ i ] = ON;
- resolveAdjacentBoundaryNeutrals (wca, start, end, i, ON);
+ resolveAdjacentBoundaryNeutrals(wca, start, end, i, ON);
}
}
}
- private static void resolveNeutrals (int[] wca, int defaultLevel, int[] ea, int[] la, int start, int end, int level, int sor, int eor) {
+ private static void resolveNeutrals(int[] wca, int defaultLevel, int[] ea, int[] la, int start, int end, int level, int sor, int eor) {
// N1 - (L|R) N+ (L|R) -> L L+ L | R R+ R; (AN|EN) N+ R -> (AN|EN) R+ R; R N+ (AN|EN) -> R R+ (AN|EN)
for (int i = start, n = end, bcPrev = sor; i < n; i++) {
int bc = wca [ i ];
- if (isNeutral (bc)) {
+ if (isNeutral(bc)) {
int bcNext = eor;
for (int j = i + 1; j < n; j++) {
bc = wca [ j ];
} else if ((bc == AN) || (bc == EN)) {
bcNext = R;
break;
- } else if (isNeutral (bc)) {
+ } else if (isNeutral(bc)) {
continue;
- } else if (isRetainedFormatting (bc)) {
+ } else if (isRetainedFormatting(bc)) {
continue;
} else {
break;
}
if (bcPrev == bcNext) {
wca [ i ] = bcPrev;
- resolveAdjacentBoundaryNeutrals (wca, start, end, i, bcPrev);
+ resolveAdjacentBoundaryNeutrals(wca, start, end, i, bcPrev);
}
} else if ((bc == L) || (bc == R)) {
bcPrev = bc;
// N2 - N -> embedding level
for (int i = start, n = end; i < n; i++) {
int bc = wca [ i ];
- if (isNeutral (bc)) {
- int bcEmbedding = directionOfLevel (levelOfEmbedding (ea [ i ]));
+ if (isNeutral(bc)) {
+ int bcEmbedding = directionOfLevel(levelOfEmbedding(ea [ i ]));
wca [ i ] = bcEmbedding;
- resolveAdjacentBoundaryNeutrals (wca, start, end, i, bcEmbedding);
+ resolveAdjacentBoundaryNeutrals(wca, start, end, i, bcEmbedding);
}
}
}
- private static void resolveAdjacentBoundaryNeutrals (int[] wca, int start, int end, int index, int bcNew) {
+ private static void resolveAdjacentBoundaryNeutrals(int[] wca, int start, int end, int index, int bcNew) {
if ((index < start) || (index >= end)) {
throw new IllegalArgumentException();
} else {
}
}
- private static void resolveImplicit (int[] wca, int defaultLevel, int[] ea, int[] la, int start, int end, int level, int sor, int eor) {
+ private static void resolveImplicit(int[] wca, int defaultLevel, int[] ea, int[] la, int start, int end, int level, int sor, int eor) {
for (int i = start, n = end; i < n; i++) {
int bc = wca [ i ]; // bidi class
int el = la [ i ]; // embedding level
* @param dl default paragraph level
* @param la array of output levels to be adjusted, as produced by bidi algorithm
*/
- private static void resolveSeparators (int[] ica, int[] wca, int dl, int[] la) {
+ private static void resolveSeparators(int[] ica, int[] wca, int dl, int[] la) {
// steps (1) through (3)
for (int i = 0, n = ica.length; i < n; i++) {
int ic = ica[i];
la[i] = dl;
for (int k = i - 1; k >= 0; k--) {
int pc = ica[k];
- if (isRetainedFormatting (pc)) {
+ if (isRetainedFormatting(pc)) {
continue;
} else if (pc == BidiConstants.WS) {
la[k] = dl;
for (int i = ica.length; i > 0; i--) {
int k = i - 1;
int ic = ica[k];
- if (isRetainedFormatting (ic)) {
+ if (isRetainedFormatting(ic)) {
continue;
} else if (ic == BidiConstants.WS) {
la[k] = dl;
// step (5) - per section 5.2
for (int i = 0, n = ica.length; i < n; i++) {
int ic = ica[i];
- if (isRetainedFormatting (ic)) {
+ if (isRetainedFormatting(ic)) {
if (i == 0) {
la[i] = dl;
} else {
}
}
- private static boolean isStrong (int bc) {
+ private static boolean isStrong(int bc) {
switch (bc) {
case L:
case R:
}
}
- private static boolean isNeutral (int bc) {
+ private static boolean isNeutral(int bc) {
switch (bc) {
case WS:
case ON:
}
}
- private static boolean isRetainedFormatting (int bc) {
+ private static boolean isRetainedFormatting(int bc) {
switch (bc) {
case LRE:
case LRO:
}
}
- private static boolean isRetainedFormatting (int[] ca, int s, int e) {
+ private static boolean isRetainedFormatting(int[] ca, int s, int e) {
for (int i = s; i < e; i++) {
- if (! isRetainedFormatting (ca[i])) {
+ if (! isRetainedFormatting(ca[i])) {
return false;
}
}
return true;
}
- private static int max (int x, int y) {
+ private static int max(int x, int y) {
if (x > y) {
return x;
} else {
}
}
- private static int[] getClasses (int[] chars) {
+ private static int[] getClasses(int[] chars) {
int[] classes = new int [ chars.length ];
int bc;
for (int i = 0, n = chars.length; i < n; i++) {
int ch = chars [ i ];
if (ch >= 0) {
- bc = BidiClass.getBidiClass (chars [ i ]);
+ bc = BidiClass.getBidiClass(chars [ i ]);
} else {
bc = SURROGATE;
}
* @throws IllegalArgumentException if the input sequence is not a valid UTF-16 string, e.g.,
* if it contains an isolated UTF-16 surrogate
*/
- private static boolean convertToScalar (CharSequence cs, int[] chars) throws IllegalArgumentException {
+ private static boolean convertToScalar(CharSequence cs, int[] chars) throws IllegalArgumentException {
boolean triggered = false;
if (chars.length != cs.length()) {
- throw new IllegalArgumentException ("characters array length must match input sequence length");
+ throw new IllegalArgumentException("characters array length must match input sequence length");
}
for (int i = 0, n = chars.length; i < n; ) {
- int chIn = cs.charAt (i);
+ int chIn = cs.charAt(i);
int chOut;
if (chIn < 0xD800) {
chOut = chIn;
int chHi = chIn;
int chLo;
if ((i + 1) < n) {
- chLo = cs.charAt (i + 1);
+ chLo = cs.charAt(i + 1);
if ((chLo >= 0xDC00) && (chLo <= 0xDFFF)) {
- chOut = convertToScalar (chHi, chLo);
+ chOut = convertToScalar(chHi, chLo);
} else {
- throw new IllegalArgumentException ("isolated high surrogate");
+ throw new IllegalArgumentException("isolated high surrogate");
}
} else {
- throw new IllegalArgumentException ("truncated surrogate pair");
+ throw new IllegalArgumentException("truncated surrogate pair");
}
} else if (chIn < 0xE000) {
- throw new IllegalArgumentException ("isolated low surrogate");
+ throw new IllegalArgumentException("isolated low surrogate");
} else {
chOut = chIn;
}
- if (! triggered && triggersBidi (chOut)) {
+ if (! triggered && triggersBidi(chOut)) {
triggered = true;
}
if ((chOut & 0xFF0000) == 0) {
* @param chLo low (least significant or second) surrogate
* @throws IllegalArgumentException if one of the input surrogates is not valid
*/
- private static int convertToScalar (int chHi, int chLo) {
+ private static int convertToScalar(int chHi, int chLo) {
if ((chHi < 0xD800) || (chHi > 0xDBFF)) {
- throw new IllegalArgumentException ("bad high surrogate");
+ throw new IllegalArgumentException("bad high surrogate");
} else if ((chLo < 0xDC00) || (chLo > 0xDFFF)) {
- throw new IllegalArgumentException ("bad low surrogate");
+ throw new IllegalArgumentException("bad low surrogate");
} else {
return (((chHi & 0x03FF) << 10) | (chLo & 0x03FF)) + 0x10000;
}
* @return true if character triggers bidirectional processing
* @param ch a unicode scalar value
*/
- private static boolean triggersBidi (int ch) {
- switch (BidiClass.getBidiClass (ch)) {
+ private static boolean triggersBidi(int ch) {
+ switch (BidiClass.getBidiClass(ch)) {
case R:
case AL:
case AN:
}
}
- private static void dump (String header, int[] chars, int[] classes, int defaultLevel, int[] levels) {
- log.debug (header);
- log.debug ("BD: default level(" + defaultLevel + ")");
+ private static void dump(String header, int[] chars, int[] classes, int defaultLevel, int[] levels) {
+ log.debug(header);
+ log.debug("BD: default level(" + defaultLevel + ")");
StringBuffer sb = new StringBuffer();
if (chars != null) {
for (int i = 0, n = chars.length; i < n; i++) {
int ch = chars [ i ];
sb.setLength(0);
if ((ch > 0x20) && (ch < 0x7F)) {
- sb.append ((char) ch);
+ sb.append((char) ch);
} else {
- sb.append (CharUtilities.charToNCRef (ch));
+ sb.append(CharUtilities.charToNCRef(ch));
}
for (int k = sb.length(); k < 12; k++) {
- sb.append (' ');
+ sb.append(' ');
}
- sb.append (": " + padRight (getClassName (classes[i]), 4) + " " + levels[i]);
- log.debug (sb);
+ sb.append(": " + padRight(getClassName(classes[i]), 4) + " " + levels[i]);
+ log.debug(sb);
}
} else {
for (int i = 0, n = classes.length; i < n; i++) {
sb.setLength(0);
for (int k = sb.length(); k < 12; k++) {
- sb.append (' ');
+ sb.append(' ');
}
- sb.append (": " + padRight (getClassName (classes[i]), 4) + " " + levels[i]);
- log.debug (sb);
+ sb.append(": " + padRight(getClassName(classes[i]), 4) + " " + levels[i]);
+ log.debug(sb);
}
}
}
- private static String getClassName (int bc) {
+ private static String getClassName(int bc) {
switch (bc) {
case L: // left-to-right
return "L";
}
}
- private static String padLeft (int n, int width) {
- return padLeft (Integer.toString (n), width);
+ private static String padLeft(int n, int width) {
+ return padLeft(Integer.toString(n), width);
}
- private static String padLeft (String s, int width) {
+ private static String padLeft(String s, int width) {
StringBuffer sb = new StringBuffer();
for (int i = s.length(); i < width; i++) {
sb.append(' ');
}
- sb.append (s);
+ sb.append(s);
return sb.toString();
}
}
*/
- private static String padRight (String s, int width) {
- StringBuffer sb = new StringBuffer (s);
+ private static String padRight(String s, int width) {
+ StringBuffer sb = new StringBuffer(s);
for (int i = sb.length(); i < width; i++) {
sb.append(' ');
}
* @param set for coverage set based class mappings, indicates set index, otherwise ignored
* @return size of class table
*/
- int getClassSize (int set);
+ int getClassSize(int set);
/**
* Map glyph identifier (code) to coverge index. Returns -1 if glyph identifier is not in the domain of
* @param set for coverage set based class mappings, indicates set index, otherwise ignored
* @return non-negative glyph class index or -1 if glyph identifiers is not mapped by table
*/
- int getClassIndex (int gid, int set);
+ int getClassIndex(int gid, int set);
}
private GlyphClassMapping cm;
- private GlyphClassTable (GlyphClassMapping cm) {
+ private GlyphClassTable(GlyphClassMapping cm) {
assert cm != null;
assert cm instanceof GlyphMappingTable;
this.cm = cm;
}
/** {@inheritDoc} */
- public int getClassSize (int set) {
- return cm.getClassSize (set);
+ public int getClassSize(int set) {
+ return cm.getClassSize(set);
}
/** {@inheritDoc} */
- public int getClassIndex (int gid, int set) {
- return cm.getClassIndex (gid, set);
+ public int getClassIndex(int gid, int set) {
+ return cm.getClassIndex(gid, set);
}
/**
* @param entries list of mapped or ranged class entries, or null or empty list
* @return a new covera table instance
*/
- public static GlyphClassTable createClassTable (List entries) {
+ public static GlyphClassTable createClassTable(List entries) {
GlyphClassMapping cm;
if ((entries == null) || (entries.size() == 0)) {
- cm = new EmptyClassTable (entries);
- } else if (isMappedClass (entries)) {
- cm = new MappedClassTable (entries);
- } else if (isRangeClass (entries)) {
- cm = new RangeClassTable (entries);
- } else if (isCoverageSetClass (entries)) {
- cm = new CoverageSetClassTable (entries);
+ cm = new EmptyClassTable(entries);
+ } else if (isMappedClass(entries)) {
+ cm = new MappedClassTable(entries);
+ } else if (isRangeClass(entries)) {
+ cm = new RangeClassTable(entries);
+ } else if (isCoverageSetClass(entries)) {
+ cm = new CoverageSetClassTable(entries);
} else {
cm = null;
}
assert cm != null : "unknown class type";
- return new GlyphClassTable (cm);
+ return new GlyphClassTable(cm);
}
- private static boolean isMappedClass (List entries) {
+ private static boolean isMappedClass(List entries) {
if ((entries == null) || (entries.size() == 0)) {
return false;
} else {
}
}
- private static boolean isRangeClass (List entries) {
+ private static boolean isRangeClass(List entries) {
if ((entries == null) || (entries.size() == 0)) {
return false;
} else {
}
}
- private static boolean isCoverageSetClass (List entries) {
+ private static boolean isCoverageSetClass(List entries) {
if ((entries == null) || (entries.size() == 0)) {
return false;
} else {
}
private static class EmptyClassTable extends GlyphMappingTable.EmptyMappingTable implements GlyphClassMapping {
- public EmptyClassTable (List entries) {
- super (entries);
+ public EmptyClassTable(List entries) {
+ super(entries);
}
/** {@inheritDoc} */
- public int getClassSize (int set) {
+ public int getClassSize(int set) {
return 0;
}
/** {@inheritDoc} */
- public int getClassIndex (int gid, int set) {
+ public int getClassIndex(int gid, int set) {
return -1;
}
}
private int firstGlyph;
private int[] gca;
private int gcMax = -1;
- public MappedClassTable (List entries) {
- populate (entries);
+ public MappedClassTable(List entries) {
+ populate(entries);
}
/** {@inheritDoc} */
public List getEntries() {
List entries = new java.util.ArrayList();
- entries.add (Integer.valueOf (firstGlyph));
+ entries.add(Integer.valueOf(firstGlyph));
if (gca != null) {
for (int i = 0, n = gca.length; i < n; i++) {
- entries.add (Integer.valueOf (gca [ i ]));
+ entries.add(Integer.valueOf(gca [ i ]));
}
}
return entries;
return gcMax + 1;
}
/** {@inheritDoc} */
- public int getMappedIndex (int gid) {
+ public int getMappedIndex(int gid) {
int i = gid - firstGlyph;
if ((i >= 0) && (i < gca.length)) {
return gca [ i ];
}
}
/** {@inheritDoc} */
- public int getClassSize (int set) {
+ public int getClassSize(int set) {
return getMappingSize();
}
/** {@inheritDoc} */
- public int getClassIndex (int gid, int set) {
- return getMappedIndex (gid);
+ public int getClassIndex(int gid, int set) {
+ return getMappedIndex(gid);
}
- private void populate (List entries) {
+ private void populate(List entries) {
// obtain entries iterator
Iterator it = entries.iterator();
// extract first glyph
if (o instanceof Integer) {
firstGlyph = ((Integer) o) . intValue();
} else {
- throw new AdvancedTypographicTableFormatException ("illegal entry, first entry must be Integer denoting first glyph value, but is: " + o);
+ throw new AdvancedTypographicTableFormatException("illegal entry, first entry must be Integer denoting first glyph value, but is: " + o);
}
}
// extract glyph class array
gcMax = gc;
}
} else {
- throw new AdvancedTypographicTableFormatException ("illegal mapping entry, must be Integer: " + o);
+ throw new AdvancedTypographicTableFormatException("illegal mapping entry, must be Integer: " + o);
}
}
assert i == n;
if (i > 0) {
sb.append(',');
}
- sb.append (Integer.toString (gca [ i ]));
+ sb.append(Integer.toString(gca [ i ]));
}
sb.append("} }");
return sb.toString();
}
private static class RangeClassTable extends GlyphMappingTable.RangeMappingTable implements GlyphClassMapping {
- public RangeClassTable (List entries) {
- super (entries);
+ public RangeClassTable(List entries) {
+ super(entries);
}
/** {@inheritDoc} */
- public int getMappedIndex (int gid, int s, int m) {
+ public int getMappedIndex(int gid, int s, int m) {
return m;
}
/** {@inheritDoc} */
- public int getClassSize (int set) {
+ public int getClassSize(int set) {
return getMappingSize();
}
/** {@inheritDoc} */
- public int getClassIndex (int gid, int set) {
- return getMappedIndex (gid);
+ public int getClassIndex(int gid, int set) {
+ return getMappedIndex(gid);
}
}
private static class CoverageSetClassTable extends GlyphMappingTable.EmptyMappingTable implements GlyphClassMapping {
- public CoverageSetClassTable (List entries) {
- throw new UnsupportedOperationException ("coverage set class table not yet supported");
+ public CoverageSetClassTable(List entries) {
+ throw new UnsupportedOperationException("coverage set class table not yet supported");
}
/** {@inheritDoc} */
public int getType() {
return GLYPH_CLASS_TYPE_COVERAGE_SET;
}
/** {@inheritDoc} */
- public int getClassSize (int set) {
+ public int getClassSize(int set) {
return 0;
}
/** {@inheritDoc} */
- public int getClassIndex (int gid, int set) {
+ public int getClassIndex(int gid, int set) {
return -1;
}
}
* @param gid glyph identifier (code)
* @return non-negative glyph coverage index or -1 if glyph identifiers is not mapped by table
*/
- int getCoverageIndex (int gid);
+ int getCoverageIndex(int gid);
}
private GlyphCoverageMapping cm;
- private GlyphCoverageTable (GlyphCoverageMapping cm) {
+ private GlyphCoverageTable(GlyphCoverageMapping cm) {
assert cm != null;
assert cm instanceof GlyphMappingTable;
this.cm = cm;
}
/** {@inheritDoc} */
- public int getCoverageIndex (int gid) {
- return cm.getCoverageIndex (gid);
+ public int getCoverageIndex(int gid) {
+ return cm.getCoverageIndex(gid);
}
/**
* @param entries list of mapped or ranged coverage entries, or null or empty list
* @return a new covera table instance
*/
- public static GlyphCoverageTable createCoverageTable (List entries) {
+ public static GlyphCoverageTable createCoverageTable(List entries) {
GlyphCoverageMapping cm;
if ((entries == null) || (entries.size() == 0)) {
- cm = new EmptyCoverageTable (entries);
- } else if (isMappedCoverage (entries)) {
- cm = new MappedCoverageTable (entries);
- } else if (isRangeCoverage (entries)) {
- cm = new RangeCoverageTable (entries);
+ cm = new EmptyCoverageTable(entries);
+ } else if (isMappedCoverage(entries)) {
+ cm = new MappedCoverageTable(entries);
+ } else if (isRangeCoverage(entries)) {
+ cm = new RangeCoverageTable(entries);
} else {
cm = null;
}
assert cm != null : "unknown coverage type";
- return new GlyphCoverageTable (cm);
+ return new GlyphCoverageTable(cm);
}
- private static boolean isMappedCoverage (List entries) {
+ private static boolean isMappedCoverage(List entries) {
if ((entries == null) || (entries.size() == 0)) {
return false;
} else {
}
}
- private static boolean isRangeCoverage (List entries) {
+ private static boolean isRangeCoverage(List entries) {
if ((entries == null) || (entries.size() == 0)) {
return false;
} else {
}
private static class EmptyCoverageTable extends GlyphMappingTable.EmptyMappingTable implements GlyphCoverageMapping {
- public EmptyCoverageTable (List entries) {
- super (entries);
+ public EmptyCoverageTable(List entries) {
+ super(entries);
}
/** {@inheritDoc} */
public int getCoverageSize() {
return 0;
}
/** {@inheritDoc} */
- public int getCoverageIndex (int gid) {
+ public int getCoverageIndex(int gid) {
return -1;
}
}
private static class MappedCoverageTable extends GlyphMappingTable.MappedMappingTable implements GlyphCoverageMapping {
private int[] map;
- public MappedCoverageTable (List entries) {
- populate (entries);
+ public MappedCoverageTable(List entries) {
+ populate(entries);
}
/** {@inheritDoc} */
public List getEntries() {
List entries = new java.util.ArrayList();
if (map != null) {
for (int i = 0, n = map.length; i < n; i++) {
- entries.add (Integer.valueOf (map [ i ]));
+ entries.add(Integer.valueOf(map [ i ]));
}
}
return entries;
public int getMappingSize() {
return (map != null) ? map.length : 0;
}
- public int getMappedIndex (int gid) {
+ public int getMappedIndex(int gid) {
int i;
- if ((i = Arrays.binarySearch (map, gid)) >= 0) {
+ if ((i = Arrays.binarySearch(map, gid)) >= 0) {
return i;
} else {
return -1;
return getMappingSize();
}
/** {@inheritDoc} */
- public int getCoverageIndex (int gid) {
- return getMappedIndex (gid);
+ public int getCoverageIndex(int gid) {
+ return getMappedIndex(gid);
}
- private void populate (List entries) {
+ private void populate(List entries) {
int i = 0;
int skipped = 0;
int n = entries.size();
if (gid > gidMax) {
map [ i++ ] = gidMax = gid;
} else {
- log.info ("ignoring out of order or duplicate glyph index: " + gid);
+ log.info("ignoring out of order or duplicate glyph index: " + gid);
skipped++;
}
} else {
- throw new AdvancedTypographicTableFormatException ("illegal glyph index: " + gid);
+ throw new AdvancedTypographicTableFormatException("illegal glyph index: " + gid);
}
} else {
- throw new AdvancedTypographicTableFormatException ("illegal coverage entry, must be Integer: " + o);
+ throw new AdvancedTypographicTableFormatException("illegal coverage entry, must be Integer: " + o);
}
}
assert (i + skipped) == n;
if (i > 0) {
sb.append(',');
}
- sb.append (Integer.toString (map [ i ]));
+ sb.append(Integer.toString(map [ i ]));
}
sb.append('}');
return sb.toString();
}
private static class RangeCoverageTable extends GlyphMappingTable.RangeMappingTable implements GlyphCoverageMapping {
- public RangeCoverageTable (List entries) {
- super (entries);
+ public RangeCoverageTable(List entries) {
+ super(entries);
}
/** {@inheritDoc} */
- public int getMappedIndex (int gid, int s, int m) {
+ public int getMappedIndex(int gid, int s, int m) {
return m + gid - s;
}
/** {@inheritDoc} */
return getMappingSize();
}
/** {@inheritDoc} */
- public int getCoverageIndex (int gid) {
- return getMappedIndex (gid);
+ public int getCoverageIndex(int gid) {
+ return getMappedIndex(gid);
}
}
* @param gi a glyph index
* @return true if some (unspecified) definition is available for the specified glyph
*/
- boolean hasDefinition (int gi);
+ boolean hasDefinition(int gi);
}
* @param format subtable format
* @param mapping subtable coverage table
*/
- protected GlyphDefinitionSubtable (String id, int sequence, int flags, int format, GlyphMappingTable mapping) {
- super (id, sequence, flags, format, mapping);
+ protected GlyphDefinitionSubtable(String id, int sequence, int flags, int format, GlyphMappingTable mapping) {
+ super(id, sequence, flags, format, mapping);
}
/** {@inheritDoc} */
/** {@inheritDoc} */
public String getTypeName() {
- return GlyphDefinitionTable.getLookupTypeName (getType());
+ return GlyphDefinitionTable.getLookupTypeName(getType());
}
/** {@inheritDoc} */
}
/** {@inheritDoc} */
- public boolean hasDefinition (int gi) {
+ public boolean hasDefinition(int gi) {
GlyphCoverageMapping cvm;
if ((cvm = getCoverage()) != null) {
- if (cvm.getCoverageIndex (gi) >= 0) {
+ if (cvm.getCoverageIndex(gi) >= 0) {
return true;
}
}
GlyphClassMapping clm;
if ((clm = getClasses()) != null) {
- if (clm.getClassIndex (gi, 0) >= 0) {
+ if (clm.getClassIndex(gi, 0) >= 0) {
return true;
}
}
* Instantiate a <code>GlyphDefinitionTable</code> object using the specified subtables.
* @param subtables a list of identified subtables
*/
- public GlyphDefinitionTable (List subtables) {
- super (null, new HashMap(0));
+ public GlyphDefinitionTable(List subtables) {
+ super(null, new HashMap(0));
if ((subtables == null) || (subtables.size() == 0)) {
- throw new AdvancedTypographicTableFormatException ("subtables must be non-empty");
+ throw new AdvancedTypographicTableFormatException("subtables must be non-empty");
} else {
for (Iterator it = subtables.iterator(); it.hasNext();) {
Object o = it.next();
if (o instanceof GlyphDefinitionSubtable) {
- addSubtable ((GlyphSubtable) o);
+ addSubtable((GlyphSubtable) o);
} else {
- throw new AdvancedTypographicTableFormatException ("subtable must be a glyph definition subtable");
+ throw new AdvancedTypographicTableFormatException("subtable must be a glyph definition subtable");
}
}
freezeSubtables();
* @param language a language identifier
* @return the reordered (output) glyph sequence
*/
- public GlyphSequence reorderCombiningMarks (GlyphSequence gs, int[][] gpa, String script, String language) {
- ScriptProcessor sp = ScriptProcessor.getInstance (script);
- return sp.reorderCombiningMarks (this, gs, gpa, script, language);
+ public GlyphSequence reorderCombiningMarks(GlyphSequence gs, int[][] gpa, String script, String language) {
+ ScriptProcessor sp = ScriptProcessor.getInstance(script);
+ return sp.reorderCombiningMarks(this, gs, gpa, script, language);
}
/** {@inheritDoc} */
- protected void addSubtable (GlyphSubtable subtable) {
+ protected void addSubtable(GlyphSubtable subtable) {
if (subtable instanceof GlyphClassSubtable) {
this.gct = (GlyphClassSubtable) subtable;
} else if (subtable instanceof AttachmentPointSubtable) {
} else if (subtable instanceof MarkAttachmentSubtable) {
this.mat = (MarkAttachmentSubtable) subtable;
} else {
- throw new UnsupportedOperationException ("unsupported glyph definition subtable type: " + subtable);
+ throw new UnsupportedOperationException("unsupported glyph definition subtable type: " + subtable);
}
}
* @param gc a pre-defined glyph class (GLYPH_CLASS_BASE|GLYPH_CLASS_LIGATURE|GLYPH_CLASS_MARK|GLYPH_CLASS_COMPONENT).
* @return true if glyph belongs to specified glyph class
*/
- public boolean isGlyphClass (int gid, int gc) {
+ public boolean isGlyphClass(int gid, int gc) {
if (gct != null) {
- return gct.isGlyphClass (gid, gc);
+ return gct.isGlyphClass(gid, gc);
} else {
return false;
}
* @param gid a glyph identifier (index)
* @return a pre-defined glyph class (GLYPH_CLASS_BASE|GLYPH_CLASS_LIGATURE|GLYPH_CLASS_MARK|GLYPH_CLASS_COMPONENT).
*/
- public int getGlyphClass (int gid) {
+ public int getGlyphClass(int gid) {
if (gct != null) {
- return gct.getGlyphClass (gid);
+ return gct.getGlyphClass(gid);
} else {
return -1;
}
* @param mac a (font specific) mark attachment class
* @return true if glyph belongs to specified mark attachment class
*/
- public boolean isMarkAttachClass (int gid, int mac) {
+ public boolean isMarkAttachClass(int gid, int mac) {
if (mat != null) {
- return mat.isMarkAttachClass (gid, mac);
+ return mat.isMarkAttachClass(gid, mac);
} else {
return false;
}
* @param gid a glyph identifier (index)
* @return a non-negative mark attachment class, or -1 if no class defined
*/
- public int getMarkAttachClass (int gid) {
+ public int getMarkAttachClass(int gid) {
if (mat != null) {
- return mat.getMarkAttachClass (gid);
+ return mat.getMarkAttachClass(gid);
} else {
return -1;
}
* @param name lookup type name
* @return lookup type
*/
- public static int getLookupTypeFromName (String name) {
+ public static int getLookupTypeFromName(String name) {
int t;
String s = name.toLowerCase();
- if ("glyphclass".equals (s)) {
+ if ("glyphclass".equals(s)) {
t = GDEF_LOOKUP_TYPE_GLYPH_CLASS;
- } else if ("attachmentpoint".equals (s)) {
+ } else if ("attachmentpoint".equals(s)) {
t = GDEF_LOOKUP_TYPE_ATTACHMENT_POINT;
- } else if ("ligaturecaret".equals (s)) {
+ } else if ("ligaturecaret".equals(s)) {
t = GDEF_LOOKUP_TYPE_LIGATURE_CARET;
- } else if ("markattachment".equals (s)) {
+ } else if ("markattachment".equals(s)) {
t = GDEF_LOOKUP_TYPE_MARK_ATTACHMENT;
} else {
t = -1;
* @param type lookup type
* @return lookup type name
*/
- public static String getLookupTypeName (int type) {
+ public static String getLookupTypeName(int type) {
String tn = null;
switch (type) {
case GDEF_LOOKUP_TYPE_GLYPH_CLASS:
* @param entries subtable entries
* @return a glyph subtable instance
*/
- public static GlyphSubtable createSubtable (int type, String id, int sequence, int flags, int format, GlyphMappingTable mapping, List entries) {
+ public static GlyphSubtable createSubtable(int type, String id, int sequence, int flags, int format, GlyphMappingTable mapping, List entries) {
GlyphSubtable st = null;
switch (type) {
case GDEF_LOOKUP_TYPE_GLYPH_CLASS:
- st = GlyphClassSubtable.create (id, sequence, flags, format, mapping, entries);
+ st = GlyphClassSubtable.create(id, sequence, flags, format, mapping, entries);
break;
case GDEF_LOOKUP_TYPE_ATTACHMENT_POINT:
- st = AttachmentPointSubtable.create (id, sequence, flags, format, mapping, entries);
+ st = AttachmentPointSubtable.create(id, sequence, flags, format, mapping, entries);
break;
case GDEF_LOOKUP_TYPE_LIGATURE_CARET:
- st = LigatureCaretSubtable.create (id, sequence, flags, format, mapping, entries);
+ st = LigatureCaretSubtable.create(id, sequence, flags, format, mapping, entries);
break;
case GDEF_LOOKUP_TYPE_MARK_ATTACHMENT:
- st = MarkAttachmentSubtable.create (id, sequence, flags, format, mapping, entries);
+ st = MarkAttachmentSubtable.create(id, sequence, flags, format, mapping, entries);
break;
default:
break;
}
private abstract static class GlyphClassSubtable extends GlyphDefinitionSubtable {
- GlyphClassSubtable (String id, int sequence, int flags, int format, GlyphMappingTable mapping, List entries) {
- super (id, sequence, flags, format, mapping);
+ GlyphClassSubtable(String id, int sequence, int flags, int format, GlyphMappingTable mapping, List entries) {
+ super(id, sequence, flags, format, mapping);
}
/** {@inheritDoc} */
public int getType() {
* @param gc a pre-defined glyph class (GLYPH_CLASS_BASE|GLYPH_CLASS_LIGATURE|GLYPH_CLASS_MARK|GLYPH_CLASS_COMPONENT).
* @return true if glyph belongs to specified glyph class
*/
- public abstract boolean isGlyphClass (int gid, int gc);
+ public abstract boolean isGlyphClass(int gid, int gc);
/**
* Determine glyph class.
* @param gid a glyph identifier (index)
* @return a pre-defined glyph class (GLYPH_CLASS_BASE|GLYPH_CLASS_LIGATURE|GLYPH_CLASS_MARK|GLYPH_CLASS_COMPONENT).
*/
- public abstract int getGlyphClass (int gid);
- static GlyphDefinitionSubtable create (String id, int sequence, int flags, int format, GlyphMappingTable mapping, List entries) {
+ public abstract int getGlyphClass(int gid);
+ static GlyphDefinitionSubtable create(String id, int sequence, int flags, int format, GlyphMappingTable mapping, List entries) {
if (format == 1) {
- return new GlyphClassSubtableFormat1 (id, sequence, flags, format, mapping, entries);
+ return new GlyphClassSubtableFormat1(id, sequence, flags, format, mapping, entries);
} else {
throw new UnsupportedOperationException();
}
}
private static class GlyphClassSubtableFormat1 extends GlyphClassSubtable {
- GlyphClassSubtableFormat1 (String id, int sequence, int flags, int format, GlyphMappingTable mapping, List entries) {
- super (id, sequence, flags, format, mapping, entries);
+ GlyphClassSubtableFormat1(String id, int sequence, int flags, int format, GlyphMappingTable mapping, List entries) {
+ super(id, sequence, flags, format, mapping, entries);
}
/** {@inheritDoc} */
public List getEntries() {
return null;
}
/** {@inheritDoc} */
- public boolean isCompatible (GlyphSubtable subtable) {
+ public boolean isCompatible(GlyphSubtable subtable) {
return subtable instanceof GlyphClassSubtable;
}
/** {@inheritDoc} */
- public boolean isGlyphClass (int gid, int gc) {
+ public boolean isGlyphClass(int gid, int gc) {
GlyphClassMapping cm = getClasses();
if (cm != null) {
- return cm.getClassIndex (gid, 0) == gc;
+ return cm.getClassIndex(gid, 0) == gc;
} else {
return false;
}
}
/** {@inheritDoc} */
- public int getGlyphClass (int gid) {
+ public int getGlyphClass(int gid) {
GlyphClassMapping cm = getClasses();
if (cm != null) {
- return cm.getClassIndex (gid, 0);
+ return cm.getClassIndex(gid, 0);
} else {
return -1;
}
}
private abstract static class AttachmentPointSubtable extends GlyphDefinitionSubtable {
- AttachmentPointSubtable (String id, int sequence, int flags, int format, GlyphMappingTable mapping, List entries) {
- super (id, sequence, flags, format, mapping);
+ AttachmentPointSubtable(String id, int sequence, int flags, int format, GlyphMappingTable mapping, List entries) {
+ super(id, sequence, flags, format, mapping);
}
/** {@inheritDoc} */
public int getType() {
return GDEF_LOOKUP_TYPE_ATTACHMENT_POINT;
}
- static GlyphDefinitionSubtable create (String id, int sequence, int flags, int format, GlyphMappingTable mapping, List entries) {
+ static GlyphDefinitionSubtable create(String id, int sequence, int flags, int format, GlyphMappingTable mapping, List entries) {
if (format == 1) {
- return new AttachmentPointSubtableFormat1 (id, sequence, flags, format, mapping, entries);
+ return new AttachmentPointSubtableFormat1(id, sequence, flags, format, mapping, entries);
} else {
throw new UnsupportedOperationException();
}
}
private static class AttachmentPointSubtableFormat1 extends AttachmentPointSubtable {
- AttachmentPointSubtableFormat1 (String id, int sequence, int flags, int format, GlyphMappingTable mapping, List entries) {
- super (id, sequence, flags, format, mapping, entries);
+ AttachmentPointSubtableFormat1(String id, int sequence, int flags, int format, GlyphMappingTable mapping, List entries) {
+ super(id, sequence, flags, format, mapping, entries);
}
/** {@inheritDoc} */
public List getEntries() {
return null;
}
/** {@inheritDoc} */
- public boolean isCompatible (GlyphSubtable subtable) {
+ public boolean isCompatible(GlyphSubtable subtable) {
return subtable instanceof AttachmentPointSubtable;
}
}
private abstract static class LigatureCaretSubtable extends GlyphDefinitionSubtable {
- LigatureCaretSubtable (String id, int sequence, int flags, int format, GlyphMappingTable mapping, List entries) {
- super (id, sequence, flags, format, mapping);
+ LigatureCaretSubtable(String id, int sequence, int flags, int format, GlyphMappingTable mapping, List entries) {
+ super(id, sequence, flags, format, mapping);
}
/** {@inheritDoc} */
public int getType() {
return GDEF_LOOKUP_TYPE_LIGATURE_CARET;
}
- static GlyphDefinitionSubtable create (String id, int sequence, int flags, int format, GlyphMappingTable mapping, List entries) {
+ static GlyphDefinitionSubtable create(String id, int sequence, int flags, int format, GlyphMappingTable mapping, List entries) {
if (format == 1) {
- return new LigatureCaretSubtableFormat1 (id, sequence, flags, format, mapping, entries);
+ return new LigatureCaretSubtableFormat1(id, sequence, flags, format, mapping, entries);
} else {
throw new UnsupportedOperationException();
}
}
private static class LigatureCaretSubtableFormat1 extends LigatureCaretSubtable {
- LigatureCaretSubtableFormat1 (String id, int sequence, int flags, int format, GlyphMappingTable mapping, List entries) {
- super (id, sequence, flags, format, mapping, entries);
+ LigatureCaretSubtableFormat1(String id, int sequence, int flags, int format, GlyphMappingTable mapping, List entries) {
+ super(id, sequence, flags, format, mapping, entries);
}
/** {@inheritDoc} */
public List getEntries() {
return null;
}
/** {@inheritDoc} */
- public boolean isCompatible (GlyphSubtable subtable) {
+ public boolean isCompatible(GlyphSubtable subtable) {
return subtable instanceof LigatureCaretSubtable;
}
}
private abstract static class MarkAttachmentSubtable extends GlyphDefinitionSubtable {
- MarkAttachmentSubtable (String id, int sequence, int flags, int format, GlyphMappingTable mapping, List entries) {
- super (id, sequence, flags, format, mapping);
+ MarkAttachmentSubtable(String id, int sequence, int flags, int format, GlyphMappingTable mapping, List entries) {
+ super(id, sequence, flags, format, mapping);
}
/** {@inheritDoc} */
public int getType() {
* @param mac a (font specific) mark attachment class
* @return true if glyph belongs to specified mark attachment class
*/
- public abstract boolean isMarkAttachClass (int gid, int mac);
+ public abstract boolean isMarkAttachClass(int gid, int mac);
/**
* Determine mark attachment class.
* @param gid a glyph identifier (index)
* @return a non-negative mark attachment class, or -1 if no class defined
*/
- public abstract int getMarkAttachClass (int gid);
- static GlyphDefinitionSubtable create (String id, int sequence, int flags, int format, GlyphMappingTable mapping, List entries) {
+ public abstract int getMarkAttachClass(int gid);
+ static GlyphDefinitionSubtable create(String id, int sequence, int flags, int format, GlyphMappingTable mapping, List entries) {
if (format == 1) {
- return new MarkAttachmentSubtableFormat1 (id, sequence, flags, format, mapping, entries);
+ return new MarkAttachmentSubtableFormat1(id, sequence, flags, format, mapping, entries);
} else {
throw new UnsupportedOperationException();
}
}
private static class MarkAttachmentSubtableFormat1 extends MarkAttachmentSubtable {
- MarkAttachmentSubtableFormat1 (String id, int sequence, int flags, int format, GlyphMappingTable mapping, List entries) {
- super (id, sequence, flags, format, mapping, entries);
+ MarkAttachmentSubtableFormat1(String id, int sequence, int flags, int format, GlyphMappingTable mapping, List entries) {
+ super(id, sequence, flags, format, mapping, entries);
}
/** {@inheritDoc} */
public List getEntries() {
return null;
}
/** {@inheritDoc} */
- public boolean isCompatible (GlyphSubtable subtable) {
+ public boolean isCompatible(GlyphSubtable subtable) {
return subtable instanceof MarkAttachmentSubtable;
}
/** {@inheritDoc} */
- public boolean isMarkAttachClass (int gid, int mac) {
+ public boolean isMarkAttachClass(int gid, int mac) {
GlyphClassMapping cm = getClasses();
if (cm != null) {
- return cm.getClassIndex (gid, 0) == mac;
+ return cm.getClassIndex(gid, 0) == mac;
} else {
return false;
}
}
/** {@inheritDoc} */
- public int getMarkAttachClass (int gid) {
+ public int getMarkAttachClass(int gid) {
GlyphClassMapping cm = getClasses();
if (cm != null) {
- return cm.getClassIndex (gid, 0);
+ return cm.getClassIndex(gid, 0);
} else {
return -1;
}
* @param gid glyph identifier (code)
* @return non-negative glyph mapping index or -1 if glyph identifiers is not mapped by table
*/
- public int getMappedIndex (int gid) {
+ public int getMappedIndex(int gid) {
return -1;
}
* Construct empty mapping table with entries (ignored).
* @param entries list of entries (ignored)
*/
- public EmptyMappingTable (List entries) {
+ public EmptyMappingTable(List entries) {
}
/** {@inheritDoc} */
public int getType() {
return 0;
}
/** {@inheritDoc} */
- public int getMappedIndex (int gid) {
+ public int getMappedIndex(int gid) {
return -1;
}
}
* Construct range mapping table.
* @param entries of mapping ranges
*/
- public RangeMappingTable (List entries) {
- populate (entries);
+ public RangeMappingTable(List entries) {
+ populate(entries);
}
/** {@inheritDoc} */
public int getType() {
List entries = new java.util.ArrayList();
if (sa != null) {
for (int i = 0, n = sa.length; i < n; i++) {
- entries.add (new MappingRange (sa [ i ], ea [ i ], ma [ i ]));
+ entries.add(new MappingRange(sa [ i ], ea [ i ], ma [ i ]));
}
}
return entries;
return miMax + 1;
}
/** {@inheritDoc} */
- public int getMappedIndex (int gid) {
+ public int getMappedIndex(int gid) {
int i;
int mi;
- if ((i = Arrays.binarySearch (sa, gid)) >= 0) {
- mi = getMappedIndex (gid, sa [ i ], ma [ i ]); // matches start of (some) range
+ if ((i = Arrays.binarySearch(sa, gid)) >= 0) {
+ mi = getMappedIndex(gid, sa [ i ], ma [ i ]); // matches start of (some) range
} else if ((i = - (i + 1)) == 0) {
mi = -1; // precedes first range
} else if (gid > ea [ --i ]) {
mi = -1; // follows preceding (or last) range
} else {
- mi = getMappedIndex (gid, sa [ i ], ma [ i ]); // intersects (some) range
+ mi = getMappedIndex(gid, sa [ i ], ma [ i ]); // intersects (some) range
}
return mi;
}
* @param m mapping value
* @return non-negative glyph mapping index or -1 if glyph identifiers is not mapped by table
*/
- public abstract int getMappedIndex (int gid, int s, int m);
- private void populate (List entries) {
+ public abstract int getMappedIndex(int gid, int s, int m);
+ private void populate(List entries) {
int i = 0;
int n = entries.size();
int gidMax = -1;
int ge = r.getEnd();
int mi = r.getIndex();
if ((gs < 0) || (gs > 65535)) {
- throw new AdvancedTypographicTableFormatException ("illegal glyph range: [" + gs + "," + ge + "]: bad start index");
+ throw new AdvancedTypographicTableFormatException("illegal glyph range: [" + gs + "," + ge + "]: bad start index");
} else if ((ge < 0) || (ge > 65535)) {
- throw new AdvancedTypographicTableFormatException ("illegal glyph range: [" + gs + "," + ge + "]: bad end index");
+ throw new AdvancedTypographicTableFormatException("illegal glyph range: [" + gs + "," + ge + "]: bad end index");
} else if (gs > ge) {
- throw new AdvancedTypographicTableFormatException ("illegal glyph range: [" + gs + "," + ge + "]: start index exceeds end index");
+ throw new AdvancedTypographicTableFormatException("illegal glyph range: [" + gs + "," + ge + "]: start index exceeds end index");
} else if (gs < gidMax) {
- throw new AdvancedTypographicTableFormatException ("out of order glyph range: [" + gs + "," + ge + "]");
+ throw new AdvancedTypographicTableFormatException("out of order glyph range: [" + gs + "," + ge + "]");
} else if (mi < 0) {
- throw new AdvancedTypographicTableFormatException ("illegal mapping index: " + mi);
+ throw new AdvancedTypographicTableFormatException("illegal mapping index: " + mi);
} else {
int miLast;
sa [ i ] = gs;
i++;
}
} else {
- throw new AdvancedTypographicTableFormatException ("illegal mapping entry, must be Integer: " + o);
+ throw new AdvancedTypographicTableFormatException("illegal mapping entry, must be Integer: " + o);
}
}
assert i == n;
if (i > 0) {
sb.append(',');
}
- sb.append ('[');
- sb.append (Integer.toString (sa [ i ]));
- sb.append (Integer.toString (ea [ i ]));
- sb.append ("]:");
- sb.append (Integer.toString (ma [ i ]));
+ sb.append('[');
+ sb.append(Integer.toString(sa [ i ]));
+ sb.append(Integer.toString(ea [ i ]));
+ sb.append("]:");
+ sb.append(Integer.toString(ma [ i ]));
}
sb.append('}');
return sb.toString();
* @param gidEnd end of range
* @param index mapping index
*/
- public MappingRange (int gidStart, int gidEnd, int index) {
+ public MappingRange(int gidStart, int gidEnd, int index) {
if ((gidStart < 0) || (gidEnd < 0) || (index < 0)) {
throw new AdvancedTypographicTableFormatException();
} else if (gidStart > gidEnd) {
* @param interval an array of length two or greater or null
* @return interval as a pair of integers, filled into specified array
*/
- public int[] getInterval (int[] interval) {
+ public int[] getInterval(int[] interval) {
if ((interval == null) || (interval.length != 2)) {
throw new IllegalArgumentException();
} else {
* adjustment occurred; it only means that no further glyph subtables for the current lookup table
* should be applied.
*/
- boolean position (GlyphPositioningState ps);
+ boolean position(GlyphPositioningState ps);
}
* @param adjustments positioning adjustments to which positioning is applied
* @param sct script context tester (or null)
*/
- public GlyphPositioningState (GlyphSequence gs, String script, String language, String feature, int fontSize, int[] widths, int[][] adjustments, ScriptContextTester sct) {
- super (gs, script, language, feature, sct);
+ public GlyphPositioningState(GlyphSequence gs, String script, String language, String feature, int fontSize, int[] widths, int[][] adjustments, ScriptContextTester sct) {
+ super(gs, script, language, feature, sct);
this.fontSize = fontSize;
this.widths = widths;
this.adjustments = adjustments;
* except as follows: input glyph sequence is copied deep except for its characters array.
* @param ps existing positioning state to copy from
*/
- public GlyphPositioningState (GlyphPositioningState ps) {
- super (ps);
+ public GlyphPositioningState(GlyphPositioningState ps) {
+ super(ps);
this.fontSize = ps.fontSize;
this.widths = ps.widths;
this.adjustments = ps.adjustments;
* @param adjustments positioning adjustments to which positioning is applied
* @param sct script context tester (or null)
*/
- public GlyphPositioningState reset (GlyphSequence gs, String script, String language, String feature, int fontSize, int[] widths, int[][] adjustments, ScriptContextTester sct) {
- super.reset (gs, script, language, feature, sct);
+ public GlyphPositioningState reset(GlyphSequence gs, String script, String language, String feature, int fontSize, int[] widths, int[][] adjustments, ScriptContextTester sct) {
+ super.reset(gs, script, language, feature, sct);
this.fontSize = fontSize;
this.widths = widths;
this.adjustments = adjustments;
* @param gi glyph index
* @return design advancement, or zero if glyph index is not present
*/
- public int getWidth (int gi) {
+ public int getWidth(int gi) {
if ((widths != null) && (gi < widths.length)) {
return widths [ gi ];
} else {
* @param v value containing adjustments
* @return true if a non-zero adjustment was made
*/
- public boolean adjust (GlyphPositioningTable.Value v) {
- return adjust (v, 0);
+ public boolean adjust(GlyphPositioningTable.Value v) {
+ return adjust(v, 0);
}
/**
* @param offset from current position index
* @return true if a non-zero adjustment was made
*/
- public boolean adjust (GlyphPositioningTable.Value v, int offset) {
+ public boolean adjust(GlyphPositioningTable.Value v, int offset) {
assert v != null;
if ((index + offset) < indexLast) {
- return v.adjust (adjustments [ index + offset ], fontSize);
+ return v.adjust(adjustments [ index + offset ], fontSize);
} else {
throw new IndexOutOfBoundsException();
}
* @return array of adjustments (int[4]) at current position
*/
public int[] getAdjustment() {
- return getAdjustment (0);
+ return getAdjustment(0);
}
/**
* @return array of adjustments (int[4]) at specified offset
* @throws IndexOutOfBoundsException if offset is invalid
*/
- public int[] getAdjustment (int offset) throws IndexOutOfBoundsException {
+ public int[] getAdjustment(int offset) throws IndexOutOfBoundsException {
if ((index + offset) < indexLast) {
return adjustments [ index + offset ];
} else {
* @return true if subtable applied, or false if it did not (e.g., its
* input coverage table did not match current input context)
*/
- public boolean apply (GlyphPositioningSubtable st) {
+ public boolean apply(GlyphPositioningSubtable st) {
assert st != null;
- updateSubtableState (st);
- boolean applied = st.position (this);
+ updateSubtableState(st);
+ boolean applied = st.position(this);
return applied;
}
* the lookups are to apply, and to be consumed once the application has finished
* @return true if lookups are non-null and non-empty; otherwise, false
*/
- public boolean apply (GlyphTable.RuleLookup[] lookups, int nig) {
+ public boolean apply(GlyphTable.RuleLookup[] lookups, int nig) {
if ((lookups != null) && (lookups.length > 0)) {
// apply each rule lookup to extracted input glyph array
for (int i = 0, n = lookups.length; i < n; i++) {
GlyphTable.LookupTable lt = l.getLookup();
if (lt != null) {
// perform positioning on a copy of previous state
- GlyphPositioningState ps = new GlyphPositioningState (this);
+ GlyphPositioningState ps = new GlyphPositioningState(this);
// apply lookup table positioning
- if (lt.position (ps, l.getSequenceIndex())) {
- setAdjusted (true);
+ if (lt.position(ps, l.getSequenceIndex())) {
+ setAdjusted(true);
}
}
}
}
- consume (nig);
+ consume(nig);
return true;
} else {
return false;
* @param adjusted true if to set adjusted state, otherwise false to
* clear adjusted state
*/
- public void setAdjusted (boolean adjusted) {
+ public void setAdjusted(boolean adjusted) {
this.adjusted = adjusted;
}
* @param format subtable format
* @param coverage subtable coverage table
*/
- protected GlyphPositioningSubtable (String id, int sequence, int flags, int format, GlyphCoverageTable coverage) {
- super (id, sequence, flags, format, coverage);
+ protected GlyphPositioningSubtable(String id, int sequence, int flags, int format, GlyphCoverageTable coverage) {
+ super(id, sequence, flags, format, coverage);
}
/** {@inheritDoc} */
/** {@inheritDoc} */
public String getTypeName() {
- return GlyphPositioningTable.getLookupTypeName (getType());
+ return GlyphPositioningTable.getLookupTypeName(getType());
}
/** {@inheritDoc} */
- public boolean isCompatible (GlyphSubtable subtable) {
+ public boolean isCompatible(GlyphSubtable subtable) {
return subtable instanceof GlyphPositioningSubtable;
}
}
/** {@inheritDoc} */
- public boolean position (GlyphPositioningState ps) {
+ public boolean position(GlyphPositioningState ps) {
return false;
}
* @param sequenceIndex if non negative, then apply subtables only at specified sequence index
* @return true if a non-zero adjustment occurred
*/
- public static final boolean position (GlyphPositioningState ps, GlyphPositioningSubtable[] sta, int sequenceIndex) {
+ public static final boolean position(GlyphPositioningState ps, GlyphPositioningSubtable[] sta, int sequenceIndex) {
int sequenceStart = ps.getPosition();
boolean appliedOneShot = false;
while (ps.hasNext()) {
if (! appliedOneShot && ps.maybeApplicable()) {
for (int i = 0, n = sta.length; ! applied && (i < n); i++) {
if (sequenceIndex < 0) {
- applied = ps.apply (sta [ i ]);
+ applied = ps.apply(sta [ i ]);
} else if (ps.getPosition() == (sequenceStart + sequenceIndex)) {
- applied = ps.apply (sta [ i ]);
+ applied = ps.apply(sta [ i ]);
if (applied) {
appliedOneShot = true;
}
* @param sct script context tester
* @return true if a non-zero adjustment occurred
*/
- public static final boolean position (GlyphSequence gs, String script, String language, String feature, int fontSize, GlyphPositioningSubtable[] sta, int[] widths, int[][] adjustments, ScriptContextTester sct) {
+ public static final boolean position(GlyphSequence gs, String script, String language, String feature, int fontSize, GlyphPositioningSubtable[] sta, int[] widths, int[][] adjustments, ScriptContextTester sct) {
synchronized (state) {
- return position (state.reset (gs, script, language, feature, fontSize, widths, adjustments, sct), sta, -1);
+ return position(state.reset(gs, script, language, feature, fontSize, widths, adjustments, sct), sta, -1);
}
}
* @param lookups a map of lookup specifications to subtable identifier strings
* @param subtables a list of identified subtables
*/
- public GlyphPositioningTable (GlyphDefinitionTable gdef, Map lookups, List subtables) {
- super (gdef, lookups);
+ public GlyphPositioningTable(GlyphDefinitionTable gdef, Map lookups, List subtables) {
+ super(gdef, lookups);
if ((subtables == null) || (subtables.size() == 0)) {
- throw new AdvancedTypographicTableFormatException ("subtables must be non-empty");
+ throw new AdvancedTypographicTableFormatException("subtables must be non-empty");
} else {
for (Iterator it = subtables.iterator(); it.hasNext();) {
Object o = it.next();
if (o instanceof GlyphPositioningSubtable) {
- addSubtable ((GlyphSubtable) o);
+ addSubtable((GlyphSubtable) o);
} else {
- throw new AdvancedTypographicTableFormatException ("subtable must be a glyph positioning subtable");
+ throw new AdvancedTypographicTableFormatException("subtable must be a glyph positioning subtable");
}
}
freezeSubtables();
* @param name lookup type name
* @return lookup type
*/
- public static int getLookupTypeFromName (String name) {
+ public static int getLookupTypeFromName(String name) {
int t;
String s = name.toLowerCase();
- if ("single".equals (s)) {
+ if ("single".equals(s)) {
t = GPOS_LOOKUP_TYPE_SINGLE;
- } else if ("pair".equals (s)) {
+ } else if ("pair".equals(s)) {
t = GPOS_LOOKUP_TYPE_PAIR;
- } else if ("cursive".equals (s)) {
+ } else if ("cursive".equals(s)) {
t = GPOS_LOOKUP_TYPE_CURSIVE;
- } else if ("marktobase".equals (s)) {
+ } else if ("marktobase".equals(s)) {
t = GPOS_LOOKUP_TYPE_MARK_TO_BASE;
- } else if ("marktoligature".equals (s)) {
+ } else if ("marktoligature".equals(s)) {
t = GPOS_LOOKUP_TYPE_MARK_TO_LIGATURE;
- } else if ("marktomark".equals (s)) {
+ } else if ("marktomark".equals(s)) {
t = GPOS_LOOKUP_TYPE_MARK_TO_MARK;
- } else if ("contextual".equals (s)) {
+ } else if ("contextual".equals(s)) {
t = GPOS_LOOKUP_TYPE_CONTEXTUAL;
- } else if ("chainedcontextual".equals (s)) {
+ } else if ("chainedcontextual".equals(s)) {
t = GPOS_LOOKUP_TYPE_CHAINED_CONTEXTUAL;
- } else if ("extensionpositioning".equals (s)) {
+ } else if ("extensionpositioning".equals(s)) {
t = GPOS_LOOKUP_TYPE_EXTENSION_POSITIONING;
} else {
t = -1;
* @param type lookup type
* @return lookup type name
*/
- public static String getLookupTypeName (int type) {
+ public static String getLookupTypeName(int type) {
String tn;
switch (type) {
case GPOS_LOOKUP_TYPE_SINGLE:
* @param entries subtable entries
* @return a glyph subtable instance
*/
- public static GlyphSubtable createSubtable (int type, String id, int sequence, int flags, int format, GlyphCoverageTable coverage, List entries) {
+ public static GlyphSubtable createSubtable(int type, String id, int sequence, int flags, int format, GlyphCoverageTable coverage, List entries) {
GlyphSubtable st = null;
switch (type) {
case GPOS_LOOKUP_TYPE_SINGLE:
- st = SingleSubtable.create (id, sequence, flags, format, coverage, entries);
+ st = SingleSubtable.create(id, sequence, flags, format, coverage, entries);
break;
case GPOS_LOOKUP_TYPE_PAIR:
- st = PairSubtable.create (id, sequence, flags, format, coverage, entries);
+ st = PairSubtable.create(id, sequence, flags, format, coverage, entries);
break;
case GPOS_LOOKUP_TYPE_CURSIVE:
- st = CursiveSubtable.create (id, sequence, flags, format, coverage, entries);
+ st = CursiveSubtable.create(id, sequence, flags, format, coverage, entries);
break;
case GPOS_LOOKUP_TYPE_MARK_TO_BASE:
- st = MarkToBaseSubtable.create (id, sequence, flags, format, coverage, entries);
+ st = MarkToBaseSubtable.create(id, sequence, flags, format, coverage, entries);
break;
case GPOS_LOOKUP_TYPE_MARK_TO_LIGATURE:
- st = MarkToLigatureSubtable.create (id, sequence, flags, format, coverage, entries);
+ st = MarkToLigatureSubtable.create(id, sequence, flags, format, coverage, entries);
break;
case GPOS_LOOKUP_TYPE_MARK_TO_MARK:
- st = MarkToMarkSubtable.create (id, sequence, flags, format, coverage, entries);
+ st = MarkToMarkSubtable.create(id, sequence, flags, format, coverage, entries);
break;
case GPOS_LOOKUP_TYPE_CONTEXTUAL:
- st = ContextualSubtable.create (id, sequence, flags, format, coverage, entries);
+ st = ContextualSubtable.create(id, sequence, flags, format, coverage, entries);
break;
case GPOS_LOOKUP_TYPE_CHAINED_CONTEXTUAL:
- st = ChainedContextualSubtable.create (id, sequence, flags, format, coverage, entries);
+ st = ChainedContextualSubtable.create(id, sequence, flags, format, coverage, entries);
break;
default:
break;
* @param entries subtable entries
* @return a glyph subtable instance
*/
- public static GlyphSubtable createSubtable (int type, String id, int sequence, int flags, int format, List coverage, List entries) {
- return createSubtable (type, id, sequence, flags, format, GlyphCoverageTable.createCoverageTable (coverage), entries);
+ public static GlyphSubtable createSubtable(int type, String id, int sequence, int flags, int format, List coverage, List entries) {
+ return createSubtable(type, id, sequence, flags, format, GlyphCoverageTable.createCoverageTable(coverage), entries);
}
/**
* with one 4-tuple for each element of glyph sequence
* @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) {
- Map/*<LookupSpec,List<LookupTable>>*/ lookups = matchLookups (script, language, "*");
+ public boolean position(GlyphSequence gs, String script, String language, int fontSize, int[] widths, int[][] adjustments) {
+ Map/*<LookupSpec,List<LookupTable>>*/ lookups = matchLookups(script, language, "*");
if ((lookups != null) && (lookups.size() > 0)) {
- ScriptProcessor sp = ScriptProcessor.getInstance (script);
- return sp.position (this, gs, script, language, fontSize, lookups, widths, adjustments);
+ ScriptProcessor sp = ScriptProcessor.getInstance(script);
+ return sp.position(this, gs, script, language, fontSize, lookups, widths, adjustments);
} else {
return false;
}
}
private abstract static class SingleSubtable extends GlyphPositioningSubtable {
- SingleSubtable (String id, int sequence, int flags, int format, GlyphCoverageTable coverage, List entries) {
- super (id, sequence, flags, format, coverage);
+ SingleSubtable(String id, int sequence, int flags, int format, GlyphCoverageTable coverage, List entries) {
+ super(id, sequence, flags, format, coverage);
}
/** {@inheritDoc} */
public int getType() {
return GPOS_LOOKUP_TYPE_SINGLE;
}
/** {@inheritDoc} */
- public boolean isCompatible (GlyphSubtable subtable) {
+ public boolean isCompatible(GlyphSubtable subtable) {
return subtable instanceof SingleSubtable;
}
/** {@inheritDoc} */
- public boolean position (GlyphPositioningState ps) {
+ public boolean position(GlyphPositioningState ps) {
int gi = ps.getGlyph();
int ci;
- if ((ci = getCoverageIndex (gi)) < 0) {
+ if ((ci = getCoverageIndex(gi)) < 0) {
return false;
} else {
- Value v = getValue (ci, gi);
+ Value v = getValue(ci, gi);
if (v != null) {
if (ps.adjust(v)) {
- ps.setAdjusted (true);
+ ps.setAdjusted(true);
}
ps.consume(1);
}
* @param gi input glyph index
* @return positioning value or null if none applies
*/
- public abstract Value getValue (int ci, int gi);
- static GlyphPositioningSubtable create (String id, int sequence, int flags, int format, GlyphCoverageTable coverage, List entries) {
+ public abstract Value getValue(int ci, int gi);
+ static GlyphPositioningSubtable create(String id, int sequence, int flags, int format, GlyphCoverageTable coverage, List entries) {
if (format == 1) {
- return new SingleSubtableFormat1 (id, sequence, flags, format, coverage, entries);
+ return new SingleSubtableFormat1(id, sequence, flags, format, coverage, entries);
} else if (format == 2) {
- return new SingleSubtableFormat2 (id, sequence, flags, format, coverage, entries);
+ return new SingleSubtableFormat2(id, sequence, flags, format, coverage, entries);
} else {
throw new UnsupportedOperationException();
}
private static class SingleSubtableFormat1 extends SingleSubtable {
private Value value;
private int ciMax;
- SingleSubtableFormat1 (String id, int sequence, int flags, int format, GlyphCoverageTable coverage, List entries) {
- super (id, sequence, flags, format, coverage, entries);
- populate (entries);
+ SingleSubtableFormat1(String id, int sequence, int flags, int format, GlyphCoverageTable coverage, List entries) {
+ super(id, sequence, flags, format, coverage, entries);
+ populate(entries);
}
/** {@inheritDoc} */
public List getEntries() {
if (value != null) {
- List entries = new ArrayList (1);
- entries.add (value);
+ List entries = new ArrayList(1);
+ entries.add(value);
return entries;
} else {
return null;
}
}
/** {@inheritDoc} */
- public Value getValue (int ci, int gi) {
+ public Value getValue(int ci, int gi) {
if ((value != null) && (ci <= ciMax)) {
return value;
} else {
return null;
}
}
- private void populate (List entries) {
+ private void populate(List entries) {
if ((entries == null) || (entries.size() != 1)) {
- throw new AdvancedTypographicTableFormatException ("illegal entries, must be non-null and contain exactly one entry");
+ throw new AdvancedTypographicTableFormatException("illegal entries, must be non-null and contain exactly one entry");
} else {
Value v;
Object o = entries.get(0);
if (o instanceof Value) {
v = (Value) o;
} else {
- throw new AdvancedTypographicTableFormatException ("illegal entries entry, must be Value, but is: " + ((o != null) ? o.getClass() : null));
+ throw new AdvancedTypographicTableFormatException("illegal entries entry, must be Value, but is: " + ((o != null) ? o.getClass() : null));
}
assert this.value == null;
this.value = v;
private static class SingleSubtableFormat2 extends SingleSubtable {
private Value[] values;
- SingleSubtableFormat2 (String id, int sequence, int flags, int format, GlyphCoverageTable coverage, List entries) {
- super (id, sequence, flags, format, coverage, entries);
- populate (entries);
+ SingleSubtableFormat2(String id, int sequence, int flags, int format, GlyphCoverageTable coverage, List entries) {
+ super(id, sequence, flags, format, coverage, entries);
+ populate(entries);
}
/** {@inheritDoc} */
public List getEntries() {
if (values != null) {
- List entries = new ArrayList (values.length);
+ List entries = new ArrayList(values.length);
for (int i = 0, n = values.length; i < n; i++) {
- entries.add (values[i]);
+ entries.add(values[i]);
}
return entries;
} else {
}
}
/** {@inheritDoc} */
- public Value getValue (int ci, int gi) {
+ public Value getValue(int ci, int gi) {
if ((values != null) && (ci < values.length)) {
return values [ ci ];
} else {
return null;
}
}
- private void populate (List entries) {
+ private void populate(List entries) {
if (entries == null) {
- throw new AdvancedTypographicTableFormatException ("illegal entries, must be non-null");
+ throw new AdvancedTypographicTableFormatException("illegal entries, must be non-null");
} else if (entries.size() != 1) {
- throw new AdvancedTypographicTableFormatException ("illegal entries, " + entries.size() + " entries present, but requires 1 entry");
+ throw new AdvancedTypographicTableFormatException("illegal entries, " + entries.size() + " entries present, but requires 1 entry");
} else {
Object o;
if (((o = entries.get(0)) == null) || ! (o instanceof Value[])) {
- throw new AdvancedTypographicTableFormatException ("illegal entries, single entry must be a Value[], but is: " + ((o != null) ? o.getClass() : null));
+ throw new AdvancedTypographicTableFormatException("illegal entries, single entry must be a Value[], but is: " + ((o != null) ? o.getClass() : null));
} else {
Value[] va = (Value[]) o;
if (va.length != getCoverageSize()) {
- throw new AdvancedTypographicTableFormatException ("illegal values array, " + entries.size() + " values present, but requires " + getCoverageSize() + " values");
+ throw new AdvancedTypographicTableFormatException("illegal values array, " + entries.size() + " values present, but requires " + getCoverageSize() + " values");
} else {
assert this.values == null;
this.values = va;
}
private abstract static class PairSubtable extends GlyphPositioningSubtable {
- PairSubtable (String id, int sequence, int flags, int format, GlyphCoverageTable coverage, List entries) {
- super (id, sequence, flags, format, coverage);
+ PairSubtable(String id, int sequence, int flags, int format, GlyphCoverageTable coverage, List entries) {
+ super(id, sequence, flags, format, coverage);
}
/** {@inheritDoc} */
public int getType() {
return GPOS_LOOKUP_TYPE_PAIR;
}
/** {@inheritDoc} */
- public boolean isCompatible (GlyphSubtable subtable) {
+ public boolean isCompatible(GlyphSubtable subtable) {
return subtable instanceof PairSubtable;
}
/** {@inheritDoc} */
- public boolean position (GlyphPositioningState ps) {
+ public boolean position(GlyphPositioningState ps) {
boolean applied = false;
int gi = ps.getGlyph(0);
int ci;
- if ((ci = getCoverageIndex (gi)) >= 0) {
- int[] counts = ps.getGlyphsAvailable (0);
+ if ((ci = getCoverageIndex(gi)) >= 0) {
+ int[] counts = ps.getGlyphsAvailable(0);
int nga = counts[0];
if (nga > 1) {
- int[] iga = ps.getGlyphs (0, 2, null, counts);
+ int[] iga = ps.getGlyphs(0, 2, null, counts);
if ((iga != null) && (iga.length == 2)) {
- PairValues pv = getPairValues (ci, iga[0], iga[1]);
+ PairValues pv = getPairValues(ci, iga[0], iga[1]);
if (pv != null) {
int offset = 0;
int offsetLast = counts[0] + counts[1];
// skip any ignored glyphs prior to first non-ignored glyph
for ( ; offset < offsetLast; ++offset) {
- if (! ps.isIgnoredGlyph (offset)) {
+ if (! ps.isIgnoredGlyph(offset)) {
break;
} else {
ps.consume(1);
Value v1 = pv.getValue1();
if (v1 != null) {
if (ps.adjust(v1, offset)) {
- ps.setAdjusted (true);
+ ps.setAdjusted(true);
}
ps.consume(1); // consume first non-ignored glyph
++offset;
}
// skip any ignored glyphs prior to second non-ignored glyph
for ( ; offset < offsetLast; ++offset) {
- if (! ps.isIgnoredGlyph (offset)) {
+ if (! ps.isIgnoredGlyph(offset)) {
break;
} else {
ps.consume(1);
Value v2 = pv.getValue2();
if (v2 != null) {
if (ps.adjust(v2, offset)) {
- ps.setAdjusted (true);
+ ps.setAdjusted(true);
}
ps.consume(1); // consume second non-ignored glyph
++offset;
* @param gi2 second input glyph index
* @return pair values or null if none applies
*/
- public abstract PairValues getPairValues (int ci, int gi1, int gi2);
- static GlyphPositioningSubtable create (String id, int sequence, int flags, int format, GlyphCoverageTable coverage, List entries) {
+ public abstract PairValues getPairValues(int ci, int gi1, int gi2);
+ static GlyphPositioningSubtable create(String id, int sequence, int flags, int format, GlyphCoverageTable coverage, List entries) {
if (format == 1) {
- return new PairSubtableFormat1 (id, sequence, flags, format, coverage, entries);
+ return new PairSubtableFormat1(id, sequence, flags, format, coverage, entries);
} else if (format == 2) {
- return new PairSubtableFormat2 (id, sequence, flags, format, coverage, entries);
+ return new PairSubtableFormat2(id, sequence, flags, format, coverage, entries);
} else {
throw new UnsupportedOperationException();
}
private static class PairSubtableFormat1 extends PairSubtable {
private PairValues[][] pvm; // pair values matrix
- PairSubtableFormat1 (String id, int sequence, int flags, int format, GlyphCoverageTable coverage, List entries) {
- super (id, sequence, flags, format, coverage, entries);
- populate (entries);
+ PairSubtableFormat1(String id, int sequence, int flags, int format, GlyphCoverageTable coverage, List entries) {
+ super(id, sequence, flags, format, coverage, entries);
+ populate(entries);
}
/** {@inheritDoc} */
public List getEntries() {
if (pvm != null) {
- List entries = new ArrayList (1);
- entries.add (pvm);
+ List entries = new ArrayList(1);
+ entries.add(pvm);
return entries;
} else {
return null;
}
}
/** {@inheritDoc} */
- public PairValues getPairValues (int ci, int gi1, int gi2) {
+ public PairValues getPairValues(int ci, int gi1, int gi2) {
if ((pvm != null) && (ci < pvm.length)) {
PairValues[] pvt = pvm [ ci ];
for (int i = 0, n = pvt.length; i < n; i++) {
}
return null;
}
- private void populate (List entries) {
+ private void populate(List entries) {
if (entries == null) {
- throw new AdvancedTypographicTableFormatException ("illegal entries, must be non-null");
+ throw new AdvancedTypographicTableFormatException("illegal entries, must be non-null");
} else if (entries.size() != 1) {
- throw new AdvancedTypographicTableFormatException ("illegal entries, " + entries.size() + " entries present, but requires 1 entry");
+ throw new AdvancedTypographicTableFormatException("illegal entries, " + entries.size() + " entries present, but requires 1 entry");
} else {
Object o;
if (((o = entries.get(0)) == null) || ! (o instanceof PairValues[][])) {
- throw new AdvancedTypographicTableFormatException ("illegal entries, first (and only) entry must be a PairValues[][], but is: " + ((o != null) ? o.getClass() : null));
+ throw new AdvancedTypographicTableFormatException("illegal entries, first (and only) entry must be a PairValues[][], but is: " + ((o != null) ? o.getClass() : null));
} else {
pvm = (PairValues[][]) o;
}
private int nc1; // class 1 count
private int nc2; // class 2 count
private PairValues[][] pvm; // pair values matrix
- PairSubtableFormat2 (String id, int sequence, int flags, int format, GlyphCoverageTable coverage, List entries) {
- super (id, sequence, flags, format, coverage, entries);
- populate (entries);
+ PairSubtableFormat2(String id, int sequence, int flags, int format, GlyphCoverageTable coverage, List entries) {
+ super(id, sequence, flags, format, coverage, entries);
+ populate(entries);
}
/** {@inheritDoc} */
public List getEntries() {
if (pvm != null) {
- List entries = new ArrayList (5);
- entries.add (cdt1);
- entries.add (cdt2);
- entries.add (Integer.valueOf (nc1));
- entries.add (Integer.valueOf (nc2));
- entries.add (pvm);
+ List entries = new ArrayList(5);
+ entries.add(cdt1);
+ entries.add(cdt2);
+ entries.add(Integer.valueOf(nc1));
+ entries.add(Integer.valueOf(nc2));
+ entries.add(pvm);
return entries;
} else {
return null;
}
}
/** {@inheritDoc} */
- public PairValues getPairValues (int ci, int gi1, int gi2) {
+ public PairValues getPairValues(int ci, int gi1, int gi2) {
if (pvm != null) {
- int c1 = cdt1.getClassIndex (gi1, 0);
+ int c1 = cdt1.getClassIndex(gi1, 0);
if ((c1 >= 0) && (c1 < nc1) && (c1 < pvm.length)) {
PairValues[] pvt = pvm [ c1 ];
if (pvt != null) {
- int c2 = cdt2.getClassIndex (gi2, 0);
+ int c2 = cdt2.getClassIndex(gi2, 0);
if ((c2 >= 0) && (c2 < nc2) && (c2 < pvt.length)) {
return pvt [ c2 ];
}
}
return null;
}
- private void populate (List entries) {
+ private void populate(List entries) {
if (entries == null) {
- throw new AdvancedTypographicTableFormatException ("illegal entries, must be non-null");
+ throw new AdvancedTypographicTableFormatException("illegal entries, must be non-null");
} else if (entries.size() != 5) {
- throw new AdvancedTypographicTableFormatException ("illegal entries, " + entries.size() + " entries present, but requires 5 entries");
+ throw new AdvancedTypographicTableFormatException("illegal entries, " + entries.size() + " entries present, but requires 5 entries");
} else {
Object o;
if (((o = entries.get(0)) == null) || ! (o instanceof GlyphClassTable)) {
- throw new AdvancedTypographicTableFormatException ("illegal entries, first entry must be an GlyphClassTable, but is: " + ((o != null) ? o.getClass() : null));
+ throw new AdvancedTypographicTableFormatException("illegal entries, first entry must be an GlyphClassTable, but is: " + ((o != null) ? o.getClass() : null));
} else {
cdt1 = (GlyphClassTable) o;
}
if (((o = entries.get(1)) == null) || ! (o instanceof GlyphClassTable)) {
- throw new AdvancedTypographicTableFormatException ("illegal entries, second entry must be an GlyphClassTable, but is: " + ((o != null) ? o.getClass() : null));
+ throw new AdvancedTypographicTableFormatException("illegal entries, second entry must be an GlyphClassTable, but is: " + ((o != null) ? o.getClass() : null));
} else {
cdt2 = (GlyphClassTable) o;
}
if (((o = entries.get(2)) == null) || ! (o instanceof Integer)) {
- throw new AdvancedTypographicTableFormatException ("illegal entries, third entry must be an Integer, but is: " + ((o != null) ? o.getClass() : null));
+ throw new AdvancedTypographicTableFormatException("illegal entries, third entry must be an Integer, but is: " + ((o != null) ? o.getClass() : null));
} else {
nc1 = ((Integer)(o)).intValue();
}
if (((o = entries.get(3)) == null) || ! (o instanceof Integer)) {
- throw new AdvancedTypographicTableFormatException ("illegal entries, fourth entry must be an Integer, but is: " + ((o != null) ? o.getClass() : null));
+ throw new AdvancedTypographicTableFormatException("illegal entries, fourth entry must be an Integer, but is: " + ((o != null) ? o.getClass() : null));
} else {
nc2 = ((Integer)(o)).intValue();
}
if (((o = entries.get(4)) == null) || ! (o instanceof PairValues[][])) {
- throw new AdvancedTypographicTableFormatException ("illegal entries, fifth entry must be a PairValues[][], but is: " + ((o != null) ? o.getClass() : null));
+ throw new AdvancedTypographicTableFormatException("illegal entries, fifth entry must be a PairValues[][], but is: " + ((o != null) ? o.getClass() : null));
} else {
pvm = (PairValues[][]) o;
}
}
private abstract static class CursiveSubtable extends GlyphPositioningSubtable {
- CursiveSubtable (String id, int sequence, int flags, int format, GlyphCoverageTable coverage, List entries) {
- super (id, sequence, flags, format, coverage);
+ CursiveSubtable(String id, int sequence, int flags, int format, GlyphCoverageTable coverage, List entries) {
+ super(id, sequence, flags, format, coverage);
}
/** {@inheritDoc} */
public int getType() {
return GPOS_LOOKUP_TYPE_CURSIVE;
}
/** {@inheritDoc} */
- public boolean isCompatible (GlyphSubtable subtable) {
+ public boolean isCompatible(GlyphSubtable subtable) {
return subtable instanceof CursiveSubtable;
}
/** {@inheritDoc} */
- public boolean position (GlyphPositioningState ps) {
+ public boolean position(GlyphPositioningState ps) {
boolean applied = false;
int gi = ps.getGlyph(0);
int ci;
- if ((ci = getCoverageIndex (gi)) >= 0) {
- int[] counts = ps.getGlyphsAvailable (0);
+ if ((ci = getCoverageIndex(gi)) >= 0) {
+ int[] counts = ps.getGlyphsAvailable(0);
int nga = counts[0];
if (nga > 1) {
- int[] iga = ps.getGlyphs (0, 2, null, counts);
+ int[] iga = ps.getGlyphs(0, 2, null, counts);
if ((iga != null) && (iga.length == 2)) {
// int gi1 = gi;
int ci1 = ci;
int gi2 = iga [ 1 ];
- int ci2 = getCoverageIndex (gi2);
- Anchor[] aa = getExitEntryAnchors (ci1, ci2);
+ int ci2 = getCoverageIndex(gi2);
+ Anchor[] aa = getExitEntryAnchors(ci1, ci2);
if (aa != null) {
Anchor exa = aa [ 0 ];
Anchor ena = aa [ 1 ];
// int exw = ps.getWidth ( gi1 );
- int enw = ps.getWidth (gi2);
+ int enw = ps.getWidth(gi2);
if ((exa != null) && (ena != null)) {
- Value v = ena.getAlignmentAdjustment (exa);
- v.adjust (- enw, 0, 0, 0);
- if (ps.adjust (v)) {
- ps.setAdjusted (true);
+ Value v = ena.getAlignmentAdjustment(exa);
+ v.adjust(- enw, 0, 0, 0);
+ if (ps.adjust(v)) {
+ ps.setAdjusted(true);
}
}
// consume only first glyph of exit/entry glyph pair
- ps.consume (1);
+ ps.consume(1);
applied = true;
}
}
* missing, where the first entry is the exit anchor of the first glyph and the second entry is the
* entry anchor of the second glyph
*/
- public abstract Anchor[] getExitEntryAnchors (int ci1, int ci2);
- static GlyphPositioningSubtable create (String id, int sequence, int flags, int format, GlyphCoverageTable coverage, List entries) {
+ public abstract Anchor[] getExitEntryAnchors(int ci1, int ci2);
+ static GlyphPositioningSubtable create(String id, int sequence, int flags, int format, GlyphCoverageTable coverage, List entries) {
if (format == 1) {
- return new CursiveSubtableFormat1 (id, sequence, flags, format, coverage, entries);
+ return new CursiveSubtableFormat1(id, sequence, flags, format, coverage, entries);
} else {
throw new UnsupportedOperationException();
}
private static class CursiveSubtableFormat1 extends CursiveSubtable {
private Anchor[] aa; // anchor array, where even entries are entry anchors, and odd entries are exit anchors
- CursiveSubtableFormat1 (String id, int sequence, int flags, int format, GlyphCoverageTable coverage, List entries) {
- super (id, sequence, flags, format, coverage, entries);
- populate (entries);
+ CursiveSubtableFormat1(String id, int sequence, int flags, int format, GlyphCoverageTable coverage, List entries) {
+ super(id, sequence, flags, format, coverage, entries);
+ populate(entries);
}
/** {@inheritDoc} */
public List getEntries() {
if (aa != null) {
- List entries = new ArrayList (1);
- entries.add (aa);
+ List entries = new ArrayList(1);
+ entries.add(aa);
return entries;
} else {
return null;
}
}
/** {@inheritDoc} */
- public Anchor[] getExitEntryAnchors (int ci1, int ci2) {
+ public Anchor[] getExitEntryAnchors(int ci1, int ci2) {
if ((ci1 >= 0) && (ci2 >= 0)) {
int ai1 = (ci1 * 2) + 1; // ci1 denotes glyph with exit anchor
int ai2 = (ci2 * 2) + 0; // ci2 denotes glyph with entry anchor
}
return null;
}
- private void populate (List entries) {
+ private void populate(List entries) {
if (entries == null) {
- throw new AdvancedTypographicTableFormatException ("illegal entries, must be non-null");
+ throw new AdvancedTypographicTableFormatException("illegal entries, must be non-null");
} else if (entries.size() != 1) {
- throw new AdvancedTypographicTableFormatException ("illegal entries, " + entries.size() + " entries present, but requires 1 entry");
+ throw new AdvancedTypographicTableFormatException("illegal entries, " + entries.size() + " entries present, but requires 1 entry");
} else {
Object o;
if (((o = entries.get(0)) == null) || ! (o instanceof Anchor[])) {
- throw new AdvancedTypographicTableFormatException ("illegal entries, first (and only) entry must be a Anchor[], but is: " + ((o != null) ? o.getClass() : null));
+ throw new AdvancedTypographicTableFormatException("illegal entries, first (and only) entry must be a Anchor[], but is: " + ((o != null) ? o.getClass() : null));
} else if ((((Anchor[]) o) . length % 2) != 0) {
- throw new AdvancedTypographicTableFormatException ("illegal entries, Anchor[] array must have an even number of entries, but has: " + ((Anchor[]) o) . length);
+ throw new AdvancedTypographicTableFormatException("illegal entries, Anchor[] array must have an even number of entries, but has: " + ((Anchor[]) o) . length);
} else {
aa = (Anchor[]) o;
}
}
private abstract static class MarkToBaseSubtable extends GlyphPositioningSubtable {
- MarkToBaseSubtable (String id, int sequence, int flags, int format, GlyphCoverageTable coverage, List entries) {
- super (id, sequence, flags, format, coverage);
+ MarkToBaseSubtable(String id, int sequence, int flags, int format, GlyphCoverageTable coverage, List entries) {
+ super(id, sequence, flags, format, coverage);
}
/** {@inheritDoc} */
public int getType() {
return GPOS_LOOKUP_TYPE_MARK_TO_BASE;
}
/** {@inheritDoc} */
- public boolean isCompatible (GlyphSubtable subtable) {
+ public boolean isCompatible(GlyphSubtable subtable) {
return subtable instanceof MarkToBaseSubtable;
}
/** {@inheritDoc} */
- public boolean position (GlyphPositioningState ps) {
+ public boolean position(GlyphPositioningState ps) {
boolean applied = false;
int giMark = ps.getGlyph();
int ciMark;
- if ((ciMark = getCoverageIndex (giMark)) >= 0) {
- MarkAnchor ma = getMarkAnchor (ciMark, giMark);
+ if ((ciMark = getCoverageIndex(giMark)) >= 0) {
+ MarkAnchor ma = getMarkAnchor(ciMark, giMark);
if (ma != null) {
for (int i = 0, n = ps.getPosition(); i < n; i++) {
- int gi = ps.getGlyph (- (i + 1));
- if (ps.isMark (gi)) {
+ int gi = ps.getGlyph(- (i + 1));
+ if (ps.isMark(gi)) {
continue;
} else {
- Anchor a = getBaseAnchor (gi, ma.getMarkClass());
+ Anchor a = getBaseAnchor(gi, ma.getMarkClass());
if (a != null) {
- Value v = a.getAlignmentAdjustment (ma);
+ Value v = a.getAlignmentAdjustment(ma);
// start experimental fix for END OF AYAH in Lateef/Scheherazade
int[] aa = ps.getAdjustment();
if (aa[2] == 0) {
- v.adjust (0, 0, - ps.getWidth (giMark), 0);
+ v.adjust(0, 0, - ps.getWidth(giMark), 0);
}
// end experimental fix for END OF AYAH in Lateef/Scheherazade
- if (ps.adjust (v)) {
- ps.setAdjusted (true);
+ if (ps.adjust(v)) {
+ ps.setAdjusted(true);
}
}
ps.consume(1);
* @param giMark input glyph index of mark glyph
* @return mark anchor or null if none applies
*/
- public abstract MarkAnchor getMarkAnchor (int ciMark, int giMark);
+ public abstract MarkAnchor getMarkAnchor(int ciMark, int giMark);
/**
* Obtain anchor associated with base glyph index and mark class.
* @param giBase input glyph index of base glyph
* @param markClass class number of mark glyph
* @return anchor or null if none applies
*/
- public abstract Anchor getBaseAnchor (int giBase, int markClass);
- static GlyphPositioningSubtable create (String id, int sequence, int flags, int format, GlyphCoverageTable coverage, List entries) {
+ public abstract Anchor getBaseAnchor(int giBase, int markClass);
+ static GlyphPositioningSubtable create(String id, int sequence, int flags, int format, GlyphCoverageTable coverage, List entries) {
if (format == 1) {
- return new MarkToBaseSubtableFormat1 (id, sequence, flags, format, coverage, entries);
+ return new MarkToBaseSubtableFormat1(id, sequence, flags, format, coverage, entries);
} else {
throw new UnsupportedOperationException();
}
private int nmc; // mark class count
private MarkAnchor[] maa; // mark anchor array, ordered by mark coverage index
private Anchor[][] bam; // base anchor matrix, ordered by base coverage index, then by mark class
- MarkToBaseSubtableFormat1 (String id, int sequence, int flags, int format, GlyphCoverageTable coverage, List entries) {
- super (id, sequence, flags, format, coverage, entries);
- populate (entries);
+ MarkToBaseSubtableFormat1(String id, int sequence, int flags, int format, GlyphCoverageTable coverage, List entries) {
+ super(id, sequence, flags, format, coverage, entries);
+ populate(entries);
}
/** {@inheritDoc} */
public List getEntries() {
if ((bct != null) && (maa != null) && (nmc > 0) && (bam != null)) {
- List entries = new ArrayList (4);
- entries.add (bct);
- entries.add (Integer.valueOf (nmc));
- entries.add (maa);
- entries.add (bam);
+ List entries = new ArrayList(4);
+ entries.add(bct);
+ entries.add(Integer.valueOf(nmc));
+ entries.add(maa);
+ entries.add(bam);
return entries;
} else {
return null;
}
}
/** {@inheritDoc} */
- public MarkAnchor getMarkAnchor (int ciMark, int giMark) {
+ public MarkAnchor getMarkAnchor(int ciMark, int giMark) {
if ((maa != null) && (ciMark < maa.length)) {
return maa [ ciMark ];
} else {
}
}
/** {@inheritDoc} */
- public Anchor getBaseAnchor (int giBase, int markClass) {
+ public Anchor getBaseAnchor(int giBase, int markClass) {
int ciBase;
- if ((bct != null) && ((ciBase = bct.getCoverageIndex (giBase)) >= 0)) {
+ if ((bct != null) && ((ciBase = bct.getCoverageIndex(giBase)) >= 0)) {
if ((bam != null) && (ciBase < bam.length)) {
Anchor[] ba = bam [ ciBase ];
if ((ba != null) && (markClass < ba.length)) {
}
return null;
}
- private void populate (List entries) {
+ private void populate(List entries) {
if (entries == null) {
- throw new AdvancedTypographicTableFormatException ("illegal entries, must be non-null");
+ throw new AdvancedTypographicTableFormatException("illegal entries, must be non-null");
} else if (entries.size() != 4) {
- throw new AdvancedTypographicTableFormatException ("illegal entries, " + entries.size() + " entries present, but requires 4 entries");
+ throw new AdvancedTypographicTableFormatException("illegal entries, " + entries.size() + " entries present, but requires 4 entries");
} else {
Object o;
if (((o = entries.get(0)) == null) || ! (o instanceof GlyphCoverageTable)) {
- throw new AdvancedTypographicTableFormatException ("illegal entries, first entry must be an GlyphCoverageTable, but is: " + ((o != null) ? o.getClass() : null));
+ throw new AdvancedTypographicTableFormatException("illegal entries, first entry must be an GlyphCoverageTable, but is: " + ((o != null) ? o.getClass() : null));
} else {
bct = (GlyphCoverageTable) o;
}
if (((o = entries.get(1)) == null) || ! (o instanceof Integer)) {
- throw new AdvancedTypographicTableFormatException ("illegal entries, second entry must be an Integer, but is: " + ((o != null) ? o.getClass() : null));
+ throw new AdvancedTypographicTableFormatException("illegal entries, second entry must be an Integer, but is: " + ((o != null) ? o.getClass() : null));
} else {
nmc = ((Integer)(o)).intValue();
}
if (((o = entries.get(2)) == null) || ! (o instanceof MarkAnchor[])) {
- throw new AdvancedTypographicTableFormatException ("illegal entries, third entry must be a MarkAnchor[], but is: " + ((o != null) ? o.getClass() : null));
+ throw new AdvancedTypographicTableFormatException("illegal entries, third entry must be a MarkAnchor[], but is: " + ((o != null) ? o.getClass() : null));
} else {
maa = (MarkAnchor[]) o;
}
if (((o = entries.get(3)) == null) || ! (o instanceof Anchor[][])) {
- throw new AdvancedTypographicTableFormatException ("illegal entries, fourth entry must be a Anchor[][], but is: " + ((o != null) ? o.getClass() : null));
+ throw new AdvancedTypographicTableFormatException("illegal entries, fourth entry must be a Anchor[][], but is: " + ((o != null) ? o.getClass() : null));
} else {
bam = (Anchor[][]) o;
}
}
private abstract static class MarkToLigatureSubtable extends GlyphPositioningSubtable {
- MarkToLigatureSubtable (String id, int sequence, int flags, int format, GlyphCoverageTable coverage, List entries) {
- super (id, sequence, flags, format, coverage);
+ MarkToLigatureSubtable(String id, int sequence, int flags, int format, GlyphCoverageTable coverage, List entries) {
+ super(id, sequence, flags, format, coverage);
}
/** {@inheritDoc} */
public int getType() {
return GPOS_LOOKUP_TYPE_MARK_TO_LIGATURE;
}
/** {@inheritDoc} */
- public boolean isCompatible (GlyphSubtable subtable) {
+ public boolean isCompatible(GlyphSubtable subtable) {
return subtable instanceof MarkToLigatureSubtable;
}
/** {@inheritDoc} */
- public boolean position (GlyphPositioningState ps) {
+ public boolean position(GlyphPositioningState ps) {
boolean applied = false;
int giMark = ps.getGlyph();
int ciMark;
- if ((ciMark = getCoverageIndex (giMark)) >= 0) {
- MarkAnchor ma = getMarkAnchor (ciMark, giMark);
+ if ((ciMark = getCoverageIndex(giMark)) >= 0) {
+ MarkAnchor ma = getMarkAnchor(ciMark, giMark);
int mxc = getMaxComponentCount();
if (ma != null) {
for (int i = 0, n = ps.getPosition(); i < n; i++) {
- int gi = ps.getGlyph (- (i + 1));
- if (ps.isMark (gi)) {
+ int gi = ps.getGlyph(- (i + 1));
+ if (ps.isMark(gi)) {
continue;
} else {
- Anchor a = getLigatureAnchor (gi, mxc, i, ma.getMarkClass());
+ Anchor a = getLigatureAnchor(gi, mxc, i, ma.getMarkClass());
if (a != null) {
- if (ps.adjust (a.getAlignmentAdjustment (ma))) {
- ps.setAdjusted (true);
+ if (ps.adjust(a.getAlignmentAdjustment(ma))) {
+ ps.setAdjusted(true);
}
}
ps.consume(1);
* @param giMark input glyph index of mark glyph
* @return mark anchor or null if none applies
*/
- public abstract MarkAnchor getMarkAnchor (int ciMark, int giMark);
+ public abstract MarkAnchor getMarkAnchor(int ciMark, int giMark);
/**
* Obtain maximum component count.
* @return maximum component count (>=0)
* @param markClass class number of mark glyph
* @return anchor or null if none applies
*/
- public abstract Anchor getLigatureAnchor (int giLig, int maxComponents, int component, int markClass);
- static GlyphPositioningSubtable create (String id, int sequence, int flags, int format, GlyphCoverageTable coverage, List entries) {
+ public abstract Anchor getLigatureAnchor(int giLig, int maxComponents, int component, int markClass);
+ static GlyphPositioningSubtable create(String id, int sequence, int flags, int format, GlyphCoverageTable coverage, List entries) {
if (format == 1) {
- return new MarkToLigatureSubtableFormat1 (id, sequence, flags, format, coverage, entries);
+ return new MarkToLigatureSubtableFormat1(id, sequence, flags, format, coverage, entries);
} else {
throw new UnsupportedOperationException();
}
private int mxc; // maximum ligature component count
private MarkAnchor[] maa; // mark anchor array, ordered by mark coverage index
private Anchor[][][] lam; // ligature anchor matrix, ordered by ligature coverage index, then ligature component, then mark class
- MarkToLigatureSubtableFormat1 (String id, int sequence, int flags, int format, GlyphCoverageTable coverage, List entries) {
- super (id, sequence, flags, format, coverage, entries);
- populate (entries);
+ MarkToLigatureSubtableFormat1(String id, int sequence, int flags, int format, GlyphCoverageTable coverage, List entries) {
+ super(id, sequence, flags, format, coverage, entries);
+ populate(entries);
}
/** {@inheritDoc} */
public List getEntries() {
if (lam != null) {
- List entries = new ArrayList (5);
- entries.add (lct);
- entries.add (Integer.valueOf (nmc));
- entries.add (Integer.valueOf (mxc));
- entries.add (maa);
- entries.add (lam);
+ List entries = new ArrayList(5);
+ entries.add(lct);
+ entries.add(Integer.valueOf(nmc));
+ entries.add(Integer.valueOf(mxc));
+ entries.add(maa);
+ entries.add(lam);
return entries;
} else {
return null;
}
}
/** {@inheritDoc} */
- public MarkAnchor getMarkAnchor (int ciMark, int giMark) {
+ public MarkAnchor getMarkAnchor(int ciMark, int giMark) {
if ((maa != null) && (ciMark < maa.length)) {
return maa [ ciMark ];
} else {
return mxc;
}
/** {@inheritDoc} */
- public Anchor getLigatureAnchor (int giLig, int maxComponents, int component, int markClass) {
+ public Anchor getLigatureAnchor(int giLig, int maxComponents, int component, int markClass) {
int ciLig;
- if ((lct != null) && ((ciLig = lct.getCoverageIndex (giLig)) >= 0)) {
+ if ((lct != null) && ((ciLig = lct.getCoverageIndex(giLig)) >= 0)) {
if ((lam != null) && (ciLig < lam.length)) {
Anchor[][] lcm = lam [ ciLig ];
if (component < maxComponents) {
}
return null;
}
- private void populate (List entries) {
+ private void populate(List entries) {
if (entries == null) {
- throw new AdvancedTypographicTableFormatException ("illegal entries, must be non-null");
+ throw new AdvancedTypographicTableFormatException("illegal entries, must be non-null");
} else if (entries.size() != 5) {
- throw new AdvancedTypographicTableFormatException ("illegal entries, " + entries.size() + " entries present, but requires 5 entries");
+ throw new AdvancedTypographicTableFormatException("illegal entries, " + entries.size() + " entries present, but requires 5 entries");
} else {
Object o;
if (((o = entries.get(0)) == null) || ! (o instanceof GlyphCoverageTable)) {
- throw new AdvancedTypographicTableFormatException ("illegal entries, first entry must be an GlyphCoverageTable, but is: " + ((o != null) ? o.getClass() : null));
+ throw new AdvancedTypographicTableFormatException("illegal entries, first entry must be an GlyphCoverageTable, but is: " + ((o != null) ? o.getClass() : null));
} else {
lct = (GlyphCoverageTable) o;
}
if (((o = entries.get(1)) == null) || ! (o instanceof Integer)) {
- throw new AdvancedTypographicTableFormatException ("illegal entries, second entry must be an Integer, but is: " + ((o != null) ? o.getClass() : null));
+ throw new AdvancedTypographicTableFormatException("illegal entries, second entry must be an Integer, but is: " + ((o != null) ? o.getClass() : null));
} else {
nmc = ((Integer)(o)).intValue();
}
if (((o = entries.get(2)) == null) || ! (o instanceof Integer)) {
- throw new AdvancedTypographicTableFormatException ("illegal entries, third entry must be an Integer, but is: " + ((o != null) ? o.getClass() : null));
+ throw new AdvancedTypographicTableFormatException("illegal entries, third entry must be an Integer, but is: " + ((o != null) ? o.getClass() : null));
} else {
mxc = ((Integer)(o)).intValue();
}
if (((o = entries.get(3)) == null) || ! (o instanceof MarkAnchor[])) {
- throw new AdvancedTypographicTableFormatException ("illegal entries, fourth entry must be a MarkAnchor[], but is: " + ((o != null) ? o.getClass() : null));
+ throw new AdvancedTypographicTableFormatException("illegal entries, fourth entry must be a MarkAnchor[], but is: " + ((o != null) ? o.getClass() : null));
} else {
maa = (MarkAnchor[]) o;
}
if (((o = entries.get(4)) == null) || ! (o instanceof Anchor[][][])) {
- throw new AdvancedTypographicTableFormatException ("illegal entries, fifth entry must be a Anchor[][][], but is: " + ((o != null) ? o.getClass() : null));
+ throw new AdvancedTypographicTableFormatException("illegal entries, fifth entry must be a Anchor[][][], but is: " + ((o != null) ? o.getClass() : null));
} else {
lam = (Anchor[][][]) o;
}
}
private abstract static class MarkToMarkSubtable extends GlyphPositioningSubtable {
- MarkToMarkSubtable (String id, int sequence, int flags, int format, GlyphCoverageTable coverage, List entries) {
- super (id, sequence, flags, format, coverage);
+ MarkToMarkSubtable(String id, int sequence, int flags, int format, GlyphCoverageTable coverage, List entries) {
+ super(id, sequence, flags, format, coverage);
}
/** {@inheritDoc} */
public int getType() {
return GPOS_LOOKUP_TYPE_MARK_TO_MARK;
}
/** {@inheritDoc} */
- public boolean isCompatible (GlyphSubtable subtable) {
+ public boolean isCompatible(GlyphSubtable subtable) {
return subtable instanceof MarkToMarkSubtable;
}
/** {@inheritDoc} */
- public boolean position (GlyphPositioningState ps) {
+ public boolean position(GlyphPositioningState ps) {
boolean applied = false;
int giMark1 = ps.getGlyph();
int ciMark1;
- if ((ciMark1 = getCoverageIndex (giMark1)) >= 0) {
- MarkAnchor ma = getMark1Anchor (ciMark1, giMark1);
+ if ((ciMark1 = getCoverageIndex(giMark1)) >= 0) {
+ MarkAnchor ma = getMark1Anchor(ciMark1, giMark1);
if (ma != null) {
if (ps.hasPrev()) {
- Anchor a = getMark2Anchor (ps.getGlyph(-1), ma.getMarkClass());
+ Anchor a = getMark2Anchor(ps.getGlyph(-1), ma.getMarkClass());
if (a != null) {
- if (ps.adjust (a.getAlignmentAdjustment (ma))) {
- ps.setAdjusted (true);
+ if (ps.adjust(a.getAlignmentAdjustment(ma))) {
+ ps.setAdjusted(true);
}
}
ps.consume(1);
* @param giMark1 input glyph index of mark 1 glyph
* @return mark 1 anchor or null if none applies
*/
- public abstract MarkAnchor getMark1Anchor (int ciMark1, int giMark1);
+ public abstract MarkAnchor getMark1Anchor(int ciMark1, int giMark1);
/**
* Obtain anchor associated with mark 2 glyph index and mark 1 class.
* @param giMark2 input glyph index of mark 2 glyph
* @param markClass class number of mark 1 glyph
* @return anchor or null if none applies
*/
- public abstract Anchor getMark2Anchor (int giBase, int markClass);
- static GlyphPositioningSubtable create (String id, int sequence, int flags, int format, GlyphCoverageTable coverage, List entries) {
+ public abstract Anchor getMark2Anchor(int giBase, int markClass);
+ static GlyphPositioningSubtable create(String id, int sequence, int flags, int format, GlyphCoverageTable coverage, List entries) {
if (format == 1) {
- return new MarkToMarkSubtableFormat1 (id, sequence, flags, format, coverage, entries);
+ return new MarkToMarkSubtableFormat1(id, sequence, flags, format, coverage, entries);
} else {
throw new UnsupportedOperationException();
}
private int nmc; // mark class count
private MarkAnchor[] maa; // mark1 anchor array, ordered by mark1 coverage index
private Anchor[][] mam; // mark2 anchor matrix, ordered by mark2 coverage index, then by mark1 class
- MarkToMarkSubtableFormat1 (String id, int sequence, int flags, int format, GlyphCoverageTable coverage, List entries) {
- super (id, sequence, flags, format, coverage, entries);
- populate (entries);
+ MarkToMarkSubtableFormat1(String id, int sequence, int flags, int format, GlyphCoverageTable coverage, List entries) {
+ super(id, sequence, flags, format, coverage, entries);
+ populate(entries);
}
/** {@inheritDoc} */
public List getEntries() {
if ((mct2 != null) && (maa != null) && (nmc > 0) && (mam != null)) {
- List entries = new ArrayList (4);
- entries.add (mct2);
- entries.add (Integer.valueOf (nmc));
- entries.add (maa);
- entries.add (mam);
+ List entries = new ArrayList(4);
+ entries.add(mct2);
+ entries.add(Integer.valueOf(nmc));
+ entries.add(maa);
+ entries.add(mam);
return entries;
} else {
return null;
}
}
/** {@inheritDoc} */
- public MarkAnchor getMark1Anchor (int ciMark1, int giMark1) {
+ public MarkAnchor getMark1Anchor(int ciMark1, int giMark1) {
if ((maa != null) && (ciMark1 < maa.length)) {
return maa [ ciMark1 ];
} else {
}
}
/** {@inheritDoc} */
- public Anchor getMark2Anchor (int giMark2, int markClass) {
+ public Anchor getMark2Anchor(int giMark2, int markClass) {
int ciMark2;
- if ((mct2 != null) && ((ciMark2 = mct2.getCoverageIndex (giMark2)) >= 0)) {
+ if ((mct2 != null) && ((ciMark2 = mct2.getCoverageIndex(giMark2)) >= 0)) {
if ((mam != null) && (ciMark2 < mam.length)) {
Anchor[] ma = mam [ ciMark2 ];
if ((ma != null) && (markClass < ma.length)) {
}
return null;
}
- private void populate (List entries) {
+ private void populate(List entries) {
if (entries == null) {
- throw new AdvancedTypographicTableFormatException ("illegal entries, must be non-null");
+ throw new AdvancedTypographicTableFormatException("illegal entries, must be non-null");
} else if (entries.size() != 4) {
- throw new AdvancedTypographicTableFormatException ("illegal entries, " + entries.size() + " entries present, but requires 4 entries");
+ throw new AdvancedTypographicTableFormatException("illegal entries, " + entries.size() + " entries present, but requires 4 entries");
} else {
Object o;
if (((o = entries.get(0)) == null) || ! (o instanceof GlyphCoverageTable)) {
- throw new AdvancedTypographicTableFormatException ("illegal entries, first entry must be an GlyphCoverageTable, but is: " + ((o != null) ? o.getClass() : null));
+ throw new AdvancedTypographicTableFormatException("illegal entries, first entry must be an GlyphCoverageTable, but is: " + ((o != null) ? o.getClass() : null));
} else {
mct2 = (GlyphCoverageTable) o;
}
if (((o = entries.get(1)) == null) || ! (o instanceof Integer)) {
- throw new AdvancedTypographicTableFormatException ("illegal entries, second entry must be an Integer, but is: " + ((o != null) ? o.getClass() : null));
+ throw new AdvancedTypographicTableFormatException("illegal entries, second entry must be an Integer, but is: " + ((o != null) ? o.getClass() : null));
} else {
nmc = ((Integer)(o)).intValue();
}
if (((o = entries.get(2)) == null) || ! (o instanceof MarkAnchor[])) {
- throw new AdvancedTypographicTableFormatException ("illegal entries, third entry must be a MarkAnchor[], but is: " + ((o != null) ? o.getClass() : null));
+ throw new AdvancedTypographicTableFormatException("illegal entries, third entry must be a MarkAnchor[], but is: " + ((o != null) ? o.getClass() : null));
} else {
maa = (MarkAnchor[]) o;
}
if (((o = entries.get(3)) == null) || ! (o instanceof Anchor[][])) {
- throw new AdvancedTypographicTableFormatException ("illegal entries, fourth entry must be a Anchor[][], but is: " + ((o != null) ? o.getClass() : null));
+ throw new AdvancedTypographicTableFormatException("illegal entries, fourth entry must be a Anchor[][], but is: " + ((o != null) ? o.getClass() : null));
} else {
mam = (Anchor[][]) o;
}
}
private abstract static class ContextualSubtable extends GlyphPositioningSubtable {
- ContextualSubtable (String id, int sequence, int flags, int format, GlyphCoverageTable coverage, List entries) {
- super (id, sequence, flags, format, coverage);
+ ContextualSubtable(String id, int sequence, int flags, int format, GlyphCoverageTable coverage, List entries) {
+ super(id, sequence, flags, format, coverage);
}
/** {@inheritDoc} */
public int getType() {
return GPOS_LOOKUP_TYPE_CONTEXTUAL;
}
/** {@inheritDoc} */
- public boolean isCompatible (GlyphSubtable subtable) {
+ public boolean isCompatible(GlyphSubtable subtable) {
return subtable instanceof ContextualSubtable;
}
/** {@inheritDoc} */
- public boolean position (GlyphPositioningState ps) {
+ public boolean position(GlyphPositioningState ps) {
boolean applied = false;
int gi = ps.getGlyph();
int ci;
- if ((ci = getCoverageIndex (gi)) >= 0) {
+ if ((ci = getCoverageIndex(gi)) >= 0) {
int[] rv = new int[1];
- RuleLookup[] la = getLookups (ci, gi, ps, rv);
+ RuleLookup[] la = getLookups(ci, gi, ps, rv);
if (la != null) {
- ps.apply (la, rv[0]);
+ ps.apply(la, rv[0]);
applied = true;
}
}
* where the first entry is used to return the input sequence length of the matched rule
* @return array of rule lookups or null if none applies
*/
- public abstract RuleLookup[] getLookups (int ci, int gi, GlyphPositioningState ps, int[] rv);
- static GlyphPositioningSubtable create (String id, int sequence, int flags, int format, GlyphCoverageTable coverage, List entries) {
+ public abstract RuleLookup[] getLookups(int ci, int gi, GlyphPositioningState ps, int[] rv);
+ static GlyphPositioningSubtable create(String id, int sequence, int flags, int format, GlyphCoverageTable coverage, List entries) {
if (format == 1) {
- return new ContextualSubtableFormat1 (id, sequence, flags, format, coverage, entries);
+ return new ContextualSubtableFormat1(id, sequence, flags, format, coverage, entries);
} else if (format == 2) {
- return new ContextualSubtableFormat2 (id, sequence, flags, format, coverage, entries);
+ return new ContextualSubtableFormat2(id, sequence, flags, format, coverage, entries);
} else if (format == 3) {
- return new ContextualSubtableFormat3 (id, sequence, flags, format, coverage, entries);
+ return new ContextualSubtableFormat3(id, sequence, flags, format, coverage, entries);
} else {
throw new UnsupportedOperationException();
}
private static class ContextualSubtableFormat1 extends ContextualSubtable {
private RuleSet[] rsa; // rule set array, ordered by glyph coverage index
- ContextualSubtableFormat1 (String id, int sequence, int flags, int format, GlyphCoverageTable coverage, List entries) {
- super (id, sequence, flags, format, coverage, entries);
- populate (entries);
+ ContextualSubtableFormat1(String id, int sequence, int flags, int format, GlyphCoverageTable coverage, List entries) {
+ super(id, sequence, flags, format, coverage, entries);
+ populate(entries);
}
/** {@inheritDoc} */
public List getEntries() {
if (rsa != null) {
- List entries = new ArrayList (1);
- entries.add (rsa);
+ List entries = new ArrayList(1);
+ entries.add(rsa);
return entries;
} else {
return null;
}
}
/** {@inheritDoc} */
- public void resolveLookupReferences (Map/*<String,LookupTable>*/ lookupTables) {
- GlyphTable.resolveLookupReferences (rsa, lookupTables);
+ public void resolveLookupReferences(Map/*<String,LookupTable>*/ lookupTables) {
+ GlyphTable.resolveLookupReferences(rsa, lookupTables);
}
/** {@inheritDoc} */
- public RuleLookup[] getLookups (int ci, int gi, GlyphPositioningState ps, int[] rv) {
+ public RuleLookup[] getLookups(int ci, int gi, GlyphPositioningState ps, int[] rv) {
assert ps != null;
assert (rv != null) && (rv.length > 0);
assert rsa != null;
Rule r = ra [ i ];
if ((r != null) && (r instanceof ChainedGlyphSequenceRule)) {
ChainedGlyphSequenceRule cr = (ChainedGlyphSequenceRule) r;
- int[] iga = cr.getGlyphs (gi);
- if (matches (ps, iga, 0, rv)) {
+ int[] iga = cr.getGlyphs(gi);
+ if (matches(ps, iga, 0, rv)) {
return r.getLookups();
}
}
}
return null;
}
- static boolean matches (GlyphPositioningState ps, int[] glyphs, int offset, int[] rv) {
+ static boolean matches(GlyphPositioningState ps, int[] glyphs, int offset, int[] rv) {
if ((glyphs == null) || (glyphs.length == 0)) {
return true; // match null or empty glyph sequence
} else {
boolean reverse = offset < 0;
GlyphTester ignores = ps.getIgnoreDefault();
- int[] counts = ps.getGlyphsAvailable (offset, reverse, ignores);
+ int[] counts = ps.getGlyphsAvailable(offset, reverse, ignores);
int nga = counts[0];
int ngm = glyphs.length;
if (nga < ngm) {
return false; // insufficient glyphs available to match
} else {
- int[] ga = ps.getGlyphs (offset, ngm, reverse, ignores, null, counts);
+ int[] ga = ps.getGlyphs(offset, ngm, reverse, ignores, null, counts);
for (int k = 0; k < ngm; k++) {
if (ga [ k ] != glyphs [ k ]) {
return false; // match fails at ga [ k ]
}
}
}
- private void populate (List entries) {
+ private void populate(List entries) {
if (entries == null) {
- throw new AdvancedTypographicTableFormatException ("illegal entries, must be non-null");
+ throw new AdvancedTypographicTableFormatException("illegal entries, must be non-null");
} else if (entries.size() != 1) {
- throw new AdvancedTypographicTableFormatException ("illegal entries, " + entries.size() + " entries present, but requires 1 entry");
+ throw new AdvancedTypographicTableFormatException("illegal entries, " + entries.size() + " entries present, but requires 1 entry");
} else {
Object o;
if (((o = entries.get(0)) == null) || ! (o instanceof RuleSet[])) {
- throw new AdvancedTypographicTableFormatException ("illegal entries, first entry must be an RuleSet[], but is: " + ((o != null) ? o.getClass() : null));
+ throw new AdvancedTypographicTableFormatException("illegal entries, first entry must be an RuleSet[], but is: " + ((o != null) ? o.getClass() : null));
} else {
rsa = (RuleSet[]) o;
}
private GlyphClassTable cdt; // class def table
private int ngc; // class set count
private RuleSet[] rsa; // rule set array, ordered by class number [0...ngc - 1]
- ContextualSubtableFormat2 (String id, int sequence, int flags, int format, GlyphCoverageTable coverage, List entries) {
- super (id, sequence, flags, format, coverage, entries);
- populate (entries);
+ ContextualSubtableFormat2(String id, int sequence, int flags, int format, GlyphCoverageTable coverage, List entries) {
+ super(id, sequence, flags, format, coverage, entries);
+ populate(entries);
}
/** {@inheritDoc} */
public List getEntries() {
if (rsa != null) {
- List entries = new ArrayList (3);
- entries.add (cdt);
- entries.add (Integer.valueOf (ngc));
- entries.add (rsa);
+ List entries = new ArrayList(3);
+ entries.add(cdt);
+ entries.add(Integer.valueOf(ngc));
+ entries.add(rsa);
return entries;
} else {
return null;
}
}
/** {@inheritDoc} */
- public void resolveLookupReferences (Map/*<String,LookupTable>*/ lookupTables) {
- GlyphTable.resolveLookupReferences (rsa, lookupTables);
+ public void resolveLookupReferences(Map/*<String,LookupTable>*/ lookupTables) {
+ GlyphTable.resolveLookupReferences(rsa, lookupTables);
}
/** {@inheritDoc} */
- public RuleLookup[] getLookups (int ci, int gi, GlyphPositioningState ps, int[] rv) {
+ public RuleLookup[] getLookups(int ci, int gi, GlyphPositioningState ps, int[] rv) {
assert ps != null;
assert (rv != null) && (rv.length > 0);
assert rsa != null;
Rule r = ra [ i ];
if ((r != null) && (r instanceof ChainedClassSequenceRule)) {
ChainedClassSequenceRule cr = (ChainedClassSequenceRule) r;
- int[] ca = cr.getClasses (cdt.getClassIndex (gi, ps.getClassMatchSet (gi)));
- if (matches (ps, cdt, ca, 0, rv)) {
+ int[] ca = cr.getClasses(cdt.getClassIndex(gi, ps.getClassMatchSet(gi)));
+ if (matches(ps, cdt, ca, 0, rv)) {
return r.getLookups();
}
}
}
return null;
}
- static boolean matches (GlyphPositioningState ps, GlyphClassTable cdt, int[] classes, int offset, int[] rv) {
+ static boolean matches(GlyphPositioningState ps, GlyphClassTable cdt, int[] classes, int offset, int[] rv) {
if ((cdt == null) || (classes == null) || (classes.length == 0)) {
return true; // match null class definitions, null or empty class sequence
} else {
boolean reverse = offset < 0;
GlyphTester ignores = ps.getIgnoreDefault();
- int[] counts = ps.getGlyphsAvailable (offset, reverse, ignores);
+ int[] counts = ps.getGlyphsAvailable(offset, reverse, ignores);
int nga = counts[0];
int ngm = classes.length;
if (nga < ngm) {
return false; // insufficient glyphs available to match
} else {
- int[] ga = ps.getGlyphs (offset, ngm, reverse, ignores, null, counts);
+ int[] ga = ps.getGlyphs(offset, ngm, reverse, ignores, null, counts);
for (int k = 0; k < ngm; k++) {
int gi = ga [ k ];
- int ms = ps.getClassMatchSet (gi);
- int gc = cdt.getClassIndex (gi, ms);
- if ((gc < 0) || (gc >= cdt.getClassSize (ms))) {
+ int ms = ps.getClassMatchSet(gi);
+ int gc = cdt.getClassIndex(gi, ms);
+ if ((gc < 0) || (gc >= cdt.getClassSize(ms))) {
return false; // none or invalid class fails mat ch
} else if (gc != classes [ k ]) {
return false; // match fails at ga [ k ]
}
}
}
- private void populate (List entries) {
+ private void populate(List entries) {
if (entries == null) {
- throw new AdvancedTypographicTableFormatException ("illegal entries, must be non-null");
+ throw new AdvancedTypographicTableFormatException("illegal entries, must be non-null");
} else if (entries.size() != 3) {
- throw new AdvancedTypographicTableFormatException ("illegal entries, " + entries.size() + " entries present, but requires 3 entries");
+ throw new AdvancedTypographicTableFormatException("illegal entries, " + entries.size() + " entries present, but requires 3 entries");
} else {
Object o;
if (((o = entries.get(0)) == null) || ! (o instanceof GlyphClassTable)) {
- throw new AdvancedTypographicTableFormatException ("illegal entries, first entry must be an GlyphClassTable, but is: " + ((o != null) ? o.getClass() : null));
+ throw new AdvancedTypographicTableFormatException("illegal entries, first entry must be an GlyphClassTable, but is: " + ((o != null) ? o.getClass() : null));
} else {
cdt = (GlyphClassTable) o;
}
if (((o = entries.get(1)) == null) || ! (o instanceof Integer)) {
- throw new AdvancedTypographicTableFormatException ("illegal entries, second entry must be an Integer, but is: " + ((o != null) ? o.getClass() : null));
+ throw new AdvancedTypographicTableFormatException("illegal entries, second entry must be an Integer, but is: " + ((o != null) ? o.getClass() : null));
} else {
ngc = ((Integer)(o)).intValue();
}
if (((o = entries.get(2)) == null) || ! (o instanceof RuleSet[])) {
- throw new AdvancedTypographicTableFormatException ("illegal entries, third entry must be an RuleSet[], but is: " + ((o != null) ? o.getClass() : null));
+ throw new AdvancedTypographicTableFormatException("illegal entries, third entry must be an RuleSet[], but is: " + ((o != null) ? o.getClass() : null));
} else {
rsa = (RuleSet[]) o;
if (rsa.length != ngc) {
- throw new AdvancedTypographicTableFormatException ("illegal entries, RuleSet[] length is " + rsa.length + ", but expected " + ngc + " glyph classes");
+ throw new AdvancedTypographicTableFormatException("illegal entries, RuleSet[] length is " + rsa.length + ", but expected " + ngc + " glyph classes");
}
}
}
private static class ContextualSubtableFormat3 extends ContextualSubtable {
private RuleSet[] rsa; // rule set array, containing a single rule set
- ContextualSubtableFormat3 (String id, int sequence, int flags, int format, GlyphCoverageTable coverage, List entries) {
- super (id, sequence, flags, format, coverage, entries);
- populate (entries);
+ ContextualSubtableFormat3(String id, int sequence, int flags, int format, GlyphCoverageTable coverage, List entries) {
+ super(id, sequence, flags, format, coverage, entries);
+ populate(entries);
}
/** {@inheritDoc} */
public List getEntries() {
if (rsa != null) {
- List entries = new ArrayList (1);
- entries.add (rsa);
+ List entries = new ArrayList(1);
+ entries.add(rsa);
return entries;
} else {
return null;
}
}
/** {@inheritDoc} */
- public void resolveLookupReferences (Map/*<String,LookupTable>*/ lookupTables) {
- GlyphTable.resolveLookupReferences (rsa, lookupTables);
+ public void resolveLookupReferences(Map/*<String,LookupTable>*/ lookupTables) {
+ GlyphTable.resolveLookupReferences(rsa, lookupTables);
}
/** {@inheritDoc} */
- public RuleLookup[] getLookups (int ci, int gi, GlyphPositioningState ps, int[] rv) {
+ public RuleLookup[] getLookups(int ci, int gi, GlyphPositioningState ps, int[] rv) {
assert ps != null;
assert (rv != null) && (rv.length > 0);
assert rsa != null;
if ((r != null) && (r instanceof ChainedCoverageSequenceRule)) {
ChainedCoverageSequenceRule cr = (ChainedCoverageSequenceRule) r;
GlyphCoverageTable[] gca = cr.getCoverages();
- if (matches (ps, gca, 0, rv)) {
+ if (matches(ps, gca, 0, rv)) {
return r.getLookups();
}
}
}
return null;
}
- static boolean matches (GlyphPositioningState ps, GlyphCoverageTable[] gca, int offset, int[] rv) {
+ static boolean matches(GlyphPositioningState ps, GlyphCoverageTable[] gca, int offset, int[] rv) {
if ((gca == null) || (gca.length == 0)) {
return true; // match null or empty coverage array
} else {
boolean reverse = offset < 0;
GlyphTester ignores = ps.getIgnoreDefault();
- int[] counts = ps.getGlyphsAvailable (offset, reverse, ignores);
+ int[] counts = ps.getGlyphsAvailable(offset, reverse, ignores);
int nga = counts[0];
int ngm = gca.length;
if (nga < ngm) {
return false; // insufficient glyphs available to match
} else {
- int[] ga = ps.getGlyphs (offset, ngm, reverse, ignores, null, counts);
+ int[] ga = ps.getGlyphs(offset, ngm, reverse, ignores, null, counts);
for (int k = 0; k < ngm; k++) {
GlyphCoverageTable ct = gca [ k ];
if (ct != null) {
- if (ct.getCoverageIndex (ga [ k ]) < 0) {
+ if (ct.getCoverageIndex(ga [ k ]) < 0) {
return false; // match fails at ga [ k ]
}
}
}
}
}
- private void populate (List entries) {
+ private void populate(List entries) {
if (entries == null) {
- throw new AdvancedTypographicTableFormatException ("illegal entries, must be non-null");
+ throw new AdvancedTypographicTableFormatException("illegal entries, must be non-null");
} else if (entries.size() != 1) {
- throw new AdvancedTypographicTableFormatException ("illegal entries, " + entries.size() + " entries present, but requires 1 entry");
+ throw new AdvancedTypographicTableFormatException("illegal entries, " + entries.size() + " entries present, but requires 1 entry");
} else {
Object o;
if (((o = entries.get(0)) == null) || ! (o instanceof RuleSet[])) {
- throw new AdvancedTypographicTableFormatException ("illegal entries, first entry must be an RuleSet[], but is: " + ((o != null) ? o.getClass() : null));
+ throw new AdvancedTypographicTableFormatException("illegal entries, first entry must be an RuleSet[], but is: " + ((o != null) ? o.getClass() : null));
} else {
rsa = (RuleSet[]) o;
}
}
private abstract static class ChainedContextualSubtable extends GlyphPositioningSubtable {
- ChainedContextualSubtable (String id, int sequence, int flags, int format, GlyphCoverageTable coverage, List entries) {
- super (id, sequence, flags, format, coverage);
+ ChainedContextualSubtable(String id, int sequence, int flags, int format, GlyphCoverageTable coverage, List entries) {
+ super(id, sequence, flags, format, coverage);
}
/** {@inheritDoc} */
public int getType() {
return GPOS_LOOKUP_TYPE_CHAINED_CONTEXTUAL;
}
/** {@inheritDoc} */
- public boolean isCompatible (GlyphSubtable subtable) {
+ public boolean isCompatible(GlyphSubtable subtable) {
return subtable instanceof ChainedContextualSubtable;
}
/** {@inheritDoc} */
- public boolean position (GlyphPositioningState ps) {
+ public boolean position(GlyphPositioningState ps) {
boolean applied = false;
int gi = ps.getGlyph();
int ci;
- if ((ci = getCoverageIndex (gi)) >= 0) {
+ if ((ci = getCoverageIndex(gi)) >= 0) {
int[] rv = new int[1];
- RuleLookup[] la = getLookups (ci, gi, ps, rv);
+ RuleLookup[] la = getLookups(ci, gi, ps, rv);
if (la != null) {
- ps.apply (la, rv[0]);
+ ps.apply(la, rv[0]);
applied = true;
}
}
* where the first entry is used to return the input sequence length of the matched rule
* @return array of rule lookups or null if none applies
*/
- public abstract RuleLookup[] getLookups (int ci, int gi, GlyphPositioningState ps, int[] rv);
- static GlyphPositioningSubtable create (String id, int sequence, int flags, int format, GlyphCoverageTable coverage, List entries) {
+ public abstract RuleLookup[] getLookups(int ci, int gi, GlyphPositioningState ps, int[] rv);
+ static GlyphPositioningSubtable create(String id, int sequence, int flags, int format, GlyphCoverageTable coverage, List entries) {
if (format == 1) {
- return new ChainedContextualSubtableFormat1 (id, sequence, flags, format, coverage, entries);
+ return new ChainedContextualSubtableFormat1(id, sequence, flags, format, coverage, entries);
} else if (format == 2) {
- return new ChainedContextualSubtableFormat2 (id, sequence, flags, format, coverage, entries);
+ return new ChainedContextualSubtableFormat2(id, sequence, flags, format, coverage, entries);
} else if (format == 3) {
- return new ChainedContextualSubtableFormat3 (id, sequence, flags, format, coverage, entries);
+ return new ChainedContextualSubtableFormat3(id, sequence, flags, format, coverage, entries);
} else {
throw new UnsupportedOperationException();
}
private static class ChainedContextualSubtableFormat1 extends ChainedContextualSubtable {
private RuleSet[] rsa; // rule set array, ordered by glyph coverage index
- ChainedContextualSubtableFormat1 (String id, int sequence, int flags, int format, GlyphCoverageTable coverage, List entries) {
- super (id, sequence, flags, format, coverage, entries);
- populate (entries);
+ ChainedContextualSubtableFormat1(String id, int sequence, int flags, int format, GlyphCoverageTable coverage, List entries) {
+ super(id, sequence, flags, format, coverage, entries);
+ populate(entries);
}
/** {@inheritDoc} */
public List getEntries() {
if (rsa != null) {
- List entries = new ArrayList (1);
- entries.add (rsa);
+ List entries = new ArrayList(1);
+ entries.add(rsa);
return entries;
} else {
return null;
}
}
/** {@inheritDoc} */
- public void resolveLookupReferences (Map/*<String,LookupTable>*/ lookupTables) {
- GlyphTable.resolveLookupReferences (rsa, lookupTables);
+ public void resolveLookupReferences(Map/*<String,LookupTable>*/ lookupTables) {
+ GlyphTable.resolveLookupReferences(rsa, lookupTables);
}
/** {@inheritDoc} */
- public RuleLookup[] getLookups (int ci, int gi, GlyphPositioningState ps, int[] rv) {
+ public RuleLookup[] getLookups(int ci, int gi, GlyphPositioningState ps, int[] rv) {
assert ps != null;
assert (rv != null) && (rv.length > 0);
assert rsa != null;
Rule r = ra [ i ];
if ((r != null) && (r instanceof ChainedGlyphSequenceRule)) {
ChainedGlyphSequenceRule cr = (ChainedGlyphSequenceRule) r;
- int[] iga = cr.getGlyphs (gi);
- if (matches (ps, iga, 0, rv)) {
+ int[] iga = cr.getGlyphs(gi);
+ if (matches(ps, iga, 0, rv)) {
int[] bga = cr.getBacktrackGlyphs();
- if (matches (ps, bga, -1, null)) {
+ if (matches(ps, bga, -1, null)) {
int[] lga = cr.getLookaheadGlyphs();
- if (matches (ps, lga, rv[0], null)) {
+ if (matches(ps, lga, rv[0], null)) {
return r.getLookups();
}
}
}
return null;
}
- private boolean matches (GlyphPositioningState ps, int[] glyphs, int offset, int[] rv) {
- return ContextualSubtableFormat1.matches (ps, glyphs, offset, rv);
+ private boolean matches(GlyphPositioningState ps, int[] glyphs, int offset, int[] rv) {
+ return ContextualSubtableFormat1.matches(ps, glyphs, offset, rv);
}
- private void populate (List entries) {
+ private void populate(List entries) {
if (entries == null) {
- throw new AdvancedTypographicTableFormatException ("illegal entries, must be non-null");
+ throw new AdvancedTypographicTableFormatException("illegal entries, must be non-null");
} else if (entries.size() != 1) {
- throw new AdvancedTypographicTableFormatException ("illegal entries, " + entries.size() + " entries present, but requires 1 entry");
+ throw new AdvancedTypographicTableFormatException("illegal entries, " + entries.size() + " entries present, but requires 1 entry");
} else {
Object o;
if (((o = entries.get(0)) == null) || ! (o instanceof RuleSet[])) {
- throw new AdvancedTypographicTableFormatException ("illegal entries, first entry must be an RuleSet[], but is: " + ((o != null) ? o.getClass() : null));
+ throw new AdvancedTypographicTableFormatException("illegal entries, first entry must be an RuleSet[], but is: " + ((o != null) ? o.getClass() : null));
} else {
rsa = (RuleSet[]) o;
}
private GlyphClassTable lcdt; // lookahead class def table
private int ngc; // class set count
private RuleSet[] rsa; // rule set array, ordered by class number [0...ngc - 1]
- ChainedContextualSubtableFormat2 (String id, int sequence, int flags, int format, GlyphCoverageTable coverage, List entries) {
- super (id, sequence, flags, format, coverage, entries);
- populate (entries);
+ ChainedContextualSubtableFormat2(String id, int sequence, int flags, int format, GlyphCoverageTable coverage, List entries) {
+ super(id, sequence, flags, format, coverage, entries);
+ populate(entries);
}
/** {@inheritDoc} */
public List getEntries() {
if (rsa != null) {
- List entries = new ArrayList (5);
- entries.add (icdt);
- entries.add (bcdt);
- entries.add (lcdt);
- entries.add (Integer.valueOf (ngc));
- entries.add (rsa);
+ List entries = new ArrayList(5);
+ entries.add(icdt);
+ entries.add(bcdt);
+ entries.add(lcdt);
+ entries.add(Integer.valueOf(ngc));
+ entries.add(rsa);
return entries;
} else {
return null;
}
}
/** {@inheritDoc} */
- public void resolveLookupReferences (Map/*<String,LookupTable>*/ lookupTables) {
- GlyphTable.resolveLookupReferences (rsa, lookupTables);
+ public void resolveLookupReferences(Map/*<String,LookupTable>*/ lookupTables) {
+ GlyphTable.resolveLookupReferences(rsa, lookupTables);
}
/** {@inheritDoc} */
- public RuleLookup[] getLookups (int ci, int gi, GlyphPositioningState ps, int[] rv) {
+ public RuleLookup[] getLookups(int ci, int gi, GlyphPositioningState ps, int[] rv) {
assert ps != null;
assert (rv != null) && (rv.length > 0);
assert rsa != null;
Rule r = ra [ i ];
if ((r != null) && (r instanceof ChainedClassSequenceRule)) {
ChainedClassSequenceRule cr = (ChainedClassSequenceRule) r;
- int[] ica = cr.getClasses (icdt.getClassIndex (gi, ps.getClassMatchSet (gi)));
- if (matches (ps, icdt, ica, 0, rv)) {
+ int[] ica = cr.getClasses(icdt.getClassIndex(gi, ps.getClassMatchSet(gi)));
+ if (matches(ps, icdt, ica, 0, rv)) {
int[] bca = cr.getBacktrackClasses();
- if (matches (ps, bcdt, bca, -1, null)) {
+ if (matches(ps, bcdt, bca, -1, null)) {
int[] lca = cr.getLookaheadClasses();
- if (matches (ps, lcdt, lca, rv[0], null)) {
+ if (matches(ps, lcdt, lca, rv[0], null)) {
return r.getLookups();
}
}
}
return null;
}
- private boolean matches (GlyphPositioningState ps, GlyphClassTable cdt, int[] classes, int offset, int[] rv) {
- return ContextualSubtableFormat2.matches (ps, cdt, classes, offset, rv);
+ private boolean matches(GlyphPositioningState ps, GlyphClassTable cdt, int[] classes, int offset, int[] rv) {
+ return ContextualSubtableFormat2.matches(ps, cdt, classes, offset, rv);
}
- private void populate (List entries) {
+ private void populate(List entries) {
if (entries == null) {
- throw new AdvancedTypographicTableFormatException ("illegal entries, must be non-null");
+ throw new AdvancedTypographicTableFormatException("illegal entries, must be non-null");
} else if (entries.size() != 5) {
- throw new AdvancedTypographicTableFormatException ("illegal entries, " + entries.size() + " entries present, but requires 5 entries");
+ throw new AdvancedTypographicTableFormatException("illegal entries, " + entries.size() + " entries present, but requires 5 entries");
} else {
Object o;
if (((o = entries.get(0)) == null) || ! (o instanceof GlyphClassTable)) {
- throw new AdvancedTypographicTableFormatException ("illegal entries, first entry must be an GlyphClassTable, but is: " + ((o != null) ? o.getClass() : null));
+ throw new AdvancedTypographicTableFormatException("illegal entries, first entry must be an GlyphClassTable, but is: " + ((o != null) ? o.getClass() : null));
} else {
icdt = (GlyphClassTable) o;
}
if (((o = entries.get(1)) != null) && ! (o instanceof GlyphClassTable)) {
- throw new AdvancedTypographicTableFormatException ("illegal entries, second entry must be an GlyphClassTable, but is: " + o.getClass());
+ throw new AdvancedTypographicTableFormatException("illegal entries, second entry must be an GlyphClassTable, but is: " + o.getClass());
} else {
bcdt = (GlyphClassTable) o;
}
if (((o = entries.get(2)) != null) && ! (o instanceof GlyphClassTable)) {
- throw new AdvancedTypographicTableFormatException ("illegal entries, third entry must be an GlyphClassTable, but is: " + o.getClass());
+ throw new AdvancedTypographicTableFormatException("illegal entries, third entry must be an GlyphClassTable, but is: " + o.getClass());
} else {
lcdt = (GlyphClassTable) o;
}
if (((o = entries.get(3)) == null) || ! (o instanceof Integer)) {
- throw new AdvancedTypographicTableFormatException ("illegal entries, fourth entry must be an Integer, but is: " + ((o != null) ? o.getClass() : null));
+ throw new AdvancedTypographicTableFormatException("illegal entries, fourth entry must be an Integer, but is: " + ((o != null) ? o.getClass() : null));
} else {
ngc = ((Integer)(o)).intValue();
}
if (((o = entries.get(4)) == null) || ! (o instanceof RuleSet[])) {
- throw new AdvancedTypographicTableFormatException ("illegal entries, fifth entry must be an RuleSet[], but is: " + ((o != null) ? o.getClass() : null));
+ throw new AdvancedTypographicTableFormatException("illegal entries, fifth entry must be an RuleSet[], but is: " + ((o != null) ? o.getClass() : null));
} else {
rsa = (RuleSet[]) o;
if (rsa.length != ngc) {
- throw new AdvancedTypographicTableFormatException ("illegal entries, RuleSet[] length is " + rsa.length + ", but expected " + ngc + " glyph classes");
+ throw new AdvancedTypographicTableFormatException("illegal entries, RuleSet[] length is " + rsa.length + ", but expected " + ngc + " glyph classes");
}
}
}
private static class ChainedContextualSubtableFormat3 extends ChainedContextualSubtable {
private RuleSet[] rsa; // rule set array, containing a single rule set
- ChainedContextualSubtableFormat3 (String id, int sequence, int flags, int format, GlyphCoverageTable coverage, List entries) {
- super (id, sequence, flags, format, coverage, entries);
- populate (entries);
+ ChainedContextualSubtableFormat3(String id, int sequence, int flags, int format, GlyphCoverageTable coverage, List entries) {
+ super(id, sequence, flags, format, coverage, entries);
+ populate(entries);
}
/** {@inheritDoc} */
public List getEntries() {
if (rsa != null) {
- List entries = new ArrayList (1);
- entries.add (rsa);
+ List entries = new ArrayList(1);
+ entries.add(rsa);
return entries;
} else {
return null;
}
}
/** {@inheritDoc} */
- public void resolveLookupReferences (Map/*<String,LookupTable>*/ lookupTables) {
- GlyphTable.resolveLookupReferences (rsa, lookupTables);
+ public void resolveLookupReferences(Map/*<String,LookupTable>*/ lookupTables) {
+ GlyphTable.resolveLookupReferences(rsa, lookupTables);
}
/** {@inheritDoc} */
- public RuleLookup[] getLookups (int ci, int gi, GlyphPositioningState ps, int[] rv) {
+ public RuleLookup[] getLookups(int ci, int gi, GlyphPositioningState ps, int[] rv) {
assert ps != null;
assert (rv != null) && (rv.length > 0);
assert rsa != null;
if ((r != null) && (r instanceof ChainedCoverageSequenceRule)) {
ChainedCoverageSequenceRule cr = (ChainedCoverageSequenceRule) r;
GlyphCoverageTable[] igca = cr.getCoverages();
- if (matches (ps, igca, 0, rv)) {
+ if (matches(ps, igca, 0, rv)) {
GlyphCoverageTable[] bgca = cr.getBacktrackCoverages();
- if (matches (ps, bgca, -1, null)) {
+ if (matches(ps, bgca, -1, null)) {
GlyphCoverageTable[] lgca = cr.getLookaheadCoverages();
- if (matches (ps, lgca, rv[0], null)) {
+ if (matches(ps, lgca, rv[0], null)) {
return r.getLookups();
}
}
}
return null;
}
- private boolean matches (GlyphPositioningState ps, GlyphCoverageTable[] gca, int offset, int[] rv) {
- return ContextualSubtableFormat3.matches (ps, gca, offset, rv);
+ private boolean matches(GlyphPositioningState ps, GlyphCoverageTable[] gca, int offset, int[] rv) {
+ return ContextualSubtableFormat3.matches(ps, gca, offset, rv);
}
- private void populate (List entries) {
+ private void populate(List entries) {
if (entries == null) {
- throw new AdvancedTypographicTableFormatException ("illegal entries, must be non-null");
+ throw new AdvancedTypographicTableFormatException("illegal entries, must be non-null");
} else if (entries.size() != 1) {
- throw new AdvancedTypographicTableFormatException ("illegal entries, " + entries.size() + " entries present, but requires 1 entry");
+ throw new AdvancedTypographicTableFormatException("illegal entries, " + entries.size() + " entries present, but requires 1 entry");
} else {
Object o;
if (((o = entries.get(0)) == null) || ! (o instanceof RuleSet[])) {
- throw new AdvancedTypographicTableFormatException ("illegal entries, first entry must be an RuleSet[], but is: " + ((o != null) ? o.getClass() : null));
+ throw new AdvancedTypographicTableFormatException("illegal entries, first entry must be an RuleSet[], but is: " + ((o != null) ? o.getClass() : null));
} else {
rsa = (RuleSet[]) o;
}
* @param endSize the ending (scaled) size
* @param deltas adjustments for each scaled size
*/
- public DeviceTable (int startSize, int endSize, int[] deltas) {
+ public DeviceTable(int startSize, int endSize, int[] deltas) {
assert startSize >= 0;
assert startSize <= endSize;
assert deltas != null;
* @param fontSize the font size to search for
* @return an adjustment if font size matches an entry
*/
- public int findAdjustment (int fontSize) {
+ public int findAdjustment(int fontSize) {
// [TODO] at present, assumes that 1 device unit equals one point
int fs = fontSize / 1000;
if (fs < startSize) {
/** {@inheritDoc} */
public String toString() {
- return "{ start = " + startSize + ", end = " + endSize + ", deltas = " + Arrays.toString (deltas) + "}";
+ return "{ start = " + startSize + ", end = " + endSize + ", deltas = " + Arrays.toString(deltas) + "}";
}
}
* @param xAdvDevice the x advance device table or null
* @param yAdvDevice the y advance device table or null
*/
- public Value (int xPlacement, int yPlacement, int xAdvance, int yAdvance, DeviceTable xPlaDevice, DeviceTable yPlaDevice, DeviceTable xAdvDevice, DeviceTable yAdvDevice) {
+ public Value(int xPlacement, int yPlacement, int xAdvance, int yAdvance, DeviceTable xPlaDevice, DeviceTable yPlaDevice, DeviceTable xAdvDevice, DeviceTable yAdvDevice) {
this.xPlacement = xPlacement;
this.yPlacement = yPlacement;
this.xAdvance = xAdvance;
* @param xAdvance the x advance or zero
* @param yAdvance the y advance or zero
*/
- public void adjust (int xPlacement, int yPlacement, int xAdvance, int yAdvance) {
+ public void adjust(int xPlacement, int yPlacement, int xAdvance, int yAdvance) {
this.xPlacement += xPlacement;
this.yPlacement += yPlacement;
this.xAdvance += xAdvance;
* @param fontSize font size for device table adjustments
* @return true if some adjustment was made
*/
- public boolean adjust (int[] adjustments, int fontSize) {
+ public boolean adjust(int[] adjustments, int fontSize) {
boolean adjust = false;
int dv;
if ((dv = xPlacement) != 0) {
if (fontSize != 0) {
DeviceTable dt;
if ((dt = xPlaDevice) != null) {
- if ((dv = dt.findAdjustment (fontSize)) != 0) {
+ if ((dv = dt.findAdjustment(fontSize)) != 0) {
adjustments [ IDX_X_PLACEMENT ] += dv;
adjust = true;
}
}
if ((dt = yPlaDevice) != null) {
- if ((dv = dt.findAdjustment (fontSize)) != 0) {
+ if ((dv = dt.findAdjustment(fontSize)) != 0) {
adjustments [ IDX_Y_PLACEMENT ] += dv;
adjust = true;
}
}
if ((dt = xAdvDevice) != null) {
- if ((dv = dt.findAdjustment (fontSize)) != 0) {
+ if ((dv = dt.findAdjustment(fontSize)) != 0) {
adjustments [ IDX_X_ADVANCE ] += dv;
adjust = true;
}
}
if ((dt = yAdvDevice) != null) {
- if ((dv = dt.findAdjustment (fontSize)) != 0) {
+ if ((dv = dt.findAdjustment(fontSize)) != 0) {
adjustments [ IDX_Y_ADVANCE ] += dv;
adjust = true;
}
public String toString() {
StringBuffer sb = new StringBuffer();
boolean first = true;
- sb.append ("{ ");
+ sb.append("{ ");
if (xPlacement != 0) {
if (! first) {
- sb.append (", ");
+ sb.append(", ");
} else {
first = false;
}
- sb.append ("xPlacement = " + xPlacement);
+ sb.append("xPlacement = " + xPlacement);
}
if (yPlacement != 0) {
if (! first) {
- sb.append (", ");
+ sb.append(", ");
} else {
first = false;
}
- sb.append ("yPlacement = " + yPlacement);
+ sb.append("yPlacement = " + yPlacement);
}
if (xAdvance != 0) {
if (! first) {
- sb.append (", ");
+ sb.append(", ");
} else {
first = false;
}
- sb.append ("xAdvance = " + xAdvance);
+ sb.append("xAdvance = " + xAdvance);
}
if (yAdvance != 0) {
if (! first) {
- sb.append (", ");
+ sb.append(", ");
} else {
first = false;
}
- sb.append ("yAdvance = " + yAdvance);
+ sb.append("yAdvance = " + yAdvance);
}
if (xPlaDevice != null) {
if (! first) {
- sb.append (", ");
+ sb.append(", ");
} else {
first = false;
}
- sb.append ("xPlaDevice = " + xPlaDevice);
+ sb.append("xPlaDevice = " + xPlaDevice);
}
if (yPlaDevice != null) {
if (! first) {
- sb.append (", ");
+ sb.append(", ");
} else {
first = false;
}
- sb.append ("xPlaDevice = " + yPlaDevice);
+ sb.append("xPlaDevice = " + yPlaDevice);
}
if (xAdvDevice != null) {
if (! first) {
- sb.append (", ");
+ sb.append(", ");
} else {
first = false;
}
- sb.append ("xAdvDevice = " + xAdvDevice);
+ sb.append("xAdvDevice = " + xAdvDevice);
}
if (yAdvDevice != null) {
if (! first) {
- sb.append (", ");
+ sb.append(", ");
} else {
first = false;
}
- sb.append ("xAdvDevice = " + yAdvDevice);
+ sb.append("xAdvDevice = " + yAdvDevice);
}
sb.append(" }");
return sb.toString();
* @param value1 the value of the first glyph in pair (or null)
* @param value2 the value of the second glyph in pair (or null)
*/
- public PairValues (int glyph, Value value1, Value value2) {
+ public PairValues(int glyph, Value value1, Value value2) {
assert glyph >= 0;
this.glyph = glyph;
this.value1 = value1;
public String toString() {
StringBuffer sb = new StringBuffer();
boolean first = true;
- sb.append ("{ ");
+ sb.append("{ ");
if (glyph != 0) {
if (! first) {
- sb.append (", ");
+ sb.append(", ");
} else {
first = false;
}
- sb.append ("glyph = " + glyph);
+ sb.append("glyph = " + glyph);
}
if (value1 != null) {
if (! first) {
- sb.append (", ");
+ sb.append(", ");
} else {
first = false;
}
- sb.append ("value1 = " + value1);
+ sb.append("value1 = " + value1);
}
if (value2 != null) {
if (! first) {
- sb.append (", ");
+ sb.append(", ");
} else {
first = false;
}
- sb.append ("value2 = " + value2);
+ sb.append("value2 = " + value2);
}
sb.append(" }");
return sb.toString();
* @param x the x coordinate
* @param y the y coordinate
*/
- public Anchor (int x, int y) {
+ public Anchor(int x, int y) {
this (x, y, -1, null, null);
}
* @param y the y coordinate
* @param anchorPoint anchor index (or -1)
*/
- public Anchor (int x, int y, int anchorPoint) {
+ public Anchor(int x, int y, int anchorPoint) {
this (x, y, anchorPoint, null, null);
}
* @param xDevice the x device table (or null if not present)
* @param yDevice the y device table (or null if not present)
*/
- public Anchor (int x, int y, DeviceTable xDevice, DeviceTable yDevice) {
+ public Anchor(int x, int y, DeviceTable xDevice, DeviceTable yDevice) {
this (x, y, -1, xDevice, yDevice);
}
* Instantiate an Anchor based on an existing anchor.
* @param a the existing anchor
*/
- protected Anchor (Anchor a) {
+ protected Anchor(Anchor a) {
this (a.x, a.y, a.anchorPoint, a.xDevice, a.yDevice);
}
- private Anchor (int x, int y, int anchorPoint, DeviceTable xDevice, DeviceTable yDevice) {
+ private Anchor(int x, int y, int anchorPoint, DeviceTable xDevice, DeviceTable yDevice) {
assert (anchorPoint >= 0) || (anchorPoint == -1);
this.x = x;
this.y = y;
* @param a the anchor to align
* @return the adjustment value needed to effect alignment
*/
- public Value getAlignmentAdjustment (Anchor a) {
+ public Value getAlignmentAdjustment(Anchor a) {
assert a != null;
// TODO - handle anchor point
// TODO - handle device tables
- return new Value (x - a.x, y - a.y, 0, 0, null, null, null, null);
+ return new Value(x - a.x, y - a.y, 0, 0, null, null, null, null);
}
/** {@inheritDoc} */
public String toString() {
StringBuffer sb = new StringBuffer();
- sb.append ("{ [" + x + "," + y + "]");
+ sb.append("{ [" + x + "," + y + "]");
if (anchorPoint != -1) {
- sb.append (", anchorPoint = " + anchorPoint);
+ sb.append(", anchorPoint = " + anchorPoint);
}
if (xDevice != null) {
- sb.append (", xDevice = " + xDevice);
+ sb.append(", xDevice = " + xDevice);
}
if (yDevice != null) {
- sb.append (", yDevice = " + yDevice);
+ sb.append(", yDevice = " + yDevice);
}
sb.append(" }");
return sb.toString();
* @param markClass the mark class
* @param a the underlying anchor (whose fields are copied)
*/
- public MarkAnchor (int markClass, Anchor a) {
- super (a);
+ public MarkAnchor(int markClass, Anchor a) {
+ super(a);
this.markClass = markClass;
}
* @param feature feature identifier
* @param sct script context tester (or null)
*/
- protected GlyphProcessingState (GlyphSequence gs, String script, String language, String feature, ScriptContextTester sct) {
+ 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.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); } };
* 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);
+ protected GlyphProcessingState(GlyphProcessingState s) {
+ this (new GlyphSequence(s.igs), s.script, s.language, s.feature, s.sct);
+ setPosition(s.index);
}
/**
* @param feature feature identifier
* @param sct script context tester (or null)
*/
- protected GlyphProcessingState reset (GlyphSequence gs, String script, String language, String feature, ScriptContextTester sct) {
+ protected GlyphProcessingState reset(GlyphSequence gs, String script, String language, String feature, ScriptContextTester sct) {
this.gdef = null;
this.script = script;
this.language = language;
this.lookupFlags = 0;
this.classMatchSet = 0;
this.sct = sct;
- this.gct = (sct != null) ? sct.getTester (feature) : null;
+ 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); } };
* Set governing glyph definition table.
* @param gdef glyph definition table (or null, to unset)
*/
- public void setGDEF (GlyphDefinitionTable gdef) {
+ public void setGDEF(GlyphDefinitionTable gdef) {
if (this.gdef == null) {
this.gdef = gdef;
} else if (gdef == null) {
* Set governing lookup flags
* @param flags lookup flags (or zero, to unset)
*/
- public void setLookupFlags (int flags) {
+ public void setLookupFlags(int flags) {
if (this.lookupFlags == 0) {
this.lookupFlags = flags;
} else if (flags == 0) {
* @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) {
+ public int getClassMatchSet(int gi) {
return 0;
}
* Set default ignore tester.
* @param ignoreDefault glyph tester (or null, to unset)
*/
- public void setIgnoreDefault (GlyphTester ignoreDefault) {
+ public void setIgnoreDefault(GlyphTester ignoreDefault) {
if (this.ignoreDefault == null) {
this.ignoreDefault = ignoreDefault;
} else if (ignoreDefault == null) {
* this state is to be reset.
* @param st glyph subtable to use for update
*/
- public void updateSubtableState (GlyphSubtable st) {
+ public void updateSubtableState(GlyphSubtable st) {
if (this.subtable != st) {
- setGDEF (st.getGDEF());
- setLookupFlags (st.getFlags());
- setIgnoreDefault (getIgnoreTester (getLookupFlags()));
+ setGDEF(st.getGDEF());
+ setLookupFlags(st.getFlags());
+ setIgnoreDefault(getIgnoreTester(getLookupFlags()));
this.subtable = st;
}
}
* @throws IndexOutOfBoundsException if index is less than zero
* or exceeds last valid position
*/
- public void setPosition (int index) throws IndexOutOfBoundsException {
+ public void setPosition(int index) throws IndexOutOfBoundsException {
if ((index >= 0) && (index <= indexLast)) {
this.index = index;
} else {
* @return true if one or more glyph remains
*/
public boolean hasNext() {
- return hasNext (1);
+ return hasNext(1);
}
/**
* @param count of glyphs to test
* @return true if at least <code>count</code> glyphs are available
*/
- public boolean hasNext (int count) {
+ public boolean hasNext(int count) {
return (index + count) <= indexLast;
}
* @return true if one or more glyph remains
*/
public boolean hasPrev() {
- return hasPrev (1);
+ return hasPrev(1);
}
/**
* @param count of glyphs to test
* @return true if at least <code>count</code> glyphs are available
*/
- public boolean hasPrev (int count) {
+ public boolean hasPrev(int count) {
return (index - count) >= 0;
}
* @throws IndexOutOfBoundsException if count would cause consumption
* to exceed count of glyphs in input glyph sequence
*/
- public int consume (int count) throws IndexOutOfBoundsException {
+ public int consume(int count) throws IndexOutOfBoundsException {
if ((consumed + count) <= indexLast) {
consumed += count;
return consumed;
* @return glyph at specified offset from current position
* @throws IndexOutOfBoundsException if no glyph available at offset
*/
- public int getGlyph (int offset) throws IndexOutOfBoundsException {
+ public int getGlyph(int offset) throws IndexOutOfBoundsException {
int i = index + offset;
if ((i >= 0) && (i < indexLast)) {
- return igs.getGlyph (i);
+ return igs.getGlyph(i);
} else {
- throw new IndexOutOfBoundsException ("attempting index at " + i);
+ throw new IndexOutOfBoundsException("attempting index at " + i);
}
}
* @throws IndexOutOfBoundsException if no glyph available
*/
public int getGlyph() throws IndexOutOfBoundsException {
- return getGlyph (0);
+ return getGlyph(0);
}
/**
* @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 {
+ public void setGlyph(int offset, int glyph) throws IndexOutOfBoundsException {
int i = index + offset;
if ((i >= 0) && (i < indexLast)) {
- igs.setGlyph (i, glyph);
+ igs.setGlyph(i, glyph);
} else {
- throw new IndexOutOfBoundsException ("attempting index at " + i);
+ throw new IndexOutOfBoundsException("attempting index at " + i);
}
}
* @return character association of glyph at current position
* @throws IndexOutOfBoundsException if offset results in an invalid index into input glyph sequence
*/
- public GlyphSequence.CharAssociation getAssociation (int offset) throws IndexOutOfBoundsException {
+ public GlyphSequence.CharAssociation getAssociation(int offset) throws IndexOutOfBoundsException {
int i = index + offset;
if ((i >= 0) && (i < indexLast)) {
- return igs.getAssociation (i);
+ return igs.getAssociation(i);
} else {
- throw new IndexOutOfBoundsException ("attempting index at " + i);
+ throw new IndexOutOfBoundsException("attempting index at " + i);
}
}
* @throws IndexOutOfBoundsException if no glyph available
*/
public GlyphSequence.CharAssociation getAssociation() throws IndexOutOfBoundsException {
- return getAssociation (0);
+ return getAssociation(0);
}
/**
* @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 {
+ 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 ];
+ count = getGlyphsAvailable(offset, reverseOrder, ignoreTester) [ 0 ];
}
int start = index + offset;
if (start < 0) {
- throw new IndexOutOfBoundsException ("will attempt index at " + start);
+ throw new IndexOutOfBoundsException("will attempt index at " + start);
} else if (! reverseOrder && ((start + count) > indexLast)) {
- throw new IndexOutOfBoundsException ("will attempt index at " + (start + count));
+ throw new IndexOutOfBoundsException("will attempt index at " + (start + count));
} else if (reverseOrder && ((start + 1) < count)) {
- throw new IndexOutOfBoundsException ("will attempt index at " + (start - 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 + ")");
+ 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);
+ return getGlyphsForward(start, count, ignoreTester, glyphs, counts);
} else {
- return getGlyphsReverse (start, count, ignoreTester, glyphs, counts);
+ return getGlyphsReverse(start, count, ignoreTester, glyphs, counts);
}
}
- private int[] getGlyphsForward (int start, int count, GlyphTester ignoreTester, int[] glyphs, int[] counts) throws IndexOutOfBoundsException {
+ 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);
+ int gi = getGlyph(i - index);
if (gi == 65535) {
ignored++;
} else {
- if ((ignoreTester == null) || ! ignoreTester.test (gi, getLookupFlags())) {
+ if ((ignoreTester == null) || ! ignoreTester.test(gi, getLookupFlags())) {
glyphs [ counted++ ] = gi;
} else {
ignored++;
return glyphs;
}
- private int[] getGlyphsReverse (int start, int count, GlyphTester ignoreTester, int[] glyphs, int[] counts) throws IndexOutOfBoundsException {
+ 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);
+ int gi = getGlyph(i - index);
if (gi == 65535) {
ignored++;
} else {
- if ((ignoreTester == null) || ! ignoreTester.test (gi, getLookupFlags())) {
+ if ((ignoreTester == null) || ! ignoreTester.test(gi, getLookupFlags())) {
glyphs [ counted++ ] = gi;
} else {
ignored++;
* @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);
+ public int[] getGlyphs(int offset, int count, int[] glyphs, int[] counts) throws IndexOutOfBoundsException {
+ return getGlyphs(offset, count, offset < 0, ignoreDefault, glyphs, counts);
}
/**
* @throws IndexOutOfBoundsException if no glyph available
*/
public int[] getGlyphs() throws IndexOutOfBoundsException {
- return getGlyphs (0, indexLast - index, false, null, null, null);
+ return getGlyphs(0, indexLast - index, false, null, null, null);
}
/**
* @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);
+ 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);
}
/**
* @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);
+ public int[] getIgnoredGlyphs(int offset, int count) throws IndexOutOfBoundsException {
+ return getIgnoredGlyphs(offset, count, offset < 0, ignoreDefault, null, null);
}
/**
* @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());
+ public boolean isIgnoredGlyph(int offset, GlyphTester ignoreTester) throws IndexOutOfBoundsException {
+ return (ignoreTester != null) && ignoreTester.test(getGlyph(offset), getLookupFlags());
}
/**
* @throws IndexOutOfBoundsException if offset results in an
* invalid index into input glyph sequence
*/
- public boolean isIgnoredGlyph (int offset) throws IndexOutOfBoundsException {
- return isIgnoredGlyph (offset, ignoreDefault);
+ public boolean isIgnoredGlyph(int offset) throws IndexOutOfBoundsException {
+ return isIgnoredGlyph(offset, ignoreDefault);
}
/**
* invalid index into input glyph sequence
*/
public boolean isIgnoredGlyph() throws IndexOutOfBoundsException {
- return isIgnoredGlyph (getPosition());
+ return isIgnoredGlyph(getPosition());
}
/**
* @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 {
+ 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);
+ return getGlyphsAvailableForward(start, ignoreTester);
} else {
- return getGlyphsAvailableReverse (start, ignoreTester);
+ return getGlyphsAvailableReverse(start, ignoreTester);
}
}
- private int[] getGlyphsAvailableForward (int start, GlyphTester ignoreTester) throws IndexOutOfBoundsException {
+ 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);
+ int gi = getGlyph(i - index);
if (gi == 65535) {
ignored++;
} else {
- if (ignoreTester.test (gi, getLookupFlags())) {
+ if (ignoreTester.test(gi, getLookupFlags())) {
ignored++;
} else {
counted++;
return new int[] { counted, ignored };
}
- private int[] getGlyphsAvailableReverse (int start, GlyphTester ignoreTester) throws IndexOutOfBoundsException {
+ 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);
+ int gi = getGlyph(i - index);
if (gi == 65535) {
ignored++;
} else {
- if (ignoreTester.test (gi, getLookupFlags())) {
+ if (ignoreTester.test(gi, getLookupFlags())) {
ignored++;
} else {
counted++;
* @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);
+ public int[] getGlyphsAvailable(int offset, boolean reverseOrder) throws IndexOutOfBoundsException {
+ return getGlyphsAvailable(offset, reverseOrder, ignoreDefault);
}
/**
* @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);
+ public int[] getGlyphsAvailable(int offset) throws IndexOutOfBoundsException {
+ return getGlyphsAvailable(offset, offset < 0);
}
/**
* @throws IndexOutOfBoundsException if offset or count results in an
* invalid index into input glyph sequence
*/
- public GlyphSequence.CharAssociation[] getAssociations (int offset, int count, boolean reverseOrder, GlyphTester ignoreTester, GlyphSequence.CharAssociation[] associations, int[] counts)
+ public GlyphSequence.CharAssociation[] getAssociations(int offset, int count, boolean reverseOrder, GlyphTester ignoreTester, GlyphSequence.CharAssociation[] associations, int[] counts)
throws IndexOutOfBoundsException {
if (count < 0) {
- count = getGlyphsAvailable (offset, reverseOrder, ignoreTester) [ 0 ];
+ count = getGlyphsAvailable(offset, reverseOrder, ignoreTester) [ 0 ];
}
int start = index + offset;
if (start < 0) {
- throw new IndexOutOfBoundsException ("will attempt index at " + start);
+ throw new IndexOutOfBoundsException("will attempt index at " + start);
} else if (! reverseOrder && ((start + count) > indexLast)) {
- throw new IndexOutOfBoundsException ("will attempt index at " + (start + count));
+ throw new IndexOutOfBoundsException("will attempt index at " + (start + count));
} else if (reverseOrder && ((start + 1) < count)) {
- throw new IndexOutOfBoundsException ("will attempt index at " + (start - count));
+ throw new IndexOutOfBoundsException("will attempt index at " + (start - count));
}
if (associations == null) {
associations = new GlyphSequence.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 + ")");
+ 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);
+ return getAssociationsForward(start, count, ignoreTester, associations, counts);
} else {
- return getAssociationsReverse (start, count, ignoreTester, associations, counts);
+ return getAssociationsReverse(start, count, ignoreTester, associations, counts);
}
}
- private GlyphSequence.CharAssociation[] getAssociationsForward (int start, int count, GlyphTester ignoreTester, GlyphSequence.CharAssociation[] associations, int[] counts)
+ private GlyphSequence.CharAssociation[] getAssociationsForward(int start, int count, GlyphTester ignoreTester, GlyphSequence.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);
+ int gi = getGlyph(i - index);
if (gi == 65535) {
ignored++;
} else {
- if ((ignoreTester == null) || ! ignoreTester.test (gi, getLookupFlags())) {
+ if ((ignoreTester == null) || ! ignoreTester.test(gi, getLookupFlags())) {
if (k < count) {
- associations [ k++ ] = getAssociation (i - index);
+ associations [ k++ ] = getAssociation(i - index);
counted++;
} else {
break;
return associations;
}
- private GlyphSequence.CharAssociation[] getAssociationsReverse (int start, int count, GlyphTester ignoreTester, GlyphSequence.CharAssociation[] associations, int[] counts)
+ private GlyphSequence.CharAssociation[] getAssociationsReverse(int start, int count, GlyphTester ignoreTester, GlyphSequence.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);
+ int gi = getGlyph(i - index);
if (gi == 65535) {
ignored++;
} else {
- if ((ignoreTester == null) || ! ignoreTester.test (gi, getLookupFlags())) {
+ if ((ignoreTester == null) || ! ignoreTester.test(gi, getLookupFlags())) {
if (k < count) {
- associations [ k++ ] = getAssociation (i - index);
+ associations [ k++ ] = getAssociation(i - index);
counted++;
} else {
break;
* @throws IndexOutOfBoundsException if offset or count results in an
* invalid index into input glyph sequence
*/
- public GlyphSequence.CharAssociation[] getAssociations (int offset, int count) throws IndexOutOfBoundsException {
- return getAssociations (offset, count, offset < 0, ignoreDefault, null, null);
+ public GlyphSequence.CharAssociation[] getAssociations(int offset, int count) throws IndexOutOfBoundsException {
+ return getAssociations(offset, count, offset < 0, ignoreDefault, null, null);
}
/**
* @throws IndexOutOfBoundsException if offset or count results in an
* invalid index into input glyph sequence
*/
- public GlyphSequence.CharAssociation[] getIgnoredAssociations (int offset, int count, boolean reverseOrder, GlyphTester ignoreTester, GlyphSequence.CharAssociation[] associations, int[] counts)
+ public GlyphSequence.CharAssociation[] getIgnoredAssociations(int offset, int count, boolean reverseOrder, GlyphTester ignoreTester, GlyphSequence.CharAssociation[] associations, int[] counts)
throws IndexOutOfBoundsException {
- return getAssociations (offset, count, reverseOrder, new NotGlyphTester (ignoreTester), associations, counts);
+ return getAssociations(offset, count, reverseOrder, new NotGlyphTester(ignoreTester), associations, counts);
}
/**
* @throws IndexOutOfBoundsException if offset or count results in an
* invalid index into input glyph sequence
*/
- public GlyphSequence.CharAssociation[] getIgnoredAssociations (int offset, int count) throws IndexOutOfBoundsException {
- return getIgnoredAssociations (offset, count, offset < 0, ignoreDefault, null, null);
+ public GlyphSequence.CharAssociation[] getIgnoredAssociations(int offset, int count) throws IndexOutOfBoundsException {
+ return getIgnoredAssociations(offset, count, offset < 0, ignoreDefault, null, null);
}
/**
* @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 {
+ 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) {
gsCount = nrg - gsOffset;
}
int ng = nig + gsCount - count;
- IntBuffer gb = IntBuffer.allocate (ng);
- List al = new ArrayList (ng);
+ 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));
+ 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));
+ 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.put(igs.getGlyph(i));
+ al.add(igs.getAssociation(i));
}
gb.flip();
- if (igs.compareGlyphs (gb) != 0) {
- this.igs = new GlyphSequence (igs.getCharacters(), gb, al);
+ if (igs.compareGlyphs(gb) != 0) {
+ this.igs = new GlyphSequence(igs.getCharacters(), gb, al);
this.indexLast = gb.limit();
return true;
} else {
* @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());
+ public boolean replaceInput(int offset, int count, GlyphSequence gs) throws IndexOutOfBoundsException {
+ return replaceInput(offset, count, gs, 0, gs.getGlyphCount());
}
/**
* @throws IndexOutOfBoundsException if offset or count results in an
* invalid index into input glyph sequence
*/
- public int erase (int offset, int[] glyphs) throws IndexOutOfBoundsException {
+ 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);
+ 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);
+ int gi = getGlyph(i);
if (gi == glyphs [ erased ]) {
- setGlyph (i, 65535);
+ setGlyph(i, 65535);
erased++;
}
}
if (gct == null) {
return true;
} else {
- return gct.test (script, language, feature, igs, index, getLookupFlags());
+ return gct.test(script, language, feature, igs, index, getLookupFlags());
}
}
* @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) {
+ public boolean isBase(int gi) {
if (gdef != null) {
- return gdef.isGlyphClass (gi, GlyphDefinitionTable.GLYPH_CLASS_BASE);
+ return gdef.isGlyphClass(gi, GlyphDefinitionTable.GLYPH_CLASS_BASE);
} else {
return false;
}
* @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);
+ public boolean isIgnoredBase(int gi, int flags) {
+ return ((flags & GlyphSubtable.LF_IGNORE_BASE) != 0) && isBase(gi);
}
/**
* @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) {
+ public boolean isLigature(int gi) {
if (gdef != null) {
- return gdef.isGlyphClass (gi, GlyphDefinitionTable.GLYPH_CLASS_LIGATURE);
+ return gdef.isGlyphClass(gi, GlyphDefinitionTable.GLYPH_CLASS_LIGATURE);
} else {
return false;
}
* @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);
+ public boolean isIgnoredLigature(int gi, int flags) {
+ return ((flags & GlyphSubtable.LF_IGNORE_LIGATURE) != 0) && isLigature(gi);
}
/**
* @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) {
+ public boolean isMark(int gi) {
if (gdef != null) {
- return gdef.isGlyphClass (gi, GlyphDefinitionTable.GLYPH_CLASS_MARK);
+ return gdef.isGlyphClass(gi, GlyphDefinitionTable.GLYPH_CLASS_MARK);
} else {
return false;
}
* @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) {
+ public boolean isIgnoredMark(int gi, int flags) {
if ((flags & GlyphSubtable.LF_IGNORE_MARK) != 0) {
- return isMark (gi);
+ 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);
+ int gac = gdef.getMarkAttachClass(gi);
return (gac != lac);
} else {
return false;
* @param flags lookup flags
* @return a glyph tester
*/
- public GlyphTester getIgnoreTester (int flags) {
+ 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);
+ 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);
+ 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 getCombinedIgnoreTester(flags);
}
}
return null;
* @param flags lookup flags
* @return a glyph tester
*/
- public GlyphTester getCombinedIgnoreTester (int flags) {
+ public GlyphTester getCombinedIgnoreTester(int flags) {
GlyphTester[] gta = new GlyphTester [ 3 ];
int ngt = 0;
if ((flags & GlyphSubtable.LF_IGNORE_BASE) != 0) {
if ((flags & GlyphSubtable.LF_IGNORE_MARK) != 0) {
gta [ ngt++ ] = ignoreMark;
}
- return getCombinedOrTester (gta, ngt);
+ return getCombinedOrTester(gta, ngt);
}
/**
* @param ngt number of glyph testers present in specified array
* @return a combined OR glyph tester
*/
- public GlyphTester getCombinedOrTester (GlyphTester[] gta, int ngt) {
+ public GlyphTester getCombinedOrTester(GlyphTester[] gta, int ngt) {
if (ngt > 0) {
- return new CombinedOrGlyphTester (gta, ngt);
+ return new CombinedOrGlyphTester(gta, ngt);
} else {
return null;
}
* @param ngt number of glyph testers present in specified array
* @return a combined AND glyph tester
*/
- public GlyphTester getCombinedAndTester (GlyphTester[] gta, int ngt) {
+ public GlyphTester getCombinedAndTester(GlyphTester[] gta, int ngt) {
if (ngt > 0) {
- return new CombinedAndGlyphTester (gta, ngt);
+ return new CombinedAndGlyphTester(gta, ngt);
} else {
return null;
}
private static class CombinedOrGlyphTester implements GlyphTester {
private GlyphTester[] gta;
private int ngt;
- CombinedOrGlyphTester (GlyphTester[] gta, int ngt) {
+ CombinedOrGlyphTester(GlyphTester[] gta, int ngt) {
this.gta = gta;
this.ngt = ngt;
}
/** {@inheritDoc} */
- public boolean test (int gi, int flags) {
+ 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)) {
+ if (gt.test(gi, flags)) {
return true;
}
}
private static class CombinedAndGlyphTester implements GlyphTester {
private GlyphTester[] gta;
private int ngt;
- CombinedAndGlyphTester (GlyphTester[] gta, int ngt) {
+ CombinedAndGlyphTester(GlyphTester[] gta, int ngt) {
this.gta = gta;
this.ngt = ngt;
}
/** {@inheritDoc} */
- public boolean test (int gi, int flags) {
+ 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)) {
+ if (! gt.test(gi, flags)) {
return false;
}
}
/** NOT glyph tester */
private static class NotGlyphTester implements GlyphTester {
private GlyphTester gt;
- NotGlyphTester (GlyphTester gt) {
+ NotGlyphTester(GlyphTester gt) {
this.gt = gt;
}
/** {@inheritDoc} */
- public boolean test (int gi, int flags) {
+ public boolean test(int gi, int flags) {
if (gt != null) {
- if (gt.test (gi, flags)) {
+ if (gt.test(gi, flags)) {
return false;
}
}
* @return true if the glyph subtable was applied, meaning that the current context matches the
* associated input context glyph coverage table
*/
- boolean substitute (GlyphSubstitutionState ss);
+ boolean substitute(GlyphSubstitutionState ss);
}
* @param feature feature identifier
* @param sct script context tester (or null)
*/
- public GlyphSubstitutionState (GlyphSequence gs, String script, String language, String feature, ScriptContextTester sct) {
- super (gs, script, language, feature, sct);
- this.ogb = IntBuffer.allocate (gs.getGlyphCount());
- this.oal = new ArrayList (gs.getGlyphCount());
+ public GlyphSubstitutionState(GlyphSequence gs, String script, String language, String feature, ScriptContextTester sct) {
+ super(gs, script, language, feature, sct);
+ this.ogb = IntBuffer.allocate(gs.getGlyphCount());
+ this.oal = new ArrayList(gs.getGlyphCount());
this.predications = gs.getPredications();
}
* except as follows: input glyph sequence is copied deep except for its characters array.
* @param ss existing positioning state to copy from
*/
- public GlyphSubstitutionState (GlyphSubstitutionState ss) {
- super (ss);
- this.ogb = IntBuffer.allocate (indexLast);
- this.oal = new ArrayList (indexLast);
+ public GlyphSubstitutionState(GlyphSubstitutionState ss) {
+ super(ss);
+ this.ogb = IntBuffer.allocate(indexLast);
+ this.oal = new ArrayList(indexLast);
}
/**
* @param feature feature identifier
* @param sct script context tester (or null)
*/
- public GlyphSubstitutionState reset (GlyphSequence gs, String script, String language, String feature, ScriptContextTester sct) {
- super.reset (gs, script, language, feature, sct);
+ public GlyphSubstitutionState reset(GlyphSequence gs, String script, String language, String feature, ScriptContextTester sct) {
+ super.reset(gs, script, language, feature, sct);
this.alternatesIndex = null;
- this.ogb = IntBuffer.allocate (gs.getGlyphCount());
- this.oal = new ArrayList (gs.getGlyphCount());
+ this.ogb = IntBuffer.allocate(gs.getGlyphCount());
+ this.oal = new ArrayList(gs.getGlyphCount());
this.predications = gs.getPredications();
return this;
}
* Set alternates indices.
* @param alternates array of alternates indices ordered by coverage index
*/
- public void setAlternates (int[] alternates) {
+ public void setAlternates(int[] alternates) {
this.alternatesIndex = alternates;
}
* @param ci coverage index
* @return an alternates index
*/
- public int getAlternatesIndex (int ci) {
+ public int getAlternatesIndex(int ci) {
if (alternatesIndex == null) {
return 0;
} else if ((ci < 0) || (ci > alternatesIndex.length)) {
* @param a character association that applies to glyph
* @param predication a predication value to add to association A if predications enabled
*/
- public void putGlyph (int glyph, GlyphSequence.CharAssociation a, Object predication) {
+ public void putGlyph(int glyph, GlyphSequence.CharAssociation a, Object predication) {
if (! ogb.hasRemaining()) {
- ogb = growBuffer (ogb);
+ ogb = growBuffer(ogb);
}
- ogb.put (glyph);
+ ogb.put(glyph);
if (predications && (predication != null)) {
- a.setPredication (feature, predication);
+ a.setPredication(feature, predication);
}
- oal.add (a);
+ oal.add(a);
}
/**
* @param associations array of character associations that apply to glyphs
* @param predication optional predicaion object to be associated with glyphs' associations
*/
- public void putGlyphs (int[] glyphs, GlyphSequence.CharAssociation[] associations, Object predication) {
+ public void putGlyphs(int[] glyphs, GlyphSequence.CharAssociation[] associations, Object predication) {
assert glyphs != null;
assert associations != null;
assert associations.length >= glyphs.length;
for (int i = 0, n = glyphs.length; i < n; i++) {
- putGlyph (glyphs [ i ], associations [ i ], predication);
+ putGlyph(glyphs [ i ], associations [ i ], predication);
}
}
public GlyphSequence getOutput() {
int position = ogb.position();
if (position > 0) {
- ogb.limit (position);
+ ogb.limit(position);
ogb.rewind();
- return new GlyphSequence (igs.getCharacters(), ogb, oal);
+ return new GlyphSequence(igs.getCharacters(), ogb, oal);
} else {
return igs;
}
* @return true if subtable applied, or false if it did not (e.g., its
* input coverage table did not match current input context)
*/
- public boolean apply (GlyphSubstitutionSubtable st) {
+ public boolean apply(GlyphSubstitutionSubtable st) {
assert st != null;
- updateSubtableState (st);
- boolean applied = st.substitute (this);
+ updateSubtableState(st);
+ boolean applied = st.substitute(this);
return applied;
}
* the lookups are to apply, and to be consumed once the application has finished
* @return true if lookups are non-null and non-empty; otherwise, false
*/
- public boolean apply (GlyphTable.RuleLookup[] lookups, int nig) {
+ public boolean apply(GlyphTable.RuleLookup[] lookups, int nig) {
// int nbg = index;
int nlg = indexLast - (index + nig);
int nog = 0;
GlyphTable.LookupTable lt = l.getLookup();
if (lt != null) {
// perform substitution on a copy of previous state
- GlyphSubstitutionState ss = new GlyphSubstitutionState (this);
+ GlyphSubstitutionState ss = new GlyphSubstitutionState(this);
// apply lookup table substitutions
- GlyphSequence gs = lt.substitute (ss, l.getSequenceIndex());
+ GlyphSequence gs = lt.substitute(ss, l.getSequenceIndex());
// replace current input sequence starting at current position with result
- if (replaceInput (0, -1, gs)) {
+ if (replaceInput(0, -1, gs)) {
nog = gs.getGlyphCount() - nlg;
}
}
}
}
// output glyphs and associations
- putGlyphs (getGlyphs (0, nog, false, null, null, null), getAssociations (0, nog, false, null, null, null), null);
+ putGlyphs(getGlyphs(0, nog, false, null, null, null), getAssociations(0, nog, false, null, null, null), null);
// consume replaced input glyphs
- consume (nog);
+ consume(nog);
return true;
} else {
return false;
super.applyDefault();
int gi = getGlyph();
if (gi != 65535) {
- putGlyph (gi, getAssociation(), null);
+ putGlyph(gi, getAssociation(), null);
}
}
- private static IntBuffer growBuffer (IntBuffer ib) {
+ private static IntBuffer growBuffer(IntBuffer ib) {
int capacity = ib.capacity();
int capacityNew = capacity * 2;
- IntBuffer ibNew = IntBuffer.allocate (capacityNew);
+ IntBuffer ibNew = IntBuffer.allocate(capacityNew);
ib.rewind();
- return ibNew.put (ib);
+ return ibNew.put(ib);
}
}
* @param format subtable format
* @param coverage subtable coverage table
*/
- protected GlyphSubstitutionSubtable (String id, int sequence, int flags, int format, GlyphCoverageTable coverage) {
- super (id, sequence, flags, format, coverage);
+ protected GlyphSubstitutionSubtable(String id, int sequence, int flags, int format, GlyphCoverageTable coverage) {
+ super(id, sequence, flags, format, coverage);
}
/** {@inheritDoc} */
/** {@inheritDoc} */
public String getTypeName() {
- return GlyphSubstitutionTable.getLookupTypeName (getType());
+ return GlyphSubstitutionTable.getLookupTypeName(getType());
}
/** {@inheritDoc} */
- public boolean isCompatible (GlyphSubtable subtable) {
+ public boolean isCompatible(GlyphSubtable subtable) {
return subtable instanceof GlyphSubstitutionSubtable;
}
}
/** {@inheritDoc} */
- public boolean substitute (GlyphSubstitutionState ss) {
+ public boolean substitute(GlyphSubstitutionState ss) {
return false;
}
* @param sequenceIndex if non negative, then apply subtables only at specified sequence index
* @return output glyph sequence
*/
- public static final GlyphSequence substitute (GlyphSubstitutionState ss, GlyphSubstitutionSubtable[] sta, int sequenceIndex) {
+ public static final GlyphSequence substitute(GlyphSubstitutionState ss, GlyphSubstitutionSubtable[] sta, int sequenceIndex) {
int sequenceStart = ss.getPosition();
boolean appliedOneShot = false;
while (ss.hasNext()) {
if (! appliedOneShot && ss.maybeApplicable()) {
for (int i = 0, n = sta.length; ! applied && (i < n); i++) {
if (sequenceIndex < 0) {
- applied = ss.apply (sta [ i ]);
+ applied = ss.apply(sta [ i ]);
} else if (ss.getPosition() == (sequenceStart + sequenceIndex)) {
- applied = ss.apply (sta [ i ]);
+ applied = ss.apply(sta [ i ]);
if (applied) {
appliedOneShot = true;
}
* @param sct script context tester
* @return output glyph sequence
*/
- public static final GlyphSequence substitute (GlyphSequence gs, String script, String language, String feature, GlyphSubstitutionSubtable[] sta, ScriptContextTester sct) {
+ public static final GlyphSequence substitute(GlyphSequence gs, String script, String language, String feature, GlyphSubstitutionSubtable[] sta, ScriptContextTester sct) {
synchronized (state) {
- return substitute (state.reset (gs, script, language, feature, sct), sta, -1);
+ return substitute(state.reset(gs, script, language, feature, sct), sta, -1);
}
}
* @param lookups a map of lookup specifications to subtable identifier strings
* @param subtables a list of identified subtables
*/
- public GlyphSubstitutionTable (GlyphDefinitionTable gdef, Map lookups, List subtables) {
- super (gdef, lookups);
+ public GlyphSubstitutionTable(GlyphDefinitionTable gdef, Map lookups, List subtables) {
+ super(gdef, lookups);
if ((subtables == null) || (subtables.size() == 0)) {
- throw new AdvancedTypographicTableFormatException ("subtables must be non-empty");
+ throw new AdvancedTypographicTableFormatException("subtables must be non-empty");
} else {
for (Iterator it = subtables.iterator(); it.hasNext();) {
Object o = it.next();
if (o instanceof GlyphSubstitutionSubtable) {
- addSubtable ((GlyphSubtable) o);
+ addSubtable((GlyphSubtable) o);
} else {
- throw new AdvancedTypographicTableFormatException ("subtable must be a glyph substitution subtable");
+ throw new AdvancedTypographicTableFormatException("subtable must be a glyph substitution subtable");
}
}
freezeSubtables();
* @param language a language identifier
* @return the substituted (output) glyph sequence
*/
- public GlyphSequence substitute (GlyphSequence gs, String script, String language) {
+ public GlyphSequence substitute(GlyphSequence gs, String script, String language) {
GlyphSequence ogs;
- Map/*<LookupSpec,List<LookupTable>>*/ lookups = matchLookups (script, language, "*");
+ Map/*<LookupSpec,List<LookupTable>>*/ lookups = matchLookups(script, language, "*");
if ((lookups != null) && (lookups.size() > 0)) {
- ScriptProcessor sp = ScriptProcessor.getInstance (script);
- ogs = sp.substitute (this, gs, script, language, lookups);
+ ScriptProcessor sp = ScriptProcessor.getInstance(script);
+ ogs = sp.substitute(this, gs, script, language, lookups);
} else {
ogs = gs;
}
* @param name lookup type name
* @return lookup type
*/
- public static int getLookupTypeFromName (String name) {
+ public static int getLookupTypeFromName(String name) {
int t;
String s = name.toLowerCase();
- if ("single".equals (s)) {
+ if ("single".equals(s)) {
t = GSUB_LOOKUP_TYPE_SINGLE;
- } else if ("multiple".equals (s)) {
+ } else if ("multiple".equals(s)) {
t = GSUB_LOOKUP_TYPE_MULTIPLE;
- } else if ("alternate".equals (s)) {
+ } else if ("alternate".equals(s)) {
t = GSUB_LOOKUP_TYPE_ALTERNATE;
- } else if ("ligature".equals (s)) {
+ } else if ("ligature".equals(s)) {
t = GSUB_LOOKUP_TYPE_LIGATURE;
- } else if ("contextual".equals (s)) {
+ } else if ("contextual".equals(s)) {
t = GSUB_LOOKUP_TYPE_CONTEXTUAL;
- } else if ("chainedcontextual".equals (s)) {
+ } else if ("chainedcontextual".equals(s)) {
t = GSUB_LOOKUP_TYPE_CHAINED_CONTEXTUAL;
- } else if ("extensionsubstitution".equals (s)) {
+ } else if ("extensionsubstitution".equals(s)) {
t = GSUB_LOOKUP_TYPE_EXTENSION_SUBSTITUTION;
- } else if ("reversechainiingcontextualsingle".equals (s)) {
+ } else if ("reversechainiingcontextualsingle".equals(s)) {
t = GSUB_LOOKUP_TYPE_REVERSE_CHAINED_SINGLE;
} else {
t = -1;
* @param type lookup type
* @return lookup type name
*/
- public static String getLookupTypeName (int type) {
+ public static String getLookupTypeName(int type) {
String tn = null;
switch (type) {
case GSUB_LOOKUP_TYPE_SINGLE:
* @param entries subtable entries
* @return a glyph subtable instance
*/
- public static GlyphSubtable createSubtable (int type, String id, int sequence, int flags, int format, GlyphCoverageTable coverage, List entries) {
+ public static GlyphSubtable createSubtable(int type, String id, int sequence, int flags, int format, GlyphCoverageTable coverage, List entries) {
GlyphSubtable st = null;
switch (type) {
case GSUB_LOOKUP_TYPE_SINGLE:
- st = SingleSubtable.create (id, sequence, flags, format, coverage, entries);
+ st = SingleSubtable.create(id, sequence, flags, format, coverage, entries);
break;
case GSUB_LOOKUP_TYPE_MULTIPLE:
- st = MultipleSubtable.create (id, sequence, flags, format, coverage, entries);
+ st = MultipleSubtable.create(id, sequence, flags, format, coverage, entries);
break;
case GSUB_LOOKUP_TYPE_ALTERNATE:
- st = AlternateSubtable.create (id, sequence, flags, format, coverage, entries);
+ st = AlternateSubtable.create(id, sequence, flags, format, coverage, entries);
break;
case GSUB_LOOKUP_TYPE_LIGATURE:
- st = LigatureSubtable.create (id, sequence, flags, format, coverage, entries);
+ st = LigatureSubtable.create(id, sequence, flags, format, coverage, entries);
break;
case GSUB_LOOKUP_TYPE_CONTEXTUAL:
- st = ContextualSubtable.create (id, sequence, flags, format, coverage, entries);
+ st = ContextualSubtable.create(id, sequence, flags, format, coverage, entries);
break;
case GSUB_LOOKUP_TYPE_CHAINED_CONTEXTUAL:
- st = ChainedContextualSubtable.create (id, sequence, flags, format, coverage, entries);
+ st = ChainedContextualSubtable.create(id, sequence, flags, format, coverage, entries);
break;
case GSUB_LOOKUP_TYPE_REVERSE_CHAINED_SINGLE:
- st = ReverseChainedSingleSubtable.create (id, sequence, flags, format, coverage, entries);
+ st = ReverseChainedSingleSubtable.create(id, sequence, flags, format, coverage, entries);
break;
default:
break;
* @param entries subtable entries
* @return a glyph subtable instance
*/
- public static GlyphSubtable createSubtable (int type, String id, int sequence, int flags, int format, List coverage, List entries) {
- return createSubtable (type, id, sequence, flags, format, GlyphCoverageTable.createCoverageTable (coverage), entries);
+ public static GlyphSubtable createSubtable(int type, String id, int sequence, int flags, int format, List coverage, List entries) {
+ return createSubtable(type, id, sequence, flags, format, GlyphCoverageTable.createCoverageTable(coverage), entries);
}
private abstract static class SingleSubtable extends GlyphSubstitutionSubtable {
- SingleSubtable (String id, int sequence, int flags, int format, GlyphCoverageTable coverage, List entries) {
- super (id, sequence, flags, format, coverage);
+ SingleSubtable(String id, int sequence, int flags, int format, GlyphCoverageTable coverage, List entries) {
+ super(id, sequence, flags, format, coverage);
}
/** {@inheritDoc} */
public int getType() {
return GSUB_LOOKUP_TYPE_SINGLE;
}
/** {@inheritDoc} */
- public boolean isCompatible (GlyphSubtable subtable) {
+ public boolean isCompatible(GlyphSubtable subtable) {
return subtable instanceof SingleSubtable;
}
/** {@inheritDoc} */
- public boolean substitute (GlyphSubstitutionState ss) {
+ public boolean substitute(GlyphSubstitutionState ss) {
int gi = ss.getGlyph();
int ci;
- if ((ci = getCoverageIndex (gi)) < 0) {
+ if ((ci = getCoverageIndex(gi)) < 0) {
return false;
} else {
- int go = getGlyphForCoverageIndex (ci, gi);
+ int go = getGlyphForCoverageIndex(ci, gi);
if ((go < 0) || (go > 65535)) {
go = 65535;
}
- ss.putGlyph (go, ss.getAssociation(), Boolean.TRUE);
+ ss.putGlyph(go, ss.getAssociation(), Boolean.TRUE);
ss.consume(1);
return true;
}
* @return substituted glyph value
* @throws IllegalArgumentException if coverage index is not valid
*/
- public abstract int getGlyphForCoverageIndex (int ci, int gi) throws IllegalArgumentException;
- static GlyphSubstitutionSubtable create (String id, int sequence, int flags, int format, GlyphCoverageTable coverage, List entries) {
+ public abstract int getGlyphForCoverageIndex(int ci, int gi) throws IllegalArgumentException;
+ static GlyphSubstitutionSubtable create(String id, int sequence, int flags, int format, GlyphCoverageTable coverage, List entries) {
if (format == 1) {
- return new SingleSubtableFormat1 (id, sequence, flags, format, coverage, entries);
+ return new SingleSubtableFormat1(id, sequence, flags, format, coverage, entries);
} else if (format == 2) {
- return new SingleSubtableFormat2 (id, sequence, flags, format, coverage, entries);
+ return new SingleSubtableFormat2(id, sequence, flags, format, coverage, entries);
} else {
throw new UnsupportedOperationException();
}
private static class SingleSubtableFormat1 extends SingleSubtable {
private int delta;
private int ciMax;
- SingleSubtableFormat1 (String id, int sequence, int flags, int format, GlyphCoverageTable coverage, List entries) {
- super (id, sequence, flags, format, coverage, entries);
- populate (entries);
+ SingleSubtableFormat1(String id, int sequence, int flags, int format, GlyphCoverageTable coverage, List entries) {
+ super(id, sequence, flags, format, coverage, entries);
+ populate(entries);
}
/** {@inheritDoc} */
public List getEntries() {
- List entries = new ArrayList (1);
- entries.add (Integer.valueOf (delta));
+ List entries = new ArrayList(1);
+ entries.add(Integer.valueOf(delta));
return entries;
}
/** {@inheritDoc} */
- public int getGlyphForCoverageIndex (int ci, int gi) throws IllegalArgumentException {
+ public int getGlyphForCoverageIndex(int ci, int gi) throws IllegalArgumentException {
if (ci <= ciMax) {
return gi + delta;
} else {
- throw new IllegalArgumentException ("coverage index " + ci + " out of range, maximum coverage index is " + ciMax);
+ throw new IllegalArgumentException("coverage index " + ci + " out of range, maximum coverage index is " + ciMax);
}
}
- private void populate (List entries) {
+ private void populate(List entries) {
if ((entries == null) || (entries.size() != 1)) {
- throw new AdvancedTypographicTableFormatException ("illegal entries, must be non-null and contain exactly one entry");
+ throw new AdvancedTypographicTableFormatException("illegal entries, must be non-null and contain exactly one entry");
} else {
Object o = entries.get(0);
int delta = 0;
if (o instanceof Integer) {
delta = ((Integer) o) . intValue();
} else {
- throw new AdvancedTypographicTableFormatException ("illegal entries entry, must be Integer, but is: " + o);
+ throw new AdvancedTypographicTableFormatException("illegal entries entry, must be Integer, but is: " + o);
}
this.delta = delta;
this.ciMax = getCoverageSize() - 1;
private static class SingleSubtableFormat2 extends SingleSubtable {
private int[] glyphs;
- SingleSubtableFormat2 (String id, int sequence, int flags, int format, GlyphCoverageTable coverage, List entries) {
- super (id, sequence, flags, format, coverage, entries);
- populate (entries);
+ SingleSubtableFormat2(String id, int sequence, int flags, int format, GlyphCoverageTable coverage, List entries) {
+ super(id, sequence, flags, format, coverage, entries);
+ populate(entries);
}
/** {@inheritDoc} */
public List getEntries() {
- List entries = new ArrayList (glyphs.length);
+ List entries = new ArrayList(glyphs.length);
for (int i = 0, n = glyphs.length; i < n; i++) {
- entries.add (Integer.valueOf (glyphs[i]));
+ entries.add(Integer.valueOf(glyphs[i]));
}
return entries;
}
/** {@inheritDoc} */
- public int getGlyphForCoverageIndex (int ci, int gi) throws IllegalArgumentException {
+ public int getGlyphForCoverageIndex(int ci, int gi) throws IllegalArgumentException {
if (glyphs == null) {
return -1;
} else if (ci >= glyphs.length) {
- throw new IllegalArgumentException ("coverage index " + ci + " out of range, maximum coverage index is " + glyphs.length);
+ throw new IllegalArgumentException("coverage index " + ci + " out of range, maximum coverage index is " + glyphs.length);
} else {
return glyphs [ ci ];
}
}
- private void populate (List entries) {
+ private void populate(List entries) {
int i = 0;
int n = entries.size();
int[] glyphs = new int [ n ];
if ((gid >= 0) && (gid < 65536)) {
glyphs [ i++ ] = gid;
} else {
- throw new AdvancedTypographicTableFormatException ("illegal glyph index: " + gid);
+ throw new AdvancedTypographicTableFormatException("illegal glyph index: " + gid);
}
} else {
- throw new AdvancedTypographicTableFormatException ("illegal entries entry, must be Integer: " + o);
+ throw new AdvancedTypographicTableFormatException("illegal entries entry, must be Integer: " + o);
}
}
assert i == n;
}
private abstract static class MultipleSubtable extends GlyphSubstitutionSubtable {
- public MultipleSubtable (String id, int sequence, int flags, int format, GlyphCoverageTable coverage, List entries) {
- super (id, sequence, flags, format, coverage);
+ public MultipleSubtable(String id, int sequence, int flags, int format, GlyphCoverageTable coverage, List entries) {
+ super(id, sequence, flags, format, coverage);
}
/** {@inheritDoc} */
public int getType() {
return GSUB_LOOKUP_TYPE_MULTIPLE;
}
/** {@inheritDoc} */
- public boolean isCompatible (GlyphSubtable subtable) {
+ public boolean isCompatible(GlyphSubtable subtable) {
return subtable instanceof MultipleSubtable;
}
/** {@inheritDoc} */
- public boolean substitute (GlyphSubstitutionState ss) {
+ public boolean substitute(GlyphSubstitutionState ss) {
int gi = ss.getGlyph();
int ci;
- if ((ci = getCoverageIndex (gi)) < 0) {
+ if ((ci = getCoverageIndex(gi)) < 0) {
return false;
} else {
- int[] ga = getGlyphsForCoverageIndex (ci, gi);
+ int[] ga = getGlyphsForCoverageIndex(ci, gi);
if (ga != null) {
- ss.putGlyphs (ga, GlyphSequence.CharAssociation.replicate (ss.getAssociation(), ga.length), Boolean.TRUE);
+ ss.putGlyphs(ga, GlyphSequence.CharAssociation.replicate(ss.getAssociation(), ga.length), Boolean.TRUE);
ss.consume(1);
}
return true;
* @return sequence of glyphs to substitute for input glyph
* @throws IllegalArgumentException if coverage index is not valid
*/
- public abstract int[] getGlyphsForCoverageIndex (int ci, int gi) throws IllegalArgumentException;
- static GlyphSubstitutionSubtable create (String id, int sequence, int flags, int format, GlyphCoverageTable coverage, List entries) {
+ public abstract int[] getGlyphsForCoverageIndex(int ci, int gi) throws IllegalArgumentException;
+ static GlyphSubstitutionSubtable create(String id, int sequence, int flags, int format, GlyphCoverageTable coverage, List entries) {
if (format == 1) {
- return new MultipleSubtableFormat1 (id, sequence, flags, format, coverage, entries);
+ return new MultipleSubtableFormat1(id, sequence, flags, format, coverage, entries);
} else {
throw new UnsupportedOperationException();
}
private static class MultipleSubtableFormat1 extends MultipleSubtable {
private int[][] gsa; // glyph sequence array, ordered by coverage index
- MultipleSubtableFormat1 (String id, int sequence, int flags, int format, GlyphCoverageTable coverage, List entries) {
- super (id, sequence, flags, format, coverage, entries);
- populate (entries);
+ MultipleSubtableFormat1(String id, int sequence, int flags, int format, GlyphCoverageTable coverage, List entries) {
+ super(id, sequence, flags, format, coverage, entries);
+ populate(entries);
}
/** {@inheritDoc} */
public List getEntries() {
if (gsa != null) {
- List entries = new ArrayList (1);
- entries.add (gsa);
+ List entries = new ArrayList(1);
+ entries.add(gsa);
return entries;
} else {
return null;
}
}
/** {@inheritDoc} */
- public int[] getGlyphsForCoverageIndex (int ci, int gi) throws IllegalArgumentException {
+ public int[] getGlyphsForCoverageIndex(int ci, int gi) throws IllegalArgumentException {
if (gsa == null) {
return null;
} else if (ci >= gsa.length) {
- throw new IllegalArgumentException ("coverage index " + ci + " out of range, maximum coverage index is " + gsa.length);
+ throw new IllegalArgumentException("coverage index " + ci + " out of range, maximum coverage index is " + gsa.length);
} else {
return gsa [ ci ];
}
}
- private void populate (List entries) {
+ private void populate(List entries) {
if (entries == null) {
- throw new AdvancedTypographicTableFormatException ("illegal entries, must be non-null");
+ throw new AdvancedTypographicTableFormatException("illegal entries, must be non-null");
} else if (entries.size() != 1) {
- throw new AdvancedTypographicTableFormatException ("illegal entries, " + entries.size() + " entries present, but requires 1 entry");
+ throw new AdvancedTypographicTableFormatException("illegal entries, " + entries.size() + " entries present, but requires 1 entry");
} else {
Object o;
if (((o = entries.get(0)) == null) || ! (o instanceof int[][])) {
- throw new AdvancedTypographicTableFormatException ("illegal entries, first entry must be an int[][], but is: " + ((o != null) ? o.getClass() : null));
+ throw new AdvancedTypographicTableFormatException("illegal entries, first entry must be an int[][], but is: " + ((o != null) ? o.getClass() : null));
} else {
gsa = (int[][]) o;
}
}
private abstract static class AlternateSubtable extends GlyphSubstitutionSubtable {
- public AlternateSubtable (String id, int sequence, int flags, int format, GlyphCoverageTable coverage, List entries) {
- super (id, sequence, flags, format, coverage);
+ public AlternateSubtable(String id, int sequence, int flags, int format, GlyphCoverageTable coverage, List entries) {
+ super(id, sequence, flags, format, coverage);
}
/** {@inheritDoc} */
public int getType() {
return GSUB_LOOKUP_TYPE_ALTERNATE;
}
/** {@inheritDoc} */
- public boolean isCompatible (GlyphSubtable subtable) {
+ public boolean isCompatible(GlyphSubtable subtable) {
return subtable instanceof AlternateSubtable;
}
/** {@inheritDoc} */
- public boolean substitute (GlyphSubstitutionState ss) {
+ public boolean substitute(GlyphSubstitutionState ss) {
int gi = ss.getGlyph();
int ci;
- if ((ci = getCoverageIndex (gi)) < 0) {
+ if ((ci = getCoverageIndex(gi)) < 0) {
return false;
} else {
- int[] ga = getAlternatesForCoverageIndex (ci, gi);
- int ai = ss.getAlternatesIndex (ci);
+ int[] ga = getAlternatesForCoverageIndex(ci, gi);
+ int ai = ss.getAlternatesIndex(ci);
int go;
if ((ai < 0) || (ai >= ga.length)) {
go = gi;
if ((go < 0) || (go > 65535)) {
go = 65535;
}
- ss.putGlyph (go, ss.getAssociation(), Boolean.TRUE);
+ ss.putGlyph(go, ss.getAssociation(), Boolean.TRUE);
ss.consume(1);
return true;
}
* @return sequence of glyphs to substitute for input glyph
* @throws IllegalArgumentException if coverage index is not valid
*/
- public abstract int[] getAlternatesForCoverageIndex (int ci, int gi) throws IllegalArgumentException;
- static GlyphSubstitutionSubtable create (String id, int sequence, int flags, int format, GlyphCoverageTable coverage, List entries) {
+ public abstract int[] getAlternatesForCoverageIndex(int ci, int gi) throws IllegalArgumentException;
+ static GlyphSubstitutionSubtable create(String id, int sequence, int flags, int format, GlyphCoverageTable coverage, List entries) {
if (format == 1) {
- return new AlternateSubtableFormat1 (id, sequence, flags, format, coverage, entries);
+ return new AlternateSubtableFormat1(id, sequence, flags, format, coverage, entries);
} else {
throw new UnsupportedOperationException();
}
private static class AlternateSubtableFormat1 extends AlternateSubtable {
private int[][] gaa; // glyph alternates array, ordered by coverage index
- AlternateSubtableFormat1 (String id, int sequence, int flags, int format, GlyphCoverageTable coverage, List entries) {
- super (id, sequence, flags, format, coverage, entries);
- populate (entries);
+ AlternateSubtableFormat1(String id, int sequence, int flags, int format, GlyphCoverageTable coverage, List entries) {
+ super(id, sequence, flags, format, coverage, entries);
+ populate(entries);
}
/** {@inheritDoc} */
public List getEntries() {
- List entries = new ArrayList (gaa.length);
+ List entries = new ArrayList(gaa.length);
for (int i = 0, n = gaa.length; i < n; i++) {
- entries.add (gaa[i]);
+ entries.add(gaa[i]);
}
return entries;
}
/** {@inheritDoc} */
- public int[] getAlternatesForCoverageIndex (int ci, int gi) throws IllegalArgumentException {
+ public int[] getAlternatesForCoverageIndex(int ci, int gi) throws IllegalArgumentException {
if (gaa == null) {
return null;
} else if (ci >= gaa.length) {
- throw new IllegalArgumentException ("coverage index " + ci + " out of range, maximum coverage index is " + gaa.length);
+ throw new IllegalArgumentException("coverage index " + ci + " out of range, maximum coverage index is " + gaa.length);
} else {
return gaa [ ci ];
}
}
- private void populate (List entries) {
+ private void populate(List entries) {
int i = 0;
int n = entries.size();
int[][] gaa = new int [ n ][];
if (o instanceof int[]) {
gaa [ i++ ] = (int[]) o;
} else {
- throw new AdvancedTypographicTableFormatException ("illegal entries entry, must be int[]: " + o);
+ throw new AdvancedTypographicTableFormatException("illegal entries entry, must be int[]: " + o);
}
}
assert i == n;
}
private abstract static class LigatureSubtable extends GlyphSubstitutionSubtable {
- public LigatureSubtable (String id, int sequence, int flags, int format, GlyphCoverageTable coverage, List entries) {
- super (id, sequence, flags, format, coverage);
+ public LigatureSubtable(String id, int sequence, int flags, int format, GlyphCoverageTable coverage, List entries) {
+ super(id, sequence, flags, format, coverage);
}
/** {@inheritDoc} */
public int getType() {
return GSUB_LOOKUP_TYPE_LIGATURE;
}
/** {@inheritDoc} */
- public boolean isCompatible (GlyphSubtable subtable) {
+ public boolean isCompatible(GlyphSubtable subtable) {
return subtable instanceof LigatureSubtable;
}
/** {@inheritDoc} */
- public boolean substitute (GlyphSubstitutionState ss) {
+ public boolean substitute(GlyphSubstitutionState ss) {
int gi = ss.getGlyph();
int ci;
- if ((ci = getCoverageIndex (gi)) < 0) {
+ if ((ci = getCoverageIndex(gi)) < 0) {
return false;
} else {
- LigatureSet ls = getLigatureSetForCoverageIndex (ci, gi);
+ LigatureSet ls = getLigatureSetForCoverageIndex(ci, gi);
if (ls != null) {
boolean reverse = false;
GlyphTester ignores = ss.getIgnoreDefault();
- int[] counts = ss.getGlyphsAvailable (0, reverse, ignores);
+ int[] counts = ss.getGlyphsAvailable(0, reverse, ignores);
int nga = counts[0];
int ngi;
if (nga > 1) {
- int[] iga = ss.getGlyphs (0, nga, reverse, ignores, null, counts);
- Ligature l = findLigature (ls, iga);
+ int[] iga = ss.getGlyphs(0, nga, reverse, ignores, null, counts);
+ Ligature l = findLigature(ls, iga);
if (l != null) {
int go = l.getLigature();
if ((go < 0) || (go > 65535)) {
}
int nmg = 1 + l.getNumComponents();
// fetch matched number of component glyphs to determine matched and ignored count
- ss.getGlyphs (0, nmg, reverse, ignores, null, counts);
+ ss.getGlyphs(0, nmg, reverse, ignores, null, counts);
nga = counts[0];
ngi = counts[1];
// fetch associations of matched component glyphs
- GlyphSequence.CharAssociation[] laa = ss.getAssociations (0, nga);
+ GlyphSequence.CharAssociation[] laa = ss.getAssociations(0, nga);
// output ligature glyph and its association
- ss.putGlyph (go, GlyphSequence.CharAssociation.join (laa), Boolean.TRUE);
+ ss.putGlyph(go, GlyphSequence.CharAssociation.join(laa), Boolean.TRUE);
// fetch and output ignored glyphs (if necessary)
if (ngi > 0) {
- ss.putGlyphs (ss.getIgnoredGlyphs (0, ngi), ss.getIgnoredAssociations (0, ngi), null);
+ ss.putGlyphs(ss.getIgnoredGlyphs(0, ngi), ss.getIgnoredAssociations(0, ngi), null);
}
- ss.consume (nga + ngi);
+ ss.consume(nga + ngi);
}
}
}
return true;
}
}
- private Ligature findLigature (LigatureSet ls, int[] glyphs) {
+ private Ligature findLigature(LigatureSet ls, int[] glyphs) {
Ligature[] la = ls.getLigatures();
int k = -1;
int maxComponents = -1;
for (int i = 0, n = la.length; i < n; i++) {
Ligature l = la [ i ];
- if (l.matchesComponents (glyphs)) {
+ if (l.matchesComponents(glyphs)) {
int nc = l.getNumComponents();
if (nc > maxComponents) {
maxComponents = nc;
* @return ligature set (or null if none defined)
* @throws IllegalArgumentException if coverage index is not valid
*/
- public abstract LigatureSet getLigatureSetForCoverageIndex (int ci, int gi) throws IllegalArgumentException;
- static GlyphSubstitutionSubtable create (String id, int sequence, int flags, int format, GlyphCoverageTable coverage, List entries) {
+ public abstract LigatureSet getLigatureSetForCoverageIndex(int ci, int gi) throws IllegalArgumentException;
+ static GlyphSubstitutionSubtable create(String id, int sequence, int flags, int format, GlyphCoverageTable coverage, List entries) {
if (format == 1) {
- return new LigatureSubtableFormat1 (id, sequence, flags, format, coverage, entries);
+ return new LigatureSubtableFormat1(id, sequence, flags, format, coverage, entries);
} else {
throw new UnsupportedOperationException();
}
private static class LigatureSubtableFormat1 extends LigatureSubtable {
private LigatureSet[] ligatureSets;
- public LigatureSubtableFormat1 (String id, int sequence, int flags, int format, GlyphCoverageTable coverage, List entries) {
- super (id, sequence, flags, format, coverage, entries);
- populate (entries);
+ public LigatureSubtableFormat1(String id, int sequence, int flags, int format, GlyphCoverageTable coverage, List entries) {
+ super(id, sequence, flags, format, coverage, entries);
+ populate(entries);
}
/** {@inheritDoc} */
public List getEntries() {
- List entries = new ArrayList (ligatureSets.length);
+ List entries = new ArrayList(ligatureSets.length);
for (int i = 0, n = ligatureSets.length; i < n; i++) {
- entries.add (ligatureSets[i]);
+ entries.add(ligatureSets[i]);
}
return entries;
}
/** {@inheritDoc} */
- public LigatureSet getLigatureSetForCoverageIndex (int ci, int gi) throws IllegalArgumentException {
+ public LigatureSet getLigatureSetForCoverageIndex(int ci, int gi) throws IllegalArgumentException {
if (ligatureSets == null) {
return null;
} else if (ci >= ligatureSets.length) {
- throw new IllegalArgumentException ("coverage index " + ci + " out of range, maximum coverage index is " + ligatureSets.length);
+ throw new IllegalArgumentException("coverage index " + ci + " out of range, maximum coverage index is " + ligatureSets.length);
} else {
return ligatureSets [ ci ];
}
}
- private void populate (List entries) {
+ private void populate(List entries) {
int i = 0;
int n = entries.size();
LigatureSet[] ligatureSets = new LigatureSet [ n ];
if (o instanceof LigatureSet) {
ligatureSets [ i++ ] = (LigatureSet) o;
} else {
- throw new AdvancedTypographicTableFormatException ("illegal ligatures entry, must be LigatureSet: " + o);
+ throw new AdvancedTypographicTableFormatException("illegal ligatures entry, must be LigatureSet: " + o);
}
}
assert i == n;
}
private abstract static class ContextualSubtable extends GlyphSubstitutionSubtable {
- public ContextualSubtable (String id, int sequence, int flags, int format, GlyphCoverageTable coverage, List entries) {
- super (id, sequence, flags, format, coverage);
+ public ContextualSubtable(String id, int sequence, int flags, int format, GlyphCoverageTable coverage, List entries) {
+ super(id, sequence, flags, format, coverage);
}
/** {@inheritDoc} */
public int getType() {
return GSUB_LOOKUP_TYPE_CONTEXTUAL;
}
/** {@inheritDoc} */
- public boolean isCompatible (GlyphSubtable subtable) {
+ public boolean isCompatible(GlyphSubtable subtable) {
return subtable instanceof ContextualSubtable;
}
/** {@inheritDoc} */
- public boolean substitute (GlyphSubstitutionState ss) {
+ public boolean substitute(GlyphSubstitutionState ss) {
int gi = ss.getGlyph();
int ci;
- if ((ci = getCoverageIndex (gi)) < 0) {
+ if ((ci = getCoverageIndex(gi)) < 0) {
return false;
} else {
int[] rv = new int[1];
- RuleLookup[] la = getLookups (ci, gi, ss, rv);
+ RuleLookup[] la = getLookups(ci, gi, ss, rv);
if (la != null) {
- ss.apply (la, rv[0]);
+ ss.apply(la, rv[0]);
}
return true;
}
* where the first entry is used to return the input sequence length of the matched rule
* @return array of rule lookups or null if none applies
*/
- public abstract RuleLookup[] getLookups (int ci, int gi, GlyphSubstitutionState ss, int[] rv);
- static GlyphSubstitutionSubtable create (String id, int sequence, int flags, int format, GlyphCoverageTable coverage, List entries) {
+ public abstract RuleLookup[] getLookups(int ci, int gi, GlyphSubstitutionState ss, int[] rv);
+ static GlyphSubstitutionSubtable create(String id, int sequence, int flags, int format, GlyphCoverageTable coverage, List entries) {
if (format == 1) {
- return new ContextualSubtableFormat1 (id, sequence, flags, format, coverage, entries);
+ return new ContextualSubtableFormat1(id, sequence, flags, format, coverage, entries);
} else if (format == 2) {
- return new ContextualSubtableFormat2 (id, sequence, flags, format, coverage, entries);
+ return new ContextualSubtableFormat2(id, sequence, flags, format, coverage, entries);
} else if (format == 3) {
- return new ContextualSubtableFormat3 (id, sequence, flags, format, coverage, entries);
+ return new ContextualSubtableFormat3(id, sequence, flags, format, coverage, entries);
} else {
throw new UnsupportedOperationException();
}
private static class ContextualSubtableFormat1 extends ContextualSubtable {
private RuleSet[] rsa; // rule set array, ordered by glyph coverage index
- ContextualSubtableFormat1 (String id, int sequence, int flags, int format, GlyphCoverageTable coverage, List entries) {
- super (id, sequence, flags, format, coverage, entries);
- populate (entries);
+ ContextualSubtableFormat1(String id, int sequence, int flags, int format, GlyphCoverageTable coverage, List entries) {
+ super(id, sequence, flags, format, coverage, entries);
+ populate(entries);
}
/** {@inheritDoc} */
public List getEntries() {
if (rsa != null) {
- List entries = new ArrayList (1);
- entries.add (rsa);
+ List entries = new ArrayList(1);
+ entries.add(rsa);
return entries;
} else {
return null;
}
}
/** {@inheritDoc} */
- public void resolveLookupReferences (Map/*<String,LookupTable>*/ lookupTables) {
- GlyphTable.resolveLookupReferences (rsa, lookupTables);
+ public void resolveLookupReferences(Map/*<String,LookupTable>*/ lookupTables) {
+ GlyphTable.resolveLookupReferences(rsa, lookupTables);
}
/** {@inheritDoc} */
- public RuleLookup[] getLookups (int ci, int gi, GlyphSubstitutionState ss, int[] rv) {
+ public RuleLookup[] getLookups(int ci, int gi, GlyphSubstitutionState ss, int[] rv) {
assert ss != null;
assert (rv != null) && (rv.length > 0);
assert rsa != null;
Rule r = ra [ i ];
if ((r != null) && (r instanceof ChainedGlyphSequenceRule)) {
ChainedGlyphSequenceRule cr = (ChainedGlyphSequenceRule) r;
- int[] iga = cr.getGlyphs (gi);
- if (matches (ss, iga, 0, rv)) {
+ int[] iga = cr.getGlyphs(gi);
+ if (matches(ss, iga, 0, rv)) {
return r.getLookups();
}
}
}
return null;
}
- static boolean matches (GlyphSubstitutionState ss, int[] glyphs, int offset, int[] rv) {
+ static boolean matches(GlyphSubstitutionState ss, int[] glyphs, int offset, int[] rv) {
if ((glyphs == null) || (glyphs.length == 0)) {
return true; // match null or empty glyph sequence
} else {
boolean reverse = offset < 0;
GlyphTester ignores = ss.getIgnoreDefault();
- int[] counts = ss.getGlyphsAvailable (offset, reverse, ignores);
+ int[] counts = ss.getGlyphsAvailable(offset, reverse, ignores);
int nga = counts[0];
int ngm = glyphs.length;
if (nga < ngm) {
return false; // insufficient glyphs available to match
} else {
- int[] ga = ss.getGlyphs (offset, ngm, reverse, ignores, null, counts);
+ int[] ga = ss.getGlyphs(offset, ngm, reverse, ignores, null, counts);
for (int k = 0; k < ngm; k++) {
if (ga [ k ] != glyphs [ k ]) {
return false; // match fails at ga [ k ]
}
}
}
- private void populate (List entries) {
+ private void populate(List entries) {
if (entries == null) {
- throw new AdvancedTypographicTableFormatException ("illegal entries, must be non-null");
+ throw new AdvancedTypographicTableFormatException("illegal entries, must be non-null");
} else if (entries.size() != 1) {
- throw new AdvancedTypographicTableFormatException ("illegal entries, " + entries.size() + " entries present, but requires 1 entry");
+ throw new AdvancedTypographicTableFormatException("illegal entries, " + entries.size() + " entries present, but requires 1 entry");
} else {
Object o;
if (((o = entries.get(0)) == null) || ! (o instanceof RuleSet[])) {
- throw new AdvancedTypographicTableFormatException ("illegal entries, first entry must be an RuleSet[], but is: " + ((o != null) ? o.getClass() : null));
+ throw new AdvancedTypographicTableFormatException("illegal entries, first entry must be an RuleSet[], but is: " + ((o != null) ? o.getClass() : null));
} else {
rsa = (RuleSet[]) o;
}
private GlyphClassTable cdt; // class def table
private int ngc; // class set count
private RuleSet[] rsa; // rule set array, ordered by class number [0...ngc - 1]
- ContextualSubtableFormat2 (String id, int sequence, int flags, int format, GlyphCoverageTable coverage, List entries) {
- super (id, sequence, flags, format, coverage, entries);
- populate (entries);
+ ContextualSubtableFormat2(String id, int sequence, int flags, int format, GlyphCoverageTable coverage, List entries) {
+ super(id, sequence, flags, format, coverage, entries);
+ populate(entries);
}
/** {@inheritDoc} */
public List getEntries() {
if (rsa != null) {
- List entries = new ArrayList (3);
- entries.add (cdt);
- entries.add (Integer.valueOf (ngc));
- entries.add (rsa);
+ List entries = new ArrayList(3);
+ entries.add(cdt);
+ entries.add(Integer.valueOf(ngc));
+ entries.add(rsa);
return entries;
} else {
return null;
}
}
/** {@inheritDoc} */
- public void resolveLookupReferences (Map/*<String,LookupTable>*/ lookupTables) {
- GlyphTable.resolveLookupReferences (rsa, lookupTables);
+ public void resolveLookupReferences(Map/*<String,LookupTable>*/ lookupTables) {
+ GlyphTable.resolveLookupReferences(rsa, lookupTables);
}
/** {@inheritDoc} */
- public RuleLookup[] getLookups (int ci, int gi, GlyphSubstitutionState ss, int[] rv) {
+ public RuleLookup[] getLookups(int ci, int gi, GlyphSubstitutionState ss, int[] rv) {
assert ss != null;
assert (rv != null) && (rv.length > 0);
assert rsa != null;
Rule r = ra [ i ];
if ((r != null) && (r instanceof ChainedClassSequenceRule)) {
ChainedClassSequenceRule cr = (ChainedClassSequenceRule) r;
- int[] ca = cr.getClasses (cdt.getClassIndex (gi, ss.getClassMatchSet (gi)));
- if (matches (ss, cdt, ca, 0, rv)) {
+ int[] ca = cr.getClasses(cdt.getClassIndex(gi, ss.getClassMatchSet(gi)));
+ if (matches(ss, cdt, ca, 0, rv)) {
return r.getLookups();
}
}
}
return null;
}
- static boolean matches (GlyphSubstitutionState ss, GlyphClassTable cdt, int[] classes, int offset, int[] rv) {
+ static boolean matches(GlyphSubstitutionState ss, GlyphClassTable cdt, int[] classes, int offset, int[] rv) {
if ((cdt == null) || (classes == null) || (classes.length == 0)) {
return true; // match null class definitions, null or empty class sequence
} else {
boolean reverse = offset < 0;
GlyphTester ignores = ss.getIgnoreDefault();
- int[] counts = ss.getGlyphsAvailable (offset, reverse, ignores);
+ int[] counts = ss.getGlyphsAvailable(offset, reverse, ignores);
int nga = counts[0];
int ngm = classes.length;
if (nga < ngm) {
return false; // insufficient glyphs available to match
} else {
- int[] ga = ss.getGlyphs (offset, ngm, reverse, ignores, null, counts);
+ int[] ga = ss.getGlyphs(offset, ngm, reverse, ignores, null, counts);
for (int k = 0; k < ngm; k++) {
int gi = ga [ k ];
- int ms = ss.getClassMatchSet (gi);
- int gc = cdt.getClassIndex (gi, ms);
- if ((gc < 0) || (gc >= cdt.getClassSize (ms))) {
+ int ms = ss.getClassMatchSet(gi);
+ int gc = cdt.getClassIndex(gi, ms);
+ if ((gc < 0) || (gc >= cdt.getClassSize(ms))) {
return false; // none or invalid class fails mat ch
} else if (gc != classes [ k ]) {
return false; // match fails at ga [ k ]
}
}
}
- private void populate (List entries) {
+ private void populate(List entries) {
if (entries == null) {
- throw new AdvancedTypographicTableFormatException ("illegal entries, must be non-null");
+ throw new AdvancedTypographicTableFormatException("illegal entries, must be non-null");
} else if (entries.size() != 3) {
- throw new AdvancedTypographicTableFormatException ("illegal entries, " + entries.size() + " entries present, but requires 3 entries");
+ throw new AdvancedTypographicTableFormatException("illegal entries, " + entries.size() + " entries present, but requires 3 entries");
} else {
Object o;
if (((o = entries.get(0)) == null) || ! (o instanceof GlyphClassTable)) {
- throw new AdvancedTypographicTableFormatException ("illegal entries, first entry must be an GlyphClassTable, but is: " + ((o != null) ? o.getClass() : null));
+ throw new AdvancedTypographicTableFormatException("illegal entries, first entry must be an GlyphClassTable, but is: " + ((o != null) ? o.getClass() : null));
} else {
cdt = (GlyphClassTable) o;
}
if (((o = entries.get(1)) == null) || ! (o instanceof Integer)) {
- throw new AdvancedTypographicTableFormatException ("illegal entries, second entry must be an Integer, but is: " + ((o != null) ? o.getClass() : null));
+ throw new AdvancedTypographicTableFormatException("illegal entries, second entry must be an Integer, but is: " + ((o != null) ? o.getClass() : null));
} else {
ngc = ((Integer)(o)).intValue();
}
if (((o = entries.get(2)) == null) || ! (o instanceof RuleSet[])) {
- throw new AdvancedTypographicTableFormatException ("illegal entries, third entry must be an RuleSet[], but is: " + ((o != null) ? o.getClass() : null));
+ throw new AdvancedTypographicTableFormatException("illegal entries, third entry must be an RuleSet[], but is: " + ((o != null) ? o.getClass() : null));
} else {
rsa = (RuleSet[]) o;
if (rsa.length != ngc) {
- throw new AdvancedTypographicTableFormatException ("illegal entries, RuleSet[] length is " + rsa.length + ", but expected " + ngc + " glyph classes");
+ throw new AdvancedTypographicTableFormatException("illegal entries, RuleSet[] length is " + rsa.length + ", but expected " + ngc + " glyph classes");
}
}
}
private static class ContextualSubtableFormat3 extends ContextualSubtable {
private RuleSet[] rsa; // rule set array, containing a single rule set
- ContextualSubtableFormat3 (String id, int sequence, int flags, int format, GlyphCoverageTable coverage, List entries) {
- super (id, sequence, flags, format, coverage, entries);
- populate (entries);
+ ContextualSubtableFormat3(String id, int sequence, int flags, int format, GlyphCoverageTable coverage, List entries) {
+ super(id, sequence, flags, format, coverage, entries);
+ populate(entries);
}
/** {@inheritDoc} */
public List getEntries() {
if (rsa != null) {
- List entries = new ArrayList (1);
- entries.add (rsa);
+ List entries = new ArrayList(1);
+ entries.add(rsa);
return entries;
} else {
return null;
}
}
/** {@inheritDoc} */
- public void resolveLookupReferences (Map/*<String,LookupTable>*/ lookupTables) {
- GlyphTable.resolveLookupReferences (rsa, lookupTables);
+ public void resolveLookupReferences(Map/*<String,LookupTable>*/ lookupTables) {
+ GlyphTable.resolveLookupReferences(rsa, lookupTables);
}
/** {@inheritDoc} */
- public RuleLookup[] getLookups (int ci, int gi, GlyphSubstitutionState ss, int[] rv) {
+ public RuleLookup[] getLookups(int ci, int gi, GlyphSubstitutionState ss, int[] rv) {
assert ss != null;
assert (rv != null) && (rv.length > 0);
assert rsa != null;
if ((r != null) && (r instanceof ChainedCoverageSequenceRule)) {
ChainedCoverageSequenceRule cr = (ChainedCoverageSequenceRule) r;
GlyphCoverageTable[] gca = cr.getCoverages();
- if (matches (ss, gca, 0, rv)) {
+ if (matches(ss, gca, 0, rv)) {
return r.getLookups();
}
}
}
return null;
}
- static boolean matches (GlyphSubstitutionState ss, GlyphCoverageTable[] gca, int offset, int[] rv) {
+ static boolean matches(GlyphSubstitutionState ss, GlyphCoverageTable[] gca, int offset, int[] rv) {
if ((gca == null) || (gca.length == 0)) {
return true; // match null or empty coverage array
} else {
boolean reverse = offset < 0;
GlyphTester ignores = ss.getIgnoreDefault();
- int[] counts = ss.getGlyphsAvailable (offset, reverse, ignores);
+ int[] counts = ss.getGlyphsAvailable(offset, reverse, ignores);
int nga = counts[0];
int ngm = gca.length;
if (nga < ngm) {
return false; // insufficient glyphs available to match
} else {
- int[] ga = ss.getGlyphs (offset, ngm, reverse, ignores, null, counts);
+ int[] ga = ss.getGlyphs(offset, ngm, reverse, ignores, null, counts);
for (int k = 0; k < ngm; k++) {
GlyphCoverageTable ct = gca [ k ];
if (ct != null) {
- if (ct.getCoverageIndex (ga [ k ]) < 0) {
+ if (ct.getCoverageIndex(ga [ k ]) < 0) {
return false; // match fails at ga [ k ]
}
}
}
}
}
- private void populate (List entries) {
+ private void populate(List entries) {
if (entries == null) {
- throw new AdvancedTypographicTableFormatException ("illegal entries, must be non-null");
+ throw new AdvancedTypographicTableFormatException("illegal entries, must be non-null");
} else if (entries.size() != 1) {
- throw new AdvancedTypographicTableFormatException ("illegal entries, " + entries.size() + " entries present, but requires 1 entry");
+ throw new AdvancedTypographicTableFormatException("illegal entries, " + entries.size() + " entries present, but requires 1 entry");
} else {
Object o;
if (((o = entries.get(0)) == null) || ! (o instanceof RuleSet[])) {
- throw new AdvancedTypographicTableFormatException ("illegal entries, first entry must be an RuleSet[], but is: " + ((o != null) ? o.getClass() : null));
+ throw new AdvancedTypographicTableFormatException("illegal entries, first entry must be an RuleSet[], but is: " + ((o != null) ? o.getClass() : null));
} else {
rsa = (RuleSet[]) o;
}
}
private abstract static class ChainedContextualSubtable extends GlyphSubstitutionSubtable {
- public ChainedContextualSubtable (String id, int sequence, int flags, int format, GlyphCoverageTable coverage, List entries) {
- super (id, sequence, flags, format, coverage);
+ public ChainedContextualSubtable(String id, int sequence, int flags, int format, GlyphCoverageTable coverage, List entries) {
+ super(id, sequence, flags, format, coverage);
}
/** {@inheritDoc} */
public int getType() {
return GSUB_LOOKUP_TYPE_CHAINED_CONTEXTUAL;
}
/** {@inheritDoc} */
- public boolean isCompatible (GlyphSubtable subtable) {
+ public boolean isCompatible(GlyphSubtable subtable) {
return subtable instanceof ChainedContextualSubtable;
}
/** {@inheritDoc} */
- public boolean substitute (GlyphSubstitutionState ss) {
+ public boolean substitute(GlyphSubstitutionState ss) {
int gi = ss.getGlyph();
int ci;
- if ((ci = getCoverageIndex (gi)) < 0) {
+ if ((ci = getCoverageIndex(gi)) < 0) {
return false;
} else {
int[] rv = new int[1];
- RuleLookup[] la = getLookups (ci, gi, ss, rv);
+ RuleLookup[] la = getLookups(ci, gi, ss, rv);
if (la != null) {
- ss.apply (la, rv[0]);
+ ss.apply(la, rv[0]);
return true;
} else {
return false;
* @param rv array of ints used to receive multiple return values, must be of length 1 or greater
* @return array of rule lookups or null if none applies
*/
- public abstract RuleLookup[] getLookups (int ci, int gi, GlyphSubstitutionState ss, int[] rv);
- static GlyphSubstitutionSubtable create (String id, int sequence, int flags, int format, GlyphCoverageTable coverage, List entries) {
+ public abstract RuleLookup[] getLookups(int ci, int gi, GlyphSubstitutionState ss, int[] rv);
+ static GlyphSubstitutionSubtable create(String id, int sequence, int flags, int format, GlyphCoverageTable coverage, List entries) {
if (format == 1) {
- return new ChainedContextualSubtableFormat1 (id, sequence, flags, format, coverage, entries);
+ return new ChainedContextualSubtableFormat1(id, sequence, flags, format, coverage, entries);
} else if (format == 2) {
- return new ChainedContextualSubtableFormat2 (id, sequence, flags, format, coverage, entries);
+ return new ChainedContextualSubtableFormat2(id, sequence, flags, format, coverage, entries);
} else if (format == 3) {
- return new ChainedContextualSubtableFormat3 (id, sequence, flags, format, coverage, entries);
+ return new ChainedContextualSubtableFormat3(id, sequence, flags, format, coverage, entries);
} else {
throw new UnsupportedOperationException();
}
private static class ChainedContextualSubtableFormat1 extends ChainedContextualSubtable {
private RuleSet[] rsa; // rule set array, ordered by glyph coverage index
- ChainedContextualSubtableFormat1 (String id, int sequence, int flags, int format, GlyphCoverageTable coverage, List entries) {
- super (id, sequence, flags, format, coverage, entries);
- populate (entries);
+ ChainedContextualSubtableFormat1(String id, int sequence, int flags, int format, GlyphCoverageTable coverage, List entries) {
+ super(id, sequence, flags, format, coverage, entries);
+ populate(entries);
}
/** {@inheritDoc} */
public List getEntries() {
if (rsa != null) {
- List entries = new ArrayList (1);
- entries.add (rsa);
+ List entries = new ArrayList(1);
+ entries.add(rsa);
return entries;
} else {
return null;
}
}
/** {@inheritDoc} */
- public void resolveLookupReferences (Map/*<String,LookupTable>*/ lookupTables) {
- GlyphTable.resolveLookupReferences (rsa, lookupTables);
+ public void resolveLookupReferences(Map/*<String,LookupTable>*/ lookupTables) {
+ GlyphTable.resolveLookupReferences(rsa, lookupTables);
}
/** {@inheritDoc} */
- public RuleLookup[] getLookups (int ci, int gi, GlyphSubstitutionState ss, int[] rv) {
+ public RuleLookup[] getLookups(int ci, int gi, GlyphSubstitutionState ss, int[] rv) {
assert ss != null;
assert (rv != null) && (rv.length > 0);
assert rsa != null;
Rule r = ra [ i ];
if ((r != null) && (r instanceof ChainedGlyphSequenceRule)) {
ChainedGlyphSequenceRule cr = (ChainedGlyphSequenceRule) r;
- int[] iga = cr.getGlyphs (gi);
- if (matches (ss, iga, 0, rv)) {
+ int[] iga = cr.getGlyphs(gi);
+ if (matches(ss, iga, 0, rv)) {
int[] bga = cr.getBacktrackGlyphs();
- if (matches (ss, bga, -1, null)) {
+ if (matches(ss, bga, -1, null)) {
int[] lga = cr.getLookaheadGlyphs();
- if (matches (ss, lga, rv[0], null)) {
+ if (matches(ss, lga, rv[0], null)) {
return r.getLookups();
}
}
}
return null;
}
- private boolean matches (GlyphSubstitutionState ss, int[] glyphs, int offset, int[] rv) {
- return ContextualSubtableFormat1.matches (ss, glyphs, offset, rv);
+ private boolean matches(GlyphSubstitutionState ss, int[] glyphs, int offset, int[] rv) {
+ return ContextualSubtableFormat1.matches(ss, glyphs, offset, rv);
}
- private void populate (List entries) {
+ private void populate(List entries) {
if (entries == null) {
- throw new AdvancedTypographicTableFormatException ("illegal entries, must be non-null");
+ throw new AdvancedTypographicTableFormatException("illegal entries, must be non-null");
} else if (entries.size() != 1) {
- throw new AdvancedTypographicTableFormatException ("illegal entries, " + entries.size() + " entries present, but requires 1 entry");
+ throw new AdvancedTypographicTableFormatException("illegal entries, " + entries.size() + " entries present, but requires 1 entry");
} else {
Object o;
if (((o = entries.get(0)) == null) || ! (o instanceof RuleSet[])) {
- throw new AdvancedTypographicTableFormatException ("illegal entries, first entry must be an RuleSet[], but is: " + ((o != null) ? o.getClass() : null));
+ throw new AdvancedTypographicTableFormatException("illegal entries, first entry must be an RuleSet[], but is: " + ((o != null) ? o.getClass() : null));
} else {
rsa = (RuleSet[]) o;
}
private GlyphClassTable lcdt; // lookahead class def table
private int ngc; // class set count
private RuleSet[] rsa; // rule set array, ordered by class number [0...ngc - 1]
- ChainedContextualSubtableFormat2 (String id, int sequence, int flags, int format, GlyphCoverageTable coverage, List entries) {
- super (id, sequence, flags, format, coverage, entries);
- populate (entries);
+ ChainedContextualSubtableFormat2(String id, int sequence, int flags, int format, GlyphCoverageTable coverage, List entries) {
+ super(id, sequence, flags, format, coverage, entries);
+ populate(entries);
}
/** {@inheritDoc} */
public List getEntries() {
if (rsa != null) {
- List entries = new ArrayList (5);
- entries.add (icdt);
- entries.add (bcdt);
- entries.add (lcdt);
- entries.add (Integer.valueOf (ngc));
- entries.add (rsa);
+ List entries = new ArrayList(5);
+ entries.add(icdt);
+ entries.add(bcdt);
+ entries.add(lcdt);
+ entries.add(Integer.valueOf(ngc));
+ entries.add(rsa);
return entries;
} else {
return null;
}
}
/** {@inheritDoc} */
- public RuleLookup[] getLookups (int ci, int gi, GlyphSubstitutionState ss, int[] rv) {
+ public RuleLookup[] getLookups(int ci, int gi, GlyphSubstitutionState ss, int[] rv) {
assert ss != null;
assert (rv != null) && (rv.length > 0);
assert rsa != null;
Rule r = ra [ i ];
if ((r != null) && (r instanceof ChainedClassSequenceRule)) {
ChainedClassSequenceRule cr = (ChainedClassSequenceRule) r;
- int[] ica = cr.getClasses (icdt.getClassIndex (gi, ss.getClassMatchSet (gi)));
- if (matches (ss, icdt, ica, 0, rv)) {
+ int[] ica = cr.getClasses(icdt.getClassIndex(gi, ss.getClassMatchSet(gi)));
+ if (matches(ss, icdt, ica, 0, rv)) {
int[] bca = cr.getBacktrackClasses();
- if (matches (ss, bcdt, bca, -1, null)) {
+ if (matches(ss, bcdt, bca, -1, null)) {
int[] lca = cr.getLookaheadClasses();
- if (matches (ss, lcdt, lca, rv[0], null)) {
+ if (matches(ss, lcdt, lca, rv[0], null)) {
return r.getLookups();
}
}
}
return null;
}
- private boolean matches (GlyphSubstitutionState ss, GlyphClassTable cdt, int[] classes, int offset, int[] rv) {
- return ContextualSubtableFormat2.matches (ss, cdt, classes, offset, rv);
+ private boolean matches(GlyphSubstitutionState ss, GlyphClassTable cdt, int[] classes, int offset, int[] rv) {
+ return ContextualSubtableFormat2.matches(ss, cdt, classes, offset, rv);
}
/** {@inheritDoc} */
- public void resolveLookupReferences (Map/*<String,LookupTable>*/ lookupTables) {
- GlyphTable.resolveLookupReferences (rsa, lookupTables);
+ public void resolveLookupReferences(Map/*<String,LookupTable>*/ lookupTables) {
+ GlyphTable.resolveLookupReferences(rsa, lookupTables);
}
- private void populate (List entries) {
+ private void populate(List entries) {
if (entries == null) {
- throw new AdvancedTypographicTableFormatException ("illegal entries, must be non-null");
+ throw new AdvancedTypographicTableFormatException("illegal entries, must be non-null");
} else if (entries.size() != 5) {
- throw new AdvancedTypographicTableFormatException ("illegal entries, " + entries.size() + " entries present, but requires 5 entries");
+ throw new AdvancedTypographicTableFormatException("illegal entries, " + entries.size() + " entries present, but requires 5 entries");
} else {
Object o;
if (((o = entries.get(0)) == null) || ! (o instanceof GlyphClassTable)) {
- throw new AdvancedTypographicTableFormatException ("illegal entries, first entry must be an GlyphClassTable, but is: " + ((o != null) ? o.getClass() : null));
+ throw new AdvancedTypographicTableFormatException("illegal entries, first entry must be an GlyphClassTable, but is: " + ((o != null) ? o.getClass() : null));
} else {
icdt = (GlyphClassTable) o;
}
if (((o = entries.get(1)) != null) && ! (o instanceof GlyphClassTable)) {
- throw new AdvancedTypographicTableFormatException ("illegal entries, second entry must be an GlyphClassTable, but is: " + o.getClass());
+ throw new AdvancedTypographicTableFormatException("illegal entries, second entry must be an GlyphClassTable, but is: " + o.getClass());
} else {
bcdt = (GlyphClassTable) o;
}
if (((o = entries.get(2)) != null) && ! (o instanceof GlyphClassTable)) {
- throw new AdvancedTypographicTableFormatException ("illegal entries, third entry must be an GlyphClassTable, but is: " + o.getClass());
+ throw new AdvancedTypographicTableFormatException("illegal entries, third entry must be an GlyphClassTable, but is: " + o.getClass());
} else {
lcdt = (GlyphClassTable) o;
}
if (((o = entries.get(3)) == null) || ! (o instanceof Integer)) {
- throw new AdvancedTypographicTableFormatException ("illegal entries, fourth entry must be an Integer, but is: " + ((o != null) ? o.getClass() : null));
+ throw new AdvancedTypographicTableFormatException("illegal entries, fourth entry must be an Integer, but is: " + ((o != null) ? o.getClass() : null));
} else {
ngc = ((Integer)(o)).intValue();
}
if (((o = entries.get(4)) == null) || ! (o instanceof RuleSet[])) {
- throw new AdvancedTypographicTableFormatException ("illegal entries, fifth entry must be an RuleSet[], but is: " + ((o != null) ? o.getClass() : null));
+ throw new AdvancedTypographicTableFormatException("illegal entries, fifth entry must be an RuleSet[], but is: " + ((o != null) ? o.getClass() : null));
} else {
rsa = (RuleSet[]) o;
if (rsa.length != ngc) {
- throw new AdvancedTypographicTableFormatException ("illegal entries, RuleSet[] length is " + rsa.length + ", but expected " + ngc + " glyph classes");
+ throw new AdvancedTypographicTableFormatException("illegal entries, RuleSet[] length is " + rsa.length + ", but expected " + ngc + " glyph classes");
}
}
}
private static class ChainedContextualSubtableFormat3 extends ChainedContextualSubtable {
private RuleSet[] rsa; // rule set array, containing a single rule set
- ChainedContextualSubtableFormat3 (String id, int sequence, int flags, int format, GlyphCoverageTable coverage, List entries) {
- super (id, sequence, flags, format, coverage, entries);
- populate (entries);
+ ChainedContextualSubtableFormat3(String id, int sequence, int flags, int format, GlyphCoverageTable coverage, List entries) {
+ super(id, sequence, flags, format, coverage, entries);
+ populate(entries);
}
/** {@inheritDoc} */
public List getEntries() {
if (rsa != null) {
- List entries = new ArrayList (1);
- entries.add (rsa);
+ List entries = new ArrayList(1);
+ entries.add(rsa);
return entries;
} else {
return null;
}
}
/** {@inheritDoc} */
- public void resolveLookupReferences (Map/*<String,LookupTable>*/ lookupTables) {
- GlyphTable.resolveLookupReferences (rsa, lookupTables);
+ public void resolveLookupReferences(Map/*<String,LookupTable>*/ lookupTables) {
+ GlyphTable.resolveLookupReferences(rsa, lookupTables);
}
/** {@inheritDoc} */
- public RuleLookup[] getLookups (int ci, int gi, GlyphSubstitutionState ss, int[] rv) {
+ public RuleLookup[] getLookups(int ci, int gi, GlyphSubstitutionState ss, int[] rv) {
assert ss != null;
assert (rv != null) && (rv.length > 0);
assert rsa != null;
if ((r != null) && (r instanceof ChainedCoverageSequenceRule)) {
ChainedCoverageSequenceRule cr = (ChainedCoverageSequenceRule) r;
GlyphCoverageTable[] igca = cr.getCoverages();
- if (matches (ss, igca, 0, rv)) {
+ if (matches(ss, igca, 0, rv)) {
GlyphCoverageTable[] bgca = cr.getBacktrackCoverages();
- if (matches (ss, bgca, -1, null)) {
+ if (matches(ss, bgca, -1, null)) {
GlyphCoverageTable[] lgca = cr.getLookaheadCoverages();
- if (matches (ss, lgca, rv[0], null)) {
+ if (matches(ss, lgca, rv[0], null)) {
return r.getLookups();
}
}
}
return null;
}
- private boolean matches (GlyphSubstitutionState ss, GlyphCoverageTable[] gca, int offset, int[] rv) {
- return ContextualSubtableFormat3.matches (ss, gca, offset, rv);
+ private boolean matches(GlyphSubstitutionState ss, GlyphCoverageTable[] gca, int offset, int[] rv) {
+ return ContextualSubtableFormat3.matches(ss, gca, offset, rv);
}
- private void populate (List entries) {
+ private void populate(List entries) {
if (entries == null) {
- throw new AdvancedTypographicTableFormatException ("illegal entries, must be non-null");
+ throw new AdvancedTypographicTableFormatException("illegal entries, must be non-null");
} else if (entries.size() != 1) {
- throw new AdvancedTypographicTableFormatException ("illegal entries, " + entries.size() + " entries present, but requires 1 entry");
+ throw new AdvancedTypographicTableFormatException("illegal entries, " + entries.size() + " entries present, but requires 1 entry");
} else {
Object o;
if (((o = entries.get(0)) == null) || ! (o instanceof RuleSet[])) {
- throw new AdvancedTypographicTableFormatException ("illegal entries, first entry must be an RuleSet[], but is: " + ((o != null) ? o.getClass() : null));
+ throw new AdvancedTypographicTableFormatException("illegal entries, first entry must be an RuleSet[], but is: " + ((o != null) ? o.getClass() : null));
} else {
rsa = (RuleSet[]) o;
}
}
private abstract static class ReverseChainedSingleSubtable extends GlyphSubstitutionSubtable {
- public ReverseChainedSingleSubtable (String id, int sequence, int flags, int format, GlyphCoverageTable coverage, List entries) {
- super (id, sequence, flags, format, coverage);
+ public ReverseChainedSingleSubtable(String id, int sequence, int flags, int format, GlyphCoverageTable coverage, List entries) {
+ super(id, sequence, flags, format, coverage);
}
/** {@inheritDoc} */
public int getType() {
return GSUB_LOOKUP_TYPE_REVERSE_CHAINED_SINGLE;
}
/** {@inheritDoc} */
- public boolean isCompatible (GlyphSubtable subtable) {
+ public boolean isCompatible(GlyphSubtable subtable) {
return subtable instanceof ReverseChainedSingleSubtable;
}
/** {@inheritDoc} */
public boolean usesReverseScan() {
return true;
}
- static GlyphSubstitutionSubtable create (String id, int sequence, int flags, int format, GlyphCoverageTable coverage, List entries) {
+ static GlyphSubstitutionSubtable create(String id, int sequence, int flags, int format, GlyphCoverageTable coverage, List entries) {
if (format == 1) {
- return new ReverseChainedSingleSubtableFormat1 (id, sequence, flags, format, coverage, entries);
+ return new ReverseChainedSingleSubtableFormat1(id, sequence, flags, format, coverage, entries);
} else {
throw new UnsupportedOperationException();
}
}
private static class ReverseChainedSingleSubtableFormat1 extends ReverseChainedSingleSubtable {
- ReverseChainedSingleSubtableFormat1 (String id, int sequence, int flags, int format, GlyphCoverageTable coverage, List entries) {
- super (id, sequence, flags, format, coverage, entries);
- populate (entries);
+ ReverseChainedSingleSubtableFormat1(String id, int sequence, int flags, int format, GlyphCoverageTable coverage, List entries) {
+ super(id, sequence, flags, format, coverage, entries);
+ populate(entries);
}
/** {@inheritDoc} */
public List getEntries() {
return null;
}
- private void populate (List entries) {
+ private void populate(List entries) {
}
}
* @param ligature glyph id
* @param components sequence of <emph>N+1...</emph> component glyph (or character) identifiers
*/
- public Ligature (int ligature, int[] components) {
+ public Ligature(int ligature, int[] components) {
if ((ligature < 0) || (ligature > 65535)) {
- throw new AdvancedTypographicTableFormatException ("invalid ligature glyph index: " + ligature);
+ throw new AdvancedTypographicTableFormatException("invalid ligature glyph index: " + ligature);
} else if (components == null) {
- throw new AdvancedTypographicTableFormatException ("invalid ligature components, must be non-null array");
+ throw new AdvancedTypographicTableFormatException("invalid ligature components, must be non-null array");
} else {
for (int i = 0, n = components.length; i < n; i++) {
int gc = components [ i ];
if ((gc < 0) || (gc > 65535)) {
- throw new AdvancedTypographicTableFormatException ("invalid component glyph index: " + gc);
+ throw new AdvancedTypographicTableFormatException("invalid component glyph index: " + gc);
}
}
this.ligature = ligature;
* @param glyphs array of glyph components to match (including first, implied glyph)
* @return true if matches
*/
- public boolean matchesComponents (int[] glyphs) {
+ public boolean matchesComponents(int[] glyphs) {
if (glyphs.length < (components.length + 1)) {
return false;
} else {
* Instantiate a set of ligatures.
* @param ligatures collection of ligatures
*/
- public LigatureSet (List ligatures) {
- this ((Ligature[]) ligatures.toArray (new Ligature [ ligatures.size() ]));
+ public LigatureSet(List ligatures) {
+ this ((Ligature[]) ligatures.toArray(new Ligature [ ligatures.size() ]));
}
/**
* Instantiate a set of ligatures.
* @param ligatures array of ligatures
*/
- public LigatureSet (Ligature[] ligatures) {
+ public LigatureSet(Ligature[] ligatures) {
if (ligatures == null) {
- throw new AdvancedTypographicTableFormatException ("invalid ligatures, must be non-null array");
+ throw new AdvancedTypographicTableFormatException("invalid ligatures, must be non-null array");
} else {
this.ligatures = ligatures;
int ncMax = -1;
* @param format subtable format
* @param mapping subtable mapping table
*/
- protected GlyphSubtable (String lookupId, int sequence, int flags, int format, GlyphMappingTable mapping)
+ protected GlyphSubtable(String lookupId, int sequence, int flags, int format, GlyphMappingTable mapping)
{
if ((lookupId == null) || (lookupId.length() == 0)) {
- throw new AdvancedTypographicTableFormatException ("invalid lookup identifier, must be non-empty string");
+ throw new AdvancedTypographicTableFormatException("invalid lookup identifier, must be non-empty string");
} else if (mapping == null) {
- throw new AdvancedTypographicTableFormatException ("invalid mapping table, must not be null");
+ throw new AdvancedTypographicTableFormatException("invalid mapping table, must not be null");
} else {
this.lookupId = lookupId;
this.sequence = sequence;
* @return true if specified subtable is compatible with this glyph subtable, where by compatible
* is meant that they share the same lookup type
*/
- public abstract boolean isCompatible (GlyphSubtable subtable);
+ public abstract boolean isCompatible(GlyphSubtable subtable);
/** @return true if subtable uses reverse scanning of glyph sequence, meaning from the last glyph
* in a glyph sequence to the first glyph
* @param table the table or null
* @throws IllegalStateException if table is already set to non-null
*/
- public synchronized void setTable (GlyphTable table) throws IllegalStateException {
+ public synchronized void setTable(GlyphTable table) throws IllegalStateException {
WeakReference r = this.table;
if (table == null) {
this.table = null;
r.clear();
}
} else if (r == null) {
- this.table = new WeakReference (table);
+ this.table = new WeakReference(table);
} else {
- throw new IllegalStateException ("table already set");
+ throw new IllegalStateException("table already set");
}
}
* 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,GlyphTable.LookupTable>*/ lookupTables) {
+ public void resolveLookupReferences(Map/*<String,GlyphTable.LookupTable>*/ lookupTables) {
}
/**
* @param gid glyph id
* @return the corresponding coverage index of the specified glyph id
*/
- public int getCoverageIndex (int gid) {
+ public int getCoverageIndex(int gid) {
if (mapping instanceof GlyphCoverageMapping) {
- return ((GlyphCoverageMapping) mapping) .getCoverageIndex (gid);
+ return ((GlyphCoverageMapping) mapping) .getCoverageIndex(gid);
} else {
return -1;
}
* @return true if the lookup identifier and the sequence number of the specified subtable is the same
* as the lookup identifier and sequence number of this subtable
*/
- public boolean equals (Object o) {
+ public boolean equals(Object o) {
if (o instanceof GlyphSubtable) {
GlyphSubtable st = (GlyphSubtable) o;
- return lookupId.equals (st.lookupId) && (sequence == st.sequence);
+ return lookupId.equals(st.lookupId) && (sequence == st.sequence);
} else {
return false;
}
* @return the result of comparing the lookup identifier and the sequence number of the specified subtable with
* the lookup identifier and sequence number of this subtable
*/
- public int compareTo (Object o) {
+ public int compareTo(Object o) {
int d;
if (o instanceof GlyphSubtable) {
GlyphSubtable st = (GlyphSubtable) o;
- if ((d = lookupId.compareTo (st.lookupId)) == 0) {
+ if ((d = lookupId.compareTo(st.lookupId)) == 0) {
if (sequence < st.sequence) {
d = -1;
} else if (sequence > st.sequence) {
* @param subtables array of glyph subtables
* @return true if any of the specified subtables uses reverse scanning.
*/
- public static boolean usesReverseScan (GlyphSubtable[] subtables) {
+ public static boolean usesReverseScan(GlyphSubtable[] subtables) {
if ((subtables == null) || (subtables.length == 0)) {
return false;
} else {
* @return consistent flags
* @throws IllegalStateException if inconsistent flags
*/
- public static int getFlags (GlyphSubtable[] subtables) throws IllegalStateException {
+ public static int getFlags(GlyphSubtable[] subtables) throws IllegalStateException {
if ((subtables == null) || (subtables.length == 0)) {
return 0;
} else {
for (int i = 0, n = subtables.length; i < n; i++) {
int f = subtables[i].getFlags();
if (f != flags) {
- throw new IllegalStateException ("inconsistent lookup flags " + f + ", expected " + flags);
+ throw new IllegalStateException("inconsistent lookup flags " + f + ", expected " + flags);
}
}
- return flags | (usesReverseScan (subtables) ? LF_INTERNAL_USE_REVERSE_SCAN : 0);
+ return flags | (usesReverseScan(subtables) ? LF_INTERNAL_USE_REVERSE_SCAN : 0);
}
}
* @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) {
+ public GlyphTable(GlyphTable gdef, Map/*<LookupSpec,List<String>>*/ lookups) {
if ((gdef != null) && ! (gdef instanceof GlyphDefinitionTable)) {
- throw new AdvancedTypographicTableFormatException ("bad glyph definition table");
+ throw new AdvancedTypographicTableFormatException("bad glyph definition table");
} else if (lookups == null) {
- throw new AdvancedTypographicTableFormatException ("lookups must be non-null map");
+ throw new AdvancedTypographicTableFormatException("lookups must be non-null map");
} else {
this.gdef = gdef;
this.lookups = lookups;
* @return (possibly empty) list of all lookup specifications
*/
public List/*<LookupSpec>*/ getLookups() {
- return matchLookupSpecs ("*", "*", "*");
+ return matchLookupSpecs("*", "*", "*");
}
/**
* @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());
+ TreeSet/*<String>*/ lids = new TreeSet/*<String>*/(lookupTables.keySet());
+ List/*<LookupTable>*/ ltl = new ArrayList/*<LookupTable>*/(lids.size());
for (Iterator it = lids.iterator(); it.hasNext(); ) {
String lid = (String) it.next();
- ltl.add (lookupTables.get (lid));
+ ltl.add(lookupTables.get(lid));
}
return ltl;
}
* @param lid lookup id
* @return table associated with lookup id or null if none
*/
- public LookupTable getLookupTable (String lid) {
- return (LookupTable) lookupTables.get (lid);
+ public LookupTable getLookupTable(String lid) {
+ return (LookupTable) lookupTables.get(lid);
}
/**
* Add a subtable.
* @param subtable a (non-null) glyph subtable
*/
- protected void addSubtable (GlyphSubtable subtable) {
+ protected void addSubtable(GlyphSubtable subtable) {
// ensure table is not frozen
if (frozen) {
- throw new IllegalStateException ("glyph table is frozen, subtable addition prohibited");
+ throw new IllegalStateException("glyph table is frozen, subtable addition prohibited");
}
// set subtable's table reference to this table
- subtable.setTable (this);
+ subtable.setTable(this);
// add subtable to this table's subtable collection
String lid = subtable.getLookupId();
- if (lookupTables.containsKey (lid)) {
- LookupTable lt = (LookupTable) lookupTables.get (lid);
- lt.addSubtable (subtable);
+ if (lookupTables.containsKey(lid)) {
+ LookupTable lt = (LookupTable) lookupTables.get(lid);
+ lt.addSubtable(subtable);
} else {
- LookupTable lt = new LookupTable (lid, subtable);
- lookupTables.put (lid, lt);
+ LookupTable lt = new LookupTable(lid, subtable);
+ lookupTables.put(lid, lt);
}
}
if (! frozen) {
for (Iterator it = lookupTables.values().iterator(); it.hasNext(); ) {
LookupTable lt = (LookupTable) it.next();
- lt.freezeSubtables (lookupTables);
+ lt.freezeSubtables(lookupTables);
}
frozen = true;
}
* @param feature a feature identifier
* @return a (possibly empty) array of matching lookup specifications
*/
- public List/*<LookupSpec>*/ matchLookupSpecs (String script, String language, String feature) {
+ public List/*<LookupSpec>*/ matchLookupSpecs(String script, String language, String feature) {
Set/*<LookupSpec>*/ keys = lookups.keySet();
List/*<LookupSpec>*/ matches = new ArrayList/*<LookupSpec>*/();
for (Iterator it = keys.iterator(); it.hasNext();) {
LookupSpec ls = (LookupSpec) it.next();
if (! "*".equals(script)) {
- if (! ls.getScript().equals (script)) {
+ if (! ls.getScript().equals(script)) {
continue;
}
}
if (! "*".equals(language)) {
- if (! ls.getLanguage().equals (language)) {
+ if (! ls.getLanguage().equals(language)) {
continue;
}
}
if (! "*".equals(feature)) {
- if (! ls.getFeature().equals (feature)) {
+ if (! ls.getFeature().equals(feature)) {
continue;
}
}
- matches.add (ls);
+ matches.add(ls);
}
return matches;
}
* @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 = (Map/*<LookupSpec,List<LookupTable>>*/) matchedLookups.get (lsm);
+ 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 = (Map/*<LookupSpec,List<LookupTable>>*/) matchedLookups.get(lsm);
if (lm == null) {
lm = new LinkedHashMap();
- List/*<LookupSpec>*/ lsl = matchLookupSpecs (script, language, feature);
+ List/*<LookupSpec>*/ lsl = matchLookupSpecs(script, language, feature);
for (Iterator it = lsl.iterator(); it.hasNext(); ) {
LookupSpec ls = (LookupSpec) it.next();
- lm.put (ls, findLookupTables (ls));
+ lm.put(ls, findLookupTables(ls));
}
- matchedLookups.put (lsm, lm);
+ matchedLookups.put(lsm, lm);
}
return lm;
}
* @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) {
+ public List/*<LookupTable>*/ findLookupTables(LookupSpec ls) {
TreeSet/*<LookupTable>*/ lts = new TreeSet/*<LookupTable>*/();
List/*<String>*/ ids;
- if ((ids = (List/*<String>*/) lookups.get (ls)) != null) {
+ if ((ids = (List/*<String>*/) lookups.get(ls)) != null) {
for (Iterator it = ids.iterator(); it.hasNext();) {
String lid = (String) it.next();
LookupTable lt;
- if ((lt = (LookupTable) lookupTables.get (lid)) != null) {
- lts.add (lt);
+ if ((lt = (LookupTable) lookupTables.get(lid)) != null) {
+ lts.add(lt);
}
}
}
- return new ArrayList/*<LookupTable>*/ (lts);
+ return new ArrayList/*<LookupTable>*/(lts);
}
/**
* @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) {
+ public UseSpec[] assembleLookups(String[] features, Map/*<LookupSpec,List<LookupTable>>*/ lookups) {
TreeSet/*<UseSpec>*/ uss = new TreeSet/*<UseSpec>*/();
for (int i = 0, n = features.length; i < n; i++) {
String feature = features[i];
for (Iterator it = lookups.entrySet().iterator(); it.hasNext(); ) {
Map.Entry/*<LookupSpec,List<LookupTable>>*/ e = (Map.Entry/*<LookupSpec,List<LookupTable>>*/) it.next();
LookupSpec ls = (LookupSpec) e.getKey();
- if (ls.getFeature().equals (feature)) {
+ if (ls.getFeature().equals(feature)) {
List/*<LookupTable>*/ ltl = (List/*<LookupTable>*/) e.getValue();
if (ltl != null) {
for (Iterator ltit = ltl.iterator(); ltit.hasNext(); ) {
LookupTable lt = (LookupTable) ltit.next();
- uss.add (new UseSpec (lt, feature));
+ uss.add(new UseSpec(lt, feature));
}
}
}
}
}
- return (UseSpec[]) uss.toArray (new UseSpec [ uss.size() ]);
+ return (UseSpec[]) uss.toArray(new UseSpec [ uss.size() ]);
}
/** {@inheritDoc} */
* @param name of table type to map to type value
* @return glyph table type (as an integer constant)
*/
- public static int getTableTypeFromName (String name) {
+ public static int getTableTypeFromName(String name) {
int t;
String s = name.toLowerCase();
- if ("gsub".equals (s)) {
+ if ("gsub".equals(s)) {
t = GLYPH_TABLE_TYPE_SUBSTITUTION;
- } else if ("gpos".equals (s)) {
+ } else if ("gpos".equals(s)) {
t = GLYPH_TABLE_TYPE_POSITIONING;
- } else if ("jstf".equals (s)) {
+ } else if ("jstf".equals(s)) {
t = GLYPH_TABLE_TYPE_JUSTIFICATION;
- } else if ("base".equals (s)) {
+ } else if ("base".equals(s)) {
t = GLYPH_TABLE_TYPE_BASELINE;
- } else if ("gdef".equals (s)) {
+ } else if ("gdef".equals(s)) {
t = GLYPH_TABLE_TYPE_DEFINITION;
} else {
t = -1;
* @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) {
+ public static void resolveLookupReferences(RuleSet[] rsa, Map/*<String,LookupTable>*/ lookupTables) {
if ((rsa != null) && (lookupTables != null)) {
for (int i = 0, n = rsa.length; i < n; i++) {
RuleSet rs = rsa [ i ];
if (rs != null) {
- rs.resolveLookupReferences (lookupTables);
+ rs.resolveLookupReferences(lookupTables);
}
}
}
* @param language a language identifier
* @param feature a feature identifier
*/
- public LookupSpec (String script, String language, String feature) {
+ public LookupSpec(String script, String language, String feature) {
this (script, language, feature, false, false);
}
* @param permitEmpty if true the permit empty script, language, or feature
* @param permitWildcard if true the permit wildcard script, language, or feature
*/
- LookupSpec (String script, String language, String feature, boolean permitEmpty, boolean permitWildcard) {
+ 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");
+ 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");
+ 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");
+ throw new AdvancedTypographicTableFormatException("feature must be non-empty string");
} else if (! permitWildcard && script.equals("*")) {
- throw new AdvancedTypographicTableFormatException ("script must not be wildcard");
+ throw new AdvancedTypographicTableFormatException("script must not be wildcard");
} else if (! permitWildcard && language.equals("*")) {
- throw new AdvancedTypographicTableFormatException ("language must not be wildcard");
+ throw new AdvancedTypographicTableFormatException("language must not be wildcard");
} else if (! permitWildcard && feature.equals("*")) {
- throw new AdvancedTypographicTableFormatException ("feature must not be wildcard");
+ throw new AdvancedTypographicTableFormatException("feature must not be wildcard");
}
this.script = script.trim();
this.language = language.trim();
}
/** {@inheritDoc} */
- public boolean equals (Object o) {
+ public boolean equals(Object o) {
if (o instanceof LookupSpec) {
LookupSpec l = (LookupSpec) o;
- if (! l.script.equals (script)) {
+ if (! l.script.equals(script)) {
return false;
- } else if (! l.language.equals (language)) {
+ } else if (! l.language.equals(language)) {
return false;
- } else if (! l.feature.equals (feature)) {
+ } else if (! l.feature.equals(feature)) {
return false;
} else {
return true;
}
/** {@inheritDoc} */
- public int compareTo (Object o) {
+ 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) {
+ if ((d = script.compareTo(ls.script)) == 0) {
+ if ((d = language.compareTo(ls.language)) == 0) {
+ if ((d = feature.compareTo(ls.feature)) == 0) {
d = 0;
}
}
* @param id the lookup table's identifier
* @param subtable an initial subtable (or null)
*/
- public LookupTable (String id, GlyphSubtable subtable) {
- this (id, makeSingleton (subtable));
+ public LookupTable(String id, GlyphSubtable subtable) {
+ this (id, makeSingleton(subtable));
}
/**
* @param id the lookup table's identifier
* @param subtables a pre-poplated list of subtables or null
*/
- public LookupTable (String id, List/*<GlyphSubtable>*/ subtables) {
+ public LookupTable(String id, List/*<GlyphSubtable>*/ subtables) {
assert id != null;
assert id.length() != 0;
- assert id.startsWith ("lu");
+ assert id.startsWith("lu");
this.id = id;
- this.idOrdinal = Integer.parseInt (id.substring (2));
+ this.idOrdinal = Integer.parseInt(id.substring(2));
this.subtables = new LinkedList/*<GlyphSubtable>*/();
if (subtables != null) {
for (Iterator it = subtables.iterator(); it.hasNext(); ) {
GlyphSubtable st = (GlyphSubtable) it.next();
- addSubtable (st);
+ addSubtable(st);
}
}
}
return (subtablesArray != null) ? subtablesArray : subtablesArrayEmpty;
} else {
if (doesSub) {
- return (GlyphSubtable[]) subtables.toArray (new GlyphSubstitutionSubtable [ subtables.size() ]);
+ return (GlyphSubtable[]) subtables.toArray(new GlyphSubstitutionSubtable [ subtables.size() ]);
} else if (doesPos) {
- return (GlyphSubtable[]) subtables.toArray (new GlyphPositioningSubtable [ subtables.size() ]);
+ return (GlyphSubtable[]) subtables.toArray(new GlyphPositioningSubtable [ subtables.size() ]);
} else {
return null;
}
* @param subtable to add
* @return true if subtable was not already present, otherwise false
*/
- public boolean addSubtable (GlyphSubtable subtable) {
+ 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");
+ throw new IllegalStateException("glyph table is frozen, subtable addition prohibited");
}
// validate subtable to ensure consistency with current subtables
- validateSubtable (subtable);
+ validateSubtable(subtable);
// insert subtable into ordered list
for (ListIterator/*<GlyphSubtable>*/ lit = subtables.listIterator(0); lit.hasNext(); ) {
GlyphSubtable st = (GlyphSubtable) lit.next();
int d;
- if ((d = subtable.compareTo (st)) < 0) {
+ if ((d = subtable.compareTo(st)) < 0) {
// insert within list
- lit.set (subtable);
- lit.add (st);
+ lit.set(subtable);
+ lit.add(st);
added = true;
} else if (d == 0) {
// duplicate entry is ignored
}
// append at end of list
if (! added && (subtable != null)) {
- subtables.add (subtable);
+ subtables.add(subtable);
added = true;
}
return added;
}
- private void validateSubtable (GlyphSubtable subtable) {
+ private void validateSubtable(GlyphSubtable subtable) {
if (subtable == null) {
- throw new AdvancedTypographicTableFormatException ("subtable must be non-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);
+ 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);
+ throw new AdvancedTypographicTableFormatException("subtable must be substitution subtable, but is: " + subtable);
} else {
doesPos = true;
}
}
if (subtables.size() > 0) {
GlyphSubtable st = (GlyphSubtable) subtables.get(0);
- if (! st.isCompatible (subtable)) {
- throw new AdvancedTypographicTableFormatException ("subtable " + subtable + " is not compatible with subtable " + st);
+ if (! st.isCompatible(subtable)) {
+ throw new AdvancedTypographicTableFormatException("subtable " + subtable + " is not compatible with subtable " + st);
}
}
}
* 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) {
+ public void freezeSubtables(Map/*<String,LookupTable>*/ lookupTables) {
if (! frozen) {
GlyphSubtable[] sta = getSubtables();
- resolveLookupReferences (sta, lookupTables);
+ resolveLookupReferences(sta, lookupTables);
this.subtablesArray = sta;
this.frozen = true;
}
}
- private void resolveLookupReferences (GlyphSubtable[] subtables, Map/*<String,LookupTable>*/ lookupTables) {
+ private void resolveLookupReferences(GlyphSubtable[] subtables, Map/*<String,LookupTable>*/ lookupTables) {
if (subtables != null) {
for (int i = 0, n = subtables.length; i < n; i++) {
GlyphSubtable st = subtables [ i ];
if (st != null) {
- st.resolveLookupReferences (lookupTables);
+ st.resolveLookupReferences(lookupTables);
}
}
}
* @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) {
+ 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);
+ return GlyphSubstitutionSubtable.substitute(gs, script, language, feature, (GlyphSubstitutionSubtable[]) subtablesArray, sct);
} else {
return gs;
}
* @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) {
+ public GlyphSequence substitute(GlyphSubstitutionState ss, int sequenceIndex) {
if (performsSubstitution()) {
- return GlyphSubstitutionSubtable.substitute (ss, (GlyphSubstitutionSubtable[]) subtablesArray, sequenceIndex);
+ return GlyphSubstitutionSubtable.substitute(ss, (GlyphSubstitutionSubtable[]) subtablesArray, sequenceIndex);
} else {
return ss.getInput();
}
* @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) {
+ 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);
+ return GlyphPositioningSubtable.position(gs, script, language, feature, fontSize, (GlyphPositioningSubtable[]) subtablesArray, widths, adjustments, sct);
} else {
return false;
}
* @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) {
+ public boolean position(GlyphPositioningState ps, int sequenceIndex) {
if (performsPositioning()) {
- return GlyphPositioningSubtable.position (ps, (GlyphPositioningSubtable[]) subtablesArray, sequenceIndex);
+ return GlyphPositioningSubtable.position(ps, (GlyphPositioningSubtable[]) subtablesArray, sequenceIndex);
} else {
return false;
}
* @return true if identifier of the specified lookup table is the same
* as the identifier of this lookup table
*/
- public boolean equals (Object o) {
+ public boolean equals(Object o) {
if (o instanceof LookupTable) {
LookupTable lt = (LookupTable) o;
return idOrdinal == lt.idOrdinal;
* "lu(DIGIT)+", with comparison based on numerical ordering of numbers expressed by
* (DIGIT)+.
*/
- public int compareTo (Object o) {
+ public int compareTo(Object o) {
if (o instanceof LookupTable) {
LookupTable lt = (LookupTable) o;
int i = idOrdinal;
/** {@inheritDoc} */
public String toString() {
StringBuffer sb = new StringBuffer();
- sb.append ("{ ");
- sb.append ("id = " + id);
- sb.append (", subtables = " + subtables);
- sb.append (" }");
+ sb.append("{ ");
+ sb.append("id = " + id);
+ sb.append(", subtables = " + subtables);
+ sb.append(" }");
return sb.toString();
}
- private static List/*<GlyphSubtable>*/ makeSingleton (GlyphSubtable subtable) {
+ private static List/*<GlyphSubtable>*/ makeSingleton(GlyphSubtable subtable) {
if (subtable == null) {
return null;
} else {
- List/*<GlyphSubtable>*/ stl = new ArrayList/*<GlyphSubtable>*/ (1);
- stl.add (subtable);
+ List/*<GlyphSubtable>*/ stl = new ArrayList/*<GlyphSubtable>*/(1);
+ stl.add(subtable);
return stl;
}
}
* @param lookupTable a glyph lookup table
* @param feature a feature that caused lookup table selection
*/
- public UseSpec (LookupTable lookupTable, String feature) {
+ public UseSpec(LookupTable lookupTable, String feature) {
this.lookupTable = lookupTable;
this.feature = feature;
}
* @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);
+ public GlyphSequence substitute(GlyphSequence gs, String script, String language, ScriptContextTester sct) {
+ return lookupTable.substitute(gs, script, language, feature, sct);
}
/**
* @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);
+ 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} */
}
/** {@inheritDoc} */
- public boolean equals (Object o) {
+ public boolean equals(Object o) {
if (o instanceof UseSpec) {
UseSpec u = (UseSpec) o;
- return lookupTable.equals (u.lookupTable);
+ return lookupTable.equals(u.lookupTable);
} else {
return false;
}
}
/** {@inheritDoc} */
- public int compareTo (Object o) {
+ public int compareTo(Object o) {
if (o instanceof UseSpec) {
UseSpec u = (UseSpec) o;
- return lookupTable.compareTo (u.lookupTable);
+ return lookupTable.compareTo(u.lookupTable);
} else {
return -1;
}
* @param sequenceIndex the index into the input sequence
* @param lookupIndex the lookup table index
*/
- public RuleLookup (int sequenceIndex, int lookupIndex) {
+ public RuleLookup(int sequenceIndex, int lookupIndex) {
this.sequenceIndex = sequenceIndex;
this.lookupIndex = lookupIndex;
this.lookup = null;
* 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) {
+ public void resolveLookupReferences(Map/*<String,LookupTable>*/ lookupTables) {
if (lookupTables != null) {
- String lid = "lu" + Integer.toString (lookupIndex);
- LookupTable lt = (LookupTable) lookupTables.get (lid);
+ String lid = "lu" + Integer.toString(lookupIndex);
+ LookupTable lt = (LookupTable) 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());
+ log.warn("unable to resolve glyph lookup table reference '" + lid + "' amongst lookup tables: " + lookupTables.values());
}
}
}
* @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) {
+ protected Rule(RuleLookup[] lookups, int inputSequenceLength) {
assert lookups != null;
this.lookups = lookups;
this.inputSequenceLength = 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) {
+ public void resolveLookupReferences(Map/*<String,LookupTable>*/ lookupTables) {
if (lookups != null) {
for (int i = 0, n = lookups.length; i < n; i++) {
RuleLookup l = lookups [ i ];
if (l != null) {
- l.resolveLookupReferences (lookupTables);
+ l.resolveLookupReferences(lookupTables);
}
}
}
/** {@inheritDoc} */
public String toString() {
- return "{ lookups = " + Arrays.toString (lookups) + ", inputSequenceLength = " + inputSequenceLength + " }";
+ return "{ lookups = " + Arrays.toString(lookups) + ", inputSequenceLength = " + inputSequenceLength + " }";
}
}
* @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);
+ public GlyphSequenceRule(RuleLookup[] lookups, int inputSequenceLength, int[] glyphs) {
+ super(lookups, inputSequenceLength);
assert glyphs != null;
this.glyphs = glyphs;
}
* @param firstGlyph to fill in first glyph entry
* @return the glyphs augmented by first glyph
*/
- public int[] getGlyphs (int firstGlyph) {
+ public int[] getGlyphs(int firstGlyph) {
int[] ga = new int [ glyphs.length + 1 ];
ga [ 0 ] = firstGlyph;
- System.arraycopy (glyphs, 0, ga, 1, glyphs.length);
+ 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 (" }");
+ sb.append("{ ");
+ sb.append("lookups = " + Arrays.toString(getLookups()));
+ sb.append(", glyphs = " + Arrays.toString(glyphs));
+ sb.append(" }");
return sb.toString();
}
* @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);
+ public ClassSequenceRule(RuleLookup[] lookups, int inputSequenceLength, int[] classes) {
+ super(lookups, inputSequenceLength);
assert classes != null;
this.classes = classes;
}
* @param firstClass to fill in first class entry
* @return the classes augmented by first class
*/
- public int[] getClasses (int firstClass) {
+ public int[] getClasses(int firstClass) {
int[] ca = new int [ classes.length + 1 ];
ca [ 0 ] = firstClass;
- System.arraycopy (classes, 0, ca, 1, classes.length);
+ 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 (" }");
+ sb.append("{ ");
+ sb.append("lookups = " + Arrays.toString(getLookups()));
+ sb.append(", classes = " + Arrays.toString(classes));
+ sb.append(" }");
return sb.toString();
}
* @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);
+ public CoverageSequenceRule(RuleLookup[] lookups, int inputSequenceLength, GlyphCoverageTable[] coverages) {
+ super(lookups, inputSequenceLength);
assert coverages != null;
this.coverages = 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 (" }");
+ sb.append("{ ");
+ sb.append("lookups = " + Arrays.toString(getLookups()));
+ sb.append(", coverages = " + Arrays.toString(coverages));
+ sb.append(" }");
return sb.toString();
}
* @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);
+ 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;
/** {@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 (" }");
+ 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();
}
* @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);
+ 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;
/** {@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 (" }");
+ 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();
}
* @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);
+ 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;
/** {@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 (" }");
+ 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();
}
* @param rules the rules
* @throws AdvancedTypographicTableFormatException if rules or some element of rules is null
*/
- public RuleSet (Rule[] rules) throws AdvancedTypographicTableFormatException {
+ public RuleSet(Rule[] rules) throws AdvancedTypographicTableFormatException {
// enforce rules array instance
if (rules == null) {
- throw new AdvancedTypographicTableFormatException ("rules[] is null");
+ throw new AdvancedTypographicTableFormatException("rules[] is null");
}
this.rules = 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) {
+ public void resolveLookupReferences(Map/*<String,LookupTable>*/ lookupTables) {
if (rules != null) {
for (int i = 0, n = rules.length; i < n; i++) {
Rule r = rules [ i ];
if (r != null) {
- r.resolveLookupReferences (lookupTables);
+ r.resolveLookupReferences(lookupTables);
}
}
}
/** {@inheritDoc} */
public String toString() {
- return "{ rules = " + Arrays.toString (rules) + " }";
+ return "{ rules = " + Arrays.toString(rules) + " }";
}
}
* @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);
+ 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++) {
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());
+ if ((r != null) && ! c.isInstance(r)) {
+ throw new AdvancedTypographicTableFormatException("rules[" + i + "] is not an instance of " + c.getName());
}
}
}
* @param ttf parent font file reader (must be non-null)
* @param in font file reader (must be non-null)
*/
- public OTFAdvancedTypographicTableReader (TTFFile ttf, FontFileReader in) {
+ public OTFAdvancedTypographicTableReader(TTFFile ttf, FontFileReader in) {
assert ttf != null;
assert in != null;
this.ttf = ttf;
throw e;
} catch (IOException e) {
resetATStateAll();
- throw new AdvancedTypographicTableFormatException (e.getMessage(), e);
+ throw new AdvancedTypographicTableFormatException(e.getMessage(), e);
} finally {
resetATState();
}
log.debug(tableTag + " lang sys table non-required feature index: " + fi);
}
fia[i] = fi;
- fl.add ("f" + fi);
+ fl.add("f" + fi);
}
if (seLanguages == null) {
seLanguages = new java.util.LinkedHashMap();
}
- seLanguages.put (langSysTag, new Object[] { rfi, fl });
+ seLanguages.put(langSysTag, new Object[] { rfi, fl });
}
private static String defaultTag = "dflt";
dl = 0;
dt = lt;
}
- ll.add (lt);
+ ll.add(lt);
}
// read non-default language system tables
for (int i = 0, n = nl; i < n; i++) {
- readLangSysTable (tableTag, scriptTable + loa [ i ], lta [ i ]);
+ readLangSysTable(tableTag, scriptTable + loa [ i ], lta [ i ]);
}
}
// read default language system table (if specified)
if (dl > 0) {
- readLangSysTable (tableTag, scriptTable + dl, dt);
+ readLangSysTable(tableTag, scriptTable + dl, dt);
} else if (dt != null) {
if (log.isDebugEnabled()) {
log.debug(tableTag + " lang sys default: " + dt);
}
}
- seScripts.put (scriptTag, new Object[] { dt, ll, seLanguages });
+ seScripts.put(scriptTag, new Object[] { dt, ll, seLanguages });
seLanguages = null;
}
// read script tables
for (int i = 0, n = ns; i < n; i++) {
seLanguages = null;
- readScriptTable (tableTag, scriptList + soa [ i ], sta [ i ]);
+ readScriptTable(tableTag, scriptList + soa [ i ], sta [ i ]);
}
}
}
log.debug(tableTag + " feature table lookup index: " + li);
}
lia[i] = li;
- lul.add ("lu" + li);
+ lul.add("lu" + li);
}
- seFeatures.put ("f" + featureIndex, new Object[] { featureTag, lul });
+ seFeatures.put("f" + featureIndex, new Object[] { featureTag, lul });
}
private void readFeatureList(TTFTableName tableTag, long featureList) throws IOException {
if (log.isDebugEnabled()) {
log.debug(tableTag + " feature index: " + i);
}
- readFeatureTable (tableTag, featureList + foa [ i ], fta [ i ], i);
+ readFeatureTable(tableTag, featureList + foa [ i ], fta [ i ], i);
}
}
}
static final int MARK_ATTACHMENT = 4;
private GDEFLookupType() {
}
- public static int getSubtableType (int lt) {
+ public static int getSubtableType(int lt) {
int st;
switch (lt) {
case GDEFLookupType.GLYPH_CLASS:
static final int REVERSE_CHAINED_SINGLE = 8;
private GSUBLookupType() {
}
- public static int getSubtableType (int lt) {
+ public static int getSubtableType(int lt) {
int st;
switch (lt) {
case GSUBLookupType.SINGLE:
if (first) {
first = false;
} else {
- sb.append ('|');
+ sb.append('|');
}
- sb.append ("RightToLeft");
+ sb.append("RightToLeft");
}
if ((flags & IGNORE_BASE_GLYPHS) != 0) {
if (first) {
first = false;
} else {
- sb.append ('|');
+ sb.append('|');
}
- sb.append ("IgnoreBaseGlyphs");
+ sb.append("IgnoreBaseGlyphs");
}
if ((flags & IGNORE_LIGATURE) != 0) {
if (first) {
first = false;
} else {
- sb.append ('|');
+ sb.append('|');
}
- sb.append ("IgnoreLigature");
+ sb.append("IgnoreLigature");
}
if ((flags & IGNORE_MARKS) != 0) {
if (first) {
first = false;
} else {
- sb.append ('|');
+ sb.append('|');
}
- sb.append ("IgnoreMarks");
+ sb.append("IgnoreMarks");
}
if ((flags & USE_MARK_FILTERING_SET) != 0) {
if (first) {
first = false;
} else {
- sb.append ('|');
+ sb.append('|');
}
- sb.append ("UseMarkFilteringSet");
+ sb.append("UseMarkFilteringSet");
}
if (sb.length() == 0) {
- sb.append ('-');
+ sb.append('-');
}
return sb.toString();
}
List entries = new java.util.ArrayList();
in.seekSet(tableOffset);
// skip over format (already known)
- in.skip (2);
+ in.skip(2);
// read glyph count
int ng = in.readTTFUShort();
int[] ga = new int[ng];
for (int i = 0, n = ng; i < n; i++) {
int g = in.readTTFUShort();
ga[i] = g;
- entries.add (Integer.valueOf(g));
+ entries.add(Integer.valueOf(g));
}
// dump info if debugging
if (log.isDebugEnabled()) {
log.debug(label + " glyphs: " + toString(ga));
}
- return GlyphCoverageTable.createCoverageTable (entries);
+ return GlyphCoverageTable.createCoverageTable(entries);
}
private GlyphCoverageTable readCoverageTableFormat2(String label, long tableOffset, int coverageFormat) throws IOException {
List entries = new java.util.ArrayList();
in.seekSet(tableOffset);
// skip over format (already known)
- in.skip (2);
+ in.skip(2);
// read range record count
int nr = in.readTTFUShort();
for (int i = 0, n = nr; i < n; i++) {
if (log.isDebugEnabled()) {
log.debug(label + " range[" + i + "]: [" + s + "," + e + "]: " + m);
}
- entries.add (new GlyphCoverageTable.MappingRange (s, e, m));
+ entries.add(new GlyphCoverageTable.MappingRange(s, e, m));
}
- return GlyphCoverageTable.createCoverageTable (entries);
+ return GlyphCoverageTable.createCoverageTable(entries);
}
private GlyphCoverageTable readCoverageTable(String label, long tableOffset) throws IOException {
// read coverage table format
int cf = in.readTTFUShort();
if (cf == 1) {
- gct = readCoverageTableFormat1 (label, tableOffset, cf);
+ gct = readCoverageTableFormat1(label, tableOffset, cf);
} else if (cf == 2) {
- gct = readCoverageTableFormat2 (label, tableOffset, cf);
+ gct = readCoverageTableFormat2(label, tableOffset, cf);
} else {
- throw new AdvancedTypographicTableFormatException ("unsupported coverage table format: " + cf);
+ throw new AdvancedTypographicTableFormatException("unsupported coverage table format: " + cf);
}
- in.seekSet (cp);
+ in.seekSet(cp);
return gct;
}
List entries = new java.util.ArrayList();
in.seekSet(tableOffset);
// skip over format (already known)
- in.skip (2);
+ in.skip(2);
// read start glyph
int sg = in.readTTFUShort();
- entries.add (Integer.valueOf(sg));
+ entries.add(Integer.valueOf(sg));
// read glyph count
int ng = in.readTTFUShort();
// read glyph classes
for (int i = 0, n = ng; i < n; i++) {
int gc = in.readTTFUShort();
ca[i] = gc;
- entries.add (Integer.valueOf(gc));
+ entries.add(Integer.valueOf(gc));
}
// dump info if debugging
if (log.isDebugEnabled()) {
log.debug(label + " glyph classes: " + toString(ca));
}
- return GlyphClassTable.createClassTable (entries);
+ return GlyphClassTable.createClassTable(entries);
}
private GlyphClassTable readClassDefTableFormat2(String label, long tableOffset, int classFormat) throws IOException {
List entries = new java.util.ArrayList();
in.seekSet(tableOffset);
// skip over format (already known)
- in.skip (2);
+ in.skip(2);
// read range record count
int nr = in.readTTFUShort();
for (int i = 0, n = nr; i < n; i++) {
if (log.isDebugEnabled()) {
log.debug(label + " range[" + i + "]: [" + s + "," + e + "]: " + m);
}
- entries.add (new GlyphClassTable.MappingRange (s, e, m));
+ entries.add(new GlyphClassTable.MappingRange(s, e, m));
}
- return GlyphClassTable.createClassTable (entries);
+ return GlyphClassTable.createClassTable(entries);
}
private GlyphClassTable readClassDefTable(String label, long tableOffset) throws IOException {
// read class table format
int cf = in.readTTFUShort();
if (cf == 1) {
- gct = readClassDefTableFormat1 (label, tableOffset, cf);
+ gct = readClassDefTableFormat1(label, tableOffset, cf);
} else if (cf == 2) {
- gct = readClassDefTableFormat2 (label, tableOffset, cf);
+ gct = readClassDefTableFormat2(label, tableOffset, cf);
} else {
- throw new AdvancedTypographicTableFormatException ("unsupported class definition table format: " + cf);
+ throw new AdvancedTypographicTableFormatException("unsupported class definition table format: " + cf);
}
- in.seekSet (cp);
+ in.seekSet(cp);
return gct;
}
String tableTag = "GSUB";
in.seekSet(subtableOffset);
// skip over format (already known)
- in.skip (2);
+ in.skip(2);
// read coverage offset
int co = in.readTTFUShort();
// read delta glyph
log.debug(tableTag + " single substitution delta: " + dg);
}
// read coverage table
- seMapping = readCoverageTable (tableTag + " single substitution coverage", subtableOffset + co);
- seEntries.add (Integer.valueOf (dg));
+ seMapping = readCoverageTable(tableTag + " single substitution coverage", subtableOffset + co);
+ seEntries.add(Integer.valueOf(dg));
}
private void readSingleSubTableFormat2(int lookupType, int lookupFlags, long subtableOffset, int subtableFormat) throws IOException {
String tableTag = "GSUB";
in.seekSet(subtableOffset);
// skip over format (already known)
- in.skip (2);
+ in.skip(2);
// read coverage offset
int co = in.readTTFUShort();
// read glyph count
log.debug(tableTag + " single substitution glyph count: " + ng);
}
// read coverage table
- seMapping = readCoverageTable (tableTag + " single substitution coverage", subtableOffset + co);
+ seMapping = readCoverageTable(tableTag + " single substitution coverage", subtableOffset + co);
// read glyph substitutions
int[] gsa = new int[ng];
for (int i = 0, n = ng; i < n; i++) {
log.debug(tableTag + " single substitution glyph[" + i + "]: " + gs);
}
gsa[i] = gs;
- seEntries.add (Integer.valueOf (gs));
+ seEntries.add(Integer.valueOf(gs));
}
}
// read substitution subtable format
int sf = in.readTTFUShort();
if (sf == 1) {
- readSingleSubTableFormat1 (lookupType, lookupFlags, subtableOffset, sf);
+ readSingleSubTableFormat1(lookupType, lookupFlags, subtableOffset, sf);
} else if (sf == 2) {
- readSingleSubTableFormat2 (lookupType, lookupFlags, subtableOffset, sf);
+ readSingleSubTableFormat2(lookupType, lookupFlags, subtableOffset, sf);
} else {
- throw new AdvancedTypographicTableFormatException ("unsupported single substitution subtable format: " + sf);
+ throw new AdvancedTypographicTableFormatException("unsupported single substitution subtable format: " + sf);
}
return sf;
}
String tableTag = "GSUB";
in.seekSet(subtableOffset);
// skip over format (already known)
- in.skip (2);
+ in.skip(2);
// read coverage offset
int co = in.readTTFUShort();
// read sequence count
log.debug(tableTag + " multiple substitution sequence count: " + ns);
}
// read coverage table
- seMapping = readCoverageTable (tableTag + " multiple substitution coverage", subtableOffset + co);
+ seMapping = readCoverageTable(tableTag + " multiple substitution coverage", subtableOffset + co);
// read sequence table offsets
int[] soa = new int[ns];
for (int i = 0, n = ns; i < n; i++) {
ga = null;
}
if (log.isDebugEnabled()) {
- log.debug(tableTag + " multiple substitution sequence[" + i + "]: " + toString (ga));
+ log.debug(tableTag + " multiple substitution sequence[" + i + "]: " + toString(ga));
}
gsa [ i ] = ga;
}
- seEntries.add (gsa);
+ seEntries.add(gsa);
}
private int readMultipleSubTable(int lookupType, int lookupFlags, long subtableOffset) throws IOException {
// read substitution subtable format
int sf = in.readTTFUShort();
if (sf == 1) {
- readMultipleSubTableFormat1 (lookupType, lookupFlags, subtableOffset, sf);
+ readMultipleSubTableFormat1(lookupType, lookupFlags, subtableOffset, sf);
} else {
- throw new AdvancedTypographicTableFormatException ("unsupported multiple substitution subtable format: " + sf);
+ throw new AdvancedTypographicTableFormatException("unsupported multiple substitution subtable format: " + sf);
}
return sf;
}
String tableTag = "GSUB";
in.seekSet(subtableOffset);
// skip over format (already known)
- in.skip (2);
+ in.skip(2);
// read coverage offset
int co = in.readTTFUShort();
// read alternate set count
log.debug(tableTag + " alternate substitution alternate set count: " + ns);
}
// read coverage table
- seMapping = readCoverageTable (tableTag + " alternate substitution coverage", subtableOffset + co);
+ seMapping = readCoverageTable(tableTag + " alternate substitution coverage", subtableOffset + co);
// read alternate set table offsets
int[] soa = new int[ns];
for (int i = 0, n = ns; i < n; i++) {
ga[j] = gs;
}
if (log.isDebugEnabled()) {
- log.debug(tableTag + " alternate substitution alternate set[" + i + "]: " + toString (ga));
+ log.debug(tableTag + " alternate substitution alternate set[" + i + "]: " + toString(ga));
}
- seEntries.add (ga);
+ seEntries.add(ga);
}
}
// read substitution subtable format
int sf = in.readTTFUShort();
if (sf == 1) {
- readAlternateSubTableFormat1 (lookupType, lookupFlags, subtableOffset, sf);
+ readAlternateSubTableFormat1(lookupType, lookupFlags, subtableOffset, sf);
} else {
- throw new AdvancedTypographicTableFormatException ("unsupported alternate substitution subtable format: " + sf);
+ throw new AdvancedTypographicTableFormatException("unsupported alternate substitution subtable format: " + sf);
}
return sf;
}
String tableTag = "GSUB";
in.seekSet(subtableOffset);
// skip over format (already known)
- in.skip (2);
+ in.skip(2);
// read coverage offset
int co = in.readTTFUShort();
// read ligature set count
log.debug(tableTag + " ligature substitution ligature set count: " + ns);
}
// read coverage table
- seMapping = readCoverageTable (tableTag + " ligature substitution coverage", subtableOffset + co);
+ seMapping = readCoverageTable(tableTag + " ligature substitution coverage", subtableOffset + co);
// read ligature set table offsets
int[] soa = new int[ns];
for (int i = 0, n = ns; i < n; i++) {
ca[k] = in.readTTFUShort();
}
if (log.isDebugEnabled()) {
- log.debug(tableTag + " ligature substitution ligature set[" + i + "]: ligature(" + lg + "), components: " + toString (ca));
+ log.debug(tableTag + " ligature substitution ligature set[" + i + "]: ligature(" + lg + "), components: " + toString(ca));
}
- ligs.add (new GlyphSubstitutionTable.Ligature (lg, ca));
+ ligs.add(new GlyphSubstitutionTable.Ligature(lg, ca));
}
- seEntries.add (new GlyphSubstitutionTable.LigatureSet (ligs));
+ seEntries.add(new GlyphSubstitutionTable.LigatureSet(ligs));
}
}
// read substitution subtable format
int sf = in.readTTFUShort();
if (sf == 1) {
- readLigatureSubTableFormat1 (lookupType, lookupFlags, subtableOffset, sf);
+ readLigatureSubTableFormat1(lookupType, lookupFlags, subtableOffset, sf);
} else {
- throw new AdvancedTypographicTableFormatException ("unsupported ligature substitution subtable format: " + sf);
+ throw new AdvancedTypographicTableFormatException("unsupported ligature substitution subtable format: " + sf);
}
return sf;
}
for (int i = 0, n = numLookups; i < n; i++) {
int sequenceIndex = in.readTTFUShort();
int lookupIndex = in.readTTFUShort();
- la [ i ] = new GlyphTable.RuleLookup (sequenceIndex, lookupIndex);
+ la [ i ] = new GlyphTable.RuleLookup(sequenceIndex, lookupIndex);
// dump info if debugging and header is non-null
if (log.isDebugEnabled() && (header != null)) {
log.debug(header + "lookup[" + i + "]: " + la[i]);
String tableTag = "GSUB";
in.seekSet(subtableOffset);
// skip over format (already known)
- in.skip (2);
+ in.skip(2);
// read coverage offset
int co = in.readTTFUShort();
// read rule set count
// read coverage table
GlyphCoverageTable ct;
if (co > 0) {
- ct = readCoverageTable (tableTag + " contextual substitution coverage", subtableOffset + co);
+ ct = readCoverageTable(tableTag + " contextual substitution coverage", subtableOffset + co);
} else {
ct = null;
}
int rso = rsoa [ i ];
if (rso > 0) {
// seek to rule set [ i ]
- in.seekSet (subtableOffset + rso);
+ in.seekSet(subtableOffset + rso);
// read rule count
int nr = in.readTTFUShort();
// read rule offsets
int ro = roa [ j ];
if (ro > 0) {
// seek to rule [ j ]
- in.seekSet (subtableOffset + rso + ro);
+ in.seekSet(subtableOffset + rso + ro);
// read glyph count
int ng = in.readTTFUShort();
// read rule lookup count
if (log.isDebugEnabled()) {
header = tableTag + " contextual substitution lookups @rule[" + i + "][" + j + "]: ";
}
- GlyphTable.RuleLookup[] lookups = readRuleLookups (nl, header);
- r = new GlyphTable.GlyphSequenceRule (lookups, ng, glyphs);
+ GlyphTable.RuleLookup[] lookups = readRuleLookups(nl, header);
+ r = new GlyphTable.GlyphSequenceRule(lookups, ng, glyphs);
} else {
r = null;
}
ra [ j ] = r;
}
- rs = new GlyphTable.HomogeneousRuleSet (ra);
+ rs = new GlyphTable.HomogeneousRuleSet(ra);
} else {
rs = null;
}
}
// store results
seMapping = ct;
- seEntries.add (rsa);
+ seEntries.add(rsa);
}
private void readContextualSubTableFormat2(int lookupType, int lookupFlags, long subtableOffset, int subtableFormat) throws IOException {
String tableTag = "GSUB";
in.seekSet(subtableOffset);
// skip over format (already known)
- in.skip (2);
+ in.skip(2);
// read coverage offset
int co = in.readTTFUShort();
// read class def table offset
// read coverage table
GlyphCoverageTable ct;
if (co > 0) {
- ct = readCoverageTable (tableTag + " contextual substitution coverage", subtableOffset + co);
+ ct = readCoverageTable(tableTag + " contextual substitution coverage", subtableOffset + co);
} else {
ct = null;
}
// read class definition table
GlyphClassTable cdt;
if (cdo > 0) {
- cdt = readClassDefTable (tableTag + " contextual substitution class definition", subtableOffset + cdo);
+ cdt = readClassDefTable(tableTag + " contextual substitution class definition", subtableOffset + cdo);
} else {
cdt = null;
}
GlyphTable.RuleSet rs;
if (cso > 0) {
// seek to rule set [ i ]
- in.seekSet (subtableOffset + cso);
+ in.seekSet(subtableOffset + cso);
// read rule count
int nr = in.readTTFUShort();
// read rule offsets
GlyphTable.ClassSequenceRule r;
if (ro > 0) {
// seek to rule [ j ]
- in.seekSet (subtableOffset + cso + ro);
+ in.seekSet(subtableOffset + cso + ro);
// read glyph count
int ng = in.readTTFUShort();
// read rule lookup count
if (log.isDebugEnabled()) {
header = tableTag + " contextual substitution lookups @rule[" + i + "][" + j + "]: ";
}
- GlyphTable.RuleLookup[] lookups = readRuleLookups (nl, header);
- r = new GlyphTable.ClassSequenceRule (lookups, ng, classes);
+ GlyphTable.RuleLookup[] lookups = readRuleLookups(nl, header);
+ r = new GlyphTable.ClassSequenceRule(lookups, ng, classes);
} else {
assert ro > 0 : "unexpected null subclass rule offset";
r = null;
}
ra [ j ] = r;
}
- rs = new GlyphTable.HomogeneousRuleSet (ra);
+ rs = new GlyphTable.HomogeneousRuleSet(ra);
} else {
rs = null;
}
}
// store results
seMapping = ct;
- seEntries.add (cdt);
- seEntries.add (Integer.valueOf (ngc));
- seEntries.add (rsa);
+ seEntries.add(cdt);
+ seEntries.add(Integer.valueOf(ngc));
+ seEntries.add(rsa);
}
private void readContextualSubTableFormat3(int lookupType, int lookupFlags, long subtableOffset, int subtableFormat) throws IOException {
String tableTag = "GSUB";
in.seekSet(subtableOffset);
// skip over format (already known)
- in.skip (2);
+ in.skip(2);
// read glyph (input sequence length) count
int ng = in.readTTFUShort();
// read substitution lookup count
int gco = gcoa [ i ];
GlyphCoverageTable gct;
if (gco > 0) {
- gct = readCoverageTable (tableTag + " contextual substitution coverage[" + i + "]", subtableOffset + gco);
+ gct = readCoverageTable(tableTag + " contextual substitution coverage[" + i + "]", subtableOffset + gco);
} else {
gct = null;
}
if (log.isDebugEnabled()) {
header = tableTag + " contextual substitution lookups: ";
}
- GlyphTable.RuleLookup[] lookups = readRuleLookups (nl, header);
+ GlyphTable.RuleLookup[] lookups = readRuleLookups(nl, header);
// construct rule, rule set, and rule set array
- GlyphTable.Rule r = new GlyphTable.CoverageSequenceRule (lookups, ng, gca);
- GlyphTable.RuleSet rs = new GlyphTable.HomogeneousRuleSet (new GlyphTable.Rule[] {r});
+ GlyphTable.Rule r = new GlyphTable.CoverageSequenceRule(lookups, ng, gca);
+ GlyphTable.RuleSet rs = new GlyphTable.HomogeneousRuleSet(new GlyphTable.Rule[] {r});
GlyphTable.RuleSet[] rsa = new GlyphTable.RuleSet[] {rs};
// store results
assert (gca != null) && (gca.length > 0);
seMapping = gca[0];
- seEntries.add (rsa);
+ seEntries.add(rsa);
}
private int readContextualSubTable(int lookupType, int lookupFlags, long subtableOffset) throws IOException {
// read substitution subtable format
int sf = in.readTTFUShort();
if (sf == 1) {
- readContextualSubTableFormat1 (lookupType, lookupFlags, subtableOffset, sf);
+ readContextualSubTableFormat1(lookupType, lookupFlags, subtableOffset, sf);
} else if (sf == 2) {
- readContextualSubTableFormat2 (lookupType, lookupFlags, subtableOffset, sf);
+ readContextualSubTableFormat2(lookupType, lookupFlags, subtableOffset, sf);
} else if (sf == 3) {
- readContextualSubTableFormat3 (lookupType, lookupFlags, subtableOffset, sf);
+ readContextualSubTableFormat3(lookupType, lookupFlags, subtableOffset, sf);
} else {
- throw new AdvancedTypographicTableFormatException ("unsupported contextual substitution subtable format: " + sf);
+ throw new AdvancedTypographicTableFormatException("unsupported contextual substitution subtable format: " + sf);
}
return sf;
}
String tableTag = "GSUB";
in.seekSet(subtableOffset);
// skip over format (already known)
- in.skip (2);
+ in.skip(2);
// read coverage offset
int co = in.readTTFUShort();
// read rule set count
// read coverage table
GlyphCoverageTable ct;
if (co > 0) {
- ct = readCoverageTable (tableTag + " chained contextual substitution coverage", subtableOffset + co);
+ ct = readCoverageTable(tableTag + " chained contextual substitution coverage", subtableOffset + co);
} else {
ct = null;
}
int rso = rsoa [ i ];
if (rso > 0) {
// seek to rule set [ i ]
- in.seekSet (subtableOffset + rso);
+ in.seekSet(subtableOffset + rso);
// read rule count
int nr = in.readTTFUShort();
// read rule offsets
int ro = roa [ j ];
if (ro > 0) {
// seek to rule [ j ]
- in.seekSet (subtableOffset + rso + ro);
+ in.seekSet(subtableOffset + rso + ro);
// read backtrack glyph count
int nbg = in.readTTFUShort();
// read backtrack glyphs
if (log.isDebugEnabled()) {
header = tableTag + " contextual substitution lookups @rule[" + i + "][" + j + "]: ";
}
- GlyphTable.RuleLookup[] lookups = readRuleLookups (nl, header);
- r = new GlyphTable.ChainedGlyphSequenceRule (lookups, nig, glyphs, backtrackGlyphs, lookaheadGlyphs);
+ GlyphTable.RuleLookup[] lookups = readRuleLookups(nl, header);
+ r = new GlyphTable.ChainedGlyphSequenceRule(lookups, nig, glyphs, backtrackGlyphs, lookaheadGlyphs);
} else {
r = null;
}
ra [ j ] = r;
}
- rs = new GlyphTable.HomogeneousRuleSet (ra);
+ rs = new GlyphTable.HomogeneousRuleSet(ra);
} else {
rs = null;
}
}
// store results
seMapping = ct;
- seEntries.add (rsa);
+ seEntries.add(rsa);
}
private void readChainedContextualSubTableFormat2(int lookupType, int lookupFlags, long subtableOffset, int subtableFormat) throws IOException {
String tableTag = "GSUB";
in.seekSet(subtableOffset);
// skip over format (already known)
- in.skip (2);
+ in.skip(2);
// read coverage offset
int co = in.readTTFUShort();
// read backtrack class def table offset
// read coverage table
GlyphCoverageTable ct;
if (co > 0) {
- ct = readCoverageTable (tableTag + " chained contextual substitution coverage", subtableOffset + co);
+ ct = readCoverageTable(tableTag + " chained contextual substitution coverage", subtableOffset + co);
} else {
ct = null;
}
// read backtrack class definition table
GlyphClassTable bcdt;
if (bcdo > 0) {
- bcdt = readClassDefTable (tableTag + " contextual substitution backtrack class definition", subtableOffset + bcdo);
+ bcdt = readClassDefTable(tableTag + " contextual substitution backtrack class definition", subtableOffset + bcdo);
} else {
bcdt = null;
}
// read input class definition table
GlyphClassTable icdt;
if (icdo > 0) {
- icdt = readClassDefTable (tableTag + " contextual substitution input class definition", subtableOffset + icdo);
+ icdt = readClassDefTable(tableTag + " contextual substitution input class definition", subtableOffset + icdo);
} else {
icdt = null;
}
// read lookahead class definition table
GlyphClassTable lcdt;
if (lcdo > 0) {
- lcdt = readClassDefTable (tableTag + " contextual substitution lookahead class definition", subtableOffset + lcdo);
+ lcdt = readClassDefTable(tableTag + " contextual substitution lookahead class definition", subtableOffset + lcdo);
} else {
lcdt = null;
}
GlyphTable.RuleSet rs;
if (cso > 0) {
// seek to rule set [ i ]
- in.seekSet (subtableOffset + cso);
+ in.seekSet(subtableOffset + cso);
// read rule count
int nr = in.readTTFUShort();
// read rule offsets
GlyphTable.ChainedClassSequenceRule r;
if (ro > 0) {
// seek to rule [ j ]
- in.seekSet (subtableOffset + cso + ro);
+ in.seekSet(subtableOffset + cso + ro);
// read backtrack glyph class count
int nbc = in.readTTFUShort();
// read backtrack glyph classes
if (log.isDebugEnabled()) {
header = tableTag + " contextual substitution lookups @rule[" + i + "][" + j + "]: ";
}
- GlyphTable.RuleLookup[] lookups = readRuleLookups (nl, header);
- r = new GlyphTable.ChainedClassSequenceRule (lookups, nic, classes, backtrackClasses, lookaheadClasses);
+ GlyphTable.RuleLookup[] lookups = readRuleLookups(nl, header);
+ r = new GlyphTable.ChainedClassSequenceRule(lookups, nic, classes, backtrackClasses, lookaheadClasses);
} else {
r = null;
}
ra [ j ] = r;
}
- rs = new GlyphTable.HomogeneousRuleSet (ra);
+ rs = new GlyphTable.HomogeneousRuleSet(ra);
} else {
rs = null;
}
}
// store results
seMapping = ct;
- seEntries.add (icdt);
- seEntries.add (bcdt);
- seEntries.add (lcdt);
- seEntries.add (Integer.valueOf (ngc));
- seEntries.add (rsa);
+ seEntries.add(icdt);
+ seEntries.add(bcdt);
+ seEntries.add(lcdt);
+ seEntries.add(Integer.valueOf(ngc));
+ seEntries.add(rsa);
}
private void readChainedContextualSubTableFormat3(int lookupType, int lookupFlags, long subtableOffset, int subtableFormat) throws IOException {
String tableTag = "GSUB";
in.seekSet(subtableOffset);
// skip over format (already known)
- in.skip (2);
+ in.skip(2);
// read backtrack glyph count
int nbg = in.readTTFUShort();
// read backtrack glyph coverage offsets
int bgco = bgcoa [ i ];
GlyphCoverageTable bgct;
if (bgco > 0) {
- bgct = readCoverageTable (tableTag + " chained contextual substitution backtrack coverage[" + i + "]", subtableOffset + bgco);
+ bgct = readCoverageTable(tableTag + " chained contextual substitution backtrack coverage[" + i + "]", subtableOffset + bgco);
} else {
bgct = null;
}
int igco = igcoa [ i ];
GlyphCoverageTable igct;
if (igco > 0) {
- igct = readCoverageTable (tableTag + " chained contextual substitution input coverage[" + i + "]", subtableOffset + igco);
+ igct = readCoverageTable(tableTag + " chained contextual substitution input coverage[" + i + "]", subtableOffset + igco);
} else {
igct = null;
}
int lgco = lgcoa [ i ];
GlyphCoverageTable lgct;
if (lgco > 0) {
- lgct = readCoverageTable (tableTag + " chained contextual substitution lookahead coverage[" + i + "]", subtableOffset + lgco);
+ lgct = readCoverageTable(tableTag + " chained contextual substitution lookahead coverage[" + i + "]", subtableOffset + lgco);
} else {
lgct = null;
}
if (log.isDebugEnabled()) {
header = tableTag + " chained contextual substitution lookups: ";
}
- GlyphTable.RuleLookup[] lookups = readRuleLookups (nl, header);
+ GlyphTable.RuleLookup[] lookups = readRuleLookups(nl, header);
// construct rule, rule set, and rule set array
- GlyphTable.Rule r = new GlyphTable.ChainedCoverageSequenceRule (lookups, nig, igca, bgca, lgca);
- GlyphTable.RuleSet rs = new GlyphTable.HomogeneousRuleSet (new GlyphTable.Rule[] {r});
+ GlyphTable.Rule r = new GlyphTable.ChainedCoverageSequenceRule(lookups, nig, igca, bgca, lgca);
+ GlyphTable.RuleSet rs = new GlyphTable.HomogeneousRuleSet(new GlyphTable.Rule[] {r});
GlyphTable.RuleSet[] rsa = new GlyphTable.RuleSet[] {rs};
// store results
assert (igca != null) && (igca.length > 0);
seMapping = igca[0];
- seEntries.add (rsa);
+ seEntries.add(rsa);
}
private int readChainedContextualSubTable(int lookupType, int lookupFlags, long subtableOffset) throws IOException {
// read substitution subtable format
int sf = in.readTTFUShort();
if (sf == 1) {
- readChainedContextualSubTableFormat1 (lookupType, lookupFlags, subtableOffset, sf);
+ readChainedContextualSubTableFormat1(lookupType, lookupFlags, subtableOffset, sf);
} else if (sf == 2) {
- readChainedContextualSubTableFormat2 (lookupType, lookupFlags, subtableOffset, sf);
+ readChainedContextualSubTableFormat2(lookupType, lookupFlags, subtableOffset, sf);
} else if (sf == 3) {
- readChainedContextualSubTableFormat3 (lookupType, lookupFlags, subtableOffset, sf);
+ readChainedContextualSubTableFormat3(lookupType, lookupFlags, subtableOffset, sf);
} else {
- throw new AdvancedTypographicTableFormatException ("unsupported chained contextual substitution subtable format: " + sf);
+ throw new AdvancedTypographicTableFormatException("unsupported chained contextual substitution subtable format: " + sf);
}
return sf;
}
String tableTag = "GSUB";
in.seekSet(subtableOffset);
// skip over format (already known)
- in.skip (2);
+ in.skip(2);
// read extension lookup type
int lt = in.readTTFUShort();
// read extension offset
log.debug(tableTag + " extension substitution lookup table offset: " + eo);
}
// read referenced subtable from extended offset
- readGSUBSubtable (lt, lookupFlags, lookupSequence, subtableSequence, subtableOffset + eo);
+ readGSUBSubtable(lt, lookupFlags, lookupSequence, subtableSequence, subtableOffset + eo);
}
private int readExtensionSubTable(int lookupType, int lookupFlags, int lookupSequence, int subtableSequence, long subtableOffset) throws IOException {
// read substitution subtable format
int sf = in.readTTFUShort();
if (sf == 1) {
- readExtensionSubTableFormat1 (lookupType, lookupFlags, lookupSequence, subtableSequence, subtableOffset, sf);
+ readExtensionSubTableFormat1(lookupType, lookupFlags, lookupSequence, subtableSequence, subtableOffset, sf);
} else {
- throw new AdvancedTypographicTableFormatException ("unsupported extension substitution subtable format: " + sf);
+ throw new AdvancedTypographicTableFormatException("unsupported extension substitution subtable format: " + sf);
}
return sf;
}
String tableTag = "GSUB";
in.seekSet(subtableOffset);
// skip over format (already known)
- in.skip (2);
+ in.skip(2);
// read coverage offset
int co = in.readTTFUShort();
// read backtrack glyph count
log.debug(tableTag + " reverse chained contextual substitution glyphs: " + toString(glyphs));
}
// read coverage table
- GlyphCoverageTable ct = readCoverageTable (tableTag + " reverse chained contextual substitution coverage", subtableOffset + co);
+ GlyphCoverageTable ct = readCoverageTable(tableTag + " reverse chained contextual substitution coverage", subtableOffset + co);
// read backtrack coverage tables
GlyphCoverageTable[] bgca = new GlyphCoverageTable[nbg];
for (int i = 0; i < nbg; i++) {
int bgco = bgcoa[i];
GlyphCoverageTable bgct;
if (bgco > 0) {
- bgct = readCoverageTable (tableTag + " reverse chained contextual substitution backtrack coverage[" + i + "]", subtableOffset + bgco);
+ bgct = readCoverageTable(tableTag + " reverse chained contextual substitution backtrack coverage[" + i + "]", subtableOffset + bgco);
} else {
bgct = null;
}
int lgco = lgcoa[i];
GlyphCoverageTable lgct;
if (lgco > 0) {
- lgct = readCoverageTable (tableTag + " reverse chained contextual substitution lookahead coverage[" + i + "]", subtableOffset + lgco);
+ lgct = readCoverageTable(tableTag + " reverse chained contextual substitution lookahead coverage[" + i + "]", subtableOffset + lgco);
} else {
lgct = null;
}
}
// store results
seMapping = ct;
- seEntries.add (bgca);
- seEntries.add (lgca);
- seEntries.add (glyphs);
+ seEntries.add(bgca);
+ seEntries.add(lgca);
+ seEntries.add(glyphs);
}
private int readReverseChainedSingleSubTable(int lookupType, int lookupFlags, long subtableOffset) throws IOException {
// read substitution subtable format
int sf = in.readTTFUShort();
if (sf == 1) {
- readReverseChainedSingleSubTableFormat1 (lookupType, lookupFlags, subtableOffset, sf);
+ readReverseChainedSingleSubTableFormat1(lookupType, lookupFlags, subtableOffset, sf);
} else {
- throw new AdvancedTypographicTableFormatException ("unsupported reverse chained single substitution subtable format: " + sf);
+ throw new AdvancedTypographicTableFormatException("unsupported reverse chained single substitution subtable format: " + sf);
}
return sf;
}
int subtableFormat = -1;
switch (lookupType) {
case GSUBLookupType.SINGLE:
- subtableFormat = readSingleSubTable (lookupType, lookupFlags, subtableOffset);
+ subtableFormat = readSingleSubTable(lookupType, lookupFlags, subtableOffset);
break;
case GSUBLookupType.MULTIPLE:
- subtableFormat = readMultipleSubTable (lookupType, lookupFlags, subtableOffset);
+ subtableFormat = readMultipleSubTable(lookupType, lookupFlags, subtableOffset);
break;
case GSUBLookupType.ALTERNATE:
- subtableFormat = readAlternateSubTable (lookupType, lookupFlags, subtableOffset);
+ subtableFormat = readAlternateSubTable(lookupType, lookupFlags, subtableOffset);
break;
case GSUBLookupType.LIGATURE:
- subtableFormat = readLigatureSubTable (lookupType, lookupFlags, subtableOffset);
+ subtableFormat = readLigatureSubTable(lookupType, lookupFlags, subtableOffset);
break;
case GSUBLookupType.CONTEXTUAL:
- subtableFormat = readContextualSubTable (lookupType, lookupFlags, subtableOffset);
+ subtableFormat = readContextualSubTable(lookupType, lookupFlags, subtableOffset);
break;
case GSUBLookupType.CHAINED_CONTEXTUAL:
- subtableFormat = readChainedContextualSubTable (lookupType, lookupFlags, subtableOffset);
+ subtableFormat = readChainedContextualSubTable(lookupType, lookupFlags, subtableOffset);
break;
case GSUBLookupType.REVERSE_CHAINED_SINGLE:
- subtableFormat = readReverseChainedSingleSubTable (lookupType, lookupFlags, subtableOffset);
+ subtableFormat = readReverseChainedSingleSubTable(lookupType, lookupFlags, subtableOffset);
break;
case GSUBLookupType.EXTENSION:
- subtableFormat = readExtensionSubTable (lookupType, lookupFlags, lookupSequence, subtableSequence, subtableOffset);
+ subtableFormat = readExtensionSubTable(lookupType, lookupFlags, lookupSequence, subtableSequence, subtableOffset);
break;
default:
break;
}
- extractSESubState (GlyphTable.GLYPH_TABLE_TYPE_SUBSTITUTION, lookupType, lookupFlags, lookupSequence, subtableSequence, subtableFormat);
+ extractSESubState(GlyphTable.GLYPH_TABLE_TYPE_SUBSTITUTION, lookupType, lookupFlags, lookupSequence, subtableSequence, subtableFormat);
resetATSubState();
}
dd = 256;
s2 = 8;
} else {
- log.debug ("unsupported device table delta format: " + df + ", ignoring device table");
+ log.debug("unsupported device table delta format: " + df + ", ignoring device table");
return null;
}
// read deltas
int n = (es - ss) + 1;
if (n < 0) {
- log.debug ("invalid device table delta count: " + n + ", ignoring device table");
+ log.debug("invalid device table delta count: " + n + ", ignoring device table");
return null;
}
int[] da = new int [ n ];
}
}
in.seekSet(cp);
- return new GlyphPositioningTable.DeviceTable (ss, es, da);
+ return new GlyphPositioningTable.DeviceTable(ss, es, da);
}
private GlyphPositioningTable.Value readPosValue(long subtableOffset, int valueFormat) throws IOException {
// XPlacement
int xp;
if ((valueFormat & GlyphPositioningTable.Value.X_PLACEMENT) != 0) {
- xp = ttf.convertTTFUnit2PDFUnit (in.readTTFShort());
+ xp = ttf.convertTTFUnit2PDFUnit(in.readTTFShort());
} else {
xp = 0;
}
// YPlacement
int yp;
if ((valueFormat & GlyphPositioningTable.Value.Y_PLACEMENT) != 0) {
- yp = ttf.convertTTFUnit2PDFUnit (in.readTTFShort());
+ yp = ttf.convertTTFUnit2PDFUnit(in.readTTFShort());
} else {
yp = 0;
}
// XAdvance
int xa;
if ((valueFormat & GlyphPositioningTable.Value.X_ADVANCE) != 0) {
- xa = ttf.convertTTFUnit2PDFUnit (in.readTTFShort());
+ xa = ttf.convertTTFUnit2PDFUnit(in.readTTFShort());
} else {
xa = 0;
}
// YAdvance
int ya;
if ((valueFormat & GlyphPositioningTable.Value.Y_ADVANCE) != 0) {
- ya = ttf.convertTTFUnit2PDFUnit (in.readTTFShort());
+ ya = ttf.convertTTFUnit2PDFUnit(in.readTTFShort());
} else {
ya = 0;
}
GlyphPositioningTable.DeviceTable xpd;
if ((valueFormat & GlyphPositioningTable.Value.X_PLACEMENT_DEVICE) != 0) {
int xpdo = in.readTTFUShort();
- xpd = readPosDeviceTable (subtableOffset, xpdo);
+ xpd = readPosDeviceTable(subtableOffset, xpdo);
} else {
xpd = null;
}
GlyphPositioningTable.DeviceTable ypd;
if ((valueFormat & GlyphPositioningTable.Value.Y_PLACEMENT_DEVICE) != 0) {
int ypdo = in.readTTFUShort();
- ypd = readPosDeviceTable (subtableOffset, ypdo);
+ ypd = readPosDeviceTable(subtableOffset, ypdo);
} else {
ypd = null;
}
GlyphPositioningTable.DeviceTable xad;
if ((valueFormat & GlyphPositioningTable.Value.X_ADVANCE_DEVICE) != 0) {
int xado = in.readTTFUShort();
- xad = readPosDeviceTable (subtableOffset, xado);
+ xad = readPosDeviceTable(subtableOffset, xado);
} else {
xad = null;
}
GlyphPositioningTable.DeviceTable yad;
if ((valueFormat & GlyphPositioningTable.Value.Y_ADVANCE_DEVICE) != 0) {
int yado = in.readTTFUShort();
- yad = readPosDeviceTable (subtableOffset, yado);
+ yad = readPosDeviceTable(subtableOffset, yado);
} else {
yad = null;
}
- return new GlyphPositioningTable.Value (xp, yp, xa, ya, xpd, ypd, xad, yad);
+ return new GlyphPositioningTable.Value(xp, yp, xa, ya, xpd, ypd, xad, yad);
}
private void readSinglePosTableFormat1(int lookupType, int lookupFlags, long subtableOffset, int subtableFormat) throws IOException {
String tableTag = "GPOS";
in.seekSet(subtableOffset);
// skip over format (already known)
- in.skip (2);
+ in.skip(2);
// read coverage offset
int co = in.readTTFUShort();
// read value format
int vf = in.readTTFUShort();
// read value
- GlyphPositioningTable.Value v = readPosValue (subtableOffset, vf);
+ GlyphPositioningTable.Value v = readPosValue(subtableOffset, vf);
// dump info if debugging
if (log.isDebugEnabled()) {
log.debug(tableTag + " single positioning subtable format: " + subtableFormat + " (delta)");
log.debug(tableTag + " single positioning value: " + v);
}
// read coverage table
- GlyphCoverageTable ct = readCoverageTable (tableTag + " single positioning coverage", subtableOffset + co);
+ GlyphCoverageTable ct = readCoverageTable(tableTag + " single positioning coverage", subtableOffset + co);
// store results
seMapping = ct;
- seEntries.add (v);
+ seEntries.add(v);
}
private void readSinglePosTableFormat2(int lookupType, int lookupFlags, long subtableOffset, int subtableFormat) throws IOException {
String tableTag = "GPOS";
in.seekSet(subtableOffset);
// skip over format (already known)
- in.skip (2);
+ in.skip(2);
// read coverage offset
int co = in.readTTFUShort();
// read value format
log.debug(tableTag + " single positioning value count: " + nv);
}
// read coverage table
- GlyphCoverageTable ct = readCoverageTable (tableTag + " single positioning coverage", subtableOffset + co);
+ GlyphCoverageTable ct = readCoverageTable(tableTag + " single positioning coverage", subtableOffset + co);
// read positioning values
GlyphPositioningTable.Value[] pva = new GlyphPositioningTable.Value[nv];
for (int i = 0, n = nv; i < n; i++) {
- GlyphPositioningTable.Value pv = readPosValue (subtableOffset, vf);
+ GlyphPositioningTable.Value pv = readPosValue(subtableOffset, vf);
if (log.isDebugEnabled()) {
log.debug(tableTag + " single positioning value[" + i + "]: " + pv);
}
}
// store results
seMapping = ct;
- seEntries.add (pva);
+ seEntries.add(pva);
}
private int readSinglePosTable(int lookupType, int lookupFlags, long subtableOffset) throws IOException {
// read positionining subtable format
int sf = in.readTTFUShort();
if (sf == 1) {
- readSinglePosTableFormat1 (lookupType, lookupFlags, subtableOffset, sf);
+ readSinglePosTableFormat1(lookupType, lookupFlags, subtableOffset, sf);
} else if (sf == 2) {
- readSinglePosTableFormat2 (lookupType, lookupFlags, subtableOffset, sf);
+ readSinglePosTableFormat2(lookupType, lookupFlags, subtableOffset, sf);
} else {
- throw new AdvancedTypographicTableFormatException ("unsupported single positioning subtable format: " + sf);
+ throw new AdvancedTypographicTableFormatException("unsupported single positioning subtable format: " + sf);
}
return sf;
}
// read first value (if present)
GlyphPositioningTable.Value v1;
if (vf1 != 0) {
- v1 = readPosValue (subtableOffset, vf1);
+ v1 = readPosValue(subtableOffset, vf1);
} else {
v1 = null;
}
// read second value (if present)
GlyphPositioningTable.Value v2;
if (vf2 != 0) {
- v2 = readPosValue (subtableOffset, vf2);
+ v2 = readPosValue(subtableOffset, vf2);
} else {
v2 = null;
}
- return new GlyphPositioningTable.PairValues (glyph, v1, v2);
+ return new GlyphPositioningTable.PairValues(glyph, v1, v2);
}
private GlyphPositioningTable.PairValues[] readPosPairSetTable(long subtableOffset, int pairSetTableOffset, int vf1, int vf2) throws IOException {
// read pair values
GlyphPositioningTable.PairValues[] pva = new GlyphPositioningTable.PairValues [ npv ];
for (int i = 0, n = npv; i < n; i++) {
- GlyphPositioningTable.PairValues pv = readPosPairValues (subtableOffset, true, vf1, vf2);
+ GlyphPositioningTable.PairValues pv = readPosPairValues(subtableOffset, true, vf1, vf2);
pva [ i ] = pv;
if (log.isDebugEnabled()) {
log.debug(tableTag + " pair set table value[" + i + "]: " + pv);
String tableTag = "GPOS";
in.seekSet(subtableOffset);
// skip over format (already known)
- in.skip (2);
+ in.skip(2);
// read coverage offset
int co = in.readTTFUShort();
// read value format for first glyph
log.debug(tableTag + " pair positioning value format #2: " + vf2);
}
// read coverage table
- GlyphCoverageTable ct = readCoverageTable (tableTag + " pair positioning coverage", subtableOffset + co);
+ GlyphCoverageTable ct = readCoverageTable(tableTag + " pair positioning coverage", subtableOffset + co);
// read pair value matrix
GlyphPositioningTable.PairValues[][] pvm = new GlyphPositioningTable.PairValues [ nps ][];
for (int i = 0, n = nps; i < n; i++) {
// read pair set offset
int pso = in.readTTFUShort();
// read pair set table at offset
- pvm [ i ] = readPosPairSetTable (subtableOffset, pso, vf1, vf2);
+ pvm [ i ] = readPosPairSetTable(subtableOffset, pso, vf1, vf2);
}
// store results
seMapping = ct;
- seEntries.add (pvm);
+ seEntries.add(pvm);
}
private void readPairPosTableFormat2(int lookupType, int lookupFlags, long subtableOffset, int subtableFormat) throws IOException {
String tableTag = "GPOS";
in.seekSet(subtableOffset);
// skip over format (already known)
- in.skip (2);
+ in.skip(2);
// read coverage offset
int co = in.readTTFUShort();
// read value format for first glyph
log.debug(tableTag + " pair positioning class #2 count: " + nc2);
}
// read coverage table
- GlyphCoverageTable ct = readCoverageTable (tableTag + " pair positioning coverage", subtableOffset + co);
+ GlyphCoverageTable ct = readCoverageTable(tableTag + " pair positioning coverage", subtableOffset + co);
// read class definition table #1
- GlyphClassTable cdt1 = readClassDefTable (tableTag + " pair positioning class definition #1", subtableOffset + cd1o);
+ GlyphClassTable cdt1 = readClassDefTable(tableTag + " pair positioning class definition #1", subtableOffset + cd1o);
// read class definition table #2
- GlyphClassTable cdt2 = readClassDefTable (tableTag + " pair positioning class definition #2", subtableOffset + cd2o);
+ GlyphClassTable cdt2 = readClassDefTable(tableTag + " pair positioning class definition #2", subtableOffset + cd2o);
// read pair value matrix
GlyphPositioningTable.PairValues[][] pvm = new GlyphPositioningTable.PairValues [ nc1 ] [ nc2 ];
for (int i = 0; i < nc1; i++) {
for (int j = 0; j < nc2; j++) {
- GlyphPositioningTable.PairValues pv = readPosPairValues (subtableOffset, false, vf1, vf2);
+ GlyphPositioningTable.PairValues pv = readPosPairValues(subtableOffset, false, vf1, vf2);
pvm [ i ] [ j ] = pv;
if (log.isDebugEnabled()) {
log.debug(tableTag + " pair set table value[" + i + "][" + j + "]: " + pv);
}
// store results
seMapping = ct;
- seEntries.add (cdt1);
- seEntries.add (cdt2);
- seEntries.add (Integer.valueOf (nc1));
- seEntries.add (Integer.valueOf (nc2));
- seEntries.add (pvm);
+ seEntries.add(cdt1);
+ seEntries.add(cdt2);
+ seEntries.add(Integer.valueOf(nc1));
+ seEntries.add(Integer.valueOf(nc2));
+ seEntries.add(pvm);
}
private int readPairPosTable(int lookupType, int lookupFlags, long subtableOffset) throws IOException {
// read positioning subtable format
int sf = in.readTTFUShort();
if (sf == 1) {
- readPairPosTableFormat1 (lookupType, lookupFlags, subtableOffset, sf);
+ readPairPosTableFormat1(lookupType, lookupFlags, subtableOffset, sf);
} else if (sf == 2) {
- readPairPosTableFormat2 (lookupType, lookupFlags, subtableOffset, sf);
+ readPairPosTableFormat2(lookupType, lookupFlags, subtableOffset, sf);
} else {
- throw new AdvancedTypographicTableFormatException ("unsupported pair positioning subtable format: " + sf);
+ throw new AdvancedTypographicTableFormatException("unsupported pair positioning subtable format: " + sf);
}
return sf;
}
int af = in.readTTFUShort();
if (af == 1) {
// read x coordinate
- int x = ttf.convertTTFUnit2PDFUnit (in.readTTFShort());
+ int x = ttf.convertTTFUnit2PDFUnit(in.readTTFShort());
// read y coordinate
- int y = ttf.convertTTFUnit2PDFUnit (in.readTTFShort());
- a = new GlyphPositioningTable.Anchor (x, y);
+ int y = ttf.convertTTFUnit2PDFUnit(in.readTTFShort());
+ a = new GlyphPositioningTable.Anchor(x, y);
} else if (af == 2) {
// read x coordinate
- int x = ttf.convertTTFUnit2PDFUnit (in.readTTFShort());
+ int x = ttf.convertTTFUnit2PDFUnit(in.readTTFShort());
// read y coordinate
- int y = ttf.convertTTFUnit2PDFUnit (in.readTTFShort());
+ int y = ttf.convertTTFUnit2PDFUnit(in.readTTFShort());
// read anchor point index
int ap = in.readTTFUShort();
- a = new GlyphPositioningTable.Anchor (x, y, ap);
+ a = new GlyphPositioningTable.Anchor(x, y, ap);
} else if (af == 3) {
// read x coordinate
- int x = ttf.convertTTFUnit2PDFUnit (in.readTTFShort());
+ int x = ttf.convertTTFUnit2PDFUnit(in.readTTFShort());
// read y coordinate
- int y = ttf.convertTTFUnit2PDFUnit (in.readTTFShort());
+ int y = ttf.convertTTFUnit2PDFUnit(in.readTTFShort());
// read x device table offset
int xdo = in.readTTFUShort();
// read y device table offset
// read x device table (if present)
GlyphPositioningTable.DeviceTable xd;
if (xdo != 0) {
- xd = readPosDeviceTable (cp, xdo);
+ xd = readPosDeviceTable(cp, xdo);
} else {
xd = null;
}
// read y device table (if present)
GlyphPositioningTable.DeviceTable yd;
if (ydo != 0) {
- yd = readPosDeviceTable (cp, ydo);
+ yd = readPosDeviceTable(cp, ydo);
} else {
yd = null;
}
- a = new GlyphPositioningTable.Anchor (x, y, xd, yd);
+ a = new GlyphPositioningTable.Anchor(x, y, xd, yd);
} else {
- throw new AdvancedTypographicTableFormatException ("unsupported positioning anchor format: " + af);
+ throw new AdvancedTypographicTableFormatException("unsupported positioning anchor format: " + af);
}
in.seekSet(cp);
return a;
String tableTag = "GPOS";
in.seekSet(subtableOffset);
// skip over format (already known)
- in.skip (2);
+ in.skip(2);
// read coverage offset
int co = in.readTTFUShort();
// read entry/exit count
log.debug(tableTag + " cursive positioning entry/exit count: " + ec);
}
// read coverage table
- GlyphCoverageTable ct = readCoverageTable (tableTag + " cursive positioning coverage", subtableOffset + co);
+ GlyphCoverageTable ct = readCoverageTable(tableTag + " cursive positioning coverage", subtableOffset + co);
// read entry/exit records
GlyphPositioningTable.Anchor[] aa = new GlyphPositioningTable.Anchor [ ec * 2 ];
for (int i = 0, n = ec; i < n; i++) {
// read entry anchor
GlyphPositioningTable.Anchor ena;
if (eno > 0) {
- ena = readPosAnchor (subtableOffset + eno);
+ ena = readPosAnchor(subtableOffset + eno);
} else {
ena = null;
}
// read exit anchor
GlyphPositioningTable.Anchor exa;
if (exo > 0) {
- exa = readPosAnchor (subtableOffset + exo);
+ exa = readPosAnchor(subtableOffset + exo);
} else {
exa = null;
}
}
// store results
seMapping = ct;
- seEntries.add (aa);
+ seEntries.add(aa);
}
private int readCursivePosTable(int lookupType, int lookupFlags, long subtableOffset) throws IOException {
// read positioning subtable format
int sf = in.readTTFUShort();
if (sf == 1) {
- readCursivePosTableFormat1 (lookupType, lookupFlags, subtableOffset, sf);
+ readCursivePosTableFormat1(lookupType, lookupFlags, subtableOffset, sf);
} else {
- throw new AdvancedTypographicTableFormatException ("unsupported cursive positioning subtable format: " + sf);
+ throw new AdvancedTypographicTableFormatException("unsupported cursive positioning subtable format: " + sf);
}
return sf;
}
String tableTag = "GPOS";
in.seekSet(subtableOffset);
// skip over format (already known)
- in.skip (2);
+ in.skip(2);
// read mark coverage offset
int mco = in.readTTFUShort();
// read base coverage offset
log.debug(tableTag + " mark-to-base positioning base array offset: " + bao);
}
// read mark coverage table
- GlyphCoverageTable mct = readCoverageTable (tableTag + " mark-to-base positioning mark coverage", subtableOffset + mco);
+ GlyphCoverageTable mct = readCoverageTable(tableTag + " mark-to-base positioning mark coverage", subtableOffset + mco);
// read base coverage table
- GlyphCoverageTable bct = readCoverageTable (tableTag + " mark-to-base positioning base coverage", subtableOffset + bco);
+ GlyphCoverageTable bct = readCoverageTable(tableTag + " mark-to-base positioning base coverage", subtableOffset + bco);
// read mark anchor array
// seek to mark array
in.seekSet(subtableOffset + mao);
int ao = in.readTTFUShort();
GlyphPositioningTable.Anchor a;
if (ao > 0) {
- a = readPosAnchor (subtableOffset + mao + ao);
+ a = readPosAnchor(subtableOffset + mao + ao);
} else {
a = null;
}
GlyphPositioningTable.MarkAnchor ma;
if (a != null) {
- ma = new GlyphPositioningTable.MarkAnchor (mc, a);
+ ma = new GlyphPositioningTable.MarkAnchor(mc, a);
} else {
ma = null;
}
int ao = in.readTTFUShort();
GlyphPositioningTable.Anchor a;
if (ao > 0) {
- a = readPosAnchor (subtableOffset + bao + ao);
+ a = readPosAnchor(subtableOffset + bao + ao);
} else {
a = null;
}
}
// store results
seMapping = mct;
- seEntries.add (bct);
- seEntries.add (Integer.valueOf (nmc));
- seEntries.add (maa);
- seEntries.add (bam);
+ seEntries.add(bct);
+ seEntries.add(Integer.valueOf(nmc));
+ seEntries.add(maa);
+ seEntries.add(bam);
}
private int readMarkToBasePosTable(int lookupType, int lookupFlags, long subtableOffset) throws IOException {
// read positioning subtable format
int sf = in.readTTFUShort();
if (sf == 1) {
- readMarkToBasePosTableFormat1 (lookupType, lookupFlags, subtableOffset, sf);
+ readMarkToBasePosTableFormat1(lookupType, lookupFlags, subtableOffset, sf);
} else {
- throw new AdvancedTypographicTableFormatException ("unsupported mark-to-base positioning subtable format: " + sf);
+ throw new AdvancedTypographicTableFormatException("unsupported mark-to-base positioning subtable format: " + sf);
}
return sf;
}
String tableTag = "GPOS";
in.seekSet(subtableOffset);
// skip over format (already known)
- in.skip (2);
+ in.skip(2);
// read mark coverage offset
int mco = in.readTTFUShort();
// read ligature coverage offset
log.debug(tableTag + " mark-to-ligature positioning ligature array offset: " + lao);
}
// read mark coverage table
- GlyphCoverageTable mct = readCoverageTable (tableTag + " mark-to-ligature positioning mark coverage", subtableOffset + mco);
+ GlyphCoverageTable mct = readCoverageTable(tableTag + " mark-to-ligature positioning mark coverage", subtableOffset + mco);
// read ligature coverage table
- GlyphCoverageTable lct = readCoverageTable (tableTag + " mark-to-ligature positioning ligature coverage", subtableOffset + lco);
+ GlyphCoverageTable lct = readCoverageTable(tableTag + " mark-to-ligature positioning ligature coverage", subtableOffset + lco);
// read mark anchor array
// seek to mark array
in.seekSet(subtableOffset + mao);
int ao = in.readTTFUShort();
GlyphPositioningTable.Anchor a;
if (ao > 0) {
- a = readPosAnchor (subtableOffset + mao + ao);
+ a = readPosAnchor(subtableOffset + mao + ao);
} else {
a = null;
}
GlyphPositioningTable.MarkAnchor ma;
if (a != null) {
- ma = new GlyphPositioningTable.MarkAnchor (mc, a);
+ ma = new GlyphPositioningTable.MarkAnchor(mc, a);
} else {
ma = null;
}
int mxc = 0;
for (int i = 0; i < nl; i++) {
int lato = laoa [ i ];
- in.seekSet (subtableOffset + lao + lato);
+ in.seekSet(subtableOffset + lao + lato);
// read component count
int cc = in.readTTFUShort();
if (cc > mxc) {
for (int i = 0; i < nl; i++) {
int lato = laoa [ i ];
// seek to ligature attach table for ligature[i]
- in.seekSet (subtableOffset + lao + lato);
+ in.seekSet(subtableOffset + lao + lato);
// read component count
int cc = in.readTTFUShort();
GlyphPositioningTable.Anchor[][] lcm = new GlyphPositioningTable.Anchor [ cc ] [ nmc ];
int ao = in.readTTFUShort();
GlyphPositioningTable.Anchor a;
if (ao > 0) {
- a = readPosAnchor (subtableOffset + lao + lato + ao);
+ a = readPosAnchor(subtableOffset + lao + lato + ao);
} else {
a = null;
}
}
// store results
seMapping = mct;
- seEntries.add (lct);
- seEntries.add (Integer.valueOf (nmc));
- seEntries.add (Integer.valueOf (mxc));
- seEntries.add (maa);
- seEntries.add (lam);
+ seEntries.add(lct);
+ seEntries.add(Integer.valueOf(nmc));
+ seEntries.add(Integer.valueOf(mxc));
+ seEntries.add(maa);
+ seEntries.add(lam);
}
private int readMarkToLigaturePosTable(int lookupType, int lookupFlags, long subtableOffset) throws IOException {
// read positioning subtable format
int sf = in.readTTFUShort();
if (sf == 1) {
- readMarkToLigaturePosTableFormat1 (lookupType, lookupFlags, subtableOffset, sf);
+ readMarkToLigaturePosTableFormat1(lookupType, lookupFlags, subtableOffset, sf);
} else {
- throw new AdvancedTypographicTableFormatException ("unsupported mark-to-ligature positioning subtable format: " + sf);
+ throw new AdvancedTypographicTableFormatException("unsupported mark-to-ligature positioning subtable format: " + sf);
}
return sf;
}
String tableTag = "GPOS";
in.seekSet(subtableOffset);
// skip over format (already known)
- in.skip (2);
+ in.skip(2);
// read mark #1 coverage offset
int m1co = in.readTTFUShort();
// read mark #2 coverage offset
log.debug(tableTag + " mark-to-mark positioning mark #2 array offset: " + m2ao);
}
// read mark #1 coverage table
- GlyphCoverageTable mct1 = readCoverageTable (tableTag + " mark-to-mark positioning mark #1 coverage", subtableOffset + m1co);
+ GlyphCoverageTable mct1 = readCoverageTable(tableTag + " mark-to-mark positioning mark #1 coverage", subtableOffset + m1co);
// read mark #2 coverage table
- GlyphCoverageTable mct2 = readCoverageTable (tableTag + " mark-to-mark positioning mark #2 coverage", subtableOffset + m2co);
+ GlyphCoverageTable mct2 = readCoverageTable(tableTag + " mark-to-mark positioning mark #2 coverage", subtableOffset + m2co);
// read mark #1 anchor array
// seek to mark array
in.seekSet(subtableOffset + m1ao);
int ao = in.readTTFUShort();
GlyphPositioningTable.Anchor a;
if (ao > 0) {
- a = readPosAnchor (subtableOffset + m1ao + ao);
+ a = readPosAnchor(subtableOffset + m1ao + ao);
} else {
a = null;
}
GlyphPositioningTable.MarkAnchor ma;
if (a != null) {
- ma = new GlyphPositioningTable.MarkAnchor (mc, a);
+ ma = new GlyphPositioningTable.MarkAnchor(mc, a);
} else {
ma = null;
}
int ao = in.readTTFUShort();
GlyphPositioningTable.Anchor a;
if (ao > 0) {
- a = readPosAnchor (subtableOffset + m2ao + ao);
+ a = readPosAnchor(subtableOffset + m2ao + ao);
} else {
a = null;
}
}
// store results
seMapping = mct1;
- seEntries.add (mct2);
- seEntries.add (Integer.valueOf (nmc));
- seEntries.add (maa);
- seEntries.add (mam);
+ seEntries.add(mct2);
+ seEntries.add(Integer.valueOf(nmc));
+ seEntries.add(maa);
+ seEntries.add(mam);
}
private int readMarkToMarkPosTable(int lookupType, int lookupFlags, long subtableOffset) throws IOException {
// read positioning subtable format
int sf = in.readTTFUShort();
if (sf == 1) {
- readMarkToMarkPosTableFormat1 (lookupType, lookupFlags, subtableOffset, sf);
+ readMarkToMarkPosTableFormat1(lookupType, lookupFlags, subtableOffset, sf);
} else {
- throw new AdvancedTypographicTableFormatException ("unsupported mark-to-mark positioning subtable format: " + sf);
+ throw new AdvancedTypographicTableFormatException("unsupported mark-to-mark positioning subtable format: " + sf);
}
return sf;
}
String tableTag = "GPOS";
in.seekSet(subtableOffset);
// skip over format (already known)
- in.skip (2);
+ in.skip(2);
// read coverage offset
int co = in.readTTFUShort();
// read rule set count
// read coverage table
GlyphCoverageTable ct;
if (co > 0) {
- ct = readCoverageTable (tableTag + " contextual positioning coverage", subtableOffset + co);
+ ct = readCoverageTable(tableTag + " contextual positioning coverage", subtableOffset + co);
} else {
ct = null;
}
int rso = rsoa [ i ];
if (rso > 0) {
// seek to rule set [ i ]
- in.seekSet (subtableOffset + rso);
+ in.seekSet(subtableOffset + rso);
// read rule count
int nr = in.readTTFUShort();
// read rule offsets
int ro = roa [ j ];
if (ro > 0) {
// seek to rule [ j ]
- in.seekSet (subtableOffset + rso + ro);
+ in.seekSet(subtableOffset + rso + ro);
// read glyph count
int ng = in.readTTFUShort();
// read rule lookup count
if (log.isDebugEnabled()) {
header = tableTag + " contextual positioning lookups @rule[" + i + "][" + j + "]: ";
}
- GlyphTable.RuleLookup[] lookups = readRuleLookups (nl, header);
- r = new GlyphTable.GlyphSequenceRule (lookups, ng, glyphs);
+ GlyphTable.RuleLookup[] lookups = readRuleLookups(nl, header);
+ r = new GlyphTable.GlyphSequenceRule(lookups, ng, glyphs);
} else {
r = null;
}
ra [ j ] = r;
}
- rs = new GlyphTable.HomogeneousRuleSet (ra);
+ rs = new GlyphTable.HomogeneousRuleSet(ra);
} else {
rs = null;
}
}
// store results
seMapping = ct;
- seEntries.add (rsa);
+ seEntries.add(rsa);
}
private void readContextualPosTableFormat2(int lookupType, int lookupFlags, long subtableOffset, int subtableFormat) throws IOException {
String tableTag = "GPOS";
in.seekSet(subtableOffset);
// skip over format (already known)
- in.skip (2);
+ in.skip(2);
// read coverage offset
int co = in.readTTFUShort();
// read class def table offset
// read coverage table
GlyphCoverageTable ct;
if (co > 0) {
- ct = readCoverageTable (tableTag + " contextual positioning coverage", subtableOffset + co);
+ ct = readCoverageTable(tableTag + " contextual positioning coverage", subtableOffset + co);
} else {
ct = null;
}
// read class definition table
GlyphClassTable cdt;
if (cdo > 0) {
- cdt = readClassDefTable (tableTag + " contextual positioning class definition", subtableOffset + cdo);
+ cdt = readClassDefTable(tableTag + " contextual positioning class definition", subtableOffset + cdo);
} else {
cdt = null;
}
GlyphTable.RuleSet rs;
if (cso > 0) {
// seek to rule set [ i ]
- in.seekSet (subtableOffset + cso);
+ in.seekSet(subtableOffset + cso);
// read rule count
int nr = in.readTTFUShort();
// read rule offsets
GlyphTable.ClassSequenceRule r;
if (ro > 0) {
// seek to rule [ j ]
- in.seekSet (subtableOffset + cso + ro);
+ in.seekSet(subtableOffset + cso + ro);
// read glyph count
int ng = in.readTTFUShort();
// read rule lookup count
if (log.isDebugEnabled()) {
header = tableTag + " contextual positioning lookups @rule[" + i + "][" + j + "]: ";
}
- GlyphTable.RuleLookup[] lookups = readRuleLookups (nl, header);
- r = new GlyphTable.ClassSequenceRule (lookups, ng, classes);
+ GlyphTable.RuleLookup[] lookups = readRuleLookups(nl, header);
+ r = new GlyphTable.ClassSequenceRule(lookups, ng, classes);
} else {
r = null;
}
ra [ j ] = r;
}
- rs = new GlyphTable.HomogeneousRuleSet (ra);
+ rs = new GlyphTable.HomogeneousRuleSet(ra);
} else {
rs = null;
}
}
// store results
seMapping = ct;
- seEntries.add (cdt);
- seEntries.add (Integer.valueOf (ngc));
- seEntries.add (rsa);
+ seEntries.add(cdt);
+ seEntries.add(Integer.valueOf(ngc));
+ seEntries.add(rsa);
}
private void readContextualPosTableFormat3(int lookupType, int lookupFlags, long subtableOffset, int subtableFormat) throws IOException {
String tableTag = "GPOS";
in.seekSet(subtableOffset);
// skip over format (already known)
- in.skip (2);
+ in.skip(2);
// read glyph (input sequence length) count
int ng = in.readTTFUShort();
// read positioning lookup count
int gco = gcoa [ i ];
GlyphCoverageTable gct;
if (gco > 0) {
- gct = readCoverageTable (tableTag + " contextual positioning coverage[" + i + "]", subtableOffset + gcoa[i]);
+ gct = readCoverageTable(tableTag + " contextual positioning coverage[" + i + "]", subtableOffset + gcoa[i]);
} else {
gct = null;
}
if (log.isDebugEnabled()) {
header = tableTag + " contextual positioning lookups: ";
}
- GlyphTable.RuleLookup[] lookups = readRuleLookups (nl, header);
+ GlyphTable.RuleLookup[] lookups = readRuleLookups(nl, header);
// construct rule, rule set, and rule set array
- GlyphTable.Rule r = new GlyphTable.CoverageSequenceRule (lookups, ng, gca);
- GlyphTable.RuleSet rs = new GlyphTable.HomogeneousRuleSet (new GlyphTable.Rule[] {r});
+ GlyphTable.Rule r = new GlyphTable.CoverageSequenceRule(lookups, ng, gca);
+ GlyphTable.RuleSet rs = new GlyphTable.HomogeneousRuleSet(new GlyphTable.Rule[] {r});
GlyphTable.RuleSet[] rsa = new GlyphTable.RuleSet[] {rs};
// store results
assert (gca != null) && (gca.length > 0);
seMapping = gca[0];
- seEntries.add (rsa);
+ seEntries.add(rsa);
}
private int readContextualPosTable(int lookupType, int lookupFlags, long subtableOffset) throws IOException {
// read positioning subtable format
int sf = in.readTTFUShort();
if (sf == 1) {
- readContextualPosTableFormat1 (lookupType, lookupFlags, subtableOffset, sf);
+ readContextualPosTableFormat1(lookupType, lookupFlags, subtableOffset, sf);
} else if (sf == 2) {
- readContextualPosTableFormat2 (lookupType, lookupFlags, subtableOffset, sf);
+ readContextualPosTableFormat2(lookupType, lookupFlags, subtableOffset, sf);
} else if (sf == 3) {
- readContextualPosTableFormat3 (lookupType, lookupFlags, subtableOffset, sf);
+ readContextualPosTableFormat3(lookupType, lookupFlags, subtableOffset, sf);
} else {
- throw new AdvancedTypographicTableFormatException ("unsupported contextual positioning subtable format: " + sf);
+ throw new AdvancedTypographicTableFormatException("unsupported contextual positioning subtable format: " + sf);
}
return sf;
}
String tableTag = "GPOS";
in.seekSet(subtableOffset);
// skip over format (already known)
- in.skip (2);
+ in.skip(2);
// read coverage offset
int co = in.readTTFUShort();
// read rule set count
// read coverage table
GlyphCoverageTable ct;
if (co > 0) {
- ct = readCoverageTable (tableTag + " chained contextual positioning coverage", subtableOffset + co);
+ ct = readCoverageTable(tableTag + " chained contextual positioning coverage", subtableOffset + co);
} else {
ct = null;
}
int rso = rsoa [ i ];
if (rso > 0) {
// seek to rule set [ i ]
- in.seekSet (subtableOffset + rso);
+ in.seekSet(subtableOffset + rso);
// read rule count
int nr = in.readTTFUShort();
// read rule offsets
int ro = roa [ j ];
if (ro > 0) {
// seek to rule [ j ]
- in.seekSet (subtableOffset + rso + ro);
+ in.seekSet(subtableOffset + rso + ro);
// read backtrack glyph count
int nbg = in.readTTFUShort();
// read backtrack glyphs
if (log.isDebugEnabled()) {
header = tableTag + " contextual positioning lookups @rule[" + i + "][" + j + "]: ";
}
- GlyphTable.RuleLookup[] lookups = readRuleLookups (nl, header);
- r = new GlyphTable.ChainedGlyphSequenceRule (lookups, nig, glyphs, backtrackGlyphs, lookaheadGlyphs);
+ GlyphTable.RuleLookup[] lookups = readRuleLookups(nl, header);
+ r = new GlyphTable.ChainedGlyphSequenceRule(lookups, nig, glyphs, backtrackGlyphs, lookaheadGlyphs);
} else {
r = null;
}
ra [ j ] = r;
}
- rs = new GlyphTable.HomogeneousRuleSet (ra);
+ rs = new GlyphTable.HomogeneousRuleSet(ra);
} else {
rs = null;
}
}
// store results
seMapping = ct;
- seEntries.add (rsa);
+ seEntries.add(rsa);
}
private void readChainedContextualPosTableFormat2(int lookupType, int lookupFlags, long subtableOffset, int subtableFormat) throws IOException {
String tableTag = "GPOS";
in.seekSet(subtableOffset);
// skip over format (already known)
- in.skip (2);
+ in.skip(2);
// read coverage offset
int co = in.readTTFUShort();
// read backtrack class def table offset
// read coverage table
GlyphCoverageTable ct;
if (co > 0) {
- ct = readCoverageTable (tableTag + " chained contextual positioning coverage", subtableOffset + co);
+ ct = readCoverageTable(tableTag + " chained contextual positioning coverage", subtableOffset + co);
} else {
ct = null;
}
// read backtrack class definition table
GlyphClassTable bcdt;
if (bcdo > 0) {
- bcdt = readClassDefTable (tableTag + " contextual positioning backtrack class definition", subtableOffset + bcdo);
+ bcdt = readClassDefTable(tableTag + " contextual positioning backtrack class definition", subtableOffset + bcdo);
} else {
bcdt = null;
}
// read input class definition table
GlyphClassTable icdt;
if (icdo > 0) {
- icdt = readClassDefTable (tableTag + " contextual positioning input class definition", subtableOffset + icdo);
+ icdt = readClassDefTable(tableTag + " contextual positioning input class definition", subtableOffset + icdo);
} else {
icdt = null;
}
// read lookahead class definition table
GlyphClassTable lcdt;
if (lcdo > 0) {
- lcdt = readClassDefTable (tableTag + " contextual positioning lookahead class definition", subtableOffset + lcdo);
+ lcdt = readClassDefTable(tableTag + " contextual positioning lookahead class definition", subtableOffset + lcdo);
} else {
lcdt = null;
}
GlyphTable.RuleSet rs;
if (cso > 0) {
// seek to rule set [ i ]
- in.seekSet (subtableOffset + cso);
+ in.seekSet(subtableOffset + cso);
// read rule count
int nr = in.readTTFUShort();
// read rule offsets
int ro = roa [ j ];
if (ro > 0) {
// seek to rule [ j ]
- in.seekSet (subtableOffset + cso + ro);
+ in.seekSet(subtableOffset + cso + ro);
// read backtrack glyph class count
int nbc = in.readTTFUShort();
// read backtrack glyph classes
if (log.isDebugEnabled()) {
header = tableTag + " contextual positioning lookups @rule[" + i + "][" + j + "]: ";
}
- GlyphTable.RuleLookup[] lookups = readRuleLookups (nl, header);
- r = new GlyphTable.ChainedClassSequenceRule (lookups, nic, classes, backtrackClasses, lookaheadClasses);
+ GlyphTable.RuleLookup[] lookups = readRuleLookups(nl, header);
+ r = new GlyphTable.ChainedClassSequenceRule(lookups, nic, classes, backtrackClasses, lookaheadClasses);
} else {
r = null;
}
ra [ j ] = r;
}
- rs = new GlyphTable.HomogeneousRuleSet (ra);
+ rs = new GlyphTable.HomogeneousRuleSet(ra);
} else {
rs = null;
}
}
// store results
seMapping = ct;
- seEntries.add (icdt);
- seEntries.add (bcdt);
- seEntries.add (lcdt);
- seEntries.add (Integer.valueOf (ngc));
- seEntries.add (rsa);
+ seEntries.add(icdt);
+ seEntries.add(bcdt);
+ seEntries.add(lcdt);
+ seEntries.add(Integer.valueOf(ngc));
+ seEntries.add(rsa);
}
private void readChainedContextualPosTableFormat3(int lookupType, int lookupFlags, long subtableOffset, int subtableFormat) throws IOException {
String tableTag = "GPOS";
in.seekSet(subtableOffset);
// skip over format (already known)
- in.skip (2);
+ in.skip(2);
// read backtrack glyph count
int nbg = in.readTTFUShort();
// read backtrack glyph coverage offsets
int bgco = bgcoa [ i ];
GlyphCoverageTable bgct;
if (bgco > 0) {
- bgct = readCoverageTable (tableTag + " chained contextual positioning backtrack coverage[" + i + "]", subtableOffset + bgco);
+ bgct = readCoverageTable(tableTag + " chained contextual positioning backtrack coverage[" + i + "]", subtableOffset + bgco);
} else {
bgct = null;
}
int igco = igcoa [ i ];
GlyphCoverageTable igct;
if (igco > 0) {
- igct = readCoverageTable (tableTag + " chained contextual positioning input coverage[" + i + "]", subtableOffset + igco);
+ igct = readCoverageTable(tableTag + " chained contextual positioning input coverage[" + i + "]", subtableOffset + igco);
} else {
igct = null;
}
int lgco = lgcoa [ i ];
GlyphCoverageTable lgct;
if (lgco > 0) {
- lgct = readCoverageTable (tableTag + " chained contextual positioning lookahead coverage[" + i + "]", subtableOffset + lgco);
+ lgct = readCoverageTable(tableTag + " chained contextual positioning lookahead coverage[" + i + "]", subtableOffset + lgco);
} else {
lgct = null;
}
if (log.isDebugEnabled()) {
header = tableTag + " chained contextual positioning lookups: ";
}
- GlyphTable.RuleLookup[] lookups = readRuleLookups (nl, header);
+ GlyphTable.RuleLookup[] lookups = readRuleLookups(nl, header);
// construct rule, rule set, and rule set array
- GlyphTable.Rule r = new GlyphTable.ChainedCoverageSequenceRule (lookups, nig, igca, bgca, lgca);
- GlyphTable.RuleSet rs = new GlyphTable.HomogeneousRuleSet (new GlyphTable.Rule[] {r});
+ GlyphTable.Rule r = new GlyphTable.ChainedCoverageSequenceRule(lookups, nig, igca, bgca, lgca);
+ GlyphTable.RuleSet rs = new GlyphTable.HomogeneousRuleSet(new GlyphTable.Rule[] {r});
GlyphTable.RuleSet[] rsa = new GlyphTable.RuleSet[] {rs};
// store results
assert (igca != null) && (igca.length > 0);
seMapping = igca[0];
- seEntries.add (rsa);
+ seEntries.add(rsa);
}
private int readChainedContextualPosTable(int lookupType, int lookupFlags, long subtableOffset) throws IOException {
// read positioning subtable format
int sf = in.readTTFUShort();
if (sf == 1) {
- readChainedContextualPosTableFormat1 (lookupType, lookupFlags, subtableOffset, sf);
+ readChainedContextualPosTableFormat1(lookupType, lookupFlags, subtableOffset, sf);
} else if (sf == 2) {
- readChainedContextualPosTableFormat2 (lookupType, lookupFlags, subtableOffset, sf);
+ readChainedContextualPosTableFormat2(lookupType, lookupFlags, subtableOffset, sf);
} else if (sf == 3) {
- readChainedContextualPosTableFormat3 (lookupType, lookupFlags, subtableOffset, sf);
+ readChainedContextualPosTableFormat3(lookupType, lookupFlags, subtableOffset, sf);
} else {
- throw new AdvancedTypographicTableFormatException ("unsupported chained contextual positioning subtable format: " + sf);
+ throw new AdvancedTypographicTableFormatException("unsupported chained contextual positioning subtable format: " + sf);
}
return sf;
}
String tableTag = "GPOS";
in.seekSet(subtableOffset);
// skip over format (already known)
- in.skip (2);
+ in.skip(2);
// read extension lookup type
int lt = in.readTTFUShort();
// read extension offset
log.debug(tableTag + " extension positioning lookup table offset: " + eo);
}
// read referenced subtable from extended offset
- readGPOSSubtable (lt, lookupFlags, lookupSequence, subtableSequence, subtableOffset + eo);
+ readGPOSSubtable(lt, lookupFlags, lookupSequence, subtableSequence, subtableOffset + eo);
}
private int readExtensionPosTable(int lookupType, int lookupFlags, int lookupSequence, int subtableSequence, long subtableOffset) throws IOException {
// read positioning subtable format
int sf = in.readTTFUShort();
if (sf == 1) {
- readExtensionPosTableFormat1 (lookupType, lookupFlags, lookupSequence, subtableSequence, subtableOffset, sf);
+ readExtensionPosTableFormat1(lookupType, lookupFlags, lookupSequence, subtableSequence, subtableOffset, sf);
} else {
- throw new AdvancedTypographicTableFormatException ("unsupported extension positioning subtable format: " + sf);
+ throw new AdvancedTypographicTableFormatException("unsupported extension positioning subtable format: " + sf);
}
return sf;
}
int subtableFormat = -1;
switch (lookupType) {
case GPOSLookupType.SINGLE:
- subtableFormat = readSinglePosTable (lookupType, lookupFlags, subtableOffset);
+ subtableFormat = readSinglePosTable(lookupType, lookupFlags, subtableOffset);
break;
case GPOSLookupType.PAIR:
- subtableFormat = readPairPosTable (lookupType, lookupFlags, subtableOffset);
+ subtableFormat = readPairPosTable(lookupType, lookupFlags, subtableOffset);
break;
case GPOSLookupType.CURSIVE:
- subtableFormat = readCursivePosTable (lookupType, lookupFlags, subtableOffset);
+ subtableFormat = readCursivePosTable(lookupType, lookupFlags, subtableOffset);
break;
case GPOSLookupType.MARK_TO_BASE:
- subtableFormat = readMarkToBasePosTable (lookupType, lookupFlags, subtableOffset);
+ subtableFormat = readMarkToBasePosTable(lookupType, lookupFlags, subtableOffset);
break;
case GPOSLookupType.MARK_TO_LIGATURE:
- subtableFormat = readMarkToLigaturePosTable (lookupType, lookupFlags, subtableOffset);
+ subtableFormat = readMarkToLigaturePosTable(lookupType, lookupFlags, subtableOffset);
break;
case GPOSLookupType.MARK_TO_MARK:
- subtableFormat = readMarkToMarkPosTable (lookupType, lookupFlags, subtableOffset);
+ subtableFormat = readMarkToMarkPosTable(lookupType, lookupFlags, subtableOffset);
break;
case GPOSLookupType.CONTEXTUAL:
- subtableFormat = readContextualPosTable (lookupType, lookupFlags, subtableOffset);
+ subtableFormat = readContextualPosTable(lookupType, lookupFlags, subtableOffset);
break;
case GPOSLookupType.CHAINED_CONTEXTUAL:
- subtableFormat = readChainedContextualPosTable (lookupType, lookupFlags, subtableOffset);
+ subtableFormat = readChainedContextualPosTable(lookupType, lookupFlags, subtableOffset);
break;
case GPOSLookupType.EXTENSION:
- subtableFormat = readExtensionPosTable (lookupType, lookupFlags, lookupSequence, subtableSequence, subtableOffset);
+ subtableFormat = readExtensionPosTable(lookupType, lookupFlags, lookupSequence, subtableSequence, subtableOffset);
break;
default:
break;
}
- extractSESubState (GlyphTable.GLYPH_TABLE_TYPE_POSITIONING, lookupType, lookupFlags, lookupSequence, subtableSequence, subtableFormat);
+ extractSESubState(GlyphTable.GLYPH_TABLE_TYPE_POSITIONING, lookupType, lookupFlags, lookupSequence, subtableSequence, subtableFormat);
resetATSubState();
}
private void readLookupTable(TTFTableName tableTag, int lookupSequence, long lookupTable) throws IOException {
- boolean isGSUB = tableTag.equals (TTFTableName.GSUB);
- boolean isGPOS = tableTag.equals (TTFTableName.GPOS);
+ boolean isGSUB = tableTag.equals(TTFTableName.GSUB);
+ boolean isGPOS = tableTag.equals(TTFTableName.GPOS);
in.seekSet(lookupTable);
// read lookup type
int lt = in.readTTFUShort();
if (log.isDebugEnabled()) {
String lts;
if (isGSUB) {
- lts = GSUBLookupType.toString (lt);
+ lts = GSUBLookupType.toString(lt);
} else if (isGPOS) {
- lts = GPOSLookupType.toString (lt);
+ lts = GPOSLookupType.toString(lt);
} else {
lts = "?";
}
log.debug(tableTag + " lookup table type: " + lt + " (" + lts + ")");
- log.debug(tableTag + " lookup table flags: " + lf + " (" + LookupFlag.toString (lf) + ")");
+ log.debug(tableTag + " lookup table flags: " + lf + " (" + LookupFlag.toString(lf) + ")");
log.debug(tableTag + " lookup table subtable count: " + ns);
}
// read subtable offsets
for (int i = 0; i < ns; i++) {
int so = soa[i];
if (isGSUB) {
- readGSUBSubtable (lt, lf, lookupSequence, i, lookupTable + so);
+ readGSUBSubtable(lt, lf, lookupSequence, i, lookupTable + so);
} else if (isGPOS) {
- readGPOSSubtable (lt, lf, lookupSequence, i, lookupTable + so);
+ readGPOSSubtable(lt, lf, lookupSequence, i, lookupTable + so);
}
}
}
if (log.isDebugEnabled()) {
log.debug(tableTag + " lookup index: " + i);
}
- readLookupTable (tableTag, i, lookupList + loa [ i ]);
+ readLookupTable(tableTag, i, lookupList + loa [ i ]);
}
}
}
*/
private void readCommonLayoutTables(TTFTableName tableTag, long scriptList, long featureList, long lookupList) throws IOException {
if (scriptList > 0) {
- readScriptList (tableTag, scriptList);
+ readScriptList(tableTag, scriptList);
}
if (featureList > 0) {
- readFeatureList (tableTag, featureList);
+ readFeatureList(tableTag, featureList);
}
if (lookupList > 0) {
- readLookupList (tableTag, lookupList);
+ readLookupList(tableTag, lookupList);
}
}
initATSubState();
in.seekSet(subtableOffset);
// subtable is a bare class definition table
- GlyphClassTable ct = readClassDefTable (tableTag + " glyph class definition table", subtableOffset);
+ GlyphClassTable ct = readClassDefTable(tableTag + " glyph class definition table", subtableOffset);
// store results
seMapping = ct;
// extract subtable
- extractSESubState (GlyphTable.GLYPH_TABLE_TYPE_DEFINITION, GDEFLookupType.GLYPH_CLASS, 0, lookupSequence, 0, 1);
+ extractSESubState(GlyphTable.GLYPH_TABLE_TYPE_DEFINITION, GDEFLookupType.GLYPH_CLASS, 0, lookupSequence, 0, 1);
resetATSubState();
}
log.debug(tableTag + " attachment point coverage table offset: " + co);
}
// read coverage table
- GlyphCoverageTable ct = readCoverageTable (tableTag + " attachment point coverage", subtableOffset + co);
+ GlyphCoverageTable ct = readCoverageTable(tableTag + " attachment point coverage", subtableOffset + co);
// store results
seMapping = ct;
// extract subtable
- extractSESubState (GlyphTable.GLYPH_TABLE_TYPE_DEFINITION, GDEFLookupType.ATTACHMENT_POINT, 0, lookupSequence, 0, 1);
+ extractSESubState(GlyphTable.GLYPH_TABLE_TYPE_DEFINITION, GDEFLookupType.ATTACHMENT_POINT, 0, lookupSequence, 0, 1);
resetATSubState();
}
}
}
// read coverage table
- GlyphCoverageTable ct = readCoverageTable (tableTag + " ligature caret coverage", subtableOffset + co);
+ GlyphCoverageTable ct = readCoverageTable(tableTag + " ligature caret coverage", subtableOffset + co);
// store results
seMapping = ct;
// extract subtable
- extractSESubState (GlyphTable.GLYPH_TABLE_TYPE_DEFINITION, GDEFLookupType.LIGATURE_CARET, 0, lookupSequence, 0, 1);
+ extractSESubState(GlyphTable.GLYPH_TABLE_TYPE_DEFINITION, GDEFLookupType.LIGATURE_CARET, 0, lookupSequence, 0, 1);
resetATSubState();
}
initATSubState();
in.seekSet(subtableOffset);
// subtable is a bare class definition table
- GlyphClassTable ct = readClassDefTable (tableTag + " glyph class definition table", subtableOffset);
+ GlyphClassTable ct = readClassDefTable(tableTag + " glyph class definition table", subtableOffset);
// store results
seMapping = ct;
// extract subtable
- extractSESubState (GlyphTable.GLYPH_TABLE_TYPE_DEFINITION, GDEFLookupType.MARK_ATTACHMENT, 0, lookupSequence, 0, 1);
+ extractSESubState(GlyphTable.GLYPH_TABLE_TYPE_DEFINITION, GDEFLookupType.MARK_ATTACHMENT, 0, lookupSequence, 0, 1);
resetATSubState();
}
initATSubState();
in.seekSet(subtableOffset);
// skip over format (already known)
- in.skip (2);
+ in.skip(2);
// read mark set class count
int nmc = in.readTTFUShort();
long[] mso = new long [ nmc ];
// read mark set coverage tables, one per class
GlyphCoverageTable[] msca = new GlyphCoverageTable[nmc];
for (int i = 0; i < nmc; i++) {
- msca[i] = readCoverageTable (tableTag + " mark set coverage[" + i + "]", subtableOffset + mso[i]);
+ msca[i] = readCoverageTable(tableTag + " mark set coverage[" + i + "]", subtableOffset + mso[i]);
}
// create combined class table from per-class coverage tables
- GlyphClassTable ct = GlyphClassTable.createClassTable (Arrays.asList (msca));
+ GlyphClassTable ct = GlyphClassTable.createClassTable(Arrays.asList(msca));
// store results
seMapping = ct;
// extract subtable
- extractSESubState (GlyphTable.GLYPH_TABLE_TYPE_DEFINITION, GDEFLookupType.MARK_ATTACHMENT, 0, lookupSequence, 0, 1);
+ extractSESubState(GlyphTable.GLYPH_TABLE_TYPE_DEFINITION, GDEFLookupType.MARK_ATTACHMENT, 0, lookupSequence, 0, 1);
resetATSubState();
}
// read mark set subtable format
int sf = in.readTTFUShort();
if (sf == 1) {
- readGDEFMarkGlyphsTableFormat1 (tableTag, lookupSequence, subtableOffset, sf);
+ readGDEFMarkGlyphsTableFormat1(tableTag, lookupSequence, subtableOffset, sf);
} else {
- throw new AdvancedTypographicTableFormatException ("unsupported mark glyph sets subtable format: " + sf);
+ throw new AdvancedTypographicTableFormatException("unsupported mark glyph sets subtable format: " + sf);
}
}
long to = dirTab.getOffset();
// (optionally) read glyph class definition subtable
if (cdo != 0) {
- readGDEFClassDefTable (tableTag, seqno++, to + cdo);
+ readGDEFClassDefTable(tableTag, seqno++, to + cdo);
}
// (optionally) read glyph attachment point subtable
if (apo != 0) {
- readGDEFAttachmentTable (tableTag, seqno++, to + apo);
+ readGDEFAttachmentTable(tableTag, seqno++, to + apo);
}
// (optionally) read ligature caret subtable
if (lco != 0) {
- readGDEFLigatureCaretTable (tableTag, seqno++, to + lco);
+ readGDEFLigatureCaretTable(tableTag, seqno++, to + lco);
}
// (optionally) read mark attachment class subtable
if (mao != 0) {
- readGDEFMarkAttachmentTable (tableTag, seqno++, to + mao);
+ readGDEFMarkAttachmentTable(tableTag, seqno++, to + mao);
}
// (optionally) read mark glyph sets subtable
if (mgo != 0) {
- readGDEFMarkGlyphsTable (tableTag, seqno++, to + mgo);
+ readGDEFMarkGlyphsTable(tableTag, seqno++, to + mgo);
}
GlyphDefinitionTable gdef;
if ((gdef = constructGDEF()) != null) {
// Initialize temporary state
initATState();
// Read glyph substitution (GSUB) table
- TTFDirTabEntry dirTab = ttf.getDirectoryEntry (tableTag);
+ TTFDirTabEntry dirTab = ttf.getDirectoryEntry(tableTag);
if (gpos != null) {
if (log.isDebugEnabled()) {
log.debug(tableTag + ": ignoring duplicate table");
log.debug(tableTag + " lookup list offset: " + llo);
}
long to = dirTab.getOffset();
- readCommonLayoutTables (tableTag, to + slo, to + flo, to + llo);
+ readCommonLayoutTables(tableTag, to + slo, to + flo, to + llo);
GlyphSubstitutionTable gsub;
if ((gsub = constructGSUB()) != null) {
this.gsub = gsub;
// Initialize temporary state
initATState();
// Read glyph positioning (GPOS) table
- TTFDirTabEntry dirTab = ttf.getDirectoryEntry (tableTag);
+ TTFDirTabEntry dirTab = ttf.getDirectoryEntry(tableTag);
if (gpos != null) {
if (log.isDebugEnabled()) {
log.debug(tableTag + ": ignoring duplicate table");
log.debug(tableTag + " lookup list offset: " + llo);
}
long to = dirTab.getOffset();
- readCommonLayoutTables (tableTag, to + slo, to + flo, to + llo);
+ readCommonLayoutTables(tableTag, to + slo, to + flo, to + llo);
GlyphPositioningTable gpos;
if ((gpos = constructGPOS()) != null) {
this.gpos = gpos;
List subtables;
if ((subtables = constructGDEFSubtables()) != null) {
if (subtables.size() > 0) {
- gdef = new GlyphDefinitionTable (subtables);
+ gdef = new GlyphDefinitionTable(subtables);
}
}
resetATState();
List subtables;
if ((subtables = constructGSUBSubtables()) != null) {
if ((lookups.size() > 0) && (subtables.size() > 0)) {
- gsub = new GlyphSubstitutionTable (gdef, lookups, subtables);
+ gsub = new GlyphSubstitutionTable(gdef, lookups, subtables);
}
}
}
List subtables;
if ((subtables = constructGPOSSubtables()) != null) {
if ((lookups.size() > 0) && (subtables.size() > 0)) {
- gpos = new GlyphPositioningTable (gdef, lookups, subtables);
+ gpos = new GlyphPositioningTable(gdef, lookups, subtables);
}
}
}
return gpos;
}
- private void constructLookupsFeature (Map lookups, String st, String lt, String fid) {
- Object[] fp = (Object[]) seFeatures.get (fid);
+ private void constructLookupsFeature(Map lookups, String st, String lt, String fid) {
+ Object[] fp = (Object[]) seFeatures.get(fid);
if (fp != null) {
assert fp.length == 2;
String ft = (String) fp[0]; // feature tag
List/*<String>*/ lul = (List) fp[1]; // list of lookup table ids
if ((ft != null) && (lul != null) && (lul.size() > 0)) {
- GlyphTable.LookupSpec ls = new GlyphTable.LookupSpec (st, lt, ft);
- lookups.put (ls, lul);
+ GlyphTable.LookupSpec ls = new GlyphTable.LookupSpec(st, lt, ft);
+ lookups.put(ls, lul);
}
}
}
- private void constructLookupsFeatures (Map lookups, String st, String lt, List/*<String>*/ fids) {
+ private void constructLookupsFeatures(Map lookups, String st, String lt, List/*<String>*/ fids) {
for (Iterator fit = fids.iterator(); fit.hasNext();) {
String fid = (String) fit.next();
- constructLookupsFeature (lookups, st, lt, fid);
+ constructLookupsFeature(lookups, st, lt, fid);
}
}
- private void constructLookupsLanguage (Map lookups, String st, String lt, Map/*<String,Object[2]>*/ languages) {
- Object[] lp = (Object[]) languages.get (lt);
+ private void constructLookupsLanguage(Map lookups, String st, String lt, Map/*<String,Object[2]>*/ languages) {
+ Object[] lp = (Object[]) languages.get(lt);
if (lp != null) {
assert lp.length == 2;
if (lp[0] != null) { // required feature id
- constructLookupsFeature (lookups, st, lt, (String) lp[0]);
+ constructLookupsFeature(lookups, st, lt, (String) lp[0]);
}
if (lp[1] != null) { // non-required features ids
- constructLookupsFeatures (lookups, st, lt, (List) lp[1]);
+ constructLookupsFeatures(lookups, st, lt, (List) lp[1]);
}
}
}
- private void constructLookupsLanguages (Map lookups, String st, List/*<String>*/ ll, Map/*<String,Object[2]>*/ languages) {
+ private void constructLookupsLanguages(Map lookups, String st, List/*<String>*/ ll, Map/*<String,Object[2]>*/ languages) {
for (Iterator lit = ll.iterator(); lit.hasNext();) {
String lt = (String) lit.next();
- constructLookupsLanguage (lookups, st, lt, languages);
+ constructLookupsLanguage(lookups, st, lt, languages);
}
}
Map/*<GlyphTable.LookupSpec,List<String>>*/ lookups = new java.util.LinkedHashMap();
for (Iterator sit = seScripts.keySet().iterator(); sit.hasNext();) {
String st = (String) sit.next();
- Object[] sp = (Object[]) seScripts.get (st);
+ Object[] sp = (Object[]) seScripts.get(st);
if (sp != null) {
assert sp.length == 3;
Map/*<String,Object[2]>*/ languages = (Map) sp[2];
if (sp[0] != null) { // default language
- constructLookupsLanguage (lookups, st, (String) sp[0], languages);
+ constructLookupsLanguage(lookups, st, (String) sp[0], languages);
}
if (sp[1] != null) { // non-default languages
- constructLookupsLanguages (lookups, st, (List) sp[1], languages);
+ constructLookupsLanguages(lookups, st, (List) sp[1], languages);
}
}
}
for (Iterator it = seSubtables.iterator(); it.hasNext();) {
Object[] stp = (Object[]) it.next();
GlyphSubtable st;
- if ((st = constructGDEFSubtable (stp)) != null) {
- subtables.add (st);
+ if ((st = constructGDEFSubtable(stp)) != null) {
+ subtables.add(st);
}
}
}
return subtables;
}
- private GlyphSubtable constructGDEFSubtable (Object[] stp) {
+ private GlyphSubtable constructGDEFSubtable(Object[] stp) {
GlyphSubtable st = null;
assert (stp != null) && (stp.length == 8);
Integer tt = (Integer) stp[0]; // table type
GlyphMappingTable mapping = (GlyphMappingTable) stp[6];
List entries = (List) stp[7];
if (tt.intValue() == GlyphTable.GLYPH_TABLE_TYPE_DEFINITION) {
- int type = GDEFLookupType.getSubtableType (lt.intValue());
+ int type = GDEFLookupType.getSubtableType(lt.intValue());
String lid = "lu" + ln.intValue();
int sequence = sn.intValue();
int flags = lf.intValue();
int format = sf.intValue();
- st = GlyphDefinitionTable.createSubtable (type, lid, sequence, flags, format, mapping, entries);
+ st = GlyphDefinitionTable.createSubtable(type, lid, sequence, flags, format, mapping, entries);
}
return st;
}
for (Iterator it = seSubtables.iterator(); it.hasNext();) {
Object[] stp = (Object[]) it.next();
GlyphSubtable st;
- if ((st = constructGSUBSubtable (stp)) != null) {
- subtables.add (st);
+ if ((st = constructGSUBSubtable(stp)) != null) {
+ subtables.add(st);
}
}
}
return subtables;
}
- private GlyphSubtable constructGSUBSubtable (Object[] stp) {
+ private GlyphSubtable constructGSUBSubtable(Object[] stp) {
GlyphSubtable st = null;
assert (stp != null) && (stp.length == 8);
Integer tt = (Integer) stp[0]; // table type
GlyphCoverageTable coverage = (GlyphCoverageTable) stp[6];
List entries = (List) stp[7];
if (tt.intValue() == GlyphTable.GLYPH_TABLE_TYPE_SUBSTITUTION) {
- int type = GSUBLookupType.getSubtableType (lt.intValue());
+ int type = GSUBLookupType.getSubtableType(lt.intValue());
String lid = "lu" + ln.intValue();
int sequence = sn.intValue();
int flags = lf.intValue();
int format = sf.intValue();
- st = GlyphSubstitutionTable.createSubtable (type, lid, sequence, flags, format, coverage, entries);
+ st = GlyphSubstitutionTable.createSubtable(type, lid, sequence, flags, format, coverage, entries);
}
return st;
}
for (Iterator it = seSubtables.iterator(); it.hasNext();) {
Object[] stp = (Object[]) it.next();
GlyphSubtable st;
- if ((st = constructGPOSSubtable (stp)) != null) {
- subtables.add (st);
+ if ((st = constructGPOSSubtable(stp)) != null) {
+ subtables.add(st);
}
}
}
return subtables;
}
- private GlyphSubtable constructGPOSSubtable (Object[] stp) {
+ private GlyphSubtable constructGPOSSubtable(Object[] stp) {
GlyphSubtable st = null;
assert (stp != null) && (stp.length == 8);
Integer tt = (Integer) stp[0]; // table type
GlyphCoverageTable coverage = (GlyphCoverageTable) stp[6];
List entries = (List) stp[7];
if (tt.intValue() == GlyphTable.GLYPH_TABLE_TYPE_POSITIONING) {
- int type = GSUBLookupType.getSubtableType (lt.intValue());
+ int type = GSUBLookupType.getSubtableType(lt.intValue());
String lid = "lu" + ln.intValue();
int sequence = sn.intValue();
int flags = lf.intValue();
int format = sf.intValue();
- st = GlyphPositioningTable.createSubtable (type, lid, sequence, flags, format, coverage, entries);
+ st = GlyphPositioningTable.createSubtable(type, lid, sequence, flags, format, coverage, entries);
}
return st;
}
seEntries = new java.util.ArrayList();
}
- private void extractSESubState (int tableType, int lookupType, int lookupFlags, int lookupSequence, int subtableSequence, int subtableFormat) {
+ private void extractSESubState(int tableType, int lookupType, int lookupFlags, int lookupSequence, int subtableSequence, int subtableFormat) {
if (seEntries != null) {
if ((tableType == GlyphTable.GLYPH_TABLE_TYPE_DEFINITION) || (seEntries.size() > 0)) {
if (seSubtables != null) {
- Integer tt = Integer.valueOf (tableType);
- Integer lt = Integer.valueOf (lookupType);
- Integer ln = Integer.valueOf (lookupSequence);
- Integer lf = Integer.valueOf (lookupFlags);
- Integer sn = Integer.valueOf (subtableSequence);
- Integer sf = Integer.valueOf (subtableFormat);
- seSubtables.add (new Object[] { tt, lt, ln, lf, sn, sf, seMapping, seEntries });
+ Integer tt = Integer.valueOf(tableType);
+ Integer lt = Integer.valueOf(lookupType);
+ Integer ln = Integer.valueOf(lookupSequence);
+ Integer lf = Integer.valueOf(lookupFlags);
+ Integer sn = Integer.valueOf(subtableSequence);
+ Integer sf = Integer.valueOf(subtableFormat);
+ seSubtables.add(new Object[] { tt, lt, ln, lf, sn, sf, seMapping, seEntries });
}
}
}
}
/** helper method for formatting an integer array for output */
- private String toString (int[] ia) {
+ private String toString(int[] ia) {
StringBuffer sb = new StringBuffer();
if ((ia == null) || (ia.length == 0)) {
- sb.append ('-');
+ sb.append('-');
} else {
boolean first = true;
for (int i = 0; i < ia.length; i++) {
if (! first) {
- sb.append (' ');
+ sb.append(' ');
} else {
first = false;
}
- sb.append (ia[i]);
+ sb.append(ia[i]);
}
}
return sb.toString();
* @return 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, or null if no non-zero adjustment applies
*/
- int[][] performPositioning (CharSequence cs, String script, String language, int fontSize);
+ int[][] performPositioning(CharSequence cs, String script, String language, int fontSize);
/**
* Perform glyph positioning using an implied font size.
* @return 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, or null if no non-zero adjustment applies
*/
- int[][] performPositioning (CharSequence cs, String script, String language);
+ int[][] performPositioning(CharSequence cs, String script, String language);
}
* @return output sequence (represented as a character sequence, where each character in the returned sequence
* denotes "font characters", i.e., character codes that map directly (1-1) to their associated glyphs
*/
- CharSequence performSubstitution (CharSequence cs, String script, String language);
+ CharSequence performSubstitution(CharSequence cs, String script, String language);
/**
* Reorder combining marks in character sequence so that they precede (within the sequence) the base
* @param language a language identifier
* @return output sequence containing reordered "font characters"
*/
- CharSequence reorderCombiningMarks (CharSequence cs, int[][] gpa, String script, String language);
+ CharSequence reorderCombiningMarks(CharSequence cs, int[][] gpa, String script, String language);
}
private static class SubstitutionScriptContextTester implements ScriptContextTester {
private static Map/*<String,GlyphContextTester>*/ testerMap = new HashMap/*<String,GlyphContextTester>*/();
static {
- testerMap.put ("fina", new GlyphContextTester() {
- public boolean test (String script, String language, String feature, GlyphSequence gs, int index, int flags) {
- return inFinalContext (script, language, feature, gs, index, flags);
+ testerMap.put("fina", new GlyphContextTester() {
+ public boolean test(String script, String language, String feature, GlyphSequence gs, int index, int flags) {
+ return inFinalContext(script, language, feature, gs, index, flags);
}
});
- testerMap.put ("init", new GlyphContextTester() {
- public boolean test (String script, String language, String feature, GlyphSequence gs, int index, int flags) {
- return inInitialContext (script, language, feature, gs, index, flags);
+ testerMap.put("init", new GlyphContextTester() {
+ public boolean test(String script, String language, String feature, GlyphSequence gs, int index, int flags) {
+ return inInitialContext(script, language, feature, gs, index, flags);
}
});
- testerMap.put ("isol", new GlyphContextTester() {
- public boolean test (String script, String language, String feature, GlyphSequence gs, int index, int flags) {
- return inIsolateContext (script, language, feature, gs, index, flags);
+ testerMap.put("isol", new GlyphContextTester() {
+ public boolean test(String script, String language, String feature, GlyphSequence gs, int index, int flags) {
+ return inIsolateContext(script, language, feature, gs, index, flags);
}
});
- testerMap.put ("liga", new GlyphContextTester() {
- public boolean test (String script, String language, String feature, GlyphSequence gs, int index, int flags) {
- return inLigatureContext (script, language, feature, gs, index, flags);
+ testerMap.put("liga", new GlyphContextTester() {
+ public boolean test(String script, String language, String feature, GlyphSequence gs, int index, int flags) {
+ return inLigatureContext(script, language, feature, gs, index, flags);
}
});
- testerMap.put ("medi", new GlyphContextTester() {
- public boolean test (String script, String language, String feature, GlyphSequence gs, int index, int flags) {
- return inMedialContext (script, language, feature, gs, index, flags);
+ testerMap.put("medi", new GlyphContextTester() {
+ public boolean test(String script, String language, String feature, GlyphSequence gs, int index, int flags) {
+ return inMedialContext(script, language, feature, gs, index, flags);
}
});
}
- public GlyphContextTester getTester (String feature) {
- return (GlyphContextTester) testerMap.get (feature);
+ public GlyphContextTester getTester(String feature) {
+ return (GlyphContextTester) testerMap.get(feature);
}
}
private static class PositioningScriptContextTester implements ScriptContextTester {
private static Map/*<String,GlyphContextTester>*/ testerMap = new HashMap/*<String,GlyphContextTester>*/();
- public GlyphContextTester getTester (String feature) {
- return (GlyphContextTester) testerMap.get (feature);
+ public GlyphContextTester getTester(String feature) {
+ return (GlyphContextTester) testerMap.get(feature);
}
}
private final ScriptContextTester subContextTester;
private final ScriptContextTester posContextTester;
- ArabicScriptProcessor (String script) {
- super (script);
+ ArabicScriptProcessor(String script) {
+ super(script);
this.subContextTester = new SubstitutionScriptContextTester();
this.posContextTester = new PositioningScriptContextTester();
}
/** {@inheritDoc} */
@Override
- public GlyphSequence reorderCombiningMarks (GlyphDefinitionTable gdef, GlyphSequence gs, int[][] gpa, String script, String language) {
+ public GlyphSequence reorderCombiningMarks(GlyphDefinitionTable gdef, GlyphSequence gs, int[][] gpa, String script, String language) {
// a side effect of BIDI reordering is to order combining marks before their base, so we need to override the default here to
// prevent double reordering
return gs;
}
- private static boolean inFinalContext (String script, String language, String feature, GlyphSequence gs, int index, int flags) {
- GlyphSequence.CharAssociation a = gs.getAssociation (index);
- int[] ca = gs.getCharacterArray (false);
+ private static boolean inFinalContext(String script, String language, String feature, GlyphSequence gs, int index, int flags) {
+ GlyphSequence.CharAssociation a = gs.getAssociation(index);
+ int[] ca = gs.getCharacterArray(false);
int nc = gs.getCharacterCount();
if (nc == 0) {
return false;
} else {
int s = a.getStart();
int e = a.getEnd();
- if (! hasFinalPrecedingContext (ca, nc, s, e)) {
+ if (! hasFinalPrecedingContext(ca, nc, s, e)) {
return false;
- } else if (forcesFinalThisContext (ca, nc, s, e)) {
+ } else if (forcesFinalThisContext(ca, nc, s, e)) {
return true;
- } else if (! hasFinalFollowingContext (ca, nc, s, e)) {
+ } else if (! hasFinalFollowingContext(ca, nc, s, e)) {
return false;
} else {
return true;
}
}
- private static boolean inInitialContext (String script, String language, String feature, GlyphSequence gs, int index, int flags) {
- GlyphSequence.CharAssociation a = gs.getAssociation (index);
- int[] ca = gs.getCharacterArray (false);
+ private static boolean inInitialContext(String script, String language, String feature, GlyphSequence gs, int index, int flags) {
+ GlyphSequence.CharAssociation a = gs.getAssociation(index);
+ int[] ca = gs.getCharacterArray(false);
int nc = gs.getCharacterCount();
if (nc == 0) {
return false;
} else {
int s = a.getStart();
int e = a.getEnd();
- if (! hasInitialPrecedingContext (ca, nc, s, e)) {
+ if (! hasInitialPrecedingContext(ca, nc, s, e)) {
return false;
- } else if (! hasInitialFollowingContext (ca, nc, s, e)) {
+ } else if (! hasInitialFollowingContext(ca, nc, s, e)) {
return false;
} else {
return true;
}
}
- private static boolean inIsolateContext (String script, String language, String feature, GlyphSequence gs, int index, int flags) {
- GlyphSequence.CharAssociation a = gs.getAssociation (index);
+ private static boolean inIsolateContext(String script, String language, String feature, GlyphSequence gs, int index, int flags) {
+ GlyphSequence.CharAssociation a = gs.getAssociation(index);
int nc = gs.getCharacterCount();
if (nc == 0) {
return false;
}
}
- private static boolean inLigatureContext (String script, String language, String feature, GlyphSequence gs, int index, int flags) {
- GlyphSequence.CharAssociation a = gs.getAssociation (index);
- int[] ca = gs.getCharacterArray (false);
+ private static boolean inLigatureContext(String script, String language, String feature, GlyphSequence gs, int index, int flags) {
+ GlyphSequence.CharAssociation a = gs.getAssociation(index);
+ int[] ca = gs.getCharacterArray(false);
int nc = gs.getCharacterCount();
if (nc == 0) {
return false;
} else {
int s = a.getStart();
int e = a.getEnd();
- if (! hasLigaturePrecedingContext (ca, nc, s, e)) {
+ if (! hasLigaturePrecedingContext(ca, nc, s, e)) {
return false;
- } else if (! hasLigatureFollowingContext (ca, nc, s, e)) {
+ } else if (! hasLigatureFollowingContext(ca, nc, s, e)) {
return false;
} else {
return true;
}
}
- private static boolean inMedialContext (String script, String language, String feature, GlyphSequence gs, int index, int flags) {
- GlyphSequence.CharAssociation a = gs.getAssociation (index);
- int[] ca = gs.getCharacterArray (false);
+ private static boolean inMedialContext(String script, String language, String feature, GlyphSequence gs, int index, int flags) {
+ GlyphSequence.CharAssociation a = gs.getAssociation(index);
+ int[] ca = gs.getCharacterArray(false);
int nc = gs.getCharacterCount();
if (nc == 0) {
return false;
} else {
int s = a.getStart();
int e = a.getEnd();
- if (! hasMedialPrecedingContext (ca, nc, s, e)) {
+ if (! hasMedialPrecedingContext(ca, nc, s, e)) {
return false;
- } else if (! hasMedialThisContext (ca, nc, s, e)) {
+ } else if (! hasMedialThisContext(ca, nc, s, e)) {
return false;
- } else if (! hasMedialFollowingContext (ca, nc, s, e)) {
+ } else if (! hasMedialFollowingContext(ca, nc, s, e)) {
return false;
} else {
return true;
}
}
- private static boolean hasFinalPrecedingContext (int[] ca, int nc, int s, int e) {
+ private static boolean hasFinalPrecedingContext(int[] ca, int nc, int s, int e) {
int chp = 0;
int clp = 0;
for (int i = s; i > 0; i--) {
int k = i - 1;
if ((k >= 0) && (k < nc)) {
chp = ca [ k ];
- clp = BidiClass.getBidiClass (chp);
+ clp = BidiClass.getBidiClass(chp);
if (clp != BidiConstants.NSM) {
break;
}
}
if (clp != BidiConstants.AL) {
return false;
- } else if (hasIsolateInitial (chp)) {
+ } else if (hasIsolateInitial(chp)) {
return false;
} else {
return true;
}
}
- private static boolean forcesFinalThisContext (int[] ca, int nc, int s, int e) {
+ private static boolean forcesFinalThisContext(int[] ca, int nc, int s, int e) {
int chl = 0;
int cll = 0;
for (int i = 0, n = e - s; i < n; i++) {
int j = s + k;
if ((j >= 0) && (j < nc)) {
chl = ca [ j ];
- cll = BidiClass.getBidiClass (chl);
+ cll = BidiClass.getBidiClass(chl);
if (cll != BidiConstants.NSM) {
break;
}
if (cll != BidiConstants.AL) {
return false;
}
- if (hasIsolateInitial (chl)) {
+ if (hasIsolateInitial(chl)) {
return true;
} else {
return false;
}
}
- private static boolean hasFinalFollowingContext (int[] ca, int nc, int s, int e) {
+ private static boolean hasFinalFollowingContext(int[] ca, int nc, int s, int e) {
int chf = 0;
int clf = 0;
for (int i = e, n = nc; i < n; i++) {
chf = ca [ i ];
- clf = BidiClass.getBidiClass (chf);
+ clf = BidiClass.getBidiClass(chf);
if (clf != BidiConstants.NSM) {
break;
}
}
if (clf != BidiConstants.AL) {
return true;
- } else if (hasIsolateFinal (chf)) {
+ } else if (hasIsolateFinal(chf)) {
return true;
} else {
return false;
}
}
- private static boolean hasInitialPrecedingContext (int[] ca, int nc, int s, int e) {
+ private static boolean hasInitialPrecedingContext(int[] ca, int nc, int s, int e) {
int chp = 0;
int clp = 0;
for (int i = s; i > 0; i--) {
int k = i - 1;
if ((k >= 0) && (k < nc)) {
chp = ca [ k ];
- clp = BidiClass.getBidiClass (chp);
+ clp = BidiClass.getBidiClass(chp);
if (clp != BidiConstants.NSM) {
break;
}
}
if (clp != BidiConstants.AL) {
return true;
- } else if (hasIsolateInitial (chp)) {
+ } else if (hasIsolateInitial(chp)) {
return true;
} else {
return false;
}
}
- private static boolean hasInitialFollowingContext (int[] ca, int nc, int s, int e) {
+ private static boolean hasInitialFollowingContext(int[] ca, int nc, int s, int e) {
int chf = 0;
int clf = 0;
for (int i = e, n = nc; i < n; i++) {
chf = ca [ i ];
- clf = BidiClass.getBidiClass (chf);
+ clf = BidiClass.getBidiClass(chf);
if (clf != BidiConstants.NSM) {
break;
}
}
if (clf != BidiConstants.AL) {
return false;
- } else if (hasIsolateFinal (chf)) {
+ } else if (hasIsolateFinal(chf)) {
return false;
} else {
return true;
}
}
- private static boolean hasMedialPrecedingContext (int[] ca, int nc, int s, int e) {
+ private static boolean hasMedialPrecedingContext(int[] ca, int nc, int s, int e) {
int chp = 0;
int clp = 0;
for (int i = s; i > 0; i--) {
int k = i - 1;
if ((k >= 0) && (k < nc)) {
chp = ca [ k ];
- clp = BidiClass.getBidiClass (chp);
+ clp = BidiClass.getBidiClass(chp);
if (clp != BidiConstants.NSM) {
break;
}
}
if (clp != BidiConstants.AL) {
return false;
- } else if (hasIsolateInitial (chp)) {
+ } else if (hasIsolateInitial(chp)) {
return false;
} else {
return true;
}
}
- private static boolean hasMedialThisContext (int[] ca, int nc, int s, int e) {
+ private static boolean hasMedialThisContext(int[] ca, int nc, int s, int e) {
int chf = 0; // first non-NSM char in [s,e)
int clf = 0;
for (int i = 0, n = e - s; i < n; i++) {
int k = s + i;
if ((k >= 0) && (k < nc)) {
chf = ca [ s + i ];
- clf = BidiClass.getBidiClass (chf);
+ clf = BidiClass.getBidiClass(chf);
if (clf != BidiConstants.NSM) {
break;
}
int j = s + k;
if ((j >= 0) && (j < nc)) {
chl = ca [ j ];
- cll = BidiClass.getBidiClass (chl);
+ cll = BidiClass.getBidiClass(chl);
if (cll != BidiConstants.NSM) {
break;
}
if (cll != BidiConstants.AL) {
return false;
}
- if (hasIsolateFinal (chf)) {
+ if (hasIsolateFinal(chf)) {
return false;
- } else if (hasIsolateInitial (chl)) {
+ } else if (hasIsolateInitial(chl)) {
return false;
} else {
return true;
}
}
- private static boolean hasMedialFollowingContext (int[] ca, int nc, int s, int e) {
+ private static boolean hasMedialFollowingContext(int[] ca, int nc, int s, int e) {
int chf = 0;
int clf = 0;
for (int i = e, n = nc; i < n; i++) {
chf = ca [ i ];
- clf = BidiClass.getBidiClass (chf);
+ clf = BidiClass.getBidiClass(chf);
if (clf != BidiConstants.NSM) {
break;
}
}
if (clf != BidiConstants.AL) {
return false;
- } else if (hasIsolateFinal (chf)) {
+ } else if (hasIsolateFinal(chf)) {
return false;
} else {
return true;
}
}
- private static boolean hasLigaturePrecedingContext (int[] ca, int nc, int s, int e) {
+ private static boolean hasLigaturePrecedingContext(int[] ca, int nc, int s, int e) {
return true;
}
- private static boolean hasLigatureFollowingContext (int[] ca, int nc, int s, int e) {
+ private static boolean hasLigatureFollowingContext(int[] ca, int nc, int s, int e) {
int chf = 0;
int clf = 0;
for (int i = e, n = nc; i < n; i++) {
chf = ca [ i ];
- clf = BidiClass.getBidiClass (chf);
+ clf = BidiClass.getBidiClass(chf);
if (clf != BidiConstants.NSM) {
break;
}
0x06EF // REH WITH INVERTED V
};
- private static boolean hasIsolateInitial (int ch) {
- return Arrays.binarySearch (isolatedInitials, ch) >= 0;
+ private static boolean hasIsolateInitial(int ch) {
+ return Arrays.binarySearch(isolatedInitials, ch) >= 0;
}
/**
0x0621 // HAMZA
};
- private static boolean hasIsolateFinal (int ch) {
- return Arrays.binarySearch (isolatedFinals, ch) >= 0;
+ private static boolean hasIsolateFinal(int ch) {
+ return Arrays.binarySearch(isolatedFinals, ch) >= 0;
}
}
"mkmk" // mark to mark positioning
};
- DefaultScriptProcessor (String script) {
- super (script);
+ DefaultScriptProcessor(String script) {
+ super(script);
}
@Override
@Override
/** {@inheritDoc} */
- public GlyphSequence reorderCombiningMarks (GlyphDefinitionTable gdef, GlyphSequence gs, int[][] gpa, String script, String language) {
+ public GlyphSequence reorderCombiningMarks(GlyphDefinitionTable gdef, GlyphSequence gs, int[][] gpa, String script, String language) {
int ng = gs.getGlyphCount();
- int[] ga = gs.getGlyphArray (false);
+ int[] ga = gs.getGlyphArray(false);
int nm = 0;
// count combining marks
for (int i = 0; i < ng; i++) {
int gid = ga [ i ];
- if (gdef.isGlyphClass (gid, GlyphDefinitionTable.GLYPH_CLASS_MARK)) {
+ if (gdef.isGlyphClass(gid, GlyphDefinitionTable.GLYPH_CLASS_MARK)) {
nm++;
}
}
// only reorder if there is at least one mark and at least one non-mark glyph
if ((nm > 0) && ((ng - nm) > 0)) {
- GlyphSequence.CharAssociation[] aa = gs.getAssociations (0, -1);
+ GlyphSequence.CharAssociation[] aa = gs.getAssociations(0, -1);
int[] nga = new int [ ng ];
int[][] npa = (gpa != null) ? new int [ ng ][] : null;
GlyphSequence.CharAssociation[] naa = new GlyphSequence.CharAssociation [ ng ];
int gid = ga [ i ];
int[] pa = (gpa != null) ? gpa [ i ] : null;
GlyphSequence.CharAssociation ca = aa [ i ];
- if (gdef.isGlyphClass (gid, GlyphDefinitionTable.GLYPH_CLASS_MARK)) {
+ if (gdef.isGlyphClass(gid, GlyphDefinitionTable.GLYPH_CLASS_MARK)) {
nga [ k ] = gid;
naa [ k ] = ca;
if (npa != null) {
}
assert k == ng;
if (npa != null) {
- System.arraycopy (npa, 0, gpa, 0, ng);
+ System.arraycopy(npa, 0, gpa, 0, ng);
}
- return new GlyphSequence (gs, null, nga, null, null, naa, null);
+ return new GlyphSequence(gs, null, nga, null, null, naa, null);
} else {
return gs;
}
/** logging instance */
private static final Log log = LogFactory.getLog(DevanagariScriptProcessor.class); // CSOK: ConstantNameCheck
- DevanagariScriptProcessor (String script) {
- super (script);
+ DevanagariScriptProcessor(String script) {
+ super(script);
}
@Override
@Override
// find rightmost pre-base matra
- protected int findPreBaseMatra (GlyphSequence gs) {
+ protected int findPreBaseMatra(GlyphSequence gs) {
int ng = gs.getGlyphCount();
int lk = -1;
for (int i = ng; i > 0; i--) {
int k = i - 1;
- if (containsPreBaseMatra (gs, k)) {
+ if (containsPreBaseMatra(gs, k)) {
lk = k;
break;
}
@Override
// find leftmost pre-base matra target, starting from source
- protected int findPreBaseMatraTarget (GlyphSequence gs, int source) {
+ protected int findPreBaseMatraTarget(GlyphSequence gs, int source) {
int ng = gs.getGlyphCount();
int lk = -1;
for (int i = (source < ng) ? source : ng; i > 0; i--) {
int k = i - 1;
- if (containsConsonant (gs, k)) {
- if (containsHalfConsonant (gs, k)) {
+ if (containsConsonant(gs, k)) {
+ if (containsHalfConsonant(gs, k)) {
lk = k;
} else if (lk == -1) {
lk = k;
return lk;
}
- private static boolean containsPreBaseMatra (GlyphSequence gs, int k) {
- GlyphSequence.CharAssociation a = gs.getAssociation (k);
- int[] ca = gs.getCharacterArray (false);
+ private static boolean containsPreBaseMatra(GlyphSequence gs, int k) {
+ GlyphSequence.CharAssociation a = gs.getAssociation(k);
+ int[] ca = gs.getCharacterArray(false);
for (int i = a.getStart(), e = a.getEnd(); i < e; i++) {
- if (isPreM (ca [ i ])) {
+ if (isPreM(ca [ i ])) {
return true;
}
}
return false;
}
- private static boolean containsConsonant (GlyphSequence gs, int k) {
- GlyphSequence.CharAssociation a = gs.getAssociation (k);
- int[] ca = gs.getCharacterArray (false);
+ private static boolean containsConsonant(GlyphSequence gs, int k) {
+ GlyphSequence.CharAssociation a = gs.getAssociation(k);
+ int[] ca = gs.getCharacterArray(false);
for (int i = a.getStart(), e = a.getEnd(); i < e; i++) {
- if (isC (ca [ i ])) {
+ if (isC(ca [ i ])) {
return true;
}
}
return false;
}
- private static boolean containsHalfConsonant (GlyphSequence gs, int k) {
- Boolean half = (Boolean) gs.getAssociation (k) . getPredication ("half");
+ private static boolean containsHalfConsonant(GlyphSequence gs, int k) {
+ Boolean half = (Boolean) gs.getAssociation(k) . getPredication("half");
return (half != null) ? half.booleanValue() : false;
}
@Override
- protected int findReph (GlyphSequence gs) {
+ protected int findReph(GlyphSequence gs) {
int ng = gs.getGlyphCount();
int li = -1;
for (int i = 0; i < ng; i++) {
- if (containsReph (gs, i)) {
+ if (containsReph(gs, i)) {
li = i;
break;
}
}
@Override
- protected int findRephTarget (GlyphSequence gs, int source) {
+ protected int findRephTarget(GlyphSequence gs, int source) {
int ng = gs.getGlyphCount();
int c1 = -1;
int c2 = -1;
// first candidate target is after first non-half consonant
for (int i = 0; i < ng; i++) {
- if ((i != source) && containsConsonant (gs, i)) {
- if (! containsHalfConsonant (gs, i)) {
+ if ((i != source) && containsConsonant(gs, i)) {
+ if (! containsHalfConsonant(gs, i)) {
c1 = i + 1;
break;
}
}
// second candidate target is after last non-prebase matra after first candidate or before first syllable or vedic mark
for (int i = (c1 >= 0) ? c1 : 0; i < ng; i++) {
- if (containsMatra (gs, i) && ! containsPreBaseMatra (gs, i)) {
+ if (containsMatra(gs, i) && ! containsPreBaseMatra(gs, i)) {
c2 = i + 1;
- } else if (containsOtherMark (gs, i)) {
+ } else if (containsOtherMark(gs, i)) {
c2 = i;
break;
}
}
}
- private static boolean containsReph (GlyphSequence gs, int k) {
- Boolean rphf = (Boolean) gs.getAssociation (k) . getPredication ("rphf");
+ private static boolean containsReph(GlyphSequence gs, int k) {
+ Boolean rphf = (Boolean) gs.getAssociation(k) . getPredication("rphf");
return (rphf != null) ? rphf.booleanValue() : false;
}
- private static boolean containsMatra (GlyphSequence gs, int k) {
- GlyphSequence.CharAssociation a = gs.getAssociation (k);
- int[] ca = gs.getCharacterArray (false);
+ private static boolean containsMatra(GlyphSequence gs, int k) {
+ GlyphSequence.CharAssociation a = gs.getAssociation(k);
+ int[] ca = gs.getCharacterArray(false);
for (int i = a.getStart(), e = a.getEnd(); i < e; i++) {
- if (isM (ca [ i ])) {
+ if (isM(ca [ i ])) {
return true;
}
}
return false;
}
- private static boolean containsOtherMark (GlyphSequence gs, int k) {
- GlyphSequence.CharAssociation a = gs.getAssociation (k);
- int[] ca = gs.getCharacterArray (false);
+ private static boolean containsOtherMark(GlyphSequence gs, int k) {
+ GlyphSequence.CharAssociation a = gs.getAssociation(k);
+ int[] ca = gs.getCharacterArray(false);
for (int i = a.getStart(), e = a.getEnd(); i < e; i++) {
- switch (typeOf (ca [ i ])) {
+ switch (typeOf(ca [ i ])) {
case C_T: // tone (e.g., udatta, anudatta)
case C_A: // accent (e.g., acute, grave)
case C_O: // other (e.g., candrabindu, anusvara, visarga, etc)
}
private static class DevanagariSyllabizer extends DefaultSyllabizer {
- DevanagariSyllabizer (String script, String language) {
- super (script, language);
+ DevanagariSyllabizer(String script, String language) {
+ super(script, language);
}
@Override
// | C ...
- protected int findStartOfSyllable (int[] ca, int s, int e) {
+ protected int findStartOfSyllable(int[] ca, int s, int e) {
if ((s < 0) || (s >= e)) {
return -1;
} else {
while (s < e) {
int c = ca [ s ];
- if (isC (c)) {
+ if (isC(c)) {
break;
} else {
s++;
}
@Override
// D* L? | ...
- protected int findEndOfSyllable (int[] ca, int s, int e) {
+ protected int findEndOfSyllable(int[] ca, int s, int e) {
if ((s < 0) || (s >= e)) {
return -1;
} else {
int nl = 0;
int i;
// consume dead consonants
- while ((i = isDeadConsonant (ca, s, e)) > s) {
+ while ((i = isDeadConsonant(ca, s, e)) > s) {
s = i;
nd++;
}
// consume zero or one live consonant
- if ((i = isLiveConsonant (ca, s, e)) > s) {
+ if ((i = isLiveConsonant(ca, s, e)) > s) {
s = i;
nl++;
}
}
}
// D := ( C N? H )?
- private int isDeadConsonant (int[] ca, int s, int e) {
+ private int isDeadConsonant(int[] ca, int s, int e) {
if (s < 0) {
return -1;
} else {
// C
if ((s + i) < e) {
c = ca [ s + i ];
- if (isC (c)) {
+ if (isC(c)) {
i++;
nc++;
} else {
// N?
if ((s + i) < e) {
c = ca [ s + 1 ];
- if (isN (c)) {
+ if (isN(c)) {
i++;
}
}
// H
if ((s + i) < e) {
c = ca [ s + i ];
- if (isH (c)) {
+ if (isH(c)) {
i++;
nh++;
} else {
}
}
// L := ( (C|V) N? X* )?; where X = ( MATRA | ACCENT MARK | TONE MARK | OTHER MARK )
- private int isLiveConsonant (int[] ca, int s, int e) {
+ private int isLiveConsonant(int[] ca, int s, int e) {
if (s < 0) {
return -1;
} else {
// C
if ((s + i) < e) {
c = ca [ s + i ];
- if (isC (c)) {
+ if (isC(c)) {
i++;
nc++;
- } else if (isV (c)) {
+ } else if (isV(c)) {
i++;
nv++;
} else {
// N?
if ((s + i) < e) {
c = ca [ s + i ];
- if (isN (c)) {
+ if (isN(c)) {
i++;
}
}
// X*
while ((s + i) < e) {
c = ca [ s + i ];
- if (isX (c)) {
+ if (isX(c)) {
i++;
nx++;
} else {
if (nx == 0) {
if ((s + i) < e) {
c = ca [ s + i ];
- if (isH (c)) {
+ if (isH(c)) {
if (nc > 0) {
nc--;
} else if (nv > 0) {
}
}
static boolean isType(int c, int t) {
- return typeOf (c) == t;
+ return typeOf(c) == t;
}
static boolean hasFlag(int c, int f) {
if ((c >= ccaStart) && (c < ccaEnd)) {
return isType(c,C_M) && hasFlag(c,C_PRE);
}
static boolean isX(int c) {
- switch (typeOf (c)) {
+ switch (typeOf(c)) {
case C_M: // matra (combining vowel)
case C_A: // accent mark
case C_T: // tone mark
/** logging instance */
private static final Log log = LogFactory.getLog(GujaratiScriptProcessor.class); // CSOK: ConstantNameCheck
- GujaratiScriptProcessor (String script) {
- super (script);
+ GujaratiScriptProcessor(String script) {
+ super(script);
}
@Override
@Override
// find rightmost pre-base matra
- protected int findPreBaseMatra (GlyphSequence gs) {
+ protected int findPreBaseMatra(GlyphSequence gs) {
int ng = gs.getGlyphCount();
int lk = -1;
for (int i = ng; i > 0; i--) {
int k = i - 1;
- if (containsPreBaseMatra (gs, k)) {
+ if (containsPreBaseMatra(gs, k)) {
lk = k;
break;
}
@Override
// find leftmost pre-base matra target, starting from source
- protected int findPreBaseMatraTarget (GlyphSequence gs, int source) {
+ protected int findPreBaseMatraTarget(GlyphSequence gs, int source) {
int ng = gs.getGlyphCount();
int lk = -1;
for (int i = (source < ng) ? source : ng; i > 0; i--) {
int k = i - 1;
- if (containsConsonant (gs, k)) {
- if (containsHalfConsonant (gs, k)) {
+ if (containsConsonant(gs, k)) {
+ if (containsHalfConsonant(gs, k)) {
lk = k;
} else if (lk == -1) {
lk = k;
return lk;
}
- private static boolean containsPreBaseMatra (GlyphSequence gs, int k) {
- GlyphSequence.CharAssociation a = gs.getAssociation (k);
- int[] ca = gs.getCharacterArray (false);
+ private static boolean containsPreBaseMatra(GlyphSequence gs, int k) {
+ GlyphSequence.CharAssociation a = gs.getAssociation(k);
+ int[] ca = gs.getCharacterArray(false);
for (int i = a.getStart(), e = a.getEnd(); i < e; i++) {
- if (isPreM (ca [ i ])) {
+ if (isPreM(ca [ i ])) {
return true;
}
}
return false;
}
- private static boolean containsConsonant (GlyphSequence gs, int k) {
- GlyphSequence.CharAssociation a = gs.getAssociation (k);
- int[] ca = gs.getCharacterArray (false);
+ private static boolean containsConsonant(GlyphSequence gs, int k) {
+ GlyphSequence.CharAssociation a = gs.getAssociation(k);
+ int[] ca = gs.getCharacterArray(false);
for (int i = a.getStart(), e = a.getEnd(); i < e; i++) {
- if (isC (ca [ i ])) {
+ if (isC(ca [ i ])) {
return true;
}
}
return false;
}
- private static boolean containsHalfConsonant (GlyphSequence gs, int k) {
- Boolean half = (Boolean) gs.getAssociation (k) . getPredication ("half");
+ private static boolean containsHalfConsonant(GlyphSequence gs, int k) {
+ Boolean half = (Boolean) gs.getAssociation(k) . getPredication("half");
return (half != null) ? half.booleanValue() : false;
}
@Override
- protected int findReph (GlyphSequence gs) {
+ protected int findReph(GlyphSequence gs) {
int ng = gs.getGlyphCount();
int li = -1;
for (int i = 0; i < ng; i++) {
- if (containsReph (gs, i)) {
+ if (containsReph(gs, i)) {
li = i;
break;
}
}
@Override
- protected int findRephTarget (GlyphSequence gs, int source) {
+ protected int findRephTarget(GlyphSequence gs, int source) {
int ng = gs.getGlyphCount();
int c1 = -1;
int c2 = -1;
// first candidate target is after first non-half consonant
for (int i = 0; i < ng; i++) {
- if ((i != source) && containsConsonant (gs, i)) {
- if (! containsHalfConsonant (gs, i)) {
+ if ((i != source) && containsConsonant(gs, i)) {
+ if (! containsHalfConsonant(gs, i)) {
c1 = i + 1;
break;
}
}
// second candidate target is after last non-prebase matra after first candidate or before first syllable or vedic mark
for (int i = (c1 >= 0) ? c1 : 0; i < ng; i++) {
- if (containsMatra (gs, i) && ! containsPreBaseMatra (gs, i)) {
+ if (containsMatra(gs, i) && ! containsPreBaseMatra(gs, i)) {
c2 = i + 1;
- } else if (containsOtherMark (gs, i)) {
+ } else if (containsOtherMark(gs, i)) {
c2 = i;
break;
}
}
}
- private static boolean containsReph (GlyphSequence gs, int k) {
- Boolean rphf = (Boolean) gs.getAssociation (k) . getPredication ("rphf");
+ private static boolean containsReph(GlyphSequence gs, int k) {
+ Boolean rphf = (Boolean) gs.getAssociation(k) . getPredication("rphf");
return (rphf != null) ? rphf.booleanValue() : false;
}
- private static boolean containsMatra (GlyphSequence gs, int k) {
- GlyphSequence.CharAssociation a = gs.getAssociation (k);
- int[] ca = gs.getCharacterArray (false);
+ private static boolean containsMatra(GlyphSequence gs, int k) {
+ GlyphSequence.CharAssociation a = gs.getAssociation(k);
+ int[] ca = gs.getCharacterArray(false);
for (int i = a.getStart(), e = a.getEnd(); i < e; i++) {
- if (isM (ca [ i ])) {
+ if (isM(ca [ i ])) {
return true;
}
}
return false;
}
- private static boolean containsOtherMark (GlyphSequence gs, int k) {
- GlyphSequence.CharAssociation a = gs.getAssociation (k);
- int[] ca = gs.getCharacterArray (false);
+ private static boolean containsOtherMark(GlyphSequence gs, int k) {
+ GlyphSequence.CharAssociation a = gs.getAssociation(k);
+ int[] ca = gs.getCharacterArray(false);
for (int i = a.getStart(), e = a.getEnd(); i < e; i++) {
- switch (typeOf (ca [ i ])) {
+ switch (typeOf(ca [ i ])) {
case C_T: // tone (e.g., udatta, anudatta)
case C_A: // accent (e.g., acute, grave)
case C_O: // other (e.g., candrabindu, anusvara, visarga, etc)
}
private static class GujaratiSyllabizer extends DefaultSyllabizer {
- GujaratiSyllabizer (String script, String language) {
- super (script, language);
+ GujaratiSyllabizer(String script, String language) {
+ super(script, language);
}
@Override
// | C ...
- protected int findStartOfSyllable (int[] ca, int s, int e) {
+ protected int findStartOfSyllable(int[] ca, int s, int e) {
if ((s < 0) || (s >= e)) {
return -1;
} else {
while (s < e) {
int c = ca [ s ];
- if (isC (c)) {
+ if (isC(c)) {
break;
} else {
s++;
}
@Override
// D* L? | ...
- protected int findEndOfSyllable (int[] ca, int s, int e) {
+ protected int findEndOfSyllable(int[] ca, int s, int e) {
if ((s < 0) || (s >= e)) {
return -1;
} else {
int nl = 0;
int i;
// consume dead consonants
- while ((i = isDeadConsonant (ca, s, e)) > s) {
+ while ((i = isDeadConsonant(ca, s, e)) > s) {
s = i;
nd++;
}
// consume zero or one live consonant
- if ((i = isLiveConsonant (ca, s, e)) > s) {
+ if ((i = isLiveConsonant(ca, s, e)) > s) {
s = i;
nl++;
}
}
}
// D := ( C N? H )?
- private int isDeadConsonant (int[] ca, int s, int e) {
+ private int isDeadConsonant(int[] ca, int s, int e) {
if (s < 0) {
return -1;
} else {
// C
if ((s + i) < e) {
c = ca [ s + i ];
- if (isC (c)) {
+ if (isC(c)) {
i++;
nc++;
} else {
// N?
if ((s + i) < e) {
c = ca [ s + 1 ];
- if (isN (c)) {
+ if (isN(c)) {
i++;
}
}
// H
if ((s + i) < e) {
c = ca [ s + i ];
- if (isH (c)) {
+ if (isH(c)) {
i++;
nh++;
} else {
}
}
// L := ( (C|V) N? X* )?; where X = ( MATRA | ACCENT MARK | TONE MARK | OTHER MARK )
- private int isLiveConsonant (int[] ca, int s, int e) {
+ private int isLiveConsonant(int[] ca, int s, int e) {
if (s < 0) {
return -1;
} else {
// C
if ((s + i) < e) {
c = ca [ s + i ];
- if (isC (c)) {
+ if (isC(c)) {
i++;
nc++;
- } else if (isV (c)) {
+ } else if (isV(c)) {
i++;
nv++;
} else {
// N?
if ((s + i) < e) {
c = ca [ s + i ];
- if (isN (c)) {
+ if (isN(c)) {
i++;
}
}
// X*
while ((s + i) < e) {
c = ca [ s + i ];
- if (isX (c)) {
+ if (isX(c)) {
i++;
nx++;
} else {
if (nx == 0) {
if ((s + i) < e) {
c = ca [ s + i ];
- if (isH (c)) {
+ if (isH(c)) {
if (nc > 0) {
nc--;
} else if (nv > 0) {
}
}
static boolean isType(int c, int t) {
- return typeOf (c) == t;
+ return typeOf(c) == t;
}
static boolean hasFlag(int c, int f) {
if ((c >= ccaStart) && (c < ccaEnd)) {
return isType(c,C_M) && hasFlag(c,C_PRE);
}
static boolean isX(int c) {
- switch (typeOf (c)) {
+ switch (typeOf(c)) {
case C_M: // matra (combining vowel)
case C_A: // accent mark
case C_T: // tone mark
/** logging instance */
private static final Log log = LogFactory.getLog(GurmukhiScriptProcessor.class); // CSOK: ConstantNameCheck
- GurmukhiScriptProcessor (String script) {
- super (script);
+ GurmukhiScriptProcessor(String script) {
+ super(script);
}
@Override
@Override
// find rightmost pre-base matra
- protected int findPreBaseMatra (GlyphSequence gs) {
+ protected int findPreBaseMatra(GlyphSequence gs) {
int ng = gs.getGlyphCount();
int lk = -1;
for (int i = ng; i > 0; i--) {
int k = i - 1;
- if (containsPreBaseMatra (gs, k)) {
+ if (containsPreBaseMatra(gs, k)) {
lk = k;
break;
}
@Override
// find leftmost pre-base matra target, starting from source
- protected int findPreBaseMatraTarget (GlyphSequence gs, int source) {
+ protected int findPreBaseMatraTarget(GlyphSequence gs, int source) {
int ng = gs.getGlyphCount();
int lk = -1;
for (int i = (source < ng) ? source : ng; i > 0; i--) {
int k = i - 1;
- if (containsConsonant (gs, k)) {
- if (containsHalfConsonant (gs, k)) {
+ if (containsConsonant(gs, k)) {
+ if (containsHalfConsonant(gs, k)) {
lk = k;
} else if (lk == -1) {
lk = k;
return lk;
}
- private static boolean containsPreBaseMatra (GlyphSequence gs, int k) {
- GlyphSequence.CharAssociation a = gs.getAssociation (k);
- int[] ca = gs.getCharacterArray (false);
+ private static boolean containsPreBaseMatra(GlyphSequence gs, int k) {
+ GlyphSequence.CharAssociation a = gs.getAssociation(k);
+ int[] ca = gs.getCharacterArray(false);
for (int i = a.getStart(), e = a.getEnd(); i < e; i++) {
- if (isPreM (ca [ i ])) {
+ if (isPreM(ca [ i ])) {
return true;
}
}
return false;
}
- private static boolean containsConsonant (GlyphSequence gs, int k) {
- GlyphSequence.CharAssociation a = gs.getAssociation (k);
- int[] ca = gs.getCharacterArray (false);
+ private static boolean containsConsonant(GlyphSequence gs, int k) {
+ GlyphSequence.CharAssociation a = gs.getAssociation(k);
+ int[] ca = gs.getCharacterArray(false);
for (int i = a.getStart(), e = a.getEnd(); i < e; i++) {
- if (isC (ca [ i ])) {
+ if (isC(ca [ i ])) {
return true;
}
}
return false;
}
- private static boolean containsHalfConsonant (GlyphSequence gs, int k) {
- Boolean half = (Boolean) gs.getAssociation (k) . getPredication ("half");
+ private static boolean containsHalfConsonant(GlyphSequence gs, int k) {
+ Boolean half = (Boolean) gs.getAssociation(k) . getPredication("half");
return (half != null) ? half.booleanValue() : false;
}
@Override
- protected int findReph (GlyphSequence gs) {
+ protected int findReph(GlyphSequence gs) {
int ng = gs.getGlyphCount();
int li = -1;
for (int i = 0; i < ng; i++) {
- if (containsReph (gs, i)) {
+ if (containsReph(gs, i)) {
li = i;
break;
}
}
@Override
- protected int findRephTarget (GlyphSequence gs, int source) {
+ protected int findRephTarget(GlyphSequence gs, int source) {
int ng = gs.getGlyphCount();
int c1 = -1;
int c2 = -1;
// first candidate target is after first non-half consonant
for (int i = 0; i < ng; i++) {
- if ((i != source) && containsConsonant (gs, i)) {
- if (! containsHalfConsonant (gs, i)) {
+ if ((i != source) && containsConsonant(gs, i)) {
+ if (! containsHalfConsonant(gs, i)) {
c1 = i + 1;
break;
}
}
// second candidate target is after last non-prebase matra after first candidate or before first syllable or vedic mark
for (int i = (c1 >= 0) ? c1 : 0; i < ng; i++) {
- if (containsMatra (gs, i) && ! containsPreBaseMatra (gs, i)) {
+ if (containsMatra(gs, i) && ! containsPreBaseMatra(gs, i)) {
c2 = i + 1;
- } else if (containsOtherMark (gs, i)) {
+ } else if (containsOtherMark(gs, i)) {
c2 = i;
break;
}
}
}
- private static boolean containsReph (GlyphSequence gs, int k) {
- Boolean rphf = (Boolean) gs.getAssociation (k) . getPredication ("rphf");
+ private static boolean containsReph(GlyphSequence gs, int k) {
+ Boolean rphf = (Boolean) gs.getAssociation(k) . getPredication("rphf");
return (rphf != null) ? rphf.booleanValue() : false;
}
- private static boolean containsMatra (GlyphSequence gs, int k) {
- GlyphSequence.CharAssociation a = gs.getAssociation (k);
- int[] ca = gs.getCharacterArray (false);
+ private static boolean containsMatra(GlyphSequence gs, int k) {
+ GlyphSequence.CharAssociation a = gs.getAssociation(k);
+ int[] ca = gs.getCharacterArray(false);
for (int i = a.getStart(), e = a.getEnd(); i < e; i++) {
- if (isM (ca [ i ])) {
+ if (isM(ca [ i ])) {
return true;
}
}
return false;
}
- private static boolean containsOtherMark (GlyphSequence gs, int k) {
- GlyphSequence.CharAssociation a = gs.getAssociation (k);
- int[] ca = gs.getCharacterArray (false);
+ private static boolean containsOtherMark(GlyphSequence gs, int k) {
+ GlyphSequence.CharAssociation a = gs.getAssociation(k);
+ int[] ca = gs.getCharacterArray(false);
for (int i = a.getStart(), e = a.getEnd(); i < e; i++) {
- switch (typeOf (ca [ i ])) {
+ switch (typeOf(ca [ i ])) {
case C_T: // tone (e.g., udatta, anudatta)
case C_A: // accent (e.g., acute, grave)
case C_O: // other (e.g., candrabindu, anusvara, visarga, etc)
}
private static class GurmukhiSyllabizer extends DefaultSyllabizer {
- GurmukhiSyllabizer (String script, String language) {
- super (script, language);
+ GurmukhiSyllabizer(String script, String language) {
+ super(script, language);
}
@Override
// | C ...
- protected int findStartOfSyllable (int[] ca, int s, int e) {
+ protected int findStartOfSyllable(int[] ca, int s, int e) {
if ((s < 0) || (s >= e)) {
return -1;
} else {
while (s < e) {
int c = ca [ s ];
- if (isC (c)) {
+ if (isC(c)) {
break;
} else {
s++;
}
@Override
// D* L? | ...
- protected int findEndOfSyllable (int[] ca, int s, int e) {
+ protected int findEndOfSyllable(int[] ca, int s, int e) {
if ((s < 0) || (s >= e)) {
return -1;
} else {
int nl = 0;
int i;
// consume dead consonants
- while ((i = isDeadConsonant (ca, s, e)) > s) {
+ while ((i = isDeadConsonant(ca, s, e)) > s) {
s = i;
nd++;
}
// consume zero or one live consonant
- if ((i = isLiveConsonant (ca, s, e)) > s) {
+ if ((i = isLiveConsonant(ca, s, e)) > s) {
s = i;
nl++;
}
}
}
// D := ( C N? H )?
- private int isDeadConsonant (int[] ca, int s, int e) {
+ private int isDeadConsonant(int[] ca, int s, int e) {
if (s < 0) {
return -1;
} else {
// C
if ((s + i) < e) {
c = ca [ s + i ];
- if (isC (c)) {
+ if (isC(c)) {
i++;
nc++;
} else {
// N?
if ((s + i) < e) {
c = ca [ s + 1 ];
- if (isN (c)) {
+ if (isN(c)) {
i++;
}
}
// H
if ((s + i) < e) {
c = ca [ s + i ];
- if (isH (c)) {
+ if (isH(c)) {
i++;
nh++;
} else {
}
}
// L := ( (C|V) N? X* )?; where X = ( MATRA | ACCENT MARK | TONE MARK | OTHER MARK )
- private int isLiveConsonant (int[] ca, int s, int e) {
+ private int isLiveConsonant(int[] ca, int s, int e) {
if (s < 0) {
return -1;
} else {
// C
if ((s + i) < e) {
c = ca [ s + i ];
- if (isC (c)) {
+ if (isC(c)) {
i++;
nc++;
- } else if (isV (c)) {
+ } else if (isV(c)) {
i++;
nv++;
} else {
// N?
if ((s + i) < e) {
c = ca [ s + i ];
- if (isN (c)) {
+ if (isN(c)) {
i++;
}
}
// X*
while ((s + i) < e) {
c = ca [ s + i ];
- if (isX (c)) {
+ if (isX(c)) {
i++;
nx++;
} else {
if (nx == 0) {
if ((s + i) < e) {
c = ca [ s + i ];
- if (isH (c)) {
+ if (isH(c)) {
if (nc > 0) {
nc--;
} else if (nv > 0) {
}
}
static boolean isType(int c, int t) {
- return typeOf (c) == t;
+ return typeOf(c) == t;
}
static boolean hasFlag(int c, int f) {
if ((c >= ccaStart) && (c < ccaEnd)) {
return isType(c,C_M) && hasFlag(c,C_PRE);
}
static boolean isX(int c) {
- switch (typeOf (c)) {
+ switch (typeOf(c)) {
case C_M: // matra (combining vowel)
case C_A: // accent mark
case C_T: // tone mark
}
@Override
- public GlyphSequence reorderCombiningMarks (GlyphDefinitionTable gdef, GlyphSequence gs, int[][] gpa, String script, String language) {
- return super.reorderCombiningMarks (gdef, gs, gpa, script, language);
+ public GlyphSequence reorderCombiningMarks(GlyphDefinitionTable gdef, GlyphSequence gs, int[][] gpa, String script, String language) {
+ return super.reorderCombiningMarks(gdef, gs, gpa, script, language);
}
}
private static class SubstitutionScriptContextTester implements ScriptContextTester {
private static Map/*<String,GlyphContextTester>*/ testerMap = new HashMap/*<String,GlyphContextTester>*/();
- public GlyphContextTester getTester (String feature) {
- return (GlyphContextTester) testerMap.get (feature);
+ public GlyphContextTester getTester(String feature) {
+ return (GlyphContextTester) testerMap.get(feature);
}
}
private static class PositioningScriptContextTester implements ScriptContextTester {
private static Map/*<String,GlyphContextTester>*/ testerMap = new HashMap/*<String,GlyphContextTester>*/();
- public GlyphContextTester getTester (String feature) {
- return (GlyphContextTester) testerMap.get (feature);
+ public GlyphContextTester getTester(String feature) {
+ return (GlyphContextTester) testerMap.get(feature);
}
}
* @param script tag
* @return script processor instance
*/
- public static ScriptProcessor makeProcessor (String script) {
- switch (CharScript.scriptCodeFromTag (script)) {
+ public static ScriptProcessor makeProcessor(String script) {
+ switch (CharScript.scriptCodeFromTag(script)) {
case CharScript.SCRIPT_DEVANAGARI:
case CharScript.SCRIPT_DEVANAGARI_2:
- return new DevanagariScriptProcessor (script);
+ return new DevanagariScriptProcessor(script);
case CharScript.SCRIPT_GUJARATI:
case CharScript.SCRIPT_GUJARATI_2:
- return new GujaratiScriptProcessor (script);
+ return new GujaratiScriptProcessor(script);
case CharScript.SCRIPT_GURMUKHI:
case CharScript.SCRIPT_GURMUKHI_2:
- return new GurmukhiScriptProcessor (script);
+ return new GurmukhiScriptProcessor(script);
// [TBD] implement other script processors
default:
- return new IndicScriptProcessor (script);
+ return new IndicScriptProcessor(script);
}
}
private final ScriptContextTester subContextTester;
private final ScriptContextTester posContextTester;
- IndicScriptProcessor (String script) {
- super (script);
+ IndicScriptProcessor(String script) {
+ super(script);
this.subContextTester = new SubstitutionScriptContextTester();
this.posContextTester = new PositioningScriptContextTester();
}
/** {@inheritDoc} */
@Override
- public GlyphSequence substitute (GlyphSequence gs, String script, String language, GlyphTable.UseSpec[] usa, ScriptContextTester sct) {
+ public GlyphSequence substitute(GlyphSequence gs, String script, String language, GlyphTable.UseSpec[] usa, ScriptContextTester sct) {
assert usa != null;
// 1. syllabize
- GlyphSequence[] sa = syllabize (gs, script, language);
+ GlyphSequence[] sa = syllabize(gs, script, language);
// 2. process each syllable
for (int i = 0, n = sa.length; i < n; i++) {
GlyphSequence s = sa [ i ];
// apply basic shaping subs
for (int j = 0, m = usa.length; j < m; j++) {
GlyphTable.UseSpec us = usa [ j ];
- if (isBasicShapingUse (us)) {
- s.setPredications (true);
- s = us.substitute (s, script, language, sct);
+ if (isBasicShapingUse(us)) {
+ s.setPredications(true);
+ s = us.substitute(s, script, language, sct);
}
}
// reorder pre-base matra
- s = reorderPreBaseMatra (s);
+ s = reorderPreBaseMatra(s);
// reorder reph
- s = reorderReph (s);
+ s = reorderReph(s);
// apply presentation subs
for (int j = 0, m = usa.length; j < m; j++) {
GlyphTable.UseSpec us = usa [ j ];
- if (isPresentationUse (us)) {
- s.setPredications (true);
- s = us.substitute (s, script, language, sct);
+ if (isPresentationUse(us)) {
+ s.setPredications(true);
+ s = us.substitute(s, script, language, sct);
}
}
// record result
sa [ i ] = s;
}
// 3. return reassembled substituted syllables
- return unsyllabize (gs, sa);
+ return unsyllabize(gs, sa);
}
/**
return null;
}
- private GlyphSequence[] syllabize (GlyphSequence gs, String script, String language) {
- return Syllabizer.getSyllabizer (script, language, getSyllabizerClass()) . syllabize (gs);
+ private GlyphSequence[] syllabize(GlyphSequence gs, String script, String language) {
+ return Syllabizer.getSyllabizer(script, language, getSyllabizerClass()) . syllabize(gs);
}
- private GlyphSequence unsyllabize (GlyphSequence gs, GlyphSequence[] sa) {
- return GlyphSequence.join (gs, sa);
+ private GlyphSequence unsyllabize(GlyphSequence gs, GlyphSequence[] sa) {
+ return GlyphSequence.join(gs, sa);
}
private static Set<String> basicShapingFeatures;
static {
basicShapingFeatures = new HashSet<String>();
for (String s : basicShapingFeatureStrings) {
- basicShapingFeatures.add (s);
+ basicShapingFeatures.add(s);
}
}
- private boolean isBasicShapingUse (GlyphTable.UseSpec us) {
+ private boolean isBasicShapingUse(GlyphTable.UseSpec us) {
assert us != null;
if (basicShapingFeatures != null) {
- return basicShapingFeatures.contains (us.getFeature());
+ return basicShapingFeatures.contains(us.getFeature());
} else {
return false;
}
static {
presentationFeatures = new HashSet<String>();
for (String s : presentationFeatureStrings) {
- presentationFeatures.add (s);
+ presentationFeatures.add(s);
}
}
- private boolean isPresentationUse (GlyphTable.UseSpec us) {
+ private boolean isPresentationUse(GlyphTable.UseSpec us) {
assert us != null;
if (presentationFeatures != null) {
- return presentationFeatures.contains (us.getFeature());
+ return presentationFeatures.contains(us.getFeature());
} else {
return false;
}
}
- private GlyphSequence reorderPreBaseMatra (GlyphSequence gs) {
+ private GlyphSequence reorderPreBaseMatra(GlyphSequence gs) {
int source;
- if ((source = findPreBaseMatra (gs)) >= 0) {
+ if ((source = findPreBaseMatra(gs)) >= 0) {
int target;
- if ((target = findPreBaseMatraTarget (gs, source)) >= 0) {
+ if ((target = findPreBaseMatraTarget(gs, source)) >= 0) {
if (target != source) {
- gs = reorder (gs, source, target);
+ gs = reorder(gs, source, target);
}
}
}
* @param gs input sequence
* @return index of pre-base matra or -1 if not found
*/
- protected int findPreBaseMatra (GlyphSequence gs) {
+ protected int findPreBaseMatra(GlyphSequence gs) {
return -1;
}
* @param source index of pre-base matra
* @return index of pre-base matra target or -1
*/
- protected int findPreBaseMatraTarget (GlyphSequence gs, int source) {
+ protected int findPreBaseMatraTarget(GlyphSequence gs, int source) {
return -1;
}
- private GlyphSequence reorderReph (GlyphSequence gs) {
+ private GlyphSequence reorderReph(GlyphSequence gs) {
int source;
- if ((source = findReph (gs)) >= 0) {
+ if ((source = findReph(gs)) >= 0) {
int target;
- if ((target = findRephTarget (gs, source)) >= 0) {
+ if ((target = findRephTarget(gs, source)) >= 0) {
if (target != source) {
- gs = reorder (gs, source, target);
+ gs = reorder(gs, source, target);
}
}
}
* @param gs input sequence
* @return index of reph or -1 if not found
*/
- protected int findReph (GlyphSequence gs) {
+ protected int findReph(GlyphSequence gs) {
return -1;
}
* @param source index of reph
* @return index of reph target or -1
*/
- protected int findRephTarget (GlyphSequence gs, int source) {
+ protected int findRephTarget(GlyphSequence gs, int source) {
return -1;
}
- private GlyphSequence reorder (GlyphSequence gs, int source, int target) {
- return GlyphSequence.reorder (gs, source, 1, target);
+ private GlyphSequence reorder(GlyphSequence gs, int source, int target) {
+ return GlyphSequence.reorder(gs, source, 1, target);
}
/** {@inheritDoc} */
@Override
- public boolean position (GlyphSequence gs, String script, String language, int fontSize, GlyphTable.UseSpec[] usa, int[] widths, int[][] adjustments, ScriptContextTester sct) {
- boolean adjusted = super.position (gs, script, language, fontSize, usa, widths, adjustments, sct);
+ public boolean position(GlyphSequence gs, String script, String language, int fontSize, GlyphTable.UseSpec[] usa, int[] widths, int[][] adjustments, ScriptContextTester sct) {
+ boolean adjusted = super.position(gs, script, language, fontSize, usa, widths, adjustments, sct);
return adjusted;
}
protected abstract static class Syllabizer implements Comparable {
private String script;
private String language;
- Syllabizer (String script, String language) {
+ Syllabizer(String script, String language) {
this.script = script;
this.language = language;
}
* @param gs input glyph sequence
* @return segmented syllabic glyph sequences
*/
- abstract GlyphSequence[] syllabize (GlyphSequence gs);
+ abstract GlyphSequence[] syllabize(GlyphSequence gs);
/** {@inheritDoc} */
public int hashCode() {
int hc = 0;
return hc;
}
/** {@inheritDoc} */
- public boolean equals (Object o) {
+ public boolean equals(Object o) {
if (o instanceof Syllabizer) {
Syllabizer s = (Syllabizer) o;
- if (! s.script.equals (script)) {
+ if (! s.script.equals(script)) {
return false;
- } else if (! s.language.equals (language)) {
+ } else if (! s.language.equals(language)) {
return false;
} else {
return true;
}
}
/** {@inheritDoc} */
- public int compareTo (Object o) {
+ public int compareTo(Object o) {
int d;
if (o instanceof Syllabizer) {
Syllabizer s = (Syllabizer) o;
- if ((d = script.compareTo (s.script)) == 0) {
- d = language.compareTo (s.language);
+ if ((d = script.compareTo(s.script)) == 0) {
+ d = language.compareTo(s.language);
}
} else {
d = -1;
return d;
}
private static Map<String,Syllabizer> syllabizers = new HashMap<String,Syllabizer>();
- static Syllabizer getSyllabizer (String script, String language, Class<? extends Syllabizer> syllabizerClass) {
- String sid = makeSyllabizerId (script, language);
- Syllabizer s = syllabizers.get (sid);
+ static Syllabizer getSyllabizer(String script, String language, Class<? extends Syllabizer> syllabizerClass) {
+ String sid = makeSyllabizerId(script, language);
+ Syllabizer s = syllabizers.get(sid);
if (s == null) {
- if ((s = makeSyllabizer (script, language, syllabizerClass)) == null) {
- s = new DefaultSyllabizer (script, language);
+ if ((s = makeSyllabizer(script, language, syllabizerClass)) == null) {
+ s = new DefaultSyllabizer(script, language);
}
- syllabizers.put (sid, s);
+ syllabizers.put(sid, s);
}
return s;
}
- static String makeSyllabizerId (String script, String language) {
+ static String makeSyllabizerId(String script, String language) {
return script + ":" + language;
}
- static Syllabizer makeSyllabizer (String script, String language, Class<? extends Syllabizer> syllabizerClass) {
+ static Syllabizer makeSyllabizer(String script, String language, Class<? extends Syllabizer> syllabizerClass) {
Syllabizer s;
try {
- Constructor<? extends Syllabizer> cf = syllabizerClass.getDeclaredConstructor (new Class[] { String.class, String.class });
- s = (Syllabizer) cf.newInstance (script, language);
+ Constructor<? extends Syllabizer> cf = syllabizerClass.getDeclaredConstructor(new Class[] { String.class, String.class });
+ s = (Syllabizer) cf.newInstance(script, language);
} catch (NoSuchMethodException e) {
s = null;
} catch (InstantiationException e) {
/** Default syllabizer. */
protected static class DefaultSyllabizer extends Syllabizer {
- DefaultSyllabizer (String script, String language) {
- super (script, language);
+ DefaultSyllabizer(String script, String language) {
+ super(script, language);
}
/** {@inheritDoc} */
@Override
- GlyphSequence[] syllabize (GlyphSequence gs) {
- int[] ca = gs.getCharacterArray (false);
+ GlyphSequence[] syllabize(GlyphSequence gs) {
+ int[] ca = gs.getCharacterArray(false);
int nc = gs.getCharacterCount();
if (nc == 0) {
return new GlyphSequence[] { gs };
} else {
- return segmentize (gs, segmentize (ca, nc));
+ return segmentize(gs, segmentize(ca, nc));
}
}
/**
* @param nc number of characters in sequence
* @return array of syllable segments
*/
- protected Segment[] segmentize (int[] ca, int nc) {
- Vector<Segment> sv = new Vector<Segment> (nc);
+ protected Segment[] segmentize(int[] ca, int nc) {
+ Vector<Segment> sv = new Vector<Segment>(nc);
for (int s = 0, e = nc; s < e; ) {
int i;
- if ((i = findStartOfSyllable (ca, s, e)) > s) {
+ if ((i = findStartOfSyllable(ca, s, e)) > s) {
// from s to i is non-syllable segment
- sv.add (new Segment (s, i, Segment.OTHER));
+ sv.add(new Segment(s, i, Segment.OTHER));
s = i; // move s to start of syllable
} else if (i > s) {
// from s to e is non-syllable segment
- sv.add (new Segment (s, e, Segment.OTHER));
+ sv.add(new Segment(s, e, Segment.OTHER));
s = e; // move s to end of input sequence
}
- if ((i = findEndOfSyllable (ca, s, e)) > s) {
+ if ((i = findEndOfSyllable(ca, s, e)) > s) {
// from s to i is syllable segment
- sv.add (new Segment (s, i, Segment.SYLLABLE));
+ sv.add(new Segment(s, i, Segment.SYLLABLE));
s = i; // move s to end of syllable
} else {
// from s to e is non-syllable segment
- sv.add (new Segment (s, e, Segment.OTHER));
+ sv.add(new Segment(s, e, Segment.OTHER));
s = e; // move s to end of input sequence
}
}
- return sv.toArray (new Segment [ sv.size() ]);
+ return sv.toArray(new Segment [ sv.size() ]);
}
/**
* Construct array of glyph sequences from original glyph sequence and segment array.
* @param sa segment array
* @return array of glyph sequences each belonging to an (ordered) segment in SA
*/
- protected GlyphSequence[] segmentize (GlyphSequence gs, Segment[] sa) {
+ protected GlyphSequence[] segmentize(GlyphSequence gs, Segment[] sa) {
int ng = gs.getGlyphCount();
- int[] ga = gs.getGlyphArray (false);
- GlyphSequence.CharAssociation[] aa = gs.getAssociations (0, -1);
+ int[] ga = gs.getGlyphArray(false);
+ GlyphSequence.CharAssociation[] aa = gs.getAssociations(0, -1);
Vector<GlyphSequence> nsv = new Vector<GlyphSequence>();
for (int i = 0, ns = sa.length; i < ns; i++) {
Segment s = sa [ i ];
- Vector<Integer> ngv = new Vector<Integer> (ng);
- Vector<GlyphSequence.CharAssociation> nav = new Vector<GlyphSequence.CharAssociation> (ng);
+ Vector<Integer> ngv = new Vector<Integer>(ng);
+ Vector<GlyphSequence.CharAssociation> nav = new Vector<GlyphSequence.CharAssociation>(ng);
for (int j = 0; j < ng; j++) {
GlyphSequence.CharAssociation ca = aa [ j ];
- if (ca.contained (s.getOffset(), s.getCount())) {
- ngv.add (ga [ j ]);
- nav.add (ca);
+ if (ca.contained(s.getOffset(), s.getCount())) {
+ ngv.add(ga [ j ]);
+ nav.add(ca);
}
}
if (ngv.size() > 0) {
- nsv.add (new GlyphSequence (gs, null, toIntArray (ngv), null, null, nav.toArray (new GlyphSequence.CharAssociation [ nav.size() ]), null));
+ nsv.add(new GlyphSequence(gs, null, toIntArray(ngv), null, null, nav.toArray(new GlyphSequence.CharAssociation [ nav.size() ]), null));
}
}
if (nsv.size() > 0) {
- return nsv.toArray (new GlyphSequence [ nsv.size() ]);
+ return nsv.toArray(new GlyphSequence [ nsv.size() ]);
} else {
return new GlyphSequence[] { gs };
}
* @param e end index
* @return index of start or E if no start found
*/
- protected int findStartOfSyllable (int[] ca, int s, int e) {
+ protected int findStartOfSyllable(int[] ca, int s, int e) {
return e;
}
/**
* @param e end index
* @return index of start or S if no end found
*/
- protected int findEndOfSyllable (int[] ca, int s, int e) {
+ protected int findEndOfSyllable(int[] ca, int s, int e) {
return s;
}
- private static int[] toIntArray (Vector<Integer> iv) {
+ private static int[] toIntArray(Vector<Integer> iv) {
int ni = iv.size();
int[] ia = new int [ iv.size() ];
for (int i = 0, n = ni; i < n; i++) {
- ia [ i ] = (int) iv.get (i);
+ ia [ i ] = (int) iv.get(i);
}
return ia;
}
private int end;
private int type;
- Segment (int start, int end, int type) {
+ Segment(int start, int end, int type) {
this.start = start;
this.end = end;
this.type = type;
* Instantiate a script processor.
* @param script a script identifier
*/
- protected ScriptProcessor (String script) {
+ protected ScriptProcessor(String script) {
if ((script == null) || (script.length() == 0)) {
- throw new IllegalArgumentException ("script must be non-empty string");
+ throw new IllegalArgumentException("script must be non-empty string");
} else {
this.script = script;
this.assembledLookups = new HashMap/*<AssembledLookupsKey,GlyphTable.UseSpec[]>*/();
* @param lookups a mapping from lookup specifications to glyph subtables to use for substitution processing
* @return the substituted (output) glyph sequence
*/
- public final GlyphSequence substitute (GlyphSubstitutionTable gsub, GlyphSequence gs, String script, String language, Map/*<LookupSpec,List<LookupTable>>>*/ lookups) {
- return substitute (gs, script, language, assembleLookups (gsub, getSubstitutionFeatures(), lookups), getSubstitutionContextTester());
+ public final GlyphSequence substitute(GlyphSubstitutionTable gsub, GlyphSequence gs, String script, String language, Map/*<LookupSpec,List<LookupTable>>>*/ lookups) {
+ return substitute(gs, script, language, assembleLookups(gsub, getSubstitutionFeatures(), lookups), getSubstitutionContextTester());
}
/**
* @param sct a script specific context tester (or null)
* @return the substituted (output) glyph sequence
*/
- public GlyphSequence substitute (GlyphSequence gs, String script, String language, GlyphTable.UseSpec[] usa, ScriptContextTester sct) {
+ public GlyphSequence substitute(GlyphSequence gs, String script, String language, GlyphTable.UseSpec[] usa, ScriptContextTester sct) {
assert usa != null;
for (int i = 0, n = usa.length; i < n; i++) {
GlyphTable.UseSpec us = usa [ i ];
- gs = us.substitute (gs, script, language, sct);
+ gs = us.substitute(gs, script, language, sct);
}
return gs;
}
* @param language a language identifier
* @return the reordered (output) glyph sequence
*/
- public GlyphSequence reorderCombiningMarks (GlyphDefinitionTable gdef, GlyphSequence gs, int[][] gpa, String script, String language) {
+ public GlyphSequence reorderCombiningMarks(GlyphDefinitionTable gdef, GlyphSequence gs, int[][] gpa, String script, String language) {
return gs;
}
* with one 4-tuple for each element of glyph sequence
* @return true if some adjustment is not zero; otherwise, false
*/
- public final boolean position (GlyphPositioningTable gpos, GlyphSequence gs, String script, String language, int fontSize, Map/*<LookupSpec,List<LookupTable>>*/ lookups, int[] widths, int[][] adjustments) {
- return position (gs, script, language, fontSize, assembleLookups (gpos, getPositioningFeatures(), lookups), widths, adjustments, getPositioningContextTester());
+ public final boolean position(GlyphPositioningTable gpos, GlyphSequence gs, String script, String language, int fontSize, Map/*<LookupSpec,List<LookupTable>>*/ lookups, int[] widths, int[][] adjustments) {
+ return position(gs, script, language, fontSize, assembleLookups(gpos, getPositioningFeatures(), lookups), widths, adjustments, getPositioningContextTester());
}
/**
* @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, GlyphTable.UseSpec[] usa, int[] widths, int[][] adjustments, ScriptContextTester sct) {
+ public boolean position(GlyphSequence gs, String script, String language, int fontSize, GlyphTable.UseSpec[] usa, int[] widths, int[][] adjustments, ScriptContextTester sct) {
assert usa != null;
boolean adjusted = false;
for (int i = 0, n = usa.length; i < n; i++) {
GlyphTable.UseSpec us = usa [ i ];
- if (us.position (gs, script, language, fontSize, widths, adjustments, sct)) {
+ if (us.position(gs, script, language, fontSize, widths, adjustments, sct)) {
adjusted = true;
}
}
* @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 final GlyphTable.UseSpec[] assembleLookups (GlyphTable table, String[] features, Map/*<LookupSpec,List<LookupTable>>*/ lookups) {
- AssembledLookupsKey key = new AssembledLookupsKey (table, features, lookups);
+ public final GlyphTable.UseSpec[] assembleLookups(GlyphTable table, String[] features, Map/*<LookupSpec,List<LookupTable>>*/ lookups) {
+ AssembledLookupsKey key = new AssembledLookupsKey(table, features, lookups);
GlyphTable.UseSpec[] usa;
- if ((usa = assembledLookupsGet (key)) != null) {
+ if ((usa = assembledLookupsGet(key)) != null) {
return usa;
} else {
- return assembledLookupsPut (key, table.assembleLookups (features, lookups));
+ return assembledLookupsPut(key, table.assembleLookups(features, lookups));
}
}
- private GlyphTable.UseSpec[] assembledLookupsGet (AssembledLookupsKey key) {
- return (GlyphTable.UseSpec[]) assembledLookups.get (key);
+ private GlyphTable.UseSpec[] assembledLookupsGet(AssembledLookupsKey key) {
+ return (GlyphTable.UseSpec[]) assembledLookups.get(key);
}
- private GlyphTable.UseSpec[] assembledLookupsPut (AssembledLookupsKey key, GlyphTable.UseSpec[] usa) {
- assembledLookups.put (key, usa);
+ private GlyphTable.UseSpec[] assembledLookupsPut(AssembledLookupsKey key, GlyphTable.UseSpec[] usa) {
+ assembledLookups.put(key, usa);
return usa;
}
* @param script a script identifier
* @return a script processor instance or null if none found
*/
- public static synchronized ScriptProcessor getInstance (String script) {
+ public static synchronized ScriptProcessor getInstance(String script) {
ScriptProcessor sp = null;
assert processors != null;
- if ((sp = processors.get (script)) == null) {
- processors.put (script, sp = createProcessor (script));
+ if ((sp = processors.get(script)) == null) {
+ processors.put(script, sp = createProcessor(script));
}
return sp;
}
// [TBD] - rework to provide more configurable binding between script name and script processor constructor
- private static ScriptProcessor createProcessor (String script) {
+ private static ScriptProcessor createProcessor(String script) {
ScriptProcessor sp = null;
- int sc = CharScript.scriptCodeFromTag (script);
+ int sc = CharScript.scriptCodeFromTag(script);
if (sc == CharScript.SCRIPT_ARABIC) {
- sp = new ArabicScriptProcessor (script);
- } else if (CharScript.isIndicScript (sc)) {
- sp = IndicScriptProcessor.makeProcessor (script);
+ sp = new ArabicScriptProcessor(script);
+ } else if (CharScript.isIndicScript(sc)) {
+ sp = IndicScriptProcessor.makeProcessor(script);
} else {
- sp = new DefaultScriptProcessor (script);
+ sp = new DefaultScriptProcessor(script);
}
return sp;
}
private final String[] features;
private final Map/*<LookupSpec,List<LookupTable>>*/ lookups;
- AssembledLookupsKey (GlyphTable table, String[] features, Map/*<LookupSpec,List<LookupTable>>*/ lookups) {
+ AssembledLookupsKey(GlyphTable table, String[] features, Map/*<LookupSpec,List<LookupTable>>*/ lookups) {
this.table = table;
this.features = features;
this.lookups = lookups;
public int hashCode() {
int hc = 0;
hc = 7 * hc + (hc ^ table.hashCode());
- hc = 11 * hc + (hc ^ Arrays.hashCode (features));
+ hc = 11 * hc + (hc ^ Arrays.hashCode(features));
hc = 17 * hc + (hc ^ lookups.hashCode());
return hc;
}
/** {@inheritDoc} */
- public boolean equals (Object o) {
+ public boolean equals(Object o) {
if (o instanceof AssembledLookupsKey) {
AssembledLookupsKey k = (AssembledLookupsKey) o;
- if (! table.equals (k.table)) {
+ if (! table.equals(k.table)) {
return false;
- } else if (! Arrays.equals (features, k.features)) {
+ } else if (! Arrays.equals(features, k.features)) {
return false;
- } else if (! lookups.equals (k.lookups)) {
+ } else if (! lookups.equals(k.lookups)) {
return false;
} else {
return true;
* @param s a string whose characters are to be mirrored
* @return the resulting string
*/
- public static String mirror (String s) {
- StringBuffer sb = new StringBuffer (s);
+ public static String mirror(String s) {
+ StringBuffer sb = new StringBuffer(s);
for (int i = 0, n = sb.length(); i < n; i++) {
- sb.setCharAt (i, (char) mirror (sb.charAt (i)));
+ sb.setCharAt(i, (char) mirror(sb.charAt(i)));
}
return sb.toString();
}
0xFF62
};
- private static int mirror (int c) {
- int i = Arrays.binarySearch (mirroredCharacters, c);
+ private static int mirror(int c) {
+ int i = Arrays.binarySearch(mirroredCharacters, c);
if (i < 0) {
return c;
} else {
* @param c a character represented as a unicode scalar value
* @return true if character is punctuation
*/
- public static boolean isPunctuation (int c) {
+ public static boolean isPunctuation(int c) {
if ((c >= 0x0021) && (c <= 0x002F)) { // basic latin punctuation
return true;
} else if ((c >= 0x003A) && (c <= 0x0040)) { // basic latin punctuation
* @param c a character represented as a unicode scalar value
* @return true if character is a digit
*/
- public static boolean isDigit (int c) {
+ public static boolean isDigit(int c) {
if ((c >= 0x0030) && (c <= 0x0039)) { // basic latin digits
return true;
} else { // [TBD] - not complete
* @param c a character represented as a unicode scalar value
* @return true if character belongs to hebrew script
*/
- public static boolean isHebrew (int c) {
+ public static boolean isHebrew(int c) {
if ((c >= 0x0590) && (c <= 0x05FF)) { // hebrew block
return true;
} else if ((c >= 0xFB00) && (c <= 0xFB4F)) { // hebrew presentation forms block
* @param c a character represented as a unicode scalar value
* @return true if character belongs to mongolian script
*/
- public static boolean isMongolian (int c) {
+ public static boolean isMongolian(int c) {
if ((c >= 0x1800) && (c <= 0x18AF)) { // mongolian block
return true;
} else {
* @param c a character represented as a unicode scalar value
* @return true if character belongs to arabic script
*/
- public static boolean isArabic (int c) {
+ public static boolean isArabic(int c) {
if ((c >= 0x0600) && (c <= 0x06FF)) { // arabic block
return true;
} else if ((c >= 0x0750) && (c <= 0x077F)) { // arabic supplement block
* @param c a character represented as a unicode scalar value
* @return true if character belongs to greek script
*/
- public static boolean isGreek (int c) {
+ public static boolean isGreek(int c) {
if ((c >= 0x0370) && (c <= 0x03FF)) { // greek (and coptic) block
return true;
} else if ((c >= 0x1F00) && (c <= 0x1FFF)) { // greek extended block
* @param c a character represented as a unicode scalar value
* @return true if character belongs to latin script
*/
- public static boolean isLatin (int c) {
+ public static boolean isLatin(int c) {
if ((c >= 0x0041) && (c <= 0x005A)) { // basic latin upper case
return true;
} else if ((c >= 0x0061) && (c <= 0x007A)) { // basic latin lower case
* @param c a character represented as a unicode scalar value
* @return true if character belongs to cyrillic script
*/
- public static boolean isCyrillic (int c) {
+ public static boolean isCyrillic(int c) {
if ((c >= 0x0400) && (c <= 0x04FF)) { // cyrillic block
return true;
} else if ((c >= 0x0500) && (c <= 0x052F)) { // cyrillic supplement block
* @param c a character represented as a unicode scalar value
* @return true if character belongs to georgian script
*/
- public static boolean isGeorgian (int c) {
+ public static boolean isGeorgian(int c) {
if ((c >= 0x10A0) && (c <= 0x10FF)) { // georgian block
return true;
} else if ((c >= 0x2D00) && (c <= 0x2D2F)) { // georgian supplement block
* @param c a character represented as a unicode scalar value
* @return true if character belongs to hangul script
*/
- public static boolean isHangul (int c) {
+ public static boolean isHangul(int c) {
if ((c >= 0x1100) && (c <= 0x11FF)) { // hangul jamo
return true;
} else if ((c >= 0x3130) && (c <= 0x318F)) { // hangul compatibility jamo
* @param c a character represented as a unicode scalar value
* @return true if character belongs to gurmukhi script
*/
- public static boolean isGurmukhi (int c) {
+ public static boolean isGurmukhi(int c) {
if ((c >= 0x0A00) && (c <= 0x0A7F)) { // gurmukhi block
return true;
} else {
* @param c a character represented as a unicode scalar value
* @return true if character belongs to devanagari script
*/
- public static boolean isDevanagari (int c) {
+ public static boolean isDevanagari(int c) {
if ((c >= 0x0900) && (c <= 0x097F)) { // devangari block
return true;
} else if ((c >= 0xA8E0) && (c <= 0xA8FF)) { // devangari extended block
* @param c a character represented as a unicode scalar value
* @return true if character belongs to gujarati script
*/
- public static boolean isGujarati (int c) {
+ public static boolean isGujarati(int c) {
if ((c >= 0x0A80) && (c <= 0x0AFF)) { // gujarati block
return true;
} else {
* @param c a character represented as a unicode scalar value
* @return true if character belongs to bengali script
*/
- public static boolean isBengali (int c) {
+ public static boolean isBengali(int c) {
if ((c >= 0x0980) && (c <= 0x09FF)) { // bengali block
return true;
} else {
* @param c a character represented as a unicode scalar value
* @return true if character belongs to oriya script
*/
- public static boolean isOriya (int c) {
+ public static boolean isOriya(int c) {
if ((c >= 0x0B00) && (c <= 0x0B7F)) { // oriya block
return true;
} else {
* @param c a character represented as a unicode scalar value
* @return true if character belongs to tibetan script
*/
- public static boolean isTibetan (int c) {
+ public static boolean isTibetan(int c) {
if ((c >= 0x0F00) && (c <= 0x0FFF)) { // tibetan block
return true;
} else {
* @param c a character represented as a unicode scalar value
* @return true if character belongs to telugu script
*/
- public static boolean isTelugu (int c) {
+ public static boolean isTelugu(int c) {
if ((c >= 0x0C00) && (c <= 0x0C7F)) { // telugu block
return true;
} else {
* @param c a character represented as a unicode scalar value
* @return true if character belongs to kannada script
*/
- public static boolean isKannada (int c) {
+ public static boolean isKannada(int c) {
if ((c >= 0x0C00) && (c <= 0x0C7F)) { // kannada block
return true;
} else {
* @param c a character represented as a unicode scalar value
* @return true if character belongs to tamil script
*/
- public static boolean isTamil (int c) {
+ public static boolean isTamil(int c) {
if ((c >= 0x0B80) && (c <= 0x0BFF)) { // tamil block
return true;
} else {
* @param c a character represented as a unicode scalar value
* @return true if character belongs to malayalam script
*/
- public static boolean isMalayalam (int c) {
+ public static boolean isMalayalam(int c) {
if ((c >= 0x0D00) && (c <= 0x0D7F)) { // malayalam block
return true;
} else {
* @param c a character represented as a unicode scalar value
* @return true if character belongs to sinhalese script
*/
- public static boolean isSinhalese (int c) {
+ public static boolean isSinhalese(int c) {
if ((c >= 0x0D80) && (c <= 0x0DFF)) { // sinhala block
return true;
} else {
* @param c a character represented as a unicode scalar value
* @return true if character belongs to burmese script
*/
- public static boolean isBurmese (int c) {
+ public static boolean isBurmese(int c) {
if ((c >= 0x1000) && (c <= 0x109F)) { // burmese (myanmar) block
return true;
} else if ((c >= 0xAA60) && (c <= 0xAA7F)) { // burmese (myanmar) extended block
* @param c a character represented as a unicode scalar value
* @return true if character belongs to thai script
*/
- public static boolean isThai (int c) {
+ public static boolean isThai(int c) {
if ((c >= 0x0E00) && (c <= 0x0E7F)) { // thai block
return true;
} else {
* @param c a character represented as a unicode scalar value
* @return true if character belongs to khmer script
*/
- public static boolean isKhmer (int c) {
+ public static boolean isKhmer(int c) {
if ((c >= 0x1780) && (c <= 0x17FF)) { // khmer block
return true;
} else if ((c >= 0x19E0) && (c <= 0x19FF)) { // khmer symbols block
* @param c a character represented as a unicode scalar value
* @return true if character belongs to lao script
*/
- public static boolean isLao (int c) {
+ public static boolean isLao(int c) {
if ((c >= 0x0E80) && (c <= 0x0EFF)) { // lao block
return true;
} else {
* @param c a character represented as a unicode scalar value
* @return true if character belongs to ethiopic (amharic) script
*/
- public static boolean isEthiopic (int c) {
+ public static boolean isEthiopic(int c) {
if ((c >= 0x1200) && (c <= 0x137F)) { // ethiopic block
return true;
} else if ((c >= 0x1380) && (c <= 0x139F)) { // ethoipic supplement block
* @param c a character represented as a unicode scalar value
* @return true if character belongs to han (unified cjk) script
*/
- public static boolean isHan (int c) {
+ public static boolean isHan(int c) {
if ((c >= 0x3400) && (c <= 0x4DBF)) {
return true; // cjk unified ideographs extension a
} else if ((c >= 0x4E00) && (c <= 0x9FFF)) {
* @param c a character represented as a unicode scalar value
* @return true if character belongs to bopomofo script
*/
- public static boolean isBopomofo (int c) {
+ public static boolean isBopomofo(int c) {
if ((c >= 0x3100) && (c <= 0x312F)) {
return true;
} else {
* @param c a character represented as a unicode scalar value
* @return true if character belongs to hiragana script
*/
- public static boolean isHiragana (int c) {
+ public static boolean isHiragana(int c) {
if ((c >= 0x3040) && (c <= 0x309F)) {
return true;
} else {
* @param c a character represented as a unicode scalar value
* @return true if character belongs to katakana script
*/
- public static boolean isKatakana (int c) {
+ public static boolean isKatakana(int c) {
if ((c >= 0x30A0) && (c <= 0x30FF)) {
return true;
} else if ((c >= 0x31F0) && (c <= 0x31FF)) {
* @param c the character to obtain script
* @return an ISO15924 script code
*/
- public static int scriptOf (int c) { // [TBD] - needs optimization!!!
- if (CharUtilities.isAnySpace (c)) {
+ public static int scriptOf(int c) { // [TBD] - needs optimization!!!
+ if (CharUtilities.isAnySpace(c)) {
return SCRIPT_UNDETERMINED;
- } else if (isPunctuation (c)) {
+ } else if (isPunctuation(c)) {
return SCRIPT_UNDETERMINED;
- } else if (isDigit (c)) {
+ } else if (isDigit(c)) {
return SCRIPT_UNDETERMINED;
- } else if (isLatin (c)) {
+ } else if (isLatin(c)) {
return SCRIPT_LATIN;
- } else if (isCyrillic (c)) {
+ } else if (isCyrillic(c)) {
return SCRIPT_CYRILLIC;
- } else if (isGreek (c)) {
+ } else if (isGreek(c)) {
return SCRIPT_GREEK;
- } else if (isHan (c)) {
+ } else if (isHan(c)) {
return SCRIPT_HAN;
- } else if (isBopomofo (c)) {
+ } else if (isBopomofo(c)) {
return SCRIPT_BOPOMOFO;
- } else if (isKatakana (c)) {
+ } else if (isKatakana(c)) {
return SCRIPT_KATAKANA;
- } else if (isHiragana (c)) {
+ } else if (isHiragana(c)) {
return SCRIPT_HIRAGANA;
- } else if (isHangul (c)) {
+ } else if (isHangul(c)) {
return SCRIPT_HANGUL;
- } else if (isArabic (c)) {
+ } else if (isArabic(c)) {
return SCRIPT_ARABIC;
- } else if (isHebrew (c)) {
+ } else if (isHebrew(c)) {
return SCRIPT_HEBREW;
- } else if (isMongolian (c)) {
+ } else if (isMongolian(c)) {
return SCRIPT_MONGOLIAN;
- } else if (isGeorgian (c)) {
+ } else if (isGeorgian(c)) {
return SCRIPT_GEORGIAN;
- } else if (isGurmukhi (c)) {
- return useV2IndicRules (SCRIPT_GURMUKHI);
- } else if (isDevanagari (c)) {
- return useV2IndicRules (SCRIPT_DEVANAGARI);
- } else if (isGujarati (c)) {
- return useV2IndicRules (SCRIPT_GUJARATI);
- } else if (isBengali (c)) {
- return useV2IndicRules (SCRIPT_BENGALI);
- } else if (isOriya (c)) {
- return useV2IndicRules (SCRIPT_ORIYA);
- } else if (isTibetan (c)) {
+ } else if (isGurmukhi(c)) {
+ return useV2IndicRules(SCRIPT_GURMUKHI);
+ } else if (isDevanagari(c)) {
+ return useV2IndicRules(SCRIPT_DEVANAGARI);
+ } else if (isGujarati(c)) {
+ return useV2IndicRules(SCRIPT_GUJARATI);
+ } else if (isBengali(c)) {
+ return useV2IndicRules(SCRIPT_BENGALI);
+ } else if (isOriya(c)) {
+ return useV2IndicRules(SCRIPT_ORIYA);
+ } else if (isTibetan(c)) {
return SCRIPT_TIBETAN;
- } else if (isTelugu (c)) {
- return useV2IndicRules (SCRIPT_TELUGU);
- } else if (isKannada (c)) {
- return useV2IndicRules (SCRIPT_KANNADA);
- } else if (isTamil (c)) {
- return useV2IndicRules (SCRIPT_TAMIL);
- } else if (isMalayalam (c)) {
- return useV2IndicRules (SCRIPT_MALAYALAM);
- } else if (isSinhalese (c)) {
+ } else if (isTelugu(c)) {
+ return useV2IndicRules(SCRIPT_TELUGU);
+ } else if (isKannada(c)) {
+ return useV2IndicRules(SCRIPT_KANNADA);
+ } else if (isTamil(c)) {
+ return useV2IndicRules(SCRIPT_TAMIL);
+ } else if (isMalayalam(c)) {
+ return useV2IndicRules(SCRIPT_MALAYALAM);
+ } else if (isSinhalese(c)) {
return SCRIPT_SINHALESE;
- } else if (isBurmese (c)) {
+ } else if (isBurmese(c)) {
return SCRIPT_BURMESE;
- } else if (isThai (c)) {
+ } else if (isThai(c)) {
return SCRIPT_THAI;
- } else if (isKhmer (c)) {
+ } else if (isKhmer(c)) {
return SCRIPT_KHMER;
- } else if (isLao (c)) {
+ } else if (isLao(c)) {
return SCRIPT_LAO;
- } else if (isEthiopic (c)) {
+ } else if (isEthiopic(c)) {
return SCRIPT_ETHIOPIC;
} else {
return SCRIPT_UNDETERMINED;
* @param sc a V1 indic script code
* @return either SC or the V2 flavor of SC if V2 indic rules apply
*/
- public static int useV2IndicRules (int sc) {
+ public static int useV2IndicRules(int sc) {
if (useV2Indic) {
return (sc < 1000) ? (sc + 1000) : sc;
} else {
* @param cs the character sequence
* @return a (possibly empty) array of script codes
*/
- public static int[] scriptsOf (CharSequence cs) {
+ public static int[] scriptsOf(CharSequence cs) {
Set s = new HashSet();
for (int i = 0, n = cs.length(); i < n; i++) {
- s.add (Integer.valueOf (scriptOf (cs.charAt (i))));
+ s.add(Integer.valueOf(scriptOf(cs.charAt(i))));
}
int[] sa = new int [ s.size() ];
int ns = 0;
for (Iterator it = s.iterator(); it.hasNext();) {
sa [ ns++ ] = ((Integer) it.next()) .intValue();
}
- Arrays.sort (sa);
+ Arrays.sort(sa);
return sa;
}
* @param cs the character sequence
* @return the dominant script or SCRIPT_UNDETERMINED
*/
- public static int dominantScript (CharSequence cs) {
+ public static int dominantScript(CharSequence cs) {
Map m = new HashMap();
for (int i = 0, n = cs.length(); i < n; i++) {
- int c = cs.charAt (i);
- int s = scriptOf (c);
- Integer k = Integer.valueOf (s);
- Integer v = (Integer) m.get (k);
+ int c = cs.charAt(i);
+ int s = scriptOf(c);
+ Integer k = Integer.valueOf(s);
+ Integer v = (Integer) m.get(k);
if (v != null) {
- m.put (k, Integer.valueOf (v.intValue() + 1));
+ m.put(k, Integer.valueOf(v.intValue() + 1));
} else {
- m.put (k, Integer.valueOf (0));
+ m.put(k, Integer.valueOf(0));
}
}
int sMax = -1;
* @param script a script tag
* @return true if script tag is a designated 'Indic' script
*/
- public static boolean isIndicScript (String script) {
- return isIndicScript (scriptCodeFromTag (script));
+ public static boolean isIndicScript(String script) {
+ return isIndicScript(scriptCodeFromTag(script));
}
/**
* @param script a script code
* @return true if script code is a designated 'Indic' script
*/
- public static boolean isIndicScript (int script) {
+ public static boolean isIndicScript(int script) {
switch (script) {
case SCRIPT_BENGALI:
case SCRIPT_BENGALI_2:
* @param code the script code
* @return a script tag
*/
- public static String scriptTagFromCode (int code) {
+ public static String scriptTagFromCode(int code) {
Map<Integer,String> m = getScriptTagsMap();
if (m != null) {
String tag;
- if ((tag = m.get (Integer.valueOf (code))) != null) {
+ if ((tag = m.get(Integer.valueOf(code))) != null) {
return tag;
} else {
return "";
* @param tag the script tag
* @return a script code
*/
- public static int scriptCodeFromTag (String tag) {
+ public static int scriptCodeFromTag(String tag) {
Map<String,Integer> m = getScriptCodeMap();
if (m != null) {
Integer c;
- if ((c = m.get (tag)) != null) {
+ if ((c = m.get(tag)) != null) {
return (int) c;
} else {
return SCRIPT_UNDETERMINED;
private static Map<Integer,String> scriptTagsMap = null;
private static Map<String,Integer> scriptCodeMap = null;
- private static void putScriptTag (Map tm, Map cm, int code, String tag) {
+ private static void putScriptTag(Map tm, Map cm, int code, String tag) {
assert tag != null;
assert tag.length() != 0;
assert code >= 0;
assert code < 2000;
- tm.put (Integer.valueOf (code), tag);
- cm.put (tag, Integer.valueOf (code));
+ tm.put(Integer.valueOf(code), tag);
+ cm.put(tag, Integer.valueOf(code));
}
private static void makeScriptMaps() {
HashMap<Integer,String> tm = new HashMap<Integer,String>();
HashMap<String,Integer> cm = new HashMap<String,Integer>();
- putScriptTag (tm, cm, SCRIPT_HEBREW, "hebr");
- putScriptTag (tm, cm, SCRIPT_MONGOLIAN, "mong");
- putScriptTag (tm, cm, SCRIPT_ARABIC, "arab");
- putScriptTag (tm, cm, SCRIPT_GREEK, "grek");
- putScriptTag (tm, cm, SCRIPT_LATIN, "latn");
- putScriptTag (tm, cm, SCRIPT_CYRILLIC, "cyrl");
- putScriptTag (tm, cm, SCRIPT_GEORGIAN, "geor");
- putScriptTag (tm, cm, SCRIPT_BOPOMOFO, "bopo");
- putScriptTag (tm, cm, SCRIPT_HANGUL, "hang");
- putScriptTag (tm, cm, SCRIPT_GURMUKHI, "guru");
- putScriptTag (tm, cm, SCRIPT_GURMUKHI_2, "gur2");
- putScriptTag (tm, cm, SCRIPT_DEVANAGARI, "deva");
- putScriptTag (tm, cm, SCRIPT_DEVANAGARI_2, "dev2");
- putScriptTag (tm, cm, SCRIPT_GUJARATI, "gujr");
- putScriptTag (tm, cm, SCRIPT_GUJARATI_2, "gjr2");
- putScriptTag (tm, cm, SCRIPT_BENGALI, "beng");
- putScriptTag (tm, cm, SCRIPT_BENGALI_2, "bng2");
- putScriptTag (tm, cm, SCRIPT_ORIYA, "orya");
- putScriptTag (tm, cm, SCRIPT_ORIYA_2, "ory2");
- putScriptTag (tm, cm, SCRIPT_TIBETAN, "tibt");
- putScriptTag (tm, cm, SCRIPT_TELUGU, "telu");
- putScriptTag (tm, cm, SCRIPT_TELUGU_2, "tel2");
- putScriptTag (tm, cm, SCRIPT_KANNADA, "knda");
- putScriptTag (tm, cm, SCRIPT_KANNADA_2, "knd2");
- putScriptTag (tm, cm, SCRIPT_TAMIL, "taml");
- putScriptTag (tm, cm, SCRIPT_TAMIL_2, "tml2");
- putScriptTag (tm, cm, SCRIPT_MALAYALAM, "mlym");
- putScriptTag (tm, cm, SCRIPT_MALAYALAM_2, "mlm2");
- putScriptTag (tm, cm, SCRIPT_SINHALESE, "sinh");
- putScriptTag (tm, cm, SCRIPT_BURMESE, "mymr");
- putScriptTag (tm, cm, SCRIPT_THAI, "thai");
- putScriptTag (tm, cm, SCRIPT_KHMER, "khmr");
- putScriptTag (tm, cm, SCRIPT_LAO, "laoo");
- putScriptTag (tm, cm, SCRIPT_HIRAGANA, "hira");
- putScriptTag (tm, cm, SCRIPT_ETHIOPIC, "ethi");
- putScriptTag (tm, cm, SCRIPT_HAN, "hani");
- putScriptTag (tm, cm, SCRIPT_KATAKANA, "kana");
- putScriptTag (tm, cm, SCRIPT_MATH, "zmth");
- putScriptTag (tm, cm, SCRIPT_SYMBOL, "zsym");
- putScriptTag (tm, cm, SCRIPT_UNDETERMINED, "zyyy");
- putScriptTag (tm, cm, SCRIPT_UNCODED, "zzzz");
+ putScriptTag(tm, cm, SCRIPT_HEBREW, "hebr");
+ putScriptTag(tm, cm, SCRIPT_MONGOLIAN, "mong");
+ putScriptTag(tm, cm, SCRIPT_ARABIC, "arab");
+ putScriptTag(tm, cm, SCRIPT_GREEK, "grek");
+ putScriptTag(tm, cm, SCRIPT_LATIN, "latn");
+ putScriptTag(tm, cm, SCRIPT_CYRILLIC, "cyrl");
+ putScriptTag(tm, cm, SCRIPT_GEORGIAN, "geor");
+ putScriptTag(tm, cm, SCRIPT_BOPOMOFO, "bopo");
+ putScriptTag(tm, cm, SCRIPT_HANGUL, "hang");
+ putScriptTag(tm, cm, SCRIPT_GURMUKHI, "guru");
+ putScriptTag(tm, cm, SCRIPT_GURMUKHI_2, "gur2");
+ putScriptTag(tm, cm, SCRIPT_DEVANAGARI, "deva");
+ putScriptTag(tm, cm, SCRIPT_DEVANAGARI_2, "dev2");
+ putScriptTag(tm, cm, SCRIPT_GUJARATI, "gujr");
+ putScriptTag(tm, cm, SCRIPT_GUJARATI_2, "gjr2");
+ putScriptTag(tm, cm, SCRIPT_BENGALI, "beng");
+ putScriptTag(tm, cm, SCRIPT_BENGALI_2, "bng2");
+ putScriptTag(tm, cm, SCRIPT_ORIYA, "orya");
+ putScriptTag(tm, cm, SCRIPT_ORIYA_2, "ory2");
+ putScriptTag(tm, cm, SCRIPT_TIBETAN, "tibt");
+ putScriptTag(tm, cm, SCRIPT_TELUGU, "telu");
+ putScriptTag(tm, cm, SCRIPT_TELUGU_2, "tel2");
+ putScriptTag(tm, cm, SCRIPT_KANNADA, "knda");
+ putScriptTag(tm, cm, SCRIPT_KANNADA_2, "knd2");
+ putScriptTag(tm, cm, SCRIPT_TAMIL, "taml");
+ putScriptTag(tm, cm, SCRIPT_TAMIL_2, "tml2");
+ putScriptTag(tm, cm, SCRIPT_MALAYALAM, "mlym");
+ putScriptTag(tm, cm, SCRIPT_MALAYALAM_2, "mlm2");
+ putScriptTag(tm, cm, SCRIPT_SINHALESE, "sinh");
+ putScriptTag(tm, cm, SCRIPT_BURMESE, "mymr");
+ putScriptTag(tm, cm, SCRIPT_THAI, "thai");
+ putScriptTag(tm, cm, SCRIPT_KHMER, "khmr");
+ putScriptTag(tm, cm, SCRIPT_LAO, "laoo");
+ putScriptTag(tm, cm, SCRIPT_HIRAGANA, "hira");
+ putScriptTag(tm, cm, SCRIPT_ETHIOPIC, "ethi");
+ putScriptTag(tm, cm, SCRIPT_HAN, "hani");
+ putScriptTag(tm, cm, SCRIPT_KATAKANA, "kana");
+ putScriptTag(tm, cm, SCRIPT_MATH, "zmth");
+ putScriptTag(tm, cm, SCRIPT_SYMBOL, "zsym");
+ putScriptTag(tm, cm, SCRIPT_UNDETERMINED, "zyyy");
+ putScriptTag(tm, cm, SCRIPT_UNCODED, "zzzz");
scriptTagsMap = tm;
scriptCodeMap = cm;
}
* @param flags that apply to lookup in scope
* @return true if test is satisfied
*/
- boolean test (String script, String language, String feature, GlyphSequence gs, int index, int flags);
+ boolean test(String script, String language, String feature, GlyphSequence gs, int index, int flags);
}
* @param associations a (possibly null) array of glyph to character associations
* @param predications true if predications are enabled
*/
- public GlyphSequence (IntBuffer characters, IntBuffer glyphs, List associations, boolean predications) {
+ public GlyphSequence(IntBuffer characters, IntBuffer glyphs, List associations, boolean predications) {
if (characters == null) {
- characters = IntBuffer.allocate (DEFAULT_CHARS_CAPACITY);
+ characters = IntBuffer.allocate(DEFAULT_CHARS_CAPACITY);
}
if (glyphs == null) {
- glyphs = IntBuffer.allocate (characters.capacity());
+ glyphs = IntBuffer.allocate(characters.capacity());
}
if (associations == null) {
- associations = makeIdentityAssociations (characters.limit(), glyphs.limit());
+ associations = makeIdentityAssociations(characters.limit(), glyphs.limit());
}
this.characters = characters;
this.glyphs = glyphs;
* @param glyphs a (possibly null) buffer of glyphs
* @param associations a (possibly null) array of glyph to character associations
*/
- public GlyphSequence (IntBuffer characters, IntBuffer glyphs, List associations) {
+ public GlyphSequence(IntBuffer characters, IntBuffer glyphs, List associations) {
this (characters, glyphs, associations, false);
}
* of glyphs buffer and association list.
* @param gs an existing glyph sequence
*/
- public GlyphSequence (GlyphSequence gs) {
- this (gs.characters.duplicate(), copyBuffer (gs.glyphs), copyAssociations (gs.associations), gs.predications);
+ public GlyphSequence(GlyphSequence gs) {
+ this (gs.characters.duplicate(), copyBuffer(gs.glyphs), copyAssociations(gs.associations), gs.predications);
}
/**
* @param ial input association list
* @param lal lookahead association list
*/
- public GlyphSequence (GlyphSequence gs, int[] bga, int[] iga, int[] lga, CharAssociation[] bal, CharAssociation[] ial, CharAssociation[] lal) {
- this (gs.characters.duplicate(), concatGlyphs (bga, iga, lga), concatAssociations (bal, ial, lal), gs.predications);
+ public GlyphSequence(GlyphSequence gs, int[] bga, int[] iga, int[] lga, CharAssociation[] bal, CharAssociation[] ial, CharAssociation[] lal) {
+ this (gs.characters.duplicate(), concatGlyphs(bga, iga, lga), concatAssociations(bal, ial, lal), gs.predications);
}
/**
* @param copy true if to return a newly instantiated array of characters
* @return array of characters
*/
- public int[] getCharacterArray (boolean copy) {
+ public int[] getCharacterArray(boolean copy) {
if (copy) {
- return toArray (characters);
+ return toArray(characters);
} else {
return characters.array();
}
* @throws IndexOutOfBoundsException if index is less than zero
* or exceeds last valid position
*/
- public int getGlyph (int index) throws IndexOutOfBoundsException {
- return glyphs.get (index);
+ public int getGlyph(int index) throws IndexOutOfBoundsException {
+ return glyphs.get(index);
}
/**
* @throws IndexOutOfBoundsException if index is greater or equal to
* the limit of the underlying glyph buffer
*/
- public void setGlyph (int index, int gi) throws IndexOutOfBoundsException {
+ public void setGlyph(int index, int gi) throws IndexOutOfBoundsException {
if (gi > 65535) {
gi = 65535;
}
- glyphs.put (index, gi);
+ glyphs.put(index, gi);
}
/**
* indicating all avaialble glyphs starting at offset
* @return glyph array
*/
- public int[] getGlyphs (int offset, int count) {
+ public int[] getGlyphs(int offset, int count) {
int ng = getGlyphCount();
if (offset < 0) {
offset = 0;
int[] ga = new int [ count ];
for (int i = offset, n = offset + count, k = 0; i < n; i++) {
if (k < ga.length) {
- ga [ k++ ] = glyphs.get (i);
+ ga [ k++ ] = glyphs.get(i);
}
}
return ga;
* @param copy true if to return a newly instantiated array of glyphs
* @return array of glyphs
*/
- public int[] getGlyphArray (boolean copy) {
+ public int[] getGlyphArray(boolean copy) {
if (copy) {
- return toArray (glyphs);
+ return toArray(glyphs);
} else {
return glyphs.array();
}
* @throws IndexOutOfBoundsException if index is less than zero
* or exceeds last valid position
*/
- public CharAssociation getAssociation (int index) throws IndexOutOfBoundsException {
- return (CharAssociation) associations.get (index);
+ public CharAssociation getAssociation(int index) throws IndexOutOfBoundsException {
+ return (CharAssociation) associations.get(index);
}
/**
* indicating all avaialble associations starting at offset
* @return associations
*/
- public CharAssociation[] getAssociations (int offset, int count) {
+ public CharAssociation[] getAssociations(int offset, int count) {
int ng = getGlyphCount();
if (offset < 0) {
offset = 0;
CharAssociation[] aa = new CharAssociation [ count ];
for (int i = offset, n = offset + count, k = 0; i < n; i++) {
if (k < aa.length) {
- aa [ k++ ] = (CharAssociation) associations.get (i);
+ aa [ k++ ] = (CharAssociation) associations.get(i);
}
}
return aa;
* Enable or disable predications.
* @param enable true if predications are to be enabled; otherwise false to disable
*/
- public void setPredications (boolean enable) {
+ public void setPredications(boolean enable) {
this.predications = enable;
}
* @param key predication key
* @param value predication value
*/
- public void setPredication (int offset, String key, Object value) {
+ public void setPredication(int offset, String key, Object value) {
if (predications) {
- CharAssociation[] aa = getAssociations (offset, 1);
+ CharAssociation[] aa = getAssociations(offset, 1);
CharAssociation ca = aa[0];
- ca.setPredication (key, value);
+ ca.setPredication(key, value);
}
}
* @param key predication key
* @return predication KEY at OFFSET or null if none exists
*/
- public Object getPredication (int offset, String key) {
+ public Object getPredication(int offset, String key) {
if (predications) {
- CharAssociation[] aa = getAssociations (offset, 1);
+ CharAssociation[] aa = getAssociations(offset, 1);
CharAssociation ca = aa[0];
- return ca.getPredication (key);
+ return ca.getPredication(key);
} else {
return null;
}
* @return zero if glyphs are the same, otherwise returns 1 or -1 according to whether this glyph sequence's
* glyphs are lexicographically greater or lesser than the glyphs in the specified string buffer
*/
- public int compareGlyphs (IntBuffer gb) {
+ public int compareGlyphs(IntBuffer gb) {
int ng = getGlyphCount();
for (int i = 0, n = gb.limit(); i < n; i++) {
if (i < ng) {
- int g1 = glyphs.get (i);
- int g2 = gb.get (i);
+ int g1 = glyphs.get(i);
+ int g2 = gb.get(i);
if (g1 > g2) {
return 1;
} else if (g1 < g2) {
public Object clone() {
try {
GlyphSequence gs = (GlyphSequence) super.clone();
- gs.characters = copyBuffer (characters);
- gs.glyphs = copyBuffer (glyphs);
- gs.associations = copyAssociations (associations);
+ gs.characters = copyBuffer(characters);
+ gs.glyphs = copyBuffer(glyphs);
+ gs.associations = copyAssociations(associations);
return gs;
} catch (CloneNotSupportedException e) {
return null;
/** {@inheritDoc} */
public String toString() {
StringBuffer sb = new StringBuffer();
- sb.append ('{');
- sb.append ("chars = [");
- sb.append (characters);
- sb.append ("], glyphs = [");
- sb.append (glyphs);
- sb.append ("], associations = [");
- sb.append (associations);
- sb.append ("]");
- sb.append ('}');
+ sb.append('{');
+ sb.append("chars = [");
+ sb.append(characters);
+ sb.append("], glyphs = [");
+ sb.append(glyphs);
+ sb.append("], associations = [");
+ sb.append(associations);
+ sb.append("]");
+ sb.append('}');
return sb.toString();
}
* @param ga2 second glyph array
* @return true if arrays are botth null or both non-null and have identical elements
*/
- public static boolean sameGlyphs (int[] ga1, int[] ga2) {
+ public static boolean sameGlyphs(int[] ga1, int[] ga2) {
if (ga1 == ga2) {
return true;
} else if ((ga1 == null) || (ga2 == null)) {
* @param lga lookahead glyph array
* @return new integer buffer containing concatenated glyphs
*/
- public static IntBuffer concatGlyphs (int[] bga, int[] iga, int[] lga) {
+ public static IntBuffer concatGlyphs(int[] bga, int[] iga, int[] lga) {
int ng = 0;
if (bga != null) {
ng += bga.length;
if (lga != null) {
ng += lga.length;
}
- IntBuffer gb = IntBuffer.allocate (ng);
+ IntBuffer gb = IntBuffer.allocate(ng);
if (bga != null) {
- gb.put (bga);
+ gb.put(bga);
}
if (iga != null) {
- gb.put (iga);
+ gb.put(iga);
}
if (lga != null) {
- gb.put (lga);
+ gb.put(lga);
}
gb.flip();
return gb;
* @param laa lookahead association array
* @return new list containing concatenated associations
*/
- public static List concatAssociations (CharAssociation[] baa, CharAssociation[] iaa, CharAssociation[] laa) {
+ public static List concatAssociations(CharAssociation[] baa, CharAssociation[] iaa, CharAssociation[] laa) {
int na = 0;
if (baa != null) {
na += baa.length;
na += laa.length;
}
if (na > 0) {
- List gl = new ArrayList (na);
+ List gl = new ArrayList(na);
if (baa != null) {
for (int i = 0; i < baa.length; i++) {
- gl.add (baa[i]);
+ gl.add(baa[i]);
}
}
if (iaa != null) {
for (int i = 0; i < iaa.length; i++) {
- gl.add (iaa[i]);
+ gl.add(iaa[i]);
}
}
if (laa != null) {
for (int i = 0; i < laa.length; i++) {
- gl.add (laa[i]);
+ gl.add(laa[i]);
}
}
return gl;
* @param sa array of glyph sequences, whose glyph arrays and association lists are to be concatenated
* @return new glyph sequence referring to character array of GS and concatenated glyphs and associations of SA
*/
- public static GlyphSequence join (GlyphSequence gs, GlyphSequence[] sa) {
+ public static GlyphSequence join(GlyphSequence gs, GlyphSequence[] sa) {
assert sa != null;
int tg = 0;
int ta = 0;
tg += ng;
ta += na;
}
- IntBuffer uga = IntBuffer.allocate (tg);
- ArrayList ual = new ArrayList (ta);
+ IntBuffer uga = IntBuffer.allocate(tg);
+ ArrayList ual = new ArrayList(ta);
for (int i = 0, n = sa.length; i < n; i++) {
GlyphSequence s = sa [ i ];
- uga.put (s.getGlyphs());
- ual.addAll (s.getAssociations());
+ uga.put(s.getGlyphs());
+ ual.addAll(s.getAssociations());
}
- return new GlyphSequence (gs.getCharacters(), uga, ual, gs.getPredications());
+ return new GlyphSequence(gs.getCharacters(), uga, ual, gs.getPredications());
}
/**
* @param target index to which source sub-sequence is to be moved
* @return reordered sequence (or original if no reordering performed)
*/
- public static GlyphSequence reorder (GlyphSequence gs, int source, int count, int target) {
+ public static GlyphSequence reorder(GlyphSequence gs, int source, int count, int target) {
if (source != target) {
int ng = gs.getGlyphCount();
- int[] ga = gs.getGlyphArray (false);
+ int[] ga = gs.getGlyphArray(false);
int[] nga = new int [ ng ];
- GlyphSequence.CharAssociation[] aa = gs.getAssociations (0, ng);
+ GlyphSequence.CharAssociation[] aa = gs.getAssociations(0, ng);
GlyphSequence.CharAssociation[] naa = new GlyphSequence.CharAssociation [ ng ];
if (source < target) {
int t = 0;
naa[t] = aa[s];
}
}
- return new GlyphSequence (gs, null, nga, null, null, naa, null);
+ return new GlyphSequence(gs, null, nga, null, null, naa, null);
} else {
return gs;
}
}
- private static int[] toArray (IntBuffer ib) {
+ private static int[] toArray(IntBuffer ib) {
if (ib != null) {
int n = ib.limit();
int[] ia = new int[n];
- ib.get (ia, 0, n);
+ ib.get(ia, 0, n);
return ia;
} else {
return new int[0];
}
}
- private static List makeIdentityAssociations (int numChars, int numGlyphs) {
+ private static List makeIdentityAssociations(int numChars, int numGlyphs) {
int nc = numChars;
int ng = numGlyphs;
- List av = new ArrayList (ng);
+ List av = new ArrayList(ng);
for (int i = 0, n = ng; i < n; i++) {
int k = (i > nc) ? nc : i;
- av.add (new CharAssociation (i, (k == nc) ? 0 : 1));
+ av.add(new CharAssociation(i, (k == nc) ? 0 : 1));
}
return av;
}
- private static IntBuffer copyBuffer (IntBuffer ib) {
+ private static IntBuffer copyBuffer(IntBuffer ib) {
if (ib != null) {
int[] ia = new int [ ib.capacity() ];
int p = ib.position();
int l = ib.limit();
- System.arraycopy (ib.array(), 0, ia, 0, ia.length);
- return IntBuffer.wrap (ia, p, l - p);
+ System.arraycopy(ib.array(), 0, ia, 0, ia.length);
+ return IntBuffer.wrap(ia, p, l - p);
} else {
return null;
}
}
- private static List copyAssociations (List ca) {
+ private static List copyAssociations(List ca) {
if (ca != null) {
- return new ArrayList (ca);
+ return new ArrayList(ca);
} else {
return ca;
}
private static volatile Map<String,PredicationMerger> predicationMergers;
interface PredicationMerger {
- Object merge (String key, Object v1, Object v2);
+ Object merge(String key, Object v1, Object v2);
}
/**
* members of array are sub-interval starts, and odd members are sub-interval
* ends (exclusive)
*/
- public CharAssociation (int offset, int count, int[] subIntervals) {
+ public CharAssociation(int offset, int count, int[] subIntervals) {
this.offset = offset;
this.count = count;
this.subIntervals = ((subIntervals != null) && (subIntervals.length > 2)) ? subIntervals : null;
* @param offset into array of UTF-16 code elements (in associated CharSequence)
* @param count of UTF-16 character code elements (in associated CharSequence)
*/
- public CharAssociation (int offset, int count) {
+ public CharAssociation(int offset, int count) {
this (offset, count, null);
}
* members of array are sub-interval starts, and odd members are sub-interval
* ends (exclusive)
*/
- public CharAssociation (int[] subIntervals) {
- this (getSubIntervalsStart (subIntervals), getSubIntervalsLength (subIntervals), subIntervals);
+ public CharAssociation(int[] subIntervals) {
+ this (getSubIntervalsStart(subIntervals), getSubIntervalsLength(subIntervals), subIntervals);
}
/** @return offset (start of association interval) */
* @param count length of interval
* @return true if this association is contained within [offset,offset+count)
*/
- public boolean contained (int offset, int count) {
+ public boolean contained(int offset, int count) {
int s = offset;
int e = offset + count;
if (! isDisjoint()) {
* @param key predication key
* @param value predication value
*/
- public void setPredication (String key, Object value) {
+ public void setPredication(String key, Object value) {
if (predications == null) {
predications = new HashMap<String,Object>();
}
if (predications != null) {
- predications.put (key, value);
+ predications.put(key, value);
}
}
* @param key predication key
* @return predication KEY at OFFSET or null if none exists
*/
- public Object getPredication (String key) {
+ public Object getPredication(String key) {
if (predications != null) {
- return predications.get (key);
+ return predications.get(key);
} else {
return null;
}
* @param key predication key
* @param value predication value
*/
- public void mergePredication (String key, Object value) {
+ public void mergePredication(String key, Object value) {
if (predications == null) {
predications = new HashMap<String,Object>();
}
if (predications != null) {
- if (predications.containsKey (key)) {
- Object v1 = predications.get (key);
+ if (predications.containsKey(key)) {
+ Object v1 = predications.get(key);
Object v2 = value;
- predications.put (key, mergePredicationValues (key, v1, v2));
+ predications.put(key, mergePredicationValues(key, v1, v2));
} else {
- predications.put (key, value);
+ predications.put(key, value);
}
}
}
* @param v2 second (to be merged) predication value
* @return merged value
*/
- public static Object mergePredicationValues (String key, Object v1, Object v2) {
- PredicationMerger pm = getPredicationMerger (key);
+ public static Object mergePredicationValues(String key, Object v1, Object v2) {
+ PredicationMerger pm = getPredicationMerger(key);
if (pm != null) {
- return pm.merge (key, v1, v2);
+ return pm.merge(key, v1, v2);
} else if (v2 != null) {
return v2;
} else {
* Merge predications from another CA.
* @param ca from which to merge
*/
- public void mergePredications (CharAssociation ca) {
+ public void mergePredications(CharAssociation ca) {
if (ca.predications != null) {
for (Map.Entry<String,Object> e : ca.predications.entrySet()) {
- mergePredication (e.getKey(), e.getValue());
+ mergePredication(e.getKey(), e.getValue());
}
}
}
try {
CharAssociation ca = (CharAssociation) super.clone();
if (predications != null) {
- ca.predications = new HashMap<String,Object> (predications);
+ ca.predications = new HashMap<String,Object>(predications);
}
return ca;
} catch (CloneNotSupportedException e) {
* @param key for predication merger
* @param pm predication merger
*/
- public static void setPredicationMerger (String key, PredicationMerger pm) {
+ public static void setPredicationMerger(String key, PredicationMerger pm) {
if (predicationMergers == null) {
predicationMergers = new HashMap<String,PredicationMerger>();
}
if (predicationMergers != null) {
- predicationMergers.put (key, pm);
+ predicationMergers.put(key, pm);
}
}
* @param key for predication merger
* @return predication merger or null if none exists
*/
- public static PredicationMerger getPredicationMerger (String key) {
+ public static PredicationMerger getPredicationMerger(String key) {
if (predicationMergers != null) {
- return predicationMergers.get (key);
+ return predicationMergers.get(key);
} else {
return null;
}
* @param repeat count
* @return array of replicated associations
*/
- public static CharAssociation[] replicate (CharAssociation a, int repeat) {
+ public static CharAssociation[] replicate(CharAssociation a, int repeat) {
CharAssociation[] aa = new CharAssociation [ repeat ];
for (int i = 0, n = aa.length; i < n; i++) {
aa [ i ] = (CharAssociation) a.clone();
* @param aa array of associations to join
* @return (possibly disjoint) association containing joined associations
*/
- public static CharAssociation join (CharAssociation[] aa) {
+ public static CharAssociation join(CharAssociation[] aa) {
CharAssociation ca;
// extract sorted intervals
- int[] ia = extractIntervals (aa);
+ int[] ia = extractIntervals(aa);
if ((ia == null) || (ia.length == 0)) {
- ca = new CharAssociation (0, 0);
+ ca = new CharAssociation(0, 0);
} else if (ia.length == 2) {
int s = ia[0];
int e = ia[1];
- ca = new CharAssociation (s, e - s);
+ ca = new CharAssociation(s, e - s);
} else {
- ca = new CharAssociation (mergeIntervals (ia));
+ ca = new CharAssociation(mergeIntervals(ia));
}
- return mergePredicates (ca, aa);
+ return mergePredicates(ca, aa);
}
- private static CharAssociation mergePredicates (CharAssociation ca, CharAssociation[] aa) {
+ private static CharAssociation mergePredicates(CharAssociation ca, CharAssociation[] aa) {
for (CharAssociation a : aa) {
- ca.mergePredications (a);
+ ca.mergePredications(a);
}
return ca;
}
- private static int getSubIntervalsStart (int[] ia) {
+ private static int getSubIntervalsStart(int[] ia) {
int us = Integer.MAX_VALUE;
int ue = Integer.MIN_VALUE;
if (ia != null) {
return us;
}
- private static int getSubIntervalsLength (int[] ia) {
+ private static int getSubIntervalsLength(int[] ia) {
int us = Integer.MAX_VALUE;
int ue = Integer.MIN_VALUE;
if (ia != null) {
/**
* Extract sorted sub-intervals.
*/
- private static int[] extractIntervals (CharAssociation[] aa) {
+ private static int[] extractIntervals(CharAssociation[] aa) {
int ni = 0;
for (int i = 0, n = aa.length; i < n; i++) {
CharAssociation a = aa [ i ];
k++;
}
}
- return sortIntervals (sa, ea);
+ return sortIntervals(sa, ea);
}
private static final int[] sortIncrements16 // CSOK: ConstantNameCheck
/**
* Sort sub-intervals using modified Shell Sort.
*/
- private static int[] sortIntervals (int[] sa, int[] ea) {
+ private static int[] sortIntervals(int[] sa, int[] ea) {
assert sa != null;
assert ea != null;
assert sa.length == ea.length;
/**
* Merge overlapping and abutting sub-intervals.
*/
- private static int[] mergeIntervals (int[] ia) {
+ private static int[] mergeIntervals(int[] ia) {
int ni = ia.length;
int i;
int n;
* @param flags that apply to lookup in scope
* @return true if test is satisfied
*/
- boolean test (int gi, int flags);
+ boolean test(int gi, int flags);
}
* @param country (may be null or empty, which is treated as null)
* @throws IllegalArgumentException if format is not a valid UTF-16 string (e.g., has unpaired surrogate)
*/
- public NumberConverter (String format, int groupingSeparator, int groupingSize, int letterValue, String features, String language, String country)
+ public NumberConverter(String format, int groupingSeparator, int groupingSize, int letterValue, String features, String language, String country)
throws IllegalArgumentException {
this.groupingSeparator = groupingSeparator;
this.groupingSize = groupingSize;
this.features = features;
this.language = (language != null) ? language.toLowerCase() : null;
this.country = (country != null) ? country.toLowerCase() : null;
- parseFormatTokens (format);
+ parseFormatTokens(format);
}
/**
* @param number number to conver
* @return string representing converted number
*/
- public String convert (long number) {
+ public String convert(long number) {
List<Long> numbers = new ArrayList<Long>();
- numbers.add (number);
- return convert (numbers);
+ numbers.add(number);
+ return convert(numbers);
}
/**
* @param numbers list of numbers to convert
* @return string representing converted list of numbers
*/
- public String convert (List<Long> numbers) {
+ public String convert(List<Long> numbers) {
List<Integer> scalars = new ArrayList<Integer>();
if (prefix != null) {
- appendScalars (scalars, prefix);
+ appendScalars(scalars, prefix);
}
- convertNumbers (scalars, numbers);
+ convertNumbers(scalars, numbers);
if (suffix != null) {
- appendScalars (scalars, suffix);
+ appendScalars(scalars, suffix);
}
- return scalarsToString (scalars);
+ return scalarsToString(scalars);
}
- private void parseFormatTokens (String format) throws IllegalArgumentException {
+ private void parseFormatTokens(String format) throws IllegalArgumentException {
List<Integer[]> tokens = new ArrayList<Integer[]>();
List<Integer[]> separators = new ArrayList<Integer[]>();
if ((format == null) || (format.length() == 0)) {
}
int tokenType = TOKEN_NONE;
List<Integer> token = new ArrayList<Integer>();
- Integer[] ca = UTF32.toUTF32 (format, 0, true);
+ Integer[] ca = UTF32.toUTF32(format, 0, true);
for (int i = 0, n = ca.length; i < n; i++) {
int c = ca[i];
- int tokenTypeNew = isAlphaNumeric (c) ? TOKEN_ALPHANUMERIC : TOKEN_NONALPHANUMERIC;
+ int tokenTypeNew = isAlphaNumeric(c) ? TOKEN_ALPHANUMERIC : TOKEN_NONALPHANUMERIC;
if (tokenTypeNew != tokenType) {
if (token.size() > 0) {
if (tokenType == TOKEN_ALPHANUMERIC) {
- tokens.add (token.toArray (new Integer [ token.size() ]));
+ tokens.add(token.toArray(new Integer [ token.size() ]));
} else {
- separators.add (token.toArray (new Integer [ token.size() ]));
+ separators.add(token.toArray(new Integer [ token.size() ]));
}
token.clear();
}
tokenType = tokenTypeNew;
}
- token.add (c);
+ token.add(c);
}
if (token.size() > 0) {
if (tokenType == TOKEN_ALPHANUMERIC) {
- tokens.add (token.toArray (new Integer [ token.size() ]));
+ tokens.add(token.toArray(new Integer [ token.size() ]));
} else {
- separators.add (token.toArray (new Integer [ token.size() ]));
+ separators.add(token.toArray(new Integer [ token.size() ]));
}
}
if (! separators.isEmpty()) {
- this.prefix = separators.remove (0);
+ this.prefix = separators.remove(0);
}
if (! separators.isEmpty()) {
- this.suffix = separators.remove (separators.size() - 1);
+ this.suffix = separators.remove(separators.size() - 1);
}
- this.separators = separators.toArray (new Integer [ separators.size() ] []);
- this.tokens = tokens.toArray (new Integer [ tokens.size() ] []);
+ this.separators = separators.toArray(new Integer [ separators.size() ] []);
+ this.tokens = tokens.toArray(new Integer [ tokens.size() ] []);
}
- private static boolean isAlphaNumeric (int c) {
- switch (Character.getType (c)) {
+ private static boolean isAlphaNumeric(int c) {
+ switch (Character.getType(c)) {
case Character.DECIMAL_DIGIT_NUMBER: // Nd
case Character.LETTER_NUMBER: // Nl
case Character.OTHER_NUMBER: // No
}
}
- private void convertNumbers (List<Integer> scalars, List<Long> numbers) {
+ private void convertNumbers(List<Integer> scalars, List<Long> numbers) {
Integer[] tknLast = DEFAULT_TOKEN;
int tknIndex = 0;
int tknCount = tokens.length;
} else {
tkn = tknLast;
}
- appendScalars (scalars, convertNumber (number, sep, tkn));
+ appendScalars(scalars, convertNumber(number, sep, tkn));
tknLast = tkn;
numIndex++;
}
}
- private Integer[] convertNumber (long number, Integer[] separator, Integer[] token) {
+ private Integer[] convertNumber(long number, Integer[] separator, Integer[] token) {
List<Integer> sl = new ArrayList<Integer>();
if (separator != null) {
- appendScalars (sl, separator);
+ appendScalars(sl, separator);
}
if (token != null) {
- appendScalars (sl, formatNumber (number, token));
+ appendScalars(sl, formatNumber(number, token));
}
- return sl.toArray (new Integer [ sl.size() ]);
+ return sl.toArray(new Integer [ sl.size() ]);
}
- private Integer[] formatNumber (long number, Integer[] token) {
+ private Integer[] formatNumber(long number, Integer[] token) {
Integer[] fn = null;
assert token.length > 0;
if (number < 0) {
- throw new IllegalArgumentException ("number must be non-negative");
+ throw new IllegalArgumentException("number must be non-negative");
} else if (token.length == 1) {
int s = token[0].intValue();
switch (s) {
case (int) '1':
{
- fn = formatNumberAsDecimal (number, (int) '1', 1);
+ fn = formatNumberAsDecimal(number, (int) '1', 1);
break;
}
case (int) 'W':
case (int) 'w':
{
- fn = formatNumberAsWord (number, (s == (int) 'W') ? Character.UPPERCASE_LETTER : Character.LOWERCASE_LETTER);
+ fn = formatNumberAsWord(number, (s == (int) 'W') ? Character.UPPERCASE_LETTER : Character.LOWERCASE_LETTER);
break;
}
case (int) 'A': // handled as numeric sequence
case (int) 'i': // handled as numeric special
default:
{
- if (isStartOfDecimalSequence (s)) {
- fn = formatNumberAsDecimal (number, s, 1);
- } else if (isStartOfAlphabeticSequence (s)) {
- fn = formatNumberAsSequence (number, s, getSequenceBase (s), null);
- } else if (isStartOfNumericSpecial (s)) {
- fn = formatNumberAsSpecial (number, s);
+ if (isStartOfDecimalSequence(s)) {
+ fn = formatNumberAsDecimal(number, s, 1);
+ } else if (isStartOfAlphabeticSequence(s)) {
+ fn = formatNumberAsSequence(number, s, getSequenceBase(s), null);
+ } else if (isStartOfNumericSpecial(s)) {
+ fn = formatNumberAsSpecial(number, s);
} else {
fn = null;
}
}
}
} else if ((token.length == 2) && (token[0] == (int) 'W') && (token[1] == (int) 'w')) {
- fn = formatNumberAsWord (number, Character.TITLECASE_LETTER);
- } else if (isPaddedOne (token)) {
+ fn = formatNumberAsWord(number, Character.TITLECASE_LETTER);
+ } else if (isPaddedOne(token)) {
int s = token [ token.length - 1 ].intValue();
- fn = formatNumberAsDecimal (number, s, token.length);
+ fn = formatNumberAsDecimal(number, s, token.length);
} else {
- throw new IllegalArgumentException ("invalid format token: \"" + UTF32.fromUTF32 (token) + "\"");
+ throw new IllegalArgumentException("invalid format token: \"" + UTF32.fromUTF32(token) + "\"");
}
if (fn == null) {
- fn = formatNumber (number, DEFAULT_TOKEN);
+ fn = formatNumber(number, DEFAULT_TOKEN);
}
assert fn != null;
return fn;
* @param width non-negative integer denoting field width of number, possible including padding
* @return formatted number as array of unicode scalars
*/
- private Integer[] formatNumberAsDecimal (long number, int one, int width) {
- assert Character.getNumericValue (one) == 1;
- assert Character.getNumericValue (one - 1) == 0;
- assert Character.getNumericValue (one + 8) == 9;
+ private Integer[] formatNumberAsDecimal(long number, int one, int width) {
+ assert Character.getNumericValue(one) == 1;
+ assert Character.getNumericValue(one - 1) == 0;
+ assert Character.getNumericValue(one + 8) == 9;
List<Integer> sl = new ArrayList<Integer>();
int zero = one - 1;
while (number > 0) {
long digit = number % 10;
- sl.add (0, zero + (int) digit);
+ sl.add(0, zero + (int) digit);
number = number / 10;
}
while (width > sl.size()) {
- sl.add (0, zero);
+ sl.add(0, zero);
}
if ((groupingSize != 0) && (groupingSeparator != 0)) {
- sl = performGrouping (sl, groupingSize, groupingSeparator);
+ sl = performGrouping(sl, groupingSize, groupingSeparator);
}
- return sl.toArray (new Integer [ sl.size() ]);
+ return sl.toArray(new Integer [ sl.size() ]);
}
- private static List<Integer> performGrouping (List<Integer> sl, int groupingSize, int groupingSeparator) {
+ private static List<Integer> performGrouping(List<Integer> sl, int groupingSize, int groupingSeparator) {
assert groupingSize > 0;
assert groupingSeparator != 0;
if (sl.size() > groupingSize) {
for (int i = 0, n = sl.size(), g = 0; i < n; i++) {
int k = n - i - 1;
if (g == groupingSize) {
- gl.add (0, groupingSeparator);
+ gl.add(0, groupingSeparator);
g = 1;
} else {
g++;
}
- gl.add (0, sl.get (k));
+ gl.add(0, sl.get(k));
}
return gl;
} else {
* @param map if non-null, then maps sequences indices to unicode scalars
* @return formatted number as array of unicode scalars
*/
- private Integer[] formatNumberAsSequence (long number, int one, int base, int[] map) {
+ private Integer[] formatNumberAsSequence(long number, int one, int base, int[] map) {
assert base > 1;
assert (map == null) || (map.length >= base);
List<Integer> sl = new ArrayList<Integer>();
while (n > 0) {
int d = (int) ((n - 1) % (long) base);
int s = (map != null) ? map [ d ] : (one + d);
- sl.add (0, s);
+ sl.add(0, s);
n = (n - 1) / base;
}
- return sl.toArray (new Integer [ sl.size() ]);
+ return sl.toArray(new Integer [ sl.size() ]);
}
}
* @param one unicode scalar value denoting start of system (numeric value 1)
* @return formatted number as array of unicode scalars
*/
- private Integer[] formatNumberAsSpecial (long number, int one) {
- SpecialNumberFormatter f = getSpecialFormatter (one, letterValue, features, language, country);
+ private Integer[] formatNumberAsSpecial(long number, int one) {
+ SpecialNumberFormatter f = getSpecialFormatter(one, letterValue, features, language, country);
if (f != null) {
- return f.format (number, one, letterValue, features, language, country);
+ return f.format(number, one, letterValue, features, language, country);
} else {
return null;
}
* @param caseType unicode character type for case conversion
* @return formatted number as array of unicode scalars
*/
- private Integer[] formatNumberAsWord (long number, int caseType) {
+ private Integer[] formatNumberAsWord(long number, int caseType) {
SpecialNumberFormatter f = null;
- if (isLanguage ("eng")) {
- f = new EnglishNumberAsWordFormatter (caseType);
- } else if (isLanguage ("spa")) {
- f = new SpanishNumberAsWordFormatter (caseType);
- } else if (isLanguage ("fra")) {
- f = new FrenchNumberAsWordFormatter (caseType);
+ if (isLanguage("eng")) {
+ f = new EnglishNumberAsWordFormatter(caseType);
+ } else if (isLanguage("spa")) {
+ f = new SpanishNumberAsWordFormatter(caseType);
+ } else if (isLanguage("fra")) {
+ f = new FrenchNumberAsWordFormatter(caseType);
} else {
- f = new EnglishNumberAsWordFormatter (caseType);
+ f = new EnglishNumberAsWordFormatter(caseType);
}
- return f.format (number, 0, letterValue, features, language, country);
+ return f.format(number, 0, letterValue, features, language, country);
}
- private boolean isLanguage (String iso3Code) {
+ private boolean isLanguage(String iso3Code) {
if (language == null) {
return false;
- } else if (language.equals (iso3Code)) {
+ } else if (language.equals(iso3Code)) {
return true;
} else {
- return isSameLanguage (iso3Code, language);
+ return isSameLanguage(iso3Code, language);
}
}
{ "spa", "es" },
};
- private static boolean isSameLanguage (String i3c, String lc) {
+ private static boolean isSameLanguage(String i3c, String lc) {
for (String[] el : equivalentLanguages) {
assert el.length >= 2;
- if (el[0].equals (i3c)) {
+ if (el[0].equals(i3c)) {
for (int i = 0, n = el.length; i < n; i++) {
- if (el[i].equals (lc)) {
+ if (el[i].equals(lc)) {
return true;
}
}
return false;
}
- private static boolean hasFeature (String features, String feature) {
+ private static boolean hasFeature(String features, String feature) {
if (features != null) {
assert feature != null;
assert feature.length() != 0;
assert fp.length > 0;
String fn = fp[0];
String fv = (fp.length > 1) ? fp[1] : "";
- if (fn.equals (feature)) {
+ if (fn.equals(feature)) {
return true;
}
}
}
*/
- private static void appendScalars (List<Integer> scalars, Integer[] sa) {
+ private static void appendScalars(List<Integer> scalars, Integer[] sa) {
for (Integer s : sa) {
- scalars.add (s);
+ scalars.add(s);
}
}
- private static String scalarsToString (List<Integer> scalars) {
- Integer[] sa = scalars.toArray (new Integer [ scalars.size() ]);
- return UTF32.fromUTF32 (sa);
+ private static String scalarsToString(List<Integer> scalars) {
+ Integer[] sa = scalars.toArray(new Integer [ scalars.size() ]);
+ return UTF32.fromUTF32(sa);
}
- private static boolean isPaddedOne (Integer[] token) {
- if (getDecimalValue (token [ token.length - 1 ]) != 1) {
+ private static boolean isPaddedOne(Integer[] token) {
+ if (getDecimalValue(token [ token.length - 1 ]) != 1) {
return false;
} else {
for (int i = 0, n = token.length - 1; i < n; i++) {
- if (getDecimalValue (token [ i ]) != 0) {
+ if (getDecimalValue(token [ i ]) != 0) {
return false;
}
}
}
}
- private static int getDecimalValue (Integer scalar) {
+ private static int getDecimalValue(Integer scalar) {
int s = scalar.intValue();
- if (Character.getType (s) == Character.DECIMAL_DIGIT_NUMBER) {
- return Character.getNumericValue (s);
+ if (Character.getType(s) == Character.DECIMAL_DIGIT_NUMBER) {
+ return Character.getNumericValue(s);
} else {
return -1;
}
}
- private static boolean isStartOfDecimalSequence (int s) {
- return (Character.getNumericValue (s) == 1)
- && (Character.getNumericValue (s - 1) == 0)
- && (Character.getNumericValue (s + 8) == 9);
+ private static boolean isStartOfDecimalSequence(int s) {
+ return (Character.getNumericValue(s) == 1)
+ && (Character.getNumericValue(s - 1) == 0)
+ && (Character.getNumericValue(s + 8) == 9);
}
private static int[][] supportedAlphabeticSequences = {
{ 'a', 26 }, // a...z
};
- private static boolean isStartOfAlphabeticSequence (int s) {
+ private static boolean isStartOfAlphabeticSequence(int s) {
for (int[] ss : supportedAlphabeticSequences) {
assert ss.length >= 2;
if (ss[0] == s) {
return false;
}
- private static int getSequenceBase (int s) {
+ private static int getSequenceBase(int s) {
for (int[] ss : supportedAlphabeticSequences) {
assert ss.length >= 2;
if (ss[0] == s) {
{ '\u30A4' }, // kana - katakana (iroha)
};
- private static boolean isStartOfNumericSpecial (int s) {
+ private static boolean isStartOfNumericSpecial(int s) {
for (int[] ss : supportedSpecials) {
assert ss.length >= 1;
if (ss[0] == s) {
return false;
}
- private SpecialNumberFormatter getSpecialFormatter (int one, int letterValue, String features, String language, String country) {
+ private SpecialNumberFormatter getSpecialFormatter(int one, int letterValue, String features, String language, String country) {
if (one == (int) 'I') {
return new RomanNumeralsFormatter();
} else if (one == (int) 'i') {
}
}
- private static Integer[] toUpperCase (Integer[] sa) {
+ private static Integer[] toUpperCase(Integer[] sa) {
assert sa != null;
for (int i = 0, n = sa.length; i < n; i++) {
Integer s = sa [ i ];
- sa [ i ] = Character.toUpperCase (s);
+ sa [ i ] = Character.toUpperCase(s);
}
return sa;
}
- private static Integer[] toLowerCase (Integer[] sa) {
+ private static Integer[] toLowerCase(Integer[] sa) {
assert sa != null;
for (int i = 0, n = sa.length; i < n; i++) {
Integer s = sa [ i ];
- sa [ i ] = Character.toLowerCase (s);
+ sa [ i ] = Character.toLowerCase(s);
}
return sa;
}
}
*/
- private static List<String> convertWordCase (List<String> words, int caseType) {
+ private static List<String> convertWordCase(List<String> words, int caseType) {
List<String> wl = new ArrayList<String>();
for (String w : words) {
- wl.add (convertWordCase (w, caseType));
+ wl.add(convertWordCase(w, caseType));
}
return wl;
}
- private static String convertWordCase (String word, int caseType) {
+ private static String convertWordCase(String word, int caseType) {
if (caseType == Character.UPPERCASE_LETTER) {
return word.toUpperCase();
} else if (caseType == Character.LOWERCASE_LETTER) {
} else if (caseType == Character.TITLECASE_LETTER) {
StringBuffer sb = new StringBuffer();
for (int i = 0, n = word.length(); i < n; i++) {
- String s = word.substring (i, i + 1);
+ String s = word.substring(i, i + 1);
if (i == 0) {
- sb.append (s.toUpperCase());
+ sb.append(s.toUpperCase());
} else {
- sb.append (s.toLowerCase());
+ sb.append(s.toLowerCase());
}
}
return sb.toString();
}
}
- private static String joinWords (List<String> words, String separator) {
+ private static String joinWords(List<String> words, String separator) {
StringBuffer sb = new StringBuffer();
for (String w : words) {
if (sb.length() > 0) {
- sb.append (separator);
+ sb.append(separator);
}
- sb.append (w);
+ sb.append(w);
}
return sb.toString();
}
* @param country denotes applicable country
* @return formatted number as array of unicode scalars
*/
- Integer[] format (long number, int one, int letterValue, String features, String language, String country);
+ Integer[] format(long number, int one, int letterValue, String features, String language, String country);
}
/**
private static String[] englishWordOthersOrd = { "hundredth", "thousandth", "millionth", "billionth" };
private static class EnglishNumberAsWordFormatter implements SpecialNumberFormatter {
private int caseType = Character.UPPERCASE_LETTER;
- EnglishNumberAsWordFormatter (int caseType) {
+ EnglishNumberAsWordFormatter(int caseType) {
this.caseType = caseType;
}
- public Integer[] format (long number, int one, int letterValue, String features, String language, String country) {
+ public Integer[] format(long number, int one, int letterValue, String features, String language, String country) {
List<String> wl = new ArrayList<String>();
if (number >= 1000000000000L) {
return null;
} else {
- boolean ordinal = hasFeature (features, "ordinal");
+ boolean ordinal = hasFeature(features, "ordinal");
if (number == 0) {
- wl.add (englishWordOnes [ 0 ]);
+ wl.add(englishWordOnes [ 0 ]);
} else if (ordinal && (number < 10)) {
- wl.add (englishWordOnesOrd [ (int) number ]);
+ wl.add(englishWordOnesOrd [ (int) number ]);
} else {
int ones = (int) (number % 1000);
int thousands = (int) ((number / 1000) % 1000);
int millions = (int) ((number / 1000000) % 1000);
int billions = (int) ((number / 1000000000) % 1000);
if (billions > 0) {
- wl = formatOnesInThousand (wl, billions);
+ wl = formatOnesInThousand(wl, billions);
if (ordinal && ((number % 1000000000) == 0)) {
- wl.add (englishWordOthersOrd[3]);
+ wl.add(englishWordOthersOrd[3]);
} else {
- wl.add (englishWordOthers[3]);
+ wl.add(englishWordOthers[3]);
}
}
if (millions > 0) {
- wl = formatOnesInThousand (wl, millions);
+ wl = formatOnesInThousand(wl, millions);
if (ordinal && ((number % 1000000) == 0)) {
- wl.add (englishWordOthersOrd[2]);
+ wl.add(englishWordOthersOrd[2]);
} else {
- wl.add (englishWordOthers[2]);
+ wl.add(englishWordOthers[2]);
}
}
if (thousands > 0) {
- wl = formatOnesInThousand (wl, thousands);
+ wl = formatOnesInThousand(wl, thousands);
if (ordinal && ((number % 1000) == 0)) {
- wl.add (englishWordOthersOrd[1]);
+ wl.add(englishWordOthersOrd[1]);
} else {
- wl.add (englishWordOthers[1]);
+ wl.add(englishWordOthers[1]);
}
}
if (ones > 0) {
- wl = formatOnesInThousand (wl, ones, ordinal);
+ wl = formatOnesInThousand(wl, ones, ordinal);
}
}
- wl = convertWordCase (wl, caseType);
- return UTF32.toUTF32 (joinWords (wl, " "), 0, true);
+ wl = convertWordCase(wl, caseType);
+ return UTF32.toUTF32(joinWords(wl, " "), 0, true);
}
}
- private List<String> formatOnesInThousand (List<String> wl, int number) {
- return formatOnesInThousand (wl, number, false);
+ private List<String> formatOnesInThousand(List<String> wl, int number) {
+ return formatOnesInThousand(wl, number, false);
}
- private List<String> formatOnesInThousand (List<String> wl, int number, boolean ordinal) {
+ private List<String> formatOnesInThousand(List<String> wl, int number, boolean ordinal) {
assert number < 1000;
int ones = number % 10;
int tens = (number / 10) % 10;
int hundreds = (number / 100) % 10;
if (hundreds > 0) {
- wl.add (englishWordOnes [ hundreds ]);
+ wl.add(englishWordOnes [ hundreds ]);
if (ordinal && ((number % 100) == 0)) {
- wl.add (englishWordOthersOrd[0]);
+ wl.add(englishWordOthersOrd[0]);
} else {
- wl.add (englishWordOthers[0]);
+ wl.add(englishWordOthers[0]);
}
}
if (tens > 0) {
if (tens == 1) {
if (ordinal) {
- wl.add (englishWordTeensOrd [ ones ]);
+ wl.add(englishWordTeensOrd [ ones ]);
} else {
- wl.add (englishWordTeens [ ones ]);
+ wl.add(englishWordTeens [ ones ]);
}
} else {
if (ordinal && (ones == 0)) {
- wl.add (englishWordTensOrd [ tens ]);
+ wl.add(englishWordTensOrd [ tens ]);
} else {
- wl.add (englishWordTens [ tens ]);
+ wl.add(englishWordTens [ tens ]);
}
if (ones > 0) {
if (ordinal) {
- wl.add (englishWordOnesOrd [ ones ]);
+ wl.add(englishWordOnesOrd [ ones ]);
} else {
- wl.add (englishWordOnes [ ones ]);
+ wl.add(englishWordOnes [ ones ]);
}
}
}
} else if (ones > 0) {
if (ordinal) {
- wl.add (englishWordOnesOrd [ ones ]);
+ wl.add(englishWordOnesOrd [ ones ]);
} else {
- wl.add (englishWordOnes [ ones ]);
+ wl.add(englishWordOnes [ ones ]);
}
}
return wl;
private static String[] frenchWordOnesOrdFemale = { "premi\u00e8re", "deuxi\u00e8me", "troisi\u00e8me", "quatri\u00e8me", "cinqui\u00e8me", "sixi\u00e8me", "septi\u00e8me", "huiti\u00e8me", "neuvi\u00e8me", "dixi\u00e8me" };
private static class FrenchNumberAsWordFormatter implements SpecialNumberFormatter {
private int caseType = Character.UPPERCASE_LETTER;
- FrenchNumberAsWordFormatter (int caseType) {
+ FrenchNumberAsWordFormatter(int caseType) {
this.caseType = caseType;
}
- public Integer[] format (long number, int one, int letterValue, String features, String language, String country) {
+ public Integer[] format(long number, int one, int letterValue, String features, String language, String country) {
List<String> wl = new ArrayList<String>();
if (number >= 1000000000000L) {
return null;
} else {
- boolean ordinal = hasFeature (features, "ordinal");
+ boolean ordinal = hasFeature(features, "ordinal");
if (number == 0) {
- wl.add (frenchWordOnes [ 0 ]);
+ wl.add(frenchWordOnes [ 0 ]);
} else if (ordinal && (number <= 10)) {
- boolean female = hasFeature (features, "female");
+ boolean female = hasFeature(features, "female");
if (female) {
- wl.add (frenchWordOnesOrdFemale [ (int) number ]);
+ wl.add(frenchWordOnesOrdFemale [ (int) number ]);
} else {
- wl.add (frenchWordOnesOrdMale [ (int) number ]);
+ wl.add(frenchWordOnesOrdMale [ (int) number ]);
}
} else {
int ones = (int) (number % 1000);
int millions = (int) ((number / 1000000) % 1000);
int billions = (int) ((number / 1000000000) % 1000);
if (billions > 0) {
- wl = formatOnesInThousand (wl, billions);
+ wl = formatOnesInThousand(wl, billions);
if (billions == 1) {
- wl.add (frenchWordOthers[5]);
+ wl.add(frenchWordOthers[5]);
} else {
- wl.add (frenchWordOthers[6]);
+ wl.add(frenchWordOthers[6]);
}
}
if (millions > 0) {
- wl = formatOnesInThousand (wl, millions);
+ wl = formatOnesInThousand(wl, millions);
if (millions == 1) {
- wl.add (frenchWordOthers[3]);
+ wl.add(frenchWordOthers[3]);
} else {
- wl.add (frenchWordOthers[4]);
+ wl.add(frenchWordOthers[4]);
}
}
if (thousands > 0) {
if (thousands > 1) {
- wl = formatOnesInThousand (wl, thousands);
+ wl = formatOnesInThousand(wl, thousands);
}
- wl.add (frenchWordOthers[2]);
+ wl.add(frenchWordOthers[2]);
}
if (ones > 0) {
- wl = formatOnesInThousand (wl, ones);
+ wl = formatOnesInThousand(wl, ones);
}
}
- wl = convertWordCase (wl, caseType);
- return UTF32.toUTF32 (joinWords (wl, " "), 0, true);
+ wl = convertWordCase(wl, caseType);
+ return UTF32.toUTF32(joinWords(wl, " "), 0, true);
}
}
- private List<String> formatOnesInThousand (List<String> wl, int number) {
+ private List<String> formatOnesInThousand(List<String> wl, int number) {
assert number < 1000;
int ones = number % 10;
int tens = (number / 10) % 10;
int hundreds = (number / 100) % 10;
if (hundreds > 0) {
if (hundreds > 1) {
- wl.add (frenchWordOnes [ hundreds ]);
+ wl.add(frenchWordOnes [ hundreds ]);
}
if ((hundreds > 1) && (tens == 0) && (ones == 0)) {
- wl.add (frenchWordOthers[1]);
+ wl.add(frenchWordOthers[1]);
} else {
- wl.add (frenchWordOthers[0]);
+ wl.add(frenchWordOthers[0]);
}
}
if (tens > 0) {
if (tens == 1) {
- wl.add (frenchWordTeens [ ones ]);
+ wl.add(frenchWordTeens [ ones ]);
} else if (tens < 7) {
if (ones == 1) {
- wl.add (frenchWordTens [ tens ]);
- wl.add ("et");
- wl.add (frenchWordOnes [ ones ]);
+ wl.add(frenchWordTens [ tens ]);
+ wl.add("et");
+ wl.add(frenchWordOnes [ ones ]);
} else {
StringBuffer sb = new StringBuffer();
- sb.append (frenchWordTens [ tens ]);
+ sb.append(frenchWordTens [ tens ]);
if (ones > 0) {
- sb.append ('-');
- sb.append (frenchWordOnes [ ones ]);
+ sb.append('-');
+ sb.append(frenchWordOnes [ ones ]);
}
- wl.add (sb.toString());
+ wl.add(sb.toString());
}
} else if (tens == 7) {
if (ones == 1) {
- wl.add (frenchWordTens [ 6 ]);
- wl.add ("et");
- wl.add (frenchWordTeens [ ones ]);
+ wl.add(frenchWordTens [ 6 ]);
+ wl.add("et");
+ wl.add(frenchWordTeens [ ones ]);
} else {
StringBuffer sb = new StringBuffer();
- sb.append (frenchWordTens [ 6 ]);
- sb.append ('-');
- sb.append (frenchWordTeens [ ones ]);
- wl.add (sb.toString());
+ sb.append(frenchWordTens [ 6 ]);
+ sb.append('-');
+ sb.append(frenchWordTeens [ ones ]);
+ wl.add(sb.toString());
}
} else if (tens == 8) {
StringBuffer sb = new StringBuffer();
- sb.append (frenchWordTens [ tens ]);
+ sb.append(frenchWordTens [ tens ]);
if (ones > 0) {
- sb.append ('-');
- sb.append (frenchWordOnes [ ones ]);
+ sb.append('-');
+ sb.append(frenchWordOnes [ ones ]);
} else {
- sb.append ('s');
+ sb.append('s');
}
- wl.add (sb.toString());
+ wl.add(sb.toString());
} else if (tens == 9) {
StringBuffer sb = new StringBuffer();
- sb.append (frenchWordTens [ 8 ]);
- sb.append ('-');
- sb.append (frenchWordTeens [ ones ]);
- wl.add (sb.toString());
+ sb.append(frenchWordTens [ 8 ]);
+ sb.append('-');
+ sb.append(frenchWordTeens [ ones ]);
+ wl.add(sb.toString());
}
} else if (ones > 0) {
- wl.add (frenchWordOnes [ ones ]);
+ wl.add(frenchWordOnes [ ones ]);
}
return wl;
}
private static String[] spanishWordOnesOrdFemale = { "ninguna", "primera", "segunda", "tercera", "cuarta", "quinta", "sexta", "s\u00e9ptima", "octava", "noventa", "d\u00e9cima" };
private static class SpanishNumberAsWordFormatter implements SpecialNumberFormatter {
private int caseType = Character.UPPERCASE_LETTER;
- SpanishNumberAsWordFormatter (int caseType) {
+ SpanishNumberAsWordFormatter(int caseType) {
this.caseType = caseType;
}
- public Integer[] format (long number, int one, int letterValue, String features, String language, String country) {
+ public Integer[] format(long number, int one, int letterValue, String features, String language, String country) {
List<String> wl = new ArrayList<String>();
if (number >= 1000000000000L) {
return null;
} else {
- boolean ordinal = hasFeature (features, "ordinal");
+ boolean ordinal = hasFeature(features, "ordinal");
if (number == 0) {
- wl.add (spanishWordOnes [ 0 ]);
+ wl.add(spanishWordOnes [ 0 ]);
} else if (ordinal && (number <= 10)) {
- boolean female = hasFeature (features, "female");
+ boolean female = hasFeature(features, "female");
if (female) {
- wl.add (spanishWordOnesOrdFemale [ (int) number ]);
+ wl.add(spanishWordOnesOrdFemale [ (int) number ]);
} else {
- wl.add (spanishWordOnesOrdMale [ (int) number ]);
+ wl.add(spanishWordOnesOrdMale [ (int) number ]);
}
} else {
int ones = (int) (number % 1000);
int billions = (int) ((number / 1000000000) % 1000);
if (billions > 0) {
if (billions > 1) {
- wl = formatOnesInThousand (wl, billions);
+ wl = formatOnesInThousand(wl, billions);
}
- wl.add (spanishWordOthers[2]);
- wl.add (spanishWordOthers[4]);
+ wl.add(spanishWordOthers[2]);
+ wl.add(spanishWordOthers[4]);
}
if (millions > 0) {
if (millions == 1) {
- wl.add (spanishWordOthers[0]);
+ wl.add(spanishWordOthers[0]);
} else {
- wl = formatOnesInThousand (wl, millions);
+ wl = formatOnesInThousand(wl, millions);
}
if (millions > 1) {
- wl.add (spanishWordOthers[4]);
+ wl.add(spanishWordOthers[4]);
} else {
- wl.add (spanishWordOthers[3]);
+ wl.add(spanishWordOthers[3]);
}
}
if (thousands > 0) {
if (thousands > 1) {
- wl = formatOnesInThousand (wl, thousands);
+ wl = formatOnesInThousand(wl, thousands);
}
- wl.add (spanishWordOthers[2]);
+ wl.add(spanishWordOthers[2]);
}
if (ones > 0) {
- wl = formatOnesInThousand (wl, ones);
+ wl = formatOnesInThousand(wl, ones);
}
}
- wl = convertWordCase (wl, caseType);
- return UTF32.toUTF32 (joinWords (wl, " "), 0, true);
+ wl = convertWordCase(wl, caseType);
+ return UTF32.toUTF32(joinWords(wl, " "), 0, true);
}
}
- private List<String> formatOnesInThousand (List<String> wl, int number) {
+ private List<String> formatOnesInThousand(List<String> wl, int number) {
assert number < 1000;
int ones = number % 10;
int tens = (number / 10) % 10;
int hundreds = (number / 100) % 10;
if (hundreds > 0) {
if ((hundreds == 1) && (tens == 0) && (ones == 0)) {
- wl.add (spanishWordOthers[1]);
+ wl.add(spanishWordOthers[1]);
} else {
- wl.add (spanishWordHundreds [ hundreds ]);
+ wl.add(spanishWordHundreds [ hundreds ]);
}
}
if (tens > 0) {
if (tens == 1) {
- wl.add (spanishWordTeens [ ones ]);
+ wl.add(spanishWordTeens [ ones ]);
} else if (tens == 2) {
- wl.add (spanishWordTweens [ ones ]);
+ wl.add(spanishWordTweens [ ones ]);
} else {
- wl.add (spanishWordTens [ tens ]);
+ wl.add(spanishWordTens [ tens ]);
if (ones > 0) {
- wl.add ("y");
- wl.add (spanishWordOnes [ ones ]);
+ wl.add("y");
+ wl.add(spanishWordOnes [ ones ]);
}
}
} else if (ones > 0) {
- wl.add (spanishWordOnes [ ones ]);
+ wl.add(spanishWordOnes [ ones ]);
}
return wl;
}
"\u2160"
};
private static class RomanNumeralsFormatter implements SpecialNumberFormatter {
- public Integer[] format (long number, int one, int letterValue, String features, String language, String country) {
+ public Integer[] format(long number, int one, int letterValue, String features, String language, String country) {
List<Integer> sl = new ArrayList<Integer>();
if (number == 0) {
return null;
} else {
String[] forms;
int maxNumber;
- if (hasFeature (features, "unicode-number-forms")) {
+ if (hasFeature(features, "unicode-number-forms")) {
forms = romanNumberForms;
maxNumber = 199999;
- } else if (hasFeature (features, "large")) {
+ } else if (hasFeature(features, "large")) {
forms = romanLargeForms;
maxNumber = 199999;
} else {
for (int i = 0, n = romanMapping.length; i < n; i++) {
int d = romanMapping [ i ];
if ((number >= d) && (forms [ i ] != null)) {
- appendScalars (sl, UTF32.toUTF32 (forms [ i ], 0, true));
+ appendScalars(sl, UTF32.toUTF32(forms [ i ], 0, true));
number = number - d;
break;
}
}
}
if (one == (int) 'I') {
- return toUpperCase (sl.toArray (new Integer [ sl.size() ]));
+ return toUpperCase(sl.toArray(new Integer [ sl.size() ]));
} else if (one == (int) 'i') {
- return toLowerCase (sl.toArray (new Integer [ sl.size() ]));
+ return toLowerCase(sl.toArray(new Integer [ sl.size() ]));
} else {
return null;
}
* Isopsephry (Greek) Numerals
*/
private static class IsopsephryNumeralsFormatter implements SpecialNumberFormatter {
- public Integer[] format (long number, int one, int letterValue, String features, String language, String country) {
+ public Integer[] format(long number, int one, int letterValue, String features, String language, String country) {
return null;
}
}
0x05E5, // FINAL TSADHI
};
private class GematriaNumeralsFormatter implements SpecialNumberFormatter {
- public Integer[] format (long number, int one, int letterValue, String features, String language, String country) {
+ public Integer[] format(long number, int one, int letterValue, String features, String language, String country) {
if (one == 0x05D0) {
if (letterValue == LETTER_VALUE_ALPHABETIC) {
- return formatNumberAsSequence (number, one, hebrewGematriaAlphabeticMap.length, hebrewGematriaAlphabeticMap);
+ return formatNumberAsSequence(number, one, hebrewGematriaAlphabeticMap.length, hebrewGematriaAlphabeticMap);
} else if (letterValue == LETTER_VALUE_TRADITIONAL) {
if ((number == 0) || (number > 1999)) {
return null;
} else {
- return formatAsGematriaNumber (number, features, language, country);
+ return formatAsGematriaNumber(number, features, language, country);
}
} else {
return null;
return null;
}
}
- private Integer[] formatAsGematriaNumber (long number, String features, String language, String country) {
+ private Integer[] formatAsGematriaNumber(long number, String features, String language, String country) {
List<Integer> sl = new ArrayList<Integer>();
assert hebrewGematriaAlphabeticMap.length == 27;
assert hebrewGematriaAlphabeticMap[0] == 0x05D0; // ALEF
int tens = (int) ((number / 10) % 10);
int ones = (int) ((number / 1) % 10);
if (thousands > 0) {
- sl.add (map [ 0 + (thousands - 1) ]);
- sl.add (0x05F3);
+ sl.add(map [ 0 + (thousands - 1) ]);
+ sl.add(0x05F3);
}
if (hundreds > 0) {
assert hundreds < 10;
if (hundreds < 5) {
- sl.add (map [ 18 + (hundreds - 1) ]);
+ sl.add(map [ 18 + (hundreds - 1) ]);
} else if (hundreds < 9) {
- sl.add (map [ 18 + (4 - 1) ]);
- sl.add (0x05F4);
- sl.add (map [ 18 + (hundreds - 5) ]);
+ sl.add(map [ 18 + (4 - 1) ]);
+ sl.add(0x05F4);
+ sl.add(map [ 18 + (hundreds - 5) ]);
} else if (hundreds == 9) {
- sl.add (map [ 18 + (4 - 1) ]);
- sl.add (map [ 18 + (4 - 1) ]);
- sl.add (0x05F4);
- sl.add (map [ 18 + (hundreds - 9) ]);
+ sl.add(map [ 18 + (4 - 1) ]);
+ sl.add(map [ 18 + (4 - 1) ]);
+ sl.add(0x05F4);
+ sl.add(map [ 18 + (hundreds - 9) ]);
}
}
if (number == 15) {
- sl.add (map [ 9 - 1]);
- sl.add (0x05F4);
- sl.add (map [ 6 - 1]);
+ sl.add(map [ 9 - 1]);
+ sl.add(0x05F4);
+ sl.add(map [ 6 - 1]);
} else if (number == 16) {
- sl.add (map [ 9 - 1 ]);
- sl.add (0x05F4);
- sl.add (map [ 7 - 1 ]);
+ sl.add(map [ 9 - 1 ]);
+ sl.add(0x05F4);
+ sl.add(map [ 7 - 1 ]);
} else {
if (tens > 0) {
assert tens < 10;
- sl.add (map [ 9 + (tens - 1) ]);
+ sl.add(map [ 9 + (tens - 1) ]);
}
if (ones > 0) {
assert ones < 10;
- sl.add (map [ 0 + (ones - 1) ]);
+ sl.add(map [ 0 + (ones - 1) ]);
}
}
- return sl.toArray (new Integer [ sl.size() ]);
+ return sl.toArray(new Integer [ sl.size() ]);
}
}
0x0649, // ALEF MAQSURA
};
private class ArabicNumeralsFormatter implements SpecialNumberFormatter {
- public Integer[] format (long number, int one, int letterValue, String features, String language, String country) {
+ public Integer[] format(long number, int one, int letterValue, String features, String language, String country) {
if (one == 0x0627) {
int[] map;
if (letterValue == LETTER_VALUE_TRADITIONAL) {
} else {
map = arabicAbjadiAlphabeticMap;
}
- return formatNumberAsSequence (number, one, map.length, map);
+ return formatNumberAsSequence(number, one, map.length, map);
} else if (one == 0x0623) {
if ((number == 0) || (number > 1999)) {
return null;
} else {
- return formatAsAbjadiNumber (number, features, language, country);
+ return formatAsAbjadiNumber(number, features, language, country);
}
} else {
return null;
}
}
- private Integer[] formatAsAbjadiNumber (long number, String features, String language, String country) {
+ private Integer[] formatAsAbjadiNumber(long number, String features, String language, String country) {
List<Integer> sl = new ArrayList<Integer>();
assert arabicAbjadiAlphabeticMap.length == 28;
assert arabicAbjadiAlphabeticMap[0] == 0x0623; // ALEF WITH HAMZA ABOVE
int ones = (int) ((number / 1) % 10);
if (thousands > 0) {
assert thousands < 2;
- sl.add (map [ 27 + (thousands - 1) ]);
+ sl.add(map [ 27 + (thousands - 1) ]);
}
if (hundreds > 0) {
assert thousands < 10;
- sl.add (map [ 18 + (hundreds - 1) ]);
+ sl.add(map [ 18 + (hundreds - 1) ]);
}
if (tens > 0) {
assert tens < 10;
- sl.add (map [ 9 + (tens - 1) ]);
+ sl.add(map [ 9 + (tens - 1) ]);
}
if (ones > 0) {
assert ones < 10;
- sl.add (map [ 0 + (ones - 1) ]);
+ sl.add(map [ 0 + (ones - 1) ]);
}
- return sl.toArray (new Integer [ sl.size() ]);
+ return sl.toArray(new Integer [ sl.size() ]);
}
}
0x30F3, // N
};
private class KanaNumeralsFormatter implements SpecialNumberFormatter {
- public Integer[] format (long number, int one, int letterValue, String features, String language, String country) {
+ public Integer[] format(long number, int one, int letterValue, String features, String language, String country) {
if ((one == 0x3042) && (letterValue == LETTER_VALUE_ALPHABETIC)) {
- return formatNumberAsSequence (number, one, hiraganaGojuonAlphabeticMap.length, hiraganaGojuonAlphabeticMap);
+ return formatNumberAsSequence(number, one, hiraganaGojuonAlphabeticMap.length, hiraganaGojuonAlphabeticMap);
} else if ((one == 0x30A2) && (letterValue == LETTER_VALUE_ALPHABETIC)) {
- return formatNumberAsSequence (number, one, katakanaGojuonAlphabeticMap.length, katakanaGojuonAlphabeticMap);
+ return formatNumberAsSequence(number, one, katakanaGojuonAlphabeticMap.length, katakanaGojuonAlphabeticMap);
} else {
return null;
}
0x0E2E,
};
private class ThaiNumeralsFormatter implements SpecialNumberFormatter {
- public Integer[] format (long number, int one, int letterValue, String features, String language, String country) {
+ public Integer[] format(long number, int one, int letterValue, String features, String language, String country) {
if ((one == 0x0E01) && (letterValue == LETTER_VALUE_ALPHABETIC)) {
- return formatNumberAsSequence (number, one, thaiAlphabeticMap.length, thaiAlphabeticMap);
+ return formatNumberAsSequence(number, one, thaiAlphabeticMap.length, thaiAlphabeticMap);
} else {
return null;
}
* @param feature a feature identifier
* @return a glyph context tester or null if none available for the specified feature
*/
- GlyphContextTester getTester (String feature);
+ GlyphContextTester getTester(String feature);
}
* @throws IllegalArgumentException if substitution required and errorOnSubstitution
* is not false
*/
- public static Integer[] toUTF32 (String s, int substitution, boolean errorOnSubstitution)
+ public static Integer[] toUTF32(String s, int substitution, boolean errorOnSubstitution)
throws IllegalArgumentException {
int n;
if ((n = s.length()) == 0) {
int c = (int) s.charAt(i);
if ((c >= 0xD800) && (c < 0xE000)) {
int s1 = c;
- int s2 = ((i + 1) < n) ? (int) s.charAt (i + 1) : 0;
+ int s2 = ((i + 1) < n) ? (int) s.charAt(i + 1) : 0;
if (s1 < 0xDC00) {
if ((s2 >= 0xDC00) && (s2 < 0xE000)) {
c = ((s1 - 0xD800) << 10) + (s2 - 0xDC00) + 65536;
i++;
} else {
if (errorOnSubstitution) {
- throw new IllegalArgumentException
- ("isolated high (leading) surrogate");
+ throw new IllegalArgumentException(
+ "isolated high (leading) surrogate");
} else {
c = substitution;
}
}
} else {
if (errorOnSubstitution) {
- throw new IllegalArgumentException
- ("isolated low (trailing) surrogate");
+ throw new IllegalArgumentException(
+ "isolated low (trailing) surrogate");
} else {
c = substitution;
}
return sa;
} else {
Integer[] na = new Integer [ k ];
- System.arraycopy (sa, 0, na, 0, k);
+ System.arraycopy(sa, 0, na, 0, k);
return na;
}
}
* @throws IllegalArgumentException if an input scalar value is illegal,
* e.g., a surrogate or out of range
*/
- public static String fromUTF32 (Integer[] sa) throws IllegalArgumentException {
+ public static String fromUTF32(Integer[] sa) throws IllegalArgumentException {
StringBuffer sb = new StringBuffer();
for (int s : sa) {
if (s < 65535) {
if ((s < 0xD800) || (s > 0xDFFF)) {
- sb.append ((char) s);
+ sb.append((char) s);
} else {
String ncr = CharUtilities.charToNCRef(s);
- throw new IllegalArgumentException
- ("illegal scalar value 0x" + ncr.substring(2, ncr.length() - 1)
+ throw new IllegalArgumentException(
+ "illegal scalar value 0x" + ncr.substring(2, ncr.length() - 1)
+ "; cannot be UTF-16 surrogate");
}
} else if (s < 1114112) {
int s1 = (((s - 65536) >> 10) & 0x3FF) + 0xD800;
int s2 = (((s - 65536) >> 0) & 0x3FF) + 0xDC00;
- sb.append ((char) s1);
- sb.append ((char) s2);
+ sb.append((char) s1);
+ sb.append((char) s2);
} else {
String ncr = CharUtilities.charToNCRef(s);
- throw new IllegalArgumentException
- ("illegal scalar value 0x" + ncr.substring(2, ncr.length() - 1)
+ throw new IllegalArgumentException(
+ "illegal scalar value 0x" + ncr.substring(2, ncr.length() - 1)
+ "; out of range for UTF-16");
}
}
//utility class
}
- private static ResourceBundle getBundle (String groupID, Locale locale) {
+ private static ResourceBundle getBundle(String groupID, Locale locale) {
ResourceBundle bundle;
String baseName = (groupID != null) ? groupID : EventFormatter.class.getName();
try {
ClassLoader classLoader = EventFormatter.class.getClassLoader();
- bundle = XMLResourceBundle.getXMLBundle (baseName, locale, classLoader);
+ bundle = XMLResourceBundle.getXMLBundle(baseName, locale, classLoader);
} catch (MissingResourceException e) {
if (log.isTraceEnabled()) {
- log.trace ("No XMLResourceBundle for " + baseName + " available.");
+ log.trace("No XMLResourceBundle for " + baseName + " available.");
}
bundle = null;
}
* @param event the event
* @return the formatted message
*/
- public static String format (Event event) {
- return format (event, event.getLocale());
+ public static String format(Event event) {
+ return format(event, event.getLocale());
}
/**
* @return the formatted message
*/
public static String format(Event event, Locale locale) {
- return format (event, getBundle (event.getEventGroupID(), locale));
+ return format(event, getBundle(event.getEventGroupID(), locale));
}
- private static String format (Event event, ResourceBundle bundle) {
+ private static String format(Event event, ResourceBundle bundle) {
assert event != null;
String key = event.getEventKey();
String template;
if (bundle != null) {
- template = bundle.getString (key);
+ template = bundle.getString(key);
} else {
template = "Missing bundle. Can't lookup event key: '" + key + "'.";
}
- return format (event, processIncludes (template, bundle));
+ return format(event, processIncludes(template, bundle));
}
private static String processIncludes(String template, ResourceBundle bundle) {
public void write(StringBuffer sb, Map params) {
String groupID = (String) params.get("groupID");
Locale locale = (Locale) params.get("locale");
- ResourceBundle bundle = getBundle (groupID, locale);
+ ResourceBundle bundle = getBundle(groupID, locale);
if (bundle != null) {
sb.append(bundle.getString(getKey(params)));
}
* with the unabbreviated URI otherwise.
*/
public static String getNodeString(String namespaceURI, String localName) {
- String prefix = getNodePrefix (namespaceURI);
+ String prefix = getNodePrefix(namespaceURI);
if (prefix != null) {
return prefix + ":" + localName;
} else {
protected void invalidChildError(Locator loc, String parentName, String nsURI, String lName,
String ruleViolated)
throws ValidationException {
- String prefix = getNodePrefix (nsURI);
+ String prefix = getNodePrefix(nsURI);
QName qn; // qualified name of offending node
if (prefix != null) {
qn = new QName(nsURI, prefix, lName);
* @return true if indicated boundary (or boundaries) constitute a delimited text range
* boundary.
*/
- public boolean isDelimitedTextRangeBoundary (int boundary) {
+ public boolean isDelimitedTextRangeBoundary(int boundary) {
return true;
}
* @param ranges a stack of delimited text ranges
* @return the (possibly) updated stack of delimited text ranges
*/
- public Stack collectDelimitedTextRanges (Stack ranges) {
+ public Stack collectDelimitedTextRanges(Stack ranges) {
// if boundary before, then push new range
if (isRangeBoundaryBefore()) {
- maybeNewRange (ranges);
+ maybeNewRange(ranges);
}
// get current range, if one exists
DelimitedTextRange currentRange;
currentRange = null;
}
// proceses this node
- ranges = collectDelimitedTextRanges (ranges, currentRange);
+ ranges = collectDelimitedTextRanges(ranges, currentRange);
// if boundary after, then push new range
if (isRangeBoundaryAfter()) {
- maybeNewRange (ranges);
+ maybeNewRange(ranges);
}
return ranges;
}
* @param currentRange the current range or null (if none)
* @return the (possibly) updated stack of delimited text ranges
*/
- protected Stack collectDelimitedTextRanges (Stack ranges, DelimitedTextRange currentRange) {
+ protected Stack collectDelimitedTextRanges(Stack ranges, DelimitedTextRange currentRange) {
for (Iterator it = getChildNodes(); (it != null) && it.hasNext();) {
- ranges = ((FONode) it.next()).collectDelimitedTextRanges (ranges);
+ ranges = ((FONode) it.next()).collectDelimitedTextRanges(ranges);
}
return ranges;
}
* @param ranges stack of delimited text ranges
* @return new range (if constructed and pushed onto stack) or current range (if any) or null
*/
- private DelimitedTextRange maybeNewRange (Stack ranges) {
+ private DelimitedTextRange maybeNewRange(Stack ranges) {
DelimitedTextRange rCur = null; // current range (top of range stack)
DelimitedTextRange rNew = null; // new range to be pushed onto range stack
if (ranges.empty()) {
} else {
rCur = (DelimitedTextRange) ranges.peek();
if (rCur != null) {
- if (!rCur.isEmpty() || !isSelfOrDescendent (rCur.getNode(), this)) {
+ if (!rCur.isEmpty() || !isSelfOrDescendent(rCur.getNode(), this)) {
rNew = new DelimitedTextRange(this);
}
}
}
if (rNew != null) {
- ranges.push (rNew);
+ ranges.push(rNew);
} else {
rNew = rCur;
}
}
private boolean isRangeBoundaryBefore() {
- return isDelimitedTextRangeBoundary (Constants.EN_BEFORE);
+ return isDelimitedTextRangeBoundary(Constants.EN_BEFORE);
}
private boolean isRangeBoundaryAfter() {
- return isDelimitedTextRangeBoundary (Constants.EN_AFTER);
+ return isDelimitedTextRangeBoundary(Constants.EN_AFTER);
}
/**
* Determine if node N2 is the same or a descendent of node N1.
*/
- private static boolean isSelfOrDescendent (FONode n1, FONode n2) {
+ private static boolean isSelfOrDescendent(FONode n1, FONode n2) {
for (FONode n = n2; n != null; n = n.getParent()) {
if (n == n1) {
return true;
addPropertyMaker("fox:block-progression-unit", l);
}
- private Property calcWritingModeDependent (int pv, int wm) {
+ private Property calcWritingModeDependent(int pv, int wm) {
if (pv == EN_LEFT) {
if (wm == Constants.EN_LR_TB) {
pv = EN_START;
pv = EN_END;
}
}
- return makeWritingModeDependentEnum (pv);
+ return makeWritingModeDependentEnum(pv);
}
- private Property makeWritingModeDependentEnum (int pv) {
+ private Property makeWritingModeDependentEnum(int pv) {
if (pv == EN_START) {
- return getEnumProperty (EN_START, "START");
+ return getEnumProperty(EN_START, "START");
} else if (pv == EN_END) {
- return getEnumProperty (EN_END, "END");
+ return getEnumProperty(EN_END, "END");
} else {
return null;
}
if (p != null) {
int pv = p.getEnum();
if ((pv == EN_LEFT) || (pv == EN_RIGHT)) {
- p = calcWritingModeDependent
- (pv, propertyList.get(Constants.PR_WRITING_MODE).getEnum());
+ p = calcWritingModeDependent(
+ pv, propertyList.get(Constants.PR_WRITING_MODE).getEnum());
}
}
return p;
} else if (correspondingValue == EN_CENTER) {
return getEnumProperty(EN_CENTER, "CENTER");
} else if (correspondingValue == EN_LEFT) {
- return calcWritingModeDependent
- (EN_LEFT, propertyList.get(Constants.PR_WRITING_MODE).getEnum());
+ return calcWritingModeDependent(
+ EN_LEFT, propertyList.get(Constants.PR_WRITING_MODE).getEnum());
} else if (correspondingValue == EN_RIGHT) {
- return calcWritingModeDependent
- (EN_RIGHT, propertyList.get(Constants.PR_WRITING_MODE).getEnum());
+ return calcWritingModeDependent(
+ EN_RIGHT, propertyList.get(Constants.PR_WRITING_MODE).getEnum());
} else {
return null;
}
}
@Override
- public boolean isDelimitedTextRangeBoundary (int boundary) {
+ public boolean isDelimitedTextRangeBoundary(int boundary) {
return false;
}
* @param start the starting index of interval
* @param end the ending index of interval
*/
- public void setBidiLevel (int level, int start, int end) {
+ public void setBidiLevel(int level, int start, int end) {
if (start < end) {
if (bidiLevels == null) {
bidiLevels = new int [ length() ];
bidiLevels [ i ] = level;
}
if (parent != null) {
- ((FObj) parent).setBidiLevel (level);
+ ((FObj) parent).setBidiLevel(level);
}
} else {
assert start < end;
* @return a (possibly empty) array of bidi levels or null
* in case no bidi levels have been assigned
*/
- public int[] getBidiLevels (int start, int end) {
+ public int[] getBidiLevels(int start, int end) {
if (this.bidiLevels != null) {
assert start <= end;
int n = end - start;
* @throws IndexOutOfBoundsException if position is not non-negative integer
* or is greater than or equal to length
*/
- public int bidiLevelAt (int position) throws IndexOutOfBoundsException {
+ public int bidiLevelAt(int position) throws IndexOutOfBoundsException {
if ((position < 0) || (position >= length())) {
throw new IndexOutOfBoundsException();
} else if (bidiLevels != null) {
* @param end index in character buffer
* @param mappedChars sequence of character codes denoting substituted characters
*/
- public void addMapping (int start, int end, CharSequence mappedChars) {
+ public void addMapping(int start, int end, CharSequence mappedChars) {
if (mappings == null) {
mappings = new java.util.HashMap();
}
- mappings.put (new MapRange (start, end), mappedChars.toString());
+ mappings.put(new MapRange(start, end), mappedChars.toString());
}
/**
* @return true if a mapping exist such that the mapping's interval is coincident to
* [start,end)
*/
- public boolean hasMapping (int start, int end) {
- return (mappings != null) && (mappings.containsKey (new MapRange (start, end)));
+ public boolean hasMapping(int start, int end) {
+ return (mappings != null) && (mappings.containsKey(new MapRange(start, end)));
}
/**
* @return a string of characters representing the mapping over the interval
* [start,end)
*/
- public String getMapping (int start, int end) {
+ public String getMapping(int start, int end) {
if (mappings != null) {
- return (String) mappings.get (new MapRange (start, end));
+ return (String) mappings.get(new MapRange(start, end));
} else {
return null;
}
* @param end index in character buffer
* @return the length of the mapping (if present) or zero
*/
- public int getMappingLength (int start, int end) {
+ public int getMappingLength(int start, int end) {
if (mappings != null) {
- return ((String) mappings.get (new MapRange (start, end))) .length();
+ return ((String) mappings.get(new MapRange(start, end))) .length();
} else {
return 0;
}
* @return a (possibly empty) array of bidi levels or null
* in case no bidi levels have been assigned
*/
- public int[] getMappingBidiLevels (int start, int end) {
- if (hasMapping (start, end)) {
+ public int[] getMappingBidiLevels(int start, int end) {
+ if (hasMapping(start, end)) {
int nc = end - start;
- int nm = getMappingLength (start, end);
- int[] la = getBidiLevels (start, end);
+ int nm = getMappingLength(start, end);
+ int[] la = getBidiLevels(start, end);
if (la == null) {
return null;
} else if (nm == nc) { // mapping is same length as mapped range
return la;
} else if (nm > nc) { // mapping is longer than mapped range
int[] ma = new int [ nm ];
- System.arraycopy (la, 0, ma, 0, la.length);
+ System.arraycopy(la, 0, ma, 0, la.length);
for (int i = la.length,
n = ma.length, l = (i > 0) ? la [ i - 1 ] : 0; i < n; i++) {
ma [ i ] = l;
return ma;
} else { // mapping is shorter than mapped range
int[] ma = new int [ nm ];
- System.arraycopy (la, 0, ma, 0, ma.length);
+ System.arraycopy(la, 0, ma, 0, ma.length);
return ma;
}
} else {
- return getBidiLevels (start, end);
+ return getBidiLevels(start, end);
}
}
@Override
- protected Stack collectDelimitedTextRanges (Stack ranges, DelimitedTextRange currentRange) {
+ protected Stack collectDelimitedTextRanges(Stack ranges, DelimitedTextRange currentRange) {
if (currentRange != null) {
- currentRange.append (charIterator(), this);
+ currentRange.append(charIterator(), this);
}
return ranges;
}
public int hashCode() {
return (start * 31) + end;
}
- public boolean equals (Object o) {
+ public boolean equals(Object o) {
if (o instanceof MapRange) {
MapRange r = (MapRange) o;
return (r.start == start) && (r.end == end);
FObj foParent = (FObj) parent;
int parentBidiLevel = foParent.getBidiLevel();
if ((parentBidiLevel < 0) || (bidiLevel < parentBidiLevel)) {
- foParent.setBidiLevel (bidiLevel);
+ foParent.setBidiLevel(bidiLevel);
}
}
}
/** {@inheritDoc} */
public Property getOptionalArgDefault(int index, PropertyInfo pi) throws PropertyException {
if (index == 0) {
- return getPropertyName (pi);
+ return getPropertyName(pi);
} else {
- return super.getOptionalArgDefault (index, pi);
+ return super.getOptionalArgDefault(index, pi);
}
}
/** {@inheritDoc} */
public Property getOptionalArgDefault(int index, PropertyInfo pi) throws PropertyException {
if (index == 0) {
- return getPropertyName (pi);
+ return getPropertyName(pi);
} else {
- return super.getOptionalArgDefault (index, pi);
+ return super.getOptionalArgDefault(index, pi);
}
}
/** {@inheritDoc} */
public Property getOptionalArgDefault(int index, PropertyInfo pi) throws PropertyException {
if (index == 0) {
- return getPropertyName (pi);
+ return getPropertyName(pi);
} else {
- return super.getOptionalArgDefault (index, pi);
+ return super.getOptionalArgDefault(index, pi);
}
}
/** {@inheritDoc} */
public Property getOptionalArgDefault(int index, PropertyInfo pi) throws PropertyException {
if (index >= getOptionalArgsCount()) {
- PropertyException e = new PropertyException (new IndexOutOfBoundsException ("illegal optional argument index"));
- e.setPropertyInfo (pi);
+ PropertyException e = new PropertyException(new IndexOutOfBoundsException("illegal optional argument index"));
+ e.setPropertyInfo(pi);
throw e;
} else {
return null;
* @param pi property information instance that applies to property being evaluated
* @return string property whose value is name of property being evaluated
*/
- protected final Property getPropertyName (PropertyInfo pi) {
- return StringProperty.getInstance (pi.getPropertyMaker().getName());
+ protected final Property getPropertyName(PropertyInfo pi) {
+ return StringProperty.getInstance(pi.getPropertyMaker().getName());
}
}
/** {@inheritDoc} */
public Property getOptionalArgDefault(int index, PropertyInfo pi) throws PropertyException {
if (index == 0) {
- return getPropertyName (pi);
+ return getPropertyName(pi);
} else {
- return super.getOptionalArgDefault (index, pi);
+ return super.getOptionalArgDefault(index, pi);
}
}
Property p = parseAdditiveExpr();
int i = args.size();
if ((i < numReq) || ((i - numReq) < numOpt) || hasVar) {
- args.add (p);
+ args.add(p);
} else {
- throw new PropertyException ("Unexpected function argument at index " + i);
+ throw new PropertyException("Unexpected function argument at index " + i);
}
// ignore extra args
if (currentToken != TOK_COMMA) {
} else {
for (int i = 0; i < numOpt; i++) {
if (args.size() < (numReq + i + 1)) {
- args.add (function.getOptionalArgDefault (i, propInfo));
+ args.add(function.getOptionalArgDefault(i, propInfo));
}
}
}
- return (Property[]) args.toArray (new Property [ args.size() ]);
+ return (Property[]) args.toArray(new Property [ args.size() ]);
}
/**
private void scanRestOfName() {
while (++exprIndex < exprLength) {
- if (!isNameChar (expr.charAt (exprIndex))) {
+ if (!isNameChar(expr.charAt(exprIndex))) {
break;
}
}
if (str.length() == 0) {
str = "100%";
}
- float width = UnitProcessor.svgHorizontalLengthToUserSpace
- (str, SVGConstants.SVG_WIDTH_ATTRIBUTE, ctx);
+ float width = UnitProcessor.svgHorizontalLengthToUserSpace(
+ str, SVGConstants.SVG_WIDTH_ATTRIBUTE, ctx);
str = svgRoot.getAttributeNS(null, SVGConstants.SVG_HEIGHT_ATTRIBUTE);
if (str.length() == 0) {
str = "100%";
}
- float height = UnitProcessor.svgVerticalLengthToUserSpace
- (str, SVGConstants.SVG_HEIGHT_ATTRIBUTE, ctx);
+ float height = UnitProcessor.svgVerticalLengthToUserSpace(
+ str, SVGConstants.SVG_HEIGHT_ATTRIBUTE, ctx);
return new Point2D.Float(width, height);
}
public abstract Length getIntrinsicAlignmentAdjust();
@Override
- public boolean isDelimitedTextRangeBoundary (int boundary) {
+ public boolean isDelimitedTextRangeBoundary(int boundary) {
return false;
}
@Override
- protected Stack collectDelimitedTextRanges (Stack ranges, DelimitedTextRange currentRange) {
+ protected Stack collectDelimitedTextRanges(Stack ranges, DelimitedTextRange currentRange) {
if (currentRange != null) {
- currentRange.append (CharUtilities.OBJECT_REPLACEMENT_CHARACTER, this);
+ currentRange.append(CharUtilities.OBJECT_REPLACEMENT_CHARACTER, this);
}
return ranges;
}
}
/** {@inheritDoc} */
- public void processNode
- (String elementName, Locator locator, Attributes attlist, PropertyList pList)
+ public void processNode(
+ String elementName, Locator locator, Attributes attlist, PropertyList pList)
throws FOPException {
super.processNode(elementName, locator, attlist, pList);
if (!inMarker() && (refId == null || "".equals(refId))) {
}
@Override
- public boolean isDelimitedTextRangeBoundary (int boundary) {
+ public boolean isDelimitedTextRangeBoundary(int boundary) {
return false;
}
@Override
- protected Stack collectDelimitedTextRanges (Stack ranges, DelimitedTextRange currentRange) {
+ protected Stack collectDelimitedTextRanges(Stack ranges, DelimitedTextRange currentRange) {
if (currentRange != null) {
- currentRange.append (CharUtilities.OBJECT_REPLACEMENT_CHARACTER, this);
+ currentRange.append(CharUtilities.OBJECT_REPLACEMENT_CHARACTER, this);
}
return ranges;
}
}
@Override
- protected Stack collectDelimitedTextRanges (Stack ranges, DelimitedTextRange currentRange) {
+ protected Stack collectDelimitedTextRanges(Stack ranges, DelimitedTextRange currentRange) {
char pfx = 0;
char sfx = 0;
int unicodeBidi = getUnicodeBidi();
}
if (currentRange != null) {
if (pfx != 0) {
- currentRange.append (pfx, this);
+ currentRange.append(pfx, this);
}
for (Iterator it = getChildNodes(); (it != null) && it.hasNext();) {
- ranges = ((FONode) it.next()).collectDelimitedTextRanges (ranges);
+ ranges = ((FONode) it.next()).collectDelimitedTextRanges(ranges);
}
if (sfx != 0) {
- currentRange.append (sfx, this);
+ currentRange.append(sfx, this);
}
}
return ranges;
overflow = pList.get(PR_OVERFLOW).getEnum();
referenceOrientation = pList.get(PR_REFERENCE_ORIENTATION).getNumeric();
span = pList.get(PR_SPAN).getEnum();
- writingModeTraits = new WritingModeTraits
- (WritingMode.valueOf(pList.get(PR_WRITING_MODE).getEnum()));
+ writingModeTraits = new WritingModeTraits(
+ WritingMode.valueOf(pList.get(PR_WRITING_MODE).getEnum()));
disableColumnBalancing = pList.get(PR_X_DISABLE_COLUMN_BALANCING).getEnum();
}
}
@Override
- public boolean isDelimitedTextRangeBoundary (int boundary) {
+ public boolean isDelimitedTextRangeBoundary(int boundary) {
return false;
}
@Override
- protected Stack collectDelimitedTextRanges (Stack ranges, DelimitedTextRange currentRange) {
+ protected Stack collectDelimitedTextRanges(Stack ranges, DelimitedTextRange currentRange) {
if (currentRange != null) {
- currentRange.append (charIterator(), this);
+ currentRange.append(charIterator(), this);
}
return ranges;
}
lineHeight = pList.get(PR_LINE_HEIGHT).getSpace();
overflow = pList.get(PR_OVERFLOW).getEnum();
referenceOrientation = pList.get(PR_REFERENCE_ORIENTATION).getNumeric();
- writingModeTraits = new WritingModeTraits
- (WritingMode.valueOf(pList.get(PR_WRITING_MODE).getEnum()));
+ writingModeTraits = new WritingModeTraits(
+ WritingMode.valueOf(pList.get(PR_WRITING_MODE).getEnum()));
}
/**
}
@Override
- public boolean isDelimitedTextRangeBoundary (int boundary) {
+ public boolean isDelimitedTextRangeBoundary(int boundary) {
return false;
}
}
@Override
- public boolean isDelimitedTextRangeBoundary (int boundary) {
+ public boolean isDelimitedTextRangeBoundary(int boundary) {
return false;
}
}
@Override
- protected Stack collectDelimitedTextRanges (Stack ranges, DelimitedTextRange currentRange) {
+ protected Stack collectDelimitedTextRanges(Stack ranges, DelimitedTextRange currentRange) {
if (currentRange != null) {
if (leaderPattern == EN_USECONTENT) {
- ranges = super.collectDelimitedTextRanges (ranges, currentRange);
+ ranges = super.collectDelimitedTextRanges(ranges, currentRange);
} else {
- currentRange.append (CharUtilities.OBJECT_REPLACEMENT_CHARACTER, this);
+ currentRange.append(CharUtilities.OBJECT_REPLACEMENT_CHARACTER, this);
}
}
return ranges;
}
@Override
- protected Stack collectDelimitedTextRanges (Stack ranges, DelimitedTextRange currentRange) {
+ protected Stack collectDelimitedTextRanges(Stack ranges, DelimitedTextRange currentRange) {
ListItemLabel label = getLabel();
if (label != null) {
- ranges = label.collectDelimitedTextRanges (ranges);
+ ranges = label.collectDelimitedTextRanges(ranges);
}
ListItemBody body = getBody();
if (body != null) {
- ranges = body.collectDelimitedTextRanges (ranges);
+ ranges = body.collectDelimitedTextRanges(ranges);
}
return ranges;
}
}
@Override
- public boolean isDelimitedTextRangeBoundary (int boundary) {
+ public boolean isDelimitedTextRangeBoundary(int boundary) {
return false;
}
* <i>NOTE: An <code>fo:retrieve-table-marker</code> is only permitted as a descendant
* of an <code>fo:table-header</code> or an <code>fo:table-footer</code>.</i>
*/
- public void processNode
- (String elementName, Locator locator, Attributes attlist, PropertyList pList)
+ public void processNode(
+ String elementName, Locator locator, Attributes attlist, PropertyList pList)
throws FOPException {
if (findAncestor(FO_TABLE_HEADER) < 0
&& findAncestor(FO_TABLE_FOOTER) < 0) {
}
@Override
- public boolean isDelimitedTextRangeBoundary (int boundary) {
+ public boolean isDelimitedTextRangeBoundary(int boundary) {
return false;
}
tableLayout = pList.get(PR_TABLE_LAYOUT).getEnum();
tableOmitFooterAtBreak = pList.get(PR_TABLE_OMIT_FOOTER_AT_BREAK).getEnum();
tableOmitHeaderAtBreak = pList.get(PR_TABLE_OMIT_HEADER_AT_BREAK).getEnum();
- writingModeTraits = new WritingModeTraits
- (WritingMode.valueOf(pList.get(PR_WRITING_MODE).getEnum()));
+ writingModeTraits = new WritingModeTraits(
+ WritingMode.valueOf(pList.get(PR_WRITING_MODE).getEnum()));
//Bind extension properties
widowContentLimit = pList.get(PR_X_WIDOW_CONTENT_LIMIT).getLength();
}
@Override
- protected Stack collectDelimitedTextRanges (Stack ranges, DelimitedTextRange currentRange) {
+ protected Stack collectDelimitedTextRanges(Stack ranges, DelimitedTextRange currentRange) {
// header sub-tree
TableHeader header = getTableHeader();
if (header != null) {
- ranges = header.collectDelimitedTextRanges (ranges);
+ ranges = header.collectDelimitedTextRanges(ranges);
}
// footer sub-tree
TableFooter footer = getTableFooter();
if (footer != null) {
- ranges = footer.collectDelimitedTextRanges (ranges);
+ ranges = footer.collectDelimitedTextRanges(ranges);
}
// body sub-tree
for (Iterator it = getChildNodes(); (it != null) && it.hasNext();) {
- ranges = ((FONode) it.next()).collectDelimitedTextRanges (ranges);
+ ranges = ((FONode) it.next()).collectDelimitedTextRanges(ranges);
}
return ranges;
}
* @param language (may be null or empty, which is treated as null)
* @param country (may be null or empty, which is treated as null)
*/
- public PageNumberGenerator (String format, int groupingSeparator, int groupingSize, int letterValue, String features, String language, String country) {
- this.converter = new NumberConverter (format, groupingSeparator, groupingSize, letterValue, features, language, country);
+ public PageNumberGenerator(String format, int groupingSeparator, int groupingSize, int letterValue, String features, String language, String country) {
+ this.converter = new NumberConverter(format, groupingSeparator, groupingSize, letterValue, features, language, country);
}
/**
* @param number page number to format
* @return the formatted page number as a String
*/
- public String makeFormattedPageNumber (int number) {
- return converter.convert (number);
+ public String makeFormattedPageNumber(int number) {
+ return converter.convert(number);
}
}
locale = CommonHyphenation.toLocale(language, country);
masterReference = pList.get(PR_MASTER_REFERENCE).getString();
referenceOrientation = pList.get(PR_REFERENCE_ORIENTATION).getNumeric();
- writingModeTraits = new WritingModeTraits
- (WritingMode.valueOf(pList.get(PR_WRITING_MODE).getEnum()));
+ writingModeTraits = new WritingModeTraits(
+ WritingMode.valueOf(pList.get(PR_WRITING_MODE).getEnum()));
if (masterReference == null || masterReference.equals("")) {
missingPropertyError("master-reference");
}
* @return the SimplePageMaster to use for this page
* @throws PageProductionException if there's a problem determining the page master
*/
- public SimplePageMaster getNextSimplePageMaster
- (int page, boolean isFirstPage, boolean isLastPage, boolean isBlank)
+ public SimplePageMaster getNextSimplePageMaster(
+ int page, boolean isFirstPage, boolean isLastPage, boolean isBlank)
throws PageProductionException {
if (pageSequenceMaster == null) {
@Override
- protected Stack collectDelimitedTextRanges (Stack ranges, DelimitedTextRange currentRange) {
+ protected Stack collectDelimitedTextRanges(Stack ranges, DelimitedTextRange currentRange) {
// collect ranges from static content flows
Map<String, FONode> flows = getFlowMap();
if (flows != null) {
for (FONode fn : flows.values()) {
if (fn instanceof StaticContent) {
- ranges = ((StaticContent) fn).collectDelimitedTextRanges (ranges);
+ ranges = ((StaticContent) fn).collectDelimitedTextRanges(ranges);
}
}
}
// collect ranges in main flow
Flow main = getMainFlow();
if (main != null) {
- ranges = main.collectDelimitedTextRanges (ranges);
+ ranges = main.collectDelimitedTextRanges(ranges);
}
return ranges;
}
}
/** {@inheritDoc} */
- public Rectangle getViewportRectangle (FODimension reldims) {
+ public Rectangle getViewportRectangle(FODimension reldims) {
/* Special rules apply to resolving extent as values are resolved relative
* to the page size and reference orientation.
*/
* @param wm writing mode
* @param siblingContext the context to use to resolve extent on siblings
*/
- protected void adjustIPD
- (Rectangle vpRefRect, WritingMode wm, PercentBaseContext siblingContext) {
+ protected void adjustIPD(
+ Rectangle vpRefRect, WritingMode wm, PercentBaseContext siblingContext) {
int offset = 0;
RegionStart start = (RegionStart) getSiblingRegion(FO_REGION_START);
if (start != null) {
}
/** {@inheritDoc} */
- public Rectangle getViewportRectangle (FODimension reldims) {
+ public Rectangle getViewportRectangle(FODimension reldims) {
/* Special rules apply to resolving extent as values are resolved relative
* to the page size and reference orientation.
*/
}
/** {@inheritDoc} */
- public Rectangle getViewportRectangle (FODimension reldims) {
+ public Rectangle getViewportRectangle(FODimension reldims) {
/* Special rules apply to resolving margins in the page context.
* Contrary to normal margins in this case top and bottom margin
* are resolved relative to the height. In the property subsystem
}
/** {@inheritDoc} */
- public Rectangle getViewportRectangle (FODimension reldims) {
+ public Rectangle getViewportRectangle(FODimension reldims) {
/* Special rules apply to resolving extent as values are resolved relative
* to the page size and reference orientation.
*/
* @param wm writing mode
* @param siblingContext the context to use to resolve extent on siblings
*/
- protected void adjustIPD
- (Rectangle vpRefRect, WritingMode wm, PercentBaseContext siblingContext) {
+ protected void adjustIPD(
+ Rectangle vpRefRect, WritingMode wm, PercentBaseContext siblingContext) {
int offset = 0;
RegionBefore before = (RegionBefore) getSiblingRegion(FO_REGION_BEFORE);
if (before != null && before.getPrecedence() == EN_TRUE) {
}
/** {@inheritDoc} */
- public Rectangle getViewportRectangle (FODimension reldims) {
+ public Rectangle getViewportRectangle(FODimension reldims) {
/* Special rules apply to resolving extent as values are resolved relative
* to the page size and reference orientation.
*/
for (int i = 0; i < extraCorresponding.length; i++) {
int[] eca = extraCorresponding[i];
if ((eca == null) || (eca.length != 4)) {
- throw new IllegalArgumentException ("bad sub-array @ [" + i + "]");
+ throw new IllegalArgumentException("bad sub-array @ [" + i + "]");
}
}
this.extraCorresponding = extraCorresponding;
throws PropertyException {
PropertyList pList = getWMPropertyList(propertyList);
if (pList != null) {
- int wmcorr = pList.selectFromWritingMode
- (corresponding[0], corresponding[1], corresponding[2], corresponding[3]);
+ int wmcorr = pList.selectFromWritingMode(
+ corresponding[0], corresponding[1], corresponding[2], corresponding[3]);
return propertyList.get(wmcorr);
} else {
return null;
case Constants.EN_BLINK:
case Constants.EN_NO_BLINK:
if (none) {
- throw new PropertyException
- ("'none' specified, no additional values allowed");
+ throw new PropertyException(
+ "'none' specified, no additional values allowed");
}
switch (enumValue) {
case Constants.EN_UNDERLINE:
@Override
public String toString() {
StringBuilder sb = new StringBuilder("CMapSegment: ");
- sb.append ("{ UC[");
- sb.append (unicodeStart);
- sb.append (',');
- sb.append (unicodeEnd);
- sb.append ("]: GC[");
- sb.append (glyphStartIndex);
- sb.append (',');
- sb.append (glyphStartIndex + (unicodeEnd - unicodeStart));
- sb.append ("] }");
+ sb.append("{ UC[");
+ sb.append(unicodeStart);
+ sb.append(',');
+ sb.append(unicodeEnd);
+ sb.append("]: GC[");
+ sb.append(glyphStartIndex);
+ sb.append(',');
+ sb.append(glyphStartIndex + (unicodeEnd - unicodeStart));
+ sb.append("] }");
return sb.toString();
}
} else if ((ch2 >= 0xD800) && (ch2 <= 0xE000)) {
return 0;
} else {
- return getKernValue ((char) ch1, (char) ch2);
+ return getKernValue((char) ch1, (char) ch2);
}
}
*/
public int getCharWidth(int c) {
if (c < 0x10000) {
- return getCharWidth ((char) c);
+ return getCharWidth((char) c);
} else {
// TODO !BMP
return -1;
}
/** {@inheritDoc} */
- public CharSequence performSubstitution (CharSequence cs, String script, String language) {
+ public CharSequence performSubstitution(CharSequence cs, String script, String language) {
if (metric instanceof Substitutable) {
Substitutable s = (Substitutable) metric;
- return s.performSubstitution (cs, script, language);
+ return s.performSubstitution(cs, script, language);
} else {
throw new UnsupportedOperationException();
}
}
/** {@inheritDoc} */
- public CharSequence reorderCombiningMarks (CharSequence cs, int[][] gpa, String script, String language) {
+ public CharSequence reorderCombiningMarks(CharSequence cs, int[][] gpa, String script, String language) {
if (metric instanceof Substitutable) {
Substitutable s = (Substitutable) metric;
- return s.reorderCombiningMarks (cs, gpa, script, language);
+ return s.reorderCombiningMarks(cs, gpa, script, language);
} else {
throw new UnsupportedOperationException();
}
}
/** {@inheritDoc} */
- public int[][] performPositioning (CharSequence cs, String script, String language, int fontSize) {
+ public int[][] performPositioning(CharSequence cs, String script, String language, int fontSize) {
if (metric instanceof Positionable) {
Positionable p = (Positionable) metric;
- return p.performPositioning (cs, script, language, fontSize);
+ return p.performPositioning(cs, script, language, fontSize);
} else {
throw new UnsupportedOperationException();
}
}
/** {@inheritDoc} */
- public int[][] performPositioning (CharSequence cs, String script, String language) {
- return performPositioning (cs, script, language, fontSize);
+ public int[][] performPositioning(CharSequence cs, String script, String language) {
+ return performPositioning(cs, script, language, fontSize);
}
}
* @return A list of matching font triplets
*/
public List<FontTriplet> getTripletsFor(String fontName) {
- List<FontTriplet> foundTriplets = new ArrayList<FontTriplet> ();
+ List<FontTriplet> foundTriplets = new ArrayList<FontTriplet>();
for (Map.Entry<FontTriplet, String> tripletEntry : triplets.entrySet()) {
if (fontName.equals((tripletEntry.getValue()))) {
foundTriplets.add(tripletEntry.getKey());
/**
* {@inheritDoc}
*/
- public CharSequence performSubstitution (CharSequence cs, String script, String language) {
+ public CharSequence performSubstitution(CharSequence cs, String script, String language) {
load(true);
if (realFontDescriptor instanceof Substitutable) {
return ((Substitutable)realFontDescriptor).performSubstitution(cs, script, language);
/**
* {@inheritDoc}
*/
- public CharSequence reorderCombiningMarks
- (CharSequence cs, int[][] gpa, String script, String language) {
+ public CharSequence reorderCombiningMarks(
+ CharSequence cs, int[][] gpa, String script, String language) {
if (!isMetricsLoaded) {
load(true);
}
* {@inheritDoc}
*/
public int[][]
- performPositioning (CharSequence cs, String script, String language, int fontSize) {
+ performPositioning(CharSequence cs, String script, String language, int fontSize) {
if (!isMetricsLoaded) {
load(true);
}
* {@inheritDoc}
*/
public int[][]
- performPositioning (CharSequence cs, String script, String language) {
+ performPositioning(CharSequence cs, String script, String language) {
if (!isMetricsLoaded) {
load(true);
}
* Add a private use mapping {PU,GI} to the existing character map.
* N.B. Does not insert in order, merely appends to end of existing map.
*/
- private synchronized void addPrivateUseMapping (int pu, int gi) {
- assert findGlyphIndex (pu) == SingleByteEncoding.NOT_FOUND_CODE_POINT;
+ private synchronized void addPrivateUseMapping(int pu, int gi) {
+ assert findGlyphIndex(pu) == SingleByteEncoding.NOT_FOUND_CODE_POINT;
CMapSegment[] oldCmap = cmap;
int cmapLength = oldCmap.length;
CMapSegment[] newCmap = new CMapSegment [ cmapLength + 1 ];
- System.arraycopy (oldCmap, 0, newCmap, 0, cmapLength);
- newCmap [ cmapLength ] = new CMapSegment (pu, pu, gi);
+ System.arraycopy(oldCmap, 0, newCmap, 0, cmapLength);
+ newCmap [ cmapLength ] = new CMapSegment(pu, pu, gi);
cmap = newCmap;
}
* @param gi glyph index
* @returns unicode scalar value
*/
- private int createPrivateUseMapping (int gi) {
+ private int createPrivateUseMapping(int gi) {
while ((nextPrivateUse < 0xF900)
&& (findGlyphIndex(nextPrivateUse) != SingleByteEncoding.NOT_FOUND_CODE_POINT)) {
nextPrivateUse++;
}
if (nextPrivateUse < 0xF900) {
int pu = nextPrivateUse;
- addPrivateUseMapping (pu, gi);
+ addPrivateUseMapping(pu, gi);
if (firstPrivate == 0) {
firstPrivate = pu;
}
lastPrivate = pu;
numMapped++;
if (log.isDebugEnabled()) {
- log.debug ("Create private use mapping from "
- + CharUtilities.format (pu)
+ log.debug("Create private use mapping from "
+ + CharUtilities.format(pu)
+ " to glyph index " + gi
+ " in font '" + getFullName() + "'");
}
}
lastUnmapped = gi;
numUnmapped++;
- log.warn ("Exhausted private use area: unable to map "
+ log.warn("Exhausted private use area: unable to map "
+ numUnmapped + " glyphs in glyph index range ["
+ firstUnmapped + "," + lastUnmapped
+ "] (inclusive) of font '" + getFullName() + "'");
* @returns unicode scalar value
*/
// [TBD] - needs optimization, i.e., change from linear search to binary search
- private int findCharacterFromGlyphIndex (int gi, boolean augment) {
+ private int findCharacterFromGlyphIndex(int gi, boolean augment) {
int cc = 0;
for (int i = 0, n = cmap.length; i < n; i++) {
CMapSegment segment = cmap [ i ];
}
}
if ((cc == 0) && augment) {
- cc = createPrivateUseMapping (gi);
+ cc = createPrivateUseMapping(gi);
}
return cc;
}
- private int findCharacterFromGlyphIndex (int gi) {
- return findCharacterFromGlyphIndex (gi, true);
+ private int findCharacterFromGlyphIndex(int gi) {
+ return findCharacterFromGlyphIndex(gi, true);
}
* Establishes the glyph definition table.
* @param gdef the glyph definition table to be used by this font
*/
- public void setGDEF (GlyphDefinitionTable gdef) {
+ public void setGDEF(GlyphDefinitionTable gdef) {
if ((this.gdef == null) || (gdef == null)) {
this.gdef = gdef;
} else {
- throw new IllegalStateException ("font already associated with GDEF table");
+ throw new IllegalStateException("font already associated with GDEF table");
}
}
* Establishes the glyph substitution table.
* @param gsub the glyph substitution table to be used by this font
*/
- public void setGSUB (GlyphSubstitutionTable gsub) {
+ public void setGSUB(GlyphSubstitutionTable gsub) {
if ((this.gsub == null) || (gsub == null)) {
this.gsub = gsub;
} else {
- throw new IllegalStateException ("font already associated with GSUB table");
+ throw new IllegalStateException("font already associated with GSUB table");
}
}
* Establishes the glyph positioning table.
* @param gpos the glyph positioning table to be used by this font
*/
- public void setGPOS (GlyphPositioningTable gpos) {
+ public void setGPOS(GlyphPositioningTable gpos) {
if ((this.gpos == null) || (gpos == null)) {
this.gpos = gpos;
} else {
- throw new IllegalStateException ("font already associated with GPOS table");
+ throw new IllegalStateException("font already associated with GPOS table");
}
}
}
/** {@inheritDoc} */
- public CharSequence performSubstitution (CharSequence cs, String script, String language) {
+ public CharSequence performSubstitution(CharSequence cs, String script, String language) {
if (gsub != null) {
- GlyphSequence igs = mapCharsToGlyphs (cs);
- GlyphSequence ogs = gsub.substitute (igs, script, language);
- CharSequence ocs = mapGlyphsToChars (ogs);
+ GlyphSequence igs = mapCharsToGlyphs(cs);
+ GlyphSequence ogs = gsub.substitute(igs, script, language);
+ CharSequence ocs = mapGlyphsToChars(ogs);
return ocs;
} else {
return cs;
}
/** {@inheritDoc} */
- public CharSequence reorderCombiningMarks
- (CharSequence cs, int[][] gpa, String script, String language) {
+ public CharSequence reorderCombiningMarks(
+ CharSequence cs, int[][] gpa, String script, String language) {
if (gdef != null) {
- GlyphSequence igs = mapCharsToGlyphs (cs);
- GlyphSequence ogs = gdef.reorderCombiningMarks (igs, gpa, script, language);
- CharSequence ocs = mapGlyphsToChars (ogs);
+ GlyphSequence igs = mapCharsToGlyphs(cs);
+ GlyphSequence ogs = gdef.reorderCombiningMarks(igs, gpa, script, language);
+ CharSequence ocs = mapGlyphsToChars(ogs);
return ocs;
} else {
return cs;
/** {@inheritDoc} */
public int[][]
- performPositioning (CharSequence cs, String script, String language, int fontSize) {
+ performPositioning(CharSequence cs, String script, String language, int fontSize) {
if (gpos != null) {
- GlyphSequence gs = mapCharsToGlyphs (cs);
+ GlyphSequence gs = mapCharsToGlyphs(cs);
int[][] adjustments = new int [ gs.getGlyphCount() ] [ 4 ];
- if (gpos.position (gs, script, language, fontSize, this.width, adjustments)) {
- return scaleAdjustments (adjustments, fontSize);
+ if (gpos.position(gs, script, language, fontSize, this.width, adjustments)) {
+ return scaleAdjustments(adjustments, fontSize);
} else {
return null;
}
}
/** {@inheritDoc} */
- public int[][] performPositioning (CharSequence cs, String script, String language) {
+ public int[][] performPositioning(CharSequence cs, String script, String language) {
throw new UnsupportedOperationException();
}
- private int[][] scaleAdjustments (int[][] adjustments, int fontSize) {
+ private int[][] scaleAdjustments(int[][] adjustments, int fontSize) {
if (adjustments != null) {
for (int i = 0, n = adjustments.length; i < n; i++) {
int[] gpa = adjustments [ i ];
* @param cs a CharSequence containing UTF-16 encoded Unicode characters
* @returns a CharSequence containing glyph indices
*/
- private GlyphSequence mapCharsToGlyphs (CharSequence cs) {
- IntBuffer cb = IntBuffer.allocate (cs.length());
- IntBuffer gb = IntBuffer.allocate (cs.length());
+ private GlyphSequence mapCharsToGlyphs(CharSequence cs) {
+ IntBuffer cb = IntBuffer.allocate(cs.length());
+ IntBuffer gb = IntBuffer.allocate(cs.length());
int gi;
- int giMissing = findGlyphIndex (Typeface.NOT_FOUND);
+ int giMissing = findGlyphIndex(Typeface.NOT_FOUND);
for (int i = 0, n = cs.length(); i < n; i++) {
- int cc = cs.charAt (i);
+ int cc = cs.charAt(i);
if ((cc >= 0xD800) && (cc < 0xDC00)) {
if ((i + 1) < n) {
int sh = cc;
- int sl = cs.charAt (++i);
+ int sl = cs.charAt(++i);
if ((sl >= 0xDC00) && (sl < 0xE000)) {
cc = 0x10000 + ((sh - 0xD800) << 10) + ((sl - 0xDC00) << 0);
} else {
- throw new IllegalArgumentException
- ("ill-formed UTF-16 sequence, "
+ throw new IllegalArgumentException(
+ "ill-formed UTF-16 sequence, "
+ "contains isolated high surrogate at index " + i);
}
} else {
- throw new IllegalArgumentException
- ("ill-formed UTF-16 sequence, "
+ throw new IllegalArgumentException(
+ "ill-formed UTF-16 sequence, "
+ "contains isolated high surrogate at end of sequence");
}
} else if ((cc >= 0xDC00) && (cc < 0xE000)) {
- throw new IllegalArgumentException
- ("ill-formed UTF-16 sequence, "
+ throw new IllegalArgumentException(
+ "ill-formed UTF-16 sequence, "
+ "contains isolated low surrogate at index " + i);
}
notifyMapOperation();
- gi = findGlyphIndex (cc);
+ gi = findGlyphIndex(cc);
if (gi == SingleByteEncoding.NOT_FOUND_CODE_POINT) {
- warnMissingGlyph ((char) cc);
+ warnMissingGlyph((char) cc);
gi = giMissing;
}
- cb.put (cc);
- gb.put (gi);
+ cb.put(cc);
+ gb.put(gi);
}
cb.flip();
gb.flip();
- return new GlyphSequence (cb, gb, null);
+ return new GlyphSequence(cb, gb, null);
}
/**
* @param gs a GlyphSequence containing glyph indices
* @returns a CharSequence containing UTF-16 encoded Unicode characters
*/
- private CharSequence mapGlyphsToChars (GlyphSequence gs) {
+ private CharSequence mapGlyphsToChars(GlyphSequence gs) {
int ng = gs.getGlyphCount();
- CharBuffer cb = CharBuffer.allocate (ng);
+ CharBuffer cb = CharBuffer.allocate(ng);
int ccMissing = Typeface.NOT_FOUND;
for (int i = 0, n = ng; i < n; i++) {
- int gi = gs.getGlyph (i);
- int cc = findCharacterFromGlyphIndex (gi);
+ int gi = gs.getGlyph(i);
+ int cc = findCharacterFromGlyphIndex(gi);
if ((cc == 0) || (cc > 0x10FFFF)) {
cc = ccMissing;
log.warn("Unable to map glyph index " + gi
cc -= 0x10000;
sh = ((cc >> 10) & 0x3FF) + 0xD800;
sl = ((cc >> 0) & 0x3FF) + 0xDC00;
- cb.put ((char) sh);
- cb.put ((char) sl);
+ cb.put((char) sh);
+ cb.put((char) sl);
} else {
- cb.put ((char) cc);
+ cb.put((char) cc);
}
}
cb.flip();
// internal mapping of glyph indexes to unicode indexes
// used for quick mappings in this class
- private final Map<Integer, Integer> glyphToUnicodeMap = new HashMap<Integer, Integer> ();
- private final Map<Integer, Integer> unicodeToGlyphMap = new HashMap<Integer, Integer> ();
+ private final Map<Integer, Integer> glyphToUnicodeMap = new HashMap<Integer, Integer>();
+ private final Map<Integer, Integer> unicodeToGlyphMap = new HashMap<Integer, Integer>();
private TTFDirTabEntry currentDirTab;
* @param useKerning true if kerning data should be loaded
* @param useAdvanced true if advanced typographic tables should be loaded
*/
- public TTFFile (boolean useKerning, boolean useAdvanced) {
+ public TTFFile(boolean useKerning, boolean useAdvanced) {
this.useKerning = useKerning;
this.useAdvanced = useAdvanced;
}
}
/** {@inheritDoc} */
- public boolean equals (Object o) {
+ public boolean equals(Object o) {
if (o instanceof UnicodeMapping) {
UnicodeMapping m = (UnicodeMapping) o;
if (unicodeIndex != m.unicodeIndex) {
}
/** {@inheritDoc} */
- public int compareTo (Object o) {
+ public int compareTo(Object o) {
if (o instanceof UnicodeMapping) {
UnicodeMapping m = (UnicodeMapping) o;
if (unicodeIndex > m.unicodeIndex) {
}
}
- private boolean readUnicodeCmap // CSOK: MethodLength
- (long cmapUniOffset, int encodingID)
+ private boolean readUnicodeCmap(
+ long cmapUniOffset, int encodingID)
throws IOException {
//Read CMAP table and correct mtxTab.index
int mtxPtr = 0;
if (useAdvanced) {
try {
OTFAdvancedTypographicTableReader atr
- = new OTFAdvancedTypographicTableReader (this, in);
+ = new OTFAdvancedTypographicTableReader(this, in);
atr.readAll();
this.advancedTableReader = atr;
} catch (AdvancedTypographicTableFormatException e) {
- log.warn (
+ log.warn(
"Encountered format constraint violation in advanced (typographic) table (AT) "
+ "in font '" + getFullName() + "', ignoring AT data: "
+ e.getMessage()
/**
* Copy advanced typographic information.
*/
- private void copyAdvanced (TTFFile ttf) {
+ private void copyAdvanced(TTFFile ttf) {
if (returnFont instanceof MultiByteFont) {
MultiByteFont mbf = (MultiByteFont) returnFont;
- mbf.setGDEF (ttf.getGDEF());
- mbf.setGSUB (ttf.getGSUB());
- mbf.setGPOS (ttf.getGPOS());
+ mbf.setGDEF(ttf.getGDEF());
+ mbf.setGSUB(ttf.getGSUB());
+ mbf.setGPOS(ttf.getGPOS());
}
}
* @param useKerning true if kerning data should be loaded
* @param useAdvanced true if advanced typographic tables should be loaded
*/
- public TTFSubSetFile (boolean useKerning, boolean useAdvanced) {
+ public TTFSubSetFile(boolean useKerning, boolean useAdvanced) {
super(useKerning, useAdvanced);
}
* Entry point for ant java task
* @param args sourceDir, targetDir
*/
- public static void main (String[] args) {
+ public static void main(String[] args) {
SerializeHyphPattern ser = new SerializeHyphPattern();
ser.serializeDir(new File(args[0]), new File(args[1]));
}
alg.setConstantLineWidth(flowBPD);
int optimalPageCount = alg.findBreakingPoints(effectiveList, 1, true,
BreakingAlgorithm.ALL_BREAKS);
- if (Math.abs (alg.getIPDdifference()) > 1) {
+ if (Math.abs(alg.getIPDdifference()) > 1) {
addAreas(alg, optimalPageCount, blockList, effectiveList);
// *** redo Phase 1 ***
log.trace("IPD changes after page " + optimalPageCount);
* @param availableBPD the available BPD
* @return the effective list
*/
- private BlockSequence justifyBoxes // CSOK: MethodLength
- (BlockSequence blockList, PageBreakingAlgorithm alg, int availableBPD) {
+ private BlockSequence justifyBoxes(
+ BlockSequence blockList, PageBreakingAlgorithm alg, int availableBPD) {
int optimalPageCount;
alg.setConstantLineWidth(availableBPD);
optimalPageCount = alg.findBreakingPoints(blockList, /*availableBPD,*/
+ " / " + difference);
}
int newAdjust = ((BlockLevelLayoutManager) blockSpace.getLayoutManager())
- .negotiateBPDAdjustment
- (((int) ((float) partial * difference / total)) - adjustedDiff, blockSpace);
+ .negotiateBPDAdjustment(
+ ((int) ((float) partial * difference / total)) - adjustedDiff, blockSpace);
adjustedDiff += newAdjust;
}
return adjustedDiff;
KnuthGlue line = lineListIterator.next();
partial += (difference > 0 ? line.getStretch() : line.getShrink());
int newAdjust = ((BlockLevelLayoutManager) line.getLayoutManager())
- .negotiateBPDAdjustment
- (((int) ((float) partial * difference / total)) - adjustedDiff, line);
+ .negotiateBPDAdjustment(
+ ((int) ((float) partial * difference / total)) - adjustedDiff, line);
adjustedDiff += newAdjust;
}
return adjustedDiff;
viewportBlockArea = new BlockViewport(allowBPDUpdate);
viewportBlockArea.addTrait(Trait.IS_VIEWPORT_AREA, Boolean.TRUE);
if (level >= 0) {
- viewportBlockArea.setBidiLevel (level);
+ viewportBlockArea.setBidiLevel(level);
}
viewportBlockArea.setIPD(getContentAreaIPD());
if (allowBPDUpdate) {
referenceArea = new Block();
referenceArea.addTrait(Trait.IS_REFERENCE_AREA, Boolean.TRUE);
if (level >= 0) {
- referenceArea.setBidiLevel (level);
+ referenceArea.setBidiLevel(level);
}
TraitSetter.setProducerID(referenceArea, getBlockContainerFO().getId());
curBlockArea.setIPD(super.getContentAreaIPD());
- curBlockArea.setBidiLevel (getBlockFO().getBidiLevel());
+ curBlockArea.setBidiLevel(getBlockFO().getBidiLevel());
TraitSetter.addBreaks(curBlockArea,
getBlockFO().getBreakBefore(), getBlockFO().getBreakAfter());
ListElement element;
while (listIter.hasNext()) {
element = (ListElement) listIter.next();
- element.setPosition
- (lm.notifyPos(new NonLeafPosition(lm, element.getPosition())));
+ element.setPosition(
+ lm.notifyPos(new NonLeafPosition(lm, element.getPosition())));
}
}
footnoteListIndex = footnotesList.size() - 1;
footnoteElementIndex
= getFootnoteList(footnoteListIndex).size() - 1;
- } else if (((canDeferOldFN = canDeferOldFootnotes // CSOK: InnerAssignment
- (pageNode, elementIndex))
+ } else if (((canDeferOldFN = canDeferOldFootnotes(// CSOK: InnerAssignment
+ pageNode, elementIndex))
|| newFootnotes)
- && (footnoteSplit = getFootnoteSplit // CSOK: InnerAssignment
- (pageNode, getLineWidth(activeNode.line) - actualWidth,
+ && (footnoteSplit = getFootnoteSplit(// CSOK: InnerAssignment
+ pageNode, getLineWidth(activeNode.line) - actualWidth,
canDeferOldFN)) > 0) {
// it is allowed to break or even defer footnotes if either:
// - there are new footnotes in the last piece of content, and
insertedFootnotesLength = totalFootnotesLength;
footnoteListIndex = lengthList.size() - 1;
footnoteElementIndex = getFootnoteList(footnoteListIndex).size() - 1;
- } else if ((split = getFootnoteSplit // CSOK: InnerAssignment
- (footnoteListIndex, footnoteElementIndex,
+ } else if ((split = getFootnoteSplit(// CSOK: InnerAssignment
+ footnoteListIndex, footnoteElementIndex,
insertedFootnotesLength, availableBPD, true)) > 0) {
// add a piece of a footnote
availableBPD -= split;
new LeafPosition(this, -1), true));
returnList.add(new KnuthGlue(letterSpaceIPD.mult(areaInfo.letterSpaces),
new LeafPosition(this, -1), true));
- returnList.add (
+ returnList.add(
new KnuthInlineBox(0, null, notifyPos(new LeafPosition(this, -1)), true));
if (areaInfo.isHyphenated) {
returnList.add(new KnuthPenalty(hyphIPD, KnuthPenalty.FLAGGED_PENALTY, true,
* @param cwidth the calculated content width of the object
* @return the X offset
*/
- public int computeXOffset (int ipd, int cwidth) {
+ public int computeXOffset(int ipd, int cwidth) {
int xoffset = 0;
switch (props.getTextAlign()) {
case EN_CENTER:
/** {@inheritDoc} */
@Override // CSOK: MethodLength
- public List getNextKnuthElements
- (LayoutContext context, int alignment) {
+ public List getNextKnuthElements(
+ LayoutContext context, int alignment) {
LayoutManager curLM;
// the list returned by child LM
ls.setIPD(iAdjust);
int level = parentArea.getBidiLevel();
if (level >= 0) {
- ls.setBidiLevel (level);
+ ls.setBidiLevel(level);
}
parentArea.addChildArea(ls);
}
if (currLM != prevLM || !oldListIterator.hasNext()) {
if (oldListIterator.hasNext()) {
- returnedList.addAll
- (prevLM.getChangedKnuthElements
- (oldList.subList(fromIndex, oldListIterator.previousIndex()),
+ returnedList.addAll(
+ prevLM.getChangedKnuthElements(
+ oldList.subList(fromIndex, oldListIterator.previousIndex()),
alignment, depth));
prevLM = currLM;
fromIndex = oldListIterator.previousIndex();
} else if (currLM == prevLM) {
- returnedList.addAll
- (prevLM.getChangedKnuthElements
- (oldList.subList(fromIndex, oldList.size()),
+ returnedList.addAll(
+ prevLM.getChangedKnuthElements(
+ oldList.subList(fromIndex, oldList.size()),
alignment, depth));
} else {
- returnedList.addAll
- (prevLM.getChangedKnuthElements
- (oldList.subList(fromIndex, oldListIterator.previousIndex()),
+ returnedList.addAll(
+ prevLM.getChangedKnuthElements(
+ oldList.subList(fromIndex, oldListIterator.previousIndex()),
alignment, depth));
if (currLM != null) {
- returnedList.addAll
- (currLM.getChangedKnuthElements
- (oldList.subList(oldListIterator.previousIndex(), oldList.size()),
+ returnedList.addAll(
+ currLM.getChangedKnuthElements(
+ oldList.subList(oldListIterator.previousIndex(), oldList.size()),
alignment, depth));
}
}
ListIterator listIter = returnedList.listIterator();
while (listIter.hasNext()) {
returnedElement = (KnuthElement) listIter.next();
- returnedElement.setPosition
- (notifyPos(new NonLeafPosition(this, returnedElement.getPosition())));
+ returnedElement.setPosition(
+ notifyPos(new NonLeafPosition(this, returnedElement.getPosition())));
returnList.add(returnedElement);
}
* @param pos the Position stored in this box
* @param auxiliary is this box auxiliary?
*/
- public KnuthInlineBox
- (int width, AlignmentContext alignmentContext, Position pos, boolean auxiliary) {
+ public KnuthInlineBox(
+ int width, AlignmentContext alignmentContext, Position pos, boolean auxiliary) {
super(width, pos, auxiliary);
this.alignmentContext = alignmentContext;
}
} else {
leaderArea = new Space();
if (level >= 0) {
- leaderArea.setBidiLevel (level);
+ leaderArea.setBidiLevel(level);
}
}
leaderArea.setBPD(fobj.getRuleThickness().getValue(this));
leaderArea.addTrait(Trait.COLOR, fobj.getColor());
if (level >= 0) {
- leaderArea.setBidiLevel (level);
+ leaderArea.setBidiLevel(level);
}
} else if (fobj.getLeaderPattern() == EN_SPACE) {
leaderArea = new Space();
leaderArea.setBPD(fobj.getRuleThickness().getValue(this));
if (level >= 0) {
- leaderArea.setBidiLevel (level);
+ leaderArea.setBidiLevel(level);
}
} else if (fobj.getLeaderPattern() == EN_DOTS) {
TextArea t = new TextArea();
spacer = new Space();
spacer.setIPD(widthLeaderPattern - width);
if (level >= 0) {
- spacer.setBidiLevel (level);
+ spacer.setBidiLevel(level);
}
width = widthLeaderPattern;
}
spacer = new Space();
spacer.setIPD(fobj.getLeaderPatternWidth().getValue(this) - width);
if (level >= 0) {
- spacer.setBidiLevel (level);
+ spacer.setBidiLevel(level);
}
width = fobj.getLeaderPatternWidth().getValue(this);
}
//Content collapsed to nothing, so use a space
leaderArea = new Space();
leaderArea.setBPD(fobj.getRuleThickness().getValue(this));
- leaderArea.setBidiLevel (fobj.getBidiLevelRecursive());
+ leaderArea.setBidiLevel(fobj.getBidiLevelRecursive());
}
}
TraitSetter.setProducerID(leaderArea, fobj.getId());
}
startIndex = endIndex + 1;
LineBreakPosition lbp = (LineBreakPosition) llPoss.getChosenPosition(i);
- returnList.add(new KnuthBlockBox
- (lbp.lineHeight + lbp.spaceBefore + lbp.spaceAfter,
+ returnList.add(new KnuthBlockBox(
+ lbp.lineHeight + lbp.spaceBefore + lbp.spaceAfter,
footnoteList, lbp, false));
}
}
.applyChanges(par.subList(fromIndex + elementsAdded,
toIndex + elementsAdded))) {
// insert the new KnuthElements
- List newElements = currUpdate.inlineLM.getChangedKnuthElements
- (par.subList(fromIndex + elementsAdded,
+ List newElements = currUpdate.inlineLM.getChangedKnuthElements(
+ par.subList(fromIndex + elementsAdded,
toIndex + elementsAdded),
/*flaggedPenalty,*/ effectiveAlignment);
// remove the old elements
}
lineArea.finish();
if (lineArea.getBidiLevel() >= 0) {
- BidiResolver.reorder (lineArea);
+ BidiResolver.reorder(lineArea);
}
parentLayoutManager.addChildArea(lineArea);
}
}
lineArea.updateExtentsFromChildren();
if (lineArea.getBidiLevel() >= 0) {
- BidiResolver.reorder (lineArea);
+ BidiResolver.reorder(lineArea);
}
parentLayoutManager.addChildArea(lineArea);
}
private final int level;
private final int[][] gposAdjustments;
- AreaInfo // CSOK: ParameterNumber
- (int startIndex, int breakIndex, int wordSpaceCount, int letterSpaceCount,
+ AreaInfo(
+ int startIndex, int breakIndex, int wordSpaceCount, int letterSpaceCount,
MinOptMax areaIPD, boolean isHyphenated, boolean isSpace, boolean breakOppAfter,
Font font, int level, int[][] gposAdjustments) {
assert startIndex <= breakIndex;
*/
private int getWordLength() {
if (wordCharLength == -1) {
- if (foText.hasMapping (startIndex, breakIndex)) {
- wordCharLength = foText.getMapping (startIndex, breakIndex).length();
+ if (foText.hasMapping(startIndex, breakIndex)) {
+ wordCharLength = foText.getMapping(startIndex, breakIndex).length();
} else {
assert breakIndex >= startIndex;
wordCharLength = breakIndex - startIndex;
letterSpaceAdjustIndex = 0;
wordLevels = new int[wordLength];
wordLevelsIndex = 0;
- Arrays.fill (wordLevels, -1);
+ Arrays.fill(wordLevels, -1);
gposAdjustments = new int[wordLength][4];
gposAdjustmentsIndex = 0;
wordIPD = 0;
private void addWordChars(AreaInfo wordAreaInfo) {
int s = wordAreaInfo.startIndex;
int e = wordAreaInfo.breakIndex;
- if (foText.hasMapping (s, e)) {
- wordChars.append (foText.getMapping (s, e));
- addWordLevels (foText.getMappingBidiLevels (s, e));
+ if (foText.hasMapping(s, e)) {
+ wordChars.append(foText.getMapping(s, e));
+ addWordLevels(foText.getMappingBidiLevels(s, e));
} else {
for (int i = s; i < e; i++) {
wordChars.append(foText.charAt(i));
}
- addWordLevels (foText.getBidiLevels (s, e));
+ addWordLevels(foText.getBidiLevels(s, e));
}
wordIPD += wordAreaInfo.areaIPD.getOpt();
}
* concatenante (possibly mapped) word bidi levels to levels buffer.
* @param levels bidi levels array or null
*/
- private void addWordLevels (int[] levels) {
+ private void addWordLevels(int[] levels) {
int numLevels = (levels != null) ? levels.length : 0;
if (numLevels > 0) {
int need = wordLevelsIndex + numLevels;
if (need <= wordLevels.length) {
- System.arraycopy (levels, 0, wordLevels, wordLevelsIndex, numLevels);
+ System.arraycopy(levels, 0, wordLevels, wordLevelsIndex, numLevels);
} else {
- throw new IllegalStateException
- ("word levels array too short: expect at least "
+ throw new IllegalStateException(
+ "word levels array too short: expect at least "
+ need + " entries, but has only " + wordLevels.length + " entries");
}
}
}
}
} else {
- throw new IllegalStateException
- ("gpos adjustments array too short: expect at least "
+ throw new IllegalStateException(
+ "gpos adjustments array too short: expect at least "
+ need + " entries, but has only " + gposAdjustments.length
+ " entries");
}
char spaceChar = foText.charAt(i);
int level = foText.bidiLevelAt(i);
if (!CharUtilities.isZeroWidthSpace(spaceChar)) {
- textArea.addSpace
- (spaceChar, spaceIPD,
+ textArea.addSpace(
+ spaceChar, spaceIPD,
CharUtilities.isAdjustableSpace(spaceChar),
blockProgressionOffset, level);
}
}
- private void addAreaInfo (AreaInfo ai) {
- addAreaInfo (areaInfos.size(), ai);
+ private void addAreaInfo(AreaInfo ai) {
+ addAreaInfo(areaInfos.size(), ai);
}
- private void addAreaInfo (int index, AreaInfo ai) {
- areaInfos.add (index, ai);
+ private void addAreaInfo(int index, AreaInfo ai) {
+ areaInfos.add(index, ai);
}
- private void removeAreaInfo (int index) {
- areaInfos.remove (index);
+ private void removeAreaInfo(int index) {
+ areaInfos.remove(index);
}
private AreaInfo getAreaInfo(int index) {
returnList.add(sequence);
if (LOG.isDebugEnabled()) {
- LOG.debug ("GK: [" + nextStart + "," + foText.length() + "]");
+ LOG.debug("GK: [" + nextStart + "," + foText.length() + "]");
}
LineBreakStatus lineBreakStatus = new LineBreakStatus();
thisStart = nextStart;
TextLayoutManager.LOG.error("Unexpected breakAction: " + breakAction);
}
if (LOG.isDebugEnabled()) {
- LOG.debug ("GK: {"
+ LOG.debug("GK: {"
+ " index = " + nextStart
- + ", char = " + CharUtilities.charToNCRef (ch)
+ + ", char = " + CharUtilities.charToNCRef(ch)
+ ", level = " + level
+ ", levelPrev = " + prevLevel
+ ", inWord = " + inWord
final KnuthSequence sequence, final boolean breakOpportunity, int level) {
if (LOG.isDebugEnabled()) {
- LOG.debug ("PS: [" + thisStart + "," + nextStart + "]");
+ LOG.debug("PS: [" + thisStart + "," + nextStart + "]");
}
// End of whitespace
// create the AreaInfo object
assert nextStart >= thisStart;
- AreaInfo areaInfo = new AreaInfo
- (thisStart, nextStart, nextStart - thisStart, 0,
+ AreaInfo areaInfo = new AreaInfo(
+ thisStart, nextStart, nextStart - thisStart, 0,
wordSpaceIPD.mult(nextStart - thisStart),
false, true, breakOpportunity, spaceFont, level, null);
return areaInfo;
}
- private AreaInfo processWordMapping
- (int lastIndex, final Font font, AreaInfo prevAreaInfo, final char breakOpportunityChar,
+ private AreaInfo processWordMapping(
+ int lastIndex, final Font font, AreaInfo prevAreaInfo, final char breakOpportunityChar,
final boolean endsWithHyphen, int level) {
int s = this.thisStart; // start index of word in FOText character buffer
int e = lastIndex; // end index of word in FOText character buffer
String language = foText.getLanguage();
if (LOG.isDebugEnabled()) {
- LOG.debug ("PW: [" + thisStart + "," + lastIndex + "]: {"
+ LOG.debug("PW: [" + thisStart + "," + lastIndex + "]: {"
+ " +M"
+ ", level = " + level
+ " }");
}
// 1. extract unmapped character sequence
- CharSequence ics = foText.subSequence (s, e);
+ CharSequence ics = foText.subSequence(s, e);
// 2. if script is not specified (by FO property) or it is specified as 'auto',
// then compute dominant script
if ((script == null) || "auto".equals(script)) {
- script = CharScript.scriptTagFromCode (CharScript.dominantScript (ics));
+ script = CharScript.scriptTagFromCode(CharScript.dominantScript(ics));
}
if ((language == null) || "none".equals(language)) {
language = "dflt";
}
// 3. perform mapping of chars to glyphs ... to glyphs ... to chars
- CharSequence mcs = font.performSubstitution (ics, script, language);
+ CharSequence mcs = font.performSubstitution(ics, script, language);
// 4. compute glyph position adjustments on (substituted) characters
int[][] gpa;
if (font.performsPositioning()) {
// handle GPOS adjustments
- gpa = font.performPositioning (mcs, script, language);
+ gpa = font.performPositioning(mcs, script, language);
} else if (font.hasKerning()) {
// handle standard (non-GPOS) kerning adjustments
- gpa = getKerningAdjustments (mcs, font);
+ gpa = getKerningAdjustments(mcs, font);
} else {
gpa = null;
}
// 5. reorder combining marks so that they precede (within the mapped char sequence) the
// base to which they are applied; N.B. position adjustments (gpa) are reordered in place
- mcs = font.reorderCombiningMarks (mcs, gpa, script, language);
+ mcs = font.reorderCombiningMarks(mcs, gpa, script, language);
// 6. if mapped sequence differs from input sequence, then memoize mapped sequence
- if (!CharUtilities.isSameSequence (mcs, ics)) {
- foText.addMapping (s, e, mcs);
+ if (!CharUtilities.isSameSequence(mcs, ics)) {
+ foText.addMapping(s, e, mcs);
}
// 7. compute word ipd based on final position adjustments
MinOptMax ipd = MinOptMax.ZERO;
for (int i = 0, n = mcs.length(); i < n; i++) {
- int c = mcs.charAt (i);
+ int c = mcs.charAt(i);
// TODO !BMP
- int w = font.getCharWidth (c);
+ int w = font.getCharWidth(c);
if (w < 0) {
w = 0;
}
if (gpa != null) {
w += gpa [ i ] [ GlyphPositioningTable.Value.IDX_X_ADVANCE ];
}
- ipd = ipd.plus (w);
+ ipd = ipd.plus(w);
}
// [TBD] - handle letter spacing
- return new AreaInfo
- (s, e, 0, nLS, ipd, endsWithHyphen, false,
+ return new AreaInfo(
+ s, e, 0, nLS, ipd, endsWithHyphen, false,
breakOpportunityChar != 0, font, level, gpa);
}
* @param font applicable font
* @return glyph position adjustments (or null if no kerning)
*/
- private int[][] getKerningAdjustments (CharSequence mcs, final Font font) {
+ private int[][] getKerningAdjustments(CharSequence mcs, final Font font) {
int nc = mcs.length();
// extract kerning array
int[] ka = new int [ nc ]; // kerning array
for (int i = 0, n = nc, cPrev = -1; i < n; i++) {
- int c = mcs.charAt (i);
+ int c = mcs.charAt(i);
// TODO !BMP
if (cPrev >= 0) {
- ka[i] = font.getKernValue (cPrev, c);
+ ka[i] = font.getKernValue(cPrev, c);
}
cPrev = c;
}
MinOptMax wordIPD = MinOptMax.ZERO;
if (LOG.isDebugEnabled()) {
- LOG.debug ("PW: [" + thisStart + "," + lastIndex + "]: {"
+ LOG.debug("PW: [" + thisStart + "," + lastIndex + "]: {"
+ " -M"
+ ", level = " + level
+ " }");
}
final boolean endsWithHyphen = checkEndsWithHyphen
&& foText.charAt(lastIndex) == CharUtilities.SOFT_HYPHEN;
- Font font = FontSelector.selectFontForCharactersInText
- (foText, thisStart, lastIndex, foText, this);
+ Font font = FontSelector.selectFontForCharactersInText(
+ foText, thisStart, lastIndex, foText, this);
AreaInfo areaInfo;
if (font.performsSubstitution() || font.performsPositioning()) {
- areaInfo = processWordMapping
- (lastIndex, font, prevAreaInfo, breakOpportunity ? ch : 0, endsWithHyphen, level);
+ areaInfo = processWordMapping(
+ lastIndex, font, prevAreaInfo, breakOpportunity ? ch : 0, endsWithHyphen, level);
} else {
- areaInfo = processWordNoMapping
- (lastIndex, font, prevAreaInfo, breakOpportunity ? ch : 0, endsWithHyphen, level);
+ areaInfo = processWordNoMapping(
+ lastIndex, font, prevAreaInfo, breakOpportunity ? ch : 0, endsWithHyphen, level);
}
prevAreaInfo = areaInfo;
addAreaInfo(areaInfo);
if (!(nothingChanged && stopIndex == areaInfo.breakIndex && !hyphenFollows)) {
// the new AreaInfo object is not equal to the old one
- changeList.add
- (new PendingChange
- (new AreaInfo(startIndex, stopIndex, 0,
+ changeList.add(
+ new PendingChange(
+ new AreaInfo(startIndex, stopIndex, 0,
letterSpaceCount, newIPD, hyphenFollows,
false, false, font, -1, null),
((LeafPosition) pos).getLeafPos() + changeOffset));
// they don't add any stretch
KnuthGlue g;
if (skipZeroCheck || lineStartBAP != 0 || lineEndBAP != 0) {
- g = new KnuthGlue
- (lineEndBAP,
+ g = new KnuthGlue(
+ lineEndBAP,
3 * LineLayoutManager.DEFAULT_SPACE_WIDTH, 0, auxiliaryPosition, false);
elements.add(g);
elements.add(makeZeroWidthPenalty(0));
- g = new KnuthGlue
- (p2WidthOffset - (lineStartBAP + lineEndBAP),
+ g = new KnuthGlue(
+ p2WidthOffset - (lineStartBAP + lineEndBAP),
-3 * LineLayoutManager.DEFAULT_SPACE_WIDTH, 0, pos2, false);
elements.add(g);
elements.add(makeAuxiliaryZeroWidthBox());
g = new KnuthGlue(lineStartBAP + p3WidthOffset, 0, 0, pos3, false);
elements.add(g);
} else {
- g = new KnuthGlue
- (0,
+ g = new KnuthGlue(
+ 0,
3 * LineLayoutManager.DEFAULT_SPACE_WIDTH, 0, auxiliaryPosition, false);
elements.add(g);
elements.add(makeZeroWidthPenalty(0));
- g = new KnuthGlue
- (areaInfo.areaIPD.getOpt(),
+ g = new KnuthGlue(
+ areaInfo.areaIPD.getOpt(),
-3 * LineLayoutManager.DEFAULT_SPACE_WIDTH, 0, pos2, false);
elements.add(g);
}
return elements;
}
- private List getElementsForJustifiedText
- (AreaInfo areaInfo, Position pos2, int p2WidthOffset,
+ private List getElementsForJustifiedText(
+ AreaInfo areaInfo, Position pos2, int p2WidthOffset,
Position pos3, int p3WidthOffset, boolean skipZeroCheck,
int shrinkability) {
public String toString() {
return super.toString() + "{"
+ "chars = \'"
- + CharUtilities.toNCRefs (foText.getCharSequence().toString())
+ + CharUtilities.toNCRefs(foText.getCharSequence().toString())
+ "\'"
+ ", len = " + foText.length()
+ "}";
}
return collapse;
case Constants.EN_COLLAPSE_WITH_PRECEDENCE:
- throw new UnsupportedOperationException ("collapse-with-precedence not yet supported");
+ throw new UnsupportedOperationException("collapse-with-precedence not yet supported");
default:
throw new IllegalArgumentException("Illegal border-collapse mode.");
}
public ColumnSetup(Table table) {
assert table != null;
this.table = table;
- this.wmTraits = WritingModeTraits.getWritingModeTraitsGetter (table);
+ this.wmTraits = WritingModeTraits.getWritingModeTraitsGetter(table);
prepareColumns();
initializeColumnWidths();
}
}*/
/** {@inheritDoc} */
- public int compare (Object obj1, Object obj2) {
+ public int compare(Object obj1, Object obj2) {
if (obj1 instanceof PDFDestination && obj2 instanceof PDFDestination) {
PDFDestination dest1 = (PDFDestination)obj1;
PDFDestination dest2 = (PDFDestination)obj2;
}
private void writeChar(char ch, StringBuffer sb) {
- writeChar (ch, sb, useMultiByte);
+ writeChar(ch, sb, useMultiByte);
}
private void checkInTextObject() {
* @param x coordinate
* @param y coordinate
*/
- public void writeTd (double x, double y) {
+ public void writeTd(double x, double y) {
StringBuffer sb = new StringBuffer();
PDFNumber.doubleOut(x, DEC, sb);
sb.append(' ');
* Writes a "Tj" command with specified character code.
* @param ch character code to write
*/
- public void writeTj (char ch) {
+ public void writeTj(char ch) {
StringBuffer sb = new StringBuffer();
sb.append('<');
writeChar(ch, sb, true);
* @param bpsEnd the border-end traits
* @param innerBackgroundColor the background color of the block
*/
- protected void clipBackground (float startx, float starty,
+ protected void clipBackground(float startx, float starty,
float width, float height,
BorderProps bpsBefore, BorderProps bpsAfter,
BorderProps bpsStart, BorderProps bpsEnd) {
// if line's content overflows line area, then
// ensure that overflow is drawn (extends)
// outside of left side of line area
- int overflow = computeInlinesOverflow (line);
+ int overflow = computeInlinesOverflow(line);
if (overflow > 0) {
currentIPPosition -= overflow;
}
currentBPPosition = saveBP;
}
- private int computeInlinesOverflow (LineArea line) {
+ private int computeInlinesOverflow(LineArea line) {
List children = line.getInlineAreas();
int ipdConsumed = 0;
for (int i = 0, l = children.size(); i < l; i++) {
objectAreaInfo.setHeightRes(resolution);
}
- private AFPDataObjectInfo encodeImage
- (AFPImageObjectInfo imageObjectInfo,
+ private AFPDataObjectInfo encodeImage(
+ AFPImageObjectInfo imageObjectInfo,
AFPPaintingState paintingState)
throws IOException {
*/
public AFPGraphics2D createGraphics2D(boolean textAsShapes) {
AFPGraphics2D g2d
- = new AFPGraphics2D
- (textAsShapes, paintingState, resourceManager, resourceInfo, fontInfo);
+ = new AFPGraphics2D(
+ textAsShapes, paintingState, resourceManager, resourceInfo, fontInfo);
g2d.setGraphicContext(new org.apache.xmlgraphics.java2d.GraphicContext());
return g2d;
}
builder.setCodedFont((byte) fontReference);
int l = text.length();
- int[] dx = IFUtil.convertDPToDX (dp);
+ int[] dx = IFUtil.convertDPToDX(dp);
int dxl = (dx != null ? dx.length : 0);
StringBuffer sb = new StringBuffer();
return objectAreaInfo;
}
- private AFPGraphicsObjectInfo createGraphicsObjectInfo
- (AFPPaintingState paintingState, Graphics2DImagePainter painter,
+ private AFPGraphicsObjectInfo createGraphicsObjectInfo(
+ AFPPaintingState paintingState, Graphics2DImagePainter painter,
FOUserAgent userAgent, AFPResourceInfo resourceInfo, AFPGraphics2D g2d) {
AFPGraphicsObjectInfo graphicsObjectInfo = new AFPGraphicsObjectInfo();
* @param renderable the Renderable instance that is used to reload/re-render a document
* after modifications.
*/
- public PreviewDialog // CSOK: MethodLength
- (FOUserAgent foUserAgent, Renderable renderable) {
+ public PreviewDialog(
+ FOUserAgent foUserAgent, Renderable renderable) {
renderer = (AWTRenderer) foUserAgent.getRendererOverride();
this.foUserAgent = foUserAgent;
this.configuredTargetResolution = this.foUserAgent.getTargetResolution();
/** {@inheritDoc} */
public void skewX(float skx) throws ParseException {
- this.transforms.add
- (AffineTransform.getShearInstance(Math.tan(Math.toRadians(skx)), 0));
+ this.transforms.add(
+ AffineTransform.getShearInstance(Math.tan(Math.toRadians(skx)), 0));
}
/** {@inheritDoc} */
public void skewY(float sky) throws ParseException {
- this.transforms.add
- (AffineTransform.getShearInstance(0, Math.tan(Math.toRadians(sky))));
+ this.transforms.add(
+ AffineTransform.getShearInstance(0, Math.tan(Math.toRadians(sky))));
}
/** {@inheritDoc} */
* {@inheritDoc}
*/
public Object clone() {
- return new IFGraphicContext (this);
+ return new IFGraphicContext(this);
}
/** @param group a group */
* @param bpsEnd the border segment on the end-side (right)
* @throws IFException if an error occurs while handling this event
*/
- void clipBackground (Rectangle rect,
+ void clipBackground(Rectangle rect,
BorderProps bpsBefore, BorderProps bpsAfter,
BorderProps bpsStart, BorderProps bpsEnd) throws IFException;
// if only DX present, then convert DX to DP; otherwise use only DP,
// effectively ignoring DX
if ((dp == null) && (dx != null)) {
- dp = IFUtil.convertDXToDP (dx);
+ dp = IFUtil.convertDXToDP(dx);
}
establishStructureTreeElement(lastAttributes);
boolean isHyphenated = Boolean.valueOf(lastAttributes.getValue("hyphenated"));
if (dp == null) {
renderTextWithAdjustments(s, word.getLetterAdjustArray(), word.isReversed(),
font, (AbstractTextArea)word.getParentArea());
- } else if (IFUtil.isDPOnlyDX (dp)) {
- renderTextWithAdjustments(s, IFUtil.convertDPToDX (dp), word.isReversed(),
+ } else if (IFUtil.isDPOnlyDX(dp)) {
+ renderTextWithAdjustments(s, IFUtil.convertDPToDX(dp), word.isReversed(),
font, (AbstractTextArea)word.getParentArea());
} else {
renderTextWithAdjustments(s, dp, word.isReversed(),
Font font, AbstractTextArea parentArea) {
assert !textUtil.combined;
for (int i = 0, n = s.length(); i < n; i++) {
- textUtil.addChar (s.charAt (i));
+ textUtil.addChar(s.charAt(i));
if (dp != null) {
- textUtil.adjust (dp[i]);
+ textUtil.adjust(dp[i]);
}
}
}
void adjust(int dx) {
if (dx != 0) {
- adjust (new int[] {
+ adjust(new int[] {
dx, // xPlaAdjust
0, // yPlaAdjust
dx, // xAdvAdjust
}
void adjust(int[] pa) {
- if (!IFUtil.isPAIdentity (pa)) {
+ if (!IFUtil.isPAIdentity(pa)) {
int idx = text.length();
if (idx > dp.length - 1) {
int newSize = Math.max(dp.length, idx + 1) + INITIAL_BUFFER_SIZE;
if (dp[idx - 1] == null) {
dp[idx - 1] = new int[4];
}
- IFUtil.adjustPA (dp[idx - 1], pa);
+ IFUtil.adjustPA(dp[idx - 1], pa);
}
}
try {
if (combined) {
painter.drawText(startx, starty, 0, 0,
- trimAdjustments (dp, text.length()), text.toString());
+ trimAdjustments(dp, text.length()), text.toString());
} else {
painter.drawText(startx, starty, tls, tws,
- trimAdjustments (dp, text.length()), text.toString());
+ trimAdjustments(dp, text.length()), text.toString());
}
} catch (IFException e) {
handleIFException(e);
* no greater than text length, and the last entry has a non-zero
* adjustment.
*/
- private int[][] trimAdjustments (int[][] dp, int textLength) {
+ private int[][] trimAdjustments(int[][] dp, int textLength) {
if (dp != null) {
int tl = textLength;
int pl = dp.length;
int i = (tl < pl) ? tl : pl;
while (i > 0) {
int[] pa = dp [ i - 1 ];
- if ((pa != null) && !IFUtil.isPAIdentity (pa)) {
+ if ((pa != null) && !IFUtil.isPAIdentity(pa)) {
break;
} else {
i--;
if (i == 0) {
dp = null;
} else if (i < pl) {
- dp = IFUtil.copyDP (dp, 0, i);
+ dp = IFUtil.copyDP(dp, 0, i);
}
}
return dp;
* @return if <code>dp</code> is not null, then an array of adjustments to the current
* x position prior to rendering individual glyphs; otherwise, null
*/
- public static int[] convertDPToDX (int[][] dp, int count) {
+ public static int[] convertDPToDX(int[][] dp, int count) {
int[] dx;
if (dp != null) {
dx = new int [ count ];
* @return if <code>dp</code> is not null, then an array of adjustments to the current
* x position prior to rendering individual glyphs; otherwise, null
*/
- public static int[] convertDPToDX (int[][] dp) {
- return convertDPToDX (dp, (dp != null) ? dp.length : 0);
+ public static int[] convertDPToDX(int[][] dp) {
+ return convertDPToDX(dp, (dp != null) ? dp.length : 0);
}
/**
* @return if <code>dx</code> is not null, then an array of 4-tuples, expressing [X,Y]
* placment adjustments and [X,Y] advancement adjustments, in that order; otherwise, null
*/
- public static int[][] convertDXToDP (int[] dx, int count) {
+ public static int[][] convertDXToDP(int[] dx, int count) {
int[][] dp;
if (dx != null) {
dp = new int [ count ] [ 4 ];
* @return if <code>dx</code> is not null, then an array of 4-tuples, expressing [X,Y]
* placment adjustments and [X,Y] advancement adjustments, in that order; otherwise, null
*/
- public static int[][] convertDXToDP (int[] dx) {
- return convertDXToDP (dx, (dx != null) ? dx.length : 0);
+ public static int[][] convertDXToDP(int[] dx) {
+ return convertDXToDP(dx, (dx != null) ? dx.length : 0);
}
/**
* @param pa a 4-tuple, expressing [X,Y] placment and [X,Y] advance adjuustments (may be null)
* @return true if <code>dp</code> is null or contains no non-zero adjustment
*/
- public static boolean isPAIdentity (int[] pa) {
+ public static boolean isPAIdentity(int[] pa) {
if (pa == null) {
return true;
} else {
* adjustments and [X,Y] advancement adjustments, in that order (may be null)
* @return true if <code>dp</code> is null or contains no non-zero adjustment
*/
- public static boolean isDPIdentity (int[][] dp) {
+ public static boolean isDPIdentity(int[][] dp) {
if (dp == null) {
return true;
} else {
for (int i = 0, n = dp.length; i < n; i++) {
- if (!isPAIdentity (dp[i])) {
+ if (!isPAIdentity(dp[i])) {
return false;
}
}
* @return true if <code>dp</code> is not null and contains only xPlaAdjust
* and xAdvAdjust values consistent with the output of {@link #convertDPToDX}.
*/
- public static boolean isDPOnlyDX (int[][] dp) {
+ public static boolean isDPOnlyDX(int[][] dp) {
if (dp == null) {
return false;
} else {
* @param paSrc a 4-tuple, expressing [X,Y] placment
* and [X,Y] advance adjuustments (may be null)
*/
- public static void adjustPA (int[] paDst, int[] paSrc) {
+ public static void adjustPA(int[] paDst, int[] paSrc) {
if ((paDst != null) && (paSrc != null)) {
assert paDst.length == 4;
assert paSrc.length == 4;
* @return a deep copy of the count position adjustment entries start at
* offset
*/
- public static int[][] copyDP (int[][] dp, int offset, int count) {
+ public static int[][] copyDP(int[][] dp, int offset, int count) {
if ((dp == null) || (offset > dp.length) || ((offset + count) > dp.length)) {
throw new IllegalArgumentException();
} else {
Point2D cursor = new Point2D.Float(0, 0);
int l = text.length();
- int[] dx = IFUtil.convertDPToDX (dp);
+ int[] dx = IFUtil.convertDPToDX(dp);
int dxl = (dx != null ? dx.length : 0);
if (dx != null && dxl > 0 && dx[0] != 0) {
float fontSize = state.getFontSize() / 1000f;
Font font = getFontInfo().getFontInstance(triplet, state.getFontSize());
int l = text.length();
- int[] dx = IFUtil.convertDPToDX (dp);
+ int[] dx = IFUtil.convertDPToDX(dp);
int dxl = (dx != null ? dx.length : 0);
StringBuffer sb = new StringBuffer(Math.max(16, l));
0, maxAscent - descent + 2 * safetyMargin);
int l = text.length();
- int[] dx = IFUtil.convertDPToDX (dp);
+ int[] dx = IFUtil.convertDPToDX(dp);
int dxl = (dx != null ? dx.length : 0);
if (dx != null && dxl > 0 && dx[0] != 0) {
FontTriplet triplet = new FontTriplet(
state.getFontFamily(), state.getFontStyle(), state.getFontWeight());
- if ((dp == null) || IFUtil.isDPOnlyDX (dp)) {
- drawTextWithDX (x, y, text, triplet, letterSpacing,
- wordSpacing, IFUtil.convertDPToDX (dp));
+ if ((dp == null) || IFUtil.isDPOnlyDX(dp)) {
+ drawTextWithDX(x, y, text, triplet, letterSpacing,
+ wordSpacing, IFUtil.convertDPToDX(dp));
} else {
- drawTextWithDP (x, y, text, triplet, letterSpacing,
+ drawTextWithDP(x, y, text, triplet, letterSpacing,
wordSpacing, dp);
}
}
private static int[] paZero = new int[4];
- private void drawTextWithDP (int x, int y, String text, FontTriplet triplet,
+ private void drawTextWithDP(int x, int y, String text, FontTriplet triplet,
int letterSpacing, int wordSpacing, int[][] dp) {
assert text != null;
assert triplet != null;
double xoLast = 0f;
double yoLast = 0f;
double wox = wordSpacing;
- tu.writeTextMatrix (new AffineTransform (1, 0, 0, -1, x / 1000f, y / 1000f));
- tu.updateTf (fk, fsPoints, true);
- generator.updateCharacterSpacing (letterSpacing / 1000f);
+ tu.writeTextMatrix(new AffineTransform(1, 0, 0, -1, x / 1000f, y / 1000f));
+ tu.updateTf(fk, fsPoints, true);
+ generator.updateCharacterSpacing(letterSpacing / 1000f);
for (int i = 0, n = text.length(); i < n; i++) {
- char ch = text.charAt (i);
+ char ch = text.charAt(i);
int[] pa = ((i >= dp.length) || (dp[i] == null)) ? paZero : dp[i];
double xo = xc + pa[0];
double yo = yc + pa[1];
- double xa = f.getCharWidth(ch) + maybeWordOffsetX (wox, ch, null);
+ double xa = f.getCharWidth(ch) + maybeWordOffsetX(wox, ch, null);
double ya = 0;
double xd = (xo - xoLast) / 1000f;
double yd = (yo - yoLast) / 1000f;
- tu.writeTd (xd, yd);
- tu.writeTj (f.mapChar (ch));
+ tu.writeTd(xd, yd);
+ tu.writeTj(f.mapChar(ch));
xc += xa + pa[2];
yc += ya + pa[3];
xoLast = xo;
}
}
- private double maybeWordOffsetX (double wox, char ch, Direction dir) {
+ private double maybeWordOffsetX(double wox, char ch, Direction dir) {
if ((wox != 0)
- && CharUtilities.isAdjustableSpace (ch)
+ && CharUtilities.isAdjustableSpace(ch)
&& ((dir == null) || dir.isHorizontal())) {
return wox;
} else {
graphics.setViewportDimension(width, height);
if (hints.containsKey(ImageTranscoder.KEY_BACKGROUND_COLOR)) {
- graphics.setBackgroundColor
- ((Color)hints.get(ImageTranscoder.KEY_BACKGROUND_COLOR));
+ graphics.setBackgroundColor(
+ (Color)hints.get(ImageTranscoder.KEY_BACKGROUND_COLOR));
}
- graphics.setGraphicContext
- (new org.apache.xmlgraphics.java2d.GraphicContext());
+ graphics.setGraphicContext(
+ new org.apache.xmlgraphics.java2d.GraphicContext());
graphics.setTransform(curTxf);
this.root.paint(graphics);
* @return the PSResource representing the derived font
* @throws IOException In case of an I/O problem
*/
- public static PSResource defineDerivedFont
- (PSGenerator gen, String baseFontName, String fontName, String encoding)
+ public static PSResource defineDerivedFont(
+ PSGenerator gen, String baseFontName, String fontName, String encoding)
throws IOException {
PSResource res = new PSResource(PSResource.TYPE_FONT, fontName);
gen.writeDSCComment(DSCConstants.BEGIN_RESOURCE, res);
attr.set(RtfBefore.HEADER);
final IRtfBeforeContainer contBefore
- = (IRtfBeforeContainer)builderContext.getContainer
- (IRtfBeforeContainer.class, true, this);
+ = (IRtfBeforeContainer)builderContext.getContainer(
+ IRtfBeforeContainer.class, true, this);
contBefore.newBefore(attr);
}
attr.set(RtfAfter.FOOTER);
final IRtfAfterContainer contAfter
- = (IRtfAfterContainer)builderContext.getContainer
- (IRtfAfterContainer.class, true, this);
+ = (IRtfAfterContainer)builderContext.getContainer(
+ IRtfAfterContainer.class, true, this);
contAfter.newAfter(attr);
}
handled = true;
* @return RTF bookmark
* @throws IOException for I/O problems
*/
- RtfBookmark newBookmark (String bookmark) throws IOException;
+ RtfBookmark newBookmark(String bookmark) throws IOException;
}
* @return RtfExternalGraphic for the new image
* @exception IOException On error
*/
- RtfExternalGraphic newImage () throws IOException;
+ RtfExternalGraphic newImage() throws IOException;
}
* @exception IOException on error
* @return new Hyperlink object
*/
- RtfHyperLink newHyperLink (String str, RtfAttributes attr) throws IOException;
+ RtfHyperLink newHyperLink(String str, RtfAttributes attr) throws IOException;
}
* Sets the compression rate for the external graphic in percent.
* @param percent Compression rate
*/
- void setRtfExternalGraphicCompressionRate (int percent);
+ void setRtfExternalGraphicCompressionRate(int percent);
/**
* Gets the compression rate for the external graphic in percent.
* @return Compression rate
*/
- int getRtfExternalGraphicCompressionRate ();
+ int getRtfExternalGraphicCompressionRate();
}
* @return new Template object
* @exception IOException on error
*/
- RtfTemplate newTemplate (String str, RtfAttributes attr) throws IOException;
+ RtfTemplate newTemplate(String str, RtfAttributes attr) throws IOException;
}
* instance
* @return this object, for chaining calls
*/
- public RtfAttributes set (RtfAttributes attrs) {
+ public RtfAttributes set(RtfAttributes attrs) {
if (attrs != null) {
- Iterator it = attrs.nameIterator ();
- while (it.hasNext ()) {
- String name = (String) it.next ();
+ Iterator it = attrs.nameIterator();
+ while (it.hasNext()) {
+ String name = (String) it.next();
if (attrs.getValue(name) instanceof Integer) {
- Integer value = (Integer)attrs.getValue (name);
+ Integer value = (Integer)attrs.getValue(name);
if (value == null) {
- set (name);
+ set(name);
} else {
- set (name, value.intValue ());
+ set(name, value.intValue());
}
} else if (attrs.getValue(name) instanceof String) {
- String value = (String)attrs.getValue (name);
+ String value = (String)attrs.getValue(name);
if (value == null) {
- set (name);
+ set(name);
} else {
- set (name, value);
+ set(name, value);
}
} else {
- set (name);
+ set(name);
}
* @param writer a <code>Writer</code> value
* @param bookmark Name of the bookmark
*/
- RtfBookmark (RtfContainer parent, Writer writer, String bookmark) throws IOException {
- super (parent, writer);
+ RtfBookmark(RtfContainer parent, Writer writer, String bookmark) throws IOException {
+ super(parent, writer);
- int now = bookmark.length ();
+ int now = bookmark.length();
- this.bookmark = bookmark.substring (0,
+ this.bookmark = bookmark.substring(0,
now < MAX_BOOKMARK_LENGTH ? now : MAX_BOOKMARK_LENGTH);
- this.bookmark = this.bookmark.replace ('.', REPLACE_CHARACTER);
- this.bookmark = this.bookmark.replace (' ', REPLACE_CHARACTER);
+ this.bookmark = this.bookmark.replace('.', REPLACE_CHARACTER);
+ this.bookmark = this.bookmark.replace(' ', REPLACE_CHARACTER);
}
*
* @throws IOException On Error
*/
- public void writeRtfPrefix () throws IOException {
- startBookmark ();
+ public void writeRtfPrefix() throws IOException {
+ startBookmark();
}
/**
*
* @exception IOException On error
*/
- public void writeRtfContent () throws IOException {
+ public void writeRtfContent() throws IOException {
// this.getRtfFile ().getLog ().logInfo ("Write bookmark '" + bookmark + "'.");
// No content to write
}
*
* @throws IOException On Error
*/
- public void writeRtfSuffix () throws IOException {
- endBookmark ();
+ public void writeRtfSuffix() throws IOException {
+ endBookmark();
}
*
* @throws IOException On error
*/
- private void startBookmark () throws IOException {
+ private void startBookmark() throws IOException {
// {\*\bkmkstart test}
- writeRtfBookmark ("bkmkstart");
+ writeRtfBookmark("bkmkstart");
}
/**
*
* @throws IOException On error
*/
- private void endBookmark () throws IOException {
+ private void endBookmark() throws IOException {
// {\*\bkmkend test}
- writeRtfBookmark ("bkmkend");
+ writeRtfBookmark("bkmkend");
}
/**
*
* @throws IOException On error
*/
- private void writeRtfBookmark (String tag) throws IOException {
+ private void writeRtfBookmark(String tag) throws IOException {
if (bookmark == null) {
return;
}
- this.writeGroupMark (true);
+ this.writeGroupMark(true);
//changed. Now using writeStarControlWord
- this.writeStarControlWord (tag);
+ this.writeStarControlWord(tag);
- writer.write (bookmark);
- this.writeGroupMark (false);
+ writer.write(bookmark);
+ this.writeGroupMark(false);
}
/**
*
* @exception IOException On error
*/
- RtfBookmarkContainerImpl (RtfContainer parent, Writer w) throws IOException {
- super (parent, w, null);
+ RtfBookmarkContainerImpl(RtfContainer parent, Writer w) throws IOException {
+ super(parent, w, null);
}
/**
*
* @exception IOException On error
*/
- RtfBookmarkContainerImpl (RtfContainer parent, Writer w, RtfAttributes attr) throws IOException
+ RtfBookmarkContainerImpl(RtfContainer parent, Writer w, RtfAttributes attr) throws IOException
{
- super (parent, w, attr);
+ super(parent, w, attr);
}
*
* @throws IOException On eror
*/
- public RtfBookmark newBookmark (String bookmark) throws IOException {
+ public RtfBookmark newBookmark(String bookmark) throws IOException {
if (mBookmark != null) {
- mBookmark.close ();
+ mBookmark.close();
}
- mBookmark = new RtfBookmark (this, writer, bookmark);
+ mBookmark = new RtfBookmark(this, writer, bookmark);
return mBookmark;
}
/**
* Constructor.
*/
- private RtfColorTable () {
- colorTable = new Vector ();
- colorIndex = new Hashtable ();
- namedColors = new Hashtable ();
+ private RtfColorTable() {
+ colorTable = new Vector();
+ colorIndex = new Hashtable();
+ namedColors = new Hashtable();
- init ();
+ init();
}
/**
*
* @return The instance of RTFColorTable
*/
- public static RtfColorTable getInstance () {
+ public static RtfColorTable getInstance() {
if (instance == null) {
- instance = new RtfColorTable ();
+ instance = new RtfColorTable();
}
return instance;
/**
* Initialize the color table.
*/
- private void init () {
- addNamedColor("black", getColorNumber (0, 0, 0).intValue());
- addNamedColor("white", getColorNumber (255, 255, 255).intValue());
- addNamedColor("red", getColorNumber (255, 0, 0).intValue());
- addNamedColor("green", getColorNumber (0, 255, 0).intValue());
- addNamedColor("blue", getColorNumber (0, 0, 255).intValue());
- addNamedColor("cyan", getColorNumber (0, 255, 255).intValue());
- addNamedColor("magenta", getColorNumber (255, 0, 255).intValue());
- addNamedColor("yellow", getColorNumber (255, 255, 0).intValue());
-
- getColorNumber (0, 0, 128);
- getColorNumber (0, 128, 128);
- getColorNumber (0, 128, 0);
- getColorNumber (128, 0, 128);
- getColorNumber (128, 0, 0);
- getColorNumber (128, 128, 0);
- getColorNumber (128, 128, 128);
+ private void init() {
+ addNamedColor("black", getColorNumber(0, 0, 0).intValue());
+ addNamedColor("white", getColorNumber(255, 255, 255).intValue());
+ addNamedColor("red", getColorNumber(255, 0, 0).intValue());
+ addNamedColor("green", getColorNumber(0, 255, 0).intValue());
+ addNamedColor("blue", getColorNumber(0, 0, 255).intValue());
+ addNamedColor("cyan", getColorNumber(0, 255, 255).intValue());
+ addNamedColor("magenta", getColorNumber(255, 0, 255).intValue());
+ addNamedColor("yellow", getColorNumber(255, 255, 0).intValue());
+
+ getColorNumber(0, 0, 128);
+ getColorNumber(0, 128, 128);
+ getColorNumber(0, 128, 0);
+ getColorNumber(128, 0, 128);
+ getColorNumber(128, 0, 0);
+ getColorNumber(128, 128, 0);
+ getColorNumber(128, 128, 128);
// Added by Normand Masse
// Gray color added
addNamedColor("gray", getColorNumber(128, 128, 128).intValue());
- getColorNumber (192, 192, 192);
+ getColorNumber(192, 192, 192);
}
/** define a named color for getColorNumber(String) */
* @param name a named color
* @return the RTF number of a named color, or null if name not found
*/
- public Integer getColorNumber (String name) {
+ public Integer getColorNumber(String name) {
return ((Integer)namedColors.get(name.toLowerCase()));
}
*
* @return The number of the color in the table
*/
- public Integer getColorNumber (int red, int green, int blue) {
- Integer identifier = new Integer (determineIdentifier (red, green, blue));
- Object o = colorIndex.get (identifier);
+ public Integer getColorNumber(int red, int green, int blue) {
+ Integer identifier = new Integer(determineIdentifier(red, green, blue));
+ Object o = colorIndex.get(identifier);
int retVal;
if (o == null) {
//First add it, then read the size as index (to return it).
//So the first added color gets index 1. That is OK, because
//index 0 is reserved for auto-colored.
- addColor (identifier);
+ addColor(identifier);
- retVal = colorTable.size ();
+ retVal = colorTable.size();
} else {
//The color was found. Before returning the index, increment
//it by one. Because index 0 is reserved for auto-colored, but
//is not contained in colorTable.
- retVal = ((Integer) o).intValue () + 1;
+ retVal = ((Integer) o).intValue() + 1;
}
return new Integer(retVal);
*
* @throws IOException On error
*/
- public void writeColors (RtfHeader header) throws IOException {
- if (colorTable == null || colorTable.size () == 0) {
+ public void writeColors(RtfHeader header) throws IOException {
+ if (colorTable == null || colorTable.size() == 0) {
return;
}
header.newLine();
- header.writeGroupMark (true);
+ header.writeGroupMark(true);
//Don't use writeControlWord, because it appends a blank,
//which may confuse Wordpad.
//This also implicitly writes the first color (=index 0), which
//is reserved for auto-colored.
- header.write ("\\colortbl;");
+ header.write("\\colortbl;");
- int len = colorTable.size ();
+ int len = colorTable.size();
for (int i = 0; i < len; i++) {
- int identifier = ((Integer) colorTable.get (i)).intValue ();
+ int identifier = ((Integer) colorTable.get(i)).intValue();
header.newLine();
- header.write ("\\red" + determineColorLevel (identifier, RED));
- header.write ("\\green" + determineColorLevel (identifier, GREEN));
- header.write ("\\blue" + determineColorLevel (identifier, BLUE) + ";");
+ header.write("\\red" + determineColorLevel(identifier, RED));
+ header.write("\\green" + determineColorLevel(identifier, GREEN));
+ header.write("\\blue" + determineColorLevel(identifier, BLUE) + ";");
}
header.newLine();
- header.writeGroupMark (false);
+ header.writeGroupMark(false);
}
*
* @param i Identifier of color
*/
- private void addColor (Integer i) {
- colorIndex.put (i, new Integer (colorTable.size ()));
- colorTable.addElement (i);
+ private void addColor(Integer i) {
+ colorIndex.put(i, new Integer(colorTable.size()));
+ colorTable.addElement(i);
}
/**
*
* @return Unique identifier of color
*/
- private int determineIdentifier (int red, int green, int blue) {
+ private int determineIdentifier(int red, int green, int blue) {
int c = red << RED;
c += green << GREEN;
*
* @return Color level in byte size
*/
- private int determineColorLevel (int identifier, int color) {
+ private int determineColorLevel(int identifier, int color) {
int retVal = (byte) (identifier >> color);
return retVal < 0 ? retVal + 256 : retVal;
* @param list list of child objects
* @return true if process succeeded
*/
- public boolean setChildren (List list) {
+ public boolean setChildren(List list) {
if (list instanceof LinkedList) {
this.children = (LinkedList) list;
return true;
* @throws IOException for I/O problems
*/
public RtfExternalGraphic(RtfContainer container, Writer writer) throws IOException {
- super (container, writer);
+ super(container, writer);
}
/**
*/
public RtfExternalGraphic(RtfContainer container, Writer writer,
RtfAttributes attributes) throws IOException {
- super (container, writer, attributes);
+ super(container, writer, attributes);
}
writeGroupMark(false);
}
- private void computeImageSize () {
+ private void computeImageSize() {
if (imageformat.getType() == ImageConstants.I_PNG) {
width = ImageUtil.getIntFromByteArray(imagedata, 16, 4, true);
height = ImageUtil.getIntFromByteArray(imagedata, 20, 4, true);
}
}
- private void writeSizeInfo () throws IOException {
+ private void writeSizeInfo() throws IOException {
// Set image size
if (width != -1) {
writeControlWord("picw" + width);
public void setURL(String urlString) throws IOException {
URL tmpUrl = null;
try {
- tmpUrl = new URL (urlString);
+ tmpUrl = new URL(urlString);
} catch (MalformedURLException e) {
try {
- tmpUrl = new File (urlString).toURI().toURL ();
+ tmpUrl = new File(urlString).toURI().toURL();
} catch (MalformedURLException ee) {
throw new ExternalGraphicException("The attribute 'src' of "
+ "<fo:external-graphic> has a invalid value: '"
* Gets the compression rate for the image in percent.
* @return Compression rate
*/
- public int getCompressionRate () {
+ public int getCompressionRate() {
return graphicCompressionRate;
}
* @param percent Compression rate
* @return true if the compression rate is valid (0..100), false if invalid
*/
- public boolean setCompressionRate (int percent) {
+ public boolean setCompressionRate(int percent) {
if (percent < 1 || percent > 100) {
return false;
}
*
* @param parentITableColumnsInfo table context to set
*/
- public void setParentITableColumnsInfo (ITableColumnsInfo parentITableColumnsInfo) {
+ public void setParentITableColumnsInfo(ITableColumnsInfo parentITableColumnsInfo) {
this.parentITableColumnsInfo = parentITableColumnsInfo;
}
/** - end - */
/**
* Constructor.
*/
- private RtfFontManager () {
- fontTable = new Vector ();
- fontIndex = new Hashtable ();
+ private RtfFontManager() {
+ fontTable = new Vector();
+ fontIndex = new Hashtable();
- init ();
+ init();
}
/**
*
* @return The instance of RtfFontManager
*/
- public static RtfFontManager getInstance () {
+ public static RtfFontManager getInstance() {
if (instance == null) {
- instance = new RtfFontManager ();
+ instance = new RtfFontManager();
}
return instance;
/**
* Initialize the font table.
*/
- private void init () {
+ private void init() {
// getFontNumber ("Helvetica");
//Chanded by R.Marra default font Arial
- getFontNumber ("Arial");
- getFontNumber ("Symbol"); // used by RtfListItem.java
- getFontNumber ("Times New Roman");
+ getFontNumber("Arial");
+ getFontNumber("Symbol"); // used by RtfListItem.java
+ getFontNumber("Times New Roman");
/*
{\\f0\\fswiss Helv;}
*
* @return The number of the font in the table
*/
- public int getFontNumber (String family) {
+ public int getFontNumber(String family) {
Object o = fontIndex.get(getFontKey(family));
int retVal;
if (o == null) {
- addFont (family);
+ addFont(family);
retVal = fontTable.size() - 1;
} else {
*
* @throws IOException On error
*/
- public void writeFonts (RtfHeader header) throws IOException {
- if (fontTable == null || fontTable.size () == 0) {
+ public void writeFonts(RtfHeader header) throws IOException {
+ if (fontTable == null || fontTable.size() == 0) {
return;
}
header.writeGroupMark(true);
header.writeControlWord("fonttbl");
- int len = fontTable.size ();
+ int len = fontTable.size();
for (int i = 0; i < len; i++) {
header.writeGroupMark(true);
header.newLine();
header.write("\\f" + i);
- header.write(" " + (String) fontTable.elementAt (i));
+ header.write(" " + (String) fontTable.elementAt(i));
header.write(";");
header.writeGroupMark(false);
}
/** write our contents to m_writer. */
protected void writeRtfContent() throws IOException {
- RtfFontManager.getInstance ().writeFonts ((RtfHeader)parent);
+ RtfFontManager.getInstance().writeFonts((RtfHeader)parent);
}
/** true if this element would generate no "useful" RTF content */
* @param attr a <code>RtfAttributes</code> value
* @throws IOException for I/O problems
*/
- public RtfHyperLink (IRtfTextContainer parent, Writer writer, String str, RtfAttributes attr)
+ public RtfHyperLink(IRtfTextContainer parent, Writer writer, String str, RtfAttributes attr)
throws IOException {
- super ((RtfContainer) parent, writer, attr);
- new RtfText (this, writer, str, attr);
+ super((RtfContainer) parent, writer, attr);
+ new RtfText(this, writer, str, attr);
}
/**
* @param attr a <code>RtfAttributes</code> value
* @throws IOException for I/O problems
*/
- public RtfHyperLink (RtfTextrun parent, Writer writer, RtfAttributes attr)
+ public RtfHyperLink(RtfTextrun parent, Writer writer, RtfAttributes attr)
throws IOException {
- super ((RtfContainer) parent, writer, attr);
+ super((RtfContainer) parent, writer, attr);
}
*
* @exception IOException On error
*/
- public void writeRtfPrefix () throws IOException {
- super.writeGroupMark (true);
- super.writeControlWord ("field");
+ public void writeRtfPrefix() throws IOException {
+ super.writeGroupMark(true);
+ super.writeControlWord("field");
- super.writeGroupMark (true);
- super.writeStarControlWord ("fldinst");
+ super.writeGroupMark(true);
+ super.writeStarControlWord("fldinst");
- writer.write ("HYPERLINK \"" + url + "\" ");
- super.writeGroupMark (false);
+ writer.write("HYPERLINK \"" + url + "\" ");
+ super.writeGroupMark(false);
- super.writeGroupMark (true);
- super.writeControlWord ("fldrslt");
+ super.writeGroupMark(true);
+ super.writeControlWord("fldrslt");
// start a group for this paragraph and write our own attributes if needed
- if (attrib != null && attrib.isSet ("cs")) {
- writeGroupMark (true);
+ if (attrib != null && attrib.isSet("cs")) {
+ writeGroupMark(true);
writeAttributes(attrib, new String [] {"cs"});
}
}
*
* @exception IOException On error
*/
- public void writeRtfSuffix () throws IOException {
- if (attrib != null && attrib.isSet ("cs")) {
- writeGroupMark (false);
+ public void writeRtfSuffix() throws IOException {
+ if (attrib != null && attrib.isSet("cs")) {
+ writeGroupMark(false);
}
- super.writeGroupMark (false);
- super.writeGroupMark (false);
+ super.writeGroupMark(false);
+ super.writeGroupMark(false);
}
* @throws IOException for I/O problems
* @return new RtfText object
*/
- public RtfText newText (String str) throws IOException {
- return newText (str, null);
+ public RtfText newText(String str) throws IOException {
+ return newText(str, null);
}
/**
* @throws IOException for I/O problems
* @return the new RtfText object
*/
- public RtfText newText (String str, RtfAttributes attr) throws IOException {
- closeAll ();
- mText = new RtfText (this, writer, str, attr);
+ public RtfText newText(String str, RtfAttributes attr) throws IOException {
+ closeAll();
+ mText = new RtfText(this, writer, str, attr);
return mText;
}
return null;
}
try {
- return (RtfAttributes) this.attrib.clone ();
+ return (RtfAttributes) this.attrib.clone();
} catch (CloneNotSupportedException e) {
throw new FOPException(e);
}
* add a line break
* @throws IOException for I/O problems
*/
- public void newLineBreak () throws IOException {
- new RtfLineBreak (this, writer);
+ public void newLineBreak() throws IOException {
+ new RtfLineBreak(this, writer);
}
// @@ Common container methods
//////////////////////////////////////////////////
- private void closeCurrentText () throws IOException {
+ private void closeCurrentText() throws IOException {
if (mText != null) {
- mText.close ();
+ mText.close();
}
}
- private void closeAll () throws IOException {
+ private void closeAll() throws IOException {
closeCurrentText();
}
*
* @param url Link url like "http://..."
*/
- public void setExternalURL (String url) {
+ public void setExternalURL(String url) {
this.url = url;
}
*
* @param jumpTo Name of the text mark
*/
- public void setInternalURL (String jumpTo) {
- int now = jumpTo.length ();
+ public void setInternalURL(String jumpTo) {
+ int now = jumpTo.length();
int max = RtfBookmark.MAX_BOOKMARK_LENGTH;
- this.url = "#" + jumpTo.substring (0, now > max ? max : now);
- this.url = this.url.replace ('.', RtfBookmark.REPLACE_CHARACTER);
- this.url = this.url.replace (' ', RtfBookmark.REPLACE_CHARACTER);
+ this.url = "#" + jumpTo.substring(0, now > max ? max : now);
+ this.url = this.url.replace('.', RtfBookmark.REPLACE_CHARACTER);
+ this.url = this.url.replace(' ', RtfBookmark.REPLACE_CHARACTER);
}
/**
*
* @return false (always)
*/
- public boolean isEmpty () {
+ public boolean isEmpty() {
return false;
}
private String id = null;
/** Create an RTF page number citation as a child of given container with default attributes */
- RtfPageNumberCitation (RtfContainer parent, Writer w, String id)
+ RtfPageNumberCitation(RtfContainer parent, Writer w, String id)
throws IOException {
super(parent, w);
this.id = id;
/** Create an RTF page number citation as a child of given
* paragraph, copying its attributes */
- RtfPageNumberCitation (RtfParagraph parent, Writer w, String id)
+ RtfPageNumberCitation(RtfParagraph parent, Writer w, String id)
throws IOException {
// add the attributes ant text attributes of the parent paragraph
super((RtfContainer)parent, w, parent.attrib);
* @return boolean
*/
public boolean canHide() {
- return this.controlWord.equals (DEFAULT_PARAGRAPH);
+ return this.controlWord.equals(DEFAULT_PARAGRAPH);
}
/**
protected void writeRtfSuffix() throws IOException {
// write suffix /sect only if this section is not last section (see bug #51484)
List siblings = parent.getChildren();
- if ((siblings.indexOf (this) + 1) < siblings.size()) {
+ if ((siblings.indexOf(this) + 1) < siblings.size()) {
writeControlWord("sect");
}
}
/**
* Constructor.
*/
- private RtfStyleSheetTable () {
- styles = new Hashtable ();
- attrTable = new Hashtable ();
- nameTable = new Vector ();
+ private RtfStyleSheetTable() {
+ styles = new Hashtable();
+ attrTable = new Hashtable();
+ nameTable = new Vector();
}
/**
*
* @return The instance of RtfStyleSheetTable
*/
- public static RtfStyleSheetTable getInstance () {
+ public static RtfStyleSheetTable getInstance() {
if (instance == null) {
- instance = new RtfStyleSheetTable ();
+ instance = new RtfStyleSheetTable();
}
return instance;
* Sets the default style.
* @param styleName Name of the default style, defined in the stylesheet
*/
- public void setDefaultStyle (String styleName) {
+ public void setDefaultStyle(String styleName) {
this.defaultStyleName = styleName;
}
* Gets the name of the default style.
* @return Default style name.
*/
- public String getDefaultStyleName () {
- if (attrTable.get (defaultStyleName) != null) {
+ public String getDefaultStyleName() {
+ if (attrTable.get(defaultStyleName) != null) {
return defaultStyleName;
}
- if (attrTable.get (STANDARD_STYLE) != null) {
+ if (attrTable.get(STANDARD_STYLE) != null) {
defaultStyleName = STANDARD_STYLE;
return defaultStyleName;
}
* @param name Name of style to add
* @param attrs Rtf attributes which defines the style
*/
- public void addStyle (String name, RtfAttributes attrs) {
- nameTable.addElement (name);
+ public void addStyle(String name, RtfAttributes attrs) {
+ nameTable.addElement(name);
if (attrs != null) {
- attrTable.put (name, attrs);
+ attrTable.put(name, attrs);
}
- styles.put (name, new Integer (nameTable.size () - 1 + startIndex));
+ styles.put(name, new Integer(nameTable.size() - 1 + startIndex));
}
/**
* @param attr Default rtf attributes
* @return Status value
*/
- public int addStyleToAttributes (String name, RtfAttributes attr) {
+ public int addStyleToAttributes(String name, RtfAttributes attr) {
// Sets status to ok
int status = STATUS_OK;
// Gets the style number from table
- Integer style = (Integer) styles.get (name);
+ Integer style = (Integer) styles.get(name);
- if (style == null && !name.equals (defaultStyleName)) {
+ if (style == null && !name.equals(defaultStyleName)) {
// If style not found, and style was not the default style, try the default style
name = defaultStyleName;
- style = (Integer) styles.get (name);
+ style = (Integer) styles.get(name);
// set status for default style setting
status = STATUS_DEFAULT;
}
}
// Adds the attributes to default attributes, if not available in default attributes
- attr.set ("cs", style.intValue ());
+ attr.set("cs", style.intValue());
- Object o = attrTable.get (name);
+ Object o = attrTable.get(name);
if (o != null) {
RtfAttributes rtfAttr = (RtfAttributes) o;
- for (Iterator names = rtfAttr.nameIterator (); names.hasNext ();) {
- String attrName = (String) names.next ();
- if (!attr.isSet (attrName)) {
- Integer i = (Integer) rtfAttr.getValue (attrName);
+ for (Iterator names = rtfAttr.nameIterator(); names.hasNext();) {
+ String attrName = (String) names.next();
+ if (!attr.isSet(attrName)) {
+ Integer i = (Integer) rtfAttr.getValue(attrName);
if (i == null) {
- attr.set (attrName);
+ attr.set(attrName);
} else {
- attr.set (attrName, i.intValue ());
+ attr.set(attrName, i.intValue());
}
}
}
* @param header Rtf header is the parent
* @throws IOException On write error
*/
- public void writeStyleSheet (RtfHeader header) throws IOException {
- if (styles == null || styles.size () == 0) {
+ public void writeStyleSheet(RtfHeader header) throws IOException {
+ if (styles == null || styles.size() == 0) {
return;
}
- header.writeGroupMark (true);
- header.writeControlWord ("stylesheet");
+ header.writeGroupMark(true);
+ header.writeControlWord("stylesheet");
- int number = nameTable.size ();
+ int number = nameTable.size();
for (int i = 0; i < number; i++) {
- String name = (String) nameTable.elementAt (i);
- header.writeGroupMark (true);
- header.writeControlWord ("*\\" + this.getRtfStyleReference (name));
+ String name = (String) nameTable.elementAt(i);
+ header.writeGroupMark(true);
+ header.writeControlWord("*\\" + this.getRtfStyleReference(name));
- Object o = attrTable.get (name);
+ Object o = attrTable.get(name);
if (o != null) {
- header.writeAttributes ((RtfAttributes) o, RtfText.ATTR_NAMES);
- header.writeAttributes ((RtfAttributes) o, RtfText.ALIGNMENT);
+ header.writeAttributes((RtfAttributes) o, RtfText.ATTR_NAMES);
+ header.writeAttributes((RtfAttributes) o, RtfText.ALIGNMENT);
}
- header.write (name + ";");
- header.writeGroupMark (false);
+ header.write(name + ";");
+ header.writeGroupMark(false);
}
- header.writeGroupMark (false);
+ header.writeGroupMark(false);
}
/**
* @param name Name of Style
* @return Rtf attribute of the style reference
*/
- private String getRtfStyleReference (String name) {
- return "cs" + styles.get (name).toString ();
+ private String getRtfStyleReference(String name) {
+ return "cs" + styles.get(name).toString();
}
}
RtfAttributes attr = null;
if (attrib != null) {
try {
- attr = (RtfAttributes) attrib.clone ();
+ attr = (RtfAttributes) attrib.clone();
} catch (CloneNotSupportedException e) {
throw new FOPException(e);
}
- attr.set (attrs);
+ attr.set(attrs);
} else {
attr = attrs;
}
* Added by Boris POUDEROUS on 2002/06/26
*/
// Cell background color processing :
- writeAttributes (attrib, ITableAttributes.CELL_COLOR);
+ writeAttributes(attrib, ITableAttributes.CELL_COLOR);
/** - end - */
- writeAttributes (attrib, ITableAttributes.ATTRIB_CELL_PADDING);
- writeAttributes (attrib, ITableAttributes.CELL_BORDER);
- writeAttributes (attrib, IBorderAttributes.BORDERS);
+ writeAttributes(attrib, ITableAttributes.ATTRIB_CELL_PADDING);
+ writeAttributes(attrib, ITableAttributes.CELL_BORDER);
+ writeAttributes(attrib, IBorderAttributes.BORDERS);
// determine cell width
int iCurrentWidth = this.cellWidth;
} else {
writeControlWord("trql");
}
- writeAttributes (attrib, ITableAttributes.CELL_VERT_ALIGN);
+ writeAttributes(attrib, ITableAttributes.CELL_VERT_ALIGN);
writeControlWord("cellx" + xPos);
public RtfTableCell newTableCellMergedVertically(int cellWidth,
RtfAttributes attrs) throws IOException {
highestCell++;
- cell = new RtfTableCell (this, writer, cellWidth, attrs, highestCell);
+ cell = new RtfTableCell(this, writer, cellWidth, attrs, highestCell);
cell.setVMerge(RtfTableCell.MERGE_WITH_PREVIOUS);
return cell;
}
* @throws IOException for I/O problems
* @throws FOPException if attributes cannot be cloned
*/
- public RtfTableCell newTableCellMergedHorizontally (int cellWidth,
+ public RtfTableCell newTableCellMergedHorizontally(int cellWidth,
RtfAttributes attrs) throws IOException, FOPException {
highestCell++;
// Added by Normand Masse
/**
* Constructor.
*/
- private RtfTemplate () {
+ private RtfTemplate() {
}
*
* @return The instance of RtfTemplate
*/
- public static RtfTemplate getInstance () {
+ public static RtfTemplate getInstance() {
if (instance == null) {
instance = new RtfTemplate();
}
* @param header Rtf header is the parent
* @throws IOException On write error
*/
- public void writeTemplate (RtfHeader header) throws IOException {
+ public void writeTemplate(RtfHeader header) throws IOException {
if (templateFilePath == null || templateFilePath.length() == 0) {
return;
}
- header.writeGroupMark (true);
- header.writeControlWord ("template");
+ header.writeGroupMark(true);
+ header.writeControlWord("template");
header.writeRtfString(this.templateFilePath);
- header.writeGroupMark (false);
+ header.writeGroupMark(false);
- header.writeGroupMark (true);
- header.writeControlWord ("linkstyles");
- header.writeGroupMark (false);
+ header.writeGroupMark(true);
+ header.writeControlWord("linkstyles");
+ header.writeGroupMark(false);
}
}
* @return true If m_text is null\n
* false m_text is set
*/
- public boolean isEmpty () {
+ public boolean isEmpty() {
return text == null || text.trim().length() == 0;
}
* @return true If m_text is character 160\n
* false m_text is not a nbsp
*/
- public boolean isNbsp () {
- if (!isEmpty ()) {
- if (text.trim ().length () == 1 && text.charAt (0) == CHAR_NBSP) {
+ public boolean isNbsp() {
+ if (!isEmpty()) {
+ if (text.trim().length() == 1 && text.charAt(0) == CHAR_NBSP) {
return true;
}
}
/**
* Private constructor.
*/
- private ImageUtil () {
+ private ImageUtil() {
}
* @return -1 There is no digit
* number The digits as integer
*/
- public static int getInt (String value) {
- String retString = new String ();
- StringBuffer s = new StringBuffer (value);
- int len = s.length ();
+ public static int getInt(String value) {
+ String retString = new String();
+ StringBuffer s = new StringBuffer(value);
+ int len = s.length();
for (int i = 0; i < len; i++) {
- if (Character.isDigit (s.charAt (i))) {
- retString += s.charAt (i);
+ if (Character.isDigit(s.charAt(i))) {
+ retString += s.charAt(i);
} else {
//for example "600.0pt" has to be exited,
//when the dot is reached.
}
}
- if (retString.length () == 0) {
+ if (retString.length() == 0) {
return -1;
} else {
- return Integer.parseInt (retString);
+ return Integer.parseInt(retString);
}
}
* @return true The string contains a % value
* false Other string
*/
- public static boolean isPercent (String value) {
- if (value.endsWith ("%")) {
+ public static boolean isPercent(String value) {
+ if (value.endsWith("%")) {
return true;
}
* @return true If equal
* false If different
*/
- public static boolean compareHexValues (byte[] pattern, byte[] data, int searchAt,
+ public static boolean compareHexValues(byte[] pattern, byte[] data, int searchAt,
boolean searchForward) {
if (searchAt >= data.length) {
return false;
*
* @return integer
*/
- public static int getIntFromByteArray (byte[] data, int startAt, int length,
+ public static int getIntFromByteArray(byte[] data, int startAt, int length,
boolean searchForward) {
int bit = 8;
int bitMoving = length * bit;
return XML_MIME_TYPE;
}
- private void maybeAddLevelAttribute (Area a) {
+ private void maybeAddLevelAttribute(Area a) {
int level = a.getBidiLevel();
if (level >= 0) {
- addAttribute ("level", level);
+ addAttribute("level", level);
}
}
- private void maybeAddPositionAdjustAttribute (WordArea w) {
+ private void maybeAddPositionAdjustAttribute(WordArea w) {
int[][] adjustments = w.getGlyphPositionAdjustments();
if (adjustments != null) {
- addAttribute ("position-adjust", XMLUtil.encodePositionAdjustments (adjustments));
+ addAttribute("position-adjust", XMLUtil.encodePositionAdjustments(adjustments));
}
}
- private void maybeAddReversedAttribute (WordArea w, String text) {
+ private void maybeAddReversedAttribute(WordArea w, String text) {
if (w.isReversed() && (text.length() > 1)) {
addAttribute("reversed", "true");
}
* @return a new graphics node
*/
@Override
- protected GraphicsNode createImageGraphicsNode
- (BridgeContext ctx, Element imageElement, ParsedURL purl) {
+ protected GraphicsNode createImageGraphicsNode(
+ BridgeContext ctx, Element imageElement, ParsedURL purl) {
AbstractFOPBridgeContext bridgeCtx = (AbstractFOPBridgeContext)ctx;
ImageManager manager = bridgeCtx.getImageManager();
* @return the newly created graphics node
* @see org.apache.batik.bridge.SVGImageElementBridge#createGraphicsNode(BridgeContext, Element)
*/
- protected GraphicsNode superCreateGraphicsNode
- (BridgeContext ctx, Element imageElement, ParsedURL purl) {
+ protected GraphicsNode superCreateGraphicsNode(
+ BridgeContext ctx, Element imageElement, ParsedURL purl) {
return super.createImageGraphicsNode(ctx, imageElement, purl);
}
PDFDeviceColorSpace colSpace;
colSpace = new PDFDeviceColorSpace(PDFDeviceColorSpace.DEVICE_RGB);
- PDFPattern myPat = pdfDoc.getFactory().makeGradient
- (resourceContext, true, colSpace,
+ PDFPattern myPat = pdfDoc.getFactory().makeGradient(
+ resourceContext, true, colSpace,
someColors, theBounds, theCoords, theMatrix);
currentStream.write(myPat.getColorSpaceOut(fill));
int devH = devBounds.height;
ColorSpace rgbCS = ColorSpace.getInstance(ColorSpace.CS_sRGB);
- ColorModel rgbCM = new DirectColorModel
- (rgbCS, 32, 0x00FF0000, 0x0000FF00, 0x000000FF, 0xFF000000,
+ ColorModel rgbCM = new DirectColorModel(
+ rgbCS, 32, 0x00FF0000, 0x0000FF00, 0x000000FF, 0xFF000000,
false, DataBuffer.TYPE_BYTE);
PaintContext pctx = paint.createContext(rgbCM, devBounds, usrBounds,
at, getRenderingHints());
- PDFXObject imageInfo = pdfDoc.getXObject
- ("TempImage:" + pctx.toString());
+ PDFXObject imageInfo = pdfDoc.getXObject(
+ "TempImage:" + pctx.toString());
if (imageInfo != null) {
resourceContext.getPDFResources().addXObject(imageInfo);
} else {
wr = wr.createWritableTranslatedChild(0, 0);
ColorModel pcm = pctx.getColorModel();
- BufferedImage bi = new BufferedImage
- (pcm, wr, pcm.isAlphaPremultiplied(), null);
+ BufferedImage bi = new BufferedImage(
+ pcm, wr, pcm.isAlphaPremultiplied(), null);
final byte[] rgb = new byte[devW * devH * 3];
final int[] line = new int[devW];
final byte[] mask;
String maskRef = null;
if (mask != null) {
- BitmapImage fopimg = new BitmapImage
- ("TempImageMask:" + pctx.toString(), devW, devH, mask, null);
+ BitmapImage fopimg = new BitmapImage(
+ "TempImageMask:" + pctx.toString(), devW, devH, mask, null);
fopimg.setColorSpace(new PDFDeviceColorSpace(PDFDeviceColorSpace.DEVICE_GRAY));
PDFImageXObject xobj = pdfDoc.addImage(resourceContext, fopimg);
maskRef = xobj.referencePDF();
graphics.setSVGDimension(width, height);
if (hints.containsKey(ImageTranscoder.KEY_BACKGROUND_COLOR)) {
- graphics.setBackgroundColor
- ((Color)hints.get(ImageTranscoder.KEY_BACKGROUND_COLOR));
+ graphics.setBackgroundColor(
+ (Color)hints.get(ImageTranscoder.KEY_BACKGROUND_COLOR));
}
- graphics.setGraphicContext
- (new org.apache.xmlgraphics.java2d.GraphicContext());
+ graphics.setGraphicContext(
+ new org.apache.xmlgraphics.java2d.GraphicContext());
graphics.preparePainting();
graphics.transform(curTxf);
- graphics.setRenderingHint
- (RenderingHintsKeyExt.KEY_TRANSCODING,
+ graphics.setRenderingHint(
+ RenderingHintsKeyExt.KEY_TRANSCODING,
RenderingHintsKeyExt.VALUE_TRANSCODING_VECTOR);
this.root.paint(graphics);
* writing mode traits setter.
* @param wms a writing mode traits setter
*/
- public void assignWritingModeTraits (WritingModeTraitsSetter wms) {
+ public void assignWritingModeTraits(WritingModeTraitsSetter wms) {
Direction inlineProgressionDirection;
Direction blockProgressionDirection;
Direction columnProgressionDirection;
shiftDirection = Direction.BT;
break;
}
- wms.setInlineProgressionDirection (inlineProgressionDirection);
- wms.setBlockProgressionDirection (blockProgressionDirection);
- wms.setColumnProgressionDirection (columnProgressionDirection);
- wms.setRowProgressionDirection (rowProgressionDirection);
- wms.setShiftDirection (shiftDirection);
- wms.setWritingMode (this);
+ wms.setInlineProgressionDirection(inlineProgressionDirection);
+ wms.setBlockProgressionDirection(blockProgressionDirection);
+ wms.setColumnProgressionDirection(columnProgressionDirection);
+ wms.setRowProgressionDirection(rowProgressionDirection);
+ wms.setShiftDirection(shiftDirection);
+ wms.setWritingMode(this);
}
/**
* Construct writing mode traits using the specified writing mode.
* @param writingMode a writing mode traits object
*/
- public WritingModeTraits (WritingMode writingMode) {
- assignWritingModeTraits (writingMode);
+ public WritingModeTraits(WritingMode writingMode) {
+ assignWritingModeTraits(writingMode);
}
/**
/**
* @param direction the "inline-progression-direction" trait.
*/
- public void setInlineProgressionDirection (Direction direction) {
+ public void setInlineProgressionDirection(Direction direction) {
this.inlineProgressionDirection = direction;
}
/**
* @param direction the "block-progression-direction" trait.
*/
- public void setBlockProgressionDirection (Direction direction) {
+ public void setBlockProgressionDirection(Direction direction) {
this.blockProgressionDirection = direction;
}
/**
* @param direction the "column-progression-direction" trait.
*/
- public void setColumnProgressionDirection (Direction direction) {
+ public void setColumnProgressionDirection(Direction direction) {
this.columnProgressionDirection = direction;
}
/**
* @param direction the "row-progression-direction" trait.
*/
- public void setRowProgressionDirection (Direction direction) {
+ public void setRowProgressionDirection(Direction direction) {
this.rowProgressionDirection = direction;
}
/**
* @param direction the "shift-direction" trait.
*/
- public void setShiftDirection (Direction direction) {
+ public void setShiftDirection(Direction direction) {
this.shiftDirection = direction;
}
/**
* @param writingMode the "writing-mode" trait.
*/
- public void setWritingMode (WritingMode writingMode) {
+ public void setWritingMode(WritingMode writingMode) {
this.writingMode = writingMode;
}
/**
* @param writingMode the "writing-mode" trait.
*/
- public void assignWritingModeTraits (WritingMode writingMode) {
- writingMode.assignWritingModeTraits (this);
+ public void assignWritingModeTraits(WritingMode writingMode) {
+ writingMode.assignWritingModeTraits(this);
}
/**
* @return the applicable writing mode traits getter, or null if none applies
*/
public static WritingModeTraitsGetter
- getWritingModeTraitsGetter (org.apache.fop.fo.FONode fn) {
+ getWritingModeTraitsGetter(org.apache.fop.fo.FONode fn) {
for (org.apache.fop.fo.FONode n = fn; n != null; n = n.getParent()) {
if (n instanceof WritingModeTraitsGetter) {
return (WritingModeTraitsGetter) n;
* Set value of inline-progression-direction trait.
* @param direction the "inline-progression-direction" trait
*/
- void setInlineProgressionDirection (Direction direction);
+ void setInlineProgressionDirection(Direction direction);
/**
* Set value of block-progression-direction trait.
* @param direction the "block-progression-direction" trait
*/
- void setBlockProgressionDirection (Direction direction);
+ void setBlockProgressionDirection(Direction direction);
/**
* Set value of column-progression-direction trait.
* @param direction the "column-progression-direction" trait
*/
- void setColumnProgressionDirection (Direction direction);
+ void setColumnProgressionDirection(Direction direction);
/**
* Set value of row-progression-direction trait.
* @param direction the "row-progression-direction" trait
*/
- void setRowProgressionDirection (Direction direction);
+ void setRowProgressionDirection(Direction direction);
/**
* Set value of shift-direction trait.
* @param direction the "shift-direction" trait
*/
- void setShiftDirection (Direction direction);
+ void setShiftDirection(Direction direction);
/**
* Set value of writing-mode trait.
* @param writingMode the "writing-mode" trait
*/
- void setWritingMode (WritingMode writingMode);
+ void setWritingMode(WritingMode writingMode);
/**
* Collectivelly assign values to all writing mode traits based upon a specific
* writing mode.
* @param writingMode the "writing-mode" trait
*/
- void assignWritingModeTraits (WritingMode writingMode);
+ void assignWritingModeTraits(WritingMode writingMode);
}
* @param c character to inspect
* @return the determined character class
*/
- public static int classOf (int c) {
+ public static int classOf(int c) {
switch (c) {
case CODE_EOT:
return EOT;
* @param c character to inspect
* @return True if the character is a normal space
*/
- public static boolean isBreakableSpace (int c) {
+ public static boolean isBreakableSpace(int c) {
return (c == SPACE || isFixedWidthSpace(c));
}
* @param c the character to check
* @return true if the character is a zero-width space
*/
- public static boolean isZeroWidthSpace (int c) {
+ public static boolean isZeroWidthSpace(int c) {
return c == ZERO_WIDTH_SPACE // 200Bh
|| c == WORD_JOINER // 2060h
|| c == ZERO_WIDTH_NOBREAK_SPACE; // FEFFh (also used as BOM)
* @param c the character to check
* @return true if the character has a fixed-width
*/
- public static boolean isFixedWidthSpace (int c) {
+ public static boolean isFixedWidthSpace(int c) {
return (c >= '\u2000' && c <= '\u200B')
|| c == '\u3000';
// c == '\u2000' // en quad
* @param c character to check
* @return True if the character is a nbsp
*/
- public static boolean isNonBreakableSpace (int c) {
+ public static boolean isNonBreakableSpace(int c) {
return
(c == NBSPACE // no-break space
|| c == '\u202F' // narrow no-break space
* @param c character to check
* @return True if the character is adjustable
*/
- public static boolean isAdjustableSpace (int c) {
+ public static boolean isAdjustableSpace(int c) {
//TODO: are there other kinds of adjustable spaces?
return
(c == '\u0020' // normal space
* @param c character to check
* @return True if the character represents any kind of space
*/
- public static boolean isAnySpace (int c) {
+ public static boolean isAnySpace(int c) {
return (isBreakableSpace(c) || isNonBreakableSpace(c));
}
* @param c the character
* @return true if the character is "Alphabetic"
*/
- public static boolean isAlphabetic (int c) {
+ public static boolean isAlphabetic(int c) {
//http://www.unicode.org/Public/UNIDATA/UCD.html#Alphabetic
//Generated from: Other_Alphabetic + Lu + Ll + Lt + Lm + Lo + Nl
int generalCategory = Character.getType((char)c);
* @param c the character to check
* @return true if the character represents an explicit break
*/
- public static boolean isExplicitBreak (int c) {
+ public static boolean isExplicitBreak(int c) {
return (c == LINEFEED_CHAR
|| c == CARRIAGE_RETURN
|| c == NEXT_LINE
* @param c a unicode scalar value
* @return a string representing a numeric character reference
*/
- public static String charToNCRef (int c) {
+ public static String charToNCRef(int c) {
StringBuffer sb = new StringBuffer();
for (int i = 0, nDigits = (c > 0xFFFF) ? 6 : 4; i < nDigits; i++, c >>= 4) {
int d = c & 0xF;
} else {
hd = (char) ((int) 'A' + (d - 10));
}
- sb.append (hd);
+ sb.append(hd);
}
return "&#x" + sb.reverse() + ";";
}
* @return a string representing a sequence of numeric character reference or
* ASCII characters
*/
- public static String toNCRefs (String s) {
+ public static String toNCRefs(String s) {
StringBuffer sb = new StringBuffer();
if (s != null) {
for (int i = 0; i < s.length(); i++) {
char c = s.charAt(i);
if ((c >= 32) && (c < 127)) {
if (c == '<') {
- sb.append ("<");
+ sb.append("<");
} else if (c == '>') {
- sb.append (">");
+ sb.append(">");
} else if (c == '&') {
- sb.append ("&");
+ sb.append("&");
} else {
- sb.append (c);
+ sb.append(c);
}
} else {
- sb.append (charToNCRef (c));
+ sb.append(charToNCRef(c));
}
}
}
* @param pad character to use for padding
* @return padded string
*/
- public static String padLeft (String s, int width, char pad) {
+ public static String padLeft(String s, int width, char pad) {
StringBuffer sb = new StringBuffer();
for (int i = s.length(); i < width; i++) {
sb.append(pad);
}
- sb.append (s);
+ sb.append(s);
return sb.toString();
}
* @param c character code
* @return formatted character string
*/
- public static String format (int c) {
+ public static String format(int c) {
if (c < 1114112) {
- return "0x" + padLeft (Integer.toString (c, 16), (c < 65536) ? 4 : 6, '0');
+ return "0x" + padLeft(Integer.toString(c, 16), (c < 65536) ? 4 : 6, '0');
} else {
return "!NOT A CHARACTER!";
}
* @param cs2 second character sequence
* @return true if both sequences have same length and same character sequence
*/
- public static boolean isSameSequence (CharSequence cs1, CharSequence cs2) {
+ public static boolean isSameSequence(CharSequence cs1, CharSequence cs2) {
assert cs1 != null;
assert cs2 != null;
if (cs1.length() != cs2.length()) {
* @param paCount the number of entries to encode from adjustments array
* @return the encoded value
*/
- public static String encodePositionAdjustments (int[][] dp, int paCount) {
+ public static String encodePositionAdjustments(int[][] dp, int paCount) {
assert dp != null;
StringBuffer sb = new StringBuffer();
int na = paCount;
int nz = 0;
- sb.append (na);
+ sb.append(na);
for (int i = 0; i < na; i++) {
int[] pa = dp [ i ];
if (pa != null) {
for (int k = 0; k < 4; k++) {
int a = pa [ k ];
if (a != 0) {
- encodeNextAdjustment (sb, nz, a);
+ encodeNextAdjustment(sb, nz, a);
nz = 0;
} else {
nz++;
nz += 4;
}
}
- encodeNextAdjustment (sb, nz, 0);
+ encodeNextAdjustment(sb, nz, 0);
return sb.toString();
}
* @param dp the adjustments array
* @return the encoded value
*/
- public static String encodePositionAdjustments (int[][] dp) {
+ public static String encodePositionAdjustments(int[][] dp) {
assert dp != null;
- return encodePositionAdjustments (dp, dp.length);
+ return encodePositionAdjustments(dp, dp.length);
}
- private static void encodeNextAdjustment (StringBuffer sb, int nz, int a) {
- encodeZeroes (sb, nz);
- encodeAdjustment (sb, a);
+ private static void encodeNextAdjustment(StringBuffer sb, int nz, int a) {
+ encodeZeroes(sb, nz);
+ encodeAdjustment(sb, a);
}
- private static void encodeZeroes (StringBuffer sb, int nz) {
+ private static void encodeZeroes(StringBuffer sb, int nz) {
if (nz > 0) {
- sb.append (' ');
+ sb.append(' ');
if (nz == 1) {
- sb.append ('0');
+ sb.append('0');
} else {
- sb.append ('Z');
- sb.append (nz);
+ sb.append('Z');
+ sb.append(nz);
}
}
}
- private static void encodeAdjustment (StringBuffer sb, int a) {
+ private static void encodeAdjustment(StringBuffer sb, int a) {
if (a != 0) {
- sb.append (' ');
- sb.append (a);
+ sb.append(' ');
+ sb.append(a);
}
}
* @param value the encoded value
* @return the position adjustments array
*/
- public static int[][] decodePositionAdjustments (String value) {
+ public static int[][] decodePositionAdjustments(String value) {
int[][] dp = null;
if (value != null) {
- String[] sa = value.split ("\\s");
+ String[] sa = value.split("\\s");
if (sa != null) {
if (sa.length > 0) {
- int na = Integer.parseInt (sa[0]);
+ int na = Integer.parseInt(sa[0]);
dp = new int [ na ] [ 4 ];
for (int i = 1, n = sa.length, k = 0; i < n; i++) {
String s = sa [ i ];
if (s.charAt(0) == 'Z') {
- int nz = Integer.parseInt (s.substring (1));
+ int nz = Integer.parseInt(s.substring(1));
k += nz;
} else {
- dp [ k / 4 ] [ k % 4 ] = Integer.parseInt (s);
+ dp [ k / 4 ] [ k % 4 ] = Integer.parseInt(s);
k += 1;
}
}
}
public void character(Character c) {
- appendCharacters (new String (new char[] {c.getCharacter()}));
+ appendCharacters(new String(new char[] {c.getCharacter()}));
}
/** {@inheritDoc} */
public void characters(FOText foText) {
- appendCharacters (foText.getCharSequence().toString());
+ appendCharacters(foText.getCharSequence().toString());
}
/** {@inheritDoc} */
public void endPageNumber(PageNumber pagenum) {
}
- private void appendCharacters (String str) {
+ private void appendCharacters(String str) {
if (para != null) {
str = str.trim();
// break into nice length chunks
String ldPfx = BidiTestData.LD_PFX;
int ldCount = BidiTestData.LD_CNT;
for (int i = 0; i < ldCount; i++) {
- int[] da = BidiTestData.readTestData (ldPfx, i);
+ int[] da = BidiTestData.readTestData(ldPfx, i);
if (da != null) {
- testBidiAlgorithm (i, da);
+ testBidiAlgorithm(i, da);
} else {
- fail ("unable to read bidi test data for resource at index " + i);
+ fail("unable to read bidi test data for resource at index " + i);
}
}
// ensure we passed all test sequences
- assertEquals ("did not pass all test sequences", BidiTestData.NUM_TEST_SEQUENCES, passedSequences);
+ assertEquals("did not pass all test sequences", BidiTestData.NUM_TEST_SEQUENCES, passedSequences);
if (log.isDebugEnabled()) {
- log.debug ("Included Sequences : " + includedSequences);
- log.debug ("Excluded Sequences : " + excludedSequences);
+ log.debug("Included Sequences : " + includedSequences);
+ log.debug("Excluded Sequences : " + excludedSequences);
log.debug("Passed Sequences : " + passedSequences);
}
}
- private void testBidiAlgorithm (int testSet, int[] da) throws Exception {
+ private void testBidiAlgorithm(int testSet, int[] da) throws Exception {
if (da.length < 1) {
- fail ("test data is empty");
+ fail("test data is empty");
} else if (da.length < ((da[0] * 2) + 1)) {
- fail ("test data is truncated");
+ fail("test data is truncated");
} else {
int k = 0;
// extract level count
for (int i = 0; i < n; i++) {
ta[i] = da[k++];
}
- if (includeSequence (testSet, testSequence)) {
+ if (includeSequence(testSet, testSequence)) {
includedSequences++;
- if (! excludeSequence (testSet, testSequence)) {
- if (testBidiAlgorithm (testSet, testSequence, la, ra, ta, bs)) {
+ if (! excludeSequence(testSet, testSequence)) {
+ if (testBidiAlgorithm(testSet, testSequence, la, ra, ta, bs)) {
passedSequences++;
}
} else {
testSequence++;
}
// ensure we exhausted test data
- assertEquals ("extraneous test data", da.length, k);
+ assertEquals("extraneous test data", da.length, k);
}
}
- private boolean includeTestSet (int testSet) {
+ private boolean includeTestSet(int testSet) {
for (int i = 0, n = TEST_SET_RANGES.length / 2; i < n; i++) {
int s = TEST_SET_RANGES [ (i * 2) + 0 ];
int e = TEST_SET_RANGES [ (i * 2) + 1 ];
return false;
}
- private boolean includeSequence (int testSet, int testSequence) {
- if (! includeTestSet (testSet)) {
+ private boolean includeSequence(int testSet, int testSequence) {
+ if (! includeTestSet(testSet)) {
return false;
} else {
for (int i = 0, n = INCLUSIONS.length / 2; i < n; i++) {
}
}
- private boolean excludeSequence (int testSet, int testSequence) {
+ private boolean excludeSequence(int testSet, int testSequence) {
for (int i = 0, n = EXCLUSIONS.length / 2; i < n; i++) {
int setno = EXCLUSIONS [ (i * 2) + 0 ];
int seqno = EXCLUSIONS [ (i * 2) + 1 ];
return false;
}
- private boolean testBidiAlgorithm (int testSet, int testSequence, int[] la, int[] ra, int[] ta, int bs) throws Exception {
+ private boolean testBidiAlgorithm(int testSet, int testSequence, int[] la, int[] ra, int[] ta, int bs) throws Exception {
boolean passed = true;
int n = la.length;
if (ra.length != n) {
- fail ("bad reorder array length, expected " + n + ", got " + ra.length);
+ fail("bad reorder array length, expected " + n + ", got " + ra.length);
} else if (ta.length != n) {
- fail ("bad test array length, expected " + n + ", got " + ta.length);
+ fail("bad test array length, expected " + n + ", got " + ta.length);
} else {
// auto-LTR
if ((bs & 1) != 0) {
}
// LTR
if ((bs & 2) != 0) {
- int[] levels = UnicodeBidiAlgorithm.resolveLevels (null, ta, 0, new int [ n ], true);
- if (! verifyResults (la, levels, ta, 0, testSet, testSequence)) {
+ int[] levels = UnicodeBidiAlgorithm.resolveLevels(null, ta, 0, new int [ n ], true);
+ if (! verifyResults(la, levels, ta, 0, testSet, testSequence)) {
passed = false;
}
}
// RTL
if ((bs & 4) != 0) {
- int[] levels = UnicodeBidiAlgorithm.resolveLevels (null, ta, 1, new int [ n ], true);
- if (! verifyResults (la, levels, ta, 1, testSet, testSequence)) {
+ int[] levels = UnicodeBidiAlgorithm.resolveLevels(null, ta, 1, new int [ n ], true);
+ if (! verifyResults(la, levels, ta, 1, testSet, testSequence)) {
passed = false;
}
}
return passed;
}
- private boolean verifyResults (int[] laExp, int[] laOut, int[] ta, int dl, int testSet, int testSequence) {
+ private boolean verifyResults(int[] laExp, int[] laOut, int[] ta, int dl, int testSet, int testSequence) {
if (laOut.length != laExp.length) {
- fail ("output levels array length mismatch, expected " + laExp.length + ", got " + laOut.length);
+ fail("output levels array length mismatch, expected " + laExp.length + ", got " + laOut.length);
return false;
} else {
int numMatch = 0;
int lo = laOut[i];
int le = laExp[i];
if (lo != le) {
- assertEquals (getMismatchMessage (testSet, testSequence, i, dl), le, lo);
+ assertEquals(getMismatchMessage(testSet, testSequence, i, dl), le, lo);
} else {
numMatch++;
}
}
}
- private String getMismatchMessage (int testSet, int testSequence, int seqIndex, int defaultLevel) {
+ private String getMismatchMessage(int testSet, int testSequence, int seqIndex, int defaultLevel) {
StringBuffer sb = new StringBuffer();
- sb.append ("level mismatch for default level ");
- sb.append (defaultLevel);
- sb.append (" at sequence index ");
- sb.append (seqIndex);
- sb.append (" in test sequence ");
- sb.append (testSequence);
- sb.append (" of test set ");
- sb.append (testSet);
+ sb.append("level mismatch for default level ");
+ sb.append(defaultLevel);
+ sb.append(" at sequence index ");
+ sb.append(seqIndex);
+ sb.append(" in test sequence ");
+ sb.append(testSequence);
+ sb.append(" of test set ");
+ sb.append(testSet);
return sb.toString();
}
String tdPfx = BidiTestData.TD_PFX;
int tdCount = BidiTestData.TD_CNT;
for (int i = 0; i < tdCount; i++) {
- int[] da = BidiTestData.readTestData (tdPfx, i);
+ int[] da = BidiTestData.readTestData(tdPfx, i);
if (da != null) {
- testBidiClass (da);
+ testBidiClass(da);
} else {
- fail ("unable to read bidi test data for resource at index " + i);
+ fail("unable to read bidi test data for resource at index " + i);
}
}
}
- private void testBidiClass (int[] da) throws Exception {
+ private void testBidiClass(int[] da) throws Exception {
int bc = da[0];
for (int i = 1, n = da.length; i < n; i += 2) {
int s = da[i+0];
int e = da[i+1];
for (int c = s; c < e; c++) {
- int cbc = BidiClass.getBidiClass (c);
- assertEquals ("bad bidi class for CH(" + CharUtilities.format (c) + ")", bc, cbc);
+ int cbc = BidiClass.getBidiClass(c);
+ assertEquals("bad bidi class for CH(" + CharUtilities.format(c) + ")", bc, cbc);
}
}
}
public static final int NUM_TEST_SEQUENCES = 216357;
- public static int[] readTestData (String prefix, int index) {
+ public static int[] readTestData(String prefix, int index) {
int[] data = null;
InputStream is = null;
Class btc = BidiTestData.class;
String name = btc.getSimpleName() + "$" + prefix + index + ".ser";
try {
- if ((is = btc.getResourceAsStream (name)) != null) {
- ObjectInputStream ois = new ObjectInputStream (is);
+ if ((is = btc.getResourceAsStream(name)) != null) {
+ ObjectInputStream ois = new ObjectInputStream(is);
data = (int[]) ois.readObject();
ois.close();
}
@Test
public void testGDEFGlyphClass() throws Exception {
- performLookups (ltGlyphClass);
+ performLookups(ltGlyphClass);
}
@Test
public void testGDEFAttachmentPoint() throws Exception {
- performLookups (ltAttachmentPoint);
+ performLookups(ltAttachmentPoint);
}
@Test
public void testGDEFLigatureCaret() throws Exception {
- performLookups (ltLigatureCaret);
+ performLookups(ltLigatureCaret);
}
@Test
public void testGDEFMarkAttachment() throws Exception {
- performLookups (ltMarkAttachment);
+ performLookups(ltMarkAttachment);
}
/**
* Perform lookups on all test data in test specification TS.
* @param ts test specification
*/
- private void performLookups (Object[][] ts) {
+ private void performLookups(Object[][] ts) {
assert ts.length > 0;
Object[] tp = ts[0];
for (int i = 1; i < ts.length; i++) {
- performLookups (tp, ts[i]);
+ performLookups(tp, ts[i]);
}
}
* @param tp test parameters
* @param td test data
*/
- private void performLookups (Object[] tp, Object[] td) {
+ private void performLookups(Object[] tp, Object[] td) {
assert tp.length > 0;
if (td.length > 1) {
String fid = (String) td[0];
String lid = (String) td[1];
- TTXFile tf = findTTX (fid);
- assertTrue (tf != null);
+ TTXFile tf = findTTX(fid);
+ assertTrue(tf != null);
GlyphDefinitionTable gdef = tf.getGDEF();
- assertTrue (gdef != null);
+ assertTrue(gdef != null);
String[][] tia = (String[][]) td[2];
switch ((int) ((Integer) tp[0])) {
case GlyphDefinitionTable.GDEF_LOOKUP_TYPE_GLYPH_CLASS:
- performGlyphClassLookups (tf, lid, tia);
+ performGlyphClassLookups(tf, lid, tia);
break;
case GlyphDefinitionTable.GDEF_LOOKUP_TYPE_ATTACHMENT_POINT:
- performAttachmentPointLookups (tf, lid, tia);
+ performAttachmentPointLookups(tf, lid, tia);
break;
case GlyphDefinitionTable.GDEF_LOOKUP_TYPE_LIGATURE_CARET:
- performLigatureCaretLookups (tf, lid, tia);
+ performLigatureCaretLookups(tf, lid, tia);
break;
case GlyphDefinitionTable.GDEF_LOOKUP_TYPE_MARK_ATTACHMENT:
- performMarkAttachmentLookups (tf, lid, tia);
+ performMarkAttachmentLookups(tf, lid, tia);
break;
default:
- assertTrue ("bad lookup type", false);
+ assertTrue("bad lookup type", false);
break;
}
}
}
- private void performGlyphClassLookups (TTXFile tf, String lid, String[][] tia) {
+ private void performGlyphClassLookups(TTXFile tf, String lid, String[][] tia) {
GlyphDefinitionTable gdef = tf.getGDEF();
assert gdef != null;
for (String[] ti : tia) {
assert gn != null;
String cn = ti[1];
assert cn != null;
- int g = tf.getGlyph (gn);
- assertTrue (g >= 0);
- int oc = Integer.parseInt (cn);
- int tc = gdef.getGlyphClass (g);
- assertEquals ("bad glyph class for glyph \'" + gn + "\', gid(" + g + ")", oc, tc);
+ int g = tf.getGlyph(gn);
+ assertTrue(g >= 0);
+ int oc = Integer.parseInt(cn);
+ int tc = gdef.getGlyphClass(g);
+ assertEquals("bad glyph class for glyph \'" + gn + "\', gid(" + g + ")", oc, tc);
}
}
- private void performAttachmentPointLookups (TTXFile tf, String lid, String[][] tia) {
+ private void performAttachmentPointLookups(TTXFile tf, String lid, String[][] tia) {
// not yet supported by GDEF or test TTX files
}
- private void performLigatureCaretLookups (TTXFile tf, String lid, String[][] tia) {
+ private void performLigatureCaretLookups(TTXFile tf, String lid, String[][] tia) {
// not yet supported by GDEF or test TTX files
}
- private void performMarkAttachmentLookups (TTXFile tf, String lid, String[][] tia) {
+ private void performMarkAttachmentLookups(TTXFile tf, String lid, String[][] tia) {
// not yet supported by GDEF or test TTX files
}
- private String findTTXPath (String fid) {
+ private String findTTXPath(String fid) {
for (String[] fs : ttxFonts) {
if ((fs != null) && (fs.length > 1)) {
- if (fs[0].equals (fid)) {
+ if (fs[0].equals(fid)) {
return ttxFilesRoot + File.separator + fs[1];
}
}
return null;
}
- private TTXFile findTTX (String fid) {
- String pn = findTTXPath (fid);
- assertTrue (pn != null);
+ private TTXFile findTTX(String fid) {
+ String pn = findTTXPath(fid);
+ assertTrue(pn != null);
try {
- TTXFile tf = TTXFile.getFromCache (pn);
+ TTXFile tf = TTXFile.getFromCache(pn);
return tf;
} catch (Exception e) {
- fail (e.getMessage());
+ fail(e.getMessage());
return null;
}
}
@Test
public void testGPOSSingle() throws Exception {
- performPositioning (ltSingle);
+ performPositioning(ltSingle);
}
@Test
public void testGPOSPair() throws Exception {
- performPositioning (ltPair);
+ performPositioning(ltPair);
}
@Test
public void testGPOSCursive() throws Exception {
- performPositioning (ltCursive);
+ performPositioning(ltCursive);
}
@Test
public void testGPOSMarkToBase() throws Exception {
- performPositioning (ltMarkToBase);
+ performPositioning(ltMarkToBase);
}
@Test
public void testGPOSMarkToLigature() throws Exception {
- performPositioning (ltMarkToLigature);
+ performPositioning(ltMarkToLigature);
}
@Test
public void testGPOSMarkToMark() throws Exception {
- performPositioning (ltMarkToMark);
+ performPositioning(ltMarkToMark);
}
@Test
public void testGPOSContextual() throws Exception {
- performPositioning (ltContextual);
+ performPositioning(ltContextual);
}
@Test
public void testGPOSChainedContextual() throws Exception {
- performPositioning (ltChainedContextual);
+ performPositioning(ltChainedContextual);
}
/**
* Perform positioning on all test data in test specification TS.
* @param ts test specification
*/
- private void performPositioning (Object[][] ts) {
+ private void performPositioning(Object[][] ts) {
assert ts.length > 0;
Object[] tp = ts[0];
for (int i = 1; i < ts.length; i++) {
- performPositioning (tp, ts[i]);
+ performPositioning(tp, ts[i]);
}
}
* @param tp test parameters
* @param td test data
*/
- private void performPositioning (Object[] tp, Object[] td) {
+ private void performPositioning(Object[] tp, Object[] td) {
assert tp.length > 0;
if (td.length > 5) {
String fid = (String) td[0];
String script = (String) td[2];
String language = (String) td[3];
String feature = (String) td[4];
- TTXFile tf = findTTX (fid);
- assertTrue (tf != null);
+ TTXFile tf = findTTX(fid);
+ assertTrue(tf != null);
GlyphPositioningTable gpos = tf.getGPOS();
- assertTrue (gpos != null);
- GlyphPositioningSubtable[] sta = findGPOSSubtables (gpos, script, language, feature, lid);
- assertTrue (sta != null);
- assertTrue (sta.length > 0);
- ScriptContextTester sct = findScriptContextTester (script, language, feature);
+ assertTrue(gpos != null);
+ GlyphPositioningSubtable[] sta = findGPOSSubtables(gpos, script, language, feature, lid);
+ assertTrue(sta != null);
+ assertTrue(sta.length > 0);
+ ScriptContextTester sct = findScriptContextTester(script, language, feature);
Object[][] tia = (Object[][]) td[5]; // test instance array
for (Object[] ti : tia) { // test instance
if (ti != null) {
if (ti.length > 0) { // must have at least input glyphs
String[] igia = (String[]) ti[0]; // input glyph id array
int[][] ogpa = (int[][]) ti[1]; // output glyph positioning array
- GlyphSequence igs = tf.getGlyphSequence (igia);
+ GlyphSequence igs = tf.getGlyphSequence(igia);
int[] widths = tf.getWidths();
int[][] tgpa = new int [ igia.length ] [ 4 ];
- boolean adjusted = GlyphPositioningSubtable.position (igs, script, language, feature, 1000, sta, widths, tgpa, sct);
- assertTrue (adjusted);
- assertSamePositions (ogpa, tgpa);
+ boolean adjusted = GlyphPositioningSubtable.position(igs, script, language, feature, 1000, sta, widths, tgpa, sct);
+ assertTrue(adjusted);
+ assertSamePositions(ogpa, tgpa);
}
}
}
}
}
- private String findTTXPath (String fid) {
+ private String findTTXPath(String fid) {
for (String[] fs : ttxFonts) {
if ((fs != null) && (fs.length > 1)) {
- if (fs[0].equals (fid)) {
+ if (fs[0].equals(fid)) {
return ttxFilesRoot + File.separator + fs[1];
}
}
return null;
}
- private TTXFile findTTX (String fid) {
- String pn = findTTXPath (fid);
- assertTrue (pn != null);
+ private TTXFile findTTX(String fid) {
+ String pn = findTTXPath(fid);
+ assertTrue(pn != null);
try {
- TTXFile tf = TTXFile.getFromCache (pn);
+ TTXFile tf = TTXFile.getFromCache(pn);
return tf;
} catch (Exception e) {
- fail (e.getMessage());
+ fail(e.getMessage());
return null;
}
}
- private GlyphPositioningSubtable[] findGPOSSubtables (GlyphPositioningTable gpos, String script, String language, String feature, String lid) {
- LookupTable lt = gpos.getLookupTable (lid);
+ private GlyphPositioningSubtable[] findGPOSSubtables(GlyphPositioningTable gpos, String script, String language, String feature, String lid) {
+ LookupTable lt = gpos.getLookupTable(lid);
if (lt != null) {
return (GlyphPositioningSubtable[]) lt.getSubtables();
} else {
}
}
- private ScriptContextTester findScriptContextTester (String script, String language, String feature) {
+ private ScriptContextTester findScriptContextTester(String script, String language, String feature) {
return this;
}
- public GlyphContextTester getTester (String feature) {
+ public GlyphContextTester getTester(String feature) {
return this;
}
- public boolean test (String script, String language, String feature, GlyphSequence gs, int index, int flags) {
+ public boolean test(String script, String language, String feature, GlyphSequence gs, int index, int flags) {
return true;
}
- private void assertSamePositions (int[][] pa1, int[][] pa2) {
- assertNotNull (pa1);
- assertNotNull (pa2);
- assertEquals ("unequal adjustment count", pa1.length, pa2.length);
+ private void assertSamePositions(int[][] pa1, int[][] pa2) {
+ assertNotNull(pa1);
+ assertNotNull(pa2);
+ assertEquals("unequal adjustment count", pa1.length, pa2.length);
for (int i = 0; i < pa1.length; i++) {
int[] a1 = pa1 [ i ];
int[] a2 = pa2 [ i ];
- assertNotNull (a1);
- assertNotNull (a2);
- assertEquals ("bad adjustment array length", 4, a1.length);
- assertEquals ("bad adjustment array length", 4, a2.length);
+ assertNotNull(a1);
+ assertNotNull(a2);
+ assertEquals("bad adjustment array length", 4, a1.length);
+ assertEquals("bad adjustment array length", 4, a2.length);
for (int k = 0; k < a1.length; k++) {
int p1 = a1[k];
int p2 = a2[k];
- assertEquals ("bad adjustment", p1, p2);
+ assertEquals("bad adjustment", p1, p2);
}
}
}
@Test
public void testGSUBSingle() throws Exception {
- performSubstitutions (ltSingle);
+ performSubstitutions(ltSingle);
}
@Test
public void testGSUBMultiple() throws Exception {
- performSubstitutions (ltMultiple);
+ performSubstitutions(ltMultiple);
}
@Test
public void testGSUBAlternate() throws Exception {
- performSubstitutions (ltAlternate);
+ performSubstitutions(ltAlternate);
}
@Test
public void testGSUBLigature() throws Exception {
- performSubstitutions (ltLigature);
+ performSubstitutions(ltLigature);
}
@Test
public void testGSUBContextual() throws Exception {
- performSubstitutions (ltContextual);
+ performSubstitutions(ltContextual);
}
@Test
public void testGSUBChainedContextual() throws Exception {
- performSubstitutions (ltChainedContextual);
+ performSubstitutions(ltChainedContextual);
}
/**
* Perform substitutions on all test data in test specification TS.
* @param ts test specification
*/
- private void performSubstitutions (Object[][] ts) {
+ private void performSubstitutions(Object[][] ts) {
assert ts.length > 0;
Object[] tp = ts[0];
for (int i = 1; i < ts.length; i++) {
- performSubstitutions (tp, ts[i]);
+ performSubstitutions(tp, ts[i]);
}
}
* @param tp test parameters
* @param td test data
*/
- private void performSubstitutions (Object[] tp, Object[] td) {
+ private void performSubstitutions(Object[] tp, Object[] td) {
assert tp.length > 0;
if (td.length > 5) {
String fid = (String) td[0];
String script = (String) td[2];
String language = (String) td[3];
String feature = (String) td[4];
- TTXFile tf = findTTX (fid);
- assertTrue (tf != null);
+ TTXFile tf = findTTX(fid);
+ assertTrue(tf != null);
GlyphSubstitutionTable gsub = tf.getGSUB();
- assertTrue (gsub != null);
- GlyphSubstitutionSubtable[] sta = findGSUBSubtables (gsub, script, language, feature, lid);
- assertTrue (sta != null);
- assertTrue (sta.length > 0);
- ScriptContextTester sct = findScriptContextTester (script, language, feature);
+ assertTrue(gsub != null);
+ GlyphSubstitutionSubtable[] sta = findGSUBSubtables(gsub, script, language, feature, lid);
+ assertTrue(sta != null);
+ assertTrue(sta.length > 0);
+ ScriptContextTester sct = findScriptContextTester(script, language, feature);
String[][][] tia = (String[][][]) td[5]; // test instance array
for (String[][] ti : tia) { // test instance
if (ti != null) {
if (ti.length > 1) { // must have at least input and output glyph id arrays
String[] igia = ti[0]; // input glyph id array
String[] ogia = ti[1]; // output glyph id array
- GlyphSequence igs = tf.getGlyphSequence (igia);
- GlyphSequence ogs = tf.getGlyphSequence (ogia);
- GlyphSequence tgs = GlyphSubstitutionSubtable.substitute (igs, script, language, feature, sta, sct);
- assertSameGlyphs (ogs, tgs);
+ GlyphSequence igs = tf.getGlyphSequence(igia);
+ GlyphSequence ogs = tf.getGlyphSequence(ogia);
+ GlyphSequence tgs = GlyphSubstitutionSubtable.substitute(igs, script, language, feature, sta, sct);
+ assertSameGlyphs(ogs, tgs);
}
}
}
}
}
- private String findTTXPath (String fid) {
+ private String findTTXPath(String fid) {
for (String[] fs : ttxFonts) {
if ((fs != null) && (fs.length > 1)) {
- if (fs[0].equals (fid)) {
+ if (fs[0].equals(fid)) {
return ttxFilesRoot + File.separator + fs[1];
}
}
return null;
}
- private TTXFile findTTX (String fid) {
- String pn = findTTXPath (fid);
- assertTrue (pn != null);
+ private TTXFile findTTX(String fid) {
+ String pn = findTTXPath(fid);
+ assertTrue(pn != null);
try {
- TTXFile tf = TTXFile.getFromCache (pn);
+ TTXFile tf = TTXFile.getFromCache(pn);
return tf;
} catch (Exception e) {
- fail (e.getMessage());
+ fail(e.getMessage());
return null;
}
}
- private GlyphSubstitutionSubtable[] findGSUBSubtables (GlyphSubstitutionTable gsub, String script, String language, String feature, String lid) {
- LookupTable lt = gsub.getLookupTable (lid);
+ private GlyphSubstitutionSubtable[] findGSUBSubtables(GlyphSubstitutionTable gsub, String script, String language, String feature, String lid) {
+ LookupTable lt = gsub.getLookupTable(lid);
if (lt != null) {
return (GlyphSubstitutionSubtable[]) lt.getSubtables();
} else {
}
}
- private ScriptContextTester findScriptContextTester (String script, String language, String feature) {
+ private ScriptContextTester findScriptContextTester(String script, String language, String feature) {
return this;
}
- public GlyphContextTester getTester (String feature) {
+ public GlyphContextTester getTester(String feature) {
return this;
}
- public boolean test (String script, String language, String feature, GlyphSequence gs, int index, int flags) {
+ public boolean test(String script, String language, String feature, GlyphSequence gs, int index, int flags) {
return true;
}
- private void assertSameGlyphs (GlyphSequence gs1, GlyphSequence gs2) {
- assertNotNull (gs1);
- assertNotNull (gs2);
+ private void assertSameGlyphs(GlyphSequence gs1, GlyphSequence gs2) {
+ assertNotNull(gs1);
+ assertNotNull(gs2);
IntBuffer gb1 = gs1.getGlyphs();
IntBuffer gb2 = gs2.getGlyphs();
- assertEquals ("unequal glyph count", gb1.limit(), gb2.limit());
+ assertEquals("unequal glyph count", gb1.limit(), gb2.limit());
for (int i = 0; i < gb1.limit(); i++) {
int g1 = gb1.get(i);
int g2 = gb2.get(i);
- assertEquals ("unequal glyph code", g1, g2);
+ assertEquals("unequal glyph code", g1, g2);
}
}
v2 = null;
upem = -1;
}
- public void parse (String filename) {
- parse (new File (filename));
+ public void parse(String filename) {
+ parse(new File(filename));
}
- public void parse (File f) {
+ public void parse(File f) {
assert f != null;
try {
SAXParserFactory spf = SAXParserFactory.newInstance();
SAXParser sp = spf.newSAXParser();
- sp.parse (f, new Handler());
+ sp.parse(f, new Handler());
} catch (FactoryConfigurationError e) {
- throw new RuntimeException (e.getMessage());
+ throw new RuntimeException(e.getMessage());
} catch (ParserConfigurationException e) {
- throw new RuntimeException (e.getMessage());
+ throw new RuntimeException(e.getMessage());
} catch (SAXException e) {
- throw new RuntimeException (e.getMessage());
+ throw new RuntimeException(e.getMessage());
} catch (IOException e) {
- throw new RuntimeException (e.getMessage());
+ throw new RuntimeException(e.getMessage());
}
}
- public GlyphSequence mapCharsToGlyphs (String s) {
- Integer[] ca = UTF32.toUTF32 (s, 0, true);
+ public GlyphSequence mapCharsToGlyphs(String s) {
+ Integer[] ca = UTF32.toUTF32(s, 0, true);
int ng = ca.length;
- IntBuffer cb = IntBuffer.allocate (ng);
- IntBuffer gb = IntBuffer.allocate (ng);
+ IntBuffer cb = IntBuffer.allocate(ng);
+ IntBuffer gb = IntBuffer.allocate(ng);
for (Integer c : ca) {
- int g = mapCharToGlyph ((int) c);
+ int g = mapCharToGlyph((int) c);
if (g >= 0) {
- cb.put (c);
- gb.put (g);
+ cb.put(c);
+ gb.put(g);
} else {
- throw new IllegalArgumentException ("character " + CharUtilities.format (c) + " has no corresponding glyph");
+ throw new IllegalArgumentException("character " + CharUtilities.format(c) + " has no corresponding glyph");
}
}
cb.rewind();
gb.rewind();
- return new GlyphSequence (cb, gb, null);
+ return new GlyphSequence(cb, gb, null);
}
- public int mapCharToGlyph (int c) {
+ public int mapCharToGlyph(int c) {
if (cmap != null) {
- Integer g = cmap.get (Integer.valueOf (c));
+ Integer g = cmap.get(Integer.valueOf(c));
if (g != null) {
return (int) g;
} else {
return -1;
}
}
- public int getGlyph (String gid) {
- return mapGlyphId0 (gid);
+ public int getGlyph(String gid) {
+ return mapGlyphId0(gid);
}
- public GlyphSequence getGlyphSequence (String[] gids) {
+ public GlyphSequence getGlyphSequence(String[] gids) {
assert gids != null;
int ng = gids.length;
- IntBuffer cb = IntBuffer.allocate (ng);
- IntBuffer gb = IntBuffer.allocate (ng);
+ IntBuffer cb = IntBuffer.allocate(ng);
+ IntBuffer gb = IntBuffer.allocate(ng);
for (String gid : gids) {
- int g = mapGlyphId0 (gid);
+ int g = mapGlyphId0(gid);
if (g >= 0) {
- int c = mapGlyphIdToChar (gid);
+ int c = mapGlyphIdToChar(gid);
if (c < 0) {
c = CharUtilities.NOT_A_CHARACTER;
}
- cb.put (c);
- gb.put (g);
+ cb.put(c);
+ gb.put(g);
} else {
- throw new IllegalArgumentException ("unmapped glyph id \"" + gid + "\"");
+ throw new IllegalArgumentException("unmapped glyph id \"" + gid + "\"");
}
}
cb.rewind();
gb.rewind();
- return new GlyphSequence (cb, gb, null);
+ return new GlyphSequence(cb, gb, null);
}
- public int[] getWidths (String[] gids) {
+ public int[] getWidths(String[] gids) {
assert gids != null;
int ng = gids.length;
int[] widths = new int [ ng ];
int i = 0;
for (String gid : gids) {
- int g = mapGlyphId0 (gid);
+ int g = mapGlyphId0(gid);
int w = 0;
if (g >= 0) {
if ((hmtx != null) && (g < hmtx.length)) {
if ((hmtx != null) && (upem > 0)) {
int[] widths = new int [ hmtx.length ];
for (int i = 0, n = widths.length; i < n; i++) {
- widths [ i ] = getPDFWidth (hmtx [ i ] [ 0 ], upem);
+ widths [ i ] = getPDFWidth(hmtx [ i ] [ 0 ], upem);
}
this.widths = widths;
}
}
return this.widths;
}
- public static int getPDFWidth (int tw, int upem) {
+ public static int getPDFWidth(int tw, int upem) {
// N.B. The following is copied (with minor edits) from TTFFile to insure same results
int pw;
if (tw < 0) {
public GlyphPositioningTable getGPOS() {
return gpos;
}
- public static synchronized TTXFile getFromCache (String filename) {
+ public static synchronized TTXFile getFromCache(String filename) {
assert cache != null;
TTXFile f;
- if ((f = (TTXFile) cache.get (filename)) == null) {
+ if ((f = (TTXFile) cache.get(filename)) == null) {
f = new TTXFile();
- f.parse (filename);
- cache.put (filename, f);
+ f.parse(filename);
+ cache.put(filename, f);
}
return f;
}
public void endDocument() {
}
@Override
- public void setDocumentLocator (Locator locator) {
+ public void setDocumentLocator(Locator locator) {
TTXFile.this.locator = locator;
}
@Override
- public void startElement (String uri, String localName, String qName, Attributes attrs) throws SAXException {
- String[] en = makeExpandedName (uri, localName, qName);
+ public void startElement(String uri, String localName, String qName, Attributes attrs) throws SAXException {
+ String[] en = makeExpandedName(uri, localName, qName);
if (en[0] != null) {
- unsupportedElement (en);
- } else if (en[1].equals ("Alternate")) {
+ unsupportedElement(en);
+ } else if (en[1].equals("Alternate")) {
String[] pn = new String[] { null, "AlternateSet" };
- if (isParent (pn)) {
- String glyph = attrs.getValue ("glyph");
+ if (isParent(pn)) {
+ String glyph = attrs.getValue("glyph");
if (glyph == null) {
- missingRequiredAttribute (en, "glyph");
+ missingRequiredAttribute(en, "glyph");
}
- int gid = mapGlyphId (glyph, en);
- alternates.add (Integer.valueOf (gid));
+ int gid = mapGlyphId(glyph, en);
+ alternates.add(Integer.valueOf(gid));
} else {
- notPermittedInElementContext (en, getParent(), pn);
+ notPermittedInElementContext(en, getParent(), pn);
}
- } else if (en[1].equals ("AlternateSet")) {
+ } else if (en[1].equals("AlternateSet")) {
String[] pn = new String[] { null, "AlternateSubst" };
- if (isParent (pn)) {
- String glyph = attrs.getValue ("glyph");
+ if (isParent(pn)) {
+ String glyph = attrs.getValue("glyph");
if (glyph == null) {
- missingRequiredAttribute (en, "glyph");
+ missingRequiredAttribute(en, "glyph");
}
- int gid = mapGlyphId (glyph, en);
- coverageEntries.add (Integer.valueOf (gid));
+ int gid = mapGlyphId(glyph, en);
+ coverageEntries.add(Integer.valueOf(gid));
} else {
- notPermittedInElementContext (en, getParent(), pn);
+ notPermittedInElementContext(en, getParent(), pn);
}
- } else if (en[1].equals ("AlternateSubst")) {
+ } else if (en[1].equals("AlternateSubst")) {
String[] pn = new String[] { null, "Lookup" };
- if (isParent (pn)) {
- String index = attrs.getValue ("index");
+ if (isParent(pn)) {
+ String index = attrs.getValue("index");
if (index == null) {
- missingRequiredAttribute (en, "index");
+ missingRequiredAttribute(en, "index");
}
- String format = attrs.getValue ("Format");
+ String format = attrs.getValue("Format");
int sf = -1;
if (format == null) {
- missingRequiredAttribute (en, "Format");
+ missingRequiredAttribute(en, "Format");
} else {
- sf = Integer.parseInt (format);
+ sf = Integer.parseInt(format);
switch (sf) {
case 1:
break;
default:
- unsupportedFormat (en, sf);
+ unsupportedFormat(en, sf);
break;
}
}
assert sf >= 0;
stFormat = sf;
} else {
- notPermittedInElementContext (en, getParent(), pn);
+ notPermittedInElementContext(en, getParent(), pn);
}
- } else if (en[1].equals ("BacktrackCoverage")) {
+ } else if (en[1].equals("BacktrackCoverage")) {
String[] pn1 = new String[] { null, "ChainContextSubst" };
String[] pn2 = new String[] { null, "ChainContextPos" };
String[][] pnx = new String[][] { pn1, pn2 };
- if (isParent (pnx)) {
- String index = attrs.getValue ("index");
+ if (isParent(pnx)) {
+ String index = attrs.getValue("index");
int ci = -1;
if (index == null) {
- missingRequiredAttribute (en, "index");
+ missingRequiredAttribute(en, "index");
} else {
- ci = Integer.parseInt (index);
+ ci = Integer.parseInt(index);
}
- String format = attrs.getValue ("Format");
+ String format = attrs.getValue("Format");
int cf = -1;
if (format == null) {
- missingRequiredAttribute (en, "Format");
+ missingRequiredAttribute(en, "Format");
} else {
- cf = Integer.parseInt (format);
+ cf = Integer.parseInt(format);
switch (cf) {
case 1:
case 2:
break;
default:
- unsupportedFormat (en, cf);
+ unsupportedFormat(en, cf);
break;
}
}
ctIndex = ci;
ctFormat = cf;
} else {
- notPermittedInElementContext (en, getParent(), pnx);
+ notPermittedInElementContext(en, getParent(), pnx);
}
- } else if (en[1].equals ("BaseAnchor")) {
+ } else if (en[1].equals("BaseAnchor")) {
String[] pn = new String[] { null, "BaseRecord" };
- if (isParent (pn)) {
- String index = attrs.getValue ("index");
+ if (isParent(pn)) {
+ String index = attrs.getValue("index");
if (index == null) {
- missingRequiredAttribute (en, "index");
+ missingRequiredAttribute(en, "index");
}
- String format = attrs.getValue ("Format");
+ String format = attrs.getValue("Format");
if (format == null) {
- missingRequiredAttribute (en, "Format");
+ missingRequiredAttribute(en, "Format");
}
assert xCoord == Integer.MIN_VALUE;
assert yCoord == Integer.MIN_VALUE;
} else {
- notPermittedInElementContext (en, getParent(), pn);
+ notPermittedInElementContext(en, getParent(), pn);
}
- } else if (en[1].equals ("BaseArray")) {
+ } else if (en[1].equals("BaseArray")) {
String[] pn = new String[] { null, "MarkBasePos" };
- if (! isParent (pn)) {
- notPermittedInElementContext (en, getParent(), pn);
+ if (! isParent(pn)) {
+ notPermittedInElementContext(en, getParent(), pn);
}
- } else if (en[1].equals ("BaseCoverage")) {
+ } else if (en[1].equals("BaseCoverage")) {
String[] pn = new String[] { null, "MarkBasePos" };
- if (isParent (pn)) {
- String format = attrs.getValue ("Format");
+ if (isParent(pn)) {
+ String format = attrs.getValue("Format");
int cf = -1;
if (format == null) {
- missingRequiredAttribute (en, "Format");
+ missingRequiredAttribute(en, "Format");
} else {
- cf = Integer.parseInt (format);
+ cf = Integer.parseInt(format);
switch (cf) {
case 1:
case 2:
break;
default:
- unsupportedFormat (en, cf);
+ unsupportedFormat(en, cf);
break;
}
}
ctIndex = 0;
ctFormat = cf;
} else {
- notPermittedInElementContext (en, getParent(), pn);
+ notPermittedInElementContext(en, getParent(), pn);
}
- } else if (en[1].equals ("BaseRecord")) {
+ } else if (en[1].equals("BaseRecord")) {
String[] pn = new String[] { null, "BaseArray" };
- if (isParent (pn)) {
- String index = attrs.getValue ("index");
+ if (isParent(pn)) {
+ String index = attrs.getValue("index");
if (index == null) {
- missingRequiredAttribute (en, "index");
+ missingRequiredAttribute(en, "index");
}
} else {
- notPermittedInElementContext (en, getParent(), pn);
+ notPermittedInElementContext(en, getParent(), pn);
}
- } else if (en[1].equals ("ChainContextPos") || en[1].equals ("ChainContextSubst")) {
+ } else if (en[1].equals("ChainContextPos") || en[1].equals("ChainContextSubst")) {
String[] pn = new String[] { null, "Lookup" };
- if (isParent (pn)) {
- String index = attrs.getValue ("index");
+ if (isParent(pn)) {
+ String index = attrs.getValue("index");
if (index == null) {
- missingRequiredAttribute (en, "index");
+ missingRequiredAttribute(en, "index");
}
- String format = attrs.getValue ("Format");
+ String format = attrs.getValue("Format");
int sf = -1;
if (format == null) {
- missingRequiredAttribute (en, "Format");
+ missingRequiredAttribute(en, "Format");
} else {
- sf = Integer.parseInt (format);
+ sf = Integer.parseInt(format);
switch (sf) {
case 1:
case 2:
case 3:
break;
default:
- unsupportedFormat (en, sf);
+ unsupportedFormat(en, sf);
break;
}
}
assert sf >= 0;
stFormat = sf;
} else {
- notPermittedInElementContext (en, getParent(), pn);
+ notPermittedInElementContext(en, getParent(), pn);
}
- } else if (en[1].equals ("Class")) {
+ } else if (en[1].equals("Class")) {
String[] pn = new String[] { null, "MarkRecord" };
- if (isParent (pn)) {
- String value = attrs.getValue ("value");
+ if (isParent(pn)) {
+ String value = attrs.getValue("value");
int v = -1;
if (value == null) {
- missingRequiredAttribute (en, "value");
+ missingRequiredAttribute(en, "value");
} else {
- v = Integer.parseInt (value);
+ v = Integer.parseInt(value);
}
assert markClass == -1;
markClass = v;
} else {
- notPermittedInElementContext (en, getParent(), pn);
+ notPermittedInElementContext(en, getParent(), pn);
}
- } else if (en[1].equals ("ClassDef")) {
+ } else if (en[1].equals("ClassDef")) {
String[] pn1 = new String[] { null, "GlyphClassDef" };
String[] pn2 = new String[] { null, "MarkAttachClassDef" };
String[][] pnx = new String[][] { pn1, pn2 };
- if (isParent (pnx)) {
- String glyph = attrs.getValue ("glyph");
+ if (isParent(pnx)) {
+ String glyph = attrs.getValue("glyph");
if (glyph == null) {
- missingRequiredAttribute (en, "glyph");
+ missingRequiredAttribute(en, "glyph");
}
- String glyphClass = attrs.getValue ("class");
+ String glyphClass = attrs.getValue("class");
if (glyphClass == null) {
- missingRequiredAttribute (en, "class");
+ missingRequiredAttribute(en, "class");
}
- if (! glyphIds.containsKey (glyph)) {
- unsupportedGlyph (en, glyph);
- } else if (isParent (pn1)) {
- if (glyphClasses.containsKey (glyph)) {
- duplicateGlyphClass (en, glyph, glyphClass);
+ if (! glyphIds.containsKey(glyph)) {
+ unsupportedGlyph(en, glyph);
+ } else if (isParent(pn1)) {
+ if (glyphClasses.containsKey(glyph)) {
+ duplicateGlyphClass(en, glyph, glyphClass);
} else {
- glyphClasses.put (glyph, Integer.parseInt(glyphClass));
+ glyphClasses.put(glyph, Integer.parseInt(glyphClass));
}
- } else if (isParent (pn2)) {
- if (glyphClasses.containsKey (glyph)) {
- duplicateGlyphClass (en, glyph, glyphClass);
+ } else if (isParent(pn2)) {
+ if (glyphClasses.containsKey(glyph)) {
+ duplicateGlyphClass(en, glyph, glyphClass);
} else {
- glyphClasses.put (glyph, Integer.parseInt(glyphClass));
+ glyphClasses.put(glyph, Integer.parseInt(glyphClass));
}
}
} else {
- notPermittedInElementContext (en, getParent(), pnx);
+ notPermittedInElementContext(en, getParent(), pnx);
}
- } else if (en[1].equals ("ComponentRecord")) {
+ } else if (en[1].equals("ComponentRecord")) {
String[] pn = new String[] { null, "LigatureAttach" };
- if (isParent (pn)) {
- String index = attrs.getValue ("index");
+ if (isParent(pn)) {
+ String index = attrs.getValue("index");
if (index == null) {
- missingRequiredAttribute (en, "index");
+ missingRequiredAttribute(en, "index");
}
assert anchors.size() == 0;
} else {
- notPermittedInElementContext (en, getParent(), pn);
+ notPermittedInElementContext(en, getParent(), pn);
}
- } else if (en[1].equals ("Coverage")) {
+ } else if (en[1].equals("Coverage")) {
String[] pn1 = new String[] { null, "CursivePos" };
String[] pn2 = new String[] { null, "LigCaretList" };
String[] pn3 = new String[] { null, "MultipleSubst" };
String[] pn4 = new String[] { null, "PairPos" };
String[] pn5 = new String[] { null, "SinglePos" };
String[][] pnx = new String[][] { pn1, pn2, pn3, pn4, pn5 };
- if (isParent (pnx)) {
- String format = attrs.getValue ("Format");
+ if (isParent(pnx)) {
+ String format = attrs.getValue("Format");
int cf = -1;
if (format == null) {
- missingRequiredAttribute (en, "Format");
+ missingRequiredAttribute(en, "Format");
} else {
- cf = Integer.parseInt (format);
+ cf = Integer.parseInt(format);
switch (cf) {
case 1:
case 2:
break;
default:
- unsupportedFormat (en, cf);
+ unsupportedFormat(en, cf);
break;
}
}
ctIndex = 0;
ctFormat = cf;
} else {
- notPermittedInElementContext (en, getParent(), pnx);
+ notPermittedInElementContext(en, getParent(), pnx);
}
- } else if (en[1].equals ("CursivePos")) {
+ } else if (en[1].equals("CursivePos")) {
String[] pn = new String[] { null, "Lookup" };
- if (isParent (pn)) {
- String index = attrs.getValue ("index");
+ if (isParent(pn)) {
+ String index = attrs.getValue("index");
if (index == null) {
- missingRequiredAttribute (en, "index");
+ missingRequiredAttribute(en, "index");
}
- String format = attrs.getValue ("Format");
+ String format = attrs.getValue("Format");
int sf = -1;
if (format == null) {
- missingRequiredAttribute (en, "Format");
+ missingRequiredAttribute(en, "Format");
} else {
- sf = Integer.parseInt (format);
+ sf = Integer.parseInt(format);
switch (sf) {
case 1:
break;
default:
- unsupportedFormat (en, sf);
+ unsupportedFormat(en, sf);
break;
}
}
stFormat = sf;
assert attachmentAnchors.size() == 0;
} else {
- notPermittedInElementContext (en, getParent(), pn);
+ notPermittedInElementContext(en, getParent(), pn);
}
- } else if (en[1].equals ("DefaultLangSys")) {
+ } else if (en[1].equals("DefaultLangSys")) {
String[] pn = new String[] { null, "Script" };
- if (! isParent (pn)) {
- notPermittedInElementContext (en, getParent(), pn);
+ if (! isParent(pn)) {
+ notPermittedInElementContext(en, getParent(), pn);
} else {
assertLanguageFeaturesClear();
assert languageTag == null;
languageTag = defaultLanguageTag;
}
- } else if (en[1].equals ("EntryAnchor")) {
+ } else if (en[1].equals("EntryAnchor")) {
String[] pn = new String[] { null, "EntryExitRecord" };
- if (isParent (pn)) {
- String format = attrs.getValue ("Format");
+ if (isParent(pn)) {
+ String format = attrs.getValue("Format");
if (format == null) {
- missingRequiredAttribute (en, "Format");
+ missingRequiredAttribute(en, "Format");
}
assert xCoord == Integer.MIN_VALUE;
assert yCoord == Integer.MIN_VALUE;
} else {
- notPermittedInElementContext (en, getParent(), pn);
+ notPermittedInElementContext(en, getParent(), pn);
}
- } else if (en[1].equals ("EntryExitRecord")) {
+ } else if (en[1].equals("EntryExitRecord")) {
String[] pn = new String[] { null, "CursivePos" };
- if (isParent (pn)) {
- String index = attrs.getValue ("index");
+ if (isParent(pn)) {
+ String index = attrs.getValue("index");
if (index == null) {
- missingRequiredAttribute (en, "index");
+ missingRequiredAttribute(en, "index");
}
} else {
- notPermittedInElementContext (en, getParent(), pn);
+ notPermittedInElementContext(en, getParent(), pn);
}
- } else if (en[1].equals ("ExitAnchor")) {
+ } else if (en[1].equals("ExitAnchor")) {
String[] pn = new String[] { null, "EntryExitRecord" };
- if (isParent (pn)) {
- String format = attrs.getValue ("Format");
+ if (isParent(pn)) {
+ String format = attrs.getValue("Format");
if (format == null) {
- missingRequiredAttribute (en, "Format");
+ missingRequiredAttribute(en, "Format");
}
assert xCoord == Integer.MIN_VALUE;
assert yCoord == Integer.MIN_VALUE;
} else {
- notPermittedInElementContext (en, getParent(), pn);
+ notPermittedInElementContext(en, getParent(), pn);
}
- } else if (en[1].equals ("Feature")) {
+ } else if (en[1].equals("Feature")) {
String[] pn = new String[] { null, "FeatureRecord" };
- if (! isParent (pn)) {
- notPermittedInElementContext (en, getParent(), pn);
+ if (! isParent(pn)) {
+ notPermittedInElementContext(en, getParent(), pn);
} else {
assertFeatureLookupsClear();
}
- } else if (en[1].equals ("FeatureIndex")) {
+ } else if (en[1].equals("FeatureIndex")) {
String[] pn1 = new String[] { null, "DefaultLangSys" };
String[] pn2 = new String[] { null, "LangSys" };
String[][] pnx = new String[][] { pn1, pn2 };
- if (isParent (pnx)) {
- String index = attrs.getValue ("index");
+ if (isParent(pnx)) {
+ String index = attrs.getValue("index");
if (index == null) {
- missingRequiredAttribute (en, "index");
+ missingRequiredAttribute(en, "index");
}
- String value = attrs.getValue ("value");
+ String value = attrs.getValue("value");
int v = -1;
if (value == null) {
- missingRequiredAttribute (en, "value");
+ missingRequiredAttribute(en, "value");
} else {
- v = Integer.parseInt (value);
+ v = Integer.parseInt(value);
}
if (languageFeatures.size() == 0) {
- languageFeatures.add (null);
+ languageFeatures.add(null);
}
if ((v >= 0) && (v < 65535)) {
- languageFeatures.add (makeFeatureId (v));
+ languageFeatures.add(makeFeatureId(v));
}
} else {
- notPermittedInElementContext (en, getParent(), pnx);
+ notPermittedInElementContext(en, getParent(), pnx);
}
- } else if (en[1].equals ("FeatureList")) {
+ } else if (en[1].equals("FeatureList")) {
String[] pn1 = new String[] { null, "GSUB" };
String[] pn2 = new String[] { null, "GPOS" };
String[][] pnx = new String[][] { pn1, pn2 };
- if (! isParent (pnx)) {
- notPermittedInElementContext (en, getParent(), pnx);
+ if (! isParent(pnx)) {
+ notPermittedInElementContext(en, getParent(), pnx);
}
- } else if (en[1].equals ("FeatureRecord")) {
+ } else if (en[1].equals("FeatureRecord")) {
String[] pn = new String[] { null, "FeatureList" };
- if (isParent (pn)) {
- String index = attrs.getValue ("index");
+ if (isParent(pn)) {
+ String index = attrs.getValue("index");
int fi = -1;
if (index == null) {
- missingRequiredAttribute (en, "index");
+ missingRequiredAttribute(en, "index");
} else {
- fi = Integer.parseInt (index);
+ fi = Integer.parseInt(index);
}
assertFeatureClear();
assert flIndex == -1;
flIndex = fi;
} else {
- notPermittedInElementContext (en, getParent(), pn);
+ notPermittedInElementContext(en, getParent(), pn);
}
- } else if (en[1].equals ("FeatureTag")) {
+ } else if (en[1].equals("FeatureTag")) {
String[] pn = new String[] { null, "FeatureRecord" };
- if (isParent (pn)) {
- String value = attrs.getValue ("value");
+ if (isParent(pn)) {
+ String value = attrs.getValue("value");
if (value == null) {
- missingRequiredAttribute (en, "value");
+ missingRequiredAttribute(en, "value");
} else {
assert featureTag == null;
featureTag = value;
}
} else {
- notPermittedInElementContext (en, getParent(), pn);
+ notPermittedInElementContext(en, getParent(), pn);
}
- } else if (en[1].equals ("GDEF")) {
+ } else if (en[1].equals("GDEF")) {
String[] pn = new String[] { null, "ttFont" };
- if (isParent (pn)) {
+ if (isParent(pn)) {
assertSubtablesClear();
} else {
- notPermittedInElementContext (en, getParent(), pn);
+ notPermittedInElementContext(en, getParent(), pn);
}
- } else if (en[1].equals ("GPOS")) {
+ } else if (en[1].equals("GPOS")) {
String[] pn = new String[] { null, "ttFont" };
- if (isParent (pn)) {
+ if (isParent(pn)) {
assertCoveragesClear();
assertSubtablesClear();
} else {
- notPermittedInElementContext (en, getParent(), pn);
+ notPermittedInElementContext(en, getParent(), pn);
}
- } else if (en[1].equals ("GSUB")) {
+ } else if (en[1].equals("GSUB")) {
String[] pn = new String[] { null, "ttFont" };
- if (isParent (pn)) {
+ if (isParent(pn)) {
assertCoveragesClear();
assertSubtablesClear();
} else {
- notPermittedInElementContext (en, getParent(), pn);
+ notPermittedInElementContext(en, getParent(), pn);
}
- } else if (en[1].equals ("Glyph")) {
+ } else if (en[1].equals("Glyph")) {
String[] pn1 = new String[] { null, "Coverage" };
String[] pn2 = new String[] { null, "InputCoverage" };
String[] pn3 = new String[] { null, "LookAheadCoverage" };
String[] pn8 = new String[] { null, "BaseCoverage" };
String[] pn9 = new String[] { null, "LigatureCoverage" };
String[][] pnx = new String[][] { pn1, pn2, pn3, pn4, pn5, pn6, pn7, pn8, pn9 };
- if (isParent (pnx)) {
- String value = attrs.getValue ("value");
+ if (isParent(pnx)) {
+ String value = attrs.getValue("value");
if (value == null) {
- missingRequiredAttribute (en, "value");
+ missingRequiredAttribute(en, "value");
} else {
- int gid = mapGlyphId (value, en);
- coverageEntries.add (Integer.valueOf (gid));
+ int gid = mapGlyphId(value, en);
+ coverageEntries.add(Integer.valueOf(gid));
}
} else {
- notPermittedInElementContext (en, getParent(), pnx);
+ notPermittedInElementContext(en, getParent(), pnx);
}
- } else if (en[1].equals ("GlyphClassDef")) {
+ } else if (en[1].equals("GlyphClassDef")) {
String[] pn = new String[] { null, "GDEF" };
- if (isParent (pn)) {
- String format = attrs.getValue ("Format");
+ if (isParent(pn)) {
+ String format = attrs.getValue("Format");
int sf = -1;
if (format == null) {
- missingRequiredAttribute (en, "Format");
+ missingRequiredAttribute(en, "Format");
} else {
- sf = Integer.parseInt (format);
+ sf = Integer.parseInt(format);
switch (sf) {
case 1:
case 2:
break;
default:
- unsupportedFormat (en, sf);
+ unsupportedFormat(en, sf);
break;
}
}
stFormat = sf;
assert glyphClasses.isEmpty();
} else {
- notPermittedInElementContext (en, getParent(), pn);
+ notPermittedInElementContext(en, getParent(), pn);
}
- } else if (en[1].equals ("GlyphID")) {
+ } else if (en[1].equals("GlyphID")) {
String[] pn = new String[] { null, "GlyphOrder" };
- if (isParent (pn)) {
- String id = attrs.getValue ("id");
+ if (isParent(pn)) {
+ String id = attrs.getValue("id");
int gid = -1;
if (id == null) {
- missingRequiredAttribute (en, "id");
+ missingRequiredAttribute(en, "id");
} else {
- gid = Integer.parseInt (id);
+ gid = Integer.parseInt(id);
}
- String name = attrs.getValue ("name");
+ String name = attrs.getValue("name");
if (name == null) {
- missingRequiredAttribute (en, "name");
+ missingRequiredAttribute(en, "name");
}
- if (glyphIds.containsKey (name)) {
- duplicateGlyph (en, name, gid);
+ if (glyphIds.containsKey(name)) {
+ duplicateGlyph(en, name, gid);
} else {
if (gid > glyphIdMax) {
glyphIdMax = gid;
}
- glyphIds.put (name, gid);
+ glyphIds.put(name, gid);
}
} else {
- notPermittedInElementContext (en, getParent(), pn);
+ notPermittedInElementContext(en, getParent(), pn);
}
- } else if (en[1].equals ("GlyphOrder")) {
+ } else if (en[1].equals("GlyphOrder")) {
String[] pn = new String[] { null, "ttFont" };
- if (! isParent (pn)) {
- notPermittedInElementContext (en, getParent(), pn);
+ if (! isParent(pn)) {
+ notPermittedInElementContext(en, getParent(), pn);
}
- } else if (en[1].equals ("InputCoverage")) {
+ } else if (en[1].equals("InputCoverage")) {
String[] pn1 = new String[] { null, "ChainContextSubst" };
String[] pn2 = new String[] { null, "ChainContextPos" };
String[][] pnx = new String[][] { pn1, pn2 };
- if (isParent (pnx)) {
- String index = attrs.getValue ("index");
+ if (isParent(pnx)) {
+ String index = attrs.getValue("index");
int ci = -1;
if (index == null) {
- missingRequiredAttribute (en, "index");
+ missingRequiredAttribute(en, "index");
} else {
- ci = Integer.parseInt (index);
+ ci = Integer.parseInt(index);
}
- String format = attrs.getValue ("Format");
+ String format = attrs.getValue("Format");
int cf = -1;
if (format == null) {
- missingRequiredAttribute (en, "Format");
+ missingRequiredAttribute(en, "Format");
} else {
- cf = Integer.parseInt (format);
+ cf = Integer.parseInt(format);
switch (cf) {
case 1:
case 2:
break;
default:
- unsupportedFormat (en, cf);
+ unsupportedFormat(en, cf);
break;
}
}
ctIndex = ci;
ctFormat = cf;
} else {
- notPermittedInElementContext (en, getParent(), pnx);
+ notPermittedInElementContext(en, getParent(), pnx);
}
- } else if (en[1].equals ("LangSys")) {
+ } else if (en[1].equals("LangSys")) {
String[] pn = new String[] { null, "LangSysRecord" };
- if (! isParent (pn)) {
- notPermittedInElementContext (en, getParent(), pn);
+ if (! isParent(pn)) {
+ notPermittedInElementContext(en, getParent(), pn);
} else {
assertLanguageFeaturesClear();
}
- } else if (en[1].equals ("LangSysRecord")) {
+ } else if (en[1].equals("LangSysRecord")) {
String[] pn = new String[] { null, "Script" };
- if (isParent (pn)) {
- String index = attrs.getValue ("index");
+ if (isParent(pn)) {
+ String index = attrs.getValue("index");
if (index == null) {
- missingRequiredAttribute (en, "index");
+ missingRequiredAttribute(en, "index");
}
} else {
- notPermittedInElementContext (en, getParent(), pn);
+ notPermittedInElementContext(en, getParent(), pn);
}
- } else if (en[1].equals ("LangSysTag")) {
+ } else if (en[1].equals("LangSysTag")) {
String[] pn = new String[] { null, "LangSysRecord" };
- if (isParent (pn)) {
- String value = attrs.getValue ("value");
+ if (isParent(pn)) {
+ String value = attrs.getValue("value");
if (value == null) {
- missingRequiredAttribute (en, "value");
+ missingRequiredAttribute(en, "value");
} else {
assert languageTag == null;
languageTag = value;
}
} else {
- notPermittedInElementContext (en, getParent(), pn);
+ notPermittedInElementContext(en, getParent(), pn);
}
- } else if (en[1].equals ("LigCaretList")) {
+ } else if (en[1].equals("LigCaretList")) {
String[] pn = new String[] { null, "GDEF" };
- if (! isParent (pn)) {
- notPermittedInElementContext (en, getParent(), pn);
+ if (! isParent(pn)) {
+ notPermittedInElementContext(en, getParent(), pn);
}
- } else if (en[1].equals ("Ligature")) {
+ } else if (en[1].equals("Ligature")) {
String[] pn = new String[] { null, "LigatureSet" };
- if (isParent (pn)) {
- String components = attrs.getValue ("components");
+ if (isParent(pn)) {
+ String components = attrs.getValue("components");
if (components == null) {
- missingRequiredAttribute (en, "components");
+ missingRequiredAttribute(en, "components");
}
- int[] cids = mapGlyphIds (components, en);
- String glyph = attrs.getValue ("glyph");
+ int[] cids = mapGlyphIds(components, en);
+ String glyph = attrs.getValue("glyph");
if (glyph == null) {
- missingRequiredAttribute (en, "glyph");
+ missingRequiredAttribute(en, "glyph");
}
- int gid = mapGlyphId (glyph, en);
- ligatures.add (new Ligature (gid, cids));
+ int gid = mapGlyphId(glyph, en);
+ ligatures.add(new Ligature(gid, cids));
} else {
- notPermittedInElementContext (en, getParent(), pn);
+ notPermittedInElementContext(en, getParent(), pn);
}
- } else if (en[1].equals ("LigatureAnchor")) {
+ } else if (en[1].equals("LigatureAnchor")) {
String[] pn = new String[] { null, "ComponentRecord" };
- if (isParent (pn)) {
- String index = attrs.getValue ("index");
+ if (isParent(pn)) {
+ String index = attrs.getValue("index");
if (index == null) {
- missingRequiredAttribute (en, "index");
+ missingRequiredAttribute(en, "index");
}
- String format = attrs.getValue ("Format");
+ String format = attrs.getValue("Format");
if (format == null) {
- missingRequiredAttribute (en, "Format");
+ missingRequiredAttribute(en, "Format");
}
assert xCoord == Integer.MIN_VALUE;
assert yCoord == Integer.MIN_VALUE;
} else {
- notPermittedInElementContext (en, getParent(), pn);
+ notPermittedInElementContext(en, getParent(), pn);
}
- } else if (en[1].equals ("LigatureArray")) {
+ } else if (en[1].equals("LigatureArray")) {
String[] pn = new String[] { null, "MarkLigPos" };
- if (! isParent (pn)) {
- notPermittedInElementContext (en, getParent(), pn);
+ if (! isParent(pn)) {
+ notPermittedInElementContext(en, getParent(), pn);
}
- } else if (en[1].equals ("LigatureAttach")) {
+ } else if (en[1].equals("LigatureAttach")) {
String[] pn = new String[] { null, "LigatureArray" };
- if (isParent (pn)) {
- String index = attrs.getValue ("index");
+ if (isParent(pn)) {
+ String index = attrs.getValue("index");
if (index == null) {
- missingRequiredAttribute (en, "index");
+ missingRequiredAttribute(en, "index");
}
assert components.size() == 0;
} else {
- notPermittedInElementContext (en, getParent(), pn);
+ notPermittedInElementContext(en, getParent(), pn);
}
- } else if (en[1].equals ("LigatureCoverage")) {
+ } else if (en[1].equals("LigatureCoverage")) {
String[] pn = new String[] { null, "MarkLigPos" };
- if (isParent (pn)) {
- String format = attrs.getValue ("Format");
+ if (isParent(pn)) {
+ String format = attrs.getValue("Format");
int cf = -1;
if (format == null) {
- missingRequiredAttribute (en, "Format");
+ missingRequiredAttribute(en, "Format");
} else {
- cf = Integer.parseInt (format);
+ cf = Integer.parseInt(format);
switch (cf) {
case 1:
case 2:
break;
default:
- unsupportedFormat (en, cf);
+ unsupportedFormat(en, cf);
break;
}
}
ctIndex = 0;
ctFormat = cf;
} else {
- notPermittedInElementContext (en, getParent(), pn);
+ notPermittedInElementContext(en, getParent(), pn);
}
- } else if (en[1].equals ("LigatureSet")) {
+ } else if (en[1].equals("LigatureSet")) {
String[] pn = new String[] { null, "LigatureSubst" };
- if (isParent (pn)) {
- String glyph = attrs.getValue ("glyph");
+ if (isParent(pn)) {
+ String glyph = attrs.getValue("glyph");
if (glyph == null) {
- missingRequiredAttribute (en, "glyph");
+ missingRequiredAttribute(en, "glyph");
}
- int gid = mapGlyphId (glyph, en);
- coverageEntries.add (Integer.valueOf (gid));
+ int gid = mapGlyphId(glyph, en);
+ coverageEntries.add(Integer.valueOf(gid));
} else {
- notPermittedInElementContext (en, getParent(), pn);
+ notPermittedInElementContext(en, getParent(), pn);
}
- } else if (en[1].equals ("LigatureSubst")) {
+ } else if (en[1].equals("LigatureSubst")) {
String[] pn = new String[] { null, "Lookup" };
- if (isParent (pn)) {
- String index = attrs.getValue ("index");
+ if (isParent(pn)) {
+ String index = attrs.getValue("index");
if (index == null) {
- missingRequiredAttribute (en, "index");
+ missingRequiredAttribute(en, "index");
}
- String format = attrs.getValue ("Format");
+ String format = attrs.getValue("Format");
int sf = -1;
if (format == null) {
- missingRequiredAttribute (en, "Format");
+ missingRequiredAttribute(en, "Format");
} else {
- sf = Integer.parseInt (format);
+ sf = Integer.parseInt(format);
switch (sf) {
case 1:
break;
default:
- unsupportedFormat (en, sf);
+ unsupportedFormat(en, sf);
break;
}
}
assert sf >= 0;
stFormat = sf;
} else {
- notPermittedInElementContext (en, getParent(), pn);
+ notPermittedInElementContext(en, getParent(), pn);
}
- } else if (en[1].equals ("LookAheadCoverage")) {
+ } else if (en[1].equals("LookAheadCoverage")) {
String[] pn1 = new String[] { null, "ChainContextSubst" };
String[] pn2 = new String[] { null, "ChainContextPos" };
String[][] pnx = new String[][] { pn1, pn2 };
- if (isParent (pnx)) {
- String index = attrs.getValue ("index");
+ if (isParent(pnx)) {
+ String index = attrs.getValue("index");
int ci = -1;
if (index == null) {
- missingRequiredAttribute (en, "index");
+ missingRequiredAttribute(en, "index");
} else {
- ci = Integer.parseInt (index);
+ ci = Integer.parseInt(index);
}
- String format = attrs.getValue ("Format");
+ String format = attrs.getValue("Format");
int cf = -1;
if (format == null) {
- missingRequiredAttribute (en, "Format");
+ missingRequiredAttribute(en, "Format");
} else {
- cf = Integer.parseInt (format);
+ cf = Integer.parseInt(format);
switch (cf) {
case 1:
case 2:
break;
default:
- unsupportedFormat (en, cf);
+ unsupportedFormat(en, cf);
break;
}
}
ctIndex = ci;
ctFormat = cf;
} else {
- notPermittedInElementContext (en, getParent(), pnx);
+ notPermittedInElementContext(en, getParent(), pnx);
}
- } else if (en[1].equals ("Lookup")) {
+ } else if (en[1].equals("Lookup")) {
String[] pn = new String[] { null, "LookupList" };
- if (isParent (pn)) {
- String index = attrs.getValue ("index");
+ if (isParent(pn)) {
+ String index = attrs.getValue("index");
int li = -1;
if (index == null) {
- missingRequiredAttribute (en, "index");
+ missingRequiredAttribute(en, "index");
} else {
- li = Integer.parseInt (index);
+ li = Integer.parseInt(index);
}
assertLookupClear();
assert ltIndex == -1;
ltIndex = li;
} else {
- notPermittedInElementContext (en, getParent(), pn);
+ notPermittedInElementContext(en, getParent(), pn);
}
- } else if (en[1].equals ("LookupFlag")) {
+ } else if (en[1].equals("LookupFlag")) {
String[] pn = new String[] { null, "Lookup" };
- if (isParent (pn)) {
- String value = attrs.getValue ("value");
+ if (isParent(pn)) {
+ String value = attrs.getValue("value");
int lf = 0;
if (value == null) {
- missingRequiredAttribute (en, "value");
+ missingRequiredAttribute(en, "value");
} else {
- lf = Integer.parseInt (value);
+ lf = Integer.parseInt(value);
}
assert ltFlags == 0;
ltFlags = lf;
} else {
- notPermittedInElementContext (en, getParent(), pn);
+ notPermittedInElementContext(en, getParent(), pn);
}
- } else if (en[1].equals ("LookupList")) {
+ } else if (en[1].equals("LookupList")) {
String[] pn1 = new String[] { null, "GSUB" };
String[] pn2 = new String[] { null, "GPOS" };
String[][] pnx = new String[][] { pn1, pn2 };
- if (! isParent (pnx)) {
- notPermittedInElementContext (en, getParent(), pnx);
+ if (! isParent(pnx)) {
+ notPermittedInElementContext(en, getParent(), pnx);
}
- } else if (en[1].equals ("LookupListIndex")) {
+ } else if (en[1].equals("LookupListIndex")) {
String[] pn1 = new String[] { null, "Feature" };
String[] pn2 = new String[] { null, "SubstLookupRecord" };
String[] pn3 = new String[] { null, "PosLookupRecord" };
String[][] pnx = new String[][] { pn1, pn2, pn3 };
- if (isParent (pnx)) {
- String index = attrs.getValue ("index");
- String value = attrs.getValue ("value");
+ if (isParent(pnx)) {
+ String index = attrs.getValue("index");
+ String value = attrs.getValue("value");
int v = -1;
if (value == null) {
- missingRequiredAttribute (en, "value");
+ missingRequiredAttribute(en, "value");
} else {
- v = Integer.parseInt (value);
+ v = Integer.parseInt(value);
}
String[][] pny = new String[][] { pn2, pn3 };
- if (isParent (pny)) {
+ if (isParent(pny)) {
assert rlLookup == -1;
assert v != -1;
rlLookup = v;
} else {
- featureLookups.add (makeLookupId (v));
+ featureLookups.add(makeLookupId(v));
}
} else {
- notPermittedInElementContext (en, getParent(), pnx);
+ notPermittedInElementContext(en, getParent(), pnx);
}
- } else if (en[1].equals ("LookupType")) {
+ } else if (en[1].equals("LookupType")) {
String[] pn = new String[] { null, "Lookup" };
- if (isParent (pn)) {
- String value = attrs.getValue ("value");
+ if (isParent(pn)) {
+ String value = attrs.getValue("value");
if (value == null) {
- missingRequiredAttribute (en, "value");
+ missingRequiredAttribute(en, "value");
}
} else {
- notPermittedInElementContext (en, getParent(), pn);
+ notPermittedInElementContext(en, getParent(), pn);
}
- } else if (en[1].equals ("Mark1Array")) {
+ } else if (en[1].equals("Mark1Array")) {
String[] pn = new String[] { null, "MarkMarkPos" };
- if (! isParent (pn)) {
- notPermittedInElementContext (en, getParent(), pn);
+ if (! isParent(pn)) {
+ notPermittedInElementContext(en, getParent(), pn);
}
- } else if (en[1].equals ("Mark1Coverage")) {
+ } else if (en[1].equals("Mark1Coverage")) {
String[] pn = new String[] { null, "MarkMarkPos" };
- if (isParent (pn)) {
- String format = attrs.getValue ("Format");
+ if (isParent(pn)) {
+ String format = attrs.getValue("Format");
int cf = -1;
if (format == null) {
- missingRequiredAttribute (en, "Format");
+ missingRequiredAttribute(en, "Format");
} else {
- cf = Integer.parseInt (format);
+ cf = Integer.parseInt(format);
switch (cf) {
case 1:
case 2:
break;
default:
- unsupportedFormat (en, cf);
+ unsupportedFormat(en, cf);
break;
}
}
ctIndex = 0;
ctFormat = cf;
} else {
- notPermittedInElementContext (en, getParent(), pn);
+ notPermittedInElementContext(en, getParent(), pn);
}
- } else if (en[1].equals ("Mark2Anchor")) {
+ } else if (en[1].equals("Mark2Anchor")) {
String[] pn = new String[] { null, "Mark2Record" };
- if (isParent (pn)) {
- String format = attrs.getValue ("Format");
+ if (isParent(pn)) {
+ String format = attrs.getValue("Format");
if (format == null) {
- missingRequiredAttribute (en, "Format");
+ missingRequiredAttribute(en, "Format");
}
assert xCoord == Integer.MIN_VALUE;
assert yCoord == Integer.MIN_VALUE;
} else {
- notPermittedInElementContext (en, getParent(), pn);
+ notPermittedInElementContext(en, getParent(), pn);
}
- } else if (en[1].equals ("Mark2Array")) {
+ } else if (en[1].equals("Mark2Array")) {
String[] pn = new String[] { null, "MarkMarkPos" };
- if (! isParent (pn)) {
- notPermittedInElementContext (en, getParent(), pn);
+ if (! isParent(pn)) {
+ notPermittedInElementContext(en, getParent(), pn);
}
- } else if (en[1].equals ("Mark2Coverage")) {
+ } else if (en[1].equals("Mark2Coverage")) {
String[] pn = new String[] { null, "MarkMarkPos" };
- if (isParent (pn)) {
- String format = attrs.getValue ("Format");
+ if (isParent(pn)) {
+ String format = attrs.getValue("Format");
int cf = -1;
if (format == null) {
- missingRequiredAttribute (en, "Format");
+ missingRequiredAttribute(en, "Format");
} else {
- cf = Integer.parseInt (format);
+ cf = Integer.parseInt(format);
switch (cf) {
case 1:
case 2:
break;
default:
- unsupportedFormat (en, cf);
+ unsupportedFormat(en, cf);
break;
}
}
ctIndex = 0;
ctFormat = cf;
} else {
- notPermittedInElementContext (en, getParent(), pn);
+ notPermittedInElementContext(en, getParent(), pn);
}
- } else if (en[1].equals ("Mark2Record")) {
+ } else if (en[1].equals("Mark2Record")) {
String[] pn = new String[] { null, "Mark2Array" };
- if (isParent (pn)) {
- String index = attrs.getValue ("index");
+ if (isParent(pn)) {
+ String index = attrs.getValue("index");
if (index == null) {
- missingRequiredAttribute (en, "index");
+ missingRequiredAttribute(en, "index");
}
} else {
- notPermittedInElementContext (en, getParent(), pn);
+ notPermittedInElementContext(en, getParent(), pn);
}
- } else if (en[1].equals ("MarkAnchor")) {
+ } else if (en[1].equals("MarkAnchor")) {
String[] pn = new String[] { null, "MarkRecord" };
- if (isParent (pn)) {
- String format = attrs.getValue ("Format");
+ if (isParent(pn)) {
+ String format = attrs.getValue("Format");
if (format == null) {
- missingRequiredAttribute (en, "Format");
+ missingRequiredAttribute(en, "Format");
}
assert xCoord == Integer.MIN_VALUE;
assert yCoord == Integer.MIN_VALUE;
} else {
- notPermittedInElementContext (en, getParent(), pn);
+ notPermittedInElementContext(en, getParent(), pn);
}
- } else if (en[1].equals ("MarkArray")) {
+ } else if (en[1].equals("MarkArray")) {
String[] pn1 = new String[] { null, "MarkBasePos" };
String[] pn2 = new String[] { null, "MarkLigPos" };
String[][] pnx = new String[][] { pn1, pn2 };
- if (! isParent (pnx)) {
- notPermittedInElementContext (en, getParent(), pnx);
+ if (! isParent(pnx)) {
+ notPermittedInElementContext(en, getParent(), pnx);
}
- } else if (en[1].equals ("MarkAttachClassDef")) {
+ } else if (en[1].equals("MarkAttachClassDef")) {
String[] pn = new String[] { null, "GDEF" };
- if (isParent (pn)) {
- String format = attrs.getValue ("Format");
+ if (isParent(pn)) {
+ String format = attrs.getValue("Format");
int sf = -1;
if (format == null) {
- missingRequiredAttribute (en, "Format");
+ missingRequiredAttribute(en, "Format");
} else {
- sf = Integer.parseInt (format);
+ sf = Integer.parseInt(format);
switch (sf) {
case 1:
case 2:
break;
default:
- unsupportedFormat (en, sf);
+ unsupportedFormat(en, sf);
break;
}
}
stFormat = sf;
assert glyphClasses.isEmpty();
} else {
- notPermittedInElementContext (en, getParent(), pn);
+ notPermittedInElementContext(en, getParent(), pn);
}
- } else if (en[1].equals ("MarkBasePos")) {
+ } else if (en[1].equals("MarkBasePos")) {
String[] pn = new String[] { null, "Lookup" };
- if (isParent (pn)) {
- String index = attrs.getValue ("index");
+ if (isParent(pn)) {
+ String index = attrs.getValue("index");
if (index == null) {
- missingRequiredAttribute (en, "index");
+ missingRequiredAttribute(en, "index");
}
- String format = attrs.getValue ("Format");
+ String format = attrs.getValue("Format");
int sf = -1;
if (format == null) {
- missingRequiredAttribute (en, "Format");
+ missingRequiredAttribute(en, "Format");
} else {
- sf = Integer.parseInt (format);
+ sf = Integer.parseInt(format);
switch (sf) {
case 1:
break;
default:
- unsupportedFormat (en, sf);
+ unsupportedFormat(en, sf);
break;
}
}
assert markAnchors.size() == 0;
assert baseOrMarkAnchors.size() == 0;
} else {
- notPermittedInElementContext (en, getParent(), pn);
+ notPermittedInElementContext(en, getParent(), pn);
}
- } else if (en[1].equals ("MarkCoverage")) {
+ } else if (en[1].equals("MarkCoverage")) {
String[] pn1 = new String[] { null, "MarkBasePos" };
String[] pn2 = new String[] { null, "MarkLigPos" };
String[][] pnx = new String[][] { pn1, pn2 };
- if (isParent (pnx)) {
- String format = attrs.getValue ("Format");
+ if (isParent(pnx)) {
+ String format = attrs.getValue("Format");
int cf = -1;
if (format == null) {
- missingRequiredAttribute (en, "Format");
+ missingRequiredAttribute(en, "Format");
} else {
- cf = Integer.parseInt (format);
+ cf = Integer.parseInt(format);
switch (cf) {
case 1:
case 2:
break;
default:
- unsupportedFormat (en, cf);
+ unsupportedFormat(en, cf);
break;
}
}
ctIndex = 0;
ctFormat = cf;
} else {
- notPermittedInElementContext (en, getParent(), pnx);
+ notPermittedInElementContext(en, getParent(), pnx);
}
- } else if (en[1].equals ("MarkLigPos")) {
+ } else if (en[1].equals("MarkLigPos")) {
String[] pn = new String[] { null, "Lookup" };
- if (isParent (pn)) {
- String index = attrs.getValue ("index");
+ if (isParent(pn)) {
+ String index = attrs.getValue("index");
if (index == null) {
- missingRequiredAttribute (en, "index");
+ missingRequiredAttribute(en, "index");
}
- String format = attrs.getValue ("Format");
+ String format = attrs.getValue("Format");
int sf = -1;
if (format == null) {
- missingRequiredAttribute (en, "Format");
+ missingRequiredAttribute(en, "Format");
} else {
- sf = Integer.parseInt (format);
+ sf = Integer.parseInt(format);
switch (sf) {
case 1:
break;
default:
- unsupportedFormat (en, sf);
+ unsupportedFormat(en, sf);
break;
}
}
assert markAnchors.size() == 0;
assert ligatureAnchors.size() == 0;
} else {
- notPermittedInElementContext (en, getParent(), pn);
+ notPermittedInElementContext(en, getParent(), pn);
}
- } else if (en[1].equals ("MarkMarkPos")) {
+ } else if (en[1].equals("MarkMarkPos")) {
String[] pn = new String[] { null, "Lookup" };
- if (isParent (pn)) {
- String index = attrs.getValue ("index");
+ if (isParent(pn)) {
+ String index = attrs.getValue("index");
if (index == null) {
- missingRequiredAttribute (en, "index");
+ missingRequiredAttribute(en, "index");
}
- String format = attrs.getValue ("Format");
+ String format = attrs.getValue("Format");
int sf = -1;
if (format == null) {
- missingRequiredAttribute (en, "Format");
+ missingRequiredAttribute(en, "Format");
} else {
- sf = Integer.parseInt (format);
+ sf = Integer.parseInt(format);
switch (sf) {
case 1:
break;
default:
- unsupportedFormat (en, sf);
+ unsupportedFormat(en, sf);
break;
}
}
assert markAnchors.size() == 0;
assert baseOrMarkAnchors.size() == 0;
} else {
- notPermittedInElementContext (en, getParent(), pn);
+ notPermittedInElementContext(en, getParent(), pn);
}
- } else if (en[1].equals ("MarkRecord")) {
+ } else if (en[1].equals("MarkRecord")) {
String[] pn1 = new String[] { null, "MarkArray" };
String[] pn2 = new String[] { null, "Mark1Array" };
String[][] pnx = new String[][] { pn1, pn2 };
- if (isParent (pnx)) {
- String index = attrs.getValue ("index");
+ if (isParent(pnx)) {
+ String index = attrs.getValue("index");
if (index == null) {
- missingRequiredAttribute (en, "index");
+ missingRequiredAttribute(en, "index");
}
} else {
- notPermittedInElementContext (en, getParent(), pnx);
+ notPermittedInElementContext(en, getParent(), pnx);
}
- } else if (en[1].equals ("MultipleSubst")) {
+ } else if (en[1].equals("MultipleSubst")) {
String[] pn = new String[] { null, "Lookup" };
- if (isParent (pn)) {
- String index = attrs.getValue ("index");
+ if (isParent(pn)) {
+ String index = attrs.getValue("index");
if (index == null) {
- missingRequiredAttribute (en, "index");
+ missingRequiredAttribute(en, "index");
}
- String format = attrs.getValue ("Format");
+ String format = attrs.getValue("Format");
int sf = -1;
if (format == null) {
- missingRequiredAttribute (en, "Format");
+ missingRequiredAttribute(en, "Format");
} else {
- sf = Integer.parseInt (format);
+ sf = Integer.parseInt(format);
switch (sf) {
case 1:
break;
default:
- unsupportedFormat (en, sf);
+ unsupportedFormat(en, sf);
break;
}
}
assert sf >= 0;
stFormat = sf;
} else {
- notPermittedInElementContext (en, getParent(), pn);
+ notPermittedInElementContext(en, getParent(), pn);
}
- } else if (en[1].equals ("PairPos")) {
+ } else if (en[1].equals("PairPos")) {
String[] pn = new String[] { null, "Lookup" };
- if (isParent (pn)) {
- String index = attrs.getValue ("index");
+ if (isParent(pn)) {
+ String index = attrs.getValue("index");
if (index == null) {
- missingRequiredAttribute (en, "index");
+ missingRequiredAttribute(en, "index");
}
- String format = attrs.getValue ("Format");
+ String format = attrs.getValue("Format");
int sf = -1;
if (format == null) {
- missingRequiredAttribute (en, "Format");
+ missingRequiredAttribute(en, "Format");
} else {
- sf = Integer.parseInt (format);
+ sf = Integer.parseInt(format);
switch (sf) {
case 1:
case 2:
break;
default:
- unsupportedFormat (en, sf);
+ unsupportedFormat(en, sf);
break;
}
}
assert sf >= 0;
stFormat = sf;
} else {
- notPermittedInElementContext (en, getParent(), pn);
+ notPermittedInElementContext(en, getParent(), pn);
}
- } else if (en[1].equals ("PairSet")) {
+ } else if (en[1].equals("PairSet")) {
String[] pn = new String[] { null, "PairPos" };
- if (isParent (pn)) {
- String index = attrs.getValue ("index");
+ if (isParent(pn)) {
+ String index = attrs.getValue("index");
int psi = -1;
if (index == null) {
- missingRequiredAttribute (en, "index");
+ missingRequiredAttribute(en, "index");
} else {
- psi = Integer.parseInt (index);
+ psi = Integer.parseInt(index);
}
assert psIndex == -1;
psIndex = psi;
} else {
- notPermittedInElementContext (en, getParent(), pn);
+ notPermittedInElementContext(en, getParent(), pn);
}
- } else if (en[1].equals ("PairValueRecord")) {
+ } else if (en[1].equals("PairValueRecord")) {
String[] pn = new String[] { null, "PairSet" };
- if (isParent (pn)) {
- String index = attrs.getValue ("index");
+ if (isParent(pn)) {
+ String index = attrs.getValue("index");
if (index == null) {
- missingRequiredAttribute (en, "index");
+ missingRequiredAttribute(en, "index");
} else {
assertPairClear();
}
} else {
- notPermittedInElementContext (en, getParent(), pn);
+ notPermittedInElementContext(en, getParent(), pn);
}
- } else if (en[1].equals ("PosLookupRecord")) {
+ } else if (en[1].equals("PosLookupRecord")) {
String[] pn1 = new String[] { null, "ChainContextSubst" };
String[] pn2 = new String[] { null, "ChainContextPos" };
String[][] pnx = new String[][] { pn1, pn2 };
- if (isParent (pnx)) {
- String index = attrs.getValue ("index");
+ if (isParent(pnx)) {
+ String index = attrs.getValue("index");
if (index == null) {
- missingRequiredAttribute (en, "index");
+ missingRequiredAttribute(en, "index");
}
} else {
- notPermittedInElementContext (en, getParent(), pnx);
+ notPermittedInElementContext(en, getParent(), pnx);
}
- } else if (en[1].equals ("ReqFeatureIndex")) {
+ } else if (en[1].equals("ReqFeatureIndex")) {
String[] pn1 = new String[] { null, "DefaultLangSys" };
String[] pn2 = new String[] { null, "LangSys" };
String[][] pnx = new String[][] { pn1, pn2 };
- if (isParent (pnx)) {
- String value = attrs.getValue ("value");
+ if (isParent(pnx)) {
+ String value = attrs.getValue("value");
int v = -1;
if (value == null) {
- missingRequiredAttribute (en, "value");
+ missingRequiredAttribute(en, "value");
} else {
- v = Integer.parseInt (value);
+ v = Integer.parseInt(value);
}
String fid;
if ((v >= 0) && (v < 65535)) {
- fid = makeFeatureId (v);
+ fid = makeFeatureId(v);
} else {
fid = null;
}
assertLanguageFeaturesClear();
- languageFeatures.add (fid);
+ languageFeatures.add(fid);
} else {
- notPermittedInElementContext (en, getParent(), pnx);
+ notPermittedInElementContext(en, getParent(), pnx);
}
- } else if (en[1].equals ("Script")) {
+ } else if (en[1].equals("Script")) {
String[] pn = new String[] { null, "ScriptRecord" };
- if (! isParent (pn)) {
- notPermittedInElementContext (en, getParent(), pn);
+ if (! isParent(pn)) {
+ notPermittedInElementContext(en, getParent(), pn);
}
- } else if (en[1].equals ("ScriptList")) {
+ } else if (en[1].equals("ScriptList")) {
String[] pn1 = new String[] { null, "GSUB" };
String[] pn2 = new String[] { null, "GPOS" };
String[][] pnx = new String[][] { pn1, pn2 };
- if (! isParent (pnx)) {
- notPermittedInElementContext (en, getParent(), pnx);
+ if (! isParent(pnx)) {
+ notPermittedInElementContext(en, getParent(), pnx);
}
- } else if (en[1].equals ("ScriptRecord")) {
+ } else if (en[1].equals("ScriptRecord")) {
String[] pn = new String[] { null, "ScriptList" };
- if (isParent (pn)) {
- String index = attrs.getValue ("index");
+ if (isParent(pn)) {
+ String index = attrs.getValue("index");
if (index == null) {
- missingRequiredAttribute (en, "index");
+ missingRequiredAttribute(en, "index");
}
} else {
- notPermittedInElementContext (en, getParent(), pn);
+ notPermittedInElementContext(en, getParent(), pn);
}
- } else if (en[1].equals ("ScriptTag")) {
+ } else if (en[1].equals("ScriptTag")) {
String[] pn = new String[] { null, "ScriptRecord" };
- if (isParent (pn)) {
- String value = attrs.getValue ("value");
+ if (isParent(pn)) {
+ String value = attrs.getValue("value");
if (value == null) {
- missingRequiredAttribute (en, "value");
+ missingRequiredAttribute(en, "value");
} else {
assert scriptTag == null;
scriptTag = value;
}
} else {
- notPermittedInElementContext (en, getParent(), pn);
+ notPermittedInElementContext(en, getParent(), pn);
}
- } else if (en[1].equals ("SecondGlyph")) {
+ } else if (en[1].equals("SecondGlyph")) {
String[] pn = new String[] { null, "PairValueRecord" };
- if (isParent (pn)) {
- String value = attrs.getValue ("value");
+ if (isParent(pn)) {
+ String value = attrs.getValue("value");
if (value == null) {
- missingRequiredAttribute (en, "value");
+ missingRequiredAttribute(en, "value");
} else {
- int gid = mapGlyphId (value, en);
+ int gid = mapGlyphId(value, en);
assert g2 == -1;
g2 = gid;
}
} else {
- notPermittedInElementContext (en, getParent(), pn);
+ notPermittedInElementContext(en, getParent(), pn);
}
- } else if (en[1].equals ("Sequence")) {
+ } else if (en[1].equals("Sequence")) {
String[] pn = new String[] { null, "MultipleSubst" };
- if (isParent (pn)) {
- String index = attrs.getValue ("index");
+ if (isParent(pn)) {
+ String index = attrs.getValue("index");
if (index == null) {
- missingRequiredAttribute (en, "index");
+ missingRequiredAttribute(en, "index");
} else {
- int i = Integer.parseInt (index);
+ int i = Integer.parseInt(index);
if (i != subtableEntries.size()) {
- invalidIndex (en, i, subtableEntries.size());
+ invalidIndex(en, i, subtableEntries.size());
}
}
} else {
- notPermittedInElementContext (en, getParent(), pn);
+ notPermittedInElementContext(en, getParent(), pn);
}
- } else if (en[1].equals ("SequenceIndex")) {
+ } else if (en[1].equals("SequenceIndex")) {
String[] pn1 = new String[] { null, "PosLookupRecord" };
String[] pn2 = new String[] { null, "SubstLookupRecord" };
String[][] pnx = new String[][] { pn1, pn2 };
- if (isParent (pnx)) {
- String value = attrs.getValue ("value");
+ if (isParent(pnx)) {
+ String value = attrs.getValue("value");
int v = -1;
if (value == null) {
- missingRequiredAttribute (en, "value");
+ missingRequiredAttribute(en, "value");
} else {
- v = Integer.parseInt (value);
+ v = Integer.parseInt(value);
}
assert rlSequence == -1;
assert v != -1;
rlSequence = v;
} else {
- notPermittedInElementContext (en, getParent(), pnx);
+ notPermittedInElementContext(en, getParent(), pnx);
}
- } else if (en[1].equals ("SinglePos")) {
+ } else if (en[1].equals("SinglePos")) {
String[] pn = new String[] { null, "Lookup" };
- if (isParent (pn)) {
- String index = attrs.getValue ("index");
+ if (isParent(pn)) {
+ String index = attrs.getValue("index");
if (index == null) {
- missingRequiredAttribute (en, "index");
+ missingRequiredAttribute(en, "index");
}
- String format = attrs.getValue ("Format");
+ String format = attrs.getValue("Format");
int sf = -1;
if (format == null) {
- missingRequiredAttribute (en, "Format");
+ missingRequiredAttribute(en, "Format");
} else {
- sf = Integer.parseInt (format);
+ sf = Integer.parseInt(format);
switch (sf) {
case 1:
case 2:
break;
default:
- unsupportedFormat (en, sf);
+ unsupportedFormat(en, sf);
break;
}
}
assert sf >= 0;
stFormat = sf;
} else {
- notPermittedInElementContext (en, getParent(), pn);
+ notPermittedInElementContext(en, getParent(), pn);
}
- } else if (en[1].equals ("SingleSubst")) {
+ } else if (en[1].equals("SingleSubst")) {
String[] pn = new String[] { null, "Lookup" };
- if (isParent (pn)) {
- String index = attrs.getValue ("index");
+ if (isParent(pn)) {
+ String index = attrs.getValue("index");
if (index == null) {
- missingRequiredAttribute (en, "index");
+ missingRequiredAttribute(en, "index");
}
- String format = attrs.getValue ("Format");
+ String format = attrs.getValue("Format");
int sf = -1;
if (format == null) {
- missingRequiredAttribute (en, "Format");
+ missingRequiredAttribute(en, "Format");
} else {
- sf = Integer.parseInt (format);
+ sf = Integer.parseInt(format);
switch (sf) {
case 1:
case 2:
break;
default:
- unsupportedFormat (en, sf);
+ unsupportedFormat(en, sf);
break;
}
}
assert sf >= 0;
stFormat = sf;
} else {
- notPermittedInElementContext (en, getParent(), pn);
+ notPermittedInElementContext(en, getParent(), pn);
}
- } else if (en[1].equals ("SubstLookupRecord")) {
+ } else if (en[1].equals("SubstLookupRecord")) {
String[] pn = new String[] { null, "ChainContextSubst" };
- if (isParent (pn)) {
- String index = attrs.getValue ("index");
+ if (isParent(pn)) {
+ String index = attrs.getValue("index");
if (index == null) {
- missingRequiredAttribute (en, "index");
+ missingRequiredAttribute(en, "index");
}
} else {
- notPermittedInElementContext (en, getParent(), pn);
+ notPermittedInElementContext(en, getParent(), pn);
}
- } else if (en[1].equals ("Substitute")) {
+ } else if (en[1].equals("Substitute")) {
String[] pn = new String[] { null, "Sequence" };
- if (isParent (pn)) {
- String index = attrs.getValue ("index");
+ if (isParent(pn)) {
+ String index = attrs.getValue("index");
if (index == null) {
- missingRequiredAttribute (en, "index");
+ missingRequiredAttribute(en, "index");
} else {
- int i = Integer.parseInt (index);
+ int i = Integer.parseInt(index);
if (i != substitutes.size()) {
- invalidIndex (en, i, substitutes.size());
+ invalidIndex(en, i, substitutes.size());
}
}
- String value = attrs.getValue ("value");
+ String value = attrs.getValue("value");
if (value == null) {
- missingRequiredAttribute (en, "value");
+ missingRequiredAttribute(en, "value");
} else {
- int gid = mapGlyphId (value, en);
- substitutes.add (Integer.valueOf (gid));
+ int gid = mapGlyphId(value, en);
+ substitutes.add(Integer.valueOf(gid));
}
} else {
- notPermittedInElementContext (en, getParent(), pn);
+ notPermittedInElementContext(en, getParent(), pn);
}
- } else if (en[1].equals ("Substitution")) {
+ } else if (en[1].equals("Substitution")) {
String[] pn = new String[] { null, "SingleSubst" };
- if (isParent (pn)) {
- String in = attrs.getValue ("in");
+ if (isParent(pn)) {
+ String in = attrs.getValue("in");
int igid = -1;
int ogid = -1;
if (in == null) {
- missingRequiredAttribute (en, "in");
+ missingRequiredAttribute(en, "in");
} else {
- igid = mapGlyphId (in, en);
+ igid = mapGlyphId(in, en);
}
- String out = attrs.getValue ("out");
+ String out = attrs.getValue("out");
if (out == null) {
- missingRequiredAttribute (en, "out");
+ missingRequiredAttribute(en, "out");
} else {
- ogid = mapGlyphId (out, en);
+ ogid = mapGlyphId(out, en);
}
- coverageEntries.add (Integer.valueOf (igid));
- subtableEntries.add (Integer.valueOf (ogid));
+ coverageEntries.add(Integer.valueOf(igid));
+ subtableEntries.add(Integer.valueOf(ogid));
} else {
- notPermittedInElementContext (en, getParent(), pn);
+ notPermittedInElementContext(en, getParent(), pn);
}
- } else if (en[1].equals ("Value")) {
+ } else if (en[1].equals("Value")) {
String[] pn = new String[] { null, "SinglePos" };
- if (isParent (pn)) {
- String index = attrs.getValue ("index");
+ if (isParent(pn)) {
+ String index = attrs.getValue("index");
if (vf1 < 0) {
- missingParameter (en, "value format");
+ missingParameter(en, "value format");
} else {
- subtableEntries.add (parseValue (en, attrs, vf1));
+ subtableEntries.add(parseValue(en, attrs, vf1));
}
} else {
- notPermittedInElementContext (en, getParent(), pn);
+ notPermittedInElementContext(en, getParent(), pn);
}
- } else if (en[1].equals ("Value1")) {
+ } else if (en[1].equals("Value1")) {
String[] pn = new String[] { null, "PairValueRecord" };
- if (isParent (pn)) {
+ if (isParent(pn)) {
if (vf1 < 0) {
- missingParameter (en, "value format 1");
+ missingParameter(en, "value format 1");
} else {
assert v1 == null;
- v1 = parseValue (en, attrs, vf1);
+ v1 = parseValue(en, attrs, vf1);
}
} else {
- notPermittedInElementContext (en, getParent(), pn);
+ notPermittedInElementContext(en, getParent(), pn);
}
- } else if (en[1].equals ("Value2")) {
+ } else if (en[1].equals("Value2")) {
String[] pn = new String[] { null, "PairValueRecord" };
- if (isParent (pn)) {
+ if (isParent(pn)) {
if (vf2 < 0) {
- missingParameter (en, "value format 2");
+ missingParameter(en, "value format 2");
} else {
assert v2 == null;
- v2 = parseValue (en, attrs, vf2);
+ v2 = parseValue(en, attrs, vf2);
}
} else {
- notPermittedInElementContext (en, getParent(), pn);
+ notPermittedInElementContext(en, getParent(), pn);
}
- } else if (en[1].equals ("ValueFormat")) {
+ } else if (en[1].equals("ValueFormat")) {
String[] pn = new String[] { null, "SinglePos" };
- if (isParent (pn)) {
- String value = attrs.getValue ("value");
+ if (isParent(pn)) {
+ String value = attrs.getValue("value");
int vf = -1;
if (value == null) {
- missingRequiredAttribute (en, "value");
+ missingRequiredAttribute(en, "value");
} else {
- vf = Integer.parseInt (value);
+ vf = Integer.parseInt(value);
}
assert vf1 == -1;
vf1 = vf;
} else {
- notPermittedInElementContext (en, getParent(), pn);
+ notPermittedInElementContext(en, getParent(), pn);
}
- } else if (en[1].equals ("ValueFormat1")) {
+ } else if (en[1].equals("ValueFormat1")) {
String[] pn = new String[] { null, "PairPos" };
- if (isParent (pn)) {
- String value = attrs.getValue ("value");
+ if (isParent(pn)) {
+ String value = attrs.getValue("value");
int vf = -1;
if (value == null) {
- missingRequiredAttribute (en, "value");
+ missingRequiredAttribute(en, "value");
} else {
- vf = Integer.parseInt (value);
+ vf = Integer.parseInt(value);
}
assert vf1 == -1;
vf1 = vf;
} else {
- notPermittedInElementContext (en, getParent(), pn);
+ notPermittedInElementContext(en, getParent(), pn);
}
- } else if (en[1].equals ("ValueFormat2")) {
+ } else if (en[1].equals("ValueFormat2")) {
String[] pn = new String[] { null, "PairPos" };
- if (isParent (pn)) {
- String value = attrs.getValue ("value");
+ if (isParent(pn)) {
+ String value = attrs.getValue("value");
int vf = -1;
if (value == null) {
- missingRequiredAttribute (en, "value");
+ missingRequiredAttribute(en, "value");
} else {
- vf = Integer.parseInt (value);
+ vf = Integer.parseInt(value);
}
assert vf2 == -1;
vf2 = vf;
} else {
- notPermittedInElementContext (en, getParent(), pn);
+ notPermittedInElementContext(en, getParent(), pn);
}
- } else if (en[1].equals ("Version")) {
+ } else if (en[1].equals("Version")) {
String[] pn1 = new String[] { null, "GDEF" };
String[] pn2 = new String[] { null, "GPOS" };
String[] pn3 = new String[] { null, "GSUB" };
String[][] pnx = new String[][] { pn1, pn2, pn3 };
- if (isParent (pnx)) {
- String value = attrs.getValue ("value");
+ if (isParent(pnx)) {
+ String value = attrs.getValue("value");
if (value == null) {
- missingRequiredAttribute (en, "value");
+ missingRequiredAttribute(en, "value");
}
} else {
- notPermittedInElementContext (en, getParent(), pnx);
+ notPermittedInElementContext(en, getParent(), pnx);
}
- } else if (en[1].equals ("XCoordinate")) {
+ } else if (en[1].equals("XCoordinate")) {
String[] pn1 = new String[] { null, "BaseAnchor" };
String[] pn2 = new String[] { null, "EntryAnchor" };
String[] pn3 = new String[] { null, "ExitAnchor" };
String[] pn5 = new String[] { null, "MarkAnchor" };
String[] pn6 = new String[] { null, "Mark2Anchor" };
String[][] pnx = new String[][] { pn1, pn2, pn3, pn4, pn5, pn6 };
- if (isParent (pnx)) {
- String value = attrs.getValue ("value");
+ if (isParent(pnx)) {
+ String value = attrs.getValue("value");
int x = 0;
if (value == null) {
- missingRequiredAttribute (en, "value");
+ missingRequiredAttribute(en, "value");
} else {
- x = Integer.parseInt (value);
+ x = Integer.parseInt(value);
}
assert xCoord == Integer.MIN_VALUE;
xCoord = x;
} else {
- notPermittedInElementContext (en, getParent(), pnx);
+ notPermittedInElementContext(en, getParent(), pnx);
}
- } else if (en[1].equals ("YCoordinate")) {
+ } else if (en[1].equals("YCoordinate")) {
String[] pn1 = new String[] { null, "BaseAnchor" };
String[] pn2 = new String[] { null, "EntryAnchor" };
String[] pn3 = new String[] { null, "ExitAnchor" };
String[] pn5 = new String[] { null, "MarkAnchor" };
String[] pn6 = new String[] { null, "Mark2Anchor" };
String[][] pnx = new String[][] { pn1, pn2, pn3, pn4, pn5, pn6 };
- if (isParent (pnx)) {
- String value = attrs.getValue ("value");
+ if (isParent(pnx)) {
+ String value = attrs.getValue("value");
int y = 0;
if (value == null) {
- missingRequiredAttribute (en, "value");
+ missingRequiredAttribute(en, "value");
} else {
- y = Integer.parseInt (value);
+ y = Integer.parseInt(value);
}
assert yCoord == Integer.MIN_VALUE;
yCoord = y;
} else {
- notPermittedInElementContext (en, getParent(), pnx);
+ notPermittedInElementContext(en, getParent(), pnx);
}
- } else if (en[1].equals ("checkSumAdjustment")) {
+ } else if (en[1].equals("checkSumAdjustment")) {
String[] pn = new String[] { null, "head" };
- if (isParent (pn)) {
- String value = attrs.getValue ("value");
+ if (isParent(pn)) {
+ String value = attrs.getValue("value");
if (value == null) {
- missingRequiredAttribute (en, "value");
+ missingRequiredAttribute(en, "value");
}
} else {
- notPermittedInElementContext (en, getParent(), pn);
+ notPermittedInElementContext(en, getParent(), pn);
}
- } else if (en[1].equals ("cmap")) {
+ } else if (en[1].equals("cmap")) {
String[] pn = new String[] { null, "ttFont" };
- if (! isParent (pn)) {
- notPermittedInElementContext (en, getParent(), pn);
+ if (! isParent(pn)) {
+ notPermittedInElementContext(en, getParent(), pn);
}
- } else if (en[1].equals ("cmap_format_0")) {
+ } else if (en[1].equals("cmap_format_0")) {
String[] pn = new String[] { null, "cmap" };
- if (isParent (pn)) {
- String platformID = attrs.getValue ("platformID");
+ if (isParent(pn)) {
+ String platformID = attrs.getValue("platformID");
if (platformID == null) {
- missingRequiredAttribute (en, "platformID");
+ missingRequiredAttribute(en, "platformID");
}
- String platEncID = attrs.getValue ("platEncID");
+ String platEncID = attrs.getValue("platEncID");
if (platEncID == null) {
- missingRequiredAttribute (en, "platEncID");
+ missingRequiredAttribute(en, "platEncID");
}
- String language = attrs.getValue ("language");
+ String language = attrs.getValue("language");
if (language == null) {
- missingRequiredAttribute (en, "language");
+ missingRequiredAttribute(en, "language");
}
} else {
- notPermittedInElementContext (en, getParent(), pn);
+ notPermittedInElementContext(en, getParent(), pn);
}
- } else if (en[1].equals ("cmap_format_4")) {
+ } else if (en[1].equals("cmap_format_4")) {
String[] pn = new String[] { null, "cmap" };
- if (isParent (pn)) {
- String platformID = attrs.getValue ("platformID");
+ if (isParent(pn)) {
+ String platformID = attrs.getValue("platformID");
int pid = -1;
if (platformID == null) {
- missingRequiredAttribute (en, "platformID");
+ missingRequiredAttribute(en, "platformID");
} else {
- pid = Integer.parseInt (platformID);
+ pid = Integer.parseInt(platformID);
}
- String platEncID = attrs.getValue ("platEncID");
+ String platEncID = attrs.getValue("platEncID");
int eid = -1;
if (platEncID == null) {
- missingRequiredAttribute (en, "platEncID");
+ missingRequiredAttribute(en, "platEncID");
} else {
- eid = Integer.parseInt (platEncID);
+ eid = Integer.parseInt(platEncID);
}
- String language = attrs.getValue ("language");
+ String language = attrs.getValue("language");
int lid = -1;
if (language == null) {
- missingRequiredAttribute (en, "language");
+ missingRequiredAttribute(en, "language");
} else {
- lid = Integer.parseInt (language);
+ lid = Integer.parseInt(language);
}
assert cmapEntries.size() == 0;
assert cmPlatform == -1;
cmEncoding = eid;
cmLanguage = lid;
} else {
- notPermittedInElementContext (en, getParent(), pn);
+ notPermittedInElementContext(en, getParent(), pn);
}
- } else if (en[1].equals ("created")) {
+ } else if (en[1].equals("created")) {
String[] pn = new String[] { null, "head" };
- if (isParent (pn)) {
- String value = attrs.getValue ("value");
+ if (isParent(pn)) {
+ String value = attrs.getValue("value");
if (value == null) {
- missingRequiredAttribute (en, "value");
+ missingRequiredAttribute(en, "value");
}
} else {
- notPermittedInElementContext (en, getParent(), pn);
+ notPermittedInElementContext(en, getParent(), pn);
}
- } else if (en[1].equals ("flags")) {
+ } else if (en[1].equals("flags")) {
String[] pn = new String[] { null, "head" };
- if (isParent (pn)) {
- String value = attrs.getValue ("value");
+ if (isParent(pn)) {
+ String value = attrs.getValue("value");
if (value == null) {
- missingRequiredAttribute (en, "value");
+ missingRequiredAttribute(en, "value");
}
} else {
- notPermittedInElementContext (en, getParent(), pn);
+ notPermittedInElementContext(en, getParent(), pn);
}
- } else if (en[1].equals ("fontDirectionHint")) {
+ } else if (en[1].equals("fontDirectionHint")) {
String[] pn = new String[] { null, "head" };
- if (isParent (pn)) {
- String value = attrs.getValue ("value");
+ if (isParent(pn)) {
+ String value = attrs.getValue("value");
if (value == null) {
- missingRequiredAttribute (en, "value");
+ missingRequiredAttribute(en, "value");
}
} else {
- notPermittedInElementContext (en, getParent(), pn);
+ notPermittedInElementContext(en, getParent(), pn);
}
- } else if (en[1].equals ("fontRevision")) {
+ } else if (en[1].equals("fontRevision")) {
String[] pn = new String[] { null, "head" };
- if (isParent (pn)) {
- String value = attrs.getValue ("value");
+ if (isParent(pn)) {
+ String value = attrs.getValue("value");
if (value == null) {
- missingRequiredAttribute (en, "value");
+ missingRequiredAttribute(en, "value");
}
} else {
- notPermittedInElementContext (en, getParent(), pn);
+ notPermittedInElementContext(en, getParent(), pn);
}
- } else if (en[1].equals ("glyphDataFormat")) {
+ } else if (en[1].equals("glyphDataFormat")) {
String[] pn = new String[] { null, "head" };
- if (isParent (pn)) {
- String value = attrs.getValue ("value");
+ if (isParent(pn)) {
+ String value = attrs.getValue("value");
if (value == null) {
- missingRequiredAttribute (en, "value");
+ missingRequiredAttribute(en, "value");
}
} else {
- notPermittedInElementContext (en, getParent(), pn);
+ notPermittedInElementContext(en, getParent(), pn);
}
- } else if (en[1].equals ("head")) {
+ } else if (en[1].equals("head")) {
String[] pn = new String[] { null, "ttFont" };
- if (! isParent (pn)) {
- notPermittedInElementContext (en, getParent(), pn);
+ if (! isParent(pn)) {
+ notPermittedInElementContext(en, getParent(), pn);
}
- } else if (en[1].equals ("hmtx")) {
+ } else if (en[1].equals("hmtx")) {
String[] pn = new String[] { null, "ttFont" };
- if (! isParent (pn)) {
- notPermittedInElementContext (en, getParent(), pn);
+ if (! isParent(pn)) {
+ notPermittedInElementContext(en, getParent(), pn);
} else if (glyphIdMax > 0) {
- hmtxEntries.setSize (glyphIdMax + 1);
+ hmtxEntries.setSize(glyphIdMax + 1);
}
- } else if (en[1].equals ("indexToLocFormat")) {
+ } else if (en[1].equals("indexToLocFormat")) {
String[] pn = new String[] { null, "head" };
- if (isParent (pn)) {
- String value = attrs.getValue ("value");
+ if (isParent(pn)) {
+ String value = attrs.getValue("value");
if (value == null) {
- missingRequiredAttribute (en, "value");
+ missingRequiredAttribute(en, "value");
}
} else {
- notPermittedInElementContext (en, getParent(), pn);
+ notPermittedInElementContext(en, getParent(), pn);
}
- } else if (en[1].equals ("lowestRecPPEM")) {
+ } else if (en[1].equals("lowestRecPPEM")) {
String[] pn = new String[] { null, "head" };
- if (isParent (pn)) {
- String value = attrs.getValue ("value");
+ if (isParent(pn)) {
+ String value = attrs.getValue("value");
if (value == null) {
- missingRequiredAttribute (en, "value");
+ missingRequiredAttribute(en, "value");
}
} else {
- notPermittedInElementContext (en, getParent(), pn);
+ notPermittedInElementContext(en, getParent(), pn);
}
- } else if (en[1].equals ("macStyle")) {
+ } else if (en[1].equals("macStyle")) {
String[] pn = new String[] { null, "head" };
- if (isParent (pn)) {
- String value = attrs.getValue ("value");
+ if (isParent(pn)) {
+ String value = attrs.getValue("value");
if (value == null) {
- missingRequiredAttribute (en, "value");
+ missingRequiredAttribute(en, "value");
}
} else {
- notPermittedInElementContext (en, getParent(), pn);
+ notPermittedInElementContext(en, getParent(), pn);
}
- } else if (en[1].equals ("magicNumber")) {
+ } else if (en[1].equals("magicNumber")) {
String[] pn = new String[] { null, "head" };
- if (isParent (pn)) {
- String value = attrs.getValue ("value");
+ if (isParent(pn)) {
+ String value = attrs.getValue("value");
if (value == null) {
- missingRequiredAttribute (en, "value");
+ missingRequiredAttribute(en, "value");
}
} else {
- notPermittedInElementContext (en, getParent(), pn);
+ notPermittedInElementContext(en, getParent(), pn);
}
- } else if (en[1].equals ("map")) {
+ } else if (en[1].equals("map")) {
String[] pn1 = new String[] { null, "cmap_format_0" };
String[] pn2 = new String[] { null, "cmap_format_4" };
String[][] pnx = new String[][] { pn1, pn2 };
- if (isParent (pnx)) {
- String code = attrs.getValue ("code");
+ if (isParent(pnx)) {
+ String code = attrs.getValue("code");
int cid = -1;
if (code == null) {
- missingRequiredAttribute (en, "code");
+ missingRequiredAttribute(en, "code");
} else {
code = code.toLowerCase();
- if (code.startsWith ("0x")) {
- cid = Integer.parseInt (code.substring (2), 16);
+ if (code.startsWith("0x")) {
+ cid = Integer.parseInt(code.substring(2), 16);
} else {
- cid = Integer.parseInt (code, 10);
+ cid = Integer.parseInt(code, 10);
}
}
- String name = attrs.getValue ("name");
+ String name = attrs.getValue("name");
int gid = -1;
if (name == null) {
- missingRequiredAttribute (en, "name");
+ missingRequiredAttribute(en, "name");
} else {
- gid = mapGlyphId (name, en);
+ gid = mapGlyphId(name, en);
}
if ((cmPlatform == 3) && (cmEncoding == 1)) {
- cmapEntries.add (new int[] { cid, gid });
+ cmapEntries.add(new int[] { cid, gid });
}
} else {
- notPermittedInElementContext (en, getParent(), pnx);
+ notPermittedInElementContext(en, getParent(), pnx);
}
- } else if (en[1].equals ("modified")) {
+ } else if (en[1].equals("modified")) {
String[] pn = new String[] { null, "head" };
- if (isParent (pn)) {
- String value = attrs.getValue ("value");
+ if (isParent(pn)) {
+ String value = attrs.getValue("value");
if (value == null) {
- missingRequiredAttribute (en, "value");
+ missingRequiredAttribute(en, "value");
}
} else {
- notPermittedInElementContext (en, getParent(), pn);
+ notPermittedInElementContext(en, getParent(), pn);
}
- } else if (en[1].equals ("mtx")) {
+ } else if (en[1].equals("mtx")) {
String[] pn = new String[] { null, "hmtx" };
- if (isParent (pn)) {
- String name = attrs.getValue ("name");
+ if (isParent(pn)) {
+ String name = attrs.getValue("name");
int gid = -1;
if (name == null) {
- missingRequiredAttribute (en, "name");
+ missingRequiredAttribute(en, "name");
} else {
- gid = mapGlyphId (name, en);
+ gid = mapGlyphId(name, en);
}
- String width = attrs.getValue ("width");
+ String width = attrs.getValue("width");
int w = -1;
if (width == null) {
- missingRequiredAttribute (en, "width");
+ missingRequiredAttribute(en, "width");
} else {
- w = Integer.parseInt (width);
+ w = Integer.parseInt(width);
}
- String lsb = attrs.getValue ("lsb");
+ String lsb = attrs.getValue("lsb");
int l = -1;
if (lsb == null) {
- missingRequiredAttribute (en, "lsb");
+ missingRequiredAttribute(en, "lsb");
} else {
- l = Integer.parseInt (lsb);
+ l = Integer.parseInt(lsb);
}
- hmtxEntries.set (gid, new int[] { w, l });
+ hmtxEntries.set(gid, new int[] { w, l });
} else {
- notPermittedInElementContext (en, getParent(), pn);
+ notPermittedInElementContext(en, getParent(), pn);
}
- } else if (en[1].equals ("tableVersion")) {
+ } else if (en[1].equals("tableVersion")) {
String[] pn1 = new String[] { null, "cmap" };
String[] pn2 = new String[] { null, "head" };
String[][] pnx = new String[][] { pn1, pn2 };
- if (isParent (pn1)) { // child of cmap
- String version = attrs.getValue ("version");
+ if (isParent(pn1)) { // child of cmap
+ String version = attrs.getValue("version");
if (version == null) {
- missingRequiredAttribute (en, "version");
+ missingRequiredAttribute(en, "version");
}
- } else if (isParent (pn2)) { // child of head
- String value = attrs.getValue ("value");
+ } else if (isParent(pn2)) { // child of head
+ String value = attrs.getValue("value");
if (value == null) {
- missingRequiredAttribute (en, "value");
+ missingRequiredAttribute(en, "value");
}
} else {
- notPermittedInElementContext (en, getParent(), pnx);
+ notPermittedInElementContext(en, getParent(), pnx);
}
- } else if (en[1].equals ("ttFont")) {
+ } else if (en[1].equals("ttFont")) {
String[] pn = new String[] { null, null };
- if (isParent (pn)) {
- String sfntVersion = attrs.getValue ("sfntVersion");
+ if (isParent(pn)) {
+ String sfntVersion = attrs.getValue("sfntVersion");
if (sfntVersion == null) {
- missingRequiredAttribute (en, "sfntVersion");
+ missingRequiredAttribute(en, "sfntVersion");
}
- String ttLibVersion = attrs.getValue ("ttLibVersion");
+ String ttLibVersion = attrs.getValue("ttLibVersion");
if (ttLibVersion == null) {
- missingRequiredAttribute (en, "ttLibVersion");
+ missingRequiredAttribute(en, "ttLibVersion");
}
} else {
- notPermittedInElementContext (en, getParent(), null);
+ notPermittedInElementContext(en, getParent(), null);
}
- } else if (en[1].equals ("unitsPerEm")) {
+ } else if (en[1].equals("unitsPerEm")) {
String[] pn = new String[] { null, "head" };
- if (isParent (pn)) {
- String value = attrs.getValue ("value");
+ if (isParent(pn)) {
+ String value = attrs.getValue("value");
int v = -1;
if (value == null) {
- missingRequiredAttribute (en, "value");
+ missingRequiredAttribute(en, "value");
} else {
- v = Integer.parseInt (value);
+ v = Integer.parseInt(value);
}
assert upem == -1;
upem = v;
} else {
- notPermittedInElementContext (en, getParent(), pn);
+ notPermittedInElementContext(en, getParent(), pn);
}
- } else if (en[1].equals ("xMax")) {
+ } else if (en[1].equals("xMax")) {
String[] pn = new String[] { null, "head" };
- if (isParent (pn)) {
- String value = attrs.getValue ("value");
+ if (isParent(pn)) {
+ String value = attrs.getValue("value");
if (value == null) {
- missingRequiredAttribute (en, "value");
+ missingRequiredAttribute(en, "value");
}
} else {
- notPermittedInElementContext (en, getParent(), pn);
+ notPermittedInElementContext(en, getParent(), pn);
}
- } else if (en[1].equals ("xMin")) {
+ } else if (en[1].equals("xMin")) {
String[] pn = new String[] { null, "head" };
- if (isParent (pn)) {
- String value = attrs.getValue ("value");
+ if (isParent(pn)) {
+ String value = attrs.getValue("value");
if (value == null) {
- missingRequiredAttribute (en, "value");
+ missingRequiredAttribute(en, "value");
}
} else {
- notPermittedInElementContext (en, getParent(), pn);
+ notPermittedInElementContext(en, getParent(), pn);
}
- } else if (en[1].equals ("yMax")) {
+ } else if (en[1].equals("yMax")) {
String[] pn = new String[] { null, "head" };
- if (isParent (pn)) {
- String value = attrs.getValue ("value");
+ if (isParent(pn)) {
+ String value = attrs.getValue("value");
if (value == null) {
- missingRequiredAttribute (en, "value");
+ missingRequiredAttribute(en, "value");
}
} else {
- notPermittedInElementContext (en, getParent(), pn);
+ notPermittedInElementContext(en, getParent(), pn);
}
- } else if (en[1].equals ("yMin")) {
+ } else if (en[1].equals("yMin")) {
String[] pn = new String[] { null, "head" };
- if (isParent (pn)) {
- String value = attrs.getValue ("value");
+ if (isParent(pn)) {
+ String value = attrs.getValue("value");
if (value == null) {
- missingRequiredAttribute (en, "value");
+ missingRequiredAttribute(en, "value");
}
} else {
- notPermittedInElementContext (en, getParent(), pn);
+ notPermittedInElementContext(en, getParent(), pn);
}
} else {
- unsupportedElement (en);
+ unsupportedElement(en);
}
- elements.push (en);
+ elements.push(en);
}
@Override
- public void endElement (String uri, String localName, String qName) throws SAXException {
+ public void endElement(String uri, String localName, String qName) throws SAXException {
if (elements.empty()) {
- throw new SAXException ("element stack is unbalanced, no elements on stack!");
+ throw new SAXException("element stack is unbalanced, no elements on stack!");
}
String[] enParent = elements.peek();
if (enParent == null) {
- throw new SAXException ("element stack is empty, elements are not balanced");
+ throw new SAXException("element stack is empty, elements are not balanced");
}
- String[] en = makeExpandedName (uri, localName, qName);
- if (! sameExpandedName (enParent, en)) {
- throw new SAXException ("element stack is unbalanced, expanded name mismatch");
+ String[] en = makeExpandedName(uri, localName, qName);
+ if (! sameExpandedName(enParent, en)) {
+ throw new SAXException("element stack is unbalanced, expanded name mismatch");
}
if (en[0] != null) {
- unsupportedElement (en);
- } else if (isAnchorElement (en[1])) {
+ unsupportedElement(en);
+ } else if (isAnchorElement(en[1])) {
if (xCoord == Integer.MIN_VALUE) {
- missingParameter (en, "x coordinate");
+ missingParameter(en, "x coordinate");
} else if (yCoord == Integer.MIN_VALUE) {
- missingParameter (en, "y coordinate");
+ missingParameter(en, "y coordinate");
} else {
- if (en[1].equals ("EntryAnchor")) {
+ if (en[1].equals("EntryAnchor")) {
if (anchors.size() > 0) {
- duplicateParameter (en, "entry anchor");
+ duplicateParameter(en, "entry anchor");
}
- } else if (en[1].equals ("ExitAnchor")) {
+ } else if (en[1].equals("ExitAnchor")) {
if (anchors.size() > 1) {
- duplicateParameter (en, "exit anchor");
+ duplicateParameter(en, "exit anchor");
} else if (anchors.size() == 0) {
- anchors.add (null);
+ anchors.add(null);
}
}
- anchors.add (new GlyphPositioningTable.Anchor (xCoord, yCoord));
+ anchors.add(new GlyphPositioningTable.Anchor(xCoord, yCoord));
xCoord = yCoord = Integer.MIN_VALUE;
}
- } else if (en[1].equals ("AlternateSet")) {
- subtableEntries.add (extractAlternates());
- } else if (en[1].equals ("AlternateSubst")) {
- if (! sortEntries (coverageEntries, subtableEntries)) {
- mismatchedEntries (en, coverageEntries.size(), subtableEntries.size());
- }
- addGSUBSubtable (GlyphSubstitutionTable.GSUB_LOOKUP_TYPE_ALTERNATE, extractCoverage());
- } else if (en[1].equals ("BacktrackCoverage")) {
- String ck = makeCoverageKey ("bk", ctIndex);
- if (coverages.containsKey (ck)) {
- duplicateCoverageIndex (en, ctIndex);
- } else {
- coverages.put (ck, extractCoverage());
- }
- } else if (en[1].equals ("BaseCoverage")) {
- coverages.put ("base", extractCoverage());
- } else if (en[1].equals ("BaseRecord")) {
- baseOrMarkAnchors.add (extractAnchors());
- } else if (en[1].equals ("ChainContextPos") || en[1].equals ("ChainContextSubst")) {
+ } else if (en[1].equals("AlternateSet")) {
+ subtableEntries.add(extractAlternates());
+ } else if (en[1].equals("AlternateSubst")) {
+ if (! sortEntries(coverageEntries, subtableEntries)) {
+ mismatchedEntries(en, coverageEntries.size(), subtableEntries.size());
+ }
+ addGSUBSubtable(GlyphSubstitutionTable.GSUB_LOOKUP_TYPE_ALTERNATE, extractCoverage());
+ } else if (en[1].equals("BacktrackCoverage")) {
+ String ck = makeCoverageKey("bk", ctIndex);
+ if (coverages.containsKey(ck)) {
+ duplicateCoverageIndex(en, ctIndex);
+ } else {
+ coverages.put(ck, extractCoverage());
+ }
+ } else if (en[1].equals("BaseCoverage")) {
+ coverages.put("base", extractCoverage());
+ } else if (en[1].equals("BaseRecord")) {
+ baseOrMarkAnchors.add(extractAnchors());
+ } else if (en[1].equals("ChainContextPos") || en[1].equals("ChainContextSubst")) {
GlyphCoverageTable coverage = null;
if (stFormat == 3) {
- GlyphCoverageTable igca[] = getCoveragesWithPrefix ("in");
- GlyphCoverageTable bgca[] = getCoveragesWithPrefix ("bk");
- GlyphCoverageTable lgca[] = getCoveragesWithPrefix ("la");
- if ((igca.length == 0) || hasMissingCoverage (igca)) {
- missingCoverage (en, "input", igca.length);
- } else if (hasMissingCoverage (bgca)) {
- missingCoverage (en, "backtrack", bgca.length);
- } else if (hasMissingCoverage (lgca)) {
- missingCoverage (en, "lookahead", lgca.length);
- } else {
- GlyphTable.Rule r = new GlyphTable.ChainedCoverageSequenceRule (extractRuleLookups(), igca.length, igca, bgca, lgca);
- GlyphTable.RuleSet rs = new GlyphTable.HomogeneousRuleSet (new GlyphTable.Rule[] {r});
+ GlyphCoverageTable igca[] = getCoveragesWithPrefix("in");
+ GlyphCoverageTable bgca[] = getCoveragesWithPrefix("bk");
+ GlyphCoverageTable lgca[] = getCoveragesWithPrefix("la");
+ if ((igca.length == 0) || hasMissingCoverage(igca)) {
+ missingCoverage(en, "input", igca.length);
+ } else if (hasMissingCoverage(bgca)) {
+ missingCoverage(en, "backtrack", bgca.length);
+ } else if (hasMissingCoverage(lgca)) {
+ missingCoverage(en, "lookahead", lgca.length);
+ } else {
+ GlyphTable.Rule r = new GlyphTable.ChainedCoverageSequenceRule(extractRuleLookups(), igca.length, igca, bgca, lgca);
+ GlyphTable.RuleSet rs = new GlyphTable.HomogeneousRuleSet(new GlyphTable.Rule[] {r});
GlyphTable.RuleSet[] rsa = new GlyphTable.RuleSet[] {rs};
coverage = igca [ 0 ];
- subtableEntries.add (rsa);
+ subtableEntries.add(rsa);
}
} else {
- unsupportedFormat (en, stFormat);
+ unsupportedFormat(en, stFormat);
}
- if (en[1].equals ("ChainContextPos")) {
- addGPOSSubtable (GlyphPositioningTable.GPOS_LOOKUP_TYPE_CHAINED_CONTEXTUAL, coverage);
- } else if (en[1].equals ("ChainContextSubst")) {
- addGSUBSubtable (GlyphSubstitutionTable.GSUB_LOOKUP_TYPE_CHAINED_CONTEXTUAL, coverage);
+ if (en[1].equals("ChainContextPos")) {
+ addGPOSSubtable(GlyphPositioningTable.GPOS_LOOKUP_TYPE_CHAINED_CONTEXTUAL, coverage);
+ } else if (en[1].equals("ChainContextSubst")) {
+ addGSUBSubtable(GlyphSubstitutionTable.GSUB_LOOKUP_TYPE_CHAINED_CONTEXTUAL, coverage);
}
- } else if (en[1].equals ("ComponentRecord")) {
- components.add (extractAnchors());
- } else if (en[1].equals ("Coverage")) {
- coverages.put ("main", extractCoverage());
- } else if (en[1].equals ("DefaultLangSys") || en[1].equals ("LangSysRecord")) {
+ } else if (en[1].equals("ComponentRecord")) {
+ components.add(extractAnchors());
+ } else if (en[1].equals("Coverage")) {
+ coverages.put("main", extractCoverage());
+ } else if (en[1].equals("DefaultLangSys") || en[1].equals("LangSysRecord")) {
if (languageTag == null) {
- missingTag (en, "language");
- } else if (languages.containsKey (languageTag)) {
- duplicateTag (en, "language", languageTag);
+ missingTag(en, "language");
+ } else if (languages.containsKey(languageTag)) {
+ duplicateTag(en, "language", languageTag);
} else {
- languages.put (languageTag, extractLanguageFeatures());
+ languages.put(languageTag, extractLanguageFeatures());
languageTag = null;
}
- } else if (en[1].equals ("CursivePos")) {
- GlyphCoverageTable ct = coverages.get ("main");
+ } else if (en[1].equals("CursivePos")) {
+ GlyphCoverageTable ct = coverages.get("main");
if (ct == null) {
- missingParameter (en, "coverages");
+ missingParameter(en, "coverages");
} else if (stFormat == 1) {
- subtableEntries.add (extractAttachmentAnchors());
+ subtableEntries.add(extractAttachmentAnchors());
} else {
- unsupportedFormat (en, stFormat);
+ unsupportedFormat(en, stFormat);
}
- addGPOSSubtable (GlyphPositioningTable.GPOS_LOOKUP_TYPE_CURSIVE, ct);
- } else if (en[1].equals ("EntryExitRecord")) {
+ addGPOSSubtable(GlyphPositioningTable.GPOS_LOOKUP_TYPE_CURSIVE, ct);
+ } else if (en[1].equals("EntryExitRecord")) {
int na = anchors.size();
if (na == 0) {
- missingParameter (en, "entry or exit anchor");
+ missingParameter(en, "entry or exit anchor");
} else if (na == 1) {
- anchors.add (null);
+ anchors.add(null);
} else if (na > 2) {
- duplicateParameter (en, "entry or exit anchor");
+ duplicateParameter(en, "entry or exit anchor");
}
- attachmentAnchors.add (extractAnchors());
- } else if (en[1].equals ("BaseRecord")) {
- baseOrMarkAnchors.add (extractAnchors());
- } else if (en[1].equals ("FeatureRecord")) {
+ attachmentAnchors.add(extractAnchors());
+ } else if (en[1].equals("BaseRecord")) {
+ baseOrMarkAnchors.add(extractAnchors());
+ } else if (en[1].equals("FeatureRecord")) {
if (flIndex != flSequence) {
- mismatchedIndex (en, "feature", flIndex, flSequence);
+ mismatchedIndex(en, "feature", flIndex, flSequence);
} else if (featureTag == null) {
- missingTag (en, "feature");
+ missingTag(en, "feature");
} else {
- String fid = makeFeatureId (flIndex);
- features.put (fid, extractFeature());
+ String fid = makeFeatureId(flIndex);
+ features.put(fid, extractFeature());
nextFeature();
}
- } else if (en[1].equals ("GDEF")) {
+ } else if (en[1].equals("GDEF")) {
if (subtables.size() > 0) {
- gdef = new GlyphDefinitionTable (subtables);
+ gdef = new GlyphDefinitionTable(subtables);
}
clearTable();
- } else if (en[1].equals ("GPOS")) {
+ } else if (en[1].equals("GPOS")) {
if (subtables.size() > 0) {
- gpos = new GlyphPositioningTable (gdef, extractLookups(), subtables);
+ gpos = new GlyphPositioningTable(gdef, extractLookups(), subtables);
}
clearTable();
- } else if (en[1].equals ("GSUB")) {
+ } else if (en[1].equals("GSUB")) {
if (subtables.size() > 0) {
- gsub = new GlyphSubstitutionTable (gdef, extractLookups(), subtables);
+ gsub = new GlyphSubstitutionTable(gdef, extractLookups(), subtables);
}
clearTable();
- } else if (en[1].equals ("GlyphClassDef")) {
- GlyphMappingTable mapping = extractClassDefMapping (glyphClasses, stFormat, true);
- addGDEFSubtable (GlyphDefinitionTable.GDEF_LOOKUP_TYPE_GLYPH_CLASS, mapping);
- } else if (en[1].equals ("InputCoverage")) {
- String ck = makeCoverageKey ("in", ctIndex);
- if (coverages.containsKey (ck)) {
- duplicateCoverageIndex (en, ctIndex);
- } else {
- coverages.put (ck, extractCoverage());
- }
- } else if (en[1].equals ("LigatureAttach")) {
- ligatureAnchors.add (extractComponents());
- } else if (en[1].equals ("LigatureCoverage")) {
- coverages.put ("liga", extractCoverage());
- } else if (en[1].equals ("LigatureSet")) {
- subtableEntries.add (extractLigatures());
- } else if (en[1].equals ("LigatureSubst")) {
- if (! sortEntries (coverageEntries, subtableEntries)) {
- mismatchedEntries (en, coverageEntries.size(), subtableEntries.size());
+ } else if (en[1].equals("GlyphClassDef")) {
+ GlyphMappingTable mapping = extractClassDefMapping(glyphClasses, stFormat, true);
+ addGDEFSubtable(GlyphDefinitionTable.GDEF_LOOKUP_TYPE_GLYPH_CLASS, mapping);
+ } else if (en[1].equals("InputCoverage")) {
+ String ck = makeCoverageKey("in", ctIndex);
+ if (coverages.containsKey(ck)) {
+ duplicateCoverageIndex(en, ctIndex);
+ } else {
+ coverages.put(ck, extractCoverage());
+ }
+ } else if (en[1].equals("LigatureAttach")) {
+ ligatureAnchors.add(extractComponents());
+ } else if (en[1].equals("LigatureCoverage")) {
+ coverages.put("liga", extractCoverage());
+ } else if (en[1].equals("LigatureSet")) {
+ subtableEntries.add(extractLigatures());
+ } else if (en[1].equals("LigatureSubst")) {
+ if (! sortEntries(coverageEntries, subtableEntries)) {
+ mismatchedEntries(en, coverageEntries.size(), subtableEntries.size());
}
GlyphCoverageTable coverage = extractCoverage();
- addGSUBSubtable (GlyphSubstitutionTable.GSUB_LOOKUP_TYPE_LIGATURE, coverage);
- } else if (en[1].equals ("LookAheadCoverage")) {
- String ck = makeCoverageKey ("la", ctIndex);
- if (coverages.containsKey (ck)) {
- duplicateCoverageIndex (en, ctIndex);
+ addGSUBSubtable(GlyphSubstitutionTable.GSUB_LOOKUP_TYPE_LIGATURE, coverage);
+ } else if (en[1].equals("LookAheadCoverage")) {
+ String ck = makeCoverageKey("la", ctIndex);
+ if (coverages.containsKey(ck)) {
+ duplicateCoverageIndex(en, ctIndex);
} else {
- coverages.put (ck, extractCoverage());
+ coverages.put(ck, extractCoverage());
}
- } else if (en[1].equals ("Lookup")) {
+ } else if (en[1].equals("Lookup")) {
if (ltIndex != ltSequence) {
- mismatchedIndex (en, "lookup", ltIndex, ltSequence);
+ mismatchedIndex(en, "lookup", ltIndex, ltSequence);
} else {
nextLookup();
}
- } else if (en[1].equals ("MarkAttachClassDef")) {
- GlyphMappingTable mapping = extractClassDefMapping (glyphClasses, stFormat, true);
- addGDEFSubtable (GlyphDefinitionTable.GDEF_LOOKUP_TYPE_MARK_ATTACHMENT, mapping);
- } else if (en[1].equals ("MarkCoverage")) {
- coverages.put ("mark", extractCoverage());
- } else if (en[1].equals ("Mark1Coverage")) {
- coverages.put ("mrk1", extractCoverage());
- } else if (en[1].equals ("Mark2Coverage")) {
- coverages.put ("mrk2", extractCoverage());
- } else if (en[1].equals ("MarkBasePos")) {
- GlyphCoverageTable mct = coverages.get ("mark");
- GlyphCoverageTable bct = coverages.get ("base");
+ } else if (en[1].equals("MarkAttachClassDef")) {
+ GlyphMappingTable mapping = extractClassDefMapping(glyphClasses, stFormat, true);
+ addGDEFSubtable(GlyphDefinitionTable.GDEF_LOOKUP_TYPE_MARK_ATTACHMENT, mapping);
+ } else if (en[1].equals("MarkCoverage")) {
+ coverages.put("mark", extractCoverage());
+ } else if (en[1].equals("Mark1Coverage")) {
+ coverages.put("mrk1", extractCoverage());
+ } else if (en[1].equals("Mark2Coverage")) {
+ coverages.put("mrk2", extractCoverage());
+ } else if (en[1].equals("MarkBasePos")) {
+ GlyphCoverageTable mct = coverages.get("mark");
+ GlyphCoverageTable bct = coverages.get("base");
if (mct == null) {
- missingParameter (en, "mark coverages");
+ missingParameter(en, "mark coverages");
} else if (bct == null) {
- missingParameter (en, "base coverages");
+ missingParameter(en, "base coverages");
} else if (stFormat == 1) {
MarkAnchor[] maa = extractMarkAnchors();
Anchor[][] bam = extractBaseOrMarkAnchors();
- subtableEntries.add (bct);
- subtableEntries.add (computeClassCount (bam));
- subtableEntries.add (maa);
- subtableEntries.add (bam);
+ subtableEntries.add(bct);
+ subtableEntries.add(computeClassCount(bam));
+ subtableEntries.add(maa);
+ subtableEntries.add(bam);
} else {
- unsupportedFormat (en, stFormat);
+ unsupportedFormat(en, stFormat);
}
- addGPOSSubtable (GlyphPositioningTable.GPOS_LOOKUP_TYPE_MARK_TO_BASE, mct);
- } else if (en[1].equals ("MarkLigPos")) {
- GlyphCoverageTable mct = coverages.get ("mark");
- GlyphCoverageTable lct = coverages.get ("liga");
+ addGPOSSubtable(GlyphPositioningTable.GPOS_LOOKUP_TYPE_MARK_TO_BASE, mct);
+ } else if (en[1].equals("MarkLigPos")) {
+ GlyphCoverageTable mct = coverages.get("mark");
+ GlyphCoverageTable lct = coverages.get("liga");
if (mct == null) {
- missingParameter (en, "mark coverages");
+ missingParameter(en, "mark coverages");
} else if (lct == null) {
- missingParameter (en, "ligature coverages");
+ missingParameter(en, "ligature coverages");
} else if (stFormat == 1) {
MarkAnchor[] maa = extractMarkAnchors();
Anchor[][][] lam = extractLigatureAnchors();
- subtableEntries.add (lct);
- subtableEntries.add (computeLigaturesClassCount (lam));
- subtableEntries.add (computeLigaturesComponentCount (lam));
- subtableEntries.add (maa);
- subtableEntries.add (lam);
- } else {
- unsupportedFormat (en, stFormat);
- }
- addGPOSSubtable (GlyphPositioningTable.GPOS_LOOKUP_TYPE_MARK_TO_LIGATURE, mct);
- } else if (en[1].equals ("MarkMarkPos")) {
- GlyphCoverageTable mct1 = coverages.get ("mrk1");
- GlyphCoverageTable mct2 = coverages.get ("mrk2");
+ subtableEntries.add(lct);
+ subtableEntries.add(computeLigaturesClassCount(lam));
+ subtableEntries.add(computeLigaturesComponentCount(lam));
+ subtableEntries.add(maa);
+ subtableEntries.add(lam);
+ } else {
+ unsupportedFormat(en, stFormat);
+ }
+ addGPOSSubtable(GlyphPositioningTable.GPOS_LOOKUP_TYPE_MARK_TO_LIGATURE, mct);
+ } else if (en[1].equals("MarkMarkPos")) {
+ GlyphCoverageTable mct1 = coverages.get("mrk1");
+ GlyphCoverageTable mct2 = coverages.get("mrk2");
if (mct1 == null) {
- missingParameter (en, "mark coverages 1");
+ missingParameter(en, "mark coverages 1");
} else if (mct2 == null) {
- missingParameter (en, "mark coverages 2");
+ missingParameter(en, "mark coverages 2");
} else if (stFormat == 1) {
MarkAnchor[] maa = extractMarkAnchors();
Anchor[][] mam = extractBaseOrMarkAnchors();
- subtableEntries.add (mct2);
- subtableEntries.add (computeClassCount (mam));
- subtableEntries.add (maa);
- subtableEntries.add (mam);
+ subtableEntries.add(mct2);
+ subtableEntries.add(computeClassCount(mam));
+ subtableEntries.add(maa);
+ subtableEntries.add(mam);
} else {
- unsupportedFormat (en, stFormat);
+ unsupportedFormat(en, stFormat);
}
- addGPOSSubtable (GlyphPositioningTable.GPOS_LOOKUP_TYPE_MARK_TO_MARK, mct1);
- } else if (en[1].equals ("MarkRecord")) {
+ addGPOSSubtable(GlyphPositioningTable.GPOS_LOOKUP_TYPE_MARK_TO_MARK, mct1);
+ } else if (en[1].equals("MarkRecord")) {
if (markClass == -1) {
- missingParameter (en, "mark class");
+ missingParameter(en, "mark class");
} else if (anchors.size() == 0) {
- missingParameter (en, "mark anchor");
+ missingParameter(en, "mark anchor");
} else if (anchors.size() > 1) {
- duplicateParameter (en, "mark anchor");
+ duplicateParameter(en, "mark anchor");
} else {
- markAnchors.add (new GlyphPositioningTable.MarkAnchor (markClass, anchors.get(0)));
+ markAnchors.add(new GlyphPositioningTable.MarkAnchor(markClass, anchors.get(0)));
markClass = -1;
anchors.clear();
}
- } else if (en[1].equals ("Mark2Record")) {
- baseOrMarkAnchors.add (extractAnchors());
- } else if (en[1].equals ("MultipleSubst")) {
- GlyphCoverageTable coverage = coverages.get ("main");
- addGSUBSubtable (GlyphSubstitutionTable.GSUB_LOOKUP_TYPE_MULTIPLE, coverage, extractSequenceEntries());
- } else if (en[1].equals ("PairPos")) {
+ } else if (en[1].equals("Mark2Record")) {
+ baseOrMarkAnchors.add(extractAnchors());
+ } else if (en[1].equals("MultipleSubst")) {
+ GlyphCoverageTable coverage = coverages.get("main");
+ addGSUBSubtable(GlyphSubstitutionTable.GSUB_LOOKUP_TYPE_MULTIPLE, coverage, extractSequenceEntries());
+ } else if (en[1].equals("PairPos")) {
assertSubtableEntriesClear();
if (stFormat == 1) {
if (pairSets.size() == 0) {
- missingParameter (en, "pair set");
+ missingParameter(en, "pair set");
} else {
- subtableEntries.add (extractPairSets());
+ subtableEntries.add(extractPairSets());
}
} else if (stFormat == 2) {
- unsupportedFormat (en, stFormat);
+ unsupportedFormat(en, stFormat);
}
- GlyphCoverageTable coverage = coverages.get ("main");
- addGPOSSubtable (GlyphPositioningTable.GPOS_LOOKUP_TYPE_PAIR, coverage);
+ GlyphCoverageTable coverage = coverages.get("main");
+ addGPOSSubtable(GlyphPositioningTable.GPOS_LOOKUP_TYPE_PAIR, coverage);
vf1 = vf2 = -1; psIndex = -1;
- } else if (en[1].equals ("PairSet")) {
+ } else if (en[1].equals("PairSet")) {
if (psIndex != pairSets.size()) {
- invalidIndex (en, psIndex, pairSets.size());
+ invalidIndex(en, psIndex, pairSets.size());
} else {
- pairSets.add (extractPairs());
+ pairSets.add(extractPairs());
}
- } else if (en[1].equals ("PairValueRecord")) {
+ } else if (en[1].equals("PairValueRecord")) {
if (g2 == -1) {
- missingParameter (en, "second glyph");
+ missingParameter(en, "second glyph");
} else if ((v1 == null) && (v2 == null)) {
- missingParameter (en, "first or second value");
+ missingParameter(en, "first or second value");
} else {
- pairs.add (new PairValues (g2, v1, v2));
+ pairs.add(new PairValues(g2, v1, v2));
clearPair();
}
- } else if (en[1].equals ("PosLookupRecord") || en[1].equals ("SubstLookupRecord")) {
+ } else if (en[1].equals("PosLookupRecord") || en[1].equals("SubstLookupRecord")) {
if (rlSequence < 0) {
- missingParameter (en, "sequence index");
+ missingParameter(en, "sequence index");
} else if (rlLookup < 0) {
- missingParameter (en, "lookup index");
+ missingParameter(en, "lookup index");
} else {
- ruleLookups.add (new GlyphTable.RuleLookup (rlSequence, rlLookup));
+ ruleLookups.add(new GlyphTable.RuleLookup(rlSequence, rlLookup));
rlSequence = rlLookup = -1;
}
- } else if (en[1].equals ("Script")) {
+ } else if (en[1].equals("Script")) {
if (scriptTag == null) {
- missingTag (en, "script");
- } else if (scripts.containsKey (scriptTag)) {
- duplicateTag (en, "script", scriptTag);
+ missingTag(en, "script");
+ } else if (scripts.containsKey(scriptTag)) {
+ duplicateTag(en, "script", scriptTag);
} else {
- scripts.put (scriptTag, extractLanguages());
+ scripts.put(scriptTag, extractLanguages());
scriptTag = null;
}
- } else if (en[1].equals ("Sequence")) {
- subtableEntries.add (extractSubstitutes());
- } else if (en[1].equals ("SinglePos")) {
+ } else if (en[1].equals("Sequence")) {
+ subtableEntries.add(extractSubstitutes());
+ } else if (en[1].equals("SinglePos")) {
int nv = subtableEntries.size();
if (stFormat == 1) {
if (nv < 0) {
- missingParameter (en, "value");
+ missingParameter(en, "value");
} else if (nv > 1) {
- duplicateParameter (en, "value");
+ duplicateParameter(en, "value");
}
} else if (stFormat == 2) {
- GlyphPositioningTable.Value[] pva = (GlyphPositioningTable.Value[]) subtableEntries.toArray (new GlyphPositioningTable.Value [ nv ]);
+ GlyphPositioningTable.Value[] pva = (GlyphPositioningTable.Value[]) subtableEntries.toArray(new GlyphPositioningTable.Value [ nv ]);
subtableEntries.clear();
- subtableEntries.add (pva);
+ subtableEntries.add(pva);
}
- GlyphCoverageTable coverage = coverages.get ("main");
- addGPOSSubtable (GlyphPositioningTable.GPOS_LOOKUP_TYPE_SINGLE, coverage);
+ GlyphCoverageTable coverage = coverages.get("main");
+ addGPOSSubtable(GlyphPositioningTable.GPOS_LOOKUP_TYPE_SINGLE, coverage);
vf1 = -1;
- } else if (en[1].equals ("SingleSubst")) {
- if (! sortEntries (coverageEntries, subtableEntries)) {
- mismatchedEntries (en, coverageEntries.size(), subtableEntries.size());
+ } else if (en[1].equals("SingleSubst")) {
+ if (! sortEntries(coverageEntries, subtableEntries)) {
+ mismatchedEntries(en, coverageEntries.size(), subtableEntries.size());
}
GlyphCoverageTable coverage = extractCoverage();
- addGSUBSubtable (GlyphSubstitutionTable.GSUB_LOOKUP_TYPE_SINGLE, coverage);
- } else if (en[1].equals ("cmap")) {
+ addGSUBSubtable(GlyphSubstitutionTable.GSUB_LOOKUP_TYPE_SINGLE, coverage);
+ } else if (en[1].equals("cmap")) {
cmap = getCMAP();
gmap = getGMAP();
cmapEntries.clear();
- } else if (en[1].equals ("cmap_format_4")) {
+ } else if (en[1].equals("cmap_format_4")) {
cmPlatform = cmEncoding = cmLanguage = -1;
- } else if (en[1].equals ("hmtx")) {
+ } else if (en[1].equals("hmtx")) {
hmtx = getHMTX();
hmtxEntries.clear();
- } else if (en[1].equals ("ttFont")) {
+ } else if (en[1].equals("ttFont")) {
if (cmap == null) {
- missingParameter (en, "cmap");
+ missingParameter(en, "cmap");
}
if (hmtx == null) {
- missingParameter (en, "hmtx");
+ missingParameter(en, "hmtx");
}
}
elements.pop();
}
@Override
- public void characters (char[] chars, int start, int length) {
+ public void characters(char[] chars, int start, int length) {
}
private String[] getParent() {
if (! elements.empty()) {
return new String[] { null, null };
}
}
- private boolean isParent (Object enx) {
+ private boolean isParent(Object enx) {
if (enx instanceof String[][]) {
for (String[] en : (String[][]) enx) {
- if (isParent (en)) {
+ if (isParent(en)) {
return true;
}
}
String[] en = (String[]) enx;
if (! elements.empty()) {
String[] pn = elements.peek();
- return (pn != null) && sameExpandedName (en, pn);
+ return (pn != null) && sameExpandedName(en, pn);
} else if ((en[0] == null) && (en[1] == null)) {
return true;
} else {
return false;
}
}
- private boolean isAnchorElement (String ln) {
- if (ln.equals ("BaseAnchor")) {
+ private boolean isAnchorElement(String ln) {
+ if (ln.equals("BaseAnchor")) {
return true;
- } else if (ln.equals ("EntryAnchor")) {
+ } else if (ln.equals("EntryAnchor")) {
return true;
- } else if (ln.equals ("ExitAnchor")) {
+ } else if (ln.equals("ExitAnchor")) {
return true;
- } else if (ln.equals ("LigatureAnchor")) {
+ } else if (ln.equals("LigatureAnchor")) {
return true;
- } else if (ln.equals ("MarkAnchor")) {
+ } else if (ln.equals("MarkAnchor")) {
return true;
- } else if (ln.equals ("Mark2Anchor")) {
+ } else if (ln.equals("Mark2Anchor")) {
return true;
} else {
return false;
private Map<Integer,Integer> getCMAP() {
Map<Integer,Integer> cmap = new TreeMap();
for (int[] cme : cmapEntries) {
- Integer c = Integer.valueOf (cme[0]);
- Integer g = Integer.valueOf (cme[1]);
- cmap.put (c, g);
+ Integer c = Integer.valueOf(cme[0]);
+ Integer g = Integer.valueOf(cme[1]);
+ cmap.put(c, g);
}
return cmap;
}
private Map<Integer,Integer> getGMAP() {
Map<Integer,Integer> gmap = new TreeMap();
for (int[] cme : cmapEntries) {
- Integer c = Integer.valueOf (cme[0]);
- Integer g = Integer.valueOf (cme[1]);
- gmap.put (g, c);
+ Integer c = Integer.valueOf(cme[0]);
+ Integer g = Integer.valueOf(cme[1]);
+ gmap.put(g, c);
}
return gmap;
}
}
return hmtx;
}
- private GlyphClassTable extractClassDefMapping (Map<String,Integer> glyphClasses, int format, boolean clearSourceMap) {
+ private GlyphClassTable extractClassDefMapping(Map<String,Integer> glyphClasses, int format, boolean clearSourceMap) {
GlyphClassTable ct;
if (format == 1) {
- ct = extractClassDefMapping1 (extractClassMappings (glyphClasses, clearSourceMap));
+ ct = extractClassDefMapping1(extractClassMappings(glyphClasses, clearSourceMap));
} else if (format == 2) {
- ct = extractClassDefMapping2 (extractClassMappings (glyphClasses, clearSourceMap));
+ ct = extractClassDefMapping2(extractClassMappings(glyphClasses, clearSourceMap));
} else {
ct = null;
}
return ct;
}
- private GlyphClassTable extractClassDefMapping1 (int[][] cma) {
+ private GlyphClassTable extractClassDefMapping1(int[][] cma) {
List entries = new ArrayList<Integer>();
int s = -1;
int l = -1;
if (s < 0) {
s = g;
l = g - 1;
- entries.add (Integer.valueOf (s));
+ entries.add(Integer.valueOf(s));
}
while (g > (l + 1)) {
- entries.add (zero);
+ entries.add(zero);
l++;
}
assert l == (g - 1);
- entries.add (Integer.valueOf (c));
+ entries.add(Integer.valueOf(c));
l = g;
}
- return GlyphClassTable.createClassTable (entries);
+ return GlyphClassTable.createClassTable(entries);
}
- private GlyphClassTable extractClassDefMapping2 (int[][] cma) {
+ private GlyphClassTable extractClassDefMapping2(int[][] cma) {
List entries = new ArrayList<Integer>();
int s = -1;
int e = s;
int c = m[1];
if (c != l) {
if (s >= 0) {
- entries.add (new GlyphClassTable.MappingRange (s, e, l));
+ entries.add(new GlyphClassTable.MappingRange(s, e, l));
}
s = e = g;
} else {
}
l = c;
}
- return GlyphClassTable.createClassTable (entries);
+ return GlyphClassTable.createClassTable(entries);
}
- private int[][] extractClassMappings (Map<String,Integer> glyphClasses, boolean clearSourceMap) {
+ private int[][] extractClassMappings(Map<String,Integer> glyphClasses, boolean clearSourceMap) {
int nc = glyphClasses.size();
int i = 0;
int[][] cma = new int [ nc ] [ 2 ];
for (Map.Entry<String,Integer> e : glyphClasses.entrySet()) {
- Integer gid = glyphIds.get (e.getKey());
+ Integer gid = glyphIds.get(e.getKey());
assert gid != null;
int[] m = cma [ i ];
m [ 0 ] = (int) gid;
if (clearSourceMap) {
glyphClasses.clear();
}
- return sortClassMappings (cma);
+ return sortClassMappings(cma);
}
- private int[][] sortClassMappings (int[][] cma) {
- Arrays.sort (cma, new Comparator<int[]>() {
- public int compare (int[] m1, int[] m2) {
+ private int[][] sortClassMappings(int[][] cma) {
+ Arrays.sort(cma, new Comparator<int[]>() {
+ public int compare(int[] m1, int[] m2) {
assert m1.length > 0;
assert m2.length > 0;
if (m1[0] < m2[0]) {
return cma;
}
// sort coverage entries and subtable entries together
- private boolean sortEntries (List cel, List sel) {
+ private boolean sortEntries(List cel, List sel) {
assert cel != null;
assert sel != null;
if (cel.size() == sel.size()) {
int np = cel.size();
Object[][] pa = new Object [ np ] [ 2 ];
for (int i = 0; i < np; i++) {
- pa [ i ] [ 0 ] = cel.get (i);
- pa [ i ] [ 1 ] = sel.get (i);
+ pa [ i ] [ 0 ] = cel.get(i);
+ pa [ i ] [ 1 ] = sel.get(i);
}
- Arrays.sort (pa, new Comparator<Object[]>() {
- public int compare (Object[] p1, Object[] p2) {
+ Arrays.sort(pa, new Comparator<Object[]>() {
+ public int compare(Object[] p1, Object[] p2) {
assert p1.length == 2;
assert p2.length == 2;
int c1 = (Integer) p1[0];
cel.clear();
sel.clear();
for (int i = 0; i < np; i++) {
- cel.add (pa [ i ] [ 0 ]);
- sel.add (pa [ i ] [ 1 ]);
+ cel.add(pa [ i ] [ 0 ]);
+ sel.add(pa [ i ] [ 1 ]);
}
assert cel.size() == sel.size();
return true;
return false;
}
}
- private String makeCoverageKey (String prefix, int index) {
+ private String makeCoverageKey(String prefix, int index) {
assert prefix != null;
assert prefix.length() == 2;
assert index < 100;
- return prefix + CharUtilities.padLeft (Integer.toString (index, 10), 2, '0');
+ return prefix + CharUtilities.padLeft(Integer.toString(index, 10), 2, '0');
}
private List extractCoverageEntries() {
- List entries = new ArrayList<Integer> (coverageEntries);
+ List entries = new ArrayList<Integer>(coverageEntries);
clearCoverage();
return entries;
}
private GlyphCoverageTable extractCoverage() {
assert (ctFormat == 1) || (ctFormat == 2);
assert ctIndex >= 0;
- GlyphCoverageTable coverage = GlyphCoverageTable.createCoverageTable (extractCoverageEntries());
+ GlyphCoverageTable coverage = GlyphCoverageTable.createCoverageTable(extractCoverageEntries());
clearCoverage();
return coverage;
}
private void assertCoveragesClear() {
assert coverages.size() == 0;
}
- private GlyphCoverageTable[] getCoveragesWithPrefix (String prefix) {
+ private GlyphCoverageTable[] getCoveragesWithPrefix(String prefix) {
assert prefix != null;
int prefixLength = prefix.length();
Set<String> keys = coverages.keySet();
int mi = -1; // maximum coverage table index
for (String k : keys) {
- if (k.startsWith (prefix)) {
- int i = Integer.parseInt (k.substring (prefixLength));
+ if (k.startsWith(prefix)) {
+ int i = Integer.parseInt(k.substring(prefixLength));
if (i > mi) {
mi = i;
}
}
GlyphCoverageTable[] gca = new GlyphCoverageTable [ mi + 1 ];
for (String k : keys) {
- if (k.startsWith (prefix)) {
- int i = Integer.parseInt (k.substring (prefixLength));
+ if (k.startsWith(prefix)) {
+ int i = Integer.parseInt(k.substring(prefixLength));
if (i >= 0) {
- gca [ i ] = coverages.get (k);
+ gca [ i ] = coverages.get(k);
}
}
}
return gca;
}
- private boolean hasMissingCoverage (GlyphCoverageTable[] gca) {
+ private boolean hasMissingCoverage(GlyphCoverageTable[] gca) {
assert gca != null;
int nc = 0;
for (int i = 0, n = gca.length; i < n; i++) {
}
return nc != gca.length;
}
- private String makeFeatureId (int fid) {
+ private String makeFeatureId(int fid) {
assert fid >= 0;
return "f" + fid;
}
- private String makeLookupId (int lid) {
+ private String makeLookupId(int lid) {
assert lid >= 0;
return "lu" + lid;
}
languageFeatures.clear();
}
private Map<String,List<String>> extractLanguages() {
- Map<String,List<String>> lm = new HashMap (languages);
+ Map<String,List<String>> lm = new HashMap(languages);
clearLanguages();
return lm;
}
assert featureLookups.size() == 0;
}
private List extractFeatureLookups() {
- List lookups = new ArrayList<String> (featureLookups);
+ List lookups = new ArrayList<String>(featureLookups);
clearFeatureLookups();
return lookups;
}
private Map<GlyphTable.LookupSpec,List<String>> extractLookups() {
Map<GlyphTable.LookupSpec,List<String>> lookups = new LinkedHashMap<GlyphTable.LookupSpec,List<String>>();
for (String st : scripts.keySet()) {
- Map<String,List<String>> lm = scripts.get (st);
+ Map<String,List<String>> lm = scripts.get(st);
if (lm != null) {
for (String lt : lm.keySet()) {
- List<String> fids = lm.get (lt);
+ List<String> fids = lm.get(lt);
if (fids != null) {
for (String fid : fids) {
if (fid != null) {
- Object[] fa = features.get (fid);
+ Object[] fa = features.get(fid);
if (fa != null) {
assert fa.length == 2;
String ft = (String) fa[0];
List<String> lids = (List<String>) fa[1];
if ((lids != null) && (lids.size() > 0)) {
- GlyphTable.LookupSpec ls = new GlyphTable.LookupSpec (st, lt, ft);
- lookups.put (ls, lids);
+ GlyphTable.LookupSpec ls = new GlyphTable.LookupSpec(st, lt, ft);
+ lookups.put(ls, lids);
}
}
}
assert subtableEntries.size() == 0;
}
private List extractSubtableEntries() {
- List entries = new ArrayList (subtableEntries);
+ List entries = new ArrayList(subtableEntries);
clearSubtableEntries();
return entries;
}
alternates.clear();
}
private LigatureSet extractLigatures() {
- LigatureSet ls = new LigatureSet (ligatures);
+ LigatureSet ls = new LigatureSet(ligatures);
clearLigatures();
return ls;
}
}
}
List entries = new ArrayList();
- entries.add (sa);
+ entries.add(sa);
return entries;
}
private RuleLookup[] extractRuleLookups() {
- RuleLookup[] lookups = (RuleLookup[]) ruleLookups.toArray (new RuleLookup [ ruleLookups.size() ]);
+ RuleLookup[] lookups = (RuleLookup[]) ruleLookups.toArray(new RuleLookup [ ruleLookups.size() ]);
clearRuleLookups();
return lookups;
}
private void clearRuleLookups() {
ruleLookups.clear();
}
- private GlyphPositioningTable.Value parseValue (String[] en, Attributes attrs, int format) throws SAXException {
- String xPlacement = attrs.getValue ("XPlacement");
+ private GlyphPositioningTable.Value parseValue(String[] en, Attributes attrs, int format) throws SAXException {
+ String xPlacement = attrs.getValue("XPlacement");
int xp = 0;
if (xPlacement != null) {
- xp = Integer.parseInt (xPlacement);
+ xp = Integer.parseInt(xPlacement);
} else if ((format & GlyphPositioningTable.Value.X_PLACEMENT) != 0) {
- missingParameter (en, "xPlacement");
+ missingParameter(en, "xPlacement");
}
- String yPlacement = attrs.getValue ("YPlacement");
+ String yPlacement = attrs.getValue("YPlacement");
int yp = 0;
if (yPlacement != null) {
- yp = Integer.parseInt (yPlacement);
+ yp = Integer.parseInt(yPlacement);
} else if ((format & GlyphPositioningTable.Value.Y_PLACEMENT) != 0) {
- missingParameter (en, "yPlacement");
+ missingParameter(en, "yPlacement");
}
- String xAdvance = attrs.getValue ("XAdvance");
+ String xAdvance = attrs.getValue("XAdvance");
int xa = 0;
if (xAdvance != null) {
- xa = Integer.parseInt (xAdvance);
+ xa = Integer.parseInt(xAdvance);
} else if ((format & GlyphPositioningTable.Value.X_ADVANCE) != 0) {
- missingParameter (en, "xAdvance");
+ missingParameter(en, "xAdvance");
}
- String yAdvance = attrs.getValue ("YAdvance");
+ String yAdvance = attrs.getValue("YAdvance");
int ya = 0;;
if (yAdvance != null) {
- ya = Integer.parseInt (yAdvance);
+ ya = Integer.parseInt(yAdvance);
} else if ((format & GlyphPositioningTable.Value.Y_ADVANCE) != 0) {
- missingParameter (en, "yAdvance");
+ missingParameter(en, "yAdvance");
}
- return new GlyphPositioningTable.Value (xp, yp, xa, ya, null, null, null, null);
+ return new GlyphPositioningTable.Value(xp, yp, xa, ya, null, null, null, null);
}
private void assertPairClear() {
assert g2 == -1;
psIndex = -1;
}
private PairValues[] extractPairs() {
- PairValues[] pva = (PairValues[]) pairs.toArray (new PairValues [ pairs.size() ]);
+ PairValues[] pva = (PairValues[]) pairs.toArray(new PairValues [ pairs.size() ]);
clearPairs();
return pva;
}
pairSets.clear();
}
private PairValues[][] extractPairSets() {
- PairValues[][] pvm = (PairValues[][]) pairSets.toArray (new PairValues [ pairSets.size() ][]);
+ PairValues[][] pvm = (PairValues[][]) pairSets.toArray(new PairValues [ pairSets.size() ][]);
clearPairSets();
return pvm;
}
private Anchor[] extractAnchors() {
- Anchor[] aa = (Anchor[]) anchors.toArray (new Anchor [ anchors.size() ]);
+ Anchor[] aa = (Anchor[]) anchors.toArray(new Anchor [ anchors.size() ]);
anchors.clear();
return aa;
}
private MarkAnchor[] extractMarkAnchors() {
MarkAnchor[] maa = new MarkAnchor [ markAnchors.size() ];
- maa = (MarkAnchor[]) markAnchors.toArray (new MarkAnchor [ maa.length ]);
+ maa = (MarkAnchor[]) markAnchors.toArray(new MarkAnchor [ maa.length ]);
markAnchors.clear();
return maa;
}
baseOrMarkAnchors.clear();
return am;
}
- private Integer computeClassCount (Anchor[][] am) {
+ private Integer computeClassCount(Anchor[][] am) {
int ncMax = 0;
for (int i = 0, n = am.length; i < n; i++) {
Anchor[] aa = am [ i ];
}
}
}
- return Integer.valueOf (ncMax);
+ return Integer.valueOf(ncMax);
}
private Anchor[][] extractComponents() {
Anchor[][] cam = new Anchor [ components.size() ][];
- cam = (Anchor[][]) components.toArray (new Anchor [ cam.length ][]);
+ cam = (Anchor[][]) components.toArray(new Anchor [ cam.length ][]);
components.clear();
return cam;
}
ligatureAnchors.clear();
return lam;
}
- private Integer computeLigaturesClassCount (Anchor[][][] lam) {
+ private Integer computeLigaturesClassCount(Anchor[][][] lam) {
int ncMax = 0;
if (lam != null) {
for (Anchor[][] cm : lam) {
}
}
}
- return Integer.valueOf (ncMax);
+ return Integer.valueOf(ncMax);
}
- private Integer computeLigaturesComponentCount (Anchor[][][] lam) {
+ private Integer computeLigaturesComponentCount(Anchor[][][] lam) {
int nxMax = 0;
if (lam != null) {
for (Anchor[][] cm : lam) {
}
}
}
- return Integer.valueOf (nxMax);
+ return Integer.valueOf(nxMax);
}
private Anchor[] extractAttachmentAnchors() {
int na = attachmentAnchors.size();
attachmentAnchors.clear();
return aa;
}
- private void addGDEFSubtable (int stType, GlyphMappingTable mapping) {
- subtables.add (GlyphDefinitionTable.createSubtable (stType, makeLookupId (ltSequence), stSequence, ltFlags, stFormat, mapping, extractSubtableEntries()));
+ private void addGDEFSubtable(int stType, GlyphMappingTable mapping) {
+ subtables.add(GlyphDefinitionTable.createSubtable(stType, makeLookupId(ltSequence), stSequence, ltFlags, stFormat, mapping, extractSubtableEntries()));
nextSubtableInLookup();
}
- private void addGSUBSubtable (int stType, GlyphCoverageTable coverage, List entries) {
- subtables.add (GlyphSubstitutionTable.createSubtable (stType, makeLookupId (ltSequence), stSequence, ltFlags, stFormat, coverage, entries));
+ private void addGSUBSubtable(int stType, GlyphCoverageTable coverage, List entries) {
+ subtables.add(GlyphSubstitutionTable.createSubtable(stType, makeLookupId(ltSequence), stSequence, ltFlags, stFormat, coverage, entries));
nextSubtableInLookup();
}
- private void addGSUBSubtable (int stType, GlyphCoverageTable coverage) {
- addGSUBSubtable (stType, coverage, extractSubtableEntries());
+ private void addGSUBSubtable(int stType, GlyphCoverageTable coverage) {
+ addGSUBSubtable(stType, coverage, extractSubtableEntries());
}
- private void addGPOSSubtable (int stType, GlyphCoverageTable coverage, List entries) {
- subtables.add (GlyphPositioningTable.createSubtable (stType, makeLookupId (ltSequence), stSequence, ltFlags, stFormat, coverage, entries));
+ private void addGPOSSubtable(int stType, GlyphCoverageTable coverage, List entries) {
+ subtables.add(GlyphPositioningTable.createSubtable(stType, makeLookupId(ltSequence), stSequence, ltFlags, stFormat, coverage, entries));
nextSubtableInLookup();
}
- private void addGPOSSubtable (int stType, GlyphCoverageTable coverage) {
- addGPOSSubtable (stType, coverage, extractSubtableEntries());
+ private void addGPOSSubtable(int stType, GlyphCoverageTable coverage) {
+ addGPOSSubtable(stType, coverage, extractSubtableEntries());
}
}
- private int mapGlyphId0 (String glyph) {
+ private int mapGlyphId0(String glyph) {
assert glyphIds != null;
- Integer gid = glyphIds.get (glyph);
+ Integer gid = glyphIds.get(glyph);
if (gid != null) {
return (int) gid;
} else {
return -1;
}
}
- private int mapGlyphId (String glyph, String[] currentElement) throws SAXException {
- int g = mapGlyphId0 (glyph);
+ private int mapGlyphId(String glyph, String[] currentElement) throws SAXException {
+ int g = mapGlyphId0(glyph);
if (g < 0) {
- unsupportedGlyph (currentElement, glyph);
+ unsupportedGlyph(currentElement, glyph);
return -1;
} else {
return g;
}
}
- private int[] mapGlyphIds (String glyphs, String[] currentElement) throws SAXException {
+ private int[] mapGlyphIds(String glyphs, String[] currentElement) throws SAXException {
String[] ga = glyphs.split(",");
int[] gids = new int [ ga.length ];
int i = 0;
for (String glyph : ga) {
- gids[i++] = mapGlyphId (glyph, currentElement);
+ gids[i++] = mapGlyphId(glyph, currentElement);
}
return gids;
}
- private int mapGlyphIdToChar (String glyph) {
+ private int mapGlyphIdToChar(String glyph) {
assert glyphIds != null;
- Integer gid = glyphIds.get (glyph);
+ Integer gid = glyphIds.get(glyph);
if (gid != null) {
if (gmap != null) {
- Integer cid = gmap.get (gid);
+ Integer cid = gmap.get(gid);
if (cid != null) {
return cid.intValue();
}
return "{" + locator.getSystemId() + ":" + locator.getLineNumber() + ":" + locator.getColumnNumber() + "}";
}
}
- private void unsupportedElement (String[] en) throws SAXException {
- throw new SAXException (formatLocator() + ": unsupported element " + formatExpandedName (en));
+ private void unsupportedElement(String[] en) throws SAXException {
+ throw new SAXException(formatLocator() + ": unsupported element " + formatExpandedName(en));
}
- private void notPermittedInElementContext (String[] en, String[] cn, Object xns) throws SAXException {
+ private void notPermittedInElementContext(String[] en, String[] cn, Object xns) throws SAXException {
assert en != null;
assert cn != null;
String s = "element " + formatExpandedName(en) + " not permitted in current element context " + formatExpandedName(cn);
if (nxn++ > 0) {
s += ", ";
}
- s += formatExpandedName (xn);
+ s += formatExpandedName(xn);
}
s += " }";
} else if (xns instanceof String[]) {
- s += ", expected " + formatExpandedName ((String[]) xns);
+ s += ", expected " + formatExpandedName((String[]) xns);
}
- throw new SAXException (formatLocator() + ": " + s);
+ throw new SAXException(formatLocator() + ": " + s);
}
- private void missingRequiredAttribute (String[] en, String name) throws SAXException {
- throw new SAXException (formatLocator() + ": element " + formatExpandedName(en) + " missing required attribute " + name);
+ private void missingRequiredAttribute(String[] en, String name) throws SAXException {
+ throw new SAXException(formatLocator() + ": element " + formatExpandedName(en) + " missing required attribute " + name);
}
- private void duplicateGlyph (String[] en, String name, int gid) throws SAXException {
- throw new SAXException (formatLocator() + ": element " + formatExpandedName(en) + " contains duplicate name \"" + name + "\", with identifier value " + gid);
+ private void duplicateGlyph(String[] en, String name, int gid) throws SAXException {
+ throw new SAXException(formatLocator() + ": element " + formatExpandedName(en) + " contains duplicate name \"" + name + "\", with identifier value " + gid);
}
- private void unsupportedGlyph (String[] en, String name) throws SAXException {
- throw new SAXException (formatLocator() + ": element " + formatExpandedName(en) + " refers to unsupported glyph id \"" + name + "\"");
+ private void unsupportedGlyph(String[] en, String name) throws SAXException {
+ throw new SAXException(formatLocator() + ": element " + formatExpandedName(en) + " refers to unsupported glyph id \"" + name + "\"");
}
- private void duplicateCMAPCharacter (String[] en, int cid) throws SAXException {
- throw new SAXException (formatLocator() + ": element " + formatExpandedName(en) + " contains duplicate cmap character code: " + CharUtilities.format (cid));
+ private void duplicateCMAPCharacter(String[] en, int cid) throws SAXException {
+ throw new SAXException(formatLocator() + ": element " + formatExpandedName(en) + " contains duplicate cmap character code: " + CharUtilities.format(cid));
}
- private void duplicateCMAPGlyph (String[] en, int gid) throws SAXException {
- throw new SAXException (formatLocator() + ": element " + formatExpandedName(en) + " contains duplicate cmap glyph code: " + gid);
+ private void duplicateCMAPGlyph(String[] en, int gid) throws SAXException {
+ throw new SAXException(formatLocator() + ": element " + formatExpandedName(en) + " contains duplicate cmap glyph code: " + gid);
}
- private void duplicateGlyphClass (String[] en, String name, String glyphClass) throws SAXException {
- throw new SAXException (formatLocator() + ": element " + formatExpandedName(en) + " contains duplicate glyph class for \"" + name + "\", with class value " + glyphClass);
+ private void duplicateGlyphClass(String[] en, String name, String glyphClass) throws SAXException {
+ throw new SAXException(formatLocator() + ": element " + formatExpandedName(en) + " contains duplicate glyph class for \"" + name + "\", with class value " + glyphClass);
}
- private void unsupportedFormat (String[] en, int format) throws SAXException {
- throw new SAXException (formatLocator() + ": element " + formatExpandedName(en) + " refers to unsupported table format \"" + format + "\"");
+ private void unsupportedFormat(String[] en, int format) throws SAXException {
+ throw new SAXException(formatLocator() + ": element " + formatExpandedName(en) + " refers to unsupported table format \"" + format + "\"");
}
- private void invalidIndex (String[] en, int actual, int expected) throws SAXException {
- throw new SAXException (formatLocator() + ": element " + formatExpandedName(en) + " specifies invalid index " + actual + ", expected " + expected);
+ private void invalidIndex(String[] en, int actual, int expected) throws SAXException {
+ throw new SAXException(formatLocator() + ": element " + formatExpandedName(en) + " specifies invalid index " + actual + ", expected " + expected);
}
- private void mismatchedIndex (String[] en, String label, int actual, int expected) throws SAXException {
- throw new SAXException (formatLocator() + ": element " + formatExpandedName(en) + " mismatched " + label + " index: got " + actual + ", expected " + expected);
+ private void mismatchedIndex(String[] en, String label, int actual, int expected) throws SAXException {
+ throw new SAXException(formatLocator() + ": element " + formatExpandedName(en) + " mismatched " + label + " index: got " + actual + ", expected " + expected);
}
- private void mismatchedEntries (String[] en, int nce, int nse) throws SAXException {
- throw new SAXException (formatLocator() + ": element " + formatExpandedName(en) + " mismatched coverage and subtable entry counts, # coverages " + nce + ", # entries " + nse);
+ private void mismatchedEntries(String[] en, int nce, int nse) throws SAXException {
+ throw new SAXException(formatLocator() + ": element " + formatExpandedName(en) + " mismatched coverage and subtable entry counts, # coverages " + nce + ", # entries " + nse);
}
- private void missingParameter (String[] en, String label) throws SAXException {
- throw new SAXException (formatLocator() + ": element " + formatExpandedName(en) + " missing " + label + " parameter");
+ private void missingParameter(String[] en, String label) throws SAXException {
+ throw new SAXException(formatLocator() + ": element " + formatExpandedName(en) + " missing " + label + " parameter");
}
- private void duplicateParameter (String[] en, String label) throws SAXException {
- throw new SAXException (formatLocator() + ": element " + formatExpandedName(en) + " duplicate " + label + " parameter");
+ private void duplicateParameter(String[] en, String label) throws SAXException {
+ throw new SAXException(formatLocator() + ": element " + formatExpandedName(en) + " duplicate " + label + " parameter");
}
- private void duplicateCoverageIndex (String[] en, int index) throws SAXException {
- throw new SAXException (formatLocator() + ": element " + formatExpandedName(en) + " duplicate coverage table index " + index);
+ private void duplicateCoverageIndex(String[] en, int index) throws SAXException {
+ throw new SAXException(formatLocator() + ": element " + formatExpandedName(en) + " duplicate coverage table index " + index);
}
- private void missingCoverage (String[] en, String type, int expected) throws SAXException {
- throw new SAXException (formatLocator() + ": element " + formatExpandedName(en) + " missing " + type + " coverage table, expected " + ((expected > 0) ? expected : 1) + " table(s)");
+ private void missingCoverage(String[] en, String type, int expected) throws SAXException {
+ throw new SAXException(formatLocator() + ": element " + formatExpandedName(en) + " missing " + type + " coverage table, expected " + ((expected > 0) ? expected : 1) + " table(s)");
}
- private void missingTag (String[] en, String label) throws SAXException {
- throw new SAXException (formatLocator() + ": element " + formatExpandedName(en) + " missing " + label + " tag");
+ private void missingTag(String[] en, String label) throws SAXException {
+ throw new SAXException(formatLocator() + ": element " + formatExpandedName(en) + " missing " + label + " tag");
}
- private void duplicateTag (String[] en, String label, String tag) throws SAXException {
- throw new SAXException (formatLocator() + ": element " + formatExpandedName(en) + " duplicate " + label + " tag: " + tag);
+ private void duplicateTag(String[] en, String label, String tag) throws SAXException {
+ throw new SAXException(formatLocator() + ": element " + formatExpandedName(en) + " duplicate " + label + " tag: " + tag);
}
- private static String[] makeExpandedName (String uri, String localName, String qName) {
+ private static String[] makeExpandedName(String uri, String localName, String qName) {
if ((uri != null) && (uri.length() == 0)) {
uri = null;
}
localName = null;
}
if ((uri == null) && (localName == null)) {
- uri = extractPrefix (qName);
- localName = extractLocalName (qName);
+ uri = extractPrefix(qName);
+ localName = extractLocalName(qName);
}
return new String[] { uri, localName };
}
- private static String extractPrefix (String qName) {
+ private static String extractPrefix(String qName) {
String[] sa = qName.split(":");
if (sa.length == 2) {
return sa[0];
return null;
}
}
- private static String extractLocalName (String qName) {
+ private static String extractLocalName(String qName) {
String[] sa = qName.split(":");
if (sa.length == 2) {
return sa[1];
return null;
}
}
- private static boolean sameExpandedName (String[] n1, String[] n2) {
+ private static boolean sameExpandedName(String[] n1, String[] n2) {
String u1 = n1[0];
String u2 = n2[0];
if ((u1 == null) ^ (u2 == null)) {
return false;
}
if ((u1 != null) && (u2 != null)) {
- if (! u1.equals (u2)) {
+ if (! u1.equals(u2)) {
return false;
}
}
return false;
}
if ((l1 != null) && (l2 != null)) {
- if (! l1.equals (l2)) {
+ if (! l1.equals(l2)) {
return false;
}
}
return true;
}
- private static String formatExpandedName (String[] n) {
+ private static String formatExpandedName(String[] n) {
String u = (n[0] != null) ? n[0] : "null";
String l = (n[1] != null) ? n[1] : "null";
return "{" + u + "}" + l;
public void testTTXFiles() throws Exception {
for (String tfn : ttxFiles) {
try {
- TTXFile tf = TTXFile.getFromCache (ttxFilesRoot + File.separator + tfn);
- assertTrue (tf != null);
+ TTXFile tf = TTXFile.getFromCache(ttxFilesRoot + File.separator + tfn);
+ assertTrue(tf != null);
} catch (Exception e) {
- fail (e.getMessage());
+ fail(e.getMessage());
}
}
}
public void testArabicWordForms() {
for (String sfn : srcFiles) {
try {
- processWordForms (new File (datFilesDir));
+ processWordForms(new File(datFilesDir));
} catch (Exception e) {
- fail (e.getMessage());
+ fail(e.getMessage());
}
}
}
- private void processWordForms (File dfd) {
- String[] files = listWordFormFiles (dfd);
+ private void processWordForms(File dfd) {
+ String[] files = listWordFormFiles(dfd);
for (String fn : files) {
- File dff = new File (dfd, fn);
- processWordForms (dff.getAbsolutePath());
+ File dff = new File(dfd, fn);
+ processWordForms(dff.getAbsolutePath());
}
}
- private String[] listWordFormFiles (File dfd) {
- return dfd.list (new FilenameFilter() {
- public boolean accept (File f, String name) {
- return hasPrefixFrom (name, srcFiles) && hasExtension (name, WF_FILE_DAT_EXT);
+ private String[] listWordFormFiles(File dfd) {
+ return dfd.list(new FilenameFilter() {
+ public boolean accept(File f, String name) {
+ return hasPrefixFrom(name, srcFiles) && hasExtension(name, WF_FILE_DAT_EXT);
}
- private boolean hasPrefixFrom (String name, String[] prefixes) {
+ private boolean hasPrefixFrom(String name, String[] prefixes) {
for (String p : prefixes) {
- if (name.startsWith (p)) {
+ if (name.startsWith(p)) {
return true;
}
}
return false;
}
- private boolean hasExtension (String name, String extension) {
- return name.endsWith ("." + extension);
+ private boolean hasExtension(String name, String extension) {
+ return name.endsWith("." + extension);
}
});
}
- private void processWordForms (String dpn) {
+ private void processWordForms(String dpn) {
FileInputStream fis = null;
try {
- fis = new FileInputStream (dpn);
+ fis = new FileInputStream(dpn);
if (fis != null) {
- ObjectInputStream ois = new ObjectInputStream (fis);
+ ObjectInputStream ois = new ObjectInputStream(fis);
List<Object[]> data = (List<Object[]>) ois.readObject();
if (data != null) {
- processWordForms (data);
+ processWordForms(data);
}
ois.close();
}
} catch (FileNotFoundException e) {
- throw new RuntimeException (e.getMessage(), e);
+ throw new RuntimeException(e.getMessage(), e);
} catch (IOException e) {
- throw new RuntimeException (e.getMessage(), e);
+ throw new RuntimeException(e.getMessage(), e);
} catch (Exception e) {
- throw new RuntimeException (e.getMessage(), e);
+ throw new RuntimeException(e.getMessage(), e);
} finally {
if (fis != null) {
try { fis.close(); } catch (Exception e) {}
}
}
- private void processWordForms (List<Object[]> data) {
+ private void processWordForms(List<Object[]> data) {
assert data != null;
assert data.size() > 0;
String script = null;
script = (String) d[0];
language = (String) d[1];
tfn = (String) d[3];
- tf = TTXFile.getFromCache (ttxFontsDir + File.separator + tfn);
- assertTrue (tf != null);
+ tf = TTXFile.getFromCache(ttxFontsDir + File.separator + tfn);
+ assertTrue(tf != null);
gsub = tf.getGSUB();
- assertTrue (gsub != null);
+ assertTrue(gsub != null);
gpos = tf.getGPOS();
- assertTrue (gpos != null);
+ assertTrue(gpos != null);
widths = tf.getWidths();
- assertTrue (widths != null);
+ assertTrue(widths != null);
} else {
assert tf != null;
assert gsub != null;
int[] iga = (int[]) d[1];
int[] oga = (int[]) d[2];
int[][] paa = (int[][]) d[3];
- GlyphSequence tigs = tf.mapCharsToGlyphs (wf);
- assertSameGlyphs (iga, getGlyphs (tigs), "input glyphs", wf, tfn);
- GlyphSequence togs = gsub.substitute (tigs, script, language);
- assertSameGlyphs (oga, getGlyphs (togs), "output glyphs", wf, tfn);
+ GlyphSequence tigs = tf.mapCharsToGlyphs(wf);
+ assertSameGlyphs(iga, getGlyphs(tigs), "input glyphs", wf, tfn);
+ GlyphSequence togs = gsub.substitute(tigs, script, language);
+ assertSameGlyphs(oga, getGlyphs(togs), "output glyphs", wf, tfn);
int[][] tpaa = new int [ togs.getGlyphCount() ] [ 4 ];
- if (gpos.position (togs, script, language, 1000, widths, tpaa)) {
- assertSameAdjustments (paa, tpaa, wf, tfn);
+ if (gpos.position(togs, script, language, 1000, widths, tpaa)) {
+ assertSameAdjustments(paa, tpaa, wf, tfn);
} else if (paa != null) {
- assertEquals ("unequal adjustment count, word form(" + wf + "), font (" + tfn + ")", paa.length, 0);
+ assertEquals("unequal adjustment count, word form(" + wf + "), font (" + tfn + ")", paa.length, 0);
}
}
}
}
- private void assertSameGlyphs (int[] expected, int[] actual, String label, String wf, String tfn) {
- assertEquals (label + ": unequal glyph count, word form(" + wf + "), font (" + tfn + ")", expected.length, actual.length);
+ private void assertSameGlyphs(int[] expected, int[] actual, String label, String wf, String tfn) {
+ assertEquals(label + ": unequal glyph count, word form(" + wf + "), font (" + tfn + ")", expected.length, actual.length);
for (int i = 0, n = expected.length; i < n; i++) {
int e = expected[i];
int a = actual[i];
- assertEquals (label + ": unequal glyphs[" + i + "], word form(" + wf + "), font (" + tfn + ")", e, a);
+ assertEquals(label + ": unequal glyphs[" + i + "], word form(" + wf + "), font (" + tfn + ")", e, a);
}
}
- private void assertSameAdjustments (int[][] expected, int[][] actual, String wf, String tfn) {
- assertEquals ("unequal adjustment count, word form(" + wf + "), font (" + tfn + ")", expected.length, actual.length);
+ private void assertSameAdjustments(int[][] expected, int[][] actual, String wf, String tfn) {
+ assertEquals("unequal adjustment count, word form(" + wf + "), font (" + tfn + ")", expected.length, actual.length);
for (int i = 0, n = expected.length; i < n; i++) {
int[] ea = expected[i];
int[] aa = actual[i];
- assertEquals ("bad adjustments length, word form(" + wf + "), font (" + tfn + ")", ea.length, aa.length);
+ assertEquals("bad adjustments length, word form(" + wf + "), font (" + tfn + ")", ea.length, aa.length);
for (int k = 0; k < 4; k++) {
int e = ea[k];
int a = aa[k];
- assertEquals ("unequal adjustment[" + i + "][" + k + "], word form(" + wf + "), font (" + tfn + ")", e, a);
+ assertEquals("unequal adjustment[" + i + "][" + k + "], word form(" + wf + "), font (" + tfn + ")", e, a);
}
}
}
- private static int[] getGlyphs (GlyphSequence gs) {
+ private static int[] getGlyphs(GlyphSequence gs) {
IntBuffer gb = gs.getGlyphs();
int[] ga = new int [ gb.limit() ];
gb.rewind();
- gb.get (ga);
+ gb.get(ga);
return ga;
}
*/
public class GenerateArabicTestData implements ArabicTestConstants {
- public static void main (String[] args) {
+ public static void main(String[] args) {
boolean compile = false;
boolean help = false;
for (String a : args) {
private static void help() {
StringBuffer sb = new StringBuffer();
- sb.append ("org.apache.fop.complexscripts.arabic.ArabicTestCase");
- sb.append (" [-compile]");
- sb.append (" [-?]");
- System.out.println (sb.toString());
+ sb.append("org.apache.fop.complexscripts.arabic.ArabicTestCase");
+ sb.append(" [-compile]");
+ sb.append(" [-?]");
+ System.out.println(sb.toString());
}
private static void compile() {
for (String sfn : srcFiles) {
try {
String spn = srcFilesDir + File.separator + sfn + "." + WF_FILE_SRC_EXT;
- compile (WF_FILE_SCRIPT, WF_FILE_LANGUAGE, spn);
+ compile(WF_FILE_SCRIPT, WF_FILE_LANGUAGE, spn);
} catch (Exception e) {
- System.err.println (e.getMessage());
+ System.err.println(e.getMessage());
}
}
}
- private static void compile (String script, String language, String spn) {
+ private static void compile(String script, String language, String spn) {
int fno = 0;
for (String tfn : ttxFonts) {
- TTXFile tf = TTXFile.getFromCache (ttxFontsDir + File.separator + tfn);
+ TTXFile tf = TTXFile.getFromCache(ttxFontsDir + File.separator + tfn);
assert tf != null;
- List data = compile (script, language, spn, tfn, tf);
- output (makeDataPathName (spn, fno++), data);
+ List data = compile(script, language, spn, tfn, tf);
+ output(makeDataPathName(spn, fno++), data);
}
}
- private static List compile (String script, String language, String spn, String tfn, TTXFile tf) {
+ private static List compile(String script, String language, String spn, String tfn, TTXFile tf) {
List<Object[]> data = new ArrayList<Object[]>();
- data.add (new Object[] { script, language, spn, tfn });
+ data.add(new Object[] { script, language, spn, tfn });
GlyphSubstitutionTable gsub = tf.getGSUB();
GlyphPositioningTable gpos = tf.getGPOS();
int[] widths = tf.getWidths();
if ((gsub != null) && (gpos != null)) {
FileInputStream fis = null;
try {
- fis = new FileInputStream (spn);
+ fis = new FileInputStream(spn);
if (fis != null) {
- LineNumberReader lr = new LineNumberReader (new InputStreamReader (fis, Charset.forName ("UTF-8")));
+ LineNumberReader lr = new LineNumberReader(new InputStreamReader(fis, Charset.forName("UTF-8")));
String wf;
while ((wf = lr.readLine()) != null) {
- GlyphSequence igs = tf.mapCharsToGlyphs (wf);
- GlyphSequence ogs = gsub.substitute (igs, script, language);
+ GlyphSequence igs = tf.mapCharsToGlyphs(wf);
+ GlyphSequence ogs = gsub.substitute(igs, script, language);
int[][] paa = new int [ ogs.getGlyphCount() ] [ 4 ];
- if (! gpos.position (ogs, script, language, 1000, widths, paa)) {
+ if (! gpos.position(ogs, script, language, 1000, widths, paa)) {
paa = null;
}
- data.add (new Object[] { wf, getGlyphs (igs), getGlyphs (ogs), paa });
+ data.add(new Object[] { wf, getGlyphs(igs), getGlyphs(ogs), paa });
}
lr.close();
}
} catch (FileNotFoundException e) {
- throw new RuntimeException (e.getMessage(), e);
+ throw new RuntimeException(e.getMessage(), e);
} catch (IOException e) {
- throw new RuntimeException (e.getMessage(), e);
+ throw new RuntimeException(e.getMessage(), e);
} catch (Exception e) {
- throw new RuntimeException (e.getMessage(), e);
+ throw new RuntimeException(e.getMessage(), e);
} finally {
if (fis != null) {
try { fis.close(); } catch (Exception e) {}
assert gsub != null;
assert gpos != null;
}
- System.err.println ("compiled " + (data.size() - 1) + " word forms using font " + tfn);
+ System.err.println("compiled " + (data.size() - 1) + " word forms using font " + tfn);
return data;
}
- private static int[] getGlyphs (GlyphSequence gs) {
+ private static int[] getGlyphs(GlyphSequence gs) {
IntBuffer gb = gs.getGlyphs();
int[] ga = new int [ gb.limit() ];
gb.rewind();
- gb.get (ga);
+ gb.get(ga);
return ga;
}
- private static String makeDataPathName (String spn, int fno) {
- File f = new File (spn);
- return datFilesDir + File.separator + stripExtension (f.getName()) + "-f" + fno + "." + WF_FILE_DAT_EXT;
+ private static String makeDataPathName(String spn, int fno) {
+ File f = new File(spn);
+ return datFilesDir + File.separator + stripExtension(f.getName()) + "-f" + fno + "." + WF_FILE_DAT_EXT;
}
- private static String stripExtension (String s) {
- int i = s.lastIndexOf ('.');
+ private static String stripExtension(String s) {
+ int i = s.lastIndexOf('.');
if (i >= 0) {
- return s.substring (0, i);
+ return s.substring(0, i);
} else {
return s;
}
}
- private static void output (String dpn, List<Object[]> data) {
+ private static void output(String dpn, List<Object[]> data) {
FileOutputStream fos = null;
try {
- fos = new FileOutputStream (dpn);
+ fos = new FileOutputStream(dpn);
if (fos != null) {
- ObjectOutputStream oos = new ObjectOutputStream (fos);
- oos.writeObject (data);
+ ObjectOutputStream oos = new ObjectOutputStream(fos);
+ oos.writeObject(data);
oos.close();
}
} catch (FileNotFoundException e) {
- throw new RuntimeException (e.getMessage(), e);
+ throw new RuntimeException(e.getMessage(), e);
} catch (IOException e) {
- throw new RuntimeException (e.getMessage(), e);
+ throw new RuntimeException(e.getMessage(), e);
} catch (Exception e) {
- throw new RuntimeException (e.getMessage(), e);
+ throw new RuntimeException(e.getMessage(), e);
} finally {
if (fos != null) {
try { fos.close(); } catch (Exception e) {}
*/
@Test
public void testFormatDecimal() throws Exception {
- performConversions (formatDecimal);
- performConversions (formatDecimalPadded);
- performConversions (formatDecimalGrouped);
- performConversions (formatDecimalGroupedPadded);
+ performConversions(formatDecimal);
+ performConversions(formatDecimalPadded);
+ performConversions(formatDecimalGrouped);
+ performConversions(formatDecimalGroupedPadded);
}
/**
*/
@Test
public void testFormatDecimalArabic() throws Exception {
- performConversions (formatDecimalArabic);
- performConversions (formatDecimalArabicPadded);
- performConversions (formatDecimalArabicGrouped);
- performConversions (formatDecimalArabicGroupedPadded);
+ performConversions(formatDecimalArabic);
+ performConversions(formatDecimalArabicPadded);
+ performConversions(formatDecimalArabicGrouped);
+ performConversions(formatDecimalArabicGroupedPadded);
}
/**
*/
@Test
public void testFormatDecimalThai() throws Exception {
- performConversions (formatDecimalThai);
- performConversions (formatDecimalThaiPadded);
+ performConversions(formatDecimalThai);
+ performConversions(formatDecimalThaiPadded);
}
/**
*/
@Test
public void testFormatRoman() throws Exception {
- performConversions (formatRomanLower);
- performConversions (formatRomanUpper);
- performConversions (formatRomanLargeLower);
- performConversions (formatRomanLargeUpper);
- performConversions (formatRomanNumberFormsLower);
- performConversions (formatRomanNumberFormsUpper);
+ performConversions(formatRomanLower);
+ performConversions(formatRomanUpper);
+ performConversions(formatRomanLargeLower);
+ performConversions(formatRomanLargeUpper);
+ performConversions(formatRomanNumberFormsLower);
+ performConversions(formatRomanNumberFormsUpper);
}
/**
*/
@Test
public void testAlphabeticLatin() throws Exception {
- performConversions (formatAlphabeticLatinLower);
- performConversions (formatAlphabeticLatinUpper);
+ performConversions(formatAlphabeticLatinLower);
+ performConversions(formatAlphabeticLatinUpper);
}
/**
*/
@Test
public void testAlphabeticArabic() throws Exception {
- performConversions (formatAlphabeticArabicHijai);
- performConversions (formatAlphabeticArabicAbjadi);
+ performConversions(formatAlphabeticArabicHijai);
+ performConversions(formatAlphabeticArabicAbjadi);
}
/**
*/
@Test
public void testAlphabeticHebrew() throws Exception {
- performConversions (formatAlphabeticHebrew);
+ performConversions(formatAlphabeticHebrew);
}
/**
*/
@Test
public void testAlphabeticThai() throws Exception {
- performConversions (formatAlphabeticThai);
+ performConversions(formatAlphabeticThai);
}
/**
*/
@Test
public void testNumeralArabic() throws Exception {
- performConversions (formatNumeralArabicAbjadi);
+ performConversions(formatNumeralArabicAbjadi);
}
/**
*/
@Test
public void testNumeralHebrew() throws Exception {
- performConversions (formatNumeralHebrewGematria);
+ performConversions(formatNumeralHebrewGematria);
}
/**
*/
@Test
public void testWordEnglish() throws Exception {
- performConversions (formatWordEnglishLower);
- performConversions (formatWordEnglishUpper);
- performConversions (formatWordEnglishTitle);
+ performConversions(formatWordEnglishLower);
+ performConversions(formatWordEnglishUpper);
+ performConversions(formatWordEnglishTitle);
}
/**
*/
@Test
public void testWordSpanish() throws Exception {
- performConversions (formatWordSpanishLower);
- performConversions (formatWordSpanishUpper);
- performConversions (formatWordSpanishTitle);
+ performConversions(formatWordSpanishLower);
+ performConversions(formatWordSpanishUpper);
+ performConversions(formatWordSpanishTitle);
}
/**
*/
@Test
public void testWordFrench() throws Exception {
- performConversions (formatWordFrenchLower);
- performConversions (formatWordFrenchUpper);
- performConversions (formatWordFrenchTitle);
+ performConversions(formatWordFrenchLower);
+ performConversions(formatWordFrenchUpper);
+ performConversions(formatWordFrenchTitle);
}
/**
* Perform conversions according to test specification.
* @param ts test specification
*/
- private void performConversions (String[][] ts) {
+ private void performConversions(String[][] ts) {
assert ts != null;
assert ts.length >= 2;
String[] args = ts[0];
if (args.length > 2) {
String s = args[2];
if ((s != null) && (s.length() > 0)) {
- groupingSize = Integer.parseInt (s);
+ groupingSize = Integer.parseInt(s);
} else {
groupingSize = 0;
}
} else {
country = null;
}
- NumberConverter nc = new NumberConverter (format, groupingSeparator, groupingSize, letterValue, features, language, country);
+ NumberConverter nc = new NumberConverter(format, groupingSeparator, groupingSize, letterValue, features, language, country);
for (int i = 1, nt = ts.length; i < nt; i++) {
String[] sa = ts[i];
assert sa != null;
List<Long> numbers = new ArrayList<Long>();
for (int k = 0, nn = sa.length - 1; k < nn; k++) {
String s = sa[k];
- numbers.add (Long.valueOf (s));
+ numbers.add(Long.valueOf(s));
}
String expected = sa [ sa.length - 1 ];
- String actual = nc.convert (numbers);
- assertEquals (expected, actual);
+ String actual = nc.convert(numbers);
+ assertEquals(expected, actual);
}
}
* @throws IOException for I/O Errors
*/
protected void generateDocument(RtfDocumentArea rda, RtfSection sect) throws IOException {
- RtfParagraph p = sect.newParagraph ();
+ RtfParagraph p = sect.newParagraph();
p.newLineBreak();
p.newLineBreak();
p.newLineBreak();
- p.newText ("external link: ");
- RtfHyperLink link = p.newHyperLink ("click here to go to the hompage", null);
- link.setExternalURL ("http://www.skynamics.com");
+ p.newText("external link: ");
+ RtfHyperLink link = p.newHyperLink("click here to go to the hompage", null);
+ link.setExternalURL("http://www.skynamics.com");
p.close();
- p = sect.newParagraph ();
+ p = sect.newParagraph();
p.newLineBreak();
- p.newText ("here we will demonstrate internal link to a bookmark");
+ p.newText("here we will demonstrate internal link to a bookmark");
p.newLineBreak();
- p.newText ("internal link: ");
- link = p.newHyperLink ("click here to go to the bookmark", null);
- link.setInternalURL ("testBookmark");
+ p.newText("internal link: ");
+ link = p.newHyperLink("click here to go to the bookmark", null);
+ link.setInternalURL("testBookmark");
p.close();
p = sect.newParagraph();
/**
* Default constructor.
*/
- public ExternalGraphic () {
+ public ExternalGraphic() {
}
/** generate the body of the test document */
- protected void generateDocument (RtfDocumentArea rda, RtfSection sect) throws IOException {
- RtfParagraph p = sect.newParagraph ();
+ protected void generateDocument(RtfDocumentArea rda, RtfSection sect) throws IOException {
+ RtfParagraph p = sect.newParagraph();
p.newLineBreak();
p.newLineBreak();
p.newLineBreak();
- p.newText ("EMF image with 150 % height");
+ p.newText("EMF image with 150 % height");
p.newLineBreak();
- RtfExternalGraphic imageA = p.newImage ();
- imageA.setURL (file + "emf");
- imageA.setHeight ("150%");
+ RtfExternalGraphic imageA = p.newImage();
+ imageA.setURL(file + "emf");
+ imageA.setHeight("150%");
p.newLineBreak();
p.close();
p = sect.newParagraph();
p.newLineBreak();
- p.newText ("PNG image with 150 % width");
+ p.newText("PNG image with 150 % width");
p.newLineBreak();
- RtfExternalGraphic imageB = sect.newImage ();
- imageB.setURL (file + "png");
- imageB.setWidth ("150%");
+ RtfExternalGraphic imageB = sect.newImage();
+ imageB.setURL(file + "png");
+ imageB.setWidth("150%");
p.newLineBreak();
p.close();
p = sect.newParagraph();
p.newLineBreak();
p.newLineBreak();
- p.newText ("JPG image with width = 200px and height = 20 px");
+ p.newText("JPG image with width = 200px and height = 20 px");
p.newLineBreak();
- RtfExternalGraphic imageC = sect.newImage ();
- imageC.setURL (file + "jpg");
- imageC.setWidth ("200");
- imageC.setHeight ("20");
+ RtfExternalGraphic imageC = sect.newImage();
+ imageC.setURL(file + "jpg");
+ imageC.setWidth("200");
+ imageC.setHeight("20");
p.newLineBreak();
p.close();
p = sect.newParagraph();
p.newLineBreak();
p.newLineBreak();
- p.newText ("GIF image with width = 200px and scaling = 'uniform', that means the image "
+ p.newText("GIF image with width = 200px and scaling = 'uniform', that means the image "
+ "size will adjusted automatically");
p.newLineBreak();
- RtfExternalGraphic imageD = sect.newImage ();
- imageD.setURL (file + "gif");
- imageD.setWidth ("200");
- imageD.setScaling ("uniform");
+ RtfExternalGraphic imageD = sect.newImage();
+ imageD.setURL(file + "gif");
+ imageD.setWidth("200");
+ imageD.setScaling("uniform");
p.newLineBreak();
p.close();
p = sect.newParagraph();
p.newLineBreak();
p.newLineBreak();
- p.newText ("GIF image");
+ p.newText("GIF image");
p.newLineBreak();
- RtfExternalGraphic imageE = sect.newImage ();
- imageE.setURL (file + "gif");
+ RtfExternalGraphic imageE = sect.newImage();
+ imageE.setURL(file + "gif");
p.newLineBreak();
p.close();
// fifth row, just one cell
{
RtfTableRow r = tbl.newTableRow();
- r.newTableCell(160 * MM_TO_TWIPS).newParagraph().newText
- ("cell 4,0, width 160mm, only cell in this row");
+ r.newTableCell(160 * MM_TO_TWIPS).newParagraph().newText(
+ "cell 4,0, width 160mm, only cell in this row");
}
}
}
// second row contains nested table
{
RtfTableRow r = tbl.newTableRow();
- r.newTableCell(40 * MM_TO_TWIPS).newParagraph().newText
- ("cell 1,0, width 40mm, to the left of nested table.");
+ r.newTableCell(40 * MM_TO_TWIPS).newParagraph().newText(
+ "cell 1,0, width 40mm, to the left of nested table.");
final RtfTableCell c = r.newTableCell(80 * MM_TO_TWIPS);
c.newParagraph().newText("cell 1,1, width 80mm, this text is "
fillNestedTable(c.newTable(new DummyTableColumnsInfo()), 1);
c.newParagraph().newText("AFTER NESTED TABLE");
- r.newTableCell(40 * MM_TO_TWIPS).newParagraph().newText
- ("cell 1,2, width 40mm, to the right of nested table.");
+ r.newTableCell(40 * MM_TO_TWIPS).newParagraph().newText(
+ "cell 1,2, width 40mm, to the right of nested table.");
}
// third row, normal
{
RtfTableRow r = tbl.newTableRow();
- r.newTableCell(80 * MM_TO_TWIPS).newParagraph().newText
- ("cell 2,0, width 80mm, this row has two cells.");
- r.newTableCell(80 * MM_TO_TWIPS).newParagraph().newText
- ("cell 2,1, width 80mm, last cell.");
+ r.newTableCell(80 * MM_TO_TWIPS).newParagraph().newText(
+ "cell 2,0, width 80mm, this row has two cells.");
+ r.newTableCell(80 * MM_TO_TWIPS).newParagraph().newText(
+ "cell 2,1, width 80mm, last cell.");
}
}
// second row contains nested table
{
RtfTableRow r = tbl.newTableRow();
- r.newTableCell(40 * MM_TO_TWIPS).newParagraph().newText
- ("cell 1,0, width 40mm, to the left of nested tables.");
+ r.newTableCell(40 * MM_TO_TWIPS).newParagraph().newText(
+ "cell 1,0, width 40mm, to the left of nested tables.");
final RtfTableCell c = r.newTableCell(80 * MM_TO_TWIPS);
c.newParagraph().newText("cell 1,1, width 80mm, this text is "
fillNestedTable(c.newTable(new DummyTableColumnsInfo()), 3);
c.newParagraph().newText("AFTER");
- r.newTableCell(40 * MM_TO_TWIPS).newParagraph().newText
- ("cell 1,2, width 40mm, to the right of nested table.");
+ r.newTableCell(40 * MM_TO_TWIPS).newParagraph().newText(
+ "cell 1,2, width 40mm, to the right of nested table.");
}
// third row, normal
{
RtfTableRow r = tbl.newTableRow();
- r.newTableCell(80 * MM_TO_TWIPS).newParagraph().newText
- ("cell 2,0, width 80mm, this row has two cells.");
- r.newTableCell(80 * MM_TO_TWIPS).newParagraph().newText
- ("cell 2,1, width 80mm, last cell.");
+ r.newTableCell(80 * MM_TO_TWIPS).newParagraph().newText(
+ "cell 2,0, width 80mm, this row has two cells.");
+ r.newTableCell(80 * MM_TO_TWIPS).newParagraph().newText(
+ "cell 2,1, width 80mm, last cell.");
}
}
// second row contains nested table
{
RtfTableRow r = tbl.newTableRow();
- r.newTableCell(40 * MM_TO_TWIPS).newParagraph().newText
- ("cell 1,0, width 40mm, to the left of nested tables.");
+ r.newTableCell(40 * MM_TO_TWIPS).newParagraph().newText(
+ "cell 1,0, width 40mm, to the left of nested tables.");
final RtfTableCell c = r.newTableCell(80 * MM_TO_TWIPS);
c.newParagraph().newText("cell 1,1, width 80mm, this text is "
fillNestedTable(c.newTable(new DummyTableColumnsInfo()), 6);
c.newParagraph().newText("AFTER");
- r.newTableCell(40 * MM_TO_TWIPS).newParagraph().newText
- ("cell 1,2, width 40mm, to the right of nested table.");
+ r.newTableCell(40 * MM_TO_TWIPS).newParagraph().newText(
+ "cell 1,2, width 40mm, to the right of nested table.");
}
// third row, normal
{
RtfTableRow r = tbl.newTableRow();
- r.newTableCell(80 * MM_TO_TWIPS).newParagraph().newText
- ("cell 2,0, width 80mm, this row has two cells.");
- r.newTableCell(80 * MM_TO_TWIPS).newParagraph().newText
- ("cell 2,1, width 80mm, last cell.");
+ r.newTableCell(80 * MM_TO_TWIPS).newParagraph().newText(
+ "cell 2,0, width 80mm, this row has two cells.");
+ r.newTableCell(80 * MM_TO_TWIPS).newParagraph().newText(
+ "cell 2,1, width 80mm, last cell.");
}
}
*/
protected void generateDocument(RtfDocumentArea rda, RtfSection sect) throws java.io.IOException
{
- RtfAttributes attr = new RtfAttributes ();
+ RtfAttributes attr = new RtfAttributes();
attr.set(RtfText.ALIGN_CENTER);
- RtfParagraph p = sect.newParagraph (attr);
+ RtfParagraph p = sect.newParagraph(attr);
p.newLineBreak();
p.newLineBreak();
- p.newText ("Centered title");
+ p.newText("Centered title");
p.newLineBreak();
p.close();
- attr = new RtfAttributes ();
+ attr = new RtfAttributes();
attr.set(RtfText.ALIGN_LEFT);
- p = sect.newParagraph (attr);
+ p = sect.newParagraph(attr);
p.newLineBreak();
- p.newText ("This is the left aligned text.");
+ p.newText("This is the left aligned text.");
p.newLineBreak();
p.close();
- attr = new RtfAttributes ();
+ attr = new RtfAttributes();
attr.set(RtfText.ALIGN_RIGHT);
- p = sect.newParagraph (attr);
+ p = sect.newParagraph(attr);
p.newLineBreak();
- p.newText ("This is the right aligned text.");
+ p.newText("This is the right aligned text.");
p.newLineBreak();
p.close();
}
protected void generateDocument(RtfDocumentArea rda, RtfSection sect)
throws IOException {
final RtfTable tbl = sect.newTable(new DummyTableColumnsInfo());
- tbl.newTableRow().newTableCell(C1W * INCH_TO_TWIPS).newParagraph().newText
- ("Here's a table row with just one cell, width " + C1W + "''");
+ tbl.newTableRow().newTableCell(C1W * INCH_TO_TWIPS).newParagraph().newText(
+ "Here's a table row with just one cell, width " + C1W + "''");
for (int row = 0; row < MAX_ROW; row++) {
final RtfTableRow r = tbl.newTableRow();
int [] refPix = null;
int [] genPix = null;
for (y = 0; y < h; y++) {
- refPix = refWR.getPixels (0, y, w, 1, refPix);
- genPix = genWR.getPixels (0, y, w, 1, genPix);
+ refPix = refWR.getPixels (0, y, w, 1, refPix);
+ genPix = genWR.getPixels (0, y, w, 1, genPix);
for (i = 0; i < refPix.length; i++) {
// val = ((genPix[i] - refPix[i]) * 5) + 128;
val = ((refPix[i] - genPix[i]) * 10) + 128;
projects / xmlgraphics-fop.git / commitdiff