|
// ------------------------------------------------------------------------------
// <auto-generated>
// This code was generated by a tool.
//
// Changes to this file may cause incorrect behavior and will be lost if
// the code is regenerated.
// </auto-generated>
// ------------------------------------------------------------------------------
#pragma warning disable CS1591,CS1573,CS0465,CS0649,CS8019,CS1570,CS1584,CS1658,CS0436,CS8981
using global::System;
using global::System.Diagnostics;
using global::System.Diagnostics.CodeAnalysis;
using global::System.Runtime.CompilerServices;
using global::System.Runtime.InteropServices;
using global::System.Runtime.Versioning;
using winmdroot = global::Windows.Win32;
namespace Windows.Win32
{
namespace System.Com.StructuredStorage
{
[Guid("0000010A-0000-0000-C000-000000000046")]
[SupportedOSPlatform("windows5.0")]
[global::System.CodeDom.Compiler.GeneratedCode("Microsoft.Windows.CsWin32", "0.3.151+58e949951d.RR")]
internal unsafe partial struct IPersistStorage
:IVTable<IPersistStorage,IPersistStorage.Vtbl>,IComIID {
/// <inheritdoc cref="QueryInterface(global::System.Guid*, void**)"/>
internal unsafe winmdroot.Foundation.HRESULT QueryInterface(in global::System.Guid riid, out void* ppvObject)
{
fixed (void** ppvObjectLocal = &ppvObject)
{
fixed (global::System.Guid* riidLocal = &riid)
{
winmdroot.Foundation.HRESULT __result = this.QueryInterface(riidLocal, ppvObjectLocal);
return __result;
}
}
}
public unsafe winmdroot.Foundation.HRESULT QueryInterface(global::System.Guid* riid, void** ppvObject)
{
return ((delegate *unmanaged [Stdcall]<IPersistStorage*,global::System.Guid* ,void** ,winmdroot.Foundation.HRESULT>)lpVtbl[0])((IPersistStorage*)Unsafe.AsPointer(ref this), riid, ppvObject);
}
public uint AddRef()
{
return ((delegate *unmanaged [Stdcall]<IPersistStorage*,uint>)lpVtbl[1])((IPersistStorage*)Unsafe.AsPointer(ref this));
}
public uint Release()
{
return ((delegate *unmanaged [Stdcall]<IPersistStorage*,uint>)lpVtbl[2])((IPersistStorage*)Unsafe.AsPointer(ref this));
}
/// <inheritdoc cref="GetClassID(global::System.Guid*)"/>
internal unsafe void GetClassID(out global::System.Guid pClassID)
{
fixed (global::System.Guid* pClassIDLocal = &pClassID)
{
this.GetClassID(pClassIDLocal);
}
}
[UnmanagedCallersOnly(CallConvs = new []{
typeof(CallConvStdcall)}
)]
private static winmdroot.Foundation.HRESULT GetClassID(IPersistStorage* pThis, global::System.Guid* pClassID)
{
try
{
winmdroot.Foundation.HRESULT __hr = ComHelpers.UnwrapCCW(pThis, out Interface __object);
if (__hr.Failed)
{
return __hr;
}
return __object.GetClassID(pClassID);
}
catch (Exception ex)
{
return (winmdroot.Foundation.HRESULT)ex.HResult;
}
}
public unsafe void GetClassID(global::System.Guid* pClassID)
{
((delegate *unmanaged [Stdcall]<IPersistStorage*,global::System.Guid* ,winmdroot.Foundation.HRESULT>)lpVtbl[3])((IPersistStorage*)Unsafe.AsPointer(ref this), pClassID).ThrowOnFailure();
}
[UnmanagedCallersOnly(CallConvs = new []{
typeof(CallConvStdcall)}
)]
private static winmdroot.Foundation.HRESULT IsDirty(IPersistStorage* pThis)
{
try
{
winmdroot.Foundation.HRESULT __hr = ComHelpers.UnwrapCCW(pThis, out Interface __object);
if (__hr.Failed)
{
return __hr;
}
return __object.IsDirty();
}
catch (Exception ex)
{
return (winmdroot.Foundation.HRESULT)ex.HResult;
}
}
/// <summary>Determines whether an object has changed since it was last saved to its current storage.</summary>
/// <returns>This method returns S_OK to indicate that the object has changed. Otherwise, it returns S_FALSE.</returns>
/// <remarks>
/// <para>Use this method to determine whether an object should be saved before closing it. The dirty flag for an object is conditionally cleared in the <a href="https://docs.microsoft.com/windows/desktop/api/objidl/nf-objidl-ipersiststorage-save">IPersistStorage::Save</a> method. For example, you could optimize a <b>File Save</b> operation by calling the <b>IPersistStorage::IsDirty</b> method for each object and then calling the <a href="https://docs.microsoft.com/windows/desktop/api/objidl/nf-objidl-ipersiststorage-save">IPersistStorage::Save</a> method only for those objects that are dirty. <h3><a id="Notes_to_Callers"></a><a id="notes_to_callers"></a><a id="NOTES_TO_CALLERS"></a>Notes to Callers</h3> You should treat any error return codes as an indication that the object has changed. Unless this method explicitly returns S_FALSE, assume that the object must be saved. <h3><a id="Notes_to_Implementers"></a><a id="notes_to_implementers"></a><a id="NOTES_TO_IMPLEMENTERS"></a>Notes to Implementers</h3> An object with no contained objects simply checks its dirty flag to return the appropriate result. A container with one or more contained objects must maintain an internal dirty flag that is set when any of its contained objects has changed since it was last saved.</para>
/// <para><see href="https://learn.microsoft.com/windows/win32/api/objidl/nf-objidl-ipersiststorage-isdirty#">Read more on docs.microsoft.com</see>.</para>
/// </remarks>
public winmdroot.Foundation.HRESULT IsDirty()
{
return ((delegate *unmanaged [Stdcall]<IPersistStorage*,winmdroot.Foundation.HRESULT>)lpVtbl[4])((IPersistStorage*)Unsafe.AsPointer(ref this));
}
[UnmanagedCallersOnly(CallConvs = new []{
typeof(CallConvStdcall)}
)]
private static winmdroot.Foundation.HRESULT InitNew(IPersistStorage* pThis, winmdroot.System.Com.StructuredStorage.IStorage* pStg)
{
try
{
winmdroot.Foundation.HRESULT __hr = ComHelpers.UnwrapCCW(pThis, out Interface __object);
if (__hr.Failed)
{
return __hr;
}
return __object.InitNew(pStg);
}
catch (Exception ex)
{
return (winmdroot.Foundation.HRESULT)ex.HResult;
}
}
/// <summary>Initializes a new storage object.</summary>
/// <param name="pStg">An <a href="https://docs.microsoft.com/windows/desktop/api/objidl/nn-objidl-istorage">IStorage</a> pointer to the new storage object to be initialized. The container creates a nested storage object in its storage object (see <a href="https://docs.microsoft.com/windows/desktop/api/objidl/nf-objidl-istorage-createstorage">IStorage::CreateStorage</a>). Then, the container calls the <a href="https://docs.microsoft.com/windows/desktop/api/coml2api/nf-coml2api-writeclassstg">WriteClassStg</a> function to initialize the new storage object with the object class identifier (CLSID).</param>
/// <returns>
/// <para>This method can return the following values. </para>
/// <para>This doc was truncated.</para>
/// </returns>
/// <remarks>
/// <para>A container application can call this method when it needs to initialize a new object, for example, with an InsertObject command. An object that supports the <a href="https://docs.microsoft.com/windows/desktop/api/objidl/nn-objidl-ipersiststorage">IPersistStorage</a> interface must have access to a valid storage object at all times while it is running. This includes the time just after the object has been created but before it has been made persistent. The object's container must provide the object with a valid <a href="https://docs.microsoft.com/windows/desktop/api/objidl/nn-objidl-istorage">IStorage</a> pointer to the storage during this time through the call to <b>IPersistStorage::InitNew</b>. Depending on the container's state, a temporary file might have to be created for this purpose. If the object wants to retain the <a href="https://docs.microsoft.com/windows/desktop/api/objidl/nn-objidl-istorage">IStorage</a> instance, it must call <a href="https://docs.microsoft.com/windows/desktop/api/unknwn/nf-unknwn-iunknown-addref">AddRef</a> to increment its reference count. After the call to <b>IPersistStorage::InitNew</b>, the object is in either the loaded or running state. For example, if the object class has an in-process server, the object will be in the running state. However, if the object uses the default handler, the container's call to <b>InitNew</b> only invokes the handler's implementation which does not run the object. Later if the container runs the object, the handler calls the <b>InitNew</b> method for the object. <h3><a id="Notes_to_Callers"></a><a id="notes_to_callers"></a><a id="NOTES_TO_CALLERS"></a>Notes to Callers</h3> Rather than calling <b>IPersistStorage::InitNew</b> directly, you typically call the <a href="https://docs.microsoft.com/windows/desktop/api/ole/nf-ole-olecreate">OleCreate</a> helper function which does the following: </para>
/// <para>This doc was truncated.</para>
/// <para><see href="https://learn.microsoft.com/windows/win32/api/objidl/nf-objidl-ipersiststorage-initnew#">Read more on docs.microsoft.com</see>.</para>
/// </remarks>
public unsafe winmdroot.Foundation.HRESULT InitNew(winmdroot.System.Com.StructuredStorage.IStorage* pStg)
{
return ((delegate *unmanaged [Stdcall]<IPersistStorage*,winmdroot.System.Com.StructuredStorage.IStorage* ,winmdroot.Foundation.HRESULT>)lpVtbl[5])((IPersistStorage*)Unsafe.AsPointer(ref this), pStg);
}
[UnmanagedCallersOnly(CallConvs = new []{
typeof(CallConvStdcall)}
)]
private static winmdroot.Foundation.HRESULT Load(IPersistStorage* pThis, winmdroot.System.Com.StructuredStorage.IStorage* pStg)
{
try
{
winmdroot.Foundation.HRESULT __hr = ComHelpers.UnwrapCCW(pThis, out Interface __object);
if (__hr.Failed)
{
return __hr;
}
return __object.Load(pStg);
}
catch (Exception ex)
{
return (winmdroot.Foundation.HRESULT)ex.HResult;
}
}
/// <summary>Loads an object from its existing storage.</summary>
/// <param name="pStg">An <a href="https://docs.microsoft.com/windows/desktop/api/objidl/nn-objidl-istorage">IStorage</a> pointer to the existing storage from which the object is to be loaded.</param>
/// <returns>
/// <para>This method can return the following values. </para>
/// <para>This doc was truncated.</para>
/// </returns>
/// <remarks>
/// <para>This method initializes an object from an existing storage. The object is placed in the loaded state if this method is called by the container application. If called by the default handler, this method places the object in the running state. Either the default handler or the object itself can hold onto the <a href="https://docs.microsoft.com/windows/desktop/api/objidl/nn-objidl-istorage">IStorage</a> pointer while the object is loaded or running. <h3><a id="Notes_to_Callers"></a><a id="notes_to_callers"></a><a id="NOTES_TO_CALLERS"></a>Notes to Callers</h3> Rather than calling <b>IPersistStorage::Load</b> directly, you typically call the <a href="https://docs.microsoft.com/windows/desktop/api/ole2/nf-ole2-oleload">OleLoad</a> helper function which does the following: </para>
/// <para>This doc was truncated.</para>
/// <para><see href="https://learn.microsoft.com/windows/win32/api/objidl/nf-objidl-ipersiststorage-load#">Read more on docs.microsoft.com</see>.</para>
/// </remarks>
public unsafe winmdroot.Foundation.HRESULT Load(winmdroot.System.Com.StructuredStorage.IStorage* pStg)
{
return ((delegate *unmanaged [Stdcall]<IPersistStorage*,winmdroot.System.Com.StructuredStorage.IStorage* ,winmdroot.Foundation.HRESULT>)lpVtbl[6])((IPersistStorage*)Unsafe.AsPointer(ref this), pStg);
}
[UnmanagedCallersOnly(CallConvs = new []{
typeof(CallConvStdcall)}
)]
private static winmdroot.Foundation.HRESULT Save(IPersistStorage* pThis, winmdroot.System.Com.StructuredStorage.IStorage* pStgSave, winmdroot.Foundation.BOOL fSameAsLoad)
{
try
{
winmdroot.Foundation.HRESULT __hr = ComHelpers.UnwrapCCW(pThis, out Interface __object);
if (__hr.Failed)
{
return __hr;
}
return __object.Save(pStgSave, fSameAsLoad);
}
catch (Exception ex)
{
return (winmdroot.Foundation.HRESULT)ex.HResult;
}
}
/// <summary>Saves an object, and any nested objects that it contains, into the specified storage object. The object enters NoScribble mode.</summary>
/// <param name="pStgSave">An <a href="https://docs.microsoft.com/windows/desktop/api/objidl/nn-objidl-istorage">IStorage</a> pointer to the storage into which the object is to be saved.</param>
/// <param name="fSameAsLoad">
/// <para>Indicates whether the specified storage is the current one, which was passed to the object by one of the following calls: <a href="https://docs.microsoft.com/windows/desktop/api/objidl/nf-objidl-ipersiststorage-initnew">IPersistStorage::InitNew</a>, <a href="https://docs.microsoft.com/windows/desktop/api/objidl/nf-objidl-ipersiststorage-load">IPersistStorage::Load</a>, or <a href="https://docs.microsoft.com/windows/desktop/api/objidl/nf-objidl-ipersiststorage-savecompleted">IPersistStorage::SaveCompleted</a>. This parameter is set to <b>FALSE</b> when performing a <b>Save As</b> or <b>Save A Copy To</b> operation or when performing a full save. In the latter case, this method saves to a temporary file, deletes the original file, and renames the temporary file. This parameter is set to <b>TRUE</b> to perform a full save in a low-memory situation or to perform a fast incremental save in which only the dirty components are saved.</para>
/// <para><see href="https://learn.microsoft.com/windows/win32/api/objidl/nf-objidl-ipersiststorage-save#parameters">Read more on docs.microsoft.com</see>.</para>
/// </param>
/// <returns>
/// <para>This method can return the following values. </para>
/// <para>This doc was truncated.</para>
/// </returns>
/// <remarks>
/// <para>This method saves an object, and any nested objects it contains, into the specified storage. It also places the object into NoScribble mode. Thus, the object cannot write to its storage until a subsequent call to the <a href="https://docs.microsoft.com/windows/desktop/api/objidl/nf-objidl-ipersiststorage-savecompleted">IPersistStorage::SaveCompleted</a> method returns the object to Normal mode. If the storage object is the same as the one it was loaded or created from, the save operation may be able to write incremental changes to the storage object. Otherwise, a full save must be done. This method recursively calls the <b>IPersistStorage::Save</b> method, the <a href="https://docs.microsoft.com/windows/desktop/api/ole2/nf-ole2-olesave">OleSave</a> function, or the <a href="https://docs.microsoft.com/windows/desktop/api/objidl/nf-objidl-istorage-copyto">IStorage::CopyTo</a> method to save its nested objects. This method does not call the <a href="https://docs.microsoft.com/windows/desktop/api/objidl/nf-objidl-istorage-commit">IStorage::Commit</a> method. Nor does it write the CLSID to the storage object. Both of these tasks are the responsibilities of the caller. <h3><a id="Notes_to_Callers"></a><a id="notes_to_callers"></a><a id="NOTES_TO_CALLERS"></a>Notes to Callers</h3> Rather than calling <b>IPersistStorage::Save</b> directly, you typically call the <a href="https://docs.microsoft.com/windows/desktop/api/ole2/nf-ole2-olesave">OleSave</a> helper function which performs the following steps: </para>
/// <para>This doc was truncated.</para>
/// <para><see href="https://learn.microsoft.com/windows/win32/api/objidl/nf-objidl-ipersiststorage-save#">Read more on docs.microsoft.com</see>.</para>
/// </remarks>
public unsafe winmdroot.Foundation.HRESULT Save(winmdroot.System.Com.StructuredStorage.IStorage* pStgSave, winmdroot.Foundation.BOOL fSameAsLoad)
{
return ((delegate *unmanaged [Stdcall]<IPersistStorage*,winmdroot.System.Com.StructuredStorage.IStorage* ,winmdroot.Foundation.BOOL ,winmdroot.Foundation.HRESULT>)lpVtbl[7])((IPersistStorage*)Unsafe.AsPointer(ref this), pStgSave, fSameAsLoad);
}
[UnmanagedCallersOnly(CallConvs = new []{
typeof(CallConvStdcall)}
)]
private static winmdroot.Foundation.HRESULT SaveCompleted(IPersistStorage* pThis, winmdroot.System.Com.StructuredStorage.IStorage* pStgNew)
{
try
{
winmdroot.Foundation.HRESULT __hr = ComHelpers.UnwrapCCW(pThis, out Interface __object);
if (__hr.Failed)
{
return __hr;
}
return __object.SaveCompleted(pStgNew);
}
catch (Exception ex)
{
return (winmdroot.Foundation.HRESULT)ex.HResult;
}
}
/// <summary>Notifies the object that it can write to its storage object.</summary>
/// <param name="pStgNew">An <a href="https://docs.microsoft.com/windows/desktop/api/objidl/nn-objidl-istorage">IStorage</a> pointer to the new storage object, if different from the storage object prior to saving. This pointer can be <b>NULL</b> if the current storage object does not change during the save operation. If the object is in HandsOff mode, this parameter must be non-<b>NULL</b>.</param>
/// <returns>
/// <para>This method can return the following values. </para>
/// <para>This doc was truncated.</para>
/// </returns>
/// <remarks>
/// <para>This method notifies an object that it can revert to Normal mode and can once again write to its storage object. The object exits NoScribble mode or HandsOff mode. If the object is reverting from HandsOff mode, the pStgNew parameter must be non-<b>NULL</b>. In HandsOffFromNormal mode, this parameter is the new storage object that replaces the one that was revoked by the <a href="https://docs.microsoft.com/windows/desktop/api/objidl/nf-objidl-ipersiststorage-handsoffstorage">IPersistStorage::HandsOffStorage</a> method. The data in the storage object is a copy of the data from the revoked storage object. In HandsOffAfterSave mode, the data is the same as the data that was most recently saved. It is not the same as the data in the revoked storage object. If the object is reverting from NoScribble mode, the <i>pStgNew</i> parameter can be <b>NULL</b> or non-<b>NULL</b>. If <b>NULL</b>, the object once again has access to its storage object. If it is not <b>NULL</b>, the component object should simulate receiving a call to its <a href="https://docs.microsoft.com/windows/desktop/api/objidl/nf-objidl-ipersiststorage-handsoffstorage">HandsOffStorage</a> method. If the component object cannot simulate this call, its container must be prepared to actually call the <b>HandsOffStorage</b> method. This method must recursively call any nested objects that are loaded or running. If this method returns an error code, the object is not returned to Normal mode. Thus, the container object can attempt different save strategies.</para>
/// <para><see href="https://learn.microsoft.com/windows/win32/api/objidl/nf-objidl-ipersiststorage-savecompleted#">Read more on docs.microsoft.com</see>.</para>
/// </remarks>
public unsafe winmdroot.Foundation.HRESULT SaveCompleted(winmdroot.System.Com.StructuredStorage.IStorage* pStgNew)
{
return ((delegate *unmanaged [Stdcall]<IPersistStorage*,winmdroot.System.Com.StructuredStorage.IStorage* ,winmdroot.Foundation.HRESULT>)lpVtbl[8])((IPersistStorage*)Unsafe.AsPointer(ref this), pStgNew);
}
[UnmanagedCallersOnly(CallConvs = new []{
typeof(CallConvStdcall)}
)]
private static winmdroot.Foundation.HRESULT HandsOffStorage(IPersistStorage* pThis)
{
try
{
winmdroot.Foundation.HRESULT __hr = ComHelpers.UnwrapCCW(pThis, out Interface __object);
if (__hr.Failed)
{
return __hr;
}
return __object.HandsOffStorage();
}
catch (Exception ex)
{
return (winmdroot.Foundation.HRESULT)ex.HResult;
}
}
/// <summary>Instructs the object to release all storage objects that have been passed to it by its container and to enter HandsOff mode.</summary>
/// <returns>This method returns S_OK to indicate that the object has entered HandsOff mode successfully.</returns>
/// <remarks>
/// <para>This method causes an object to release any storage objects that it is holding and to enter the HandsOff mode until a subsequent <a href="https://docs.microsoft.com/windows/desktop/api/objidl/nf-objidl-ipersiststorage-savecompleted">IPersistStorage::SaveCompleted</a> call. In HandsOff mode, the object cannot do anything and the only operation that works is a close operation. A container application typically calls this method during a full save or low-memory full save operation to force the object to release all pointers to its current storage. In these scenarios, the <b>HandsOffStorage</b> call comes after a call to either <a href="https://docs.microsoft.com/windows/desktop/api/ole2/nf-ole2-olesave">OleSave</a> or <a href="https://docs.microsoft.com/windows/desktop/api/objidl/nf-objidl-ipersiststorage-save">IPersistStorage::Save</a>, putting the object in HandsOffAfterSave mode. Calling this method is necessary so the container application can delete the current file as part of a full save, or so it can call the <a href="https://docs.microsoft.com/windows/desktop/api/objidl/nf-objidl-irootstorage-switchtofile">IRootStorage::SwitchToFile</a> method as part of a low-memory save. A container application also calls this method when an object is in Normal mode to put the object in HandsOffFromNormal mode. While the component object is in either HandsOffAfterSave or HandsOffFromNormal mode, most operations on the object will fail. Thus, the container should restore the object to Normal mode as soon as possible. The container application does this by calling the <a href="https://docs.microsoft.com/windows/desktop/api/objidl/nf-objidl-ipersiststorage-savecompleted">IPersistStorage::SaveCompleted</a> method, which passes a storage pointer back to the component object for the new storage object. <h3><a id="Notes_to_Implementers"></a><a id="notes_to_implementers"></a><a id="NOTES_TO_IMPLEMENTERS"></a>Notes to Implementers</h3> This method must release all pointers to the current storage object, including pointers to any nested streams and storages. If the object contains nested objects, the container application must recursively call this method for any nested objects that are loaded or running.</para>
/// <para><see href="https://learn.microsoft.com/windows/win32/api/objidl/nf-objidl-ipersiststorage-handsoffstorage#">Read more on docs.microsoft.com</see>.</para>
/// </remarks>
public winmdroot.Foundation.HRESULT HandsOffStorage()
{
return ((delegate *unmanaged [Stdcall]<IPersistStorage*,winmdroot.Foundation.HRESULT>)lpVtbl[9])((IPersistStorage*)Unsafe.AsPointer(ref this));
}
internal unsafe global::Windows.Win32.Foundation.HRESULT QueryInterface<T>(out T* ppv)
where T : unmanaged
{
var hr = this.QueryInterface(typeof(T).GUID, out void* pv);
if (hr.Succeeded)
{
ppv = (T*)pv;
}
else
{
ppv = null;
}
return hr;
}
internal struct Vtbl
{
internal delegate *unmanaged [Stdcall]<IPersistStorage*,global::System.Guid* ,void** ,winmdroot.Foundation.HRESULT> QueryInterface_1;
internal delegate *unmanaged [Stdcall]<IPersistStorage*,uint> AddRef_2;
internal delegate *unmanaged [Stdcall]<IPersistStorage*,uint> Release_3;
internal delegate *unmanaged [Stdcall]<IPersistStorage*,global::System.Guid* ,winmdroot.Foundation.HRESULT> GetClassID_4;
internal delegate *unmanaged [Stdcall]<IPersistStorage*,winmdroot.Foundation.HRESULT> IsDirty_5;
internal delegate *unmanaged [Stdcall]<IPersistStorage*,winmdroot.System.Com.StructuredStorage.IStorage* ,winmdroot.Foundation.HRESULT> InitNew_6;
internal delegate *unmanaged [Stdcall]<IPersistStorage*,winmdroot.System.Com.StructuredStorage.IStorage* ,winmdroot.Foundation.HRESULT> Load_7;
internal delegate *unmanaged [Stdcall]<IPersistStorage*,winmdroot.System.Com.StructuredStorage.IStorage* ,winmdroot.Foundation.BOOL ,winmdroot.Foundation.HRESULT> Save_8;
internal delegate *unmanaged [Stdcall]<IPersistStorage*,winmdroot.System.Com.StructuredStorage.IStorage* ,winmdroot.Foundation.HRESULT> SaveCompleted_9;
internal delegate *unmanaged [Stdcall]<IPersistStorage*,winmdroot.Foundation.HRESULT> HandsOffStorage_10;
}
public static void PopulateVTable(Vtbl* vtable)
{
vtable->GetClassID_4 = &GetClassID;
vtable->IsDirty_5 = &IsDirty;
vtable->InitNew_6 = &InitNew;
vtable->Load_7 = &Load;
vtable->Save_8 = &Save;
vtable->SaveCompleted_9 = &SaveCompleted;
vtable->HandsOffStorage_10 = &HandsOffStorage;
}
private void** lpVtbl;
/// <summary>The IID guid for this interface.</summary>
/// <value>{0000010a-0000-0000-c000-000000000046}</value>
internal static readonly Guid IID_Guid = new Guid(0x0000010A, 0x0000, 0x0000, 0xC0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46);
static ref readonly Guid IComIID.Guid {
[MethodImpl(MethodImplOptions.AggressiveInlining)]
get
{
ReadOnlySpan<byte> data = new byte[] {
0x0A,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0xC0,0x00,0x00,0x00,0x00,0x00,0x00,0x46 };
return ref Unsafe.As<byte,Guid>(ref MemoryMarshal.GetReference(data));
}
}
[Guid("0000010A-0000-0000-C000-000000000046"),InterfaceType(ComInterfaceType.InterfaceIsIUnknown),ComImport()]
[SupportedOSPlatform("windows5.0")]
internal interface Interface
:winmdroot.System.Com.IPersist.Interface {
[PreserveSig()]
unsafe new winmdroot.Foundation.HRESULT GetClassID(global::System.Guid* pClassID);
[PreserveSig()]
winmdroot.Foundation.HRESULT IsDirty();
[PreserveSig()]
unsafe winmdroot.Foundation.HRESULT InitNew(winmdroot.System.Com.StructuredStorage.IStorage* pStg);
[PreserveSig()]
unsafe winmdroot.Foundation.HRESULT Load(winmdroot.System.Com.StructuredStorage.IStorage* pStg);
[PreserveSig()]
unsafe winmdroot.Foundation.HRESULT Save(winmdroot.System.Com.StructuredStorage.IStorage* pStgSave, winmdroot.Foundation.BOOL fSameAsLoad);
[PreserveSig()]
unsafe winmdroot.Foundation.HRESULT SaveCompleted(winmdroot.System.Com.StructuredStorage.IStorage* pStgNew);
[PreserveSig()]
winmdroot.Foundation.HRESULT HandsOffStorage();
}
}
}
}
|