GFXMappingList.java
5.46 KB
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
/*
* Decompiled with CFR 0_118.
*/
package com.adobe.xfa.gfx;
import com.adobe.xfa.gfx.GFXMapping;
import com.adobe.xfa.ut.Storage;
import java.util.Collections;
import java.util.Comparator;
public class GFXMappingList {
public static final int MAPPING_ERR_CHAR_OVERLAP = 0;
public static final int MAPPING_ERR_CHAR_UNMAPPED = 1;
public static final int MAPPING_ERR_CHAR_MAP_RANGE = 2;
public static final int MAPPING_ERR_GLYPH_OVERLAP = 3;
public static final int MAPPING_ERR_GLYPH_UNMAPPED = 4;
public static final int MAPPING_ERR_GLYPH_MAP_RANGE = 5;
private final Storage<GFXMapping> moMappings = new Storage();
public GFXMappingList() {
}
public GFXMappingList(int nSizeHint, boolean bAutoMap) {
if (bAutoMap) {
this.autoMap(nSizeHint);
} else {
this.moMappings.ensureCapacity(nSizeHint);
}
}
public GFXMappingList(int nSizeHint) {
this(nSizeHint, false);
}
public GFXMappingList(GFXMappingList source) {
this.copyFrom(source);
}
public void reset() {
this.moMappings.setSize(0);
}
public void autoMap(int nMappings) {
this.moMappings.setSize(nMappings);
for (int i = 0; i < nMappings; ++i) {
this.moMappings.set(i, new GFXMapping(i, i));
}
}
public void addMapping(GFXMapping oMapping) {
this.moMappings.add(oMapping);
}
public void addMapping(int nCharStart, int nGlyphStart, int nCharLength, int nGlyphLength) {
this.moMappings.add(new GFXMapping(nCharStart, nGlyphStart, nCharLength, nGlyphLength));
}
public void addMapping(int nCharStart, int nGlyphStart, int nCharLength) {
this.addMapping(nCharStart, nGlyphStart, nCharLength, 1);
}
public void addMapping(int nCharStart, int nGlyphStart) {
this.addMapping(nCharStart, nGlyphStart, 1, 1);
}
public int getMappingCount() {
return this.moMappings.size();
}
public GFXMapping getMapping(int nIndex) {
return this.moMappings.get(nIndex);
}
public void validate(int pnExpectedChars, int pnExpectedGlyphs) {
this.validateMappings(false, pnExpectedChars, 0, 1, 2);
this.validateMappings(true, pnExpectedGlyphs, 3, 4, 5);
}
public void validate(int pnExpectedChars) {
this.validate(pnExpectedChars, -1);
}
public void validate() {
this.validate(-1, -1);
}
public void orderByCharacter() {
this.sortMappings(false);
}
public void orderByGlyph() {
this.sortMappings(true);
}
public void copyFrom(GFXMappingList source) {
int size = source.moMappings.size();
this.moMappings.setSize(size);
for (int i = 0; i < size; ++i) {
this.moMappings.set(i, new GFXMapping(source.getMapping(i)));
}
}
private void validateMappings(boolean bGlyph, int pnExpected, int nErrorDuplicate, int nErrorMissing, int nErrorOverflow) {
int i;
int nMinIndex = 0;
int nIndexCount = 0;
if (pnExpected < 0) {
nMinIndex = Integer.MAX_VALUE;
int nMaxIndex = 0;
for (i = 0; i < this.moMappings.size(); ++i) {
GFXMapping oMapping = this.getMapping(i);
int nLow = oMapping.getLowestIndex(bGlyph);
int nHigh = oMapping.getHighestIndex(bGlyph);
if (nLow < nMinIndex) {
nMinIndex = nLow;
}
if (nHigh <= nMaxIndex) continue;
nMaxIndex = nHigh;
}
if (nMinIndex <= nMaxIndex) {
nIndexCount = nMaxIndex + nMinIndex + 1;
}
} else {
nMinIndex = 0;
nIndexCount = pnExpected;
}
boolean[] oVisited = null;
if (nIndexCount > 0) {
oVisited = new boolean[nIndexCount];
for (i = 0; i < nIndexCount; ++i) {
oVisited[i] = false;
}
}
int nIndexLimit = nMinIndex + nIndexCount;
for (i = 0; i < this.moMappings.size(); ++i) {
GFXMapping oMapping = this.getMapping(i);
int nCount = oMapping.getCount(bGlyph);
for (int j = 0; j < nCount; ++j) {
int nIndex = oMapping.getIndex(bGlyph, j);
if (nIndex >= nIndexLimit) {
GFXMappingList.throwError(nErrorOverflow, nIndex);
}
int nVisitedIndex = nIndex - nMinIndex;
if (oVisited != null && oVisited[nVisitedIndex]) {
GFXMappingList.throwError(nErrorDuplicate, nIndex);
}
oVisited[nVisitedIndex] = true;
}
}
if (pnExpected >= 0) {
for (i = 0; i < nIndexCount; ++i) {
if (oVisited[i]) continue;
GFXMappingList.throwError(nErrorMissing, i);
}
}
}
private void sortMappings(final boolean bGlyph) {
Collections.sort(this.moMappings, new Comparator<GFXMapping>(){
@Override
public int compare(GFXMapping mapping1, GFXMapping mapping2) {
int lowestIndex2;
int lowestIndex1 = mapping1.getLowestIndex(bGlyph);
return lowestIndex1 < (lowestIndex2 = mapping2.getLowestIndex(bGlyph)) ? -1 : (lowestIndex1 > lowestIndex2 ? 1 : 0);
}
});
}
private static void throwError(int nError, int nValue) {
assert (false);
}
}