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 bbbd72fbf..a877da1f2 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[] _header; + private static long _type = 4001l; + private byte[] reserved; - private byte[] rawContents; // Holds the contents between write-outs + 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; + /** + * 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 paragraphStyles; - public LinkedList getParagraphStyles() { return paragraphStyles; } - /** - * Updates the link list of TextPropCollections which make up the - * paragraph stylings - */ - public void setParagraphStyles(LinkedList 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 charStyles; - public LinkedList getCharacterStyles() { return charStyles; } - /** - * Updates the link list of TextPropCollections which make up the - * character stylings - */ - public void setCharacterStyles(LinkedList cs) { charStyles = cs; } + /** + * 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 paragraphStyles; + public LinkedList getParagraphStyles() { return paragraphStyles; } + /** + * Updates the link list of TextPropCollections which make up the + * paragraph stylings + */ + public void setParagraphStyles(LinkedList 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 charStyles; + public LinkedList getCharacterStyles() { return charStyles; } + /** + * Updates the link list of TextPropCollections which make up the + * character stylings + */ + public void setCharacterStyles(LinkedList 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 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"), + /** + * 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 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 ********************** */ + /* *************** 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)); - } - } + /** + * 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); + // 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]; + // 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(); - charStyles = new LinkedList(); - } + // Set empty linked lists, ready for when they call setParentTextSize + paragraphStyles = new LinkedList(); + charStyles = new LinkedList(); + } - /** - * 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]; + /** + * 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 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(); - charStyles = new LinkedList(); + // Set empty paragraph and character styles + paragraphStyles = new LinkedList(); + charStyles = new LinkedList(); - TextPropCollection defaultParagraphTextProps = - new TextPropCollection(parentTextSize, (short)0); - paragraphStyles.add(defaultParagraphTextProps); + TextPropCollection defaultParagraphTextProps = + new TextPropCollection(parentTextSize, (short)0); + paragraphStyles.add(defaultParagraphTextProps); - TextPropCollection defaultCharacterTextProps = - new TextPropCollection(parentTextSize); - charStyles.add(defaultCharacterTextProps); + TextPropCollection defaultCharacterTextProps = + new TextPropCollection(parentTextSize); + charStyles.add(defaultCharacterTextProps); - // Set us as now initialised - initialised = true; - } + // Set us as now initialised + initialised = true; + } - /** - * We are of type 4001 - */ - public long getRecordType() { return _type; } + /** + * 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(); + /** + * 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); + // 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 (new) header + out.write(_header); - // Write out the styles - out.write(rawContents); + // Write out the styles + out.write(rawContents); - // Write out any extra bits - out.write(reserved); - } + // 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; + /** + * 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 + // 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; + 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; + // 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; + // 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; + // 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); + // Save this properties set + charStyles.add(thisCollection); - // Handle extra 1 char styles at the end - if(pos < rawContents.length && textHandled == size) { - chsize++; - } - } + // 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; iStringBuffer * * @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"); + 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"); - } + 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"); + 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(); - } - } + 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("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"); + 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(); - } - } + 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(); }