public void TestConstructor()
{
DirectoryProperty property1 = new DirectoryProperty("directory");
RawDataBlock[] rawBlocks = new RawDataBlock[4];
MemoryStream stream =
new MemoryStream(new byte[2048]);
for (int j = 0; j < 4; j++)
{
rawBlocks[j] = new RawDataBlock(stream);
}
POIFSDocument document = new POIFSDocument("document", rawBlocks,
2000);
DocumentProperty property2 = document.DocumentProperty;
DirectoryNode parent = new DirectoryNode(property1, (POIFSFileSystem)null, null);
DocumentNode node = new DocumentNode(property2, parent);
// Verify we can retrieve the document
Assert.AreEqual(property2.Document, node.Document);
// Verify we can Get the size
Assert.AreEqual(property2.Size, node.Size);
// Verify isDocumentEntry returns true
Assert.IsTrue(node.IsDocumentEntry);
// Verify isDirectoryEntry returns false
Assert.IsTrue(!node.IsDirectoryEntry);
// Verify GetName behaves correctly
Assert.AreEqual(property2.Name, node.Name);
// Verify GetParent behaves correctly
Assert.AreEqual(parent, node.Parent);
}
public EncryptionInfo(DirectoryNode dir)
{
DocumentInputStream dis = dir.CreateDocumentInputStream("EncryptionInfo");
versionMajor = dis.ReadShort();
versionMinor = dis.ReadShort();
encryptionFlags = dis.ReadInt();
if (versionMajor == 4 && versionMinor == 4 && encryptionFlags == 0x40)
{
StringBuilder builder = new StringBuilder();
byte[] xmlDescriptor = new byte[dis.Available()];
dis.Read(xmlDescriptor);
foreach (byte b in xmlDescriptor)
builder.Append((char)b);
string descriptor = builder.ToString();
header = new EncryptionHeader(descriptor);
verifier = new EncryptionVerifier(descriptor);
}
else
{
int hSize = dis.ReadInt();
header = new EncryptionHeader(dis);
if (header.Algorithm == EncryptionHeader.ALGORITHM_RC4)
{
verifier = new EncryptionVerifier(dis, 20);
}
else
{
verifier = new EncryptionVerifier(dis, 32);
}
}
}
public static void DisplayDirectory(DirectoryNode dir, String indent)
{
Console.WriteLine(indent + dir.Name + " -");
String newIndent = indent + " ";
IEnumerator it = dir.Entries;
while (it.MoveNext())
{
Object entry = it.Current;
if (entry is DirectoryNode)
{
DisplayDirectory((DirectoryNode)entry, newIndent);
}
else
{
DocumentNode doc = (DocumentNode)entry;
String name = doc.Name;
if (name[0] < 10)
{
String altname = "(0x0" + (int)name[0] + ")" + name.Substring(1);
name = name.Substring(1) + " <" + altname + ">";
}
Console.WriteLine(newIndent + name);
}
}
}
/// <summary>
/// Creates an instance of this class from an embedded OLE Object. The OLE Object is expected
/// to include a stream "{01}Ole10Native" which contains the actual
/// data relevant for this class.
/// </summary>
/// <param name="directory">directory POI Filesystem object</param>
/// <returns>Returns an instance of this class</returns>
public static Ole10Native CreateFromEmbeddedOleObject(DirectoryNode directory)
{
DocumentEntry nativeEntry =
(DocumentEntry)directory.GetEntry(OLE10_NATIVE);
byte[] data = new byte[nativeEntry.Size];
directory.CreateDocumentInputStream(nativeEntry).Read(data);
return new Ole10Native(data, 0);
}
public DirectoryTreeNode(DirectoryNode dn)
: base(dn)
{
this.DirectoryNode = dn;
ChangeImage("Folder");
this.Nodes.Add(string.Empty); // Dummy node
}
public void TestEmptyConstructor()
{
POIFSFileSystem fs = new POIFSFileSystem();
DirectoryProperty property1 = new DirectoryProperty("parent");
DirectoryProperty property2 = new DirectoryProperty("child");
DirectoryNode parent = new DirectoryNode(property1, fs, null);
DirectoryNode node = new DirectoryNode(property2, fs, parent);
Assert.AreEqual(0, parent.Path.Length);
Assert.AreEqual(1, node.Path.Length);
Assert.AreEqual("child", node.Path.GetComponent(0));
// Verify that GetEntries behaves correctly
int count = 0;
IEnumerator iter = node.Entries;
while (iter.MoveNext())
{
count++;
}
Assert.AreEqual(0, count);
// Verify behavior of IsEmpty
Assert.IsTrue(node.IsEmpty);
// Verify behavior of EntryCount
Assert.AreEqual(0, node.EntryCount);
// Verify behavior of Entry
try
{
node.GetEntry("foo");
Assert.Fail("Should have caught FileNotFoundException");
}
catch (FileNotFoundException )
{
// as expected
}
// Verify behavior of isDirectoryEntry
Assert.IsTrue(node.IsDirectoryEntry);
// Verify behavior of GetName
Assert.AreEqual(property2.Name, node.Name);
// Verify behavior of isDocumentEntry
Assert.IsTrue(!node.IsDocumentEntry);
// Verify behavior of GetParent
Assert.AreEqual(parent, node.Parent);
}
private NPOIFSFileSystem(bool newFS)
{
_header = new HeaderBlock(bigBlockSize);
_property_table = new NPropertyTable(_header);
_mini_store = new NPOIFSMiniStore(this, _property_table.Root, new List<BATBlock>(), _header);
_xbat_blocks = new List<BATBlock>();
_bat_blocks = new List<BATBlock>();
_root = null;
if (newFS)
{
// Data needs to Initially hold just the header block,
// a single bat block, and an empty properties section
_data = new ByteArrayBackedDataSource(new byte[bigBlockSize.GetBigBlockSize() * 3]);
}
}
internal static TreeNode[] GetChildren(DirectoryNode node,object innerDoc)
{
var children = new List<AbstractTreeNode>();
var entries = node.Entries;
while (entries.MoveNext())
{
EntryNode entry = entries.Current as EntryNode;
AbstractTreeNode treeNode;
if (entry is DirectoryNode)
{
treeNode = new DirectoryTreeNode(entry as DirectoryNode);
var o = entry as DirectoryNode;
}
else
{
var o = entry as DocumentNode;
treeNode = new DocumentTreeNode(entry as DocumentNode);
#region handle Excel BIFF records
if (treeNode.Text.ToLower() == "workbook")
{
HandleWorkbook(treeNode, (HSSFWorkbook)innerDoc);
}
//else if(treeNode.Text.ToLower() == "worddocument")
//{
// HandleWord(treeNode, (HWPFDocument)innerDoc);
//}
#endregion
}
children.Add(treeNode);
}
children.Sort();
return children.ToArray();
}
/// <summary>
/// Creates an instance of this class from an embedded OLE Object. The OLE Object is expected
/// to include a stream "{01}Ole10Native" which contains the actual
/// data relevant for this class.
/// </summary>
/// <param name="directory">directory POI Filesystem object</param>
/// <returns>Returns an instance of this class</returns>
public static Ole10Native CreateFromEmbeddedOleObject(DirectoryNode directory)
{
bool plain = false;
try
{
directory.GetEntry("\u0001Ole10ItemName");
plain = true;
}
catch (FileNotFoundException)
{
plain = false;
}
DocumentEntry nativeEntry =
(DocumentEntry)directory.GetEntry(OLE10_NATIVE);
byte[] data = new byte[nativeEntry.Size];
directory.CreateDocumentInputStream(nativeEntry).Read(data);
return new Ole10Native(data, 0);
}
/// <summary>
/// Create a DirectoryNode. This method Is not public by design; it
/// Is intended strictly for the internal use of this package
/// </summary>
/// <param name="property">the DirectoryProperty for this DirectoryEntry</param>
/// <param name="filesystem">the POIFSFileSystem we belong to</param>
/// <param name="parent">the parent of this entry</param>
public DirectoryNode(DirectoryProperty property,
POIFSFileSystem filesystem,
DirectoryNode parent)
: base(property, parent)
{
if (parent == null)
{
_path = new POIFSDocumentPath();
}
else
{
_path = new POIFSDocumentPath(parent._path, new String[]
{
property.Name
});
}
_filesystem = filesystem;
_entries = new Hashtable();
IEnumerator iter = property.Children;
while (iter.MoveNext())
{
Property child = ( Property ) iter.Current;
Entry childNode = null;
if (child.IsDirectory)
{
childNode = new DirectoryNode(( DirectoryProperty ) child,
_filesystem, this);
}
else
{
childNode = new DocumentNode(( DocumentProperty ) child,
this);
}
_entries[childNode.Name]=childNode;
}
}
private void fetchSizes(String path, DirectoryNode dir, Dictionary<String, int> entries)
{
foreach (Entry entry in dir)
{
if (entry is DirectoryNode)
{
String ourPath = path + entry.Name + "/";
entries.Add(ourPath, -1);
fetchSizes(ourPath, (DirectoryNode)entry, entries);
}
else
{
DocumentNode doc = (DocumentNode)entry;
entries.Add(path + entry.Name, doc.Size);
}
}
}
private void CheckSizes(String path, DirectoryNode dir, Dictionary<String, int> entries)
{
foreach (Entry entry in dir)
{
if (entry is DirectoryNode)
{
String ourPath = path + entry.Name + "/";
Assert.IsTrue(entries.ContainsKey(ourPath));
Assert.AreEqual(-1, entries[(ourPath)]);
CheckSizes(ourPath, (DirectoryNode)entry, entries);
}
else
{
DocumentNode doc = (DocumentNode)entry;
Assert.AreEqual(entries[(path + entry.Name)], doc.Size);
}
}
}
/// <summary>
/// Create a DirectoryNode. This method Is not public by design; it
/// Is intended strictly for the internal use of this package
/// </summary>
/// <param name="property">the DirectoryProperty for this DirectoryEntry</param>
/// <param name="fileSystem">the OPOIFSFileSystem we belong to</param>
/// <param name="parent">the parent of this entry</param>
internal DirectoryNode(DirectoryProperty property,
OPOIFSFileSystem fileSystem,
DirectoryNode parent)
: this(property, parent, fileSystem, (NPOIFSFileSystem)null)
{
}
/// <summary>
/// Create a DocumentNode. ThIs method Is not public by design; it
/// Is intended strictly for the internal use of extending classes
/// </summary>
/// <param name="property">the Property for this Entry</param>
/// <param name="parent">the parent of this entry</param>
protected EntryNode(Property property, DirectoryNode parent)
{
_property = property;
_parent = parent;
}
public HWPFOldDocument(DirectoryNode directory, POIFSFileSystem fs):this(directory)
{
}
public override Stream GetDataStream(DirectoryNode dir)
{
DocumentInputStream dis = dir.CreateDocumentInputStream("EncryptedPackage");
_length = dis.ReadLong();
return new ChunkedCipherInputStream(dis, _length, this);
}
public void TestDifferentPOIFS()
{
//throw new NotImplementedException("class NPOIFSFileSystem is not implemented");
// Open the two filesystems
DirectoryNode[] files = new DirectoryNode[2];
files[0] = (new POIFSFileSystem(HSSFTestDataSamples.OpenSampleFileStream("Simple.xls"))).Root;
files[1] = (new NPOIFSFileSystem(HSSFTestDataSamples.OpenSampleFileStream("Simple.xls"))).Root;
// Open without preserving nodes
foreach (DirectoryNode dir in files)
{
IWorkbook workbook = new HSSFWorkbook(dir, false);
ISheet sheet = workbook.GetSheetAt(0);
ICell cell = sheet.GetRow(0).GetCell(0);
Assert.AreEqual("replaceMe", cell.RichStringCellValue.String);
}
// Now re-check with preserving
foreach (DirectoryNode dir in files)
{
IWorkbook workbook = new HSSFWorkbook(dir, true);
ISheet sheet = workbook.GetSheetAt(0);
ICell cell = sheet.GetRow(0).GetCell(0);
Assert.AreEqual("replaceMe", cell.RichStringCellValue.String);
}
}
private bool HasEntry(DirectoryNode dirNode, String entryName)
{
try
{
dirNode.GetEntry(entryName);
return true;
}
catch (FileNotFoundException)
{
return false;
}
}
/**
* given a POI POIFSFileSystem object, and a specific directory
* within it, read in its Workbook and populate the high and
* low level models. If you're reading in a workbook...start here.
*
* @param directory the POI filesystem directory to process from
* @param preserveNodes whether to preseve other nodes, such as
* macros. This takes more memory, so only say yes if you
* need to. If set, will store all of the POIFSFileSystem
* in memory
* @see org.apache.poi.poifs.filesystem.POIFSFileSystem
* @exception IOException if the stream cannot be read
*/
public HSSFWorkbook(DirectoryNode directory, bool preserveNodes):base(directory)
{
String workbookName = GetWorkbookDirEntryName(directory);
this.preserveNodes = preserveNodes;
// If we're not preserving nodes, don't track the
// POIFS any more
if (!preserveNodes)
{
this.directory = null;
}
_sheets = new List<HSSFSheet>(INITIAL_CAPACITY);
names = new List<HSSFName>(INITIAL_CAPACITY);
// Grab the data from the workbook stream, however
// it happens to be spelled.
Stream stream = directory.CreatePOIFSDocumentReader(workbookName);
List<Record> records = RecordFactory.CreateRecords(stream);
workbook = InternalWorkbook.CreateWorkbook(records);
SetPropertiesFromWorkbook(workbook);
int recOffset = workbook.NumRecords;
// Convert all LabelRecord records to LabelSSTRecord
ConvertLabelRecords(records, recOffset);
RecordStream rs = new RecordStream(records, recOffset);
while (rs.HasNext())
{
InternalSheet sheet = InternalSheet.CreateSheet(rs);
_sheets.Add(new HSSFSheet(this, sheet));
}
for (int i = 0; i < workbook.NumNames; ++i)
{
NameRecord nameRecord = workbook.GetNameRecord(i);
HSSFName name = new HSSFName(this, workbook.GetNameRecord(i), workbook.GetNameCommentRecord(nameRecord));
names.Add(name);
}
}
private void ProcessProperties(BlockList small_blocks,
BlockList big_blocks,
IEnumerator properties,
DirectoryNode dir,
int headerPropertiesStartAt)
{
while (properties.MoveNext())
{
Property property = ( Property ) properties.Current;
String name = property.Name;
DirectoryNode parent = (dir == null)
? (( DirectoryNode ) this.Root)
: dir;
if (property.IsDirectory)
{
DirectoryNode new_dir =
( DirectoryNode ) parent.CreateDirectory(name);
new_dir.StorageClsid=property.StorageClsid ;
ProcessProperties(
small_blocks, big_blocks,
((DirectoryProperty)property).Children, new_dir, headerPropertiesStartAt);
}
else
{
int startBlock = property.StartBlock;
int size = property.Size;
POIFSDocument document = null;
if (property.ShouldUseSmallBlocks)
{
document =
new POIFSDocument(name, small_blocks
.FetchBlocks(startBlock, headerPropertiesStartAt), size);
}
else
{
document =
new POIFSDocument(name,
big_blocks.FetchBlocks(startBlock,headerPropertiesStartAt),
size);
}
parent.CreateDocument(document);
}
}
}
/// <summary>
/// given a POI POIFSFileSystem object, and a specific directory
/// within it, Read in its Workbook and populate the high and
/// low level models. If you're Reading in a workbook...start here.
/// </summary>
/// <param name="directory">the POI filesystem directory to Process from</param>
/// <param name="fs">the POI filesystem that Contains the Workbook stream.</param>
/// <param name="preserveNodes">whether to preseve other nodes, such as
/// macros. This takes more memory, so only say yes if you
/// need to. If Set, will store all of the POIFSFileSystem
/// in memory</param>
public HSSFWorkbook(DirectoryNode directory, POIFSFileSystem fs, bool preserveNodes)
: this(directory, preserveNodes)
{
}
private static String GetWorkbookDirEntryName(DirectoryNode directory)
{
String[] potentialNames = WORKBOOK_DIR_ENTRY_NAMES;
for (int i = 0; i < potentialNames.Length; i++)
{
String wbName = potentialNames[i];
try
{
directory.GetEntry(wbName);
return wbName;
}
catch (FileNotFoundException)
{
// continue - to try other options
}
}
// Check for previous version of file format
try
{
directory.GetEntry("Book");
throw new OldExcelFormatException("The supplied spreadsheet seems to be Excel 5.0/7.0 (BIFF5) format. "
+ "POI only supports BIFF8 format (from Excel versions 97/2000/XP/2003)");
}
catch (FileNotFoundException)
{
// fall through
}
throw new ArgumentException("The supplied POIFSFileSystem does not contain a BIFF8 'Workbook' entry. "
+ "Is it really an excel file?");
}
/**
* create a DocumentNode. This method Is not public by design; it
* Is intended strictly for the internal use of this package
*
* @param property the DocumentProperty for this DocumentEntry
* @param parent the parent of this entry
*/
public DocumentNode(DocumentProperty property, DirectoryNode parent)
: base(property, parent)
{
_document = property.Document;
}
/// <summary>
/// Return a stream with decrypted data.
/// Use {@link #getLength()} to get the size of that data that can be safely read from the stream.
/// Just reading to the end of the input stream is not sufficient because there are
/// normally padding bytes that must be discarded
/// </summary>
/// <param name="dir">the node to read from</param>
/// <returns>decrypted stream</returns>
public abstract Stream GetDataStream(DirectoryNode dir);
/// <summary>
/// Initializes a new instance of the <see cref="POIFSFileSystem"/> class. intended for writing
/// </summary>
public POIFSFileSystem()
{
_property_table = new PropertyTable();
_documents = new ArrayList();
_root = null;
}
// there is nothing to dispose
//public void Dispose()
//{
// Dispose(true);
// GC.SuppressFinalize(this);
//}
//protected virtual void Dispose(bool disposing)
//{
// if (disposing)
// {
// }
//}
/// <summary>
/// Initializes a new instance of the <see cref="POIFSFileSystem"/> class. intended for writing
/// </summary>
public POIFSFileSystem()
{
HeaderBlock headerBlock = new HeaderBlock(bigBlockSize);
_property_table = new PropertyTable(headerBlock);
_documents = new ArrayList();
_root = null;
}
/**
* create a DocumentNode. This method Is not public by design; it
* Is intended strictly for the internal use of this package
*
* @param property the DocumentProperty for this DocumentEntry
* @param parent the parent of this entry
*/
public DocumentNode(DocumentProperty property, DirectoryNode parent) : base(property, parent)
{
_document = property.Document;
}
public void TestWordDocEmbeddedInXls()
{
//throw new NotImplementedException("class NPOIFSFileSystem is not implemented");
// Open the two filesystems
DirectoryNode[] files = new DirectoryNode[2];
files[0] = (new POIFSFileSystem(HSSFTestDataSamples.OpenSampleFileStream("WithEmbeddedObjects.xls"))).Root;
files[1] = (new NPOIFSFileSystem(HSSFTestDataSamples.OpenSampleFileStream("WithEmbeddedObjects.xls"))).Root;
// Check the embedded parts
foreach (DirectoryNode root in files)
{
HSSFWorkbook hw = new HSSFWorkbook(root, true);
IList<HSSFObjectData> objects = hw.GetAllEmbeddedObjects();
bool found = false;
for (int i = 0; i < objects.Count; i++)
{
HSSFObjectData embeddedObject = objects[i];
if (embeddedObject.HasDirectoryEntry())
{
DirectoryEntry dir = embeddedObject.GetDirectory();
if (dir is DirectoryNode)
{
DirectoryNode dNode = (DirectoryNode)dir;
if (HasEntry(dNode, "WordDocument"))
{
found = true;
}
}
}
}
Assert.IsTrue(found);
}
}
public HWPFDocument(DirectoryNode directory, POIFSFileSystem pfilesystem)
: this(directory)
{
}
/// <summary>
/// Create a DocumentNode. ThIs method Is not public by design; it
/// Is intended strictly for the internal use of extending classes
/// </summary>
/// <param name="property">the Property for this Entry</param>
/// <param name="parent">the parent of this entry</param>
protected EntryNode(Property property, DirectoryNode parent)
{
_property = property;
_parent = parent;
}
/// <summary>
/// Initializes a new instance of the <see cref="HWPFDocument"/> class.
/// </summary>
/// <param name="directory">The directory.</param>
public HWPFDocument(DirectoryNode directory)
: base(directory)
{
_endnotes = new NotesImpl(_endnotesTables);
_footnotes = new NotesImpl(_footnotesTables);
// Load the main stream and FIB
// Also handles HPSF bits
// Do the CP Split
_cpSplit = new CPSplitCalculator(_fib);
// Is this document too old for us?
if (_fib.GetNFib() < 106)
{
throw new OldWordFileFormatException("The document is too old - Word 95 or older. Try HWPFOldDocument instead?");
}
// use the fib to determine the name of the table stream.
String name = "0Table";
if (_fib.IsFWhichTblStm())
{
name = "1Table";
}
// Grab the table stream.
DocumentEntry tableProps;
try
{
tableProps =
(DocumentEntry)directory.GetEntry(name);
}
catch (FileNotFoundException)
{
throw new InvalidOperationException("Table Stream '" + name + "' wasn't found - Either the document is corrupt, or is Word95 (or earlier)");
}
// read in the table stream.
_tableStream = new byte[tableProps.Size];
directory.CreatePOIFSDocumentReader(name).Read(_tableStream);
_fib.FillVariableFields(_mainStream, _tableStream);
// read in the data stream.
try
{
DocumentEntry dataProps =
(DocumentEntry)directory.GetEntry("Data");
_dataStream = new byte[dataProps.Size];
directory.CreatePOIFSDocumentReader("Data").Read(_dataStream);
}
catch (FileNotFoundException)
{
_dataStream = new byte[0];
}
// Get the cp of the start of text in the main stream
// The latest spec doc says this is always zero!
int fcMin = 0;
//fcMin = _fib.GetFcMin()
// Start to load up our standard structures.
_dop = new DocumentProperties(_tableStream, _fib.GetFcDop());
_cft = new ComplexFileTable(_mainStream, _tableStream, _fib.GetFcClx(), fcMin);
TextPieceTable _tpt = _cft.GetTextPieceTable();
// Now load the rest of the properties, which need to be adjusted
// for where text really begin
_cbt = new CHPBinTable(_mainStream, _tableStream, _fib.GetFcPlcfbteChpx(), _fib.GetLcbPlcfbteChpx(), _tpt);
_pbt = new PAPBinTable(_mainStream, _tableStream, _dataStream, _fib.GetFcPlcfbtePapx(), _fib.GetLcbPlcfbtePapx(), _tpt);
_text = _tpt.Text;
/*
* in this mode we preserving PAPX/CHPX structure from file, so text may
* miss from output, and text order may be corrupted
*/
bool preserveBinTables = false;
try
{
preserveBinTables = Boolean.Parse(
ConfigurationManager.AppSettings[PROPERTY_PRESERVE_BIN_TABLES]);
}
catch (Exception)
{
// ignore;
}
if (!preserveBinTables)
{
_cbt.Rebuild(_cft);
_pbt.Rebuild(_text, _cft);
}
/*
* Property to disable text rebuilding. In this mode changing the text
* will lead to unpredictable behavior
*/
bool preserveTextTable = false;
try
{
preserveTextTable = Boolean.Parse(
ConfigurationManager.AppSettings[PROPERTY_PRESERVE_TEXT_TABLE]);
}
catch (Exception)
{
// ignore;
}
if (!preserveTextTable)
{
_cft = new ComplexFileTable();
_tpt = _cft.GetTextPieceTable();
TextPiece textPiece = new SinglentonTextPiece(_text);
_tpt.Add(textPiece);
_text = textPiece.GetStringBuilder();
}
// Read FSPA and Escher information
// _fspa = new FSPATable(_tableStream, _fib.getFcPlcspaMom(),
// _fib.getLcbPlcspaMom(), getTextTable().getTextPieces());
_fspaHeaders = new FSPATable(_tableStream, _fib,
FSPADocumentPart.HEADER);
_fspaMain = new FSPATable(_tableStream, _fib, FSPADocumentPart.MAIN);
if (_fib.GetFcDggInfo() != 0)
{
_dgg = new EscherRecordHolder(_tableStream, _fib.GetFcDggInfo(), _fib.GetLcbDggInfo());
}
else
{
_dgg = new EscherRecordHolder();
}
// read in the pictures stream
_pictures = new PicturesTable(this, _dataStream, _mainStream, _fspa, _dgg);
// And the art shapes stream
_officeArts = new ShapesTable(_tableStream, _fib);
// And escher pictures
_officeDrawingsHeaders = new OfficeDrawingsImpl(_fspaHeaders, _dgg, _mainStream);
_officeDrawingsMain = new OfficeDrawingsImpl(_fspaMain, _dgg, _mainStream);
_st = new SectionTable(_mainStream, _tableStream, _fib.GetFcPlcfsed(), _fib.GetLcbPlcfsed(), fcMin, _tpt, _cpSplit);
_ss = new StyleSheet(_tableStream, _fib.GetFcStshf());
_ft = new FontTable(_tableStream, _fib.GetFcSttbfffn(), _fib.GetLcbSttbfffn());
int listOffset = _fib.GetFcPlcfLst();
int lfoOffset = _fib.GetFcPlfLfo();
if (listOffset != 0 && _fib.GetLcbPlcfLst() != 0)
{
_lt = new ListTables(_tableStream, _fib.GetFcPlcfLst(), _fib.GetFcPlfLfo());
}
int sbtOffset = _fib.GetFcSttbSavedBy();
int sbtLength = _fib.GetLcbSttbSavedBy();
if (sbtOffset != 0 && sbtLength != 0)
{
_sbt = new SavedByTable(_tableStream, sbtOffset, sbtLength);
}
int rmarkOffset = _fib.GetFcSttbfRMark();
int rmarkLength = _fib.GetLcbSttbfRMark();
if (rmarkOffset != 0 && rmarkLength != 0)
{
_rmat = new RevisionMarkAuthorTable(_tableStream, rmarkOffset, rmarkLength);
}
_bookmarksTables = new BookmarksTables(_tableStream, _fib);
_bookmarks = new BookmarksImpl(_bookmarksTables);
_endnotesTables = new NotesTables(NoteType.ENDNOTE, _tableStream, _fib);
_endnotes = new NotesImpl(_endnotesTables);
_footnotesTables = new NotesTables(NoteType.FOOTNOTE, _tableStream, _fib);
_footnotes = new NotesImpl(_footnotesTables);
_fieldsTables = new FieldsTables(_tableStream, _fib);
_fields = new FieldsImpl(_fieldsTables);
}
public HWPFOldDocument(DirectoryNode directory)
: base(directory)
{
// Where are things?
int sedTableOffset = LittleEndian.GetInt(_mainStream, 0x88);
int sedTableSize = LittleEndian.GetInt(_mainStream, 0x8c);
int chpTableOffset = LittleEndian.GetInt(_mainStream, 0xb8);
int chpTableSize = LittleEndian.GetInt(_mainStream, 0xbc);
int papTableOffset = LittleEndian.GetInt(_mainStream, 0xc0);
int papTableSize = LittleEndian.GetInt(_mainStream, 0xc4);
//int shfTableOffset = LittleEndian.GetInt(_mainStream, 0x60);
//int shfTableSize = LittleEndian.GetInt(_mainStream, 0x64);
int complexTableOffset = LittleEndian.GetInt(_mainStream, 0x160);
// We need to get hold of the text that Makes up the
// document, which might be regular or fast-saved
StringBuilder text = new StringBuilder();
if (_fib.IsFComplex())
{
ComplexFileTable cft = new ComplexFileTable(
_mainStream, _mainStream,
complexTableOffset, _fib.GetFcMin()
);
tpt = cft.GetTextPieceTable();
foreach (TextPiece tp in tpt.TextPieces)
{
text.Append(tp.GetStringBuilder());
}
}
else
{
// TODO Discover if these older documents can ever hold Unicode Strings?
// (We think not, because they seem to lack a Piece table)
// TODO Build the Piece Descriptor properly
// (We have to fake it, as they don't seem to have a proper Piece table)
PieceDescriptor pd = new PieceDescriptor(new byte[] { 0, 0, 0, 0, 0, 127, 0, 0 }, 0);
pd.FilePosition = _fib.GetFcMin();
// Generate a single Text Piece Table, with a single Text Piece
// which covers all the (8 bit only) text in the file
tpt = new TextPieceTable();
byte[] textData = new byte[_fib.GetFcMac() - _fib.GetFcMin()];
Array.Copy(_mainStream, _fib.GetFcMin(), textData, 0, textData.Length);
TextPiece tp = new TextPiece(
0, textData.Length, textData, pd
);
tpt.Add(tp);
text.Append(tp.GetStringBuilder());
}
_text = tpt.Text;
// Now we can fetch the character and paragraph properties
_cbt = new OldCHPBinTable(
_mainStream, chpTableOffset, chpTableSize,
_fib.GetFcMin(), tpt
);
_pbt = new OldPAPBinTable(
_mainStream, chpTableOffset, papTableSize,
_fib.GetFcMin(), tpt
);
_st = new OldSectionTable(
_mainStream, chpTableOffset, sedTableSize,
_fib.GetFcMin(), tpt
);
}
public WordExtractor(DirectoryNode dir, POIFSFileSystem fs)
: this(new HWPFDocument(dir, fs))
{
this.fs = fs;
}
/// <summary>
/// Initializes a new instance of the <see cref="POIDocument"/> class.
/// </summary>
/// <param name="dir">The dir.</param>
/// <param name="fs">The fs.</param>
public POIDocument(DirectoryNode dir, POIFSFileSystem fs)
{
this.filesystem = fs;
this.directory = dir;
//POILogFactory.GetLogger(this.GetType());
}
/// <summary>
/// Create a DirectoryNode. This method Is not public by design; it
/// Is intended strictly for the internal use of this package
/// </summary>
/// <param name="property">the DirectoryProperty for this DirectoryEntry</param>
/// <param name="nFileSystem">the POIFSFileSystem we belong to</param>
/// <param name="parent">the parent of this entry</param>
internal DirectoryNode(DirectoryProperty property,
NPOIFSFileSystem nFileSystem,
DirectoryNode parent)
: this(property, parent, (OPOIFSFileSystem)null, nFileSystem)
{
}