diff options
Diffstat (limited to 'src/scratchpad')
| -rw-r--r-- | src/scratchpad/src/org/apache/poi/hslf/record/StyleTextPropAtom.java | 725 |
1 files changed, 362 insertions, 363 deletions
diff --git a/src/scratchpad/src/org/apache/poi/hslf/record/StyleTextPropAtom.java b/src/scratchpad/src/org/apache/poi/hslf/record/StyleTextPropAtom.java index bbbd72fbf6..a877da1f24 100644 --- a/src/scratchpad/src/org/apache/poi/hslf/record/StyleTextPropAtom.java +++ b/src/scratchpad/src/org/apache/poi/hslf/record/StyleTextPropAtom.java @@ -50,330 +50,329 @@ import org.apache.poi.util.POILogger; public final class StyleTextPropAtom extends RecordAtom { - private byte[] _header; - private static long _type = 4001l; - private byte[] reserved; - - private byte[] rawContents; // Holds the contents between write-outs - - /** - * Only set to true once setParentTextSize(int) is called. - * Until then, no stylings will have been decoded - */ - private boolean initialised = false; - - /** - * The list of all the different paragraph stylings we code for. - * Each entry is a TextPropCollection, which tells you how many - * Characters the paragraph covers, and also contains the TextProps - * that actually define the styling of the paragraph. - */ - private LinkedList<TextPropCollection> paragraphStyles; - public LinkedList<TextPropCollection> getParagraphStyles() { return paragraphStyles; } - /** - * Updates the link list of TextPropCollections which make up the - * paragraph stylings - */ - public void setParagraphStyles(LinkedList<TextPropCollection> ps) { paragraphStyles = ps; } - /** - * The list of all the different character stylings we code for. - * Each entry is a TextPropCollection, which tells you how many - * Characters the character styling covers, and also contains the - * TextProps that actually define the styling of the characters. - */ - private LinkedList<TextPropCollection> charStyles; - public LinkedList<TextPropCollection> getCharacterStyles() { return charStyles; } - /** - * Updates the link list of TextPropCollections which make up the - * character stylings - */ - public void setCharacterStyles(LinkedList<TextPropCollection> cs) { charStyles = cs; } - - /** - * Returns how many characters the paragraph's - * TextPropCollections cover. - * (May be one or two more than the underlying text does, - * due to having extra characters meaning something - * special to powerpoint) - */ - public int getParagraphTextLengthCovered() { - return getCharactersCovered(paragraphStyles); - } - /** - * Returns how many characters the character's - * TextPropCollections cover. - * (May be one or two more than the underlying text does, - * due to having extra characters meaning something - * special to powerpoint) - */ - public int getCharacterTextLengthCovered() { - return getCharactersCovered(charStyles); - } - private int getCharactersCovered(LinkedList<TextPropCollection> styles) { - int length = 0; - for(TextPropCollection tpc : styles) { - length += tpc.getCharactersCovered(); - } - return length; - } - - /** All the different kinds of paragraph properties we might handle */ - public static TextProp[] paragraphTextPropTypes = new TextProp[] { - new TextProp(0, 0x1, "hasBullet"), - new TextProp(0, 0x2, "hasBulletFont"), - new TextProp(0, 0x4, "hasBulletColor"), - new TextProp(0, 0x8, "hasBulletSize"), - new ParagraphFlagsTextProp(), - new TextProp(2, 0x80, "bullet.char"), - new TextProp(2, 0x10, "bullet.font"), - new TextProp(2, 0x40, "bullet.size"), - new TextProp(4, 0x20, "bullet.color"), - new AlignmentTextProp(), - new TextProp(2, 0x100, "text.offset"), - new TextProp(2, 0x400, "bullet.offset"), - new TextProp(2, 0x1000, "linespacing"), - new TextProp(2, 0x2000, "spacebefore"), - new TextProp(2, 0x4000, "spaceafter"), - new TextProp(2, 0x8000, "defaultTabSize"), - new TextProp(2, 0x100000, "tabStops"), - new TextProp(2, 0x10000, "fontAlign"), - new TextProp(2, 0xA0000, "wrapFlags"), - new TextProp(2, 0x200000, "textDirection") - }; - /** All the different kinds of character properties we might handle */ - public static TextProp[] characterTextPropTypes = new TextProp[] { - new TextProp(0, 0x1, "bold"), - new TextProp(0, 0x2, "italic"), - new TextProp(0, 0x4, "underline"), - new TextProp(0, 0x8, "unused1"), - new TextProp(0, 0x10, "shadow"), - new TextProp(0, 0x20, "fehint"), - new TextProp(0, 0x40, "unused2"), - new TextProp(0, 0x80, "kumi"), - new TextProp(0, 0x100, "unused3"), - new TextProp(0, 0x200, "emboss"), - new TextProp(0, 0x400, "nibble1"), - new TextProp(0, 0x800, "nibble2"), - new TextProp(0, 0x1000, "nibble3"), - new TextProp(0, 0x2000, "nibble4"), - new TextProp(0, 0x4000, "unused4"), - new TextProp(0, 0x8000, "unused5"), - new CharFlagsTextProp(), - new TextProp(2, 0x10000, "font.index"), - new TextProp(0, 0x100000, "pp10ext"), - new TextProp(2, 0x200000, "asian.font.index"), - new TextProp(2, 0x400000, "ansi.font.index"), - new TextProp(2, 0x800000, "symbol.font.index"), - new TextProp(2, 0x20000, "font.size"), - new TextProp(4, 0x40000, "font.color"), - new TextProp(2, 0x80000, "superscript"), + private byte[] _header; + private static long _type = 4001l; + private byte[] reserved; + private byte[] rawContents; // Holds the contents between write-outs + + /** + * Only set to true once setParentTextSize(int) is called. + * Until then, no stylings will have been decoded + */ + private boolean initialised = false; + + /** + * The list of all the different paragraph stylings we code for. + * Each entry is a TextPropCollection, which tells you how many + * Characters the paragraph covers, and also contains the TextProps + * that actually define the styling of the paragraph. + */ + private LinkedList<TextPropCollection> paragraphStyles; + public LinkedList<TextPropCollection> getParagraphStyles() { return paragraphStyles; } + /** + * Updates the link list of TextPropCollections which make up the + * paragraph stylings + */ + public void setParagraphStyles(LinkedList<TextPropCollection> ps) { paragraphStyles = ps; } + /** + * The list of all the different character stylings we code for. + * Each entry is a TextPropCollection, which tells you how many + * Characters the character styling covers, and also contains the + * TextProps that actually define the styling of the characters. + */ + private LinkedList<TextPropCollection> charStyles; + public LinkedList<TextPropCollection> getCharacterStyles() { return charStyles; } + /** + * Updates the link list of TextPropCollections which make up the + * character stylings + */ + public void setCharacterStyles(LinkedList<TextPropCollection> cs) { charStyles = cs; } + + /** + * Returns how many characters the paragraph's + * TextPropCollections cover. + * (May be one or two more than the underlying text does, + * due to having extra characters meaning something + * special to powerpoint) + */ + public int getParagraphTextLengthCovered() { + return getCharactersCovered(paragraphStyles); + } + /** + * Returns how many characters the character's + * TextPropCollections cover. + * (May be one or two more than the underlying text does, + * due to having extra characters meaning something + * special to powerpoint) + */ + public int getCharacterTextLengthCovered() { + return getCharactersCovered(charStyles); + } + private int getCharactersCovered(LinkedList<TextPropCollection> styles) { + int length = 0; + for(TextPropCollection tpc : styles) { + length += tpc.getCharactersCovered(); + } + return length; + } + + /** All the different kinds of paragraph properties we might handle */ + public static TextProp[] paragraphTextPropTypes = new TextProp[] { + new TextProp(0, 0x1, "hasBullet"), + new TextProp(0, 0x2, "hasBulletFont"), + new TextProp(0, 0x4, "hasBulletColor"), + new TextProp(0, 0x8, "hasBulletSize"), + new ParagraphFlagsTextProp(), + new TextProp(2, 0x80, "bullet.char"), + new TextProp(2, 0x10, "bullet.font"), + new TextProp(2, 0x40, "bullet.size"), + new TextProp(4, 0x20, "bullet.color"), + new AlignmentTextProp(), + new TextProp(2, 0x100, "text.offset"), + new TextProp(2, 0x400, "bullet.offset"), + new TextProp(2, 0x1000, "linespacing"), + new TextProp(2, 0x2000, "spacebefore"), + new TextProp(2, 0x4000, "spaceafter"), + new TextProp(2, 0x8000, "defaultTabSize"), + new TextProp(2, 0x100000, "tabStops"), + new TextProp(2, 0x10000, "fontAlign"), + new TextProp(2, 0xA0000, "wrapFlags"), + new TextProp(2, 0x200000, "textDirection") }; + /** All the different kinds of character properties we might handle */ + public static TextProp[] characterTextPropTypes = new TextProp[] { + new TextProp(0, 0x1, "bold"), + new TextProp(0, 0x2, "italic"), + new TextProp(0, 0x4, "underline"), + new TextProp(0, 0x8, "unused1"), + new TextProp(0, 0x10, "shadow"), + new TextProp(0, 0x20, "fehint"), + new TextProp(0, 0x40, "unused2"), + new TextProp(0, 0x80, "kumi"), + new TextProp(0, 0x100, "unused3"), + new TextProp(0, 0x200, "emboss"), + new TextProp(0, 0x400, "nibble1"), + new TextProp(0, 0x800, "nibble2"), + new TextProp(0, 0x1000, "nibble3"), + new TextProp(0, 0x2000, "nibble4"), + new TextProp(0, 0x4000, "unused4"), + new TextProp(0, 0x8000, "unused5"), + new CharFlagsTextProp(), + new TextProp(2, 0x10000, "font.index"), + new TextProp(0, 0x100000, "pp10ext"), + new TextProp(2, 0x200000, "asian.font.index"), + new TextProp(2, 0x400000, "ansi.font.index"), + new TextProp(2, 0x800000, "symbol.font.index"), + new TextProp(2, 0x20000, "font.size"), + new TextProp(4, 0x40000, "font.color"), + new TextProp(2, 0x80000, "superscript") + }; + + /* *************** record code follows ********************** */ + + /** + * For the Text Style Properties (StyleTextProp) Atom + */ + public StyleTextPropAtom(byte[] source, int start, int len) { + // Sanity Checking - we're always at least 8+10 bytes long + if(len < 18) { + len = 18; + if(source.length - start < 18) { + throw new RuntimeException("Not enough data to form a StyleTextPropAtom (min size 18 bytes long) - found " + (source.length - start)); + } + } + + // Get the header + _header = new byte[8]; + System.arraycopy(source,start,_header,0,8); + + // Save the contents of the atom, until we're asked to go and + // decode them (via a call to setParentTextSize(int) + rawContents = new byte[len-8]; + System.arraycopy(source,start+8,rawContents,0,rawContents.length); + reserved = new byte[0]; + + // Set empty linked lists, ready for when they call setParentTextSize + paragraphStyles = new LinkedList<TextPropCollection>(); + charStyles = new LinkedList<TextPropCollection>(); + } + + + /** + * A new set of text style properties for some text without any. + */ + public StyleTextPropAtom(int parentTextSize) { + _header = new byte[8]; + rawContents = new byte[0]; + reserved = new byte[0]; + + // Set our type + LittleEndian.putInt(_header,2,(short)_type); + // Our initial size is 10 + LittleEndian.putInt(_header,4,10); + + // Set empty paragraph and character styles + paragraphStyles = new LinkedList<TextPropCollection>(); + charStyles = new LinkedList<TextPropCollection>(); + + TextPropCollection defaultParagraphTextProps = + new TextPropCollection(parentTextSize, (short)0); + paragraphStyles.add(defaultParagraphTextProps); + + TextPropCollection defaultCharacterTextProps = + new TextPropCollection(parentTextSize); + charStyles.add(defaultCharacterTextProps); - /* *************** record code follows ********************** */ - - /** - * For the Text Style Properties (StyleTextProp) Atom - */ - public StyleTextPropAtom(byte[] source, int start, int len) { - // Sanity Checking - we're always at least 8+10 bytes long - if(len < 18) { - len = 18; - if(source.length - start < 18) { - throw new RuntimeException("Not enough data to form a StyleTextPropAtom (min size 18 bytes long) - found " + (source.length - start)); - } - } - - // Get the header - _header = new byte[8]; - System.arraycopy(source,start,_header,0,8); - - // Save the contents of the atom, until we're asked to go and - // decode them (via a call to setParentTextSize(int) - rawContents = new byte[len-8]; - System.arraycopy(source,start+8,rawContents,0,rawContents.length); - reserved = new byte[0]; - - // Set empty linked lists, ready for when they call setParentTextSize - paragraphStyles = new LinkedList<TextPropCollection>(); - charStyles = new LinkedList<TextPropCollection>(); - } - - - /** - * A new set of text style properties for some text without any. - */ - public StyleTextPropAtom(int parentTextSize) { - _header = new byte[8]; - rawContents = new byte[0]; - reserved = new byte[0]; - - // Set our type - LittleEndian.putInt(_header,2,(short)_type); - // Our initial size is 10 - LittleEndian.putInt(_header,4,10); - - // Set empty paragraph and character styles - paragraphStyles = new LinkedList<TextPropCollection>(); - charStyles = new LinkedList<TextPropCollection>(); - - TextPropCollection defaultParagraphTextProps = - new TextPropCollection(parentTextSize, (short)0); - paragraphStyles.add(defaultParagraphTextProps); - - TextPropCollection defaultCharacterTextProps = - new TextPropCollection(parentTextSize); - charStyles.add(defaultCharacterTextProps); - - // Set us as now initialised - initialised = true; - } - - - /** - * We are of type 4001 - */ - public long getRecordType() { return _type; } - - - /** - * Write the contents of the record back, so it can be written - * to disk - */ - public void writeOut(OutputStream out) throws IOException { - // First thing to do is update the raw bytes of the contents, based - // on the properties - updateRawContents(); - - // Now ensure that the header size is correct - int newSize = rawContents.length + reserved.length; - LittleEndian.putInt(_header,4,newSize); - - // Write out the (new) header - out.write(_header); - - // Write out the styles - out.write(rawContents); - - // Write out any extra bits - out.write(reserved); - } - - - /** - * Tell us how much text the parent TextCharsAtom or TextBytesAtom - * contains, so we can go ahead and initialise ourselves. - */ - public void setParentTextSize(int size) { - int pos = 0; - int textHandled = 0; - - // While we have text in need of paragraph stylings, go ahead and - // grok the contents as paragraph formatting data + // Set us as now initialised + initialised = true; + } + + + /** + * We are of type 4001 + */ + public long getRecordType() { return _type; } + + + /** + * Write the contents of the record back, so it can be written + * to disk + */ + public void writeOut(OutputStream out) throws IOException { + // First thing to do is update the raw bytes of the contents, based + // on the properties + updateRawContents(); + + // Now ensure that the header size is correct + int newSize = rawContents.length + reserved.length; + LittleEndian.putInt(_header,4,newSize); + + // Write out the (new) header + out.write(_header); + + // Write out the styles + out.write(rawContents); + + // Write out any extra bits + out.write(reserved); + } + + + /** + * Tell us how much text the parent TextCharsAtom or TextBytesAtom + * contains, so we can go ahead and initialise ourselves. + */ + public void setParentTextSize(int size) { + int pos = 0; + int textHandled = 0; + + // While we have text in need of paragraph stylings, go ahead and + // grok the contents as paragraph formatting data int prsize = size; - while(pos < rawContents.length && textHandled < prsize) { - // First up, fetch the number of characters this applies to - int textLen = LittleEndian.getInt(rawContents,pos); - textHandled += textLen; - pos += 4; + while(pos < rawContents.length && textHandled < prsize) { + // First up, fetch the number of characters this applies to + int textLen = LittleEndian.getInt(rawContents,pos); + textHandled += textLen; + pos += 4; - short indent = LittleEndian.getShort(rawContents,pos); - pos += 2; + short indent = LittleEndian.getShort(rawContents,pos); + pos += 2; - // Grab the 4 byte value that tells us what properties follow - int paraFlags = LittleEndian.getInt(rawContents,pos); - pos += 4; + // Grab the 4 byte value that tells us what properties follow + int paraFlags = LittleEndian.getInt(rawContents,pos); + pos += 4; - // Now make sense of those properties - TextPropCollection thisCollection = new TextPropCollection(textLen, indent); - int plSize = thisCollection.buildTextPropList( - paraFlags, paragraphTextPropTypes, rawContents, pos); - pos += plSize; + // Now make sense of those properties + TextPropCollection thisCollection = new TextPropCollection(textLen, indent); + int plSize = thisCollection.buildTextPropList( + paraFlags, paragraphTextPropTypes, rawContents, pos); + pos += plSize; - // Save this properties set - paragraphStyles.add(thisCollection); + // Save this properties set + paragraphStyles.add(thisCollection); // Handle extra 1 paragraph styles at the end if(pos < rawContents.length && textHandled == size) { prsize++; } - } + } if (rawContents.length > 0 && textHandled != (size+1)){ logger.log(POILogger.WARN, "Problem reading paragraph style runs: textHandled = " + textHandled + ", text.size+1 = " + (size+1)); } - // Now do the character stylings - textHandled = 0; + // Now do the character stylings + textHandled = 0; int chsize = size; - while(pos < rawContents.length && textHandled < chsize) { - // First up, fetch the number of characters this applies to - int textLen = LittleEndian.getInt(rawContents,pos); - textHandled += textLen; - pos += 4; - - // There is no 2 byte value - short no_val = -1; - - // Grab the 4 byte value that tells us what properties follow - int charFlags = LittleEndian.getInt(rawContents,pos); - pos += 4; - - // Now make sense of those properties - // (Assuming we actually have some) - TextPropCollection thisCollection = new TextPropCollection(textLen, no_val); - int chSize = thisCollection.buildTextPropList( - charFlags, characterTextPropTypes, rawContents, pos); - pos += chSize; - - // Save this properties set - charStyles.add(thisCollection); - - // Handle extra 1 char styles at the end - if(pos < rawContents.length && textHandled == size) { - chsize++; - } - } + while(pos < rawContents.length && textHandled < chsize) { + // First up, fetch the number of characters this applies to + int textLen = LittleEndian.getInt(rawContents,pos); + textHandled += textLen; + pos += 4; + + // There is no 2 byte value + short no_val = -1; + + // Grab the 4 byte value that tells us what properties follow + int charFlags = LittleEndian.getInt(rawContents,pos); + pos += 4; + + // Now make sense of those properties + // (Assuming we actually have some) + TextPropCollection thisCollection = new TextPropCollection(textLen, no_val); + int chSize = thisCollection.buildTextPropList( + charFlags, characterTextPropTypes, rawContents, pos); + pos += chSize; + + // Save this properties set + charStyles.add(thisCollection); + + // Handle extra 1 char styles at the end + if(pos < rawContents.length && textHandled == size) { + chsize++; + } + } if (rawContents.length > 0 && textHandled != (size+1)){ logger.log(POILogger.WARN, "Problem reading character style runs: textHandled = " + textHandled + ", text.size+1 = " + (size+1)); } - // Handle anything left over - if(pos < rawContents.length) { - reserved = new byte[rawContents.length-pos]; - System.arraycopy(rawContents,pos,reserved,0,reserved.length); - } + // Handle anything left over + if(pos < rawContents.length) { + reserved = new byte[rawContents.length-pos]; + System.arraycopy(rawContents,pos,reserved,0,reserved.length); + } - initialised = true; - } + initialised = true; + } - /** - * Updates the cache of the raw contents. Serialised the styles out. - */ - private void updateRawContents() throws IOException { - if(!initialised) { - // We haven't groked the styles since creation, so just stick - // with what we found - return; - } + /** + * Updates the cache of the raw contents. Serialised the styles out. + */ + private void updateRawContents() throws IOException { + if(!initialised) { + // We haven't groked the styles since creation, so just stick + // with what we found + return; + } - ByteArrayOutputStream baos = new ByteArrayOutputStream(); + ByteArrayOutputStream baos = new ByteArrayOutputStream(); - // First up, we need to serialise the paragraph properties - for(int i=0; i<paragraphStyles.size(); i++) { - TextPropCollection tpc = paragraphStyles.get(i); - tpc.writeOut(baos); - } + // First up, we need to serialise the paragraph properties + for(int i=0; i<paragraphStyles.size(); i++) { + TextPropCollection tpc = paragraphStyles.get(i); + tpc.writeOut(baos); + } - // Now, we do the character ones - for(int i=0; i<charStyles.size(); i++) { - TextPropCollection tpc = charStyles.get(i); - tpc.writeOut(baos); - } + // Now, we do the character ones + for(int i=0; i<charStyles.size(); i++) { + TextPropCollection tpc = charStyles.get(i); + tpc.writeOut(baos); + } - rawContents = baos.toByteArray(); - } + rawContents = baos.toByteArray(); + } public void setRawContents(byte[] bytes) { rawContents = bytes; @@ -382,30 +381,30 @@ public final class StyleTextPropAtom extends RecordAtom } /** - * Create a new Paragraph TextPropCollection, and add it to the list - * @param charactersCovered The number of characters this TextPropCollection will cover - * @return the new TextPropCollection, which will then be in the list - */ - public TextPropCollection addParagraphTextPropCollection(int charactersCovered) { - TextPropCollection tpc = new TextPropCollection(charactersCovered, (short)0); - paragraphStyles.add(tpc); - return tpc; - } - /** - * Create a new Character TextPropCollection, and add it to the list - * @param charactersCovered The number of characters this TextPropCollection will cover - * @return the new TextPropCollection, which will then be in the list - */ - public TextPropCollection addCharacterTextPropCollection(int charactersCovered) { - TextPropCollection tpc = new TextPropCollection(charactersCovered); - charStyles.add(tpc); - return tpc; - } - -/* ************************************************************************ */ - - - /** + * Create a new Paragraph TextPropCollection, and add it to the list + * @param charactersCovered The number of characters this TextPropCollection will cover + * @return the new TextPropCollection, which will then be in the list + */ + public TextPropCollection addParagraphTextPropCollection(int charactersCovered) { + TextPropCollection tpc = new TextPropCollection(charactersCovered, (short)0); + paragraphStyles.add(tpc); + return tpc; + } + /** + * Create a new Character TextPropCollection, and add it to the list + * @param charactersCovered The number of characters this TextPropCollection will cover + * @return the new TextPropCollection, which will then be in the list + */ + public TextPropCollection addCharacterTextPropCollection(int charactersCovered) { + TextPropCollection tpc = new TextPropCollection(charactersCovered); + charStyles.add(tpc); + return tpc; + } + + /* ************************************************************************ */ + + + /** * Dump the record content into <code>StringBuffer</code> * * @return the string representation of the record data @@ -413,57 +412,57 @@ public final class StyleTextPropAtom extends RecordAtom public String toString(){ StringBuffer out = new StringBuffer(); - out.append("StyleTextPropAtom:\n"); + out.append("StyleTextPropAtom:\n"); if (!initialised) { - out.append("Uninitialised, dumping Raw Style Data\n"); + out.append("Uninitialised, dumping Raw Style Data\n"); } else { - out.append("Paragraph properties\n"); - - for(TextPropCollection pr : getParagraphStyles()) { - out.append(" chars covered: " + pr.getCharactersCovered()); - out.append(" special mask flags: 0x" + HexDump.toHex(pr.getSpecialMask()) + "\n"); - for(TextProp p : pr.getTextPropList()) { - out.append(" " + p.getName() + " = " + p.getValue() ); - out.append(" (0x" + HexDump.toHex(p.getValue()) + ")\n"); - } - - out.append(" para bytes that would be written: \n"); - - try { - ByteArrayOutputStream baos = new ByteArrayOutputStream(); - pr.writeOut(baos); - byte[] b = baos.toByteArray(); - out.append(HexDump.dump(b, 0, 0)); - } catch (Exception e ) { - e.printStackTrace(); - } - } - - out.append("Character properties\n"); - for(TextPropCollection pr : getCharacterStyles()) { - out.append(" chars covered: " + pr.getCharactersCovered() ); - out.append(" special mask flags: 0x" + HexDump.toHex(pr.getSpecialMask()) + "\n"); - for(TextProp p : pr.getTextPropList()) { - out.append(" " + p.getName() + " = " + p.getValue() ); - out.append(" (0x" + HexDump.toHex(p.getValue()) + ")\n"); - } - - out.append(" char bytes that would be written: \n"); - - try { - ByteArrayOutputStream baos = new ByteArrayOutputStream(); - pr.writeOut(baos); - byte[] b = baos.toByteArray(); - out.append(HexDump.dump(b, 0, 0)); - } catch (Exception e ) { - e.printStackTrace(); - } - } + out.append("Paragraph properties\n"); + + for(TextPropCollection pr : getParagraphStyles()) { + out.append(" chars covered: " + pr.getCharactersCovered()); + out.append(" special mask flags: 0x" + HexDump.toHex(pr.getSpecialMask()) + "\n"); + for(TextProp p : pr.getTextPropList()) { + out.append(" " + p.getName() + " = " + p.getValue() ); + out.append(" (0x" + HexDump.toHex(p.getValue()) + ")\n"); + } + + out.append(" para bytes that would be written: \n"); + + try { + ByteArrayOutputStream baos = new ByteArrayOutputStream(); + pr.writeOut(baos); + byte[] b = baos.toByteArray(); + out.append(HexDump.dump(b, 0, 0)); + } catch (Exception e ) { + e.printStackTrace(); + } + } + + out.append("Character properties\n"); + for(TextPropCollection pr : getCharacterStyles()) { + out.append(" chars covered: " + pr.getCharactersCovered() ); + out.append(" special mask flags: 0x" + HexDump.toHex(pr.getSpecialMask()) + "\n"); + for(TextProp p : pr.getTextPropList()) { + out.append(" " + p.getName() + " = " + p.getValue() ); + out.append(" (0x" + HexDump.toHex(p.getValue()) + ")\n"); + } + + out.append(" char bytes that would be written: \n"); + + try { + ByteArrayOutputStream baos = new ByteArrayOutputStream(); + pr.writeOut(baos); + byte[] b = baos.toByteArray(); + out.append(HexDump.dump(b, 0, 0)); + } catch (Exception e ) { + e.printStackTrace(); + } + } } out.append(" original byte stream \n"); - out.append( HexDump.dump(rawContents, 0, 0) ); + out.append( HexDump.dump(rawContents, 0, 0) ); return out.toString(); } |