public void TestReadWrite()
{
FileInformationBlock fib = _hWPFDocFixture._fib;
byte[] mainStream = _hWPFDocFixture._mainStream;
byte[] tableStream = _hWPFDocFixture._tableStream;
int fcMin = fib.GetFcMin();
_cHPBinTable = new CHPBinTable(mainStream, tableStream, fib.GetFcPlcfbteChpx(), fib.GetLcbPlcfbteChpx(), fcMin, fakeTPT);
HWPFFileSystem fileSys = new HWPFFileSystem();
_cHPBinTable.WriteTo(fileSys, 0);
MemoryStream tableOut = fileSys.GetStream("1Table");
MemoryStream mainOut = fileSys.GetStream("WordDocument");
byte[] newTableStream = tableOut.ToArray();
byte[] newMainStream = mainOut.ToArray();
CHPBinTable newBinTable = new CHPBinTable(newMainStream, newTableStream, 0, newTableStream.Length, 0, fakeTPT);
List<CHPX> oldTextRuns = _cHPBinTable._textRuns;
List<CHPX> newTextRuns = newBinTable._textRuns;
Assert.AreEqual(oldTextRuns.Count, newTextRuns.Count);
int size = oldTextRuns.Count;
for (int x = 0; x < size; x++)
{
PropertyNode oldNode = (PropertyNode)oldTextRuns[x];
PropertyNode newNode = (PropertyNode)newTextRuns[x];
Assert.IsTrue(oldNode.Equals(newNode));
}
}
public void TestReadWrite()
{
FileInformationBlock fib = _hWPFDocFixture._fib;
byte[] mainStream = _hWPFDocFixture._mainStream;
byte[] tableStream = _hWPFDocFixture._tableStream;
int fcMin = fib.GetFcMin();
ComplexFileTable cft = new ComplexFileTable(mainStream, tableStream, fib.GetFcClx(), fcMin);
HWPFFileSystem fileSys = new HWPFFileSystem();
cft.WriteTo(fileSys);
MemoryStream tableOut = fileSys.GetStream("1Table");
MemoryStream mainOut = fileSys.GetStream("WordDocument");
byte[] newTableStream = tableOut.ToArray();
byte[] newMainStream = mainOut.ToArray();
ComplexFileTable newCft = new ComplexFileTable(newMainStream, newTableStream, 0, 0);
TextPieceTable oldTextPieceTable = cft.GetTextPieceTable();
TextPieceTable newTextPieceTable = newCft.GetTextPieceTable();
Assert.AreEqual(oldTextPieceTable.Text.ToString(), newTextPieceTable.Text.ToString());
}
public void TestReadWrite()
{
FileInformationBlock fib = _hWPFDocFixture._fib;
byte[] tableStream = _hWPFDocFixture._tableStream;
int listOffset = fib.GetFcPlcfLst();
int lfoOffset = fib.GetFcPlfLfo();
if (listOffset != 0 && fib.GetLcbPlcfLst() != 0)
{
ListTables listTables = new ListTables(tableStream, fib.GetFcPlcfLst(),
fib.GetFcPlfLfo());
HWPFFileSystem fileSys = new HWPFFileSystem();
HWPFStream tableOut = fileSys.GetStream("1Table");
listTables.WriteListDataTo(tableOut);
int offset = tableOut.Offset;
listTables.WriteListOverridesTo(tableOut);
ListTables newTables = new ListTables(tableOut.ToArray(), 0, offset);
Assert.AreEqual(listTables, newTables);
}
}
public void TestReadWrite()
{
TextPieceTable fakeTPT = new TextPieceTable();
FileInformationBlock fib = _hWPFDocFixture._fib;
byte[] mainStream = _hWPFDocFixture._mainStream;
byte[] tableStream = _hWPFDocFixture._tableStream;
_pAPBinTable = new PAPBinTable(mainStream, tableStream, null, fib.GetFcPlcfbtePapx(), fib.GetLcbPlcfbtePapx(), fakeTPT);
HWPFFileSystem fileSys = new HWPFFileSystem();
_pAPBinTable.WriteTo(fileSys, fakeTPT);
MemoryStream tableOut = fileSys.GetStream("1Table");
MemoryStream mainOut = fileSys.GetStream("WordDocument");
byte[] newTableStream = tableOut.ToArray();
byte[] newMainStream = mainOut.ToArray();
PAPBinTable newBinTable = new PAPBinTable(newMainStream, newTableStream, null, 0, newTableStream.Length, fakeTPT);
List<PAPX> oldTextRuns = _pAPBinTable.GetParagraphs();
List<PAPX> newTextRuns = newBinTable.GetParagraphs();
Assert.AreEqual(oldTextRuns.Count, newTextRuns.Count);
int size = oldTextRuns.Count;
for (int x = 0; x < size; x++)
{
PropertyNode oldNode = (PropertyNode)oldTextRuns[x];
PropertyNode newNode = (PropertyNode)newTextRuns[x];
Assert.IsTrue(oldNode.Equals(newNode));
}
}
public void TestReadWrite()
{
FileInformationBlock fib = _hWPFDocFixture._fib;
byte[] mainStream = _hWPFDocFixture._mainStream;
byte[] tableStream = _hWPFDocFixture._tableStream;
int fcMin = fib.GetFcMin();
CPSplitCalculator cps = new CPSplitCalculator(fib);
ComplexFileTable cft = new ComplexFileTable(mainStream, tableStream, fib.GetFcClx(), fcMin);
TextPieceTable tpt = cft.GetTextPieceTable();
SectionTable sectionTable = new SectionTable(mainStream, tableStream,
fib.GetFcPlcfsed(),
fib.GetLcbPlcfsed(),
fcMin, tpt, cps);
HWPFFileSystem fileSys = new HWPFFileSystem();
sectionTable.WriteTo(fileSys, 0);
MemoryStream tableOut = fileSys.GetStream("1Table");
MemoryStream mainOut = fileSys.GetStream("WordDocument");
byte[] newTableStream = tableOut.ToArray();
byte[] newMainStream = mainOut.ToArray();
SectionTable newSectionTable = new SectionTable(
newMainStream, newTableStream, 0,
newTableStream.Length, 0, tpt, cps);
List<SEPX> oldSections = sectionTable.GetSections();
List<SEPX> newSections = newSectionTable.GetSections();
Assert.AreEqual(oldSections.Count, newSections.Count);
//test for proper char offset conversions
PlexOfCps oldSedPlex = new PlexOfCps(tableStream, fib.GetFcPlcfsed(),
fib.GetLcbPlcfsed(), 12);
PlexOfCps newSedPlex = new PlexOfCps(newTableStream, 0,
newTableStream.Length, 12);
Assert.AreEqual(oldSedPlex.Length, newSedPlex.Length);
for (int x = 0; x < oldSedPlex.Length; x++)
{
Assert.AreEqual(oldSedPlex.GetProperty(x).Start, newSedPlex.GetProperty(x).Start);
Assert.AreEqual(oldSedPlex.GetProperty(x).End, newSedPlex.GetProperty(x).End);
}
int size = oldSections.Count;
for (int x = 0; x < size; x++)
{
PropertyNode oldNode = (PropertyNode)oldSections[x];
PropertyNode newNode = (PropertyNode)newSections[x];
Assert.AreEqual(oldNode, newNode);
}
}
public void TestReadWriteFromNonZeroOffset()
{
HWPFFileSystem fileSys = new HWPFFileSystem();
HWPFStream tableOut = fileSys.GetStream("1Table");
tableOut.Write(new byte[20]); // 20 bytes of whatever at the front.
_styleSheet.WriteTo(tableOut);
byte[] newTableStream = tableOut.ToArray();
StyleSheet newStyleSheet = new StyleSheet(newTableStream, 20);
Assert.AreEqual(newStyleSheet, _styleSheet);
}
public void TestReadWrite()
{
HWPFFileSystem fileSys = new HWPFFileSystem();
HWPFStream tableOut = fileSys.GetStream("1Table");
HWPFStream mainOut = fileSys.GetStream("WordDocument");
_styleSheet.WriteTo(tableOut);
byte[] newTableStream = tableOut.ToArray();
StyleSheet newStyleSheet = new StyleSheet(newTableStream, 0);
Assert.AreEqual(newStyleSheet, _styleSheet);
}
public void TestReadWrite()
{
FileInformationBlock fib = _hWPFDocFixture._fib;
byte[] tableStream = _hWPFDocFixture._tableStream;
int fcSttbfffn = fib.GetFcSttbfffn();
int lcbSttbfffn = fib.GetLcbSttbfffn();
_fontTable = new FontTable(tableStream, fcSttbfffn, lcbSttbfffn);
HWPFFileSystem fileSys = new HWPFFileSystem();
_fontTable.WriteTo(fileSys);
HWPFStream tableOut = fileSys.GetStream("1Table");
byte[] newTableStream = tableOut.ToArray();
FontTable newFontTable = new FontTable(newTableStream, 0, newTableStream.Length);
Assert.IsTrue(_fontTable.Equals(newFontTable));
}
public void WriteTo(HWPFFileSystem sys, int fcMin)
{
HWPFStream docStream = sys.GetStream("WordDocument");
HWPFStream tableStream = sys.GetStream("1Table");
int offset = docStream.Offset;
int len = _sections.Count;
PlexOfCps plex = new PlexOfCps(SED_SIZE);
for (int x = 0; x < len; x++)
{
SEPX sepx = _sections[x];
byte[] grpprl = sepx.GetGrpprl();
// write the sepx to the document stream. starts with a 2 byte size
// followed by the grpprl
byte[] shortBuf = new byte[2];
LittleEndian.PutShort(shortBuf, (short)grpprl.Length);
docStream.Write(shortBuf);
docStream.Write(grpprl);
// set the fc in the section descriptor
SectionDescriptor sed = sepx.GetSectionDescriptor();
sed.SetFc(offset);
// add the section descriptor bytes to the PlexOfCps.
// original line -
//GenericPropertyNode property = new GenericPropertyNode(sepx.Start, sepx.End, sed.ToArray());
// Line using Ryan's FCtoCP() conversion method -
// unable to observe any effect on our testcases when using this code - piers
GenericPropertyNode property = new GenericPropertyNode(tpt.GetCharIndex(sepx.StartBytes), tpt.GetCharIndex(sepx.EndBytes), sed.ToArray());
plex.AddProperty(property);
offset = docStream.Offset;
}
tableStream.Write(plex.ToByteArray());
}
public void WriteTo(HWPFFileSystem sys)
{
HWPFStream docStream = sys.GetStream("WordDocument");
HWPFStream tableStream = sys.GetStream("1Table");
WriteTo(docStream, tableStream);
}
/**
* Writes out the word file that is represented by an instance of this class.
*
* @param out The OutputStream to write to.
* @throws IOException If there is an unexpected IOException from the passed
* in OutputStream.
*/
public override void Write(Stream out1)
{
// Initialize our streams for writing.
HWPFFileSystem docSys = new HWPFFileSystem();
HWPFStream mainStream = docSys.GetStream("WordDocument");
HWPFStream tableStream = docSys.GetStream("1Table");
//HWPFOutputStream dataStream = docSys.GetStream("Data");
int tableOffset = 0;
// FileInformationBlock fib = (FileInformationBlock)_fib.Clone();
// clear the offSets and sizes in our FileInformationBlock.
_fib.ClearOffsetsSizes();
// determine the FileInformationBLock size
int fibSize = _fib.GetSize();
fibSize += POIFSConstants.SMALLER_BIG_BLOCK_SIZE -
(fibSize % POIFSConstants.SMALLER_BIG_BLOCK_SIZE);
// preserve space for the FileInformationBlock because we will be writing
// it after we write everything else.
byte[] placeHolder = new byte[fibSize];
mainStream.Write(placeHolder);
int mainOffset = mainStream.Offset;
// write out the StyleSheet.
_fib.SetFcStshf(tableOffset);
_ss.WriteTo(tableStream);
_fib.SetLcbStshf(tableStream.Offset - tableOffset);
tableOffset = tableStream.Offset;
// get fcMin and fcMac because we will be writing the actual text with the
// complex table.
int fcMin = mainOffset;
// write out the Complex table, includes text.
_fib.SetFcClx(tableOffset);
_cft.WriteTo(mainStream, tableStream);
_fib.SetLcbClx(tableStream.Offset - tableOffset);
tableOffset = tableStream.Offset;
int fcMac = mainStream.Offset;
// write out the CHPBinTable.
_fib.SetFcPlcfbteChpx(tableOffset);
_cbt.WriteTo(docSys, fcMin);
_fib.SetLcbPlcfbteChpx(tableStream.Offset - tableOffset);
tableOffset = tableStream.Offset;
// write out the PAPBinTable.
_fib.SetFcPlcfbtePapx(tableOffset);
_pbt.WriteTo(mainStream, tableStream, _cft.GetTextPieceTable());
_fib.SetLcbPlcfbtePapx(tableStream.Offset - tableOffset);
tableOffset = tableStream.Offset;
/*
* plcfendRef (endnote reference position table) Written immediately
* after the previously recorded table if the document contains endnotes
*
* plcfendTxt (endnote text position table) Written immediately after
* the plcfendRef if the document contains endnotes
*
* Microsoft Office Word 97-2007 Binary File Format (.doc)
* Specification; Page 24 of 210
*/
_endnotesTables.WriteRef(_fib, tableStream);
_endnotesTables.WriteTxt(_fib, tableStream);
tableOffset = tableStream.Offset;
/*
* plcffndRef (footnote reference position table) Written immediately
* after the stsh if the document contains footnotes
*
* plcffndTxt (footnote text position table) Written immediately after
* the plcffndRef if the document contains footnotes
*
* Microsoft Office Word 97-2007 Binary File Format (.doc)
* Specification; Page 24 of 210
*/
_footnotesTables.WriteRef(_fib, tableStream);
_footnotesTables.WriteTxt(_fib, tableStream);
tableOffset = tableStream.Offset;
// write out the SectionTable.
_fib.SetFcPlcfsed(tableOffset);
_st.WriteTo(docSys, fcMin);
_fib.SetLcbPlcfsed(tableStream.Offset - tableOffset);
tableOffset = tableStream.Offset;
// write out the list tables
if (_lt != null)
{
_fib.SetFcPlcfLst(tableOffset);
_lt.WriteListDataTo(tableStream);
_fib.SetLcbPlcfLst(tableStream.Offset - tableOffset);
}
/*
* plflfo (more list formats) Written immediately after the end of the
* plcflst and its accompanying data, if there are any lists defined in
* the document. This consists first of a PL of LFO records, followed by
* the allocated data (if any) hanging off the LFOs. The allocated data
* consists of the array of LFOLVLFs for each LFO (and each LFOLVLF is
* immediately followed by some LVLs).
*
* Microsoft Office Word 97-2007 Binary File Format (.doc)
* Specification; Page 26 of 210
*/
if (_lt != null)
{
_fib.SetFcPlfLfo(tableStream.Offset);
_lt.WriteListOverridesTo(tableStream);
_fib.SetLcbPlfLfo(tableStream.Offset - tableOffset);
tableOffset = tableStream.Offset;
}
/*
* sttbfBkmk (table of bookmark name strings) Written immediately after
* the previously recorded table, if the document contains bookmarks.
*
* Microsoft Office Word 97-2007 Binary File Format (.doc)
* Specification; Page 27 of 210
*/
if (_bookmarksTables != null)
{
_bookmarksTables.WriteSttbfBkmk(_fib, tableStream);
tableOffset = tableStream.Offset;
}
// write out the saved-by table.
if (_sbt != null)
{
_fib.SetFcSttbSavedBy(tableOffset);
_sbt.WriteTo(tableStream);
_fib.SetLcbSttbSavedBy(tableStream.Offset - tableOffset);
tableOffset = tableStream.Offset;
}
// write out the revision mark authors table.
if (_rmat != null)
{
_fib.SetFcSttbfRMark(tableOffset);
_rmat.WriteTo(tableStream);
_fib.SetLcbSttbfRMark(tableStream.Offset - tableOffset);
tableOffset = tableStream.Offset;
}
// write out the FontTable.
_fib.SetFcSttbfffn(tableOffset);
_ft.WriteTo(docSys);
_fib.SetLcbSttbfffn(tableStream.Offset - tableOffset);
tableOffset = tableStream.Offset;
// write out the DocumentProperties.
_fib.SetFcDop(tableOffset);
byte[] buf = new byte[_dop.GetSize()];
_fib.SetLcbDop(_dop.GetSize());
_dop.Serialize(buf, 0);
tableStream.Write(buf);
// set some variables in the FileInformationBlock.
_fib.SetFcMin(fcMin);
_fib.SetFcMac(fcMac);
_fib.SetCbMac(mainStream.Offset);
// make sure that the table, doc and data streams use big blocks.
byte[] mainBuf = mainStream.ToArray();
if (mainBuf.Length < 4096)
{
byte[] tempBuf = new byte[4096];
Array.Copy(mainBuf, 0, tempBuf, 0, mainBuf.Length);
mainBuf = tempBuf;
}
// write out the FileInformationBlock.
//_fib.Serialize(mainBuf, 0);
_fib.WriteTo(mainBuf, tableStream);
byte[] tableBuf = tableStream.ToArray();
if (tableBuf.Length < 4096)
{
byte[] tempBuf = new byte[4096];
Array.Copy(tableBuf, 0, tempBuf, 0, tableBuf.Length);
tableBuf = tempBuf;
}
byte[] dataBuf = _dataStream;
if (dataBuf == null)
{
dataBuf = new byte[4096];
}
if (dataBuf.Length < 4096)
{
byte[] tempBuf = new byte[4096];
Array.Copy(dataBuf, 0, tempBuf, 0, dataBuf.Length);
dataBuf = tempBuf;
}
// spit out the Word document.
POIFSFileSystem pfs = new POIFSFileSystem();
pfs.CreateDocument(new MemoryStream(mainBuf), "WordDocument");
pfs.CreateDocument(new MemoryStream(tableBuf), "1Table");
pfs.CreateDocument(new MemoryStream(dataBuf), "Data");
WriteProperties(pfs);
pfs.WriteFileSystem(out1);
}
public void WriteTo(HWPFFileSystem sys)
{
HWPFStream tableStream = sys.GetStream("1Table");
byte[] buf = new byte[LittleEndianConsts.SHORT_SIZE];
LittleEndian.PutShort(buf, _stringCount);
tableStream.Write(buf);
LittleEndian.PutShort(buf, _extraDataSz);
tableStream.Write(buf);
for (int i = 0; i < _fontNames.Length; i++)
{
tableStream.Write(_fontNames[i].ToArray());
}
}