/// <summary> /// Initializes a new instance of the <see cref="BlockAllocationTableWriter"/> class. /// </summary> public BlockAllocationTableWriter(POIFSBigBlockSize bigBlockSize) { _start_block = POIFSConstants.END_OF_CHAIN; _entries = new List<int>(_default_size); _blocks = new BATBlock[ 0 ]; _bigBlockSize = bigBlockSize; }
/// <summary> /// Initializes a new instance of the <see cref="SmallBlockTableWriter"/> class. /// </summary> /// <param name="bigBlockSize">the poifs bigBlockSize</param> /// <param name="documents">a IList of POIFSDocument instances</param> /// <param name="root">the Filesystem's root property</param> public SmallBlockTableWriter(POIFSBigBlockSize bigBlockSize, IList documents, RootProperty root) { _sbat = new BlockAllocationTableWriter(bigBlockSize); _small_blocks = new ArrayList(); _root = root; IEnumerator iter = documents.GetEnumerator(); while (iter.MoveNext()) { POIFSDocument doc = ( POIFSDocument ) iter.Current; BlockWritable[] blocks = doc.SmallBlocks; if (blocks.Length != 0) { doc.StartBlock=_sbat.AllocateSpace(blocks.Length); for (int j = 0; j < blocks.Length; j++) { _small_blocks.Add(blocks[ j ]); } } else { doc.StartBlock=POIFSConstants.END_OF_CHAIN; } } _sbat.SimpleCreateBlocks(); _root.Size=_small_blocks.Count; _big_block_count = SmallDocumentBlock.Fill(bigBlockSize, _small_blocks); }
private static List<Property> BuildProperties(IEnumerator<ByteBuffer> dataSource, POIFSBigBlockSize bigBlockSize) { List<Property> properties = new List<Property>(); while(dataSource.MoveNext()) { ByteBuffer bb = dataSource.Current; // Turn it into an array byte[] data; if (bb.HasBuffer && bb.Offset == 0 && bb.Buffer.Length == bigBlockSize.GetBigBlockSize()) { data = bb.Buffer; } else { data = new byte[bigBlockSize.GetBigBlockSize()]; int toRead = data.Length; if (bb.Remaining() < bigBlockSize.GetBigBlockSize()) { // Looks to be a truncated block // This isn't allowed, but some third party created files // sometimes do this, and we can normally read anyway toRead = bb.Remaining(); } bb.Read(data, 0, toRead); } PropertyFactory.ConvertToProperties(data, properties); } return properties; }
/// <summary> /// convert a single long array into an array of SmallDocumentBlock /// instances /// </summary> /// <param name="bigBlockSize">the poifs bigBlockSize</param> /// <param name="array">the byte array to be converted</param> /// <param name="size">the intended size of the array (which may be smaller)</param> /// <returns>an array of SmallDocumentBlock instances, filled from /// the array</returns> public static SmallDocumentBlock [] Convert(POIFSBigBlockSize bigBlockSize, byte [] array, int size) { SmallDocumentBlock[] rval = new SmallDocumentBlock[ (size + _block_size - 1) / _block_size ]; int offset = 0; for (int k = 0; k < rval.Length; k++) { rval[ k ] = new SmallDocumentBlock(bigBlockSize); if (offset < array.Length) { int length = Math.Min(_block_size, array.Length - offset); Array.Copy(array, offset, rval[ k ]._data, 0, length); if (length != _block_size) { for (int i = length; i < _block_size; i++) rval[k]._data[i] = _default_fill; } } else { for (int j = 0; j < rval[k]._data.Length; j++) { rval[k]._data[j] = _default_fill; } } offset += _block_size; } return rval; }
public NPropertyTable(HeaderBlock headerBlock, NPOIFSFileSystem fileSystem) :base(headerBlock, BuildProperties( (new NPOIFSStream(fileSystem, headerBlock.PropertyStart)).GetEnumerator(),headerBlock.BigBlockSize) ) { _bigBigBlockSize = headerBlock.BigBlockSize; }
/// <summary> /// Create a single instance initialized with default values /// </summary> /// <param name="bigBlockSize"></param> /// <param name="properties">the properties to be inserted</param> /// <param name="offset">the offset into the properties array</param> protected PropertyBlock(POIFSBigBlockSize bigBlockSize, Property[] properties, int offset) : base(bigBlockSize) { _properties = new Property[ bigBlockSize.GetPropertiesPerBlock() ]; for (int j = 0; j < _properties.Length; j++) { _properties[ j ] = properties[ j + offset ]; } }
public SmallDocumentBlock(POIFSBigBlockSize bigBlockSize, byte[] data, int index) { _bigBlockSize = bigBlockSize; _blocks_per_big_block = GetBlocksPerBigBlock(bigBlockSize); _data = new byte[_block_size]; System.Array.Copy(data, index*_block_size, _data, 0, _block_size); }
/** * reading constructor (used when we've read in a file and we want * to extract the property table from it). Populates the * properties thoroughly * * @param startBlock the first block of the property table * @param blockList the list of blocks * * @exception IOException if anything goes wrong (which should be * a result of the input being NFG) */ public PropertyTable(HeaderBlock headerBlock, RawDataBlockList blockList) : base(headerBlock, PropertyFactory.ConvertToProperties( blockList.FetchBlocks(headerBlock.PropertyStart, -1) ) ) { _bigBigBlockSize = headerBlock.BigBlockSize; _blocks = null; }
/// <summary> /// fetch the small document block list from an existing file /// </summary> /// <param name="blockList">the raw data from which the small block table will be extracted</param> /// <param name="root">the root property (which contains the start block and small block table size)</param> /// <param name="sbatStart">the start block of the SBAT</param> /// <returns>the small document block list</returns> public static BlockList GetSmallDocumentBlocks(POIFSBigBlockSize bigBlockSize, RawDataBlockList blockList, RootProperty root, int sbatStart) { BlockList list = new SmallDocumentBlockList( SmallDocumentBlock.Extract(bigBlockSize, blockList.FetchBlocks(root.StartBlock, -1))); new BlockAllocationTableReader(bigBlockSize, blockList.FetchBlocks(sbatStart, -1), list); return list; }
public POIFSDocument(string name, RawDataBlock[] blocks, int length) { _size = length; if (blocks.Length == 0) _bigBigBlockSize = POIFSConstants.SMALLER_BIG_BLOCK_SIZE_DETAILS; else { _bigBigBlockSize = (blocks[0].BigBlockSize == POIFSConstants.SMALLER_BIG_BLOCK_SIZE ? POIFSConstants.SMALLER_BIG_BLOCK_SIZE_DETAILS : POIFSConstants.LARGER_BIG_BLOCK_SIZE_DETAILS); } _big_store = new BigBlockStore(_bigBigBlockSize, ConvertRawBlocksToBigBlocks(blocks)); _property = new DocumentProperty(name, _size); _small_store = new SmallBlockStore(_bigBigBlockSize, EMPTY_SMALL_BLOCK_ARRAY); _property.Document = this; }
/// <summary> /// Initializes a new instance of the <see cref="RawDataBlockList"/> class. /// </summary> /// <param name="stream">the InputStream from which the data will be read</param> /// <param name="bigBlockSize">The big block size, either 512 bytes or 4096 bytes</param> public RawDataBlockList(Stream stream, POIFSBigBlockSize bigBlockSize) { List<RawDataBlock> blocks = new List<RawDataBlock>(); while (true) { RawDataBlock block = new RawDataBlock(stream, bigBlockSize.GetBigBlockSize()); // If there was data, add the block to the list if(block.HasData) { blocks.Add(block); } // If the stream is now at the End Of File, we're done if (block.EOF) { break; } } SetBlocks((ListManagedBlock[])blocks.ToArray()); }
// private static List<Property> BuildProperties(IEnumerator<byte[]> dataSource, POIFSBigBlockSize bigBlockSize) private static List<Property> BuildProperties(IEnumerator<ByteBuffer> dataSource, POIFSBigBlockSize bigBlockSize) { try { List<Property> properties = new List<Property>(); while(dataSource.MoveNext()) { ByteBuffer bb = dataSource.Current; //byte[] bb = (byte[])dataSource.Current; // Turn it into an array byte[] data; if (bb.HasBuffer && bb.Offset == 0 && bb.Buffer.Length == bigBlockSize.GetBigBlockSize()) { data = bb.Buffer; } else { data = new byte[bigBlockSize.GetBigBlockSize()]; //bb.get(data, 0, data.length); bb.Read(data, 0, data.Length); } //} //data = new byte[bigBlockSize.GetBigBlockSize()]; //System.Array.Copy(bb, data, bb.Length); PropertyFactory.ConvertToProperties(data, properties); } return properties; } catch(System.IO.IOException ex) { throw ex; } }
/// <summary> /// Create an array of PropertyBlocks from an array of Property /// instances, creating empty Property instances to make up any /// shortfall /// </summary> /// <param name="properties">the Property instances to be converted into PropertyBlocks, in a java List</param> /// <returns>the array of newly created PropertyBlock instances</returns> public static BlockWritable [] CreatePropertyBlockArray( POIFSBigBlockSize bigBlockSize, List<Property> properties) { int _properties_per_block = bigBlockSize.GetPropertiesPerBlock(); int blockCount = (properties.Count + _properties_per_block - 1) / _properties_per_block; Property[] toBeWritten = new Property[blockCount * _properties_per_block]; System.Array.Copy(properties.ToArray(), 0, toBeWritten, 0, properties.Count); for (int i = properties.Count; i < toBeWritten.Length; i++) { toBeWritten[i] = new AnonymousProperty(); } BlockWritable[] rvalue = new BlockWritable[blockCount]; for (int i = 0; i < blockCount; i++) rvalue[i] = new PropertyBlock(bigBlockSize, toBeWritten, i * _properties_per_block); return rvalue; }
/// <summary> /// create a BlockAllocationTableReader for an existing filesystem. Side /// effect: when this method finishes, the BAT blocks will have /// been Removed from the raw block list, and any blocks labeled as /// 'unused' in the block allocation table will also have been /// Removed from the raw block list. </summary> /// <param name="bigBlockSizse">the poifs bigBlockSize</param> /// <param name="block_count">the number of BAT blocks making up the block allocation table</param> /// <param name="block_array">the array of BAT block indices from the /// filesystem's header</param> /// <param name="xbat_count">the number of XBAT blocks</param> /// <param name="xbat_index">the index of the first XBAT block</param> /// <param name="raw_block_list">the list of RawDataBlocks</param> public BlockAllocationTableReader(POIFSBigBlockSize bigBlockSizse, int block_count, int[] block_array, int xbat_count, int xbat_index, BlockList raw_block_list) : this(bigBlockSizse) { SanityCheckBlockCount(block_count); RawDataBlock[] blocks = new RawDataBlock[block_count]; int limit = Math.Min(block_count, block_array.Length); int block_index; for (block_index = 0; block_index < limit; block_index++) { int nextOffset = block_array[block_index]; if (nextOffset > raw_block_list.BlockCount()) { throw new IOException("Your file contains " + raw_block_list.BlockCount() + " sectors, but the initial DIFAT array at index " + block_index + " referenced block # " + nextOffset + ". This isn't allowed and " + " your file is corrupt"); } blocks[block_index] = (RawDataBlock)raw_block_list.Remove(nextOffset); } if (block_index < block_count) { // must have extended blocks if (xbat_index < 0) { throw new IOException( "BAT count exceeds limit, yet XBAT index indicates no valid entries"); } int chain_index = xbat_index; int max_entries_per_block = BATBlock.EntriesPerXBATBlock; int chain_index_offset = BATBlock.XBATChainOffset; // Each XBAT block contains either: // (maximum number of sector indexes) + index of next XBAT // some sector indexes + FREE sectors to max # + EndOfChain for (int j = 0; j < xbat_count; j++) { limit = Math.Min(block_count - block_index, max_entries_per_block); byte[] data = raw_block_list.Remove(chain_index).Data; int offset = 0; for (int k = 0; k < limit; k++) { blocks[block_index++] = (RawDataBlock)raw_block_list.Remove(LittleEndian.GetInt(data, offset)); offset += LittleEndianConsts.INT_SIZE; } chain_index = LittleEndian.GetInt(data, chain_index_offset); if (chain_index == POIFSConstants.END_OF_CHAIN) { break; } } } if (block_index != block_count) { throw new IOException("Could not find all blocks"); } // now that we have all of the raw data blocks, go through and // create the indices SetEntries((ListManagedBlock[])blocks, raw_block_list); }
public POIFSDocument(string name, POIFSBigBlockSize bigBlockSize, Stream stream) { List<DocumentBlock> blocks = new List<DocumentBlock>(); _size = 0; _bigBigBlockSize = bigBlockSize; while (true) { DocumentBlock block = new DocumentBlock(stream, bigBlockSize); int blockSize = block.Size; if (blockSize > 0) { blocks.Add(block); _size += blockSize; } if (block.PartiallyRead) break; } DocumentBlock[] bigBlocks = blocks.ToArray(); _big_store = new BigBlockStore(bigBlockSize, bigBlocks); _property = new DocumentProperty(name, _size); _property.Document = this; if (_property.ShouldUseSmallBlocks) { _small_store = new SmallBlockStore(bigBlockSize, SmallDocumentBlock.Convert(bigBlockSize, bigBlocks, _size)); _big_store = new BigBlockStore(bigBlockSize, new DocumentBlock[0]); } else { _small_store = new SmallBlockStore(bigBlockSize, EMPTY_SMALL_BLOCK_ARRAY); } }
/// <summary> /// create a BlockAllocationTableReader from an array of raw data blocks /// </summary> /// <param name="bigBlockSize"></param> /// <param name="blocks">the raw data</param> /// <param name="raw_block_list">the list holding the managed blocks</param> public BlockAllocationTableReader(POIFSBigBlockSize bigBlockSize, ListManagedBlock[] blocks, BlockList raw_block_list) : this(bigBlockSize) { SetEntries(blocks, raw_block_list); }
/// <summary> /// Initializes a new instance of the <see cref="BlockAllocationTableReader"/> class. /// </summary> public BlockAllocationTableReader(POIFSBigBlockSize bigBlockSize) { this.bigBlockSize = bigBlockSize; _entries = new List<int>(); }
/// <summary> /// Create a single instance initialized with data. /// </summary> /// <param name="stream">the InputStream delivering the data.</param> /// <param name="bigBlockSize">the poifs bigBlockSize</param> public DocumentBlock(Stream stream, POIFSBigBlockSize bigBlockSize) : this(bigBlockSize) { int count = IOUtils.ReadFully(stream, _data); _bytes_Read = (count == -1) ? 0: count; }
public DocumentBlock(POIFSBigBlockSize bigBlockSize) :base(bigBlockSize) { _data = new byte[POIFSConstants.BIG_BLOCK_SIZE]; Arrays.Fill(_data, _default_value); }
public POIFSDocument(string name, SmallDocumentBlock[] blocks, int length) { _size = length; if(blocks.Length == 0) _bigBigBlockSize = POIFSConstants.SMALLER_BIG_BLOCK_SIZE_DETAILS; else _bigBigBlockSize = blocks[0].BigBlockSize; _big_store = new BigBlockStore(_bigBigBlockSize, EMPTY_BIG_BLOCK_ARRAY); _property = new DocumentProperty(name, _size); _small_store = new SmallBlockStore(_bigBigBlockSize, blocks); _property.Document = this; }
/// <summary> /// convert a single long array into an array of DocumentBlock /// instances /// </summary> /// <param name="bigBlockSize">the poifs bigBlockSize</param> /// <param name="array">the byte array to be converted</param> /// <param name="size">the intended size of the array (which may be smaller)</param> /// <returns>an array of DocumentBlock instances, filled from the /// input array</returns> public static DocumentBlock[] Convert(POIFSBigBlockSize bigBlockSize, byte[] array, int size) { DocumentBlock[] rval = new DocumentBlock[(size + POIFSConstants.BIG_BLOCK_SIZE - 1) / POIFSConstants.BIG_BLOCK_SIZE]; int offset = 0; for (int k = 0; k < rval.Length; k++) { rval[k] = new DocumentBlock(bigBlockSize); if (offset < array.Length) { int length = Math.Min(POIFSConstants.BIG_BLOCK_SIZE, array.Length - offset); Array.Copy(array, offset, rval[k]._data, 0, length); if (length != POIFSConstants.BIG_BLOCK_SIZE) { for (int j = (length > 0) ? (length - 1) : length; j < POIFSConstants.BIG_BLOCK_SIZE; j++) { rval[k]._data[j] = _default_value; } } } else { for (int j = 0; j < rval[k]._data.Length; j++) { rval[k]._data[j] = _default_value; } } offset += POIFSConstants.BIG_BLOCK_SIZE; } return rval; }
internal BigBlockStore(POIFSBigBlockSize bigBlockSize, POIFSDocumentPath path, string name, int size, POIFSWriterListener writer) { this.bigBlockSize = bigBlockSize; this.bigBlocks = new DocumentBlock[0]; this.path = path; this.name = name; this.size = size; this.writer = writer; }
public void PrivateHeaderBlock(byte[] data) { _data = data; long signature = LittleEndian.GetLong(_data, _signature_offset); if (signature != _signature) { byte[] OOXML_FILE_HEADER = POIFSConstants.OOXML_FILE_HEADER; if (_data[0] == OOXML_FILE_HEADER[0] && _data[1] == OOXML_FILE_HEADER[1] && _data[2] == OOXML_FILE_HEADER[2] && _data[3] == OOXML_FILE_HEADER[3]) { throw new OfficeXmlFileException("The supplied data appears to be in the Office 2007+ XML. You are calling the part of POI that deals with OLE2 Office Documents. You need to call a different part of POI to process this data (eg XSSF instead of HSSF)"); } if (_data[0] == 0x09 && _data[1] == 0x00 && // sid=0x0009 _data[2] == 0x04 && _data[3] == 0x00 && // size=0x0004 _data[4] == 0x00 && _data[5] == 0x00 && // unused (_data[6] == 0x10 || _data[6] == 0x20 || _data[6] == 0x40) && _data[7] == 0x00) { // BIFF2 raw stream throw new OldExcelFormatException("The supplied data appears to be in BIFF2 format. " + "HSSF only supports the BIFF8 format, try OldExcelExtractor"); } if (_data[0] == 0x09 && _data[1] == 0x02 && // sid=0x0209 _data[2] == 0x06 && _data[3] == 0x00 && // size=0x0006 _data[4] == 0x00 && _data[5] == 0x00 && // unused (_data[6] == 0x10 || _data[6] == 0x20 || _data[6] == 0x40) && _data[7] == 0x00) { // BIFF3 raw stream throw new OldExcelFormatException("The supplied data appears to be in BIFF3 format. " + "HSSF only supports the BIFF8 format, try OldExcelExtractor"); } if (_data[0] == 0x09 && _data[1] == 0x04 && // sid=0x0409 _data[2] == 0x06 && _data[3] == 0x00 && // size=0x0006 _data[4] == 0x00 && _data[5] == 0x00) { // unused if (((_data[6] == 0x10 || _data[6] == 0x20 || _data[6] == 0x40) && _data[7] == 0x00) || (_data[6] == 0x00 && _data[7] == 0x01)) { // BIFF4 raw stream throw new OldExcelFormatException("The supplied data appears to be in BIFF4 format. " + "HSSF only supports the BIFF8 format, try OldExcelExtractor"); } } // Give a generic error if the OLE2 signature isn't found throw new NotOLE2FileException("Invalid header signature; read " + LongToHex(signature) + ", expected " + LongToHex(_signature) + " - Your file appears " + "not to be a valid OLE2 document"); } if (_data[30] == 12) { bigBlockSize = POIFSConstants.LARGER_BIG_BLOCK_SIZE_DETAILS; } else if (_data[30] == 9) { bigBlockSize = POIFSConstants.SMALLER_BIG_BLOCK_SIZE_DETAILS; } else { throw new IOException("Unsupported blocksize (2^" + _data[30] + "). Expected 2^9 or 2^12."); } // Setup the fields to read and write the counts and starts _bat_count = new IntegerField(HeaderBlockConstants._bat_count_offset, _data).Value; _property_start = new IntegerField(HeaderBlockConstants._property_start_offset, _data).Value; _sbat_start = new IntegerField(HeaderBlockConstants._sbat_start_offset, _data).Value; _sbat_count = new IntegerField(HeaderBlockConstants._sbat_block_count_offset, _data).Value; _xbat_start = new IntegerField(HeaderBlockConstants._xbat_start_offset, _data).Value; _xbat_count = new IntegerField(HeaderBlockConstants._xbat_count_offset, _data).Value; }
internal BigBlockStore(POIFSBigBlockSize bigBlockSize, DocumentBlock[] blocks) { this.bigBlockSize = bigBlockSize; bigBlocks = (DocumentBlock[])blocks.Clone(); path = null; name = null; size = -1; writer = null; }
internal SmallBlockStore(POIFSBigBlockSize bigBlockSize, SmallDocumentBlock[] blocks) { this.bigBlockSize = bigBlockSize; smallBlocks = (SmallDocumentBlock[])blocks.Clone(); this.path = null; this.name = null; this.size = -1; this.writer = null; }
public NPropertyTable(HeaderBlock headerBlock) : base(headerBlock) { _bigBigBlockSize = headerBlock.BigBlockSize; }
public void PrivateHeaderBlock(byte[] data) { _data = data; long signature = LittleEndian.GetLong(_data, _signature_offset); if (signature != _signature) { byte[] OOXML_FILE_HEADER = POIFSConstants.OOXML_FILE_HEADER; if (_data[0] == OOXML_FILE_HEADER[0] && _data[1] == OOXML_FILE_HEADER[1] && _data[2] == OOXML_FILE_HEADER[2] && _data[3] == OOXML_FILE_HEADER[3]) { throw new OfficeXmlFileException("The supplied data appears to be in the Office 2007+ XML. You are calling the part of POI that deals with OLE2 Office Documents. You need to call a different part of POI to process this data (eg XSSF instead of HSSF)"); } if ((signature & unchecked((long)0xFF8FFFFFFFFFFFFFL)) == 0x0010000200040009L) { throw new ArgumentException("The supplied data appears to be in BIFF2 format. " + "POI only supports BIFF8 format"); } throw new IOException("Invalid header signature; read " + LongToHex(signature) + ", expected " + LongToHex(_signature)); } if (_data[30] == 12) { bigBlockSize = POIFSConstants.LARGER_BIG_BLOCK_SIZE_DETAILS; } else if (_data[30] == 9) { bigBlockSize = POIFSConstants.SMALLER_BIG_BLOCK_SIZE_DETAILS; } else { throw new IOException("Unsupported blocksize (2^" + _data[30] + "). Expected 2^9 or 2^12."); } // Setup the fields to read and write the counts and starts _bat_count = new IntegerField(HeaderBlockConstants._bat_count_offset, _data).Value; _property_start = new IntegerField(HeaderBlockConstants._property_start_offset, _data).Value; _sbat_start = new IntegerField(HeaderBlockConstants._sbat_start_offset, _data).Value; _sbat_count = new IntegerField(HeaderBlockConstants._sbat_block_count_offset, _data).Value; _xbat_start = new IntegerField(HeaderBlockConstants._xbat_start_offset, _data).Value; _xbat_count = new IntegerField(HeaderBlockConstants._xbat_count_offset, _data).Value; }
public POIFSDocument(string name, POIFSBigBlockSize bigBlockSize, ListManagedBlock[] blocks, int length) { _size = length; _bigBigBlockSize = bigBlockSize; _property = new DocumentProperty(name, _size); _property.Document = this; if (Property.IsSmall(_size)) { _big_store = new BigBlockStore(bigBlockSize, EMPTY_BIG_BLOCK_ARRAY); _small_store = new SmallBlockStore(bigBlockSize, ConvertRawBlocksToSmallBlocks(blocks)); } else { _big_store = new BigBlockStore(bigBlockSize, ConvertRawBlocksToBigBlocks(blocks)); _small_store = new SmallBlockStore(bigBlockSize, EMPTY_SMALL_BLOCK_ARRAY); } }
public HeaderBlock(POIFSBigBlockSize bigBlockSize) { this.bigBlockSize = bigBlockSize; _data = new byte[POIFSConstants.SMALLER_BIG_BLOCK_SIZE]; //fill the array. for (int i = 0; i < _data.Length; i++) _data[i] = _default_value; new LongField(_signature_offset, _signature, _data); new IntegerField(0x08, 0, _data); new IntegerField(0x0c, 0, _data); new IntegerField(0x10, 0, _data); new IntegerField(0x14, 0, _data); new ShortField((int)0x18, (short)0x3b, ref _data); new ShortField((int)0x1a, (short)0x3, ref _data); new ShortField((int)0x1c, (short)-2, ref _data); new ShortField(0x1e, bigBlockSize.GetHeaderValue(), ref _data); new IntegerField(0x20, 0x6, _data); new IntegerField(0x24, 0, _data); new IntegerField(0x28, 0, _data); new IntegerField(0x34, 0, _data); new IntegerField(0x38, 0x1000, _data); _bat_count = 0; _sbat_count = 0; _xbat_count = 0; _property_start = POIFSConstants.END_OF_CHAIN; _sbat_start = POIFSConstants.END_OF_CHAIN; _xbat_start = POIFSConstants.END_OF_CHAIN; }
public POIFSDocument(string name, int size, POIFSBigBlockSize bigBlockSize, POIFSDocumentPath path, POIFSWriterListener writer) { _size = size; _bigBigBlockSize = bigBlockSize; _property = new DocumentProperty(name, _size); _property.Document = this; if (_property.ShouldUseSmallBlocks) { _small_store = new SmallBlockStore(_bigBigBlockSize, path, name, size, writer); _big_store = new BigBlockStore(_bigBigBlockSize, EMPTY_BIG_BLOCK_ARRAY); } else { _small_store = new SmallBlockStore(_bigBigBlockSize, EMPTY_SMALL_BLOCK_ARRAY); _big_store = new BigBlockStore(_bigBigBlockSize, path, name, size, writer); } }