using System;
|
using System.Collections.Generic;
|
using System.Text;
|
using System.IO;
|
using QiHe.CodeLib;
|
|
namespace HH.WMS.Utils.ExcelLibrary.CompoundDocumentFormat
|
{
|
public partial class CompoundDocument : IDisposable
|
{
|
internal FileHeader Header;
|
internal int SectorSize;
|
internal int ShortSectorSize;
|
private int TotalSectors;
|
internal MasterSectorAllocation MasterSectorAllocation;
|
internal SectorAllocation SectorAllocation;
|
internal ShortSectorAllocation ShortSectorAllocation;
|
|
private MemoryStream ShortStreamContainer;
|
private MemoryStream DirectoryStream;
|
private Dictionary<int, DirectoryEntry> DirectoryEntries;
|
|
public DirectoryEntry RootStorage
|
{
|
get { return DirectoryEntries[0]; }
|
}
|
|
internal Stream FileStorage;
|
private BinaryReader Reader;
|
private BinaryWriter Writer;
|
|
internal CompoundDocument(Stream stream, FileHeader header)
|
{
|
this.FileStorage = stream;
|
this.Reader = new BinaryReader(this.FileStorage);
|
if (stream.CanWrite)
|
{
|
this.Writer = new BinaryWriter(this.FileStorage, Encoding.Unicode);
|
}
|
|
this.Header = header;
|
this.SectorSize = (int)Math.Pow(2, Header.SectorSizeInPot);
|
this.ShortSectorSize = (int)Math.Pow(2, Header.ShortSectorSizeInPot);
|
this.TotalSectors = stream.Length == 0 ? 0
|
: (int)(stream.Length - 512) / this.SectorSize;
|
|
this.MasterSectorAllocation = new MasterSectorAllocation(this);
|
this.SectorAllocation = new SectorAllocation(this);
|
this.ShortSectorAllocation = new ShortSectorAllocation(this);
|
}
|
|
public static CompoundDocument Create(string file)
|
{
|
FileStream stream = File.Open(file, FileMode.Create, FileAccess.ReadWrite, FileShare.Read);
|
return Create(stream);
|
}
|
|
public static CompoundDocument Open(string file)
|
{
|
FileStream stream = File.Open(file, FileMode.Open, FileAccess.ReadWrite, FileShare.Read);
|
return Open(stream);
|
}
|
|
public static CompoundDocument Create(Stream stream)
|
{
|
CompoundDocument document = new CompoundDocument(stream, new CompoundFileHeader());
|
document.WriteHeader();
|
document.MasterSectorAllocation.AllocateSATSector();
|
document.InitializeDirectoryEntries();
|
return document;
|
}
|
|
public static CompoundDocument Open(Stream stream)
|
{
|
BinaryReader reader = new BinaryReader(stream);
|
FileHeader header = ReadHeader(reader);
|
|
CompoundDocument document = new CompoundDocument(stream, header);
|
if (!document.CheckHeader()) return null;
|
|
document.ReadDirectoryEntries();
|
|
return document;
|
}
|
|
public void Save()
|
{
|
SaveDirectoryEntries();
|
SaveShortStreams();
|
WriteHeader();
|
Writer.Flush();
|
}
|
|
public void Close()
|
{
|
Dispose();
|
}
|
|
public void Dispose()
|
{
|
Dispose(true);
|
GC.SuppressFinalize(this);
|
}
|
|
~CompoundDocument()
|
{
|
Dispose(false);
|
}
|
|
bool disposed = false;
|
protected virtual void Dispose(bool disposing)
|
{
|
if (disposed) { return; }
|
|
if (disposing)
|
{
|
if (FileStorage != null)
|
{
|
FileStorage.Close();
|
FileStorage = null;
|
}
|
}
|
|
disposed = true;
|
}
|
|
bool CheckHeader()
|
{
|
if (!ArrayEqual(Header.FileTypeIdentifier, CompoundFileHeader.FileTypeIdentifier)) throw new Exception("File header not recognized.");
|
if (!ArrayEqual(Header.ByteOrderMark, ByteOrderMarks.LittleEndian)) throw new Exception("Endian not implemented.");
|
return true;
|
}
|
|
void InitializeDirectoryEntries()
|
{
|
Header.FirstSectorIDofDirectoryStream = AllocateDataSector();
|
DirectoryEntries = new Dictionary<int, DirectoryEntry>();
|
DirectoryEntry root = new DirectoryEntry(this, "Root Entry");
|
root.EntryType = EntryType.Root;
|
root.NodeColor = NodeColor.Black;
|
root.FirstSectorID = AllocateDataSector();
|
root.StreamLength = 0;
|
DirectoryEntries.Add(0, root);
|
DirectoryStream = new MemoryStream();
|
ShortStreamContainer = new MemoryStream();
|
}
|
|
void SaveDirectoryEntries()
|
{
|
DirectoryTree.Build(RootStorage);
|
DirectoryStream.Position = 0;
|
BinaryWriter writer = new BinaryWriter(DirectoryStream, Encoding.Unicode);
|
for (int id = 0; id < DirectoryEntries.Count; id++)
|
{
|
WriteDirectoryEntry(writer, DirectoryEntries[id]);
|
}
|
WriteStreamData(Header.FirstSectorIDofDirectoryStream, DirectoryStream.ToArray());
|
}
|
|
void SaveShortStreams()
|
{
|
ShortSectorAllocation.Save();
|
WriteStreamData(RootStorage.FirstSectorID, ShortStreamContainer.ToArray());
|
}
|
|
internal int ReadInt32(long position)
|
{
|
FileStorage.Position = position;
|
return Reader.ReadInt32();
|
}
|
|
internal int ReadInt32InSector(int secID, int position)
|
{
|
int offset = GetSectorOffset(secID);
|
FileStorage.Position = offset + position;
|
return Reader.ReadInt32();
|
}
|
|
internal void Write(long position, int integer)
|
{
|
FileStorage.Position = position;
|
Writer.Write(integer);
|
}
|
|
internal void WriteInSector(int secID, int position, int integer)
|
{
|
int offset = GetSectorOffset(secID);
|
FileStorage.Position = offset + position;
|
Writer.Write(integer);
|
}
|
|
internal void WriteInSector(int secID, int position, int[] integers)
|
{
|
int offset = GetSectorOffset(secID);
|
FileStorage.Position = offset + position;
|
WriteArrayOfInt32(Writer, integers);
|
}
|
|
internal void WriteInSector(int secID, int position, byte[] data, int index, int count)
|
{
|
int offset = GetSectorOffset(secID);
|
FileStorage.Position = offset + position;
|
Writer.Write(data, index, count);
|
}
|
|
internal int AllocateNewSector()
|
{
|
int secID = TotalSectors;
|
FileStorage.Position = GetSectorOffset(secID);
|
Writer.Write(new byte[SectorSize]);
|
TotalSectors++;
|
return secID;
|
}
|
|
internal int AllocateDataSector()
|
{
|
return this.SectorAllocation.AllocateSector();
|
}
|
|
internal int AllocateDataSectorAfter(int sectorID)
|
{
|
int newSectorID = this.SectorAllocation.AllocateSector();
|
this.SectorAllocation.LinkSectorID(sectorID, newSectorID);
|
return newSectorID;
|
}
|
|
internal int AllocateNewSector(int[] sectorData)
|
{
|
int secID = TotalSectors;
|
FileStorage.Position = GetSectorOffset(secID);
|
WriteArrayOfInt32(Writer, sectorData);
|
TotalSectors++;
|
return secID;
|
}
|
|
internal int AllocateShortSector()
|
{
|
return ShortSectorAllocation.AllocateSector();
|
}
|
|
internal void AllocateNewShortSector()
|
{
|
ShortStreamContainer.Position = ShortStreamContainer.Length;
|
byte[] sidData = new byte[ShortSectorSize];
|
for (int i = 0; i < sidData.Length; i++)
|
{
|
sidData[i] = 0xFF;
|
}
|
ShortStreamContainer.Write(sidData, 0, ShortSectorSize);
|
RootStorage.StreamLength = (int)ShortStreamContainer.Length;
|
}
|
|
internal static Int32[] ReadArrayOfInt32(BinaryReader reader, int count)
|
{
|
Int32[] data = new Int32[count];
|
for (int i = 0; i < data.Length; i++)
|
{
|
data[i] = reader.ReadInt32();
|
}
|
return data;
|
}
|
|
internal static void WriteArrayOfInt32(BinaryWriter writer, Int32[] data)
|
{
|
for (int i = 0; i < data.Length; i++)
|
{
|
writer.Write(data[i]);
|
}
|
}
|
|
public static CompoundDocument CreateFromStream(Stream stream)
|
{
|
CompoundDocument document = new CompoundDocument(stream, new CompoundFileHeader());
|
document.WriteHeader();
|
document.MasterSectorAllocation.AllocateSATSector();
|
document.InitializeDirectoryEntries();
|
return document;
|
}
|
}
|
}
|
