void UCOMIStream.CopyTo(UCOMIStream destination, long count, IntPtr pcbRead, IntPtr pcbWritten)
{
//////////
// Copy the lot using 4k chunks
//////////
byte [] _buffer = new byte[4096];
int _cbRead = 0;
int _cbWritten = 0;
while (count > 0)
{
int _chunk = (int)Math.Min(count, _buffer.Length);
int _chunkRead = this.Read(_buffer, _cbRead, _chunk);
destination.Write(_buffer, _chunk, IntPtr.Zero);
_cbRead += _chunkRead;
_cbWritten += _chunkRead;
}
//////////
// Update the counts, if they were provided
//////////
if (pcbRead != IntPtr.Zero)
{
Marshal.WriteInt64(pcbRead, _cbRead);
}
if (pcbWritten != IntPtr.Zero)
{
Marshal.WriteInt64(pcbWritten, _cbWritten);
}
}
void foo(UCOMIStream iStream)
{
// Load the Encrypted file into a stream.
FileStream fsIn = new FileStream("C:\\test.pdf", FileMode.Open, FileAccess.Read);
// Create a MemoryStream to hold the decrypted data.
MemoryStream ms = new MemoryStream();
// Create a reader for the data.
BinaryReader r = new BinaryReader(ms);
// Get length of the file.
int fileLen = Convert.ToInt32(ms.Length);
// Create a buffer for the data.
byte[] fileBytes = new byte[fileLen];
// Read the data from Memory
for (int i = 0; i < fileLen; i++)
{
fileBytes[i] = r.ReadByte();
}
// declare the COM stream
//UCOMIStream iStream;
// Write the data from buffer into COM Stream
iStream.Write(fileBytes, fileLen, System.IntPtr.Zero);
// Set size of COM stream
iStream.SetSize(fileLen);
}
void UCOMIStream.CopyTo(UCOMIStream destination, long count, IntPtr pcbRead, IntPtr pcbWritten)
{
//////////
// Copy the lot using 4k chunks
//////////
byte [] _buffer = new byte[4096];
int _cbRead = 0;
int _cbWritten = 0;
while (count > 0)
{
int _chunk = (int)Math.Min(count, _buffer.Length);
int _chunkRead = this.Read(_buffer, _cbRead, _chunk);
destination.Write(_buffer, _chunk, IntPtr.Zero);
_cbRead += _chunkRead;
_cbWritten += _chunkRead;
}
//////////
// Update the counts, if they were provided
//////////
if (pcbRead != IntPtr.Zero)
{
Marshal.WriteInt64(pcbRead, _cbRead);
}
if (pcbWritten != IntPtr.Zero)
{
Marshal.WriteInt64(pcbWritten, _cbWritten);
}
}
public static void LoadGraphFile(IGraphBuilder graphBuilder, string fileName)
{
int hr = 0;
IStorage storage = null;
#if USING_NET11
UCOMIStream stream = null;
#else
IStream stream = null;
#endif
if (graphBuilder == null)
{
throw new ArgumentNullException("graphBuilder");
}
try
{
if (NativeMethods.StgIsStorageFile(fileName) != 0)
{
throw new ArgumentException(fileName);
}
hr = NativeMethods.StgOpenStorage(
fileName,
null,
STGM.Transacted | STGM.Read | STGM.ShareDenyWrite,
IntPtr.Zero,
0,
out storage
);
Marshal.ThrowExceptionForHR(hr);
hr = storage.OpenStream(
@"ActiveMovieGraph",
IntPtr.Zero,
STGM.Read | STGM.ShareExclusive,
0,
out stream
);
Marshal.ThrowExceptionForHR(hr);
hr = (graphBuilder as IPersistStream).Load(stream);
Marshal.ThrowExceptionForHR(hr);
}
finally
{
if (stream != null)
{
Marshal.ReleaseComObject(stream);
}
if (storage != null)
{
Marshal.ReleaseComObject(storage);
}
}
}
/// <summary>
/// Enumerates an Interop.IStorage object and creates the internal file object collection
/// </summary>
/// <param name="BasePath">Sets the base url for the storage files</param>
/// <param name="enumStorage">storage to enumerate</param>
protected void EnumIStorageObject(Interop.IStorage enumStorage, string BasePath)
{
Interop.IEnumSTATSTG iEnumSTATSTG;
STATSTG sTATSTG;
int i;
enumStorage.EnumElements(0, IntPtr.Zero, 0, out iEnumSTATSTG);
iEnumSTATSTG.Reset();
while (iEnumSTATSTG.Next(1, out sTATSTG, out i) == (int)Interop.S_OK)
{
if (i == 0)
{
break;
}
FileObject newFileObj = new FileObject();
newFileObj.FileType = sTATSTG.type;
switch (sTATSTG.type)
{
case 1:
Interop.IStorage iStorage = enumStorage.OpenStorage(sTATSTG.pwcsName, IntPtr.Zero, 16, IntPtr.Zero, 0);
if (iStorage != null)
{
string str = String.Concat(BasePath, sTATSTG.pwcsName.ToString());
newFileObj.FileStorage = iStorage;
newFileObj.FilePath = BasePath;
newFileObj.FileName = sTATSTG.pwcsName.ToString();
foCollection.Add(newFileObj);
EnumIStorageObject(iStorage, str);
}
break;
case 2:
UCOMIStream uCOMIStream = enumStorage.OpenStream(sTATSTG.pwcsName, IntPtr.Zero, 16, 0);
newFileObj.FilePath = BasePath;
newFileObj.FileName = sTATSTG.pwcsName.ToString();
newFileObj.FileStream = uCOMIStream;
foCollection.Add(newFileObj);
break;
case 4:
Trace.WriteLine("Ignoring IProperty type ...");
break;
case 3:
Trace.WriteLine("Ignoring ILockBytes type ...");
break;
default:
Trace.WriteLine("Unknown object type ...");
break;
}
}
}
/// <summary>
/// Closes the storage stream
/// </summary>
public override void Close()
{
if (fileStream != null)
{
fileStream.Commit(0);
Marshal.ReleaseComObject(fileStream);
fileStream = null;
GC.SuppressFinalize(this);
}
}
public static void SaveGraphFile(IGraphBuilder graphBuilder, string fileName)
{
int hr = 0;
IStorage storage = null;
#if USING_NET11
UCOMIStream stream = null;
#else
IStream stream = null;
#endif
if (graphBuilder == null)
{
throw new ArgumentNullException("graphBuilder");
}
try
{
hr = NativeMethods.StgCreateDocfile(
fileName,
STGM.Create | STGM.Transacted | STGM.ReadWrite | STGM.ShareExclusive,
0,
out storage
);
Marshal.ThrowExceptionForHR(hr);
hr = storage.CreateStream(
@"ActiveMovieGraph",
STGM.Write | STGM.Create | STGM.ShareExclusive,
0,
0,
out stream
);
Marshal.ThrowExceptionForHR(hr);
hr = (graphBuilder as IPersistStream).Save(stream, true);
Marshal.ThrowExceptionForHR(hr);
hr = storage.Commit(STGC.Default);
Marshal.ThrowExceptionForHR(hr);
}
finally
{
if (stream != null)
{
Marshal.ReleaseComObject(stream);
}
if (storage != null)
{
Marshal.ReleaseComObject(storage);
}
}
}
protected void Dispose(bool isDisposing)
{
if (_Stream != null)
{
if (isDisposing)
{
_Stream.Commit(0);
}
Marshal.ReleaseComObject(_Stream);
_Stream = null;
}
}
// Not used - But there are things here that may be useful some day
#if false
void TestSave2()
{
int hr;
UCOMIStream uis = null;
long siz;
hr = m_ips.GetSizeMax(out siz);
myIStorage iStore = null;
hr = StgCreateDocfile(@"C:\foo.out",
//STGM.DIRECT|STGM.CREATE|STGM.READWRITE|STGM.SHARE_EXCLUSIVE,
STGM.CREATE | STGM.WRITE | STGM.SHARE_EXCLUSIVE,
0,
ref iStore);
DsError.ThrowExceptionForHR(hr);
uis = iStore as UCOMIStream;
//hr = iStore.CreateStream("asdf", STGM.DIRECT|STGM.CREATE|STGM.READWRITE|STGM.SHARE_EXCLUSIVE, 0, 0, out uis);
hr = iStore.CreateStream("asdf", STGM.CREATE | STGM.WRITE | STGM.SHARE_EXCLUSIVE, 0, 0, out uis);
hr = OleSaveToStream(m_ips, uis);
hr = StgCreateStorageEx(@"c:\foo.out",
(STGM)0,
(STGFMT)0,
0,
IntPtr.Zero,
IntPtr.Zero,
typeof(myIStorage).GUID,
ref iStore);
DsError.ThrowExceptionForHR(hr);
string s = typeof(UCOMIStream).GUID.ToString();
// Create the stream (with no initial memory allocated)
IntPtr ip = Marshal.AllocCoTaskMem((int)siz);
ip = GlobalAlloc(0, (int)siz);
hr = CreateStreamOnHGlobal(ip, false, out uis);
//uis.SetSize(siz * 2);
byte[] b = new byte[3];
b[0] = 65;
b[1] = 66;
b[2] = 67;
uis.Write(b, b.Length, IntPtr.Zero);
hr = m_ips.Save(uis, true);
DsError.ThrowExceptionForHR(hr);
}
/// <summary>
/// Opens an UCOMIStream and returns the associated file object
/// </summary>
/// <param name="parentStorage">storage used to open the stream</param>
/// <param name="fileName">filename of the stream</param>
/// <returns>A <see cref="FileObject">FileObject</see> instance if the file was found, otherwise null.</returns>
public FileObject OpenUCOMStream(Interop.IStorage parentStorage, string fileName)
{
if (parentStorage == null)
{
parentStorage = storage;
}
FileObject retObject = null;
STATSTG sTATSTG;
sTATSTG.pwcsName = fileName;
sTATSTG.type = 2;
try
{
retObject = new FileObject();
UCOMIStream uCOMIStream = parentStorage.OpenStream(sTATSTG.pwcsName, IntPtr.Zero, 16, 0);
if (uCOMIStream != null)
{
retObject.FileType = sTATSTG.type;
retObject.FilePath = "";
retObject.FileName = sTATSTG.pwcsName.ToString();
retObject.FileStream = uCOMIStream;
}
else
{
retObject = null;
}
}
catch (Exception ex)
{
retObject = null;
Trace.WriteLine("ITStorageWrapper.OpenUCOMStream() - Failed for file '" + fileName + "'");
Trace.Indent();
Trace.WriteLine("Exception: " + ex.Message);
Trace.Unindent();
}
return(retObject);
}
/// <summary>
/// Called to save the settings data to the given stream.
/// </summary>
/// <param name="stm">stream to save the settings to</param>
/// <param name="clearDirty">if true, clear our 'dirty' flag</param>
public void Save(UCOMIStream stm, bool clearDirty)
{
MemoryStream memStream = new MemoryStream();
BinaryWriter binWriter = new BinaryWriter(memStream);
// first our version
binWriter.Write(dataVersion);
// then the data.
binWriter.Write(itemStart);
// cleanup
binWriter.Flush();
// write to actual output stream
byte[] data = memStream.ToArray();
stm.Write(data, data.Length, IntPtr.Zero);
if (clearDirty)
{
isDirty = false;
}
}
/// <summary>
/// Called to read the settings data from the given stream.
/// </summary>
/// <param name="stm">stream from which the settings can be read</param>
public void Load(UCOMIStream stm)
{
const int maxDataLen = 1000; // read a large enough number of bytes for us.
byte[] data = new byte[maxDataLen];
stm.Read(data, data.Length, IntPtr.Zero);
MemoryStream memStream = new MemoryStream(data);
BinaryReader binReader = new BinaryReader(memStream);
int version = binReader.ReadInt32();
if (version != dataVersion)
{
MessageBox.Show("Invalid data version, using default values");
}
else
{
// valid version, continue reading data.
itemStart = binReader.ReadInt32();
}
Initialize();
}
static extern int CreateStreamOnHGlobal(IntPtr hGlobal, bool fDeleteOnRelease, out UCOMIStream ppstm);
private static extern int GdipLoadImageFromStream(UCOMIStream istream, out IntPtr image);
public void Clone(out UCOMIStream ppstm)
{
throw new NotImplementedException();
}
public void CopyTo(UCOMIStream pstm, long cb, IntPtr pcbRead, IntPtr pcbWritten)
{
throw new NotImplementedException();
}
public OleStream(UCOMIStream stream, string name)
{
_Stream = stream;
_Name = name;
}
private static extern int BindIFilterFromStream(UCOMIStream pStm,
[MarshalAs(UnmanagedType.IUnknown)] object pUnkOuter,
[Out] out IFilter ppIUnk);
public void CopyTo(UCOMIStream pstm, long cb, IntPtr pcbRead, IntPtr pcbWritten)
{
throw new NotImplementedException();
}
/// <summary>
/// Called to save the settings data to the given stream.
/// </summary>
/// <param name="stm">stream to save the settings to</param>
/// <param name="clearDirty">if true, clear our 'dirty' flag</param>
public void Save(UCOMIStream stm, bool clearDirty)
{
try
{
MemoryStream memStream = new MemoryStream();
BinaryWriter binWriter = new BinaryWriter(memStream);
// first our version
binWriter.Write(dataVersion);
// then the data.
// cleanup
binWriter.Flush();
// write to actual output stream
byte[] data = memStream.ToArray();
stm.Write(data, data.Length, IntPtr.Zero);
if (clearDirty)
isDirty = false;
}
catch (Exception E)
{
Log.Error("Save Error "+E.Message);
}
}
/// <summary>
/// Called to read the settings data from the given stream.
/// </summary>
/// <param name="stm">stream from which the settings can be read</param>
public void Load(UCOMIStream stm)
{
Log.Debug("Called Load()");
try
{
const int maxDataLen = 1000; // read a large enough number of bytes for us.
byte[] data = new byte[maxDataLen];
stm.Read(data, data.Length, IntPtr.Zero);
MemoryStream memStream = new MemoryStream(data);
BinaryReader binReader = new BinaryReader(memStream);
int version = binReader.ReadInt32();
if (version != dataVersion)
{
// MessageBox.Show("Invalid data version, using default values");
}
else
{
// valid version, continue reading data.
}
}
catch (Exception E)
{
Log.Error("Load Error"+E.Message);
}
Initialize();
}
public void LoadDocument(String documentVal)
{
if ((documentVal != string.Empty) | (!this.bLoadDocumentWhenReady))
{
//if doc is waiting to load, it is already in string variable
sDocument = documentVal;
this.bLoadDocumentWhenReady = false;
}
else
{
this.bLoadDocumentWhenReady = false;
this.iLoadAttempts += 1;
}
if (!IsCreated)
{
throw new HtmlEditorException("Document not created");
}
if ((this.m_htmldoc.readyState.ToLower() != "complete") & (this.m_htmldoc.readyState.ToLower() != "interactive"))
//try to load on interactive as well as complete
{
if (iLoadAttempts < 2)
{
this.bLoadDocumentWhenReady = true;
return;
}
else
{
throw new HtmlEditorException("Document not ready");
}
}
if ((sDocument == null) || (sDocument == String.Empty))
{
sDocument = "<html><body></body></html>";
}
UCOMIStream stream = null;
if (this.mIsWin98 | this.mAlwaysLoadAnsi)
{
ComSupport.CreateStreamOnHGlobal(Marshal.StringToHGlobalAnsi(sDocument), 1, out
stream);
}
else
{
ComSupport.CreateStreamOnHGlobal(Marshal.StringToHGlobalUni(sDocument), 1, out
stream);
}
if (stream == null)
{
throw new HtmlEditorException("Could not allocate document stream");
}
if (this.mIsWin98)
{
//This code fixes a problem in Win98 - Framework bug? - where the string
//is sometimes incorrectly terminated
//It assumes an ANSI string
ulong thesize = 0;
IntPtr ptr = IntPtr.Zero;
int iSizeOfIntPtr = Marshal.SizeOf(typeof(Int64));
ptr = Marshal.AllocHGlobal(iSizeOfIntPtr);
if (ptr == IntPtr.Zero)
{
throw new HtmlEditorException("Could not load document");
}
//seek to end of stream
stream.Seek(0, 2, ptr);
//read the size
thesize = (ulong)Marshal.ReadInt64(ptr);
//free the pointer
Marshal.FreeHGlobal(ptr);
//2nd param, 0 is beginning, 1 is current, 2 is end
if (thesize != (ulong)sDocument.Length + 1)
{
//fix the size by truncating the stream
Debug.Assert(true, "Size of stream is unexpected", "The size of the stream is not equal to the length of the string passed to it.");
stream.SetSize((sDocument.Length) + 1);
}
}
//set stream to start
stream.Seek(0, 0, IntPtr.Zero);
IPersistStreamInit persistentStreamInit = (IPersistStreamInit)
this.m_htmldoc;
if (persistentStreamInit != null)
{
int iRetVal = 0;
iRetVal = persistentStreamInit.InitNew();
if (iRetVal == HRESULT.S_OK)
{
//this is a fix for exception raised in UpdateUI
site.mFullyActive = false;
iRetVal = persistentStreamInit.Load(stream);
if (iRetVal != HRESULT.S_OK)
{
throw new HtmlEditorException("Could not load document");
}
}
else
{
throw new HtmlEditorException("Could not load document");
}
persistentStreamInit = null;
}
else
{
throw new HtmlEditorException("Could not load document");
}
stream = null;
this.iLoadAttempts = 0;
}
public void Clone(out UCOMIStream ppstm)
{
throw new NotImplementedException();
}
/// <summary>
/// Called to read the settings data from the given stream.
/// </summary>
/// <param name="stm">stream from which the settings can be read</param>
public void Load(UCOMIStream stm)
{
const int maxDataLen = 1000; // read a large enough number of bytes for us.
byte[] data = new byte[maxDataLen];
stm.Read(data, data.Length, IntPtr.Zero);
MemoryStream memStream = new MemoryStream(data);
BinaryReader binReader = new BinaryReader(memStream);
int version = binReader.ReadInt32();
if (version != dataVersion) {
MessageBox.Show("Invalid data version, using default values");
} else {
// valid version, continue reading data.
itemStart = binReader.ReadInt32();
}
Initialize();
}
void UCOMIStream.Clone(out UCOMIStream clone)
{
clone = this.MemberwiseClone() as UCOMIStream;
}
/// <summary>
/// Called to save the settings data to the given stream.
/// </summary>
/// <param name="stm">stream to save the settings to</param>
/// <param name="clearDirty">if true, clear our 'dirty' flag</param>
public void Save(UCOMIStream stm, bool clearDirty)
{
MemoryStream memStream = new MemoryStream();
BinaryWriter binWriter = new BinaryWriter(memStream);
// first our version
binWriter.Write(dataVersion);
// then the data.
binWriter.Write(itemStart);
// cleanup
binWriter.Flush();
// write to actual output stream
byte[] data = memStream.ToArray();
stm.Write(data, data.Length, IntPtr.Zero);
if (clearDirty)
isDirty = false;
}
private static extern int OleSaveToStream(
IPersistStream pPStm, //Pointer to the interface on the object
// to be saved
UCOMIStream pStm //Pointer to the destination stream to
// which the object is saved
);
/// <summary>
/// Closes the storage stream
/// </summary>
public override void Close()
{
if (fileStream != null)
{
fileStream.Commit(0);
Marshal.ReleaseComObject(fileStream);
fileStream = null;
GC.SuppressFinalize(this);
}
}
void UCOMIStream.Clone(out UCOMIStream clone)
{
clone = this.MemberwiseClone() as UCOMIStream;
}
