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; }
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> /// 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) { }