git-svn-id: https://svn.apache.org/repos/asf/xmlgraphics/fop/trunk@1758773 13f79535-47bb-0310-9956-ffa450edef68tags/fop-2_2
boundingBoxes[0x<xsl:value-of select="$char-num"/>] = new Rectangle(<xsl:value-of select="@llx"/>, <xsl:value-of select="@lly"/>, <xsl:value-of select="@urx - @llx"/>, <xsl:value-of select="@ury - @lly"/>);</xsl:if></xsl:template> | boundingBoxes[0x<xsl:value-of select="$char-num"/>] = new Rectangle(<xsl:value-of select="@llx"/>, <xsl:value-of select="@lly"/>, <xsl:value-of select="@urx - @llx"/>, <xsl:value-of select="@ury - @lly"/>);</xsl:if></xsl:template> | ||||
<xsl:template match="kerning"> | <xsl:template match="kerning"> | ||||
first = new Integer(<xsl:value-of select="@kpx1"/>); | |||||
first = <xsl:value-of select="@kpx1"/>; | |||||
pairs = (Map)kerning.get(first); | pairs = (Map)kerning.get(first); | ||||
if (pairs == null) { | if (pairs == null) { | ||||
pairs = new java.util.HashMap(); | pairs = new java.util.HashMap(); | ||||
<xsl:apply-templates select="pair"/></xsl:template> | <xsl:apply-templates select="pair"/></xsl:template> | ||||
<xsl:template match="pair"> | <xsl:template match="pair"> | ||||
second = new Integer(<xsl:value-of select="@kpx2"/>); | |||||
pairs.put(second, new Integer(<xsl:value-of select="@kern"/>)); | |||||
second = <xsl:value-of select="@kpx2"/>; | |||||
pairs.put(second, <xsl:value-of select="@kern"/>); | |||||
</xsl:template> | </xsl:template> | ||||
</xsl:stylesheet> | </xsl:stylesheet> |
} | } | ||||
private static void registerResourceTypeName(String name, byte type) { | private static void registerResourceTypeName(String name, byte type) { | ||||
RESOURCE_TYPE_NAMES.put(name.toLowerCase(), new Byte(type)); | |||||
RESOURCE_TYPE_NAMES.put(name.toLowerCase(), type); | |||||
} | } | ||||
private static byte getResourceType(String resourceTypeName) { | private static byte getResourceType(String resourceTypeName) { | ||||
* @param level the resource level | * @param level the resource level | ||||
*/ | */ | ||||
public void setDefaultResourceLevel(byte type, AFPResourceLevel level) { | public void setDefaultResourceLevel(byte type, AFPResourceLevel level) { | ||||
this.defaultResourceLevels.put(new Byte(type), level); | |||||
this.defaultResourceLevels.put(type, level); | |||||
} | } | ||||
/** | /** | ||||
* @return the default resource level | * @return the default resource level | ||||
*/ | */ | ||||
public AFPResourceLevel getDefaultResourceLevel(byte type) { | public AFPResourceLevel getDefaultResourceLevel(byte type) { | ||||
AFPResourceLevel result = (AFPResourceLevel)this.defaultResourceLevels.get(new Byte(type)); | |||||
AFPResourceLevel result = (AFPResourceLevel)this.defaultResourceLevels.get(type); | |||||
if (result == null) { | if (result == null) { | ||||
result = AFPResourceInfo.DEFAULT_LEVEL; | result = AFPResourceInfo.DEFAULT_LEVEL; | ||||
} | } |
*/ | */ | ||||
public void addCharacterSet(int size, CharacterSet characterSet) { | public void addCharacterSet(int size, CharacterSet characterSet) { | ||||
//TODO: replace with Integer.valueOf() once we switch to Java 5 | //TODO: replace with Integer.valueOf() once we switch to Java 5 | ||||
this.charSets.put(new Integer(size), characterSet); | |||||
this.charSets.put(size, characterSet); | |||||
this.charSet = characterSet; | this.charSet = characterSet; | ||||
} | } | ||||
*/ | */ | ||||
public CharacterSet getCharacterSet(int sizeInMpt) { | public CharacterSet getCharacterSet(int sizeInMpt) { | ||||
Integer requestedSize = Integer.valueOf(sizeInMpt); | |||||
Integer requestedSize = sizeInMpt; | |||||
CharacterSet csm = charSets.get(requestedSize); | CharacterSet csm = charSets.get(requestedSize); | ||||
double sizeInPt = sizeInMpt / 1000.0; | double sizeInPt = sizeInMpt / 1000.0; | ||||
Integer fontSize; | Integer fontSize; | ||||
if (!smallerSizes.isEmpty() | if (!smallerSizes.isEmpty() | ||||
&& (sizeInMpt - smallerSize) <= (largerSize - sizeInMpt)) { | && (sizeInMpt - smallerSize) <= (largerSize - sizeInMpt)) { | ||||
fontSize = Integer.valueOf(smallerSize); | |||||
fontSize = smallerSize; | |||||
} else { | } else { | ||||
fontSize = Integer.valueOf(largerSize); | |||||
fontSize = largerSize; | |||||
} | } | ||||
csm = charSets.get(fontSize); | csm = charSets.get(fontSize); | ||||
if (value != null) { | if (value != null) { | ||||
Class cl = Trait.getTraitClass(trait); | Class cl = Trait.getTraitClass(trait); | ||||
if (cl == Integer.class) { | if (cl == Integer.class) { | ||||
area.addTrait(trait, new Integer(value)); | |||||
area.addTrait(trait, Integer.valueOf(value)); | |||||
} else if (cl == Boolean.class) { | } else if (cl == Boolean.class) { | ||||
area.addTrait(trait, Boolean.valueOf(value)); | area.addTrait(trait, Boolean.valueOf(value)); | ||||
} else if (cl == String.class) { | } else if (cl == String.class) { |
} | } | ||||
/** Id reference line, not resolved. (not sure if this is needed.) */ | /** Id reference line, not resolved. (not sure if this is needed.) */ | ||||
//public static final Integer ID_LINK = new Integer(0); | |||||
//public static final Integer ID_LINK = Integer.valueOf(0); | |||||
/** | /** | ||||
* Internal link trait. | * Internal link trait. | ||||
public static final Integer LINETHROUGH = 12; | public static final Integer LINETHROUGH = 12; | ||||
/** Shadow offset. */ | /** Shadow offset. */ | ||||
//public static final Integer OFFSET = new Integer(13); | |||||
//public static final Integer OFFSET = Integer.valueOf(13); | |||||
/** The shadow for text. */ | /** The shadow for text. */ | ||||
//public static final Integer SHADOW = new Integer(14); | |||||
//public static final Integer SHADOW = Integer.valueOf(14); | |||||
/** The border start. */ | /** The border start. */ | ||||
public static final Integer BORDER_START = 15; | public static final Integer BORDER_START = 15; | ||||
public static final Integer SPACE_END = 24; | public static final Integer SPACE_END = 24; | ||||
/** break before */ | /** break before */ | ||||
//public static final Integer BREAK_BEFORE = new Integer(25); | |||||
//public static final Integer BREAK_BEFORE = Integer.valueOf(25); | |||||
/** break after */ | /** break after */ | ||||
//public static final Integer BREAK_AFTER = new Integer(26); | |||||
//public static final Integer BREAK_AFTER = Integer.valueOf(26); | |||||
/** The start-indent trait. */ | /** The start-indent trait. */ | ||||
public static final Integer START_INDENT = 27; | public static final Integer START_INDENT = 27; |
for (int j = 0; j < parts.length; j++) { | for (int j = 0; j < parts.length; j++) { | ||||
String s = parts[j]; | String s = parts[j]; | ||||
if (s.matches("\\d+")) { | if (s.matches("\\d+")) { | ||||
renderingOptions.put(PrintRenderer.START_PAGE, new Integer(s)); | |||||
renderingOptions.put(PrintRenderer.START_PAGE, Integer.valueOf(s)); | |||||
} else if (s.matches("\\d+-\\d+")) { | } else if (s.matches("\\d+-\\d+")) { | ||||
String[] startend = s.split("-"); | String[] startend = s.split("-"); | ||||
renderingOptions.put(PrintRenderer.START_PAGE, new Integer(startend[0])); | |||||
renderingOptions.put(PrintRenderer.END_PAGE, new Integer(startend[1])); | |||||
renderingOptions.put(PrintRenderer.START_PAGE, Integer.valueOf(startend[0])); | |||||
renderingOptions.put(PrintRenderer.END_PAGE, Integer.valueOf(startend[1])); | |||||
} else { | } else { | ||||
PagesMode mode = PagesMode.byName(s); | PagesMode mode = PagesMode.byName(s); | ||||
renderingOptions.put(PrintRenderer.PAGES_MODE, mode); | renderingOptions.put(PrintRenderer.PAGES_MODE, mode); | ||||
|| (isOption(args[i + 1]))) { | || (isOption(args[i + 1]))) { | ||||
throw new FOPException("you must specify the number of copies"); | throw new FOPException("you must specify the number of copies"); | ||||
} else { | } else { | ||||
renderingOptions.put(PrintRenderer.COPIES, new Integer(args[i + 1])); | |||||
renderingOptions.put(PrintRenderer.COPIES, Integer.valueOf(args[i + 1])); | |||||
return 1; | return 1; | ||||
} | } | ||||
} | } |
/** {@inheritDoc} */ | /** {@inheritDoc} */ | ||||
public List getEntries() { | public List getEntries() { | ||||
List entries = new java.util.ArrayList(); | List entries = new java.util.ArrayList(); | ||||
entries.add(Integer.valueOf(firstGlyph)); | |||||
entries.add(firstGlyph); | |||||
if (gca != null) { | if (gca != null) { | ||||
for (int i = 0, n = gca.length; i < n; i++) { | for (int i = 0, n = gca.length; i < n; i++) { | ||||
entries.add(Integer.valueOf(gca [ i ])); | |||||
entries.add(gca[i]); | |||||
} | } | ||||
} | } | ||||
return entries; | return entries; |
List entries = new java.util.ArrayList(); | List entries = new java.util.ArrayList(); | ||||
if (map != null) { | if (map != null) { | ||||
for (int i = 0, n = map.length; i < n; i++) { | for (int i = 0, n = map.length; i < n; i++) { | ||||
entries.add(Integer.valueOf(map [ i ])); | |||||
entries.add(map[i]); | |||||
} | } | ||||
} | } | ||||
return entries; | return entries; |
List entries = new ArrayList(5); | List entries = new ArrayList(5); | ||||
entries.add(cdt1); | entries.add(cdt1); | ||||
entries.add(cdt2); | entries.add(cdt2); | ||||
entries.add(Integer.valueOf(nc1)); | |||||
entries.add(Integer.valueOf(nc2)); | |||||
entries.add(nc1); | |||||
entries.add(nc2); | |||||
entries.add(pvm); | entries.add(pvm); | ||||
return entries; | return entries; | ||||
} else { | } else { | ||||
if ((bct != null) && (maa != null) && (nmc > 0) && (bam != null)) { | if ((bct != null) && (maa != null) && (nmc > 0) && (bam != null)) { | ||||
List entries = new ArrayList(4); | List entries = new ArrayList(4); | ||||
entries.add(bct); | entries.add(bct); | ||||
entries.add(Integer.valueOf(nmc)); | |||||
entries.add(nmc); | |||||
entries.add(maa); | entries.add(maa); | ||||
entries.add(bam); | entries.add(bam); | ||||
return entries; | return entries; | ||||
if (lam != null) { | if (lam != null) { | ||||
List entries = new ArrayList(5); | List entries = new ArrayList(5); | ||||
entries.add(lct); | entries.add(lct); | ||||
entries.add(Integer.valueOf(nmc)); | |||||
entries.add(Integer.valueOf(mxc)); | |||||
entries.add(nmc); | |||||
entries.add(mxc); | |||||
entries.add(maa); | entries.add(maa); | ||||
entries.add(lam); | entries.add(lam); | ||||
return entries; | return entries; | ||||
if ((mct2 != null) && (maa != null) && (nmc > 0) && (mam != null)) { | if ((mct2 != null) && (maa != null) && (nmc > 0) && (mam != null)) { | ||||
List entries = new ArrayList(4); | List entries = new ArrayList(4); | ||||
entries.add(mct2); | entries.add(mct2); | ||||
entries.add(Integer.valueOf(nmc)); | |||||
entries.add(nmc); | |||||
entries.add(maa); | entries.add(maa); | ||||
entries.add(mam); | entries.add(mam); | ||||
return entries; | return entries; | ||||
if (rsa != null) { | if (rsa != null) { | ||||
List entries = new ArrayList(3); | List entries = new ArrayList(3); | ||||
entries.add(cdt); | entries.add(cdt); | ||||
entries.add(Integer.valueOf(ngc)); | |||||
entries.add(ngc); | |||||
entries.add(rsa); | entries.add(rsa); | ||||
return entries; | return entries; | ||||
} else { | } else { | ||||
entries.add(icdt); | entries.add(icdt); | ||||
entries.add(bcdt); | entries.add(bcdt); | ||||
entries.add(lcdt); | entries.add(lcdt); | ||||
entries.add(Integer.valueOf(ngc)); | |||||
entries.add(ngc); | |||||
entries.add(rsa); | entries.add(rsa); | ||||
return entries; | return entries; | ||||
} else { | } else { |
/** {@inheritDoc} */ | /** {@inheritDoc} */ | ||||
public List getEntries() { | public List getEntries() { | ||||
List entries = new ArrayList(1); | List entries = new ArrayList(1); | ||||
entries.add(Integer.valueOf(delta)); | |||||
entries.add(delta); | |||||
return entries; | return entries; | ||||
} | } | ||||
/** {@inheritDoc} */ | /** {@inheritDoc} */ | ||||
public List getEntries() { | 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++) { | for (int i = 0, n = glyphs.length; i < n; i++) { | ||||
entries.add(Integer.valueOf(glyphs[i])); | |||||
entries.add(glyphs[i]); | |||||
} | } | ||||
return entries; | return entries; | ||||
} | } | ||||
if (rsa != null) { | if (rsa != null) { | ||||
List entries = new ArrayList(3); | List entries = new ArrayList(3); | ||||
entries.add(cdt); | entries.add(cdt); | ||||
entries.add(Integer.valueOf(ngc)); | |||||
entries.add(ngc); | |||||
entries.add(rsa); | entries.add(rsa); | ||||
return entries; | return entries; | ||||
} else { | } else { | ||||
entries.add(icdt); | entries.add(icdt); | ||||
entries.add(bcdt); | entries.add(bcdt); | ||||
entries.add(lcdt); | entries.add(lcdt); | ||||
entries.add(Integer.valueOf(ngc)); | |||||
entries.add(ngc); | |||||
entries.add(rsa); | entries.add(rsa); | ||||
return entries; | return entries; | ||||
} else { | } else { |
for (int i = 0, n = ng; i < n; i++) { | for (int i = 0, n = ng; i < n; i++) { | ||||
int g = in.readTTFUShort(); | int g = in.readTTFUShort(); | ||||
ga[i] = g; | ga[i] = g; | ||||
entries.add(Integer.valueOf(g)); | |||||
entries.add(g); | |||||
} | } | ||||
// dump info if debugging | // dump info if debugging | ||||
if (log.isDebugEnabled()) { | if (log.isDebugEnabled()) { | ||||
in.skip(2); | in.skip(2); | ||||
// read start glyph | // read start glyph | ||||
int sg = in.readTTFUShort(); | int sg = in.readTTFUShort(); | ||||
entries.add(Integer.valueOf(sg)); | |||||
entries.add(sg); | |||||
// read glyph count | // read glyph count | ||||
int ng = in.readTTFUShort(); | int ng = in.readTTFUShort(); | ||||
// read glyph classes | // read glyph classes | ||||
for (int i = 0, n = ng; i < n; i++) { | for (int i = 0, n = ng; i < n; i++) { | ||||
int gc = in.readTTFUShort(); | int gc = in.readTTFUShort(); | ||||
ca[i] = gc; | ca[i] = gc; | ||||
entries.add(Integer.valueOf(gc)); | |||||
entries.add(gc); | |||||
} | } | ||||
// dump info if debugging | // dump info if debugging | ||||
if (log.isDebugEnabled()) { | if (log.isDebugEnabled()) { | ||||
} | } | ||||
// read coverage table | // read coverage table | ||||
seMapping = readCoverageTable(tableTag + " single substitution coverage", subtableOffset + co); | seMapping = readCoverageTable(tableTag + " single substitution coverage", subtableOffset + co); | ||||
seEntries.add(Integer.valueOf(dg)); | |||||
seEntries.add(dg); | |||||
} | } | ||||
private void readSingleSubTableFormat2(int lookupType, int lookupFlags, long subtableOffset, int subtableFormat) throws IOException { | private void readSingleSubTableFormat2(int lookupType, int lookupFlags, long subtableOffset, int subtableFormat) throws IOException { | ||||
log.debug(tableTag + " single substitution glyph[" + i + "]: " + gs); | log.debug(tableTag + " single substitution glyph[" + i + "]: " + gs); | ||||
} | } | ||||
gsa[i] = gs; | gsa[i] = gs; | ||||
seEntries.add(Integer.valueOf(gs)); | |||||
seEntries.add(gs); | |||||
} | } | ||||
} | } | ||||
// store results | // store results | ||||
seMapping = ct; | seMapping = ct; | ||||
seEntries.add(cdt); | seEntries.add(cdt); | ||||
seEntries.add(Integer.valueOf(ngc)); | |||||
seEntries.add(ngc); | |||||
seEntries.add(rsa); | seEntries.add(rsa); | ||||
} | } | ||||
seEntries.add(icdt); | seEntries.add(icdt); | ||||
seEntries.add(bcdt); | seEntries.add(bcdt); | ||||
seEntries.add(lcdt); | seEntries.add(lcdt); | ||||
seEntries.add(Integer.valueOf(ngc)); | |||||
seEntries.add(ngc); | |||||
seEntries.add(rsa); | seEntries.add(rsa); | ||||
} | } | ||||
seMapping = ct; | seMapping = ct; | ||||
seEntries.add(cdt1); | seEntries.add(cdt1); | ||||
seEntries.add(cdt2); | seEntries.add(cdt2); | ||||
seEntries.add(Integer.valueOf(nc1)); | |||||
seEntries.add(Integer.valueOf(nc2)); | |||||
seEntries.add(nc1); | |||||
seEntries.add(nc2); | |||||
seEntries.add(pvm); | seEntries.add(pvm); | ||||
} | } | ||||
// store results | // store results | ||||
seMapping = mct; | seMapping = mct; | ||||
seEntries.add(bct); | seEntries.add(bct); | ||||
seEntries.add(Integer.valueOf(nmc)); | |||||
seEntries.add(nmc); | |||||
seEntries.add(maa); | seEntries.add(maa); | ||||
seEntries.add(bam); | seEntries.add(bam); | ||||
} | } | ||||
// store results | // store results | ||||
seMapping = mct; | seMapping = mct; | ||||
seEntries.add(lct); | seEntries.add(lct); | ||||
seEntries.add(Integer.valueOf(nmc)); | |||||
seEntries.add(Integer.valueOf(mxc)); | |||||
seEntries.add(nmc); | |||||
seEntries.add(mxc); | |||||
seEntries.add(maa); | seEntries.add(maa); | ||||
seEntries.add(lam); | seEntries.add(lam); | ||||
} | } | ||||
// store results | // store results | ||||
seMapping = mct1; | seMapping = mct1; | ||||
seEntries.add(mct2); | seEntries.add(mct2); | ||||
seEntries.add(Integer.valueOf(nmc)); | |||||
seEntries.add(nmc); | |||||
seEntries.add(maa); | seEntries.add(maa); | ||||
seEntries.add(mam); | seEntries.add(mam); | ||||
} | } | ||||
// store results | // store results | ||||
seMapping = ct; | seMapping = ct; | ||||
seEntries.add(cdt); | seEntries.add(cdt); | ||||
seEntries.add(Integer.valueOf(ngc)); | |||||
seEntries.add(ngc); | |||||
seEntries.add(rsa); | seEntries.add(rsa); | ||||
} | } | ||||
seEntries.add(icdt); | seEntries.add(icdt); | ||||
seEntries.add(bcdt); | seEntries.add(bcdt); | ||||
seEntries.add(lcdt); | seEntries.add(lcdt); | ||||
seEntries.add(Integer.valueOf(ngc)); | |||||
seEntries.add(ngc); | |||||
seEntries.add(rsa); | seEntries.add(rsa); | ||||
} | } | ||||
if (seEntries != null) { | if (seEntries != null) { | ||||
if ((tableType == GlyphTable.GLYPH_TABLE_TYPE_DEFINITION) || (seEntries.size() > 0)) { | if ((tableType == GlyphTable.GLYPH_TABLE_TYPE_DEFINITION) || (seEntries.size() > 0)) { | ||||
if (seSubtables != null) { | 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); | |||||
Integer tt = tableType; | |||||
Integer lt = lookupType; | |||||
Integer ln = lookupSequence; | |||||
Integer lf = lookupFlags; | |||||
Integer sn = subtableSequence; | |||||
Integer sf = subtableFormat; | |||||
seSubtables.add(new Object[] { tt, lt, ln, lf, sn, sf, seMapping, seEntries }); | seSubtables.add(new Object[] { tt, lt, ln, lf, sn, sf, seMapping, seEntries }); | ||||
} | } | ||||
} | } |
public static int[] scriptsOf(CharSequence cs) { | public static int[] scriptsOf(CharSequence cs) { | ||||
Set s = new HashSet(); | Set s = new HashSet(); | ||||
for (int i = 0, n = cs.length(); i < n; i++) { | for (int i = 0, n = cs.length(); i < n; i++) { | ||||
s.add(Integer.valueOf(scriptOf(cs.charAt(i)))); | |||||
s.add(scriptOf(cs.charAt(i))); | |||||
} | } | ||||
int[] sa = new int [ s.size() ]; | int[] sa = new int [ s.size() ]; | ||||
int ns = 0; | int ns = 0; | ||||
for (int i = 0, n = cs.length(); i < n; i++) { | for (int i = 0, n = cs.length(); i < n; i++) { | ||||
int c = cs.charAt(i); | int c = cs.charAt(i); | ||||
int s = scriptOf(c); | int s = scriptOf(c); | ||||
Integer k = Integer.valueOf(s); | |||||
Integer k = s; | |||||
Integer v = (Integer) m.get(k); | Integer v = (Integer) m.get(k); | ||||
if (v != null) { | if (v != null) { | ||||
m.put(k, Integer.valueOf(v.intValue() + 1)); | |||||
m.put(k, v.intValue() + 1); | |||||
} else { | } else { | ||||
m.put(k, Integer.valueOf(0)); | |||||
m.put(k, 0); | |||||
} | } | ||||
} | } | ||||
int sMax = -1; | int sMax = -1; | ||||
Map<Integer, String> m = getScriptTagsMap(); | Map<Integer, String> m = getScriptTagsMap(); | ||||
if (m != null) { | if (m != null) { | ||||
String tag; | String tag; | ||||
if ((tag = m.get(Integer.valueOf(code))) != null) { | |||||
if ((tag = m.get(code)) != null) { | |||||
return tag; | return tag; | ||||
} else { | } else { | ||||
return ""; | return ""; | ||||
assert tag.length() != 0; | assert tag.length() != 0; | ||||
assert code >= 0; | assert code >= 0; | ||||
assert code < 2000; | assert code < 2000; | ||||
tm.put(Integer.valueOf(code), tag); | |||||
cm.put(tag, Integer.valueOf(code)); | |||||
tm.put(code, tag); | |||||
cm.put(tag, code); | |||||
} | } | ||||
private static void makeScriptMaps() { | private static void makeScriptMaps() { |
* {@inheritDoc} | * {@inheritDoc} | ||||
*/ | */ | ||||
public Object next() throws NoSuchElementException { | public Object next() throws NoSuchElementException { | ||||
return new Character(nextChar()); | |||||
return nextChar(); | |||||
} | } | ||||
/** | /** |
/** {@inheritDoc} */ | /** {@inheritDoc} */ | ||||
public Number getNumber() { | public Number getNumber() { | ||||
return new Double(value); | |||||
return value; | |||||
} | } | ||||
/** {@inheritDoc} */ | /** {@inheritDoc} */ |
break; | break; | ||||
case TOK_FLOAT: | case TOK_FLOAT: | ||||
prop = NumberProperty.getInstance(new Double(currentTokenValue)); | |||||
prop = NumberProperty.getInstance(Double.valueOf(currentTokenValue)); | |||||
break; | break; | ||||
case TOK_INTEGER: | case TOK_INTEGER: | ||||
prop = NumberProperty.getInstance(new Integer(currentTokenValue)); | |||||
prop = NumberProperty.getInstance(Integer.valueOf(currentTokenValue)); | |||||
break; | break; | ||||
case TOK_PERCENT: | case TOK_PERCENT: |
* @return this.character cast as an Object | * @return this.character cast as an Object | ||||
*/ | */ | ||||
public Object getObject() { | public Object getObject() { | ||||
return new Character(character); | |||||
return character; | |||||
} | } | ||||
/** | /** |
//if possible | //if possible | ||||
if (num == Math.floor(num)) { | if (num == Math.floor(num)) { | ||||
if (num < Integer.MAX_VALUE) { | if (num < Integer.MAX_VALUE) { | ||||
this.number = new Integer((int)num); | |||||
this.number = (int) num; | |||||
} else { | } else { | ||||
this.number = new Long((long)num); | |||||
this.number = (long) num; | |||||
} | } | ||||
} else { | } else { | ||||
this.number = new Double(num); | |||||
this.number = num; | |||||
} | } | ||||
} | } | ||||
* @param num integer numeric value for property | * @param num integer numeric value for property | ||||
*/ | */ | ||||
private NumberProperty(int num) { | private NumberProperty(int num) { | ||||
this.number = new Integer(num); | |||||
this.number = num; | |||||
} | } | ||||
/** | /** |
return null; | return null; | ||||
} | } | ||||
Integer hashCode = Integer.valueOf(obj.hashCode()); | |||||
Integer hashCode = obj.hashCode(); | |||||
WeakReference<T> weakRef = map.get(hashCode); | WeakReference<T> weakRef = map.get(hashCode); | ||||
if (weakRef == null) { | if (weakRef == null) { |
int nextBitSet = 0; | int nextBitSet = 0; | ||||
for (int j = 0; j < glyphIndices.cardinality(); j++) { | for (int j = 0; j < glyphIndices.cardinality(); j++) { | ||||
nextBitSet = glyphIndices.nextSetBit(nextBitSet); | nextBitSet = glyphIndices.nextSetBit(nextBitSet); | ||||
glyphs.put(Integer.valueOf(nextBitSet), Integer.valueOf(nextBitSet)); | |||||
glyphs.put(nextBitSet, nextBitSet); | |||||
nextBitSet++; | nextBitSet++; | ||||
} | } | ||||
return Collections.unmodifiableMap(glyphs); | return Collections.unmodifiableMap(glyphs); |
public void registerFailedFont(String embedUrl, long lastModified) { | public void registerFailedFont(String embedUrl, long lastModified) { | ||||
synchronized (changeLock) { | synchronized (changeLock) { | ||||
if (!getFailedFontMap().containsKey(embedUrl)) { | if (!getFailedFontMap().containsKey(embedUrl)) { | ||||
getFailedFontMap().put(embedUrl, new Long(lastModified)); | |||||
getFailedFontMap().put(embedUrl, lastModified); | |||||
changed = true; | changed = true; | ||||
} | } | ||||
} | } |
} | } | ||||
} | } | ||||
this.triplets.put(triplet, internalFontKey); | this.triplets.put(triplet, internalFontKey); | ||||
this.tripletPriorities.put(triplet, Integer.valueOf(newPriority)); | |||||
this.tripletPriorities.put(triplet, newPriority); | |||||
} | } | ||||
/** | /** | ||||
sizes = new HashMap<Integer, Font>(); | sizes = new HashMap<Integer, Font>(); | ||||
getFontInstanceCache().put(triplet, sizes); | getFontInstanceCache().put(triplet, sizes); | ||||
} | } | ||||
Integer size = Integer.valueOf(fontSize); | |||||
Integer size = fontSize; | |||||
Font font = sizes.get(size); | Font font = sizes.get(size); | ||||
if (font == null) { | if (font == null) { | ||||
String fontKey = getInternalFontKey(triplet); | String fontKey = getInternalFontKey(triplet); |
/** {@inheritDoc} */ | /** {@inheritDoc} */ | ||||
public char mapChar(char c) { | public char mapChar(char c) { | ||||
Character nc = charMap.get(Character.valueOf(c)); | |||||
Character nc = charMap.get(c); | |||||
if (nc != null) { | if (nc != null) { | ||||
return nc.charValue(); | return nc.charValue(); | ||||
} | } | ||||
} | } | ||||
char newSlot = (char)(getLastChar() + 1); | char newSlot = (char)(getLastChar() + 1); | ||||
this.mapping.add(ch); | this.mapping.add(ch); | ||||
this.charMap.put(Character.valueOf(ch.getSingleUnicodeValue()), Character.valueOf(newSlot)); | |||||
this.charMap.put(ch.getSingleUnicodeValue(), newSlot); | |||||
return newSlot; | return newSlot; | ||||
} | } | ||||
int codePoint = i % 256; | int codePoint = i % 256; | ||||
NamedCharacter nc = encoding.getCharacterForIndex(codePoint); | NamedCharacter nc = encoding.getCharacterForIndex(codePoint); | ||||
UnencodedCharacter uc | UnencodedCharacter uc | ||||
= this.unencodedCharacters.get(Character.valueOf(nc.getSingleUnicodeValue())); | |||||
= this.unencodedCharacters.get(nc.getSingleUnicodeValue()); | |||||
return size * uc.getWidth(); | return size * uc.getWidth(); | ||||
} | } | ||||
return 0; | return 0; | ||||
SimpleSingleByteEncoding encoding = getAdditionalEncoding(encodingIndex); | SimpleSingleByteEncoding encoding = getAdditionalEncoding(encodingIndex); | ||||
int codePoint = glyphIndex % 256; | int codePoint = glyphIndex % 256; | ||||
NamedCharacter nc = encoding.getCharacterForIndex(codePoint); | NamedCharacter nc = encoding.getCharacterForIndex(codePoint); | ||||
UnencodedCharacter uc = this.unencodedCharacters.get(Character.valueOf(nc.getSingleUnicodeValue())); | |||||
UnencodedCharacter uc = this.unencodedCharacters.get(nc.getSingleUnicodeValue()); | |||||
bbox = uc.getBBox(); | bbox = uc.getBBox(); | ||||
} | } | ||||
return bbox == null ? null : new Rectangle(bbox.x * size, bbox.y * size, bbox.width * size, bbox.height * size); | return bbox == null ? null : new Rectangle(bbox.x * size, bbox.y * size, bbox.width * size, bbox.height * size); | ||||
private char mapUnencodedChar(char ch) { | private char mapUnencodedChar(char ch) { | ||||
if (this.unencodedCharacters != null) { | if (this.unencodedCharacters != null) { | ||||
UnencodedCharacter unencoded = this.unencodedCharacters.get(Character.valueOf(ch)); | |||||
UnencodedCharacter unencoded = this.unencodedCharacters.get(ch); | |||||
if (unencoded != null) { | if (unencoded != null) { | ||||
if (this.additionalEncodings == null) { | if (this.additionalEncodings == null) { | ||||
this.additionalEncodings = new ArrayList<SimpleSingleByteEncoding>(); | this.additionalEncodings = new ArrayList<SimpleSingleByteEncoding>(); | ||||
} | } | ||||
if (ch.hasSingleUnicodeValue()) { | if (ch.hasSingleUnicodeValue()) { | ||||
UnencodedCharacter uc = new UnencodedCharacter(ch, width, bbox); | UnencodedCharacter uc = new UnencodedCharacter(ch, width, bbox); | ||||
this.unencodedCharacters.put(Character.valueOf(ch.getSingleUnicodeValue()), uc); | |||||
this.unencodedCharacters.put(ch.getSingleUnicodeValue(), uc); | |||||
} else { | } else { | ||||
//Cannot deal with unicode sequences, so ignore this character | //Cannot deal with unicode sequences, so ignore this character | ||||
} | } | ||||
for (int i = 0, c = arr.length; i < c; i++) { | for (int i = 0, c = arr.length; i < c; i++) { | ||||
NamedCharacter nc = enc.getCharacterForIndex(enc.getFirstChar() + i); | NamedCharacter nc = enc.getCharacterForIndex(enc.getFirstChar() + i); | ||||
UnencodedCharacter uc = this.unencodedCharacters.get( | UnencodedCharacter uc = this.unencodedCharacters.get( | ||||
Character.valueOf(nc.getSingleUnicodeValue())); | |||||
nc.getSingleUnicodeValue()); | |||||
arr[i] = uc.getWidth(); | arr[i] = uc.getWidth(); | ||||
} | } | ||||
return arr; | return arr; |
*/ | */ | ||||
protected void warnMissingGlyph(char c) { | protected void warnMissingGlyph(char c) { | ||||
// Give up, character is not available | // Give up, character is not available | ||||
Character ch = new Character(c); | |||||
Character ch = c; | |||||
if (warnedChars == null) { | if (warnedChars == null) { | ||||
warnedChars = new HashSet<Character>(); | warnedChars = new HashSet<Character>(); | ||||
} | } |
el = doc.createElement("cap-height"); | el = doc.createElement("cap-height"); | ||||
root.appendChild(el); | root.appendChild(el); | ||||
Integer value = new Integer(pfm.getCapHeight()); | |||||
Integer value = pfm.getCapHeight(); | |||||
el.appendChild(doc.createTextNode(value.toString())); | el.appendChild(doc.createTextNode(value.toString())); | ||||
el = doc.createElement("x-height"); | el = doc.createElement("x-height"); | ||||
root.appendChild(el); | root.appendChild(el); | ||||
value = new Integer(pfm.getXHeight()); | |||||
value = pfm.getXHeight(); | |||||
el.appendChild(doc.createTextNode(value.toString())); | el.appendChild(doc.createTextNode(value.toString())); | ||||
el = doc.createElement("ascender"); | el = doc.createElement("ascender"); | ||||
root.appendChild(el); | root.appendChild(el); | ||||
value = new Integer(pfm.getLowerCaseAscent()); | |||||
value = pfm.getLowerCaseAscent(); | |||||
el.appendChild(doc.createTextNode(value.toString())); | el.appendChild(doc.createTextNode(value.toString())); | ||||
el = doc.createElement("descender"); | el = doc.createElement("descender"); | ||||
root.appendChild(el); | root.appendChild(el); | ||||
value = new Integer(pfm.getLowerCaseDescent()); | |||||
value = pfm.getLowerCaseDescent(); | |||||
el.appendChild(doc.createTextNode(value.toString())); | el.appendChild(doc.createTextNode(value.toString())); | ||||
Element bbox = doc.createElement("bbox"); | Element bbox = doc.createElement("bbox"); | ||||
for (int i = 0; i < names.length; i++) { | for (int i = 0; i < names.length; i++) { | ||||
el = doc.createElement(names[i]); | el = doc.createElement(names[i]); | ||||
bbox.appendChild(el); | bbox.appendChild(el); | ||||
value = new Integer(bb[i]); | |||||
value = bb[i]; | |||||
el.appendChild(doc.createTextNode(value.toString())); | el.appendChild(doc.createTextNode(value.toString())); | ||||
} | } | ||||
el = doc.createElement("flags"); | el = doc.createElement("flags"); | ||||
root.appendChild(el); | root.appendChild(el); | ||||
value = new Integer(pfm.getFlags()); | |||||
value = pfm.getFlags(); | |||||
el.appendChild(doc.createTextNode(value.toString())); | el.appendChild(doc.createTextNode(value.toString())); | ||||
el = doc.createElement("stemv"); | el = doc.createElement("stemv"); | ||||
root.appendChild(el); | root.appendChild(el); | ||||
value = new Integer(pfm.getStemV()); | |||||
value = pfm.getStemV(); | |||||
el.appendChild(doc.createTextNode(value.toString())); | el.appendChild(doc.createTextNode(value.toString())); | ||||
el = doc.createElement("italicangle"); | el = doc.createElement("italicangle"); | ||||
root.appendChild(el); | root.appendChild(el); | ||||
value = new Integer(pfm.getItalicAngle()); | |||||
value = pfm.getItalicAngle(); | |||||
el.appendChild(doc.createTextNode(value.toString())); | el.appendChild(doc.createTextNode(value.toString())); | ||||
el = doc.createElement("first-char"); | el = doc.createElement("first-char"); | ||||
root.appendChild(el); | root.appendChild(el); | ||||
value = new Integer(pfm.getFirstChar()); | |||||
value = (int) pfm.getFirstChar(); | |||||
el.appendChild(doc.createTextNode(value.toString())); | el.appendChild(doc.createTextNode(value.toString())); | ||||
el = doc.createElement("last-char"); | el = doc.createElement("last-char"); | ||||
root.appendChild(el); | root.appendChild(el); | ||||
value = new Integer(pfm.getLastChar()); | |||||
value = (int) pfm.getLastChar(); | |||||
el.appendChild(doc.createTextNode(value.toString())); | el.appendChild(doc.createTextNode(value.toString())); | ||||
Element widths = doc.createElement("widths"); | Element widths = doc.createElement("widths"); |
UnicodeMapping(OpenFont font, int glyphIndex, int unicodeIndex) { | UnicodeMapping(OpenFont font, int glyphIndex, int unicodeIndex) { | ||||
this.unicodeIndex = unicodeIndex; | this.unicodeIndex = unicodeIndex; | ||||
this.glyphIndex = glyphIndex; | this.glyphIndex = glyphIndex; | ||||
font.glyphToUnicodeMap.put(new Integer(glyphIndex), new Integer(unicodeIndex)); | |||||
font.unicodeToGlyphMap.put(new Integer(unicodeIndex), new Integer(glyphIndex)); | |||||
font.glyphToUnicodeMap.put(glyphIndex, unicodeIndex); | |||||
font.unicodeToGlyphMap.put(unicodeIndex, glyphIndex); | |||||
} | } | ||||
/** | /** | ||||
& 0xffff; | & 0xffff; | ||||
//mtxTab[glyphIdx].setName(mtxTab[glyphIdx].getName() + " - "+(char)j); | //mtxTab[glyphIdx].setName(mtxTab[glyphIdx].getName() + " - "+(char)j); | ||||
unicodeMappings.add(new UnicodeMapping(this, glyphIdx, j)); | unicodeMappings.add(new UnicodeMapping(this, glyphIdx, j)); | ||||
mtxTab[glyphIdx].getUnicodeIndex().add(new Integer(j)); | |||||
mtxTab[glyphIdx].getUnicodeIndex().add(j); | |||||
if (encodingID == 0 && j >= 0xF020 && j <= 0xF0FF) { | if (encodingID == 0 && j >= 0xF020 && j <= 0xF0FF) { | ||||
//Experimental: Mapping 0xF020-0xF0FF to 0x0020-0x00FF | //Experimental: Mapping 0xF020-0xF0FF to 0x0020-0x00FF | ||||
if (!eightBitGlyphs.get(mapped)) { | if (!eightBitGlyphs.get(mapped)) { | ||||
//Only map if Unicode code point hasn't been mapped before | //Only map if Unicode code point hasn't been mapped before | ||||
unicodeMappings.add(new UnicodeMapping(this, glyphIdx, mapped)); | unicodeMappings.add(new UnicodeMapping(this, glyphIdx, mapped)); | ||||
mtxTab[glyphIdx].getUnicodeIndex().add(new Integer(mapped)); | |||||
mtxTab[glyphIdx].getUnicodeIndex().add(mapped); | |||||
} | } | ||||
} | } | ||||
// Also add winAnsiWidth | // Also add winAnsiWidth | ||||
List<Integer> v = ansiIndex.get(new Integer(j)); | |||||
List<Integer> v = ansiIndex.get(j); | |||||
if (v != null) { | if (v != null) { | ||||
for (Integer aIdx : v) { | for (Integer aIdx : v) { | ||||
ansiWidth[aIdx.intValue()] | ansiWidth[aIdx.intValue()] | ||||
glyphIdx = (j + cmapDeltas[i]) & 0xffff; | glyphIdx = (j + cmapDeltas[i]) & 0xffff; | ||||
if (glyphIdx < mtxTab.length) { | if (glyphIdx < mtxTab.length) { | ||||
mtxTab[glyphIdx].getUnicodeIndex().add(new Integer(j)); | |||||
mtxTab[glyphIdx].getUnicodeIndex().add(j); | |||||
} else { | } else { | ||||
log.debug("Glyph " + glyphIdx | log.debug("Glyph " + glyphIdx | ||||
+ " out of range: " | + " out of range: " | ||||
unicodeMappings.add(new UnicodeMapping(this, glyphIdx, j)); | unicodeMappings.add(new UnicodeMapping(this, glyphIdx, j)); | ||||
if (glyphIdx < mtxTab.length) { | if (glyphIdx < mtxTab.length) { | ||||
mtxTab[glyphIdx].getUnicodeIndex().add(new Integer(j)); | |||||
mtxTab[glyphIdx].getUnicodeIndex().add(j); | |||||
} else { | } else { | ||||
log.debug("Glyph " + glyphIdx | log.debug("Glyph " + glyphIdx | ||||
+ " out of range: " | + " out of range: " | ||||
} | } | ||||
// Also add winAnsiWidth | // Also add winAnsiWidth | ||||
List<Integer> v = ansiIndex.get(new Integer(j)); | |||||
List<Integer> v = ansiIndex.get(j); | |||||
if (v != null) { | if (v != null) { | ||||
for (Integer aIdx : v) { | for (Integer aIdx : v) { | ||||
ansiWidth[aIdx.intValue()] = mtxTab[glyphIdx].getWx(); | ansiWidth[aIdx.intValue()] = mtxTab[glyphIdx].getWx(); | ||||
// same char (eg bullet) is repeated more than one place | // same char (eg bullet) is repeated more than one place | ||||
ansiIndex = new HashMap<Integer, List<Integer>>(); | ansiIndex = new HashMap<Integer, List<Integer>>(); | ||||
for (int i = 32; i < Glyphs.WINANSI_ENCODING.length; i++) { | for (int i = 32; i < Glyphs.WINANSI_ENCODING.length; i++) { | ||||
Integer ansi = new Integer(i); | |||||
Integer uni = new Integer(Glyphs.WINANSI_ENCODING[i]); | |||||
Integer ansi = i; | |||||
Integer uni = (int) Glyphs.WINANSI_ENCODING[i]; | |||||
List<Integer> v = ansiIndex.get(uni); | List<Integer> v = ansiIndex.get(uni); | ||||
if (v == null) { | if (v == null) { | ||||
if (adjTab == null) { | if (adjTab == null) { | ||||
adjTab = new HashMap<Integer, Integer>(); | adjTab = new HashMap<Integer, Integer>(); | ||||
} | } | ||||
adjTab.put(u2, new Integer(convertTTFUnit2PDFUnit(kpx))); | |||||
adjTab.put(u2, convertTTFUnit2PDFUnit(kpx)); | |||||
kerningTab.put(iObj, adjTab); | kerningTab.put(iObj, adjTab); | ||||
} | } | ||||
} | } | ||||
List<Integer> ret = new ArrayList<Integer>(); | List<Integer> ret = new ArrayList<Integer>(); | ||||
for (int i = 32; i < Glyphs.WINANSI_ENCODING.length; i++) { | for (int i = 32; i < Glyphs.WINANSI_ENCODING.length; i++) { | ||||
if (unicode == Glyphs.WINANSI_ENCODING[i]) { | if (unicode == Glyphs.WINANSI_ENCODING[i]) { | ||||
ret.add(new Integer(i)); | |||||
ret.add(i); | |||||
} | } | ||||
} | } | ||||
return ret.toArray(new Integer[ret.size()]); | return ret.toArray(new Integer[ret.size()]); | ||||
* @return unicode code point | * @return unicode code point | ||||
*/ | */ | ||||
private Integer glyphToUnicode(int glyphIndex) { | private Integer glyphToUnicode(int glyphIndex) { | ||||
return glyphToUnicodeMap.get(new Integer(glyphIndex)); | |||||
return glyphToUnicodeMap.get(glyphIndex); | |||||
} | } | ||||
/** | /** | ||||
*/ | */ | ||||
private Integer unicodeToGlyph(int unicodeIndex) throws IOException { | private Integer unicodeToGlyph(int unicodeIndex) throws IOException { | ||||
final Integer result | final Integer result | ||||
= unicodeToGlyphMap.get(new Integer(unicodeIndex)); | |||||
= unicodeToGlyphMap.get(unicodeIndex); | |||||
if (result == null) { | if (result == null) { | ||||
throw new IOException( | throw new IOException( | ||||
"Glyph index not found for unicode value " + unicodeIndex); | "Glyph index not found for unicode value " + unicodeIndex); |
continue; | continue; | ||||
} | } | ||||
if (container == null) { | if (container == null) { | ||||
Integer k1 = Integer.valueOf(chm1.getCharCode()); | |||||
Integer k1 = chm1.getCharCode(); | |||||
container = m.get(k1); | container = m.get(k1); | ||||
if (container == null) { | if (container == null) { | ||||
container = new java.util.HashMap<Integer, Integer>(); | container = new java.util.HashMap<Integer, Integer>(); | ||||
} | } | ||||
} | } | ||||
Dimension2D dim = entryTo.getValue(); | Dimension2D dim = entryTo.getValue(); | ||||
container.put(Integer.valueOf(chm2.getCharCode()), | |||||
Integer.valueOf((int)Math.round(dim.getWidth()))); | |||||
container.put(chm2.getCharCode(), | |||||
(int) Math.round(dim.getWidth())); | |||||
} | } | ||||
} | } | ||||
return m; | return m; |
VALUE_PARSERS.put(KPY, new NotImplementedYet(KPY)); | VALUE_PARSERS.put(KPY, new NotImplementedYet(KPY)); | ||||
PARSE_MODE_CHANGES = new HashMap<String, Integer>(); | PARSE_MODE_CHANGES = new HashMap<String, Integer>(); | ||||
PARSE_MODE_CHANGES.put(START_CHAR_METRICS, new Integer(PARSE_CHAR_METRICS)); | |||||
PARSE_MODE_CHANGES.put(END_CHAR_METRICS, new Integer(PARSE_NORMAL)); | |||||
PARSE_MODE_CHANGES.put(START_CHAR_METRICS, PARSE_CHAR_METRICS); | |||||
PARSE_MODE_CHANGES.put(END_CHAR_METRICS, PARSE_NORMAL); | |||||
} | } | ||||
/** | /** | ||||
protected Number getNumberValue(String line, int startpos) { | protected Number getNumberValue(String line, int startpos) { | ||||
try { | try { | ||||
return new Integer(getIntegerValue(line, startpos)); | |||||
return getIntegerValue(line, startpos); | |||||
} catch (NumberFormatException nfe) { | } catch (NumberFormatException nfe) { | ||||
return new Double(getDoubleValue(line, startpos)); | |||||
return getDoubleValue(line, startpos); | |||||
} | } | ||||
} | } | ||||
public void parse(String line, int startpos, Stack<Object> stack) throws IOException { | public void parse(String line, int startpos, Stack<Object> stack) throws IOException { | ||||
int value = getIntegerValue(line, startpos); | int value = getIntegerValue(line, startpos); | ||||
setValue(getContextObject(stack), int.class, new Integer(value)); | |||||
setValue(getContextObject(stack), int.class, value); | |||||
} | } | ||||
} | } | ||||
public void parse(String line, int startpos, Stack<Object> stack) throws IOException { | public void parse(String line, int startpos, Stack<Object> stack) throws IOException { | ||||
double value = getDoubleValue(line, startpos); | double value = getDoubleValue(line, startpos); | ||||
setValue(getContextObject(stack), double.class, new Double(value)); | |||||
setValue(getContextObject(stack), double.class, value); | |||||
} | } | ||||
} | } | ||||
public void parse(String line, int startpos, Stack<Object> stack) throws IOException { | public void parse(String line, int startpos, Stack<Object> stack) throws IOException { | ||||
double value = getDoubleValue(line, startpos); | double value = getDoubleValue(line, startpos); | ||||
setValue(getContextObject(stack), double.class, new Double(value)); | |||||
setValue(getContextObject(stack), double.class, value); | |||||
} | } | ||||
} | } | ||||
log.trace("glyphs: " + glyph1 + ", " + glyph2); | log.trace("glyphs: " + glyph1 + ", " + glyph2); | ||||
} | } | ||||
Map<Integer, Integer> adjTab = kerningTab.get(Integer.valueOf(g1)); | |||||
Map<Integer, Integer> adjTab = kerningTab.get(g1); | |||||
if (adjTab == null) { | if (adjTab == null) { | ||||
adjTab = new HashMap<Integer, Integer>(); | adjTab = new HashMap<Integer, Integer>(); | ||||
} | } | ||||
adjTab.put(Integer.valueOf(g2), Integer.valueOf(adj)); | |||||
kerningTab.put(Integer.valueOf(g1), adjTab); | |||||
adjTab.put(g2, adj); | |||||
kerningTab.put(g1, adjTab); | |||||
} | } | ||||
} | } | ||||
*/ | */ | ||||
public static void addBreaks(Area area, int breakBefore, int breakAfter) { | public static void addBreaks(Area area, int breakBefore, int breakAfter) { | ||||
/* Currently disabled as these traits are never used by the renderers | /* Currently disabled as these traits are never used by the renderers | ||||
area.addTrait(Trait.BREAK_AFTER, new Integer(breakAfter)); | |||||
area.addTrait(Trait.BREAK_BEFORE, new Integer(breakBefore)); | |||||
area.addTrait(Trait.BREAK_AFTER, Integer.valueOf(breakAfter)); | |||||
area.addTrait(Trait.BREAK_BEFORE, Integer.valueOf(breakBefore)); | |||||
*/ | */ | ||||
} | } | ||||
lineArea.addTrait(Trait.START_INDENT, lbp.startIndent); | lineArea.addTrait(Trait.START_INDENT, lbp.startIndent); | ||||
} | } | ||||
if (lbp.endIndent != 0) { | if (lbp.endIndent != 0) { | ||||
lineArea.addTrait(Trait.END_INDENT, new Integer(lbp.endIndent)); | |||||
lineArea.addTrait(Trait.END_INDENT, lbp.endIndent); | |||||
} | } | ||||
lineArea.setBPD(lbp.lineHeight); | lineArea.setBPD(lbp.lineHeight); | ||||
lineArea.setIPD(lbp.lineWidth); | lineArea.setIPD(lbp.lineWidth); |
* below. | * below. | ||||
*/ | */ | ||||
for (int i = rowOffsets.size(); i <= rowIndex - firstRowIndex; i++) { | for (int i = rowOffsets.size(); i <= rowIndex - firstRowIndex; i++) { | ||||
rowOffsets.add(new Integer(offset)); | |||||
rowOffsets.add(offset); | |||||
} | } | ||||
} | } | ||||
OutputStream filteredOutput = getFilterList().applyFilters(cout); | OutputStream filteredOutput = getFilterList().applyFilters(cout); | ||||
outputRawStreamData(filteredOutput); | outputRawStreamData(filteredOutput); | ||||
filteredOutput.close(); | filteredOutput.close(); | ||||
refLength.setNumber(Integer.valueOf(cout.getCount())); | |||||
refLength.setNumber(cout.getCount()); | |||||
bytesWritten += cout.getCount(); | bytesWritten += cout.getCount(); | ||||
//Stream trailer | //Stream trailer |
super(parent); | super(parent); | ||||
for (int i = 0, c = values.length; i < c; i++) { | for (int i = 0, c = values.length; i < c; i++) { | ||||
this.values.add(Integer.valueOf(values[i])); | |||||
this.values.add(values[i]); | |||||
} | } | ||||
} | } | ||||
super(parent); | super(parent); | ||||
for (int i = 0, c = values.length; i < c; i++) { | for (int i = 0, c = values.length; i < c; i++) { | ||||
this.values.add(new Double(values[i])); | |||||
this.values.add(values[i]); | |||||
} | } | ||||
} | } | ||||
* @param value the new value | * @param value the new value | ||||
*/ | */ | ||||
public void set(int index, double value) { | public void set(int index, double value) { | ||||
this.values.set(index, new Double(value)); | |||||
this.values.set(index, value); | |||||
} | } | ||||
/** | /** | ||||
* @param value the value | * @param value the value | ||||
*/ | */ | ||||
public void add(double value) { | public void add(double value) { | ||||
this.values.add(new Double(value)); | |||||
this.values.add(value); | |||||
} | } | ||||
/** | /** |
this.basefont = basefont; | this.basefont = basefont; | ||||
this.cidtype = cidtype; | this.cidtype = cidtype; | ||||
this.dw = new Integer(dw); | |||||
this.dw = dw; | |||||
this.w = w; | this.w = w; | ||||
this.dw2 = null; | this.dw2 = null; | ||||
this.w2 = null; | this.w2 = null; | ||||
* @param dw the default width | * @param dw the default width | ||||
*/ | */ | ||||
public void setDW(int dw) { | public void setDW(int dw) { | ||||
this.dw = new Integer(dw); | |||||
this.dw = dw; | |||||
} | } | ||||
/** | /** |
super(basefont, fontBBox[3], fontBBox[1], capHeight, flags, | super(basefont, fontBBox[3], fontBBox[1], capHeight, flags, | ||||
new PDFRectangle(fontBBox), italicAngle, stemV); | new PDFRectangle(fontBBox), italicAngle, stemV); | ||||
put("MissingWidth", new Integer(500)); | |||||
put("MissingWidth", Integer.valueOf(500)); | |||||
if (lang != null) { | if (lang != null) { | ||||
put("Lang", lang); | put("Lang", lang); | ||||
} | } |
List theColorVector = new ArrayList(); | List theColorVector = new ArrayList(); | ||||
if (this.colorSpace.getColorSpace() == PDFDeviceColorSpace.DEVICE_RGB) { | if (this.colorSpace.getColorSpace() == PDFDeviceColorSpace.DEVICE_RGB) { | ||||
// RGB | // RGB | ||||
theColorVector.add(new Double(this.red)); | |||||
theColorVector.add(new Double(this.green)); | |||||
theColorVector.add(new Double(this.blue)); | |||||
theColorVector.add(this.red); | |||||
theColorVector.add(this.green); | |||||
theColorVector.add(this.blue); | |||||
} else if (this.colorSpace.getColorSpace() | } else if (this.colorSpace.getColorSpace() | ||||
== PDFDeviceColorSpace.DEVICE_CMYK) { | == PDFDeviceColorSpace.DEVICE_CMYK) { | ||||
// CMYK | // CMYK | ||||
theColorVector.add(new Double(this.cyan)); | |||||
theColorVector.add(new Double(this.magenta)); | |||||
theColorVector.add(new Double(this.yellow)); | |||||
theColorVector.add(new Double(this.black)); | |||||
theColorVector.add(this.cyan); | |||||
theColorVector.add(this.magenta); | |||||
theColorVector.add(this.yellow); | |||||
theColorVector.add(this.black); | |||||
} else { | } else { | ||||
// GRAY | // GRAY | ||||
theColorVector.add(new Double(this.black)); | |||||
theColorVector.add(this.black); | |||||
} | } | ||||
return (theColorVector); | return (theColorVector); | ||||
} | } |
if (!entries.containsKey(name)) { | if (!entries.containsKey(name)) { | ||||
this.order.add(name); | this.order.add(name); | ||||
} | } | ||||
this.entries.put(name, Integer.valueOf(value)); | |||||
this.entries.put(name, value); | |||||
} | } | ||||
/** | /** |
super.populateStreamDict(lengthEntry); | super.populateStreamDict(lengthEntry); | ||||
try { | try { | ||||
PDFDictionary dict = (PDFDictionary)get("Params"); | PDFDictionary dict = (PDFDictionary)get("Params"); | ||||
dict.put("Size", new Integer(data.getSize())); | |||||
dict.put("Size", Integer.valueOf(data.getSize())); | |||||
} catch (IOException ioe) { | } catch (IOException ioe) { | ||||
//ignore and just skip this entry as it's optional | //ignore and just skip this entry as it's optional | ||||
} | } |
public PDFSeparationColorSpace makeSeparationColorSpace(PDFResourceContext res, | public PDFSeparationColorSpace makeSeparationColorSpace(PDFResourceContext res, | ||||
NamedColorSpace ncs) { | NamedColorSpace ncs) { | ||||
String colorName = ncs.getColorName(); | String colorName = ncs.getColorName(); | ||||
final Double zero = new Double(0d); | |||||
final Double one = new Double(1d); | |||||
final Double zero = 0d; | |||||
final Double one = 1d; | |||||
List domain = Arrays.asList(new Double[] {zero, one}); | List domain = Arrays.asList(new Double[] {zero, one}); | ||||
List range = Arrays.asList(new Double[] {zero, one, zero, one, zero, one}); | List range = Arrays.asList(new Double[] {zero, one, zero, one, zero, one}); | ||||
float[] cZero = new float[] {1f, 1f, 1f}; | float[] cZero = new float[] {1f, 1f, 1f}; |
*/ | */ | ||||
public void setWidthMetrics(int firstChar, int lastChar, | public void setWidthMetrics(int firstChar, int lastChar, | ||||
PDFArray widths) { | PDFArray widths) { | ||||
put("FirstChar", new Integer(firstChar)); | |||||
put("LastChar", new Integer(lastChar)); | |||||
put("FirstChar", Integer.valueOf(firstChar)); | |||||
put("LastChar", Integer.valueOf(lastChar)); | |||||
put("Widths", widths); | put("Widths", widths); | ||||
} | } | ||||
put("Type", new PDFName("XObject")); | put("Type", new PDFName("XObject")); | ||||
put("Subtype", new PDFName("Form")); | put("Subtype", new PDFName("Form")); | ||||
put("FormType", new Integer(1)); | |||||
put("FormType", 1); | |||||
setMatrix(new AffineTransform()); | setMatrix(new AffineTransform()); | ||||
if (resources != null) { | if (resources != null) { | ||||
put("Resources", resources); | put("Resources", resources); |
DEFAULT = new PDFGState(); | DEFAULT = new PDFGState(); | ||||
Map vals = DEFAULT.values; | Map vals = DEFAULT.values; | ||||
/*vals.put(LW, new Float(1.0)); | /*vals.put(LW, new Float(1.0)); | ||||
vals.put(LC, new Integer(0)); | |||||
vals.put(LJ, new Integer(0)); | |||||
vals.put(LC, Integer.valueOf(0)); | |||||
vals.put(LJ, Integer.valueOf(0)); | |||||
vals.put(ML, new Float(10.0)); | vals.put(ML, new Float(10.0)); | ||||
vals.put(D, "0 []"); | vals.put(D, "0 []"); | ||||
vals.put(RI, "RelativeColorimetric"); | vals.put(RI, "RelativeColorimetric"); | ||||
vals.put(OP, Boolean.FALSE); | vals.put(OP, Boolean.FALSE); | ||||
vals.put(op, Boolean.FALSE); | vals.put(op, Boolean.FALSE); | ||||
vals.put(OPM, new Integer(1)); | |||||
vals.put(OPM, Integer.valueOf(1)); | |||||
vals.put(Font, "");*/ | vals.put(Font, "");*/ | ||||
vals.put(GSTATE_ALPHA_STROKE, new Float(1.0)); | |||||
vals.put(GSTATE_ALPHA_NONSTROKE, new Float(1.0)); | |||||
vals.put(GSTATE_ALPHA_STROKE, 1.0f); | |||||
vals.put(GSTATE_ALPHA_NONSTROKE, 1.0f); | |||||
} | } | ||||
private Map values = new java.util.HashMap(); | private Map values = new java.util.HashMap(); | ||||
*/ | */ | ||||
public void setAlpha(float val, boolean fill) { | public void setAlpha(float val, boolean fill) { | ||||
if (fill) { | if (fill) { | ||||
values.put(GSTATE_ALPHA_NONSTROKE, new Float(val)); | |||||
values.put(GSTATE_ALPHA_NONSTROKE, val); | |||||
} else { | } else { | ||||
values.put(GSTATE_ALPHA_STROKE, new Float(val)); | |||||
values.put(GSTATE_ALPHA_STROKE, val); | |||||
} | } | ||||
} | } | ||||
private void populateDictionaryFromImage() { | private void populateDictionaryFromImage() { | ||||
put("Subtype", new PDFName("Image")); | put("Subtype", new PDFName("Image")); | ||||
put("Width", new Integer(pdfimage.getWidth())); | |||||
put("Height", new Integer(pdfimage.getHeight())); | |||||
put("BitsPerComponent", new Integer(pdfimage.getBitsPerComponent())); | |||||
put("Width", pdfimage.getWidth()); | |||||
put("Height", pdfimage.getHeight()); | |||||
put("BitsPerComponent", pdfimage.getBitsPerComponent()); | |||||
PDFICCStream pdfICCStream = pdfimage.getICCStream(); | PDFICCStream pdfICCStream = pdfimage.getICCStream(); | ||||
if (pdfICCStream != null) { | if (pdfICCStream != null) { | ||||
* this will invert the values - too bad if it's not | * this will invert the values - too bad if it's not | ||||
* a PhotoShop image... | * a PhotoShop image... | ||||
*/ | */ | ||||
final Float zero = new Float(0.0f); | |||||
final Float one = new Float(1.0f); | |||||
final Float zero = 0.0f; | |||||
final Float one = 1.0f; | |||||
PDFArray decode = new PDFArray(this); | PDFArray decode = new PDFArray(this); | ||||
for (int i = 0, c = pdfimage.getColorSpace().getNumComponents(); i < c; i++) { | for (int i = 0, c = pdfimage.getColorSpace().getNumComponents(); i < c; i++) { | ||||
decode.add(one); | decode.add(one); | ||||
PDFColor transp = pdfimage.getTransparentColor(); | PDFColor transp = pdfimage.getTransparentColor(); | ||||
PDFArray mask = new PDFArray(this); | PDFArray mask = new PDFArray(this); | ||||
if (pdfimage.getColorSpace().isGrayColorSpace()) { | if (pdfimage.getColorSpace().isGrayColorSpace()) { | ||||
mask.add(new Integer(transp.red255())); | |||||
mask.add(new Integer(transp.red255())); | |||||
mask.add(Integer.valueOf(transp.red255())); | |||||
mask.add(Integer.valueOf(transp.red255())); | |||||
} else { | } else { | ||||
mask.add(new Integer(transp.red255())); | |||||
mask.add(new Integer(transp.red255())); | |||||
mask.add(new Integer(transp.green255())); | |||||
mask.add(new Integer(transp.green255())); | |||||
mask.add(new Integer(transp.blue255())); | |||||
mask.add(new Integer(transp.blue255())); | |||||
mask.add(Integer.valueOf(transp.red255())); | |||||
mask.add(Integer.valueOf(transp.red255())); | |||||
mask.add(Integer.valueOf(transp.green255())); | |||||
mask.add(Integer.valueOf(transp.green255())); | |||||
mask.add(Integer.valueOf(transp.blue255())); | |||||
mask.add(Integer.valueOf(transp.blue255())); | |||||
} | } | ||||
put("Mask", mask); | put("Mask", mask); | ||||
} | } |
* @param structParent key in the structure parent tree | * @param structParent key in the structure parent tree | ||||
*/ | */ | ||||
public void setStructParent(int structParent) { | public void setStructParent(int structParent) { | ||||
this.structParent = new Integer(structParent); | |||||
this.structParent = structParent; | |||||
} | } | ||||
/** | /** |
private Number number; | private Number number; | ||||
public PDFNumber() { | public PDFNumber() { | ||||
this.number = Integer.valueOf(0); | |||||
this.number = 0; | |||||
} | } | ||||
public PDFNumber(Number number) { | public PDFNumber(Number number) { |
* @param tr the transition dictionary | * @param tr the transition dictionary | ||||
*/ | */ | ||||
public void setTransition(int dur, TransitionDictionary tr) { | public void setTransition(int dur, TransitionDictionary tr) { | ||||
put("Dur", new Integer(dur)); | |||||
put("Dur", Integer.valueOf(dur)); | |||||
put("Trans", tr); | put("Trans", tr); | ||||
} | } | ||||
} | } | ||||
p.append("] \n"); | p.append("] \n"); | ||||
} | } | ||||
p.append("/XStep " + PDFNumber.doubleOut(new Double(this.xStep)) | |||||
p.append("/XStep " + PDFNumber.doubleOut(Double.valueOf(this.xStep)) | |||||
+ " \n"); | + " \n"); | ||||
p.append("/YStep " + PDFNumber.doubleOut(new Double(this.yStep)) | |||||
p.append("/YStep " + PDFNumber.doubleOut(Double.valueOf(this.yStep)) | |||||
+ " \n"); | + " \n"); | ||||
if (this.matrix != null) { | if (this.matrix != null) { |
/** {@inheritDoc} */ | /** {@inheritDoc} */ | ||||
protected void populateStreamDict(Object lengthEntry) { | protected void populateStreamDict(Object lengthEntry) { | ||||
super.populateStreamDict(lengthEntry); | super.populateStreamDict(lengthEntry); | ||||
put("Length1", new Integer(pfb.getLength1())); | |||||
put("Length2", new Integer(pfb.getLength2())); | |||||
put("Length3", new Integer(pfb.getLength3())); | |||||
put("Length1", pfb.getLength1()); | |||||
put("Length2", pfb.getLength2()); | |||||
put("Length3", pfb.getLength3()); | |||||
} | } | ||||
/** | /** |
context.setUserAgent(userAgent); | context.setUserAgent(userAgent); | ||||
context.setProperty(RendererContextConstants.WIDTH, | context.setProperty(RendererContextConstants.WIDTH, | ||||
new Integer(width)); | |||||
width); | |||||
context.setProperty(RendererContextConstants.HEIGHT, | context.setProperty(RendererContextConstants.HEIGHT, | ||||
new Integer(height)); | |||||
height); | |||||
context.setProperty(RendererContextConstants.XPOS, | context.setProperty(RendererContextConstants.XPOS, | ||||
new Integer(x)); | |||||
x); | |||||
context.setProperty(RendererContextConstants.YPOS, | context.setProperty(RendererContextConstants.YPOS, | ||||
new Integer(y)); | |||||
y); | |||||
context.setProperty(RendererContextConstants.PAGE_VIEWPORT, | context.setProperty(RendererContextConstants.PAGE_VIEWPORT, | ||||
getCurrentPageViewport()); | getCurrentPageViewport()); | ||||
if (foreignAttributes != null) { | if (foreignAttributes != null) { |
hints.put(ImageHandlerUtil.CONVERSION_MODE, ImageHandlerUtil.CONVERSION_MODE_BITMAP); | hints.put(ImageHandlerUtil.CONVERSION_MODE, ImageHandlerUtil.CONVERSION_MODE_BITMAP); | ||||
hints.put("TARGET_RESOLUTION", | hints.put("TARGET_RESOLUTION", | ||||
Integer.valueOf(context.getPaintingState().getResolution())); | |||||
context.getPaintingState().getResolution()); | |||||
try { | try { |
super(name); | super(name); | ||||
putValue(SHORT_DESCRIPTION, name); | putValue(SHORT_DESCRIPTION, name); | ||||
if (mnemonic > 0) { | if (mnemonic > 0) { | ||||
putValue(MNEMONIC_KEY, new Integer(mnemonic)); | |||||
putValue(MNEMONIC_KEY, mnemonic); | |||||
} | } | ||||
} | } | ||||
Point2D startPoint = gp.getStartPoint(); | Point2D startPoint = gp.getStartPoint(); | ||||
Point2D endPoint = gp.getEndPoint(); | Point2D endPoint = gp.getEndPoint(); | ||||
List<Double> coords = new java.util.ArrayList<Double>(4); | List<Double> coords = new java.util.ArrayList<Double>(4); | ||||
coords.add(Double.valueOf(startPoint.getX())); | |||||
coords.add(Double.valueOf(startPoint.getY())); | |||||
coords.add(Double.valueOf(endPoint.getX())); | |||||
coords.add(Double.valueOf(endPoint.getY())); | |||||
coords.add(startPoint.getX()); | |||||
coords.add(startPoint.getY()); | |||||
coords.add(endPoint.getX()); | |||||
coords.add(endPoint.getY()); | |||||
return makeGradient(gp, coords, baseTransform, transform); | return makeGradient(gp, coords, baseTransform, transform); | ||||
} | } | ||||
dy *= scale; | dy *= scale; | ||||
} | } | ||||
List<Double> coords = new java.util.ArrayList<Double>(6); | List<Double> coords = new java.util.ArrayList<Double>(6); | ||||
coords.add(Double.valueOf(center.getX() + dx)); | |||||
coords.add(Double.valueOf(center.getY() + dy)); | |||||
coords.add(Double.valueOf(0)); | |||||
coords.add(Double.valueOf(center.getX())); | |||||
coords.add(Double.valueOf(center.getY())); | |||||
coords.add(Double.valueOf(radius)); | |||||
coords.add(center.getX() + dx); | |||||
coords.add(center.getY() + dy); | |||||
coords.add(0d); | |||||
coords.add(center.getX()); | |||||
coords.add(center.getY()); | |||||
coords.add(radius); | |||||
return makeGradient(gradient, coords, baseTransform, transform); | return makeGradient(gradient, coords, baseTransform, transform); | ||||
} | } | ||||
double[] m = new double[6]; | double[] m = new double[6]; | ||||
gradientTransform.getMatrix(m); | gradientTransform.getMatrix(m); | ||||
for (double d : m) { | for (double d : m) { | ||||
matrix.add(Double.valueOf(d)); | |||||
matrix.add(d); | |||||
} | } | ||||
return matrix; | return matrix; | ||||
} | } |
log.trace("renderPage() " + page); | log.trace("renderPage() " + page); | ||||
} | } | ||||
try { | try { | ||||
pageIndices.put(page.getKey(), new Integer(page.getPageIndex())); | |||||
pageIndices.put(page.getKey(), page.getPageIndex()); | |||||
Rectangle viewArea = page.getViewArea(); | Rectangle viewArea = page.getViewArea(); | ||||
Dimension dim = new Dimension(viewArea.width, viewArea.height); | Dimension dim = new Dimension(viewArea.width, viewArea.height); | ||||
FontTriplet triplet = (FontTriplet)text.getTrait(Trait.FONT); | FontTriplet triplet = (FontTriplet)text.getTrait(Trait.FONT); | ||||
try { | try { | ||||
painter.setFont(triplet.getName(), triplet.getStyle(), new Integer(triplet.getWeight()), | |||||
"normal", new Integer(size), ct); | |||||
painter.setFont(triplet.getName(), triplet.getStyle(), triplet.getWeight(), | |||||
"normal", size, ct); | |||||
} catch (IFException e) { | } catch (IFException e) { | ||||
handleIFException(e); | handleIFException(e); | ||||
} | } |
if ((style & Font.ITALIC) != 0) { | if ((style & Font.ITALIC) != 0) { | ||||
atts.put(TextAttribute.POSTURE, TextAttribute.POSTURE_OBLIQUE); | atts.put(TextAttribute.POSTURE, TextAttribute.POSTURE_OBLIQUE); | ||||
} | } | ||||
atts.put(TextAttribute.SIZE, new Float(size)); //size in pt | |||||
atts.put(TextAttribute.SIZE, size); //size in pt | |||||
return new Font(atts); | return new Font(atts); | ||||
} | } | ||||
icm.getBlues(blues); | icm.getBlues(blues); | ||||
for (int i = 0; i < icm.getMapSize(); i++) { | for (int i = 0; i < icm.getMapSize(); i++) { | ||||
if ((alphas[i] & 0xFF) == 0) { | if ((alphas[i] & 0xFF) == 0) { | ||||
return Integer.valueOf(i); | |||||
return i; | |||||
} | } | ||||
} | } | ||||
return null; | return null; |
pdfUtil.generatePageLabel(index, name); | pdfUtil.generatePageLabel(index, name); | ||||
currentPageRef = new PageReference(currentPage, size); | currentPageRef = new PageReference(currentPage, size); | ||||
this.pageReferences.put(Integer.valueOf(index), currentPageRef); | |||||
this.pageReferences.put(index, currentPageRef); | |||||
this.generator = new PDFContentGenerator(this.pdfDoc, this.outputStream, | this.generator = new PDFContentGenerator(this.pdfDoc, this.outputStream, | ||||
this.currentPage); | this.currentPage); | ||||
} | } | ||||
PageReference getPageReference(int pageIndex) { | PageReference getPageReference(int pageIndex) { | ||||
return this.pageReferences.get(Integer.valueOf(pageIndex)); | |||||
return this.pageReferences.get(pageIndex); | |||||
} | } | ||||
static final class PageReference { | static final class PageReference { |
try { | try { | ||||
double d = Double.parseDouble(value); | double d = Double.parseDouble(value); | ||||
if (Math.abs(Math.floor(d) - d) < 1E-10) { | if (Math.abs(Math.floor(d) - d) < 1E-10) { | ||||
extension.setValue(Long.valueOf((long) d)); | |||||
extension.setValue((long) d); | |||||
} else { | } else { | ||||
extension.setValue(Double.valueOf(d)); | |||||
extension.setValue(d); | |||||
} | } | ||||
} catch (NumberFormatException e) { | } catch (NumberFormatException e) { | ||||
invalidPropertyValueError("<value>", value, null); | invalidPropertyValueError("<value>", value, null); |
} else if (value instanceof String) { | } else if (value instanceof String) { | ||||
double d = Double.parseDouble((String) value); | double d = Double.parseDouble((String) value); | ||||
if (Math.abs(Math.floor(d) - d) < 1E-10) { | if (Math.abs(Math.floor(d) - d) < 1E-10) { | ||||
return Long.valueOf((long) d); | |||||
return (long) d; | |||||
} else { | } else { | ||||
return Double.valueOf(d); | |||||
return d; | |||||
} | } | ||||
} else { | } else { | ||||
return Integer.valueOf(0); | |||||
return 0; | |||||
} | } | ||||
} | } | ||||
/** {@inheritDoc} */ | /** {@inheritDoc} */ | ||||
public String getImplicitFilter() { | public String getImplicitFilter() { | ||||
PSDictionary dict = new PSDictionary(); | PSDictionary dict = new PSDictionary(); | ||||
dict.put("/Columns", new Integer(ccitt.getSize().getWidthPx())); | |||||
dict.put("/Columns", ccitt.getSize().getWidthPx()); | |||||
int compression = ccitt.getCompression(); | int compression = ccitt.getCompression(); | ||||
switch (compression) { | switch (compression) { | ||||
case TIFFImage.COMP_FAX_G3_1D : | case TIFFImage.COMP_FAX_G3_1D : | ||||
dict.put("/K", new Integer(0)); | |||||
dict.put("/K", 0); | |||||
break; | break; | ||||
case TIFFImage.COMP_FAX_G3_2D : | case TIFFImage.COMP_FAX_G3_2D : | ||||
dict.put("/K", new Integer(1)); | |||||
dict.put("/K", 1); | |||||
break; | break; | ||||
case TIFFImage.COMP_FAX_G4_2D : | case TIFFImage.COMP_FAX_G4_2D : | ||||
dict.put("/K", new Integer(-1)); | |||||
dict.put("/K", -1); | |||||
break; | break; | ||||
default: | default: | ||||
throw new IllegalStateException( | throw new IllegalStateException( |
gen.writeln(DSCConstants.PS_ADOBE_30); | gen.writeln(DSCConstants.PS_ADOBE_30); | ||||
gen.writeDSCComment(DSCConstants.CREATOR, new String[] {getUserAgent().getProducer()}); | gen.writeDSCComment(DSCConstants.CREATOR, new String[] {getUserAgent().getProducer()}); | ||||
gen.writeDSCComment(DSCConstants.CREATION_DATE, new Object[] {new java.util.Date()}); | gen.writeDSCComment(DSCConstants.CREATION_DATE, new Object[] {new java.util.Date()}); | ||||
gen.writeDSCComment(DSCConstants.LANGUAGE_LEVEL, new Integer(gen.getPSLevel())); | |||||
gen.writeDSCComment(DSCConstants.LANGUAGE_LEVEL, gen.getPSLevel()); | |||||
gen.writeDSCComment(DSCConstants.PAGES, new Object[] {DSCConstants.ATEND}); | gen.writeDSCComment(DSCConstants.PAGES, new Object[] {DSCConstants.ATEND}); | ||||
gen.writeDSCComment(DSCConstants.BBOX, DSCConstants.ATEND); | gen.writeDSCComment(DSCConstants.BBOX, DSCConstants.ATEND); | ||||
gen.writeDSCComment(DSCConstants.HIRES_BBOX, DSCConstants.ATEND); | gen.writeDSCComment(DSCConstants.HIRES_BBOX, DSCConstants.ATEND); | ||||
//Write trailer | //Write trailer | ||||
gen.writeDSCComment(DSCConstants.TRAILER); | gen.writeDSCComment(DSCConstants.TRAILER); | ||||
writeExtensions(COMMENT_DOCUMENT_TRAILER); | writeExtensions(COMMENT_DOCUMENT_TRAILER); | ||||
gen.writeDSCComment(DSCConstants.PAGES, new Integer(this.currentPageNumber)); | |||||
gen.writeDSCComment(DSCConstants.PAGES, this.currentPageNumber); | |||||
new DSCCommentBoundingBox(this.documentBoundingBox).generate(gen); | new DSCCommentBoundingBox(this.documentBoundingBox).generate(gen); | ||||
new DSCCommentHiResBoundingBox(this.documentBoundingBox).generate(gen); | new DSCCommentHiResBoundingBox(this.documentBoundingBox).generate(gen); | ||||
gen.getResourceTracker().writeResources(false, gen); | gen.getResourceTracker().writeResources(false, gen); | ||||
gen.getResourceTracker().notifyResourceUsageOnPage(PSProcSets.STD_PROCSET); | gen.getResourceTracker().notifyResourceUsageOnPage(PSProcSets.STD_PROCSET); | ||||
gen.writeDSCComment(DSCConstants.PAGE, new Object[] | gen.writeDSCComment(DSCConstants.PAGE, new Object[] | ||||
{name, | {name, | ||||
new Integer(this.currentPageNumber)}); | |||||
Integer.valueOf(this.currentPageNumber)}); | |||||
double pageWidth = size.width / 1000.0; | double pageWidth = size.width / 1000.0; | ||||
double pageHeight = size.height / 1000.0; | double pageHeight = size.height / 1000.0; | ||||
List pageSizes = new java.util.ArrayList(); | List pageSizes = new java.util.ArrayList(); | ||||
if (this.psUtil.isAutoRotateLandscape() && (pageHeight < pageWidth)) { | if (this.psUtil.isAutoRotateLandscape() && (pageHeight < pageWidth)) { | ||||
rotate = true; | rotate = true; | ||||
pageSizes.add(new Long(Math.round(pageHeight))); | |||||
pageSizes.add(new Long(Math.round(pageWidth))); | |||||
pageSizes.add(Math.round(pageHeight)); | |||||
pageSizes.add(Math.round(pageWidth)); | |||||
} else { | } else { | ||||
pageSizes.add(new Long(Math.round(pageWidth))); | |||||
pageSizes.add(new Long(Math.round(pageHeight))); | |||||
pageSizes.add(Math.round(pageWidth)); | |||||
pageSizes.add(Math.round(pageHeight)); | |||||
} | } | ||||
pageDeviceDictionary.put("/PageSize", pageSizes); | pageDeviceDictionary.put("/PageSize", pageSizes); | ||||
this.currentPageDefinition = new PageDefinition( | this.currentPageDefinition = new PageDefinition( | ||||
} | } | ||||
}*/ | }*/ | ||||
final Integer zero = new Integer(0); | |||||
final Integer zero = 0; | |||||
Rectangle2D pageBoundingBox = new Rectangle2D.Double(); | Rectangle2D pageBoundingBox = new Rectangle2D.Double(); | ||||
if (rotate) { | if (rotate) { | ||||
pageBoundingBox.setRect(0, 0, pageHeight, pageWidth); | pageBoundingBox.setRect(0, 0, pageHeight, pageWidth); | ||||
gen.writeDSCComment(DSCConstants.PAGE_BBOX, new Object[] { | gen.writeDSCComment(DSCConstants.PAGE_BBOX, new Object[] { | ||||
zero, zero, new Long(Math.round(pageHeight)), | |||||
new Long(Math.round(pageWidth)) }); | |||||
zero, zero, Long.valueOf(Math.round(pageHeight)), | |||||
Long.valueOf(Math.round(pageWidth)) }); | |||||
gen.writeDSCComment(DSCConstants.PAGE_HIRES_BBOX, new Object[] { | gen.writeDSCComment(DSCConstants.PAGE_HIRES_BBOX, new Object[] { | ||||
zero, zero, new Double(pageHeight), | |||||
new Double(pageWidth) }); | |||||
zero, zero, Double.valueOf(pageHeight), | |||||
Double.valueOf(pageWidth) }); | |||||
gen.writeDSCComment(DSCConstants.PAGE_ORIENTATION, "Landscape"); | gen.writeDSCComment(DSCConstants.PAGE_ORIENTATION, "Landscape"); | ||||
} else { | } else { | ||||
pageBoundingBox.setRect(0, 0, pageWidth, pageHeight); | pageBoundingBox.setRect(0, 0, pageWidth, pageHeight); | ||||
gen.writeDSCComment(DSCConstants.PAGE_BBOX, new Object[] { | gen.writeDSCComment(DSCConstants.PAGE_BBOX, new Object[] { | ||||
zero, zero, new Long(Math.round(pageWidth)), | |||||
new Long(Math.round(pageHeight)) }); | |||||
zero, zero, Long.valueOf(Math.round(pageWidth)), | |||||
Long.valueOf(Math.round(pageHeight)) }); | |||||
gen.writeDSCComment(DSCConstants.PAGE_HIRES_BBOX, new Object[] { | gen.writeDSCComment(DSCConstants.PAGE_HIRES_BBOX, new Object[] { | ||||
zero, zero, new Double(pageWidth), | |||||
new Double(pageHeight) }); | |||||
zero, zero, Double.valueOf(pageWidth), | |||||
Double.valueOf(pageHeight) }); | |||||
if (psUtil.isAutoRotateLandscape()) { | if (psUtil.isAutoRotateLandscape()) { | ||||
gen.writeDSCComment(DSCConstants.PAGE_ORIENTATION, | gen.writeDSCComment(DSCConstants.PAGE_ORIENTATION, | ||||
"Portrait"); | "Portrait"); |
/** conversion factors keyed by xsl:fo units names */ | /** conversion factors keyed by xsl:fo units names */ | ||||
private static final Map TWIP_FACTORS = new HashMap(); | private static final Map TWIP_FACTORS = new HashMap(); | ||||
static { | static { | ||||
TWIP_FACTORS.put(FixedLength.MM, new Float(MM_TO_TWIPS)); | |||||
TWIP_FACTORS.put(FixedLength.CM, new Float(CM_TO_TWIPS)); | |||||
TWIP_FACTORS.put(FixedLength.POINT, new Float(POINT_TO_TWIPS)); | |||||
TWIP_FACTORS.put(FixedLength.INCH, new Float(IN_TO_TWIPS)); | |||||
TWIP_FACTORS.put(FixedLength.MM, MM_TO_TWIPS); | |||||
TWIP_FACTORS.put(FixedLength.CM, CM_TO_TWIPS); | |||||
TWIP_FACTORS.put(FixedLength.POINT, POINT_TO_TWIPS); | |||||
TWIP_FACTORS.put(FixedLength.INCH, IN_TO_TWIPS); | |||||
} | } | ||||
/** singleton pattern */ | /** singleton pattern */ |
percentManager.setDimension(tc, iWidth); | percentManager.setDimension(tc, iWidth); | ||||
//convert to twips | //convert to twips | ||||
Float width = new Float(FoUnitsConverter.getInstance().convertMptToTwips(iWidth)); | |||||
Float width = FoUnitsConverter.getInstance().convertMptToTwips(iWidth); | |||||
builderContext.getTableContext().setNextColumnWidth(width); | builderContext.getTableContext().setNextColumnWidth(width); | ||||
builderContext.getTableContext().setNextColumnRowSpanning( | builderContext.getTableContext().setNextColumnRowSpanning( | ||||
new Integer(0), null); | |||||
0, null); | |||||
builderContext.getTableContext().setNextFirstSpanningCol(false); | builderContext.getTableContext().setNextFirstSpanningCol(false); | ||||
} catch (Exception e) { | } catch (Exception e) { | ||||
log.error("startColumn: " + e.getMessage()); | log.error("startColumn: " + e.getMessage()); | ||||
cell.setVMerge(RtfTableCell.MERGE_START); | cell.setVMerge(RtfTableCell.MERGE_START); | ||||
// set the number of rows spanned | // set the number of rows spanned | ||||
tctx.setCurrentColumnRowSpanning(new Integer(numberRowsSpanned), | |||||
tctx.setCurrentColumnRowSpanning(numberRowsSpanned, | |||||
cell.getRtfAttributes()); | cell.getRtfAttributes()); | ||||
} else { | } else { | ||||
tctx.setCurrentColumnRowSpanning( | tctx.setCurrentColumnRowSpanning( | ||||
new Integer(numberRowsSpanned), null); | |||||
numberRowsSpanned, null); | |||||
} | } | ||||
//process number-columns-spanned attribute | //process number-columns-spanned attribute | ||||
// set the number of rows spanned | // set the number of rows spanned | ||||
tctx.setCurrentColumnRowSpanning( | tctx.setCurrentColumnRowSpanning( | ||||
new Integer(numberRowsSpanned), | |||||
numberRowsSpanned, | |||||
cell.getRtfAttributes()); | cell.getRtfAttributes()); | ||||
} else { | } else { | ||||
tctx.setCurrentColumnRowSpanning( | tctx.setCurrentColumnRowSpanning( | ||||
new Integer(numberRowsSpanned), cell.getRtfAttributes()); | |||||
numberRowsSpanned, cell.getRtfAttributes()); | |||||
} | } | ||||
} | } | ||||
} | } |
* @return this (which now contains the new entry), for chaining calls | * @return this (which now contains the new entry), for chaining calls | ||||
*/ | */ | ||||
public RtfAttributes set(String name, int value) { | public RtfAttributes set(String name, int value) { | ||||
values.put(name, new Integer(value)); | |||||
values.put(name, value); | |||||
return this; | return this; | ||||
} | } | ||||
/** define a named color for getColorNumber(String) */ | /** define a named color for getColorNumber(String) */ | ||||
private void addNamedColor(String name, int colorNumber) { | private void addNamedColor(String name, int colorNumber) { | ||||
namedColors.put(name.toLowerCase(), new Integer(colorNumber)); | |||||
namedColors.put(name.toLowerCase(), colorNumber); | |||||
} | } | ||||
////////////////////////////////////////////////// | ////////////////////////////////////////////////// | ||||
* @return The number of the color in the table | * @return The number of the color in the table | ||||
*/ | */ | ||||
public Integer getColorNumber(int red, int green, int blue) { | public Integer getColorNumber(int red, int green, int blue) { | ||||
Integer identifier = new Integer(determineIdentifier(red, green, blue)); | |||||
Integer identifier = determineIdentifier(red, green, blue); | |||||
Object o = colorIndex.get(identifier); | Object o = colorIndex.get(identifier); | ||||
int retVal; | int retVal; | ||||
retVal = ((Integer) o).intValue() + 1; | retVal = ((Integer) o).intValue() + 1; | ||||
} | } | ||||
return new Integer(retVal); | |||||
return retVal; | |||||
} | } | ||||
/** | /** | ||||
* @param i Identifier of color | * @param i Identifier of color | ||||
*/ | */ | ||||
private void addColor(Integer i) { | private void addColor(Integer i) { | ||||
colorIndex.put(i, new Integer(colorTable.size())); | |||||
colorIndex.put(i, colorTable.size()); | |||||
colorTable.addElement(i); | colorTable.addElement(i); | ||||
} | } | ||||
} | } | ||||
if (this.cropValues[0] != 0) { | if (this.cropValues[0] != 0) { | ||||
writeOneAttribute("piccropl", new Integer(this.cropValues[0])); | |||||
writeOneAttribute("piccropl", this.cropValues[0]); | |||||
} | } | ||||
if (this.cropValues[1] != 0) { | if (this.cropValues[1] != 0) { | ||||
writeOneAttribute("piccropt", new Integer(this.cropValues[1])); | |||||
writeOneAttribute("piccropt", this.cropValues[1]); | |||||
} | } | ||||
if (this.cropValues[2] != 0) { | if (this.cropValues[2] != 0) { | ||||
writeOneAttribute("piccropr", new Integer(this.cropValues[2])); | |||||
writeOneAttribute("piccropr", this.cropValues[2]); | |||||
} | } | ||||
if (this.cropValues[3] != 0) { | if (this.cropValues[3] != 0) { | ||||
writeOneAttribute("piccropb", new Integer(this.cropValues[3])); | |||||
writeOneAttribute("piccropb", this.cropValues[3]); | |||||
} | } | ||||
} | } | ||||
if (listTable != null) { | if (listTable != null) { | ||||
return listTable; | return listTable; | ||||
} else { | } else { | ||||
listTable = new RtfListTable(this, writer, new Integer(listNum), attr); | |||||
listTable = new RtfListTable(this, writer, listNum, attr); | |||||
listTableContainer.addChild(listTable); | listTableContainer.addChild(listTable); | ||||
} | } | ||||
* @param family Identifier of font | * @param family Identifier of font | ||||
*/ | */ | ||||
private void addFont(String family) { | private void addFont(String family) { | ||||
fontIndex.put(getFontKey(family), new Integer(fontTable.size())); | |||||
fontIndex.put(getFontKey(family), fontTable.size()); | |||||
fontTable.addElement(family); | fontTable.addElement(family); | ||||
} | } | ||||
} | } |
super(parent, w, attr); | super(parent, w, attr); | ||||
//random number generator for ids | //random number generator for ids | ||||
listId = new Integer(listIdGenerator.nextInt()); | |||||
listTemplateId = new Integer(listIdGenerator.nextInt()); | |||||
listId = listIdGenerator.nextInt(); | |||||
listTemplateId = listIdGenerator.nextInt(); | |||||
//create a new list table entry for the list | //create a new list table entry for the list | ||||
listTable = getRtfFile().startListTable(attr); | listTable = getRtfFile().startListTable(attr); |
getRtfListStyle().writeListPrefix(this); | getRtfListStyle().writeListPrefix(this); | ||||
writeGroupMark(false); | writeGroupMark(false); | ||||
writeOneAttribute(RtfListTable.LIST_NUMBER, new Integer(number)); | |||||
writeOneAttribute(RtfListTable.LIST_NUMBER, number); | |||||
} | } | ||||
/** | /** |
// bulleted list | // bulleted list | ||||
item.writeControlWord("pnlvlblt"); | item.writeControlWord("pnlvlblt"); | ||||
item.writeControlWord("ilvl0"); | item.writeControlWord("ilvl0"); | ||||
item.writeOneAttribute(RtfListTable.LIST_NUMBER, new Integer(item.getNumber())); | |||||
item.writeOneAttribute(RtfListTable.LIST_NUMBER, item.getNumber()); | |||||
item.writeOneAttribute("pnindent", | item.writeOneAttribute("pnindent", | ||||
item.getParentList().attrib.getValue(RtfListTable.LIST_INDENT)); | item.getParentList().attrib.getValue(RtfListTable.LIST_INDENT)); | ||||
item.writeControlWord("pnf1"); | item.writeControlWord("pnf1"); |
item.writeControlWord("ilvl0"); | item.writeControlWord("ilvl0"); | ||||
item.writeOneAttribute(RtfListTable.LIST_NUMBER, "0"); | item.writeOneAttribute(RtfListTable.LIST_NUMBER, "0"); | ||||
item.writeControlWord("pndec"); | item.writeControlWord("pndec"); | ||||
item.writeOneAttribute("pnstart", new Integer(1)); | |||||
item.writeOneAttribute("pnstart", 1); | |||||
item.writeOneAttribute("pnindent", | item.writeOneAttribute("pnindent", | ||||
item.attrib.getValue(RtfListTable.LIST_INDENT)); | item.attrib.getValue(RtfListTable.LIST_INDENT)); | ||||
item.writeControlWord("pntxta."); | item.writeControlWord("pntxta."); | ||||
public void writeLevelGroup(RtfElement element) | public void writeLevelGroup(RtfElement element) | ||||
throws IOException { | throws IOException { | ||||
element.writeOneAttributeNS( | element.writeOneAttributeNS( | ||||
RtfListTable.LIST_START_AT, new Integer(1)); | |||||
RtfListTable.LIST_START_AT, 1); | |||||
element.attrib.set(RtfListTable.LIST_NUMBER_TYPE, 0); | element.attrib.set(RtfListTable.LIST_NUMBER_TYPE, 0); | ||||
element.writeGroupMark(true); | element.writeGroupMark(true); | ||||
RtfListTable.LIST_NUM_POSITION, "\\'01;"); | RtfListTable.LIST_NUM_POSITION, "\\'01;"); | ||||
element.writeGroupMark(false); | element.writeGroupMark(false); | ||||
element.writeOneAttribute(RtfListTable.LIST_FONT_TYPE, new Integer(0)); | |||||
element.writeOneAttribute(RtfListTable.LIST_FONT_TYPE, 0); | |||||
} | } | ||||
} | } |
// bulleted list | // bulleted list | ||||
item.writeControlWord("pnlvlblt"); | item.writeControlWord("pnlvlblt"); | ||||
item.writeControlWord("ilvl0"); | item.writeControlWord("ilvl0"); | ||||
item.writeOneAttribute(RtfListTable.LIST_NUMBER, new Integer(item.getNumber())); | |||||
item.writeOneAttribute(RtfListTable.LIST_NUMBER, item.getNumber()); | |||||
item.writeOneAttribute("pnindent", | item.writeOneAttribute("pnindent", | ||||
item.getParentList().attrib.getValue(RtfListTable.LIST_INDENT)); | item.getParentList().attrib.getValue(RtfListTable.LIST_INDENT)); | ||||
item.writeControlWord("pnf1"); | item.writeControlWord("pnf1"); |
writeGroupMark(true); | writeGroupMark(true); | ||||
writeOneAttributeNS(LIST_ID, style.getRtfList().getListId().toString()); | writeOneAttributeNS(LIST_ID, style.getRtfList().getListId().toString()); | ||||
writeOneAttributeNS(LIST_OVR_COUNT, new Integer(0)); | |||||
writeOneAttributeNS(LIST_NUMBER, new Integer(z++)); | |||||
writeOneAttributeNS(LIST_OVR_COUNT, 0); | |||||
writeOneAttributeNS(LIST_NUMBER, z++); | |||||
writeGroupMark(false); | writeGroupMark(false); | ||||
writeGroupMark(false); | writeGroupMark(false); | ||||
writeOneAttributeNS(LIST_JUSTIFICATION, attrib.getValue(LIST_JUSTIFICATION)); | writeOneAttributeNS(LIST_JUSTIFICATION, attrib.getValue(LIST_JUSTIFICATION)); | ||||
writeOneAttributeNS(LIST_FOLLOWING_CHAR, attrib.getValue(LIST_FOLLOWING_CHAR)); | writeOneAttributeNS(LIST_FOLLOWING_CHAR, attrib.getValue(LIST_FOLLOWING_CHAR)); | ||||
writeOneAttributeNS(LIST_SPACE, new Integer(0)); | |||||
writeOneAttributeNS(LIST_SPACE, 0); | |||||
writeOneAttributeNS(LIST_INDENT, attrib.getValue(LIST_INDENT)); | writeOneAttributeNS(LIST_INDENT, attrib.getValue(LIST_INDENT)); | ||||
RtfListItem item = (RtfListItem)list.getChildren().get(0); | RtfListItem item = (RtfListItem)list.getChildren().get(0); |
public int split(String key) { | public int split(String key) { | ||||
Integer i = (Integer) commonAttributes.getValue(key); | Integer i = (Integer) commonAttributes.getValue(key); | ||||
if (i == null) { | if (i == null) { | ||||
i = new Integer(0); | |||||
i = 0; | |||||
} | } | ||||
commonAttributes.unset(key); | commonAttributes.unset(key); |
private static final RtfStringConverter INSTANCE = new RtfStringConverter(); | private static final RtfStringConverter INSTANCE = new RtfStringConverter(); | ||||
private static final Map SPECIAL_CHARS; | private static final Map SPECIAL_CHARS; | ||||
private static final Character DBLQUOTE = new Character('\"'); | |||||
private static final Character QUOTE = new Character('\''); | |||||
private static final Character SPACE = new Character(' '); | |||||
private static final Character DBLQUOTE = '\"'; | |||||
private static final Character QUOTE = '\''; | |||||
private static final Character SPACE = ' '; | |||||
/** List of characters to escape with corresponding replacement strings */ | /** List of characters to escape with corresponding replacement strings */ | ||||
static { | static { | ||||
SPECIAL_CHARS = new HashMap(); | SPECIAL_CHARS = new HashMap(); | ||||
SPECIAL_CHARS.put(new Character('\t'), "tab"); | |||||
SPECIAL_CHARS.put(new Character('\n'), "line"); | |||||
SPECIAL_CHARS.put(new Character('\''), "rquote"); | |||||
SPECIAL_CHARS.put(new Character('\"'), "rdblquote"); | |||||
SPECIAL_CHARS.put(new Character('\\'), "\\"); | |||||
SPECIAL_CHARS.put(new Character('{'), "{"); | |||||
SPECIAL_CHARS.put(new Character('}'), "}"); | |||||
SPECIAL_CHARS.put('\t', "tab"); | |||||
SPECIAL_CHARS.put('\n', "line"); | |||||
SPECIAL_CHARS.put('\'', "rquote"); | |||||
SPECIAL_CHARS.put('\"', "rdblquote"); | |||||
SPECIAL_CHARS.put('\\', "\\"); | |||||
SPECIAL_CHARS.put('{', "{"); | |||||
SPECIAL_CHARS.put('}', "}"); | |||||
} | } | ||||
/** singleton pattern */ | /** singleton pattern */ | ||||
StringBuffer sb = new StringBuffer(Math.max(16, str.length())); | StringBuffer sb = new StringBuffer(Math.max(16, str.length())); | ||||
// TODO: could be made more efficient (binary lookup, etc.) | // TODO: could be made more efficient (binary lookup, etc.) | ||||
for (int i = 0; i < str.length(); i++) { | for (int i = 0; i < str.length(); i++) { | ||||
final Character c = new Character(str.charAt(i)); | |||||
final Character c = str.charAt(i); | |||||
Character d; | Character d; | ||||
String replacement; | String replacement; | ||||
if (i != 0) { | if (i != 0) { | ||||
d = new Character(str.charAt(i - 1)); | |||||
d = str.charAt(i - 1); | |||||
} else { | } else { | ||||
d = new Character(SPACE); | |||||
d = SPACE; | |||||
} | } | ||||
//This section modified by Chris Scott | //This section modified by Chris Scott |
if (attrs != null) { | if (attrs != null) { | ||||
attrTable.put(name, attrs); | attrTable.put(name, attrs); | ||||
} | } | ||||
styles.put(name, new Integer(nameTable.size() - 1 + startIndex)); | |||||
styles.put(name, nameTable.size() - 1 + startIndex); | |||||
} | } | ||||
/** | /** |
ListIterator lit = children.listIterator(children.size()); | ListIterator lit = children.listIterator(children.size()); | ||||
while (lit.hasPrevious() | while (lit.hasPrevious() | ||||
&& (lit.previous() instanceof RtfCloseGroupMark)) { | && (lit.previous() instanceof RtfCloseGroupMark)) { | ||||
tmp.push(Integer.valueOf(((RtfCloseGroupMark)lit.next()).getBreakType())); | |||||
tmp.push(((RtfCloseGroupMark) lit.next()).getBreakType()); | |||||
lit.remove(); | lit.remove(); | ||||
deletedCloseGroupCount++; | deletedCloseGroupCount++; | ||||
} | } |
baseWidthSet = true; | baseWidthSet = true; | ||||
} | } | ||||
// width in mpt | // width in mpt | ||||
lengthMap.put(fobj, new Integer(width)); | |||||
lengthMap.put(fobj, width); | |||||
} | } | ||||
/** | /** | ||||
* @param tableUnit the table unit value (in millipoints) | * @param tableUnit the table unit value (in millipoints) | ||||
*/ | */ | ||||
public void setTableUnit(Table table, int tableUnit) { | public void setTableUnit(Table table, int tableUnit) { | ||||
tableUnitMap.put(table, new Integer(tableUnit)); | |||||
tableUnitMap.put(table, tableUnit); | |||||
} | } | ||||
/** | /** | ||||
private Integer findParent(FONode fobj) { | private Integer findParent(FONode fobj) { | ||||
if (fobj.getRoot() != fobj) { | if (fobj.getRoot() != fobj) { | ||||
if (lengthMap.containsKey(fobj)) { | if (lengthMap.containsKey(fobj)) { | ||||
return new Integer(lengthMap.get(fobj).toString()); | |||||
return Integer.valueOf(lengthMap.get(fobj).toString()); | |||||
} else { | } else { | ||||
return findParent(fobj.getParent()); | return findParent(fobj.getParent()); | ||||
} | } | ||||
} else { | } else { | ||||
log.error("Base Value for element " + fobj.getName() + " not found"); | log.error("Base Value for element " + fobj.getName() + " not found"); | ||||
return new Integer(-1); | |||||
return -1; | |||||
} | } | ||||
} | } | ||||
while (colIndex >= colFirstSpanningCol.size()) { | while (colIndex >= colFirstSpanningCol.size()) { | ||||
setNextFirstSpanningCol(false); | setNextFirstSpanningCol(false); | ||||
} | } | ||||
colFirstSpanningCol.set(colIndex, Boolean.valueOf(bFirstSpanningCol)); | |||||
colFirstSpanningCol.set(colIndex, bFirstSpanningCol); | |||||
} else { | } else { | ||||
colFirstSpanningCol.add(Boolean.valueOf(bFirstSpanningCol)); | |||||
colFirstSpanningCol.add(bFirstSpanningCol); | |||||
} | } | ||||
} | } | ||||
*/ | */ | ||||
public void setNextFirstSpanningCol( | public void setNextFirstSpanningCol( | ||||
boolean bFirstSpanningCol) { | boolean bFirstSpanningCol) { | ||||
colFirstSpanningCol.add(Boolean.valueOf(bFirstSpanningCol)); | |||||
colFirstSpanningCol.add(bFirstSpanningCol); | |||||
} | } | ||||
/** | /** | ||||
Integer i = (Integer)colRowSpanningNumber.get(z); | Integer i = (Integer)colRowSpanningNumber.get(z); | ||||
if (i.intValue() > 0) { | if (i.intValue() > 0) { | ||||
i = new Integer(i.intValue() - 1); | |||||
i = i.intValue() - 1; | |||||
} | } | ||||
colRowSpanningNumber.set(z, i); | colRowSpanningNumber.set(z, i); | ||||
if (i.intValue() == 0) { | if (i.intValue() == 0) { | ||||
colRowSpanningAttrs.set(z, null); | colRowSpanningAttrs.set(z, null); | ||||
colFirstSpanningCol.set(z, Boolean.valueOf(false)); | |||||
colFirstSpanningCol.set(z, false); | |||||
} | } | ||||
} | } | ||||
} | } | ||||
log.warn("Column width for column " + (colIndex + 1) + " is not defined, using " | log.warn("Column width for column " + (colIndex + 1) + " is not defined, using " | ||||
+ INVALID_COLUMN_WIDTH); | + INVALID_COLUMN_WIDTH); | ||||
while (colIndex >= getNumberOfColumns()) { | while (colIndex >= getNumberOfColumns()) { | ||||
setNextColumnWidth(new Float(INVALID_COLUMN_WIDTH)); | |||||
setNextColumnWidth(INVALID_COLUMN_WIDTH); | |||||
} | } | ||||
} | } | ||||
return ((Float)colWidths.get(colIndex)).floatValue(); | return ((Float)colWidths.get(colIndex)).floatValue(); |
public Character getCharacter(int x, int y) { | public Character getCharacter(int x, int y) { | ||||
Character c = null; | Character c = null; | ||||
if (borderInfo[y][x] != null) { | if (borderInfo[y][x] != null) { | ||||
c = new Character(borderInfo[y][x].convert2Char()); | |||||
c = borderInfo[y][x].convert2Char(); | |||||
} | } | ||||
return c; | return c; | ||||
} | } |
// } | // } | ||||
List<Double> bbox = new java.util.ArrayList<Double>(); | List<Double> bbox = new java.util.ArrayList<Double>(); | ||||
bbox.add(new Double(rect.getX())); | |||||
bbox.add(new Double(rect.getHeight() + rect.getY())); | |||||
bbox.add(new Double(rect.getWidth() + rect.getX())); | |||||
bbox.add(new Double(rect.getY())); | |||||
bbox.add(rect.getX()); | |||||
bbox.add(rect.getHeight() + rect.getY()); | |||||
bbox.add(rect.getWidth() + rect.getX()); | |||||
bbox.add(rect.getY()); | |||||
AffineTransform transform; | AffineTransform transform; | ||||
transform = new AffineTransform(getBaseTransform()); | transform = new AffineTransform(getBaseTransform()); | ||||
double [] mat = new double[6]; | double [] mat = new double[6]; | ||||
transform.getMatrix(mat); | transform.getMatrix(mat); | ||||
for (int idx = 0; idx < mat.length; idx++) { | for (int idx = 0; idx < mat.length; idx++) { | ||||
theMatrix.add(new Double(mat[idx])); | |||||
theMatrix.add(mat[idx]); | |||||
} | } | ||||
/** @todo see if pdfDoc and res can be linked here, | /** @todo see if pdfDoc and res can be linked here, | ||||
} | } | ||||
if (kerningAvailable && (i + 1) < l) { | if (kerningAvailable && (i + 1) < l) { | ||||
addKerning(currentStream, (Integer.valueOf(ch)), | |||||
(Integer.valueOf(fontState.mapChar(s.charAt(i + 1)))), | |||||
addKerning(currentStream, ((int) ch), | |||||
((int) fontState.mapChar(s.charAt(i + 1))), | |||||
kerning, startText, endText); | kerning, startText, endText); | ||||
} | } | ||||
if (profile == null) { | if (profile == null) { | ||||
Map<String, Float> vals = new java.util.HashMap<String, Float>(); | Map<String, Float> vals = new java.util.HashMap<String, Float>(); | ||||
if (fillAlpha != OPAQUE) { | if (fillAlpha != OPAQUE) { | ||||
vals.put(PDFGState.GSTATE_ALPHA_NONSTROKE, new Float(fillAlpha / 255f)); | |||||
vals.put(PDFGState.GSTATE_ALPHA_NONSTROKE, fillAlpha / 255f); | |||||
} | } | ||||
if (strokeAlpha != OPAQUE) { | if (strokeAlpha != OPAQUE) { | ||||
vals.put(PDFGState.GSTATE_ALPHA_STROKE, new Float(strokeAlpha / 255f)); | |||||
vals.put(PDFGState.GSTATE_ALPHA_STROKE, strokeAlpha / 255f); | |||||
} | } | ||||
PDFGState gstate = pdfDoc.getFactory().makeGState(vals, paintingState.getGState()); | PDFGState gstate = pdfDoc.getFactory().makeGState(vals, paintingState.getGState()); | ||||
resourceContext.addGState(gstate); | resourceContext.addGState(gstate); |
currRunLevel = nextRunLevel; | currRunLevel = nextRunLevel; | ||||
} else if (nextRunLevel != currRunLevel) { | } else if (nextRunLevel != currRunLevel) { | ||||
as.addAttribute(GVTAttributedCharacterIterator.TextAttribute.BIDI_LEVEL, | as.addAttribute(GVTAttributedCharacterIterator.TextAttribute.BIDI_LEVEL, | ||||
new Integer(currRunLevel), runStart, i); | |||||
currRunLevel, runStart, i); | |||||
runStart = i; | runStart = i; | ||||
runEnd = runStart; | runEnd = runStart; | ||||
currRunLevel = nextRunLevel; | currRunLevel = nextRunLevel; | ||||
} | } | ||||
if ((currRunLevel >= 0) && (end > runStart)) { | if ((currRunLevel >= 0) && (end > runStart)) { | ||||
as.addAttribute(GVTAttributedCharacterIterator.TextAttribute.BIDI_LEVEL, | as.addAttribute(GVTAttributedCharacterIterator.TextAttribute.BIDI_LEVEL, | ||||
new Integer(currRunLevel), runStart, end); | |||||
currRunLevel, runStart, end); | |||||
} | } | ||||
return as.getIterator(); | return as.getIterator(); | ||||
} else { | } else { |
FopFactory fopFactory = FopFactory.newInstance(baseUri); | FopFactory fopFactory = FopFactory.newInstance(baseUri); | ||||
FOUserAgent userAgent = fopFactory.newFOUserAgent(); | FOUserAgent userAgent = fopFactory.newFOUserAgent(); | ||||
userAgent.getRendererOptions().put("fineDetail", Boolean.valueOf(false)); | |||||
userAgent.getRendererOptions().put("consistentOutput", Boolean.valueOf(true)); | |||||
userAgent.getRendererOptions().put("fineDetail", false); | |||||
userAgent.getRendererOptions().put("consistentOutput", true); | |||||
userAgent.setProducer("Testsuite Converter"); | userAgent.setProducer("Testsuite Converter"); | ||||
String outname = res; | String outname = res; | ||||
File f1 = new File(destdir, outname + ".at.xml"); | File f1 = new File(destdir, outname + ".at.xml"); | ||||
File f2 = new File(compare, outname + ".at.xml"); | File f2 = new File(compare, outname + ".at.xml"); | ||||
if (!compareFiles(f1, f2)) { | if (!compareFiles(f1, f2)) { | ||||
differ.put(outname + ".at.xml", Boolean.valueOf(pass)); | |||||
differ.put(outname + ".at.xml", pass); | |||||
} | } | ||||
} | } | ||||
} catch (Exception e) { | } catch (Exception e) { |
if (s == null) { | if (s == null) { | ||||
return null; | return null; | ||||
} else { | } else { | ||||
return new Integer(s); | |||||
return Integer.valueOf(s); | |||||
} | } | ||||
} | } | ||||
} | } | ||||
public int mapCharToGlyph(int c) { | public int mapCharToGlyph(int c) { | ||||
if (cmap != null) { | if (cmap != null) { | ||||
Integer g = cmap.get(Integer.valueOf(c)); | |||||
Integer g = cmap.get(c); | |||||
if (g != null) { | if (g != null) { | ||||
return (int) g; | return (int) g; | ||||
} else { | } else { | ||||
missingRequiredAttribute(en, "glyph"); | missingRequiredAttribute(en, "glyph"); | ||||
} | } | ||||
int gid = mapGlyphId(glyph, en); | int gid = mapGlyphId(glyph, en); | ||||
alternates.add(Integer.valueOf(gid)); | |||||
alternates.add(gid); | |||||
} else { | } else { | ||||
notPermittedInElementContext(en, getParent(), pn); | notPermittedInElementContext(en, getParent(), pn); | ||||
} | } | ||||
missingRequiredAttribute(en, "glyph"); | missingRequiredAttribute(en, "glyph"); | ||||
} | } | ||||
int gid = mapGlyphId(glyph, en); | int gid = mapGlyphId(glyph, en); | ||||
coverageEntries.add(Integer.valueOf(gid)); | |||||
coverageEntries.add(gid); | |||||
} else { | } else { | ||||
notPermittedInElementContext(en, getParent(), pn); | notPermittedInElementContext(en, getParent(), pn); | ||||
} | } | ||||
missingRequiredAttribute(en, "value"); | missingRequiredAttribute(en, "value"); | ||||
} else { | } else { | ||||
int gid = mapGlyphId(value, en); | int gid = mapGlyphId(value, en); | ||||
coverageEntries.add(Integer.valueOf(gid)); | |||||
coverageEntries.add(gid); | |||||
} | } | ||||
} else { | } else { | ||||
notPermittedInElementContext(en, getParent(), pnx); | notPermittedInElementContext(en, getParent(), pnx); | ||||
missingRequiredAttribute(en, "glyph"); | missingRequiredAttribute(en, "glyph"); | ||||
} | } | ||||
int gid = mapGlyphId(glyph, en); | int gid = mapGlyphId(glyph, en); | ||||
coverageEntries.add(Integer.valueOf(gid)); | |||||
coverageEntries.add(gid); | |||||
} else { | } else { | ||||
notPermittedInElementContext(en, getParent(), pn); | notPermittedInElementContext(en, getParent(), pn); | ||||
} | } | ||||
missingRequiredAttribute(en, "value"); | missingRequiredAttribute(en, "value"); | ||||
} else { | } else { | ||||
int gid = mapGlyphId(value, en); | int gid = mapGlyphId(value, en); | ||||
substitutes.add(Integer.valueOf(gid)); | |||||
substitutes.add(gid); | |||||
} | } | ||||
} else { | } else { | ||||
notPermittedInElementContext(en, getParent(), pn); | notPermittedInElementContext(en, getParent(), pn); | ||||
} else { | } else { | ||||
ogid = mapGlyphId(out, en); | ogid = mapGlyphId(out, en); | ||||
} | } | ||||
coverageEntries.add(Integer.valueOf(igid)); | |||||
subtableEntries.add(Integer.valueOf(ogid)); | |||||
coverageEntries.add(igid); | |||||
subtableEntries.add(ogid); | |||||
} else { | } else { | ||||
notPermittedInElementContext(en, getParent(), pn); | notPermittedInElementContext(en, getParent(), pn); | ||||
} | } | ||||
private Map<Integer, Integer> getCMAP() { | private Map<Integer, Integer> getCMAP() { | ||||
Map<Integer, Integer> cmap = new TreeMap(); | Map<Integer, Integer> cmap = new TreeMap(); | ||||
for (int[] cme : cmapEntries) { | for (int[] cme : cmapEntries) { | ||||
Integer c = Integer.valueOf(cme[0]); | |||||
Integer g = Integer.valueOf(cme[1]); | |||||
Integer c = cme[0]; | |||||
Integer g = cme[1]; | |||||
cmap.put(c, g); | cmap.put(c, g); | ||||
} | } | ||||
return cmap; | return cmap; | ||||
private Map<Integer, Integer> getGMAP() { | private Map<Integer, Integer> getGMAP() { | ||||
Map<Integer, Integer> gmap = new TreeMap(); | Map<Integer, Integer> gmap = new TreeMap(); | ||||
for (int[] cme : cmapEntries) { | for (int[] cme : cmapEntries) { | ||||
Integer c = Integer.valueOf(cme[0]); | |||||
Integer g = Integer.valueOf(cme[1]); | |||||
Integer c = cme[0]; | |||||
Integer g = cme[1]; | |||||
gmap.put(g, c); | gmap.put(g, c); | ||||
} | } | ||||
return gmap; | return gmap; | ||||
List entries = new ArrayList<Integer>(); | List entries = new ArrayList<Integer>(); | ||||
int s = -1; | int s = -1; | ||||
int l = -1; | int l = -1; | ||||
Integer zero = Integer.valueOf(0); | |||||
Integer zero = 0; | |||||
for (int[] m : cma) { | for (int[] m : cma) { | ||||
int g = m[0]; | int g = m[0]; | ||||
int c = m[1]; | int c = m[1]; | ||||
if (s < 0) { | if (s < 0) { | ||||
s = g; | s = g; | ||||
l = g - 1; | l = g - 1; | ||||
entries.add(Integer.valueOf(s)); | |||||
entries.add(s); | |||||
} | } | ||||
while (g > (l + 1)) { | while (g > (l + 1)) { | ||||
entries.add(zero); | entries.add(zero); | ||||
l++; | l++; | ||||
} | } | ||||
assert l == (g - 1); | assert l == (g - 1); | ||||
entries.add(Integer.valueOf(c)); | |||||
entries.add(c); | |||||
l = g; | l = g; | ||||
} | } | ||||
return GlyphClassTable.createClassTable(entries); | return GlyphClassTable.createClassTable(entries); | ||||
} | } | ||||
} | } | ||||
} | } | ||||
return Integer.valueOf(ncMax); | |||||
return ncMax; | |||||
} | } | ||||
private Anchor[][] extractComponents() { | private Anchor[][] extractComponents() { | ||||
Anchor[][] cam = new Anchor [ components.size() ][]; | Anchor[][] cam = new Anchor [ components.size() ][]; | ||||
} | } | ||||
} | } | ||||
} | } | ||||
return Integer.valueOf(ncMax); | |||||
return ncMax; | |||||
} | } | ||||
private Integer computeLigaturesComponentCount(Anchor[][][] lam) { | private Integer computeLigaturesComponentCount(Anchor[][][] lam) { | ||||
int nxMax = 0; | int nxMax = 0; | ||||
} | } | ||||
} | } | ||||
} | } | ||||
return Integer.valueOf(nxMax); | |||||
return nxMax; | |||||
} | } | ||||
private Anchor[] extractAttachmentAnchors() { | private Anchor[] extractAttachmentAnchors() { | ||||
int na = attachmentAnchors.size(); | int na = attachmentAnchors.size(); |
*/ | */ | ||||
public class CollapsedConditionalBorderTestCase extends AbstractTableTest { | public class CollapsedConditionalBorderTestCase extends AbstractTableTest { | ||||
private final Integer border0pt = new Integer(0); | |||||
private final Integer border0pt = 0; | |||||
private final Integer border4pt = new Integer(4000); | |||||
private final Integer border4pt = 4000; | |||||
private final Integer border6pt = new Integer(6000); | |||||
private final Integer border6pt = 6000; | |||||
private final Integer border8pt = new Integer(8000); | |||||
private final Integer border8pt = 8000; | |||||
/** | /** | ||||
* Resolved borders for tables without headers and footers, generated from the Python | * Resolved borders for tables without headers and footers, generated from the Python |
continue; | continue; | ||||
} | } | ||||
bs.set(j); | bs.set(j); | ||||
glyphs.put(Integer.valueOf(j), Integer.valueOf(j)); | |||||
glyphs.put(j, j); | |||||
chars[i] = (char) j; | chars[i] = (char) j; | ||||
widths[i] = 100; | widths[i] = 100; | ||||
i++; | i++; |
if (b0 == 28) { | if (b0 == 28) { | ||||
int b1 = input[curPos + 1] & 0xff; | int b1 = input[curPos + 1] & 0xff; | ||||
int b2 = input[curPos + 2] & 0xff; | int b2 = input[curPos + 2] & 0xff; | ||||
return new BytesNumber(Integer.valueOf((short) (b1 << 8 | b2)), 3); | |||||
return new BytesNumber((int) (short) (b1 << 8 | b2), 3); | |||||
} else if (b0 >= 32 && b0 <= 246) { | } else if (b0 >= 32 && b0 <= 246) { | ||||
return new BytesNumber(Integer.valueOf(b0 - 139), 1); | |||||
return new BytesNumber(b0 - 139, 1); | |||||
} else if (b0 >= 247 && b0 <= 250) { | } else if (b0 >= 247 && b0 <= 250) { | ||||
int b1 = input[curPos + 1] & 0xff; | int b1 = input[curPos + 1] & 0xff; | ||||
return new BytesNumber(Integer.valueOf((b0 - 247) * 256 + b1 + 108), 2); | |||||
return new BytesNumber((b0 - 247) * 256 + b1 + 108, 2); | |||||
} else if (b0 >= 251 && b0 <= 254) { | } else if (b0 >= 251 && b0 <= 254) { | ||||
int b1 = input[curPos + 1] & 0xff; | int b1 = input[curPos + 1] & 0xff; | ||||
return new BytesNumber(Integer.valueOf(-(b0 - 251) * 256 - b1 - 108), 2); | |||||
return new BytesNumber(-(b0 - 251) * 256 - b1 - 108, 2); | |||||
} else if (b0 == 255) { | } else if (b0 == 255) { | ||||
int b1 = input[curPos + 1] & 0xff; | int b1 = input[curPos + 1] & 0xff; | ||||
int b2 = input[curPos + 2] & 0xff; | int b2 = input[curPos + 2] & 0xff; | ||||
int b3 = input[curPos + 3] & 0xff; | int b3 = input[curPos + 3] & 0xff; | ||||
int b4 = input[curPos + 4] & 0xff; | int b4 = input[curPos + 4] & 0xff; | ||||
return new BytesNumber(Integer.valueOf((b1 << 24 | b2 << 16 | b3 << 8 | b4)), 5); | |||||
return new BytesNumber((b1 << 24 | b2 << 16 | b3 << 8 | b4), 5); | |||||
} else { | } else { | ||||
throw new IllegalArgumentException(); | throw new IllegalArgumentException(); | ||||
} | } |
if (ansiKerning.isEmpty()) { | if (ansiKerning.isEmpty()) { | ||||
fail(); | fail(); | ||||
} | } | ||||
Integer k1 = ansiKerning.get(Integer.valueOf('A')).get( | |||||
Integer.valueOf('T')); | |||||
Integer k1 = ansiKerning.get((int) 'A').get( | |||||
(int) 'T'); | |||||
assertEquals(dejavuTTFFile.convertTTFUnit2PDFUnit(-112), k1.intValue()); | assertEquals(dejavuTTFFile.convertTTFUnit2PDFUnit(-112), k1.intValue()); | ||||
Integer k2 = ansiKerning.get(Integer.valueOf('Y')).get(Integer.valueOf('u')); | |||||
Integer k2 = ansiKerning.get((int) 'Y').get((int) 'u'); | |||||
assertEquals(dejavuTTFFile.convertTTFUnit2PDFUnit(-178), k2.intValue()); | assertEquals(dejavuTTFFile.convertTTFUnit2PDFUnit(-178), k2.intValue()); | ||||
// DroidSansMono doens't have kerning (it's mono-spaced) | // DroidSansMono doens't have kerning (it's mono-spaced) | ||||
if (kerning.isEmpty()) { | if (kerning.isEmpty()) { | ||||
fail(); | fail(); | ||||
} | } | ||||
Integer k1 = kerning.get(Integer.valueOf('A')).get(Integer.valueOf('T')); | |||||
Integer k1 = kerning.get((int) 'A').get((int) 'T'); | |||||
assertEquals(dejavuTTFFile.convertTTFUnit2PDFUnit(-112), k1.intValue()); | assertEquals(dejavuTTFFile.convertTTFUnit2PDFUnit(-112), k1.intValue()); | ||||
Integer k2 = kerning.get(Integer.valueOf('K')).get(Integer.valueOf('u')); | |||||
Integer k2 = kerning.get((int) 'K').get((int) 'u'); | |||||
assertEquals(dejavuTTFFile.convertTTFUnit2PDFUnit(-45), k2.intValue()); | assertEquals(dejavuTTFFile.convertTTFUnit2PDFUnit(-45), k2.intValue()); | ||||
// DroidSansMono has no kerning data (mono-spaced) | // DroidSansMono has no kerning data (mono-spaced) |
Source src = new StreamSource(foFile); | Source src = new StreamSource(foFile); | ||||
Transformer transformer = replicatorTemplates.newTransformer(); | Transformer transformer = replicatorTemplates.newTransformer(); | ||||
transformer.setParameter("repeats", new Integer(replicatorRepeats)); | |||||
transformer.setParameter("repeats", replicatorRepeats); | |||||
OutputStream out = new NullOutputStream(); //write to /dev/nul | OutputStream out = new NullOutputStream(); //write to /dev/nul | ||||
try { | try { |
*/ | */ | ||||
@Test | @Test | ||||
public void testAdd() { | public void testAdd() { | ||||
intArray.add(new Integer(6)); | |||||
intArray.add(Integer.valueOf(6)); | |||||
doubleArray.add(6.6); | doubleArray.add(6.6); | ||||
// Test some arbitrary values | // Test some arbitrary values | ||||
for (int i = 1; i <= 6; i++) { | for (int i = 1; i <= 6; i++) { |
pdfDictUnderTest.setDocument(doc); | pdfDictUnderTest.setDocument(doc); | ||||
pdfDictUnderTest.put("String", "TestValue"); | pdfDictUnderTest.put("String", "TestValue"); | ||||
pdfDictUnderTest.put("int", 10); | pdfDictUnderTest.put("int", 10); | ||||
pdfDictUnderTest.put("double", Double.valueOf(3.1)); | |||||
pdfDictUnderTest.put("double", 3.1); | |||||
pdfDictUnderTest.put("array", testArray); | pdfDictUnderTest.put("array", testArray); | ||||
pdfDictUnderTest.put("number", testNumber); | pdfDictUnderTest.put("number", testNumber); | ||||
// null is a valid PDF object | // null is a valid PDF object |
assertFalse(number.equals(MinOptMax.getInstance(1, 4, 5))); | assertFalse(number.equals(MinOptMax.getInstance(1, 4, 5))); | ||||
assertFalse(number.equals(MinOptMax.getInstance(1, 3, 4))); | assertFalse(number.equals(MinOptMax.getInstance(1, 3, 4))); | ||||
assertFalse(number.equals(null)); | assertFalse(number.equals(null)); | ||||
assertFalse(number.equals(new Integer(1))); | |||||
assertFalse(number.equals(1)); | |||||
} | } | ||||
@Test | @Test |
Map params = new java.util.HashMap(); | Map params = new java.util.HashMap(); | ||||
params.put("amount", new Integer(0)); | |||||
params.put("amount", 0); | |||||
msg = format.format(params); | msg = format.format(params); | ||||
assertEquals("You have nothing.", msg); | assertEquals("You have nothing.", msg); | ||||
params.put("amount", new Integer(7)); | |||||
params.put("amount", 7); | |||||
msg = format.format(params); | msg = format.format(params); | ||||
assertEquals("You have 7 bucks.", msg); | assertEquals("You have 7 bucks.", msg); | ||||
params.put("amount", new Integer(140)); | |||||
params.put("amount", 140); | |||||
msg = format.format(params); | msg = format.format(params); | ||||
assertEquals("You have more than enough.", msg); | assertEquals("You have more than enough.", msg); | ||||
Event ev = new Event(this, "123", EventSeverity.INFO, | Event ev = new Event(this, "123", EventSeverity.INFO, | ||||
Event.paramsBuilder() | Event.paramsBuilder() | ||||
.param("reason", "I'm tired") | .param("reason", "I'm tired") | ||||
.param("blah", new Integer(23)) | |||||
.param("blah", Integer.valueOf(23)) | |||||
.build()); | .build()); | ||||
broadcaster.broadcastEvent(ev); | broadcaster.broadcastEvent(ev); | ||||
assertEquals("123", listener.event.getEventID()); | assertEquals("123", listener.event.getEventID()); | ||||
assertEquals(EventSeverity.INFO, listener.event.getSeverity()); | assertEquals(EventSeverity.INFO, listener.event.getSeverity()); | ||||
assertEquals("I'm tired", ev.getParam("reason")); | assertEquals("I'm tired", ev.getParam("reason")); | ||||
assertEquals(new Integer(23), ev.getParam("blah")); | |||||
assertEquals(Integer.valueOf(23), ev.getParam("blah")); | |||||
broadcaster.removeEventListener(listener); | broadcaster.removeEventListener(listener); | ||||
assertFalse(broadcaster.hasEventListeners()); | assertFalse(broadcaster.hasEventListeners()); | ||||
listener.event.getEventID()); | listener.event.getEventID()); | ||||
assertEquals(EventSeverity.WARN, listener.event.getSeverity()); | assertEquals(EventSeverity.WARN, listener.event.getSeverity()); | ||||
assertEquals("I'm tired", ev.getParam("reason")); | assertEquals("I'm tired", ev.getParam("reason")); | ||||
assertEquals(new Integer(23), ev.getParam("blah")); | |||||
assertEquals(Integer.valueOf(23), ev.getParam("blah")); | |||||
broadcaster.removeEventListener(listener); | broadcaster.removeEventListener(listener); | ||||
assertFalse(broadcaster.hasEventListeners()); | assertFalse(broadcaster.hasEventListeners()); |
Node n = new Node(nodeIndex); | Node n = new Node(nodeIndex); | ||||
ns.string.append(n.toNodeString()); | ns.string.append(n.toNodeString()); | ||||
if (n.high != 0) { | if (n.high != 0) { | ||||
ns.high.add(new Integer(pos)); | |||||
ns.high.add(Integer.valueOf(pos)); | |||||
NodeString highNs = new NodeString(pos); | NodeString highNs = new NodeString(pos); | ||||
highNs.low.add(new Integer(pos)); | |||||
highNs.low.add(Integer.valueOf(pos)); | |||||
int index = strings.indexOf(ns); | int index = strings.indexOf(ns); | ||||
strings.add(index, highNs); | strings.add(index, highNs); | ||||
addNode(n.high, strings, highNs); | addNode(n.high, strings, highNs); | ||||
} | } | ||||
if (n.low != 0) { | if (n.low != 0) { | ||||
ns.low.add(new Integer(pos)); | |||||
ns.low.add(Integer.valueOf(pos)); | |||||
NodeString lowNs = new NodeString(pos); | NodeString lowNs = new NodeString(pos); | ||||
lowNs.high.add(new Integer(pos)); | |||||
lowNs.high.add(Integer.valueOf(pos)); | |||||
int index = strings.indexOf(ns); | int index = strings.indexOf(ns); | ||||
strings.add(index + 1, lowNs); | strings.add(index + 1, lowNs); | ||||
addNode(n.low, strings, lowNs); | addNode(n.low, strings, lowNs); |